Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
i3d Namespace Reference

Namespaces

namespace  EllipseFitting
namespace  fls
namespace  Registration

Classes

struct  ChromAberParams
 Surface parameters for a chromatic aberration correction. More...
class  CCompTreeUnionFind
 Representation of the disjoint sets insired by: R. More...
struct  SCompTreeSortStdLibSorter
 structure used in the CompTreeSort function while sorting the indices according to the decreasing value of the voxel intensities (increasingly for the same voxel intensities) using the std library More...
struct  SCompTreeNodeListElem
 Representation of a single item in list of component tree nodes. More...
struct  SCompTreeNodeList
 Representation of a list of component tree nodes. More...
struct  SCompTreeNode
 Representation of a single component tree node. More...
class  CCompTreeNodeAttribHandler
 General empty handler of the additional attributes associated to the component tree node. More...
class  CCompTreeNodeAttribHandlerPHAV
 Handler of the additional attributes associated to the component tree node - parent, height, area, volume. More...
struct  SCompTree
 Representation of the component tree. More...
struct  couple
 A function this an auxiliary structure. More...
struct  voxelxy
struct  voxelxyz
class  StoreToImage
 Functor for storing voxels into the image. More...
class  StoreToMem
 Functor for storing voxels into the memory - without changing the image. More...
struct  JADRO
struct  Buffer
 A memory buffer (the main reason for defining this class is its destructor, which automatically deallocates the buffer memory when leaving function/block) : More...
struct  RGBD
struct  SumOf< RGB >
struct  SumOf< double >
struct  SumOf< float >
struct  SumOf< GRAY8 >
struct  SumOf< GRAY16 >
struct  SumOf< unsigned long >
struct  SumOf< _ULONGLONG >
struct  StrictSumOf< GRAY8 >
struct  StrictSumOf< GRAY16 >
struct  StrictSumOf< float >
struct  Filter
 General filter structure. More...
struct  Separable3dFilter
 Structure for representing separable filter of arbitrary sizes in each directions/axis. More...
struct  BorderPadding
 Structure containing data that is used for input image expansion. More...
struct  maxstruct
struct  HistInfo
 Histogram shape description. More...
class  HRCA_Histogram
 Histogram class. More...
class  HRCA_LUT
 class implements operations with LUT for unsigned numerical types (unsigned char and unsigned short) More...
struct  HomomorphicFilterParams
 Filter parameters for a homomorphic filtering method. More...
class  FMRoutines2D
class  FMRoutines3D
class  PDESolverFunction
 This class is together with class PDESolver the root abstract class for wide family of classes which implements segmentation methods and image preprocessing filters. More...
class  ExplicitSchemeFunction
 This class is together with class ExplicitSchemeFunction the abstract class for segmentation methods and image preproccessing filters, which compute the solution of underlying PDE on the whole domain (i.e. More...
class  MCFFilterFunction
 This class implements together with class MCFFilter the Curvature Flow anisotropic diffusion filter, which was published by Alvarez, Lions and Morel. More...
class  GradientMagnitudeEstimator
 This class implements simple Estimator of the gradient magnitude. More...
class  SpatialDerivatives
 This class implements spatial derivatives operator neede for optical flow comp. More...
class  PMFilterFunction
 This class implements together with class PMFilter the Perona-Malik anisotropic diffusion filter, which was published by Perona and Malik. More...
class  MCDEFilterFunction
 This class implements together with class MCDEFilter the Modified Curvature Diffusion Flow anisotropic diffusion filter, which was published by Whitaker and Xue. More...
class  PDESolver
 This class is together with class PDESolverFunction the root abstract class for wide family of classes which implements segmentation methods and image preprocessing filters. More...
class  ExplicitScheme
 This class is together with class ExplicitSchemeFunction the abstract class for segmentation methods and image preproccessing filters, which compute the solution of underlying PDE on the whole domain (i.e. More...
class  ImplicitAOSScheme
 This class is root abstract class for wide family of nonlinear diffusion filters. More...
class  AOSCLMCFilter
 This class implements the nonlinear diffusion filter, which was published by Catte, Lions, Morel and Coll. More...
class  AOSTVFilter
 This class implements the Total Variations nonlinear diffusion filter and the Ballanced Forward Backward filter, which were published by Andreu et al. More...
class  AOSPMFilter
 This class implements the Perona-Malik anisotropic diffusion filter, which was published by Perona and Malik. More...
class  ImplicitLODScheme
 This class is root abstract class for filters, which can be computed by simple LOD numerical scheme. More...
class  LODGaussianBlur
 This class implements the classical Gaussian Blur filter by solving the following PDE $ u_t = \Delta u = (u_{xx} + u_{yy}) $. More...
class  MCFFilter
 This class implements together with class MCFFilterFunction the Curvature Flow anisotropic diffusion filter, which was published by Alvarez, Lions and Morel. More...
class  PMFilter
 This class implements together with class PMFilterFunction the Perona-Malik anisotropic diffusion filter, which was published by Perona and Malik. More...
class  MCDEFilter
 This class implements together with class MCDEFilterFunction the Modified Curvature Diffusion Flow anisotropic diffusion filter, which was published by Whitaker and Xue. More...
class  KMeansLS
 This class implements simple the Kmeans segmentation algorithm for two means. More...
class  ThresholdActiveContours
 This class implements the threshold dynamics approximation of the Chan-Vese functional. More...
class  LUT
 class implements operations with LUT for voxel types More...
struct  minimum
struct  maximum
class  less_than
class  greater_than
struct  Neighbourhood
 The main structure representing the neighbourhood of an image voxel. More...
class  NeighbourhoodWalkerU
 Class that border-unsafely walks the neighbourhood. More...
class  NeighbourhoodWalker
 Class that border-safely walks the neighbourhood. More...
class  PDE_ExplicitSolver
class  PDE_Dilation
 Compute grayscale dilation with spherical structural element using PDE The main advantage is that the sphere radius can be set with "subpixel" accuracy. More...
class  PDE_Erosion
 Compute grayscale erosion with spherical structural element using PDE The main advantage is that the sphere radius can be set with "subpixel" accuracy. More...
class  Point3d
class  PointSet
struct  MovingHistCell
 A moving histogram cell. More...
class  MovingHist
 A basic moving histogram class. More...
class  MovingHist2D
 2D moving histogram class. More...
class  MovingHist3D
 3D moving histogram class. More...
class  MovingHist1D
 1D moving histogram class. More...
class  FieldIter
 this class iterates through all the points in one plane given by normal to this plane More...
class  ComponentInfo
struct  volume_less
struct  component_volume_less
struct  component_volume_greater
struct  density_less
struct  component_touch_border
struct  true1
class  LabeledImage3d
 class LabeledImage3d implements a labeled image More...
class  ComponentToRemove
 Class ComponentToRemove represents the predicate for RemoveComponents function. More...
struct  components_distance_matrix
 Added by Vladimir Ulman (xulman@fi.muni.cz), 14.11.2004. More...
struct  SNR_Params
struct  ProbabilityRecord
class  HistFinder
 HistFinder is class which provides a member function with prototype: T find(const Image3d<T> &img, const VOI<PIXELS> &voi) More...
class  MaxPlusKDeltaFinder
class  UnimodalThresholdFinder
class  OtsuThresholdFinder
class  is_background
class  CBeucherQueue
 Priority queue used in the Beucher's watershed algorithm. More...
class  CWSCDBasinManager
 handles all the operations necessary for the watershed contour dynamics computation (is able to create the flooding list and to derive contour dynamics from it) More...
class  CWSMeyerQueue
 Priority queue used in the Meyer's watershed algorithm. More...
class  CCompTreeNodeAttribHandlerTW
 Handler of the additional attributes associated to the component tree node used for the topological watershed computation - depth, first occurance. More...
struct  SCompTreeNodeCompareFunctor
 compares two component tree nodes - the one with the lower altitude is the smaller one, in the case of same altitudes, the on without the children is lower (when both the altitude and the fact of having a childre is the same, pointer decides) More...
struct  SCompTreeTW
 Representation of the component tree used for the topological watershed computation. More...
class  CTWQueue
 Priority queue class which preserves the order of the elements on the same level (don't know whether priority queue or multimap does this) More...

Typedefs

typedef int edge [5]
typedef std::valarray
< unsigned long > 
Histogram
typedef std::vector
< i3d::Vector3d< size_t > > 
SeedPointsVector
typedef std::vector< Vector3d
< int > > 
VectContainer
typedef std::vector< Vector3d
< size_t > > 
Boundary

Enumerations

enum  InitClusterMethod {
  ClusterRandom, ClusterEqualMass, ClusterAlternating, ClusterMask,
  ClusterMultilevelOtsu
}
enum  BoundaryConditionType { BoundaryDirichlet, BoundaryNeumann }
enum  Direction { AXIS_X = 0, AXIS_Y = 1, AXIS_Z = 2 }
enum  McEstimateType { MC_ESTIMATE_SURFACE, MC_ESTIMATE_VOLUME }
enum  SamplingMode { NEAREST_NEIGHBOUR, LINEAR, LANCZOS }

Functions

void BinFillHoles (Image3d< bool > &img, const Neighbourhood &nb=nb3D_6)
void EraseProtrusionVoxels (Image3d< bool > &img, const Image3d< bool > &img_boundary)
bool EraseUnambiguousVoxels (Image3d< bool > &img, const Image3d< bool > &img_boundary)
void FindBoundaryVoxels (const Image3d< bool > &img, Image3d< bool > &img_boundary)
void BinUnambiguous (Image3d< bool > &img)
void BinPartialConvex (Image3d< bool > &img, size_t Range)
template<class T >
void CorrectChromaticAberration (const i3d::Image3d< T > &input,i3d::Image3d< T > &output,const i3d::ChromAberParams &params,bool cut)
template I3D_ALGO_EXPORT void CorrectChromaticAberration (const i3d::Image3d< i3d::GRAY8 > &input, i3d::Image3d< i3d::GRAY8 > &output, const ChromAberParams &params, bool cut)
template I3D_ALGO_EXPORT void CorrectChromaticAberration (const i3d::Image3d< i3d::GRAY16 > &input, i3d::Image3d< i3d::GRAY16 > &output, const ChromAberParams &params, bool cut)
template I3D_ALGO_EXPORT void CorrectChromaticAberration (const i3d::Image3d< float > &input, i3d::Image3d< float > &output, const ChromAberParams &params, bool cut)
template<class T >
void CorrectChromaticAberration (const i3d::Image3d< i3d::RGB_generic< T > > &input,i3d::Image3d< i3d::RGB_generic< T > > &output,const i3d::ChromAberParams &red_params,const i3d::ChromAberParams &green_params,const i3d::ChromAberParams &blue_params,bool cut)
template I3D_ALGO_EXPORT void CorrectChromaticAberration (const i3d::Image3d< i3d::RGB_generic< i3d::GRAY8 > > &input, i3d::Image3d< i3d::RGB_generic< i3d::GRAY8 > > &output, const ChromAberParams &red_params, const ChromAberParams &green_params, const ChromAberParams &blue_params, bool cut)
template I3D_ALGO_EXPORT void CorrectChromaticAberration (const i3d::Image3d< i3d::RGB_generic< i3d::GRAY16 > > &input, i3d::Image3d< i3d::RGB_generic< i3d::GRAY16 > > &output, const ChromAberParams &red_params, const ChromAberParams &green_params, const ChromAberParams &blue_params, bool cut)
void GetCuttingPosition (const i3d::Offset &img_offset,const i3d::Resolution &img_resolution,const i3d::Vector3d< size_t > &img_size,const i3d::ChromAberParams &params,i3d::Vector3d< size_t > &minimum,i3d::Vector3d< size_t > &maximum)
void GetCuttingPosition (const i3d::Offset &img_offset,const i3d::Resolution &img_resolution,const i3d::Vector3d< size_t > &img_size,const i3d::ChromAberParams &red_params,const i3d::ChromAberParams &green_params,const i3d::ChromAberParams &blue_params,i3d::Vector3d< size_t > &minimum,i3d::Vector3d< size_t > &maximum)
template<class VOXEL >
void ComputeMeans (const i3d::Image3d< VOXEL > &imgin, const i3d::Image3d< i3d::GRAY8 > &imgout, std::vector< float > &means)
template<class VOXEL >
void CreateEqualMassClusters (const Image3d< VOXEL > &img, Image3d< GRAY8 > &imgout, GRAY8 k)
template<>
void CreateEqualMassClusters (const Image3d< float > &img, Image3d< GRAY8 > &imgout, GRAY8 k)
template<class VOXEL >
void CreateOtsuClusters (const Image3d< VOXEL > &img, Image3d< GRAY8 > &imgout, GRAY8 k)
template<>
void CreateOtsuClusters (const Image3d< float > &img, Image3d< GRAY8 > &imgout, GRAY8 k)
template<class VOXEL >
bool kMeans (const Image3d< VOXEL > &img, Image3d< GRAY8 > &imgout, GRAY8 k, InitClusterMethod method, int max_iters=50, std::vector< float > *means=NULL)
template I3D_ALGO_EXPORT bool kMeans (const Image3d< GRAY8 > &img, Image3d< GRAY8 > &imgout, GRAY8 k, InitClusterMethod method, int max_iters, std::vector< float > *means)
template I3D_ALGO_EXPORT bool kMeans (const Image3d< GRAY16 > &img, Image3d< GRAY8 > &imgout, GRAY8 k, InitClusterMethod method, int max_iters, std::vector< float > *means)
template I3D_ALGO_EXPORT bool kMeans (const Image3d< float > &img, Image3d< GRAY8 > &imgout, GRAY8 k, InitClusterMethod method, int max_iters, std::vector< float > *means)
template<class VOXEL >
void Manders (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, Image3d< GRAY16 > &o1, unsigned int threshold)
template<class VOXEL >
void Pearson (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, Image3d< GRAY16 > &o1)
template<class VOXEL >
void Overlap (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, Image3d< GRAY16 > &o1)
template<class VOXEL >
double PearsonC (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label)
template<class VOXEL >
double MandersC (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label, unsigned int threshold)
template<class VOXEL >
double OverlapC (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label)
template<class VOXEL >
double PearsonC (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2)
template<class VOXEL >
double MandersC (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, unsigned int threshold)
template<class VOXEL >
double OverlapC (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2)
template<class VOXEL >
std::map< GRAY16, double > PearsonM (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, const LabeledImage3d< GRAY16, bool > &mask)
template<class VOXEL >
std::map< GRAY16, double > MandersM (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, const LabeledImage3d< GRAY16, bool > &mask, unsigned int threshold)
template<class VOXEL >
std::map< GRAY16, double > OverlapM (const Image3d< VOXEL > &i1, const Image3d< VOXEL > &i2, const LabeledImage3d< GRAY16, bool > &mask)
template I3D_ALGO_EXPORT void Manders (const Image3d< GRAY8 > &, const Image3d< GRAY8 > &, Image3d< GRAY16 > &, unsigned int)
template I3D_ALGO_EXPORT void Manders (const Image3d< GRAY16 > &, const Image3d< GRAY16 > &, Image3d< GRAY16 > &, unsigned int)
template I3D_ALGO_EXPORT void Pearson (const Image3d< GRAY8 > &, const Image3d< GRAY8 > &, Image3d< GRAY16 > &)
template I3D_ALGO_EXPORT void Pearson (const Image3d< GRAY16 > &, const Image3d< GRAY16 > &, Image3d< GRAY16 > &)
template I3D_ALGO_EXPORT void Overlap (const Image3d< GRAY8 > &, const Image3d< GRAY8 > &, Image3d< GRAY16 > &)
template I3D_ALGO_EXPORT void Overlap (const Image3d< GRAY16 > &, const Image3d< GRAY16 > &, Image3d< GRAY16 > &)
template I3D_ALGO_EXPORT
std::map< GRAY16, double > 
PearsonM (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, const LabeledImage3d< GRAY16, bool > &mask)
template I3D_ALGO_EXPORT
std::map< GRAY16, double > 
MandersM (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, const LabeledImage3d< GRAY16, bool > &mask, unsigned int threshold)
template I3D_ALGO_EXPORT
std::map< GRAY16, double > 
OverlapM (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, const LabeledImage3d< GRAY16, bool > &mask)
template I3D_ALGO_EXPORT
std::map< GRAY16, double > 
PearsonM (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, const LabeledImage3d< GRAY16, bool > &mask)
template I3D_ALGO_EXPORT
std::map< GRAY16, double > 
MandersM (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, const LabeledImage3d< GRAY16, bool > &mask, unsigned int threshold)
template I3D_ALGO_EXPORT
std::map< GRAY16, double > 
OverlapM (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, const LabeledImage3d< GRAY16, bool > &mask)
template I3D_ALGO_EXPORT double OverlapC (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label)
template I3D_ALGO_EXPORT double MandersC (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label, unsigned int threshold)
template I3D_ALGO_EXPORT double PearsonC (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label)
template I3D_ALGO_EXPORT double OverlapC (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2)
template I3D_ALGO_EXPORT double MandersC (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2, unsigned int threshold)
template I3D_ALGO_EXPORT double PearsonC (const Image3d< GRAY8 > &i1, const Image3d< GRAY8 > &i2)
template I3D_ALGO_EXPORT double OverlapC (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label)
template I3D_ALGO_EXPORT double MandersC (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label, unsigned int threshold)
template I3D_ALGO_EXPORT double PearsonC (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, const LabeledImage3d< GRAY16, bool > &mask, int label)
template I3D_ALGO_EXPORT double OverlapC (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2)
template I3D_ALGO_EXPORT double MandersC (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2, unsigned int threshold)
template I3D_ALGO_EXPORT double PearsonC (const Image3d< GRAY16 > &i1, const Image3d< GRAY16 > &i2)
template<typename T >
I3D_ALGO_EXPORT void PrintSCompTreeNode (std::ostream &ost, const SCompTreeNode< T > *compTreeNode, CCompTreeNodeAttribHandler< T > *atribHandler, size_t level)
template<typename T >
I3D_ALGO_EXPORT std::ostream & operator<< (std::ostream &ost, const SCompTree< T > &compTree)
template<typename T >
I3D_ALGO_EXPORT std::ostream & operator<< (std::ostream &ost, const SCompTree< T > *compTree)
template I3D_ALGO_EXPORT
std::ostream & 
operator<< (std::ostream &ost, const SCompTree< i3d::GRAY8 > &compTreeNode)
template I3D_ALGO_EXPORT
std::ostream & 
operator<< (std::ostream &ost, const SCompTree< i3d::GRAY16 > &compTreeNode)
template I3D_ALGO_EXPORT
std::ostream & 
operator<< (std::ostream &ost, const SCompTree< i3d::GRAY8 > *compTreeNode)
template I3D_ALGO_EXPORT
std::ostream & 
operator<< (std::ostream &ost, const SCompTree< i3d::GRAY16 > *compTreeNode)
template<typename T >
static size_t * CompTreeSort (const Image3d< T > &input)
template<typename T >
I3D_ALGO_EXPORT void BuildComponentTree (const Image3d< T > &input, SCompTree< T > &componentTree, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void BuildComponentTree (const Image3d< i3d::GRAY8 > &input, SCompTree< i3d::GRAY8 > &componentTree, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void BuildComponentTree (const Image3d< i3d::GRAY16 > &input, SCompTree< i3d::GRAY16 > &componentTree, const Neighbourhood &neighbourhood)
template<typename T >
I3D_ALGO_EXPORT void BuildComponentTree (const Image3d< T > &input, SCompTree< T > &componentTree, NeighbourhoodWalker &nbhWalker)
template I3D_ALGO_EXPORT void BuildComponentTree (const Image3d< i3d::GRAY8 > &input, SCompTree< i3d::GRAY8 > &componentTree, NeighbourhoodWalker &nbhWalker)
template I3D_ALGO_EXPORT void BuildComponentTree (const Image3d< i3d::GRAY16 > &input, SCompTree< i3d::GRAY16 > &componentTree, NeighbourhoodWalker &nbhWalker)
template<class VOXEL >
void ApplyMarchingSquaresOnOneSlice (i3d::Image3d< VOXEL > &ImgIn, VOXEL value, std::vector< Point3d< float > > &points, size_t start, size_t *cellSize, size_t *incr, size_t *dir)
template<class VOXEL >
void MarchingSquaresOneSlice (i3d::Image3d< VOXEL > &ImgIn, VOXEL Value, Direction Axis, std::vector< Point3d< float > > &Lines, size_t SliceNumber)
template<class VOXELIN , class VOXELOUT >
void MarchingSquares (i3d::Image3d< VOXELIN > &ImgIn, i3d::Image3d< VOXELOUT > &ImgOut, VOXELIN Value, Direction Axis=AXIS_Z, VOXELOUT Colour=std::numeric_limits< VOXELOUT >::max())
template I3D_ALGO_EXPORT void MarchingSquares (i3d::Image3d< float > &ImgIn, i3d::Image3d< GRAY8 > &ImgOut, float Value, Direction Axis, GRAY8 Colour)
void generate_descending_sequence (const Vector3d< size_t > &dim, std::queue< Vector3d< size_t >> &seq)
bool is_factorable (size_t number)
template<class T_in , class T_out , class PRECISION >
double estimate_needed_space (const Vector3d< size_t > &F_voi_sz, const Vector3d< size_t > &G_voi_sz)
template<class T_in , class T_out , class PRECISION >
bool find_optimal_tile_size (const Vector3d< size_t > &img_dim, const Vector3d< size_t > &ker_dim, Vector3d< size_t > &tile_dim)
template<class T_in , class T_out , class PRECISION >
void convolution_via_fft (const Image3d< T_in > &F, const Image3d< T_in > &G, Image3d< T_out > &H, PRECISION factor)
template<class T_in , class T_out , class PRECISION >
void convolution_in_voi (const Image3d< T_in > &F, const Image3d< T_in > &G, Image3d< T_out > &H, const VOI< PIXELS > &F_voi, const VOI< PIXELS > &G_voi, PRECISION factor, BoundaryConditionType boundary_condition)
void establish_location_of_tiles (const Vector3d< size_t > &image_dim, const Vector3d< size_t > &tile_dim, std::vector< VOI< PIXELS >> &list_of_VOIs)
template<class T >
void validate_images (const Image3d< T > &img_in, const Image3d< T > &kernel)
template<class PRECISION , class T_in , class T_out >
void Convolution (const Image3d< T_in > &img_in, const Image3d< T_in > &kernel, Image3d< T_out > &img_out, bool normalize_kernel=true, BoundaryConditionType boundary_condition=BoundaryDirichlet)
template I3D_ALGO_EXPORT void Convolution< float, bool, float > (const Image3d< bool > &, const Image3d< bool > &, Image3d< float > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< double, bool, float > (const Image3d< bool > &, const Image3d< bool > &, Image3d< float > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< float, GRAY8, GRAY8 > (const Image3d< GRAY8 > &, const Image3d< GRAY8 > &, Image3d< GRAY8 > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< float, GRAY16, GRAY16 > (const Image3d< GRAY16 > &, const Image3d< GRAY16 > &, Image3d< GRAY16 > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< float, float, float > (const Image3d< float > &, const Image3d< float > &, Image3d< float > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< double, GRAY8, GRAY8 > (const Image3d< GRAY8 > &, const Image3d< GRAY8 > &, Image3d< GRAY8 > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< double, GRAY16, GRAY16 > (const Image3d< GRAY16 > &, const Image3d< GRAY16 > &, Image3d< GRAY16 > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< double, float, float > (const Image3d< float > &, const Image3d< float > &, Image3d< float > &, bool, BoundaryConditionType)
template I3D_ALGO_EXPORT void Convolution< double, double, double > (const Image3d< double > &, const Image3d< double > &, Image3d< double > &, bool, BoundaryConditionType)
template<class T >
static void TridiagonalMatrixSolver (T *a, T *b, T *c, T *d, T *x, size_t n)
template<class VOXEL >
static void ForwardBackwardSubstitution (const VOXEL *M, const VOXEL *L, VOXEL *d, size_t n, VOXEL tau, size_t shift)
template<class VOXEL >
static void PrepareLRDecomposition (VOXEL *M, VOXEL *L, size_t n, VOXEL tau)
template<class T >
static void PrepareDiagonals (T *Diag, T *UDiag, T *LDiag, const T *data, size_t N, T tau, size_t shift)
template<class T >
static void CopyFrom (const T *src, T *dst, size_t num, size_t step)
template<class T >
static void Add (const T *src, T *dst, size_t num, size_t step)
template<class T >
static void AddAndAvg (const T *src, T *dst, size_t num, size_t step, T coef)
template<class T >
static void EigDecomposition (T a, T b, T c, double *eigval, double *eigvec)
template<class T >
static void EigDecomposition3D (T a, T b, T c, T d, T e, T f, double *eigval, double *eigvec)
template<class T >
static void StructureTensor (const Image3d< T > &in, Image3d< T > &Da, Image3d< T > &Db, Image3d< T > &Dc)
template<class T >
static void StructureTensor3D (const Image3d< T > &in, Image3d< T > &Da, Image3d< T > &Db, Image3d< T > &Dc, Image3d< T > &Dd, Image3d< T > &De, Image3d< T > &Df)
template<class T >
static void EEDTensor (Image3d< T > &Da, Image3d< T > &Db, Image3d< T > &Dc, T lambda)
template<class T >
static void EEDTensor3D (Image3d< T > &Da, Image3d< T > &Db, Image3d< T > &Dc, Image3d< T > &Dd, Image3d< T > &De, Image3d< T > &Df, T lambda)
template<class T >
static void CEDTensor (Image3d< T > &Da, Image3d< T > &Db, Image3d< T > &Dc)
template<class T >
static void CEDTensor3D (Image3d< T > &Da, Image3d< T > &Db, Image3d< T > &Dc, Image3d< T > &Dd, Image3d< T > &De, Image3d< T > &Df)
template<class T >
static void AnisoDiffStep_AOS (const Image3d< T > &in, const Image3d< T > &Da, const Image3d< T > &Db, const Image3d< T > &Dc, Image3d< T > &out, T tau)
template<class T >
static void AnisoDiffStep3D_AOS (const Image3d< T > &in, const Image3d< T > &Da, const Image3d< T > &Db, const Image3d< T > &Dc, const Image3d< T > &Dd, const Image3d< T > &De, const Image3d< T > &Df, Image3d< T > &out, T tau)
template<class VOXEL >
void Gauss_LOD (Image3d< VOXEL > &img, VOXEL sigma, size_t num_iter)
template I3D_ALGO_EXPORT void Gauss_LOD (Image3d< float > &img, float sigma, size_t num_iter)
template I3D_ALGO_EXPORT void Gauss_LOD (Image3d< double > &img, double sigma, size_t num_iter)
template<class VOXEL , class PRECISION >
void GrayGauss_LOD (Image3d< VOXEL > &img, PRECISION sigma, size_t num_iter)
template I3D_ALGO_EXPORT void GrayGauss_LOD (Image3d< GRAY8 > &img, float sigma, size_t num_iter)
template I3D_ALGO_EXPORT void GrayGauss_LOD (Image3d< GRAY16 > &img, float sigma, size_t num_iter)
template I3D_ALGO_EXPORT void GrayGauss_LOD (Image3d< GRAY8 > &img, double sigma, size_t num_iter)
template I3D_ALGO_EXPORT void GrayGauss_LOD (Image3d< GRAY16 > &img, double sigma, size_t num_iter)
template<class VOXEL >
void EED_AOS (Image3d< VOXEL > &img, VOXEL sigma, VOXEL lambda, VOXEL tau, size_t num_iter)
template I3D_ALGO_EXPORT void EED_AOS (Image3d< float > &img, float sigma, float lambda, float tau, size_t num_iter)
template I3D_ALGO_EXPORT void EED_AOS (Image3d< double > &img, double sigma, double lambda, double tau, size_t num_iter)
template<class VOXEL , class PRECISION >
void GrayEED_AOS (Image3d< VOXEL > &img, PRECISION sigma, PRECISION lambda, PRECISION tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayEED_AOS (Image3d< GRAY8 > &img, float sigma, float lambda, float tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayEED_AOS (Image3d< GRAY16 > &img, float sigma, float lambda, float tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayEED_AOS (Image3d< GRAY8 > &img, double sigma, double lambda, double tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayEED_AOS (Image3d< GRAY16 > &img, double sigma, double lambda, double tau, size_t num_iter)
template<class VOXEL >
void CED_AOS (Image3d< VOXEL > &img, VOXEL sigma, VOXEL rho, VOXEL tau, size_t num_iter)
template I3D_ALGO_EXPORT void CED_AOS (Image3d< float > &img, float sigma, float rho, float tau, size_t num_iter)
template I3D_ALGO_EXPORT void CED_AOS (Image3d< double > &img, double sigma, double rho, double tau, size_t num_iter)
template<class VOXEL , class PRECISION >
void GrayCED_AOS (Image3d< VOXEL > &img, PRECISION sigma, PRECISION rho, PRECISION tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayCED_AOS (Image3d< GRAY8 > &img, float sigma, float rho, float tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayCED_AOS (Image3d< GRAY16 > &img, float sigma, float rho, float tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayCED_AOS (Image3d< GRAY8 > &img, double sigma, double rho, double tau, size_t num_iter)
template I3D_ALGO_EXPORT void GrayCED_AOS (Image3d< GRAY16 > &img, double sigma, double rho, double tau, size_t num_iter)
template<typename T >
void scanCityBlock (int pocx, int konx, int pocy, int kony, int pocz, int konz, int xmax, int ymax, int zmax, T xp, T yp, T zp, std::valarray< T > &mapa)
template<typename T >
void scanChamfer (int pocx, int konx, int pocy, int kony, int pocz, int konz, int xmax, int ymax, int zmax, T xp, T yp, T zp, std::valarray< T > &mapa)
template<typename T >
void scan4N (int pocx, int konx, int pocy, int kony, size_t xm, size_t ym, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< voxelxy > &pole)
template<typename T >
void scan8N (int pocx, int konx, int pocy, int kony, size_t xm, size_t ym, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< voxelxy > &pole)
template<typename T >
void EDM2D (Image3d< T > &Obraz, byte kvalita, T Image_Background, bool odmocnina)
template<typename T >
void scan6N (int pocx, int konx, int pocy, int kony, int pocz, int konz, size_t xm, size_t ym, size_t zm, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< T > &mocninaz, std::valarray< voxelxyz > &pole)
template<typename T >
void scan26N (int pocx, int konx, int pocy, int kony, int pocz, int konz, size_t xm, size_t ym, size_t zm, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< T > &mocninaz, std::valarray< voxelxyz > &pole)
template<typename T >
void EDM3D (Image3d< T > &Obraz, byte kvalita, T Image_Background, bool odmocnina)
template<typename T >
void Saito4Sed (Image3d< T > &Obraz, T Image_Background, bool odmocnina)
template<typename T >
void Saito8Sed (Image3d< T > &Obraz, T Image_Background, bool odmocnina)
template<typename T >
void scanDED4N (int pocx, int konx, int pocy, int kony, size_t xmax, size_t ymax, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< voxelxy > &pole)
template<typename T >
void scanDED8N (int pocx, int konx, int pocy, int kony, size_t xmax, size_t ymax, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< voxelxy > &pole)
template<typename T >
void DeuclideanDistance2D (Image3d< T > &Obraz, byte kvalita, T Image_Background, bool odmocnina)
template<typename T >
void scanDED26N (int pocx, int konx, int pocy, int kony, int pocz, int konz, size_t xmax, size_t ymax, size_t zmax, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< T > &mocninaz, std::valarray< voxelxyz > &pole)
template<typename T >
void scanDED18N (int pocx, int konx, int pocy, int kony, int pocz, int konz, size_t xmax, size_t ymax, size_t zmax, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< T > &mocninaz, std::valarray< voxelxyz > &pole)
template<typename T >
void scanDED6N (int pocx, int konx, int pocy, int kony, int pocz, int konz, size_t xmax, size_t ymax, size_t zmax, std::valarray< T > &mocninax, std::valarray< T > &mocninay, std::valarray< T > &mocninaz, std::valarray< voxelxyz > &pole)
template<typename T >
void DeuclideanDistance3D (Image3d< T > &Obraz, byte kvalita, T Image_Background, bool odmocnina)
template<typename T >
I3D_ALGO_EXPORT void CityBlock (Image3d< T > &Obraz, T Image_background=0)
template I3D_ALGO_EXPORT void CityBlock (Image3d< float > &Obraz, float Image_background)
template<typename T >
I3D_ALGO_EXPORT void Chamfer (Image3d< T > &Obraz, T Image_background=0)
template I3D_ALGO_EXPORT void Chamfer (Image3d< float > &Obraz, float Image_background)
template<typename T >
I3D_ALGO_EXPORT void EDM (Image3d< T > &Obraz, byte kvalita=0, T Image_background=0, bool odmocnina=false)
template I3D_ALGO_EXPORT void EDM (Image3d< float > &Obraz, byte kvalita, float Image_background, bool odmocnina)
template<typename T >
I3D_ALGO_EXPORT void HybridSaito (Image3d< T > &Obraz, byte kvalita=0, T Image_background=0, bool odmocnina=false)
template I3D_ALGO_EXPORT void HybridSaito (Image3d< float > &Obraz, byte kvalita, float Image_background, bool odmocnina)
template<typename T >
I3D_ALGO_EXPORT void SlowSaito (Image3d< T > &Obraz, T Image_background=0, bool odmocnina=false)
template I3D_ALGO_EXPORT void SlowSaito (Image3d< float > &Obraz, float Image_background, bool odmocnina)
template<typename T >
I3D_ALGO_EXPORT void FastSaito (Image3d< T > &Obraz, T Image_background=0, bool odmocnina=false)
template I3D_ALGO_EXPORT void FastSaito (Image3d< float > &Obraz, float Image_background, bool odmocnina)
template<typename T >
void DeuclideanDistance (Image3d< T > &Obraz, byte kvalita=0, T Image_background=0, bool odmocnina=false)
template void DeuclideanDistance (Image3d< float > &Obraz, byte kvalita, float Image_background, bool odmocnina)
size_t PrepareLine (Vector3d< size_t > p1, Vector3d< size_t > p2, Vector3d< double > &d)
void ShiftPenAlongLine (Vector3d< double > &D, int &dx, int &dy, int &dz)
template<class T >
void RasterizeLineBres (const T &Dest, Vector3d< size_t > p1, Vector3d< size_t > p2)
template<class VOXEL1 , class VOXEL2 >
size_t FillRow (std::stack< size_t > &buf, const Image3d< VOXEL1 > &input, Image3d< VOXEL2 > &output, VOXEL2 NewColor, const Neighbourhood &neib)
template<class T >
void DrawLine (Image3d< T > &img, const Offset &p1, const Offset &p2, T color)
template<class T >
void DrawLine (Image3d< T > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, T color)
template I3D_ALGO_EXPORT void DrawLine (Image3d< bool > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, bool color)
template I3D_ALGO_EXPORT void DrawLine (Image3d< GRAY8 > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, GRAY8 color)
template I3D_ALGO_EXPORT void DrawLine (Image3d< GRAY16 > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, GRAY16 color)
template I3D_ALGO_EXPORT void DrawLine (Image3d< RGB > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, RGB color)
template I3D_ALGO_EXPORT void DrawLine (Image3d< RGB16 > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, RGB16 color)
template<class T >
void DrawLines (Image3d< T > &img, const std::vector< Offset > &pnts, T color)
template I3D_ALGO_EXPORT void DrawLines (Image3d< GRAY8 > &img, const std::vector< Offset > &pnts, GRAY8 color)
template I3D_ALGO_EXPORT void DrawLines (Image3d< GRAY16 > &img, const std::vector< Offset > &pnts, GRAY16 color)
template I3D_ALGO_EXPORT void DrawLines (Image3d< RGB > &img, const std::vector< Offset > &pnts, RGB color)
template I3D_ALGO_EXPORT void DrawLines (Image3d< RGB16 > &img, const std::vector< Offset > &pnts, RGB16 color)
template<class T >
void DrawLineBres (Image3d< T > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, T color)
void DrawLineBres (std::list< Vector3d< int > > &ll, Vector3d< size_t > p1, Vector3d< size_t > p2)
template I3D_ALGO_EXPORT void DrawLineBres (Image3d< bool > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, bool color)
template I3D_ALGO_EXPORT void DrawLineBres (Image3d< GRAY8 > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, GRAY8 color)
template I3D_ALGO_EXPORT void DrawLineBres (Image3d< GRAY16 > &img, Vector3d< size_t > p1, Vector3d< size_t > p2, GRAY16 color)
template<class T >
void DrawCube (Image3d< T > &img, const VOI< PIXELS > &voi, T color)
template I3D_ALGO_EXPORT void DrawCube (Image3d< bool > &img, const VOI< PIXELS > &voi, bool color)
template I3D_ALGO_EXPORT void DrawCube (Image3d< GRAY8 > &img, const VOI< PIXELS > &voi, GRAY8 color)
template<class VOXEL1 , class VOXEL2 >
ComponentInfo< VOXEL2, VOXEL1 > FloodFill (const Image3d< VOXEL1 > &in, Image3d< VOXEL2 > &out, VOXEL2 color, size_t x, size_t y, size_t z, const Neighbourhood &neib=nb3D_6)
template<class VOXEL1 , class VOXEL2 >
ComponentInfo< VOXEL2, VOXEL1 > FloodFill (const Image3d< VOXEL1 > &in, Image3d< VOXEL2 > &out, VOXEL2 color, size_t seed_index, const Neighbourhood &neib=nb3D_6)
template<class VOXEL >
void FloodFill (Image3d< VOXEL > &img, VOXEL color, size_t x, size_t y, size_t z, const Neighbourhood &neib=nb3D_6)
template<class VOXEL >
void FloodFill (Image3d< VOXEL > &img, VOXEL color, size_t seed_index, const Neighbourhood &neib=nb3D_6)
template I3D_ALGO_EXPORT
ComponentInfo< bool, bool > 
FloodFill (const Image3d< bool > &in, Image3d< bool > &out, bool color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< int, bool > 
FloodFill (const Image3d< bool > &in, Image3d< int > &out, int color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY8, bool > 
FloodFill (const Image3d< bool > &in, Image3d< GRAY8 > &out, GRAY8 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY8, GRAY16 > 
FloodFill (const Image3d< GRAY16 > &in, Image3d< byte > &out, GRAY8 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY8, GRAY8 > 
FloodFill (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, GRAY8 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY16, bool > 
FloodFill (const Image3d< bool > &in, Image3d< GRAY16 > &out, GRAY16 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY16, GRAY16 > 
FloodFill (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, GRAY16 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, bool > 
FloodFill (const Image3d< bool > &in, Image3d< size_t > &out, size_t color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, GRAY8 > 
FloodFill (const Image3d< GRAY8 > &in, Image3d< size_t > &out, size_t color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, GRAY16 > 
FloodFill (const Image3d< GRAY16 > &in, Image3d< size_t > &out, size_t color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, float > 
FloodFill (const Image3d< float > &in, Image3d< size_t > &out, size_t color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< bool, bool > 
FloodFill (const Image3d< bool > &in, Image3d< bool > &out, bool color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< int, bool > 
FloodFill (const Image3d< bool > &in, Image3d< int > &out, int color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY8, bool > 
FloodFill (const Image3d< bool > &in, Image3d< GRAY8 > &out, GRAY8 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY8, GRAY8 > 
FloodFill (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, GRAY8 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY8, GRAY16 > 
FloodFill (const Image3d< GRAY16 > &in, Image3d< byte > &out, GRAY8 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY16, bool > 
FloodFill (const Image3d< bool > &in, Image3d< GRAY16 > &out, GRAY16 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< GRAY16, GRAY16 > 
FloodFill (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, GRAY16 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, bool > 
FloodFill (const Image3d< bool > &in, Image3d< size_t > &out, size_t color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, GRAY8 > 
FloodFill (const Image3d< GRAY8 > &in, Image3d< size_t > &out, size_t color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, GRAY16 > 
FloodFill (const Image3d< GRAY16 > &in, Image3d< size_t > &out, size_t color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT
ComponentInfo< size_t, float > 
FloodFill (const Image3d< float > &in, Image3d< size_t > &out, size_t color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< bool > &img, bool color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< GRAY8 > &img, GRAY8 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< GRAY16 > &img, GRAY16 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< RGB > &img, RGB color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< RGB16 > &img, RGB16 color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< size_t > &img, size_t color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< float > &img, float color, size_t x, size_t y, size_t z, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< bool > &img, bool color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< GRAY8 > &img, GRAY8 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< GRAY16 > &img, GRAY16 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< RGB > &img, RGB color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< RGB16 > &img, RGB16 color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< size_t > &img, size_t color, size_t seed_index, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void FloodFill (Image3d< float > &img, float color, size_t seed_index, const Neighbourhood &neib)
template<class VOXEL >
void Negative (Image3d< VOXEL > &img)
template I3D_ALGO_EXPORT void Negative (Image3d< bool > &img)
template I3D_ALGO_EXPORT void Negative (Image3d< GRAY8 > &img)
template I3D_ALGO_EXPORT void Negative (Image3d< GRAY16 > &img)
template<class T >
static T Sqr (T val)
template<class T >
static T Abs (T x)
template<class T >
static T Max (T x, T y, T z)
template<class VOXEL >
static Vector3d< float > get_relative_resolution (const Image3d< VOXEL > &in)
template<class VOXEL >
static bool is_anisotropic (const Image3d< VOXEL > &in)
static void Make3DKernel (int vstup[3][3][3], JADRO &vystup)
template<class VOXEL >
static void Apply3DCompassFilter (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, JADRO filtr)
template<class VOXEL >
static float AGetVoxel (const Image3d< VOXEL > &in, float x, float y, float z)
template<class VOXEL >
void Robinson3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Robinson3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Robinson3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
void CompassSobel3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void CompassSobel3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void CompassSobel3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
void Prewitt3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Prewitt3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Prewitt3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
void Kirsch3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Kirsch3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Kirsch3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
static int optimal_length (int length)
static double ISEF1D (double x, double p)
template<class VOXEL , class REAL >
void ApplyFilter1D2 (Image3d< VOXEL > &in, Image3d< REAL > *out, Filter< double > &filtr, int osa)
static void ApplyFilter1D (Image3d< float > *in, Filter< double > &filtr, int osa)
static Filter< double > MakeISEF1DFilter (double p, double widthFactor)
template<class VOXEL >
static bool IsCandidateEdge3D (const Image3d< float > *smoothed, Image3d< VOXEL > &out, size_t x, size_t y, size_t z)
template<class VOXEL >
static void ComputeAdaptiveGradient3D (Image3d< float > *smoothed, const Image3d< VOXEL > &out, int halfsize, float &min, float &max)
template<class VOXEL >
void ApplyShenCastan3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double p, int WinHalfSize)
template<class VOXEL >
void ShenCastan3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double p, int WinHalfSize)
template<>
I3D_ALGO_EXPORT void ShenCastan3D (const Image3d< RGB > &in, Image3d< RGB > &out, double p, int WinHalfSize)
template<>
I3D_ALGO_EXPORT void ShenCastan3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, double p, int WinHalfSize)
template<class VOXEL >
static bool IsCandidateEdge2D (const Image3d< float > *smoothed, Image3d< VOXEL > &out, size_t x, size_t y, size_t z)
template<class VOXEL >
static void ComputeAdaptiveGradient2D (Image3d< float > *smoothed, const Image3d< VOXEL > &out, int halfsize, float &min, float &max)
template<class VOXEL >
static void ApplyShenCastan2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double p, int WinHalfSize)
template<class VOXEL >
void ShenCastan2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double p, int WinHalfSize)
template<>
I3D_ALGO_EXPORT void ShenCastan2D (const Image3d< RGB > &in, Image3d< RGB > &out, double p, int WinHalfSize)
template<>
I3D_ALGO_EXPORT void ShenCastan2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, double p, int WinHalfSize)
static double Gauss1D (double x, double sigma)
template<class VOXEL >
static bool ZeroCross3D (const Image3d< VOXEL > &in, size_t x, size_t y, size_t z)
static Filter< double > MakeGauss1DFilter (double sigma, double widthFactor)
template<class VOXEL >
static void ApplyLaplaceOnGauss3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, Filter< double > &filtr1, Filter< double > &filtr2)
template<class VOXEL >
static void ApplyMarrHildreth3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double sigma1, double sigma2)
template<class VOXEL >
void MarrHildreth3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double sigma1, double sigma2)
template<>
I3D_ALGO_EXPORT void MarrHildreth3D (const Image3d< RGB > &in, Image3d< RGB > &out, double sigma1, double sigma2)
template<>
void MarrHildreth3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, double sigma1, double sigma2)
template<class VOXEL >
static bool ZeroCross2D (const Image3d< VOXEL > &in, size_t x, size_t y, size_t z)
template<class VOXEL >
static void ApplyLaplaceOnGauss2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, Filter< double > &filtr1, Filter< double > &filtr2)
template<class VOXEL >
static void ApplyMarrHildreth2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double sigma1, double sigma2)
template<class VOXEL >
void MarrHildreth2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, double sigma1, double sigma2)
template<>
I3D_ALGO_EXPORT void MarrHildreth2D (const Image3d< RGB > &in, Image3d< RGB > &out, double sigma1, double sigma2)
template<>
I3D_ALGO_EXPORT void MarrHildreth2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, double sigma1, double sigma2)
template<class VOXEL >
static void ApplyLaplace3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void Laplace3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Laplace3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Laplace3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyRoberts3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void Roberts3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Roberts3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Roberts3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyAnisotropicRoberts3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void AnisotropicRoberts3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void AnisotropicRoberts3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void AnisotropicRoberts3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyEstimateGradient1_3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<class VOXEL >
void EstimateGradient1_3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient1_3D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient1_3D (const Image3d< RGB > &in, Image3d< RGB > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient1_3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, bool clamp)
template<class VOXEL >
static void ApplyEstimateGradient2_3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<class VOXEL >
void EstimateGradient2_3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<>
void ApplyEstimateGradient2_3D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient2_3D (const Image3d< RGB > &in, Image3d< RGB > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient2_3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, bool clamp)
static void GradMag (const float *&in, float *&out, size_t right, size_t left, size_t upper, size_t lower, float denom_x, float denom_y)
static void RowGradMag (const float *&in, float *&out, size_t upper, size_t lower, float denom_x, float denom_y, size_t sx)
static void GradMag3D (const float *&in, float *&out, size_t right, size_t left, size_t upper, size_t lower, size_t top, size_t bottom, float denom_x, float denom_y, float denom_z)
static void RowGradMag3D (const float *&in, float *&out, size_t upper, size_t lower, size_t top, size_t bottom, float denom_x, float denom_y, float denom_z, size_t sx)
static void SliceGradMag3D (const float *&in, float *&out, size_t top, size_t bottom, float denom_x, float denom_y, float denom_z, size_t sx, size_t sy)
void EstimateGradientMagnitude (const Image3d< float > &in, Image3d< float > &out)
template<class VOXEL >
static void ApplySobel3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void Sobel3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Sobel3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Sobel3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyAnisoSobel3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void AnisoSobel3D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void AnisoSobel3D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void AnisoSobel3D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
static double dG (int x, double sigma)
static Filter< double > MakeDiffGauss1DFilter (double sigma, double widthFactor)
template<class VOXEL >
void Gradient3D (Filter< double > diff_gauss_filter, Filter< double > gauss_filter, const Image3d< VOXEL > &vstup, Vector3d< int > offset, Vector3d< int > size, VectField3d< float > *&vystup)
static float InterpolateGradient (int axis, Vector3d< float > gradient, int x, int y, int z, VectField3d< float > *gradients)
template<class VOXEL >
static void NonMaxSuppression3D (Image3d< VOXEL > &vystup, VectField3d< float > *&gradients, Vector3d< int > offset, Vector3d< int > size)
template<class VOXEL >
static void ApplyCanny3D (const Image3d< VOXEL > &vstup, Image3d< VOXEL > &vystup, float sigma, float scale)
template<class VOXEL >
void hysteresisThreshold3D (Image3d< VOXEL > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<class VOXEL >
void hystThres3D (Image3d< VOXEL > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<>
I3D_ALGO_EXPORT void hystThres3D (Image3d< RGB > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<>
I3D_ALGO_EXPORT void hystThres3D (Image3d< RGB16 > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<class VOXEL >
void Gradient2D (Filter< double > diff_gauss_filter, Filter< double > gauss_filter, const Image3d< VOXEL > &vstup, VectField3d< double > *&vystup, int z)
double InterpolateGradient2D (int axis, Vector3d< double > gradient, int x, int y, VectField3d< double > *gradients)
template<class VOXEL >
void NonMaxSuppression2D (Image3d< VOXEL > &vystup, VectField3d< double > *&gradients, float scale, int z)
template<class VOXEL >
static void ApplyCanny2D (const Image3d< VOXEL > &vstup, Image3d< VOXEL > &vystup, float sigma, float scale)
template<class VOXEL >
void hysteresisThreshold2D (Image3d< VOXEL > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<class VOXEL >
void hystThres2D (Image3d< VOXEL > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<>
I3D_ALGO_EXPORT void hystThres2D (Image3d< RGB > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<>
I3D_ALGO_EXPORT void hystThres2D (Image3d< RGB16 > &data, unsigned short lowThreshold, unsigned short highThreshold)
template<class VOXEL >
void Canny2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, float sigma, float scale)
template<class VOXEL >
static void ApplySobel2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void Sobel2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Sobel2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Sobel2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyLaplace2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void Laplace2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Laplace2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Laplace2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void Apply2DCompassFilter (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, int filtr[8][3][3])
template<class VOXEL >
void Kirsch2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Kirsch2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Kirsch2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
void Prewitt2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Prewitt2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Prewitt2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
void Robinson2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Robinson2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Robinson2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
void CompassSobel2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void CompassSobel2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void CompassSobel2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyRoberts2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class VOXEL >
void Roberts2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<>
I3D_ALGO_EXPORT void Roberts2D (const Image3d< RGB > &in, Image3d< RGB > &out)
template<>
I3D_ALGO_EXPORT void Roberts2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out)
template<class VOXEL >
static void ApplyEstimateGradient1_2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<class VOXEL >
void EstimateGradient1_2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<>
void ApplyEstimateGradient1_2D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template<>
void I3D_ALGO_EXPORT EstimateGradient1_2D (const Image3d< RGB > &in, Image3d< RGB > &out, bool clamp)
template<>
void I3D_ALGO_EXPORT EstimateGradient1_2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, bool clamp)
template<class VOXEL >
static void ApplyEstimateGradient2_2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<class VOXEL >
void EstimateGradient2_2D (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, bool clamp)
template<>
void ApplyEstimateGradient2_2D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient2_2D (const Image3d< RGB > &in, Image3d< RGB > &out, bool clamp)
template<>
I3D_ALGO_EXPORT void EstimateGradient2_2D (const Image3d< RGB16 > &in, Image3d< RGB16 > &out, bool clamp)
template I3D_ALGO_EXPORT void Robinson3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Robinson3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Robinson3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Robinson3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void CompassSobel3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void CompassSobel3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void CompassSobel3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void CompassSobel3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Prewitt3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Prewitt3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Prewitt3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Prewitt3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Kirsch3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Kirsch3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Kirsch3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Kirsch3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void ShenCastan3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, double p, int WinHalfSize)
template I3D_ALGO_EXPORT void ShenCastan3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, double p, int WinHalfSize)
template I3D_ALGO_EXPORT void ShenCastan3D (const Image3d< float > &in, Image3d< float > &out, double p, int WinHalfSize)
template I3D_ALGO_EXPORT void ShenCastan2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, double p, int WinHalfSize)
template I3D_ALGO_EXPORT void ShenCastan2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, double p, int WinHalfSize)
template I3D_ALGO_EXPORT void ShenCastan2D (const Image3d< float > &in, Image3d< float > &out, double p, int WinHalfSize)
template I3D_ALGO_EXPORT void MarrHildreth3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, double sigma1, double sigma2)
template I3D_ALGO_EXPORT void MarrHildreth3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, double sigma1, double sigma2)
template I3D_ALGO_EXPORT void MarrHildreth2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, double sigma1, double sigma2)
template I3D_ALGO_EXPORT void MarrHildreth2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, double sigma1, double sigma2)
template I3D_ALGO_EXPORT void Laplace3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Laplace3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Laplace3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Laplace3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Roberts3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Roberts3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Roberts3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Roberts3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void EstimateGradient1_3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient1_3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient1_3D (const Image3d< bool > &in, Image3d< bool > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_3D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_3D (const Image3d< bool > &in, Image3d< bool > &out, bool clamp)
template I3D_ALGO_EXPORT void Sobel3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Sobel3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Sobel3D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Sobel3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void AnisoSobel3D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void AnisoSobel3D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void AnisoSobel3D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void hystThres3D (Image3d< GRAY8 > &data, unsigned short lowThreshold, unsigned short highThreshold)
template I3D_ALGO_EXPORT void hystThres3D (Image3d< GRAY16 > &data, unsigned short lowThreshold, unsigned short highThreshold)
template I3D_ALGO_EXPORT void hystThres3D (Image3d< float > &data, unsigned short lowThreshold, unsigned short highThreshold)
template I3D_ALGO_EXPORT void hystThres2D (Image3d< GRAY8 > &data, unsigned short lowThreshold, unsigned short highThreshold)
template I3D_ALGO_EXPORT void hystThres2D (Image3d< GRAY16 > &data, unsigned short lowThreshold, unsigned short highThreshold)
template I3D_ALGO_EXPORT void hystThres2D (Image3d< float > &data, unsigned short lowThreshold, unsigned short highThreshold)
template I3D_ALGO_EXPORT void Sobel2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Sobel2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Sobel2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Sobel2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Laplace2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Laplace2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Laplace2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Laplace2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Kirsch2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Kirsch2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Kirsch2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Kirsch2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Prewitt2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Prewitt2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Prewitt2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Prewitt2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Robinson2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Robinson2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Robinson2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Robinson2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void CompassSobel2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void CompassSobel2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void CompassSobel2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void CompassSobel2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Roberts2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Roberts2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Roberts2D (const Image3d< bool > &in, Image3d< bool > &out)
template I3D_ALGO_EXPORT void Roberts2D (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void EstimateGradient1_2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient1_2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient1_2D (const Image3d< bool > &in, Image3d< bool > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient1_2D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_2D (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_2D (const Image3d< float > &in, Image3d< float > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_2D (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, bool clamp)
template I3D_ALGO_EXPORT void EstimateGradient2_2D (const Image3d< bool > &in, Image3d< bool > &out, bool clamp)
template<class NUMBER , class NUMBER2 >
void Convert (Filter< NUMBER > &out, const Filter< NUMBER2 > &in)
template<>
void ApplyGauss1D (RGB *data, const slice &slc, Filter< double > &f, Buffer &b, bool divide)
template<>
void ApplyGauss1D (RGB16 *data, const slice &slc, Filter< double > &f, Buffer &b, bool divide)
template<>
void ApplyGauss1D (RGBD *data, const slice &slc, Filter< double > &f, Buffer &b, bool divide)
template<class VOXEL >
void ApplyGauss1D (VOXEL *restrict data, const slice &slc, Filter< double > &f, Buffer &b, bool divide)
template<class VOXEL >
void GaussFIR (i3d::Image3d< VOXEL > const &In, i3d::Image3d< VOXEL > &Out, const VOXEL Sigma, const float Width)
template<class VOXEL >
void GaussFIR (i3d::Image3d< VOXEL > &img, const VOXEL Sigma, const float Width)
template<class VOXEL >
void GaussFIR (i3d::Image3d< VOXEL > const &In, i3d::Image3d< VOXEL > &Out, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ, const float WidthX, const float WidthY, const float WidthZ)
template<class VOXEL >
void GaussFIR (i3d::Image3d< VOXEL > &img, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ, const float WidthX, const float WidthY, const float WidthZ)
void MakeFWindow (int *f, const Neighbourhood &nb, vector< int > &win)
template<class VOXEL >
VOXEL ApplFilter (const vector< VOXEL * > &img, const vector< int > &filter)
template<class VOXEL >
void Sobel (Image3d< VOXEL > &, bool do_vertical=true, bool do_horizontal=true)
template<class VOXEL >
void Laplace (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class T >
void SuppresHotPixels (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib, T thres)
template<class VOXEL >
void SigmaFilter (const Image3d< VOXEL > &in, Image3d< VOXEL > &out, const Neighbourhood &neib, const Neighbourhood &neib1, VOXEL sigma, int tres)
template<class VOXEL >
int SeparableConvolution (i3d::Image3d< VOXEL > const &d, i3d::Image3d< VOXEL > &res, struct Separable3dFilter< VOXEL > const &f, struct BorderPadding< VOXEL > const &b)
template<class VOXEL >
int NaiveConvolution (Image3d< VOXEL > const &in,Image3d< VOXEL > const &kern,Image3d< VOXEL > &out,const VOXEL border=0)
template I3D_ALGO_EXPORT void Convert (Filter< double > &, const Filter< double > &)
template I3D_ALGO_EXPORT void Convert (Filter< GRAY8 > &, const Filter< GRAY8 > &)
template I3D_ALGO_EXPORT void Convert (Filter< GRAY16 > &, const Filter< GRAY16 > &)
template I3D_ALGO_EXPORT void Convert (Filter< GRAY8 > &, const Filter< double > &)
template I3D_ALGO_EXPORT void Convert (Filter< GRAY16 > &, const Filter< double > &)
template I3D_ALGO_EXPORT void Convert (Filter< GRAY8 > &, const Filter< GRAY16 > &)
template I3D_ALGO_EXPORT void Convert (Filter< GRAY16 > &, const Filter< GRAY8 > &)
template I3D_ALGO_EXPORT void Gauss (Image3d< RGB > &, double, double, double, double, bool)
template I3D_ALGO_EXPORT void Gauss (Image3d< GRAY8 > &, double, double, double, double, bool)
template I3D_ALGO_EXPORT void Gauss (Image3d< GRAY16 > &, double, double, double, double, bool)
template I3D_ALGO_EXPORT void Gauss (Image3d< float > &, double, double, double, double, bool)
template I3D_ALGO_EXPORT void GaussIIR (Image3d< float > &, const float)
template I3D_ALGO_EXPORT void GaussIIR (Image3d< double > &, const double)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY8 > &, const float)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY8 > &, const double)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY16 > &, const float)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY16 > &, const double)
template I3D_ALGO_EXPORT void GaussIIR (Image3d< float > &, const float, const float, const float)
template I3D_ALGO_EXPORT void GaussIIR (Image3d< double > &, const double, const double, const double)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY8 > &, const float, const float, const float)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY8 > &, const double, const double, const double)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY16 > &, const float, const float, const float)
template I3D_ALGO_EXPORT void GrayGaussIIR (Image3d< GRAY16 > &, const double, const double, const double)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< float > const &, Image3d< float > &, const float, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< double > const &, Image3d< double > &, const double, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< float > &, const float, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< double > &, const double, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< float > const &, Image3d< float > &, const float, const float, const float, const float, const float, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< double > const &, Image3d< double > &, const double, const double, const double, const float, const float, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< float > &, const float, const float, const float, const float, const float, const float)
template I3D_ALGO_EXPORT void GaussFIR (Image3d< double > &, const double, const double, const double, const float, const float, const float)
template I3D_ALGO_EXPORT void Sobel (Image3d< GRAY8 > &, bool, bool)
template I3D_ALGO_EXPORT void Laplace (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void SuppresHotPixels (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, const Neighbourhood &, GRAY8)
template I3D_ALGO_EXPORT void SuppresHotPixels (const Image3d< GRAY16 > &, Image3d< GRAY16 > &, const Neighbourhood &, GRAY16)
template I3D_ALGO_EXPORT void SuppresHotPixels (const Image3d< float > &, Image3d< float > &, const Neighbourhood &, float)
template I3D_ALGO_EXPORT void ApplyGauss1D (unsigned long *restrict data, const slice &slc, Filter< double > &f, Buffer &b, bool divide)
template I3D_ALGO_EXPORT void ApplyGauss1D (float *restrict data, const slice &slc, Filter< double > &f, Buffer &b, bool divide)
template I3D_ALGO_EXPORT void SigmaFilter (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib, const Neighbourhood &neib1, GRAY8 sigma, int tres)
template I3D_ALGO_EXPORT void SimpleGauss (Image3d< GRAY8 > &img, double sigma, bool exact)
template I3D_ALGO_EXPORT void SimpleGauss (Image3d< GRAY16 > &img, double sigma, bool exact)
template I3D_ALGO_EXPORT void SimpleGauss (Image3d< float > &img, double sigma, bool exact)
template I3D_ALGO_EXPORT void PrepareZeroBoundaryForFilter (struct Separable3dFilter< float > const &filter, BorderPadding< float > &b)
template I3D_ALGO_EXPORT void PrepareZeroBoundaryForFilter (struct Separable3dFilter< double > const &filter, BorderPadding< double > &b)
template I3D_ALGO_EXPORT void EstimateGaussKernel (struct Separable3dFilter< float > &, const float, const float, const float, const float, const float, const float)
template I3D_ALGO_EXPORT void EstimateGaussKernel (struct Separable3dFilter< double > &, const double, const double, const double, const float, const float, const float)
template I3D_ALGO_EXPORT int SeparableConvolution (i3d::Image3d< float > const &d, i3d::Image3d< float > &res, struct Separable3dFilter< float > const &f, struct BorderPadding< float > const &b)
template I3D_ALGO_EXPORT int SeparableConvolution (i3d::Image3d< double > const &d, i3d::Image3d< double > &res, struct Separable3dFilter< double > const &f, struct BorderPadding< double > const &b)
template I3D_ALGO_EXPORT int NaiveConvolution (Image3d< float > const &, Image3d< float > const &, Image3d< float > &, const float)
template I3D_ALGO_EXPORT int NaiveConvolution (Image3d< double > const &, Image3d< double > const &, Image3d< double > &, const double)
template I3D_ALGO_EXPORT int NaiveConvolution (Image3d< GRAY8 > const &, Image3d< GRAY8 > const &, Image3d< GRAY8 > &, const GRAY8)
template I3D_ALGO_EXPORT int NaiveConvolution (Image3d< GRAY16 > const &, Image3d< GRAY16 > const &, Image3d< GRAY16 > &, const GRAY16)
template<class NUMBER >
void Convert (Filter< NUMBER > &out, const Filter< NUMBER > &in)
void MUTEX_LOCK ()
void MUTEX_UNLOCK ()
template<class PRECISION >
I3D_ALGO_EXPORT size_t GetFFTWBufferSize (Vector3d< size_t > img_sz)
template<class S , class T >
void RealImage2FFTWBuffer (const Image3d< S > &img, T *fftw_buffer, T factor)
template<class T >
I3D_ALGO_EXPORT void FFTshift (Image3d< T > &img, const Vector3d< int > &shift)
template<class S , class T >
void FFTWBuffer2RealImage (const S *fftw_buffer, Image3d< T > &img, S factor)
template<class T , class PRECISION >
I3D_ALGO_EXPORT void FFT (const Image3d< T > &real_img, Image3d< complex< PRECISION >> &complex_img, bool normalize)
template<class T , class PRECISION >
I3D_ALGO_EXPORT void IFFT (const Image3d< std::complex< PRECISION >> &complex_img, Image3d< T > &real_img, bool normalize)
template I3D_ALGO_EXPORT void FFT (const Image3d< bool > &, Image3d< complex< float >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< GRAY8 > &, Image3d< complex< float >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< GRAY16 > &, Image3d< complex< float >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< float > &, Image3d< complex< float >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< double > &, Image3d< complex< float >> &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< float >> &, Image3d< GRAY8 > &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< float >> &, Image3d< GRAY16 > &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< float >> &, Image3d< float > &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< float >> &, Image3d< double > &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< bool > &, Image3d< complex< double >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< GRAY8 > &, Image3d< complex< double >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< GRAY16 > &, Image3d< complex< double >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< float > &, Image3d< complex< double >> &, bool)
template I3D_ALGO_EXPORT void FFT (const Image3d< double > &, Image3d< complex< double >> &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< double >> &, Image3d< GRAY8 > &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< double >> &, Image3d< GRAY16 > &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< double >> &, Image3d< float > &, bool)
template I3D_ALGO_EXPORT void IFFT (const Image3d< complex< double >> &, Image3d< double > &, bool)
template I3D_ALGO_EXPORT void FFTshift (Image3d< bool > &img, const Vector3d< int > &shift)
template I3D_ALGO_EXPORT void FFTshift (Image3d< GRAY8 > &img, const Vector3d< int > &shift)
template I3D_ALGO_EXPORT void FFTshift (Image3d< GRAY16 > &img, const Vector3d< int > &shift)
template I3D_ALGO_EXPORT void FFTshift (Image3d< float > &img, const Vector3d< int > &shift)
template I3D_ALGO_EXPORT void FFTshift (Image3d< double > &img, const Vector3d< int > &shift)
template I3D_ALGO_EXPORT size_t GetFFTWBufferSize< float > (Vector3d< size_t > img_sz)
template I3D_ALGO_EXPORT size_t GetFFTWBufferSize< double > (Vector3d< size_t > img_sz)
template<class T , class PRECISION >
I3D_ALGO_EXPORT void FFT (const Image3d< T > &real_img, Image3d< std::complex< PRECISION > > &complex_img, bool normalize=false)
template<class T , class PRECISION >
I3D_ALGO_EXPORT void IFFT (const Image3d< std::complex< PRECISION > > &in, Image3d< T > &out, bool normalize=false)
template<class VOXEL_TYPE >
void GradientMagnitude (const Image3d< VOXEL_TYPE > &img, Image3d< float > &gimg)
template<class VOXEL_TYPE >
void GradientMagnitude2 (const Image3d< VOXEL_TYPE > &img, Image3d< float > &gimg)
template<class VOXEL_TYPE >
void Gradient (const Image3d< VOXEL_TYPE > &img, Image3d< float > &dx, Image3d< float > &dy, Image3d< float > &dz)
template<class VOXEL_TYPE >
void GradientX (const Image3d< VOXEL_TYPE > &img, Image3d< float > &dx)
template<class VOXEL_TYPE >
void GradientY (const Image3d< VOXEL_TYPE > &img, Image3d< float > &dy)
template<class VOXEL_TYPE >
void GradientZ (const Image3d< VOXEL_TYPE > &img, Image3d< float > &dz)
template<class VOXEL_TYPE >
void MultiplyImage (Image3d< VOXEL_TYPE > &img, VOXEL_TYPE k)
template<class VOXEL_TYPE >
void SquareImage (Image3d< VOXEL_TYPE > &img)
template<class VOXEL_TYPE >
void AddImage (Image3d< VOXEL_TYPE > &img1, const Image3d< VOXEL_TYPE > &img2)
template I3D_ALGO_EXPORT void Gradient (const Image3d< i3d::GRAY8 > &img, Image3d< float > &dx, Image3d< float > &dy, Image3d< float > &dz)
template I3D_ALGO_EXPORT void Gradient (const Image3d< i3d::GRAY16 > &img, Image3d< float > &dx, Image3d< float > &dy, Image3d< float > &dz)
template I3D_ALGO_EXPORT void Gradient (const Image3d< float > &img, Image3d< float > &dx, Image3d< float > &dy, Image3d< float > &dz)
template I3D_ALGO_EXPORT void GradientMagnitude (const Image3d< i3d::GRAY8 > &img, Image3d< float > &gimg)
template I3D_ALGO_EXPORT void GradientMagnitude (const Image3d< i3d::GRAY16 > &img, Image3d< float > &gimg)
template I3D_ALGO_EXPORT void GradientMagnitude (const Image3d< float > &img, Image3d< float > &gimg)
template I3D_ALGO_EXPORT void GradientMagnitude2 (const Image3d< i3d::GRAY8 > &img, Image3d< float > &gimg)
template I3D_ALGO_EXPORT void GradientMagnitude2 (const Image3d< i3d::GRAY16 > &img, Image3d< float > &gimg)
template I3D_ALGO_EXPORT void GradientMagnitude2 (const Image3d< float > &img, Image3d< float > &gimg)
template I3D_ALGO_EXPORT void GradientX (const Image3d< i3d::GRAY8 > &img, Image3d< float > &dx)
template I3D_ALGO_EXPORT void GradientX (const Image3d< i3d::GRAY16 > &img, Image3d< float > &dx)
template I3D_ALGO_EXPORT void GradientX (const Image3d< float > &img, Image3d< float > &dx)
template I3D_ALGO_EXPORT void GradientY (const Image3d< i3d::GRAY8 > &img, Image3d< float > &dy)
template I3D_ALGO_EXPORT void GradientY (const Image3d< i3d::GRAY16 > &img, Image3d< float > &dy)
template I3D_ALGO_EXPORT void GradientY (const Image3d< float > &img, Image3d< float > &dy)
template I3D_ALGO_EXPORT void GradientZ (const Image3d< i3d::GRAY8 > &img, Image3d< float > &dz)
template I3D_ALGO_EXPORT void GradientZ (const Image3d< i3d::GRAY16 > &img, Image3d< float > &dz)
template I3D_ALGO_EXPORT void GradientZ (const Image3d< float > &img, Image3d< float > &dz)
template I3D_ALGO_EXPORT void MultiplyImage (Image3d< float > &img, float k)
template I3D_ALGO_EXPORT void SquareImage (Image3d< float > &img)
template I3D_ALGO_EXPORT void AddImage (Image3d< float > &img1, const Image3d< float > &img2)
void ClearHist (Histogram &hist)
void IntensityHist (const Image3d< float > &img, Histogram &hist, size_t NumberOfBins, size_t SizeOfStep)
void IntensityHist (const Image3d< float > &img, Histogram &hist, const std::gslice &slc)
void IntensityHist (const Image3d< double > &img, Histogram &hist, size_t NumberOfBins, size_t SizeOfStep)
void IntensityHist (const Image3d< double > &img, Histogram &hist, const std::gslice &slc)
void IntensityHist (const Image3d< Vector3d< float > > &img, Histogram &hist, const std::gslice &slc)
void IntensityHist (const Image3d< Vector3d< double > > &img, Histogram &hist, const std::gslice &slc)
template<class T >
void InitHist (Histogram &hist)
template<class T >
void ComputeHist (const T *data, Histogram &hist, size_t size, size_t stride=1)
template<class T , class MT >
void ComputeHist (const T *data, Histogram &hist, size_t size, const MT *mask)
void IntensityHist (const Image3d< RGB > &img, Histogram &hist, int channel)
template<class T >
void IntensityHist (const Image3d< T > &img, Histogram &hist)
template<class T , class MT >
void IntensityHist (const Image3d< T > &img, Histogram &hist, const Image3d< MT > &mask)
template<class T >
void IntensityHist (const Image3d< T > &img, Histogram &hist, const std::gslice &slc)
void ComputeHistInfo (const Histogram &hist, HistInfo &hi, double thres_factor)
void SmoothHist (const Histogram &in, Histogram &out)
void SmoothHist (const Histogram &in, Histogram &out, size_t diff)
unsigned long CumulativeHistogram (const Histogram &in, Histogram &out)
void RecDilHist (const Histogram &mask, Histogram &out)
void RecEroHist (const Histogram &mask, Histogram &out)
void DynMax (const Histogram &in, Histogram &out)
template<class T >
void MapLevels (const Histogram &h, std::vector< T > &map_func, int thres=0)
template<class T >
void MapPermileLevels (const Histogram &h, std::vector< T > &map_func, int perm=5)
size_t FindUnimodalThreshold (const Histogram &hist)
size_t OldFindOtsuThreshold (const Histogram &hist)
size_t FindOtsuThreshold (const Histogram &hist)
size_t FindIsoDataThreshold (const Histogram &hist, int init_thr_type=0)
template I3D_ALGO_EXPORT void MapLevels (const Histogram &h, std::vector< GRAY8 > &map_func, int thres)
template I3D_ALGO_EXPORT void MapLevels (const Histogram &h, std::vector< GRAY16 > &map_func, int thres)
template I3D_ALGO_EXPORT void MapPermileLevels (const Histogram &h, std::vector< GRAY8 > &map_func, int thres)
template I3D_ALGO_EXPORT void MapPermileLevels (const Histogram &h, std::vector< GRAY16 > &map_func, int thres)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY8 > &img, Histogram &hist)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY8 > &img, Histogram &hist, const Image3d< GRAY8 > &mask)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY16 > &img, Histogram &hist, const Image3d< GRAY8 > &mask)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY16 > &img, Histogram &hist, const Image3d< GRAY16 > &mask)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY8 > &img, Histogram &hist, const Image3d< int > &mask)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< bool > &img, Histogram &hist)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY16 > &img, Histogram &hist)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY8 > &img, Histogram &hist, const std::gslice &slc)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY16 > &img, Histogram &hist, const std::gslice &slc)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< int > &img, Histogram &hist, const std::gslice &slc)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< size_t > &img, Histogram &hist, const std::gslice &slc)
size_t HistMax (const Histogram &h)
size_t HistMin (const Histogram &h)
int HistPercentil (const Histogram &h, float k)
size_t HistFirstNonZero (const Histogram &h)
size_t HistLastNonZero (const Histogram &h)
I3D_ALGO_EXPORT void DiffHist (const Histogram &in, Histogram &out)
void RegMaxHist (const Histogram &in, Histogram &out)
unsigned long aplicateMask (const Histogram &data, const size_t i, const std::vector< double > &mask)
std::vector< double > generateGaussMask (const double sigma)
template<class T >
bool fitBspline (const Image3d< T > &img, bSplineSurface &surface, const Image3d< bool > &background, bool backgroundSign)
template<class T >
double getRMS (T *data, size_t size)
template<class T >
size_t getThreshold (Image3d< T > &img)
template<class T >
void thresholdBackground (Image3d< T > &in, Image3d< bool > &out)
template<class T >
bool estimateBackground (const Image3d< T > &o, Image3d< T > &background, int bSplineCpCountX, int bSplineCpCountY, int bSplineDegree)
template I3D_ALGO_EXPORT bool estimateBackground (const Image3d< GRAY8 > &o, Image3d< GRAY8 > &background, int bSplineCpCountX, int bSplineCpCountY, int bSplineDegree)
template I3D_ALGO_EXPORT bool estimateBackground (const Image3d< GRAY16 > &o, Image3d< GRAY16 > &background, int bSplineCpCountX, int bSplineCpCountY, int bSplineDegree)
template<class T >
bool correctIlluminationBsplineAprox (const Image3d< T > &in, Image3d< T > &out, int previewPercent, int bSplineCpCountX, int bSplineCpCountY, int bSplineDegree)
template I3D_ALGO_EXPORT bool correctIlluminationBsplineAprox (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, int previewPercent, int bSplineCpCountX, int bSplineCpCountY, int bSplineDegree)
template I3D_ALGO_EXPORT bool correctIlluminationBsplineAprox (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, int previewPercent, int bSplineCpCountX, int bSplineCpCountY, int bSplineDegree)
template<class T >
void homFilter (Image3d< T > &in, Image3d< T > &out, const HomomorphicFilterParams &params)
template I3D_ALGO_EXPORT void homFilter (Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const HomomorphicFilterParams &params)
template I3D_ALGO_EXPORT void homFilter (Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const HomomorphicFilterParams &params)
double getGauss (const size_t x, const double sigma)
template<class VOXEL >
i3d::Vector3d< float > ComputeNormedSpacing (i3d::Image3d< VOXEL > &img)
template<class VOXELIN , class VOXELOUT >
void SpeedFunctionStandard (Image3d< VOXELIN > &ImgIn, Image3d< VOXELOUT > &SpeedImg, double sigmax=1.2, double sigmay=1.2, double sigmaz=1.2, double width=1.5)
template<class VOXELIN , class VOXELOUT >
void SpeedFunctionExponential (Image3d< VOXELIN > &ImgIn, Image3d< VOXELOUT > &SpeedImg, double sigmax=1.0, double sigmay=1.0, double sigmaz=1.0, double width=1.5, double alpha=0.02)
template<class VOXEL , class SF >
void UpdatePoint (std::valarray< VOXEL > &ArrivalTimes, VOXEL Speed, Vector3d< float > &res, Heap< VOXEL, SF > &heap, std::valarray< unsigned char > &Flags, size_t PointId, size_t *Neighbors)
template<class VOXEL , class SF >
void UpdatePoint3D (std::valarray< VOXEL > &ArrivalTimes, VOXEL Speed, Vector3d< float > &res, Heap< VOXEL, SF > &heap, std::valarray< unsigned char > &Flags, size_t PointId, size_t *Neighbors)
template<class VOXELIN , class VOXELOUT >
void FastMarchingMethod (Image3d< VOXELIN > &SpeedImg, Image3d< VOXELOUT > &ImgOut, SeedPointsVector &SeedPoints)
template<class VOXELIN , class VOXELOUT , class FMROUTINES >
void FastMarchingMethodComp (Image3d< VOXELIN > &SpeedImg, Image3d< VOXELOUT > &ImgOut, SeedPointsVector &SeedPoints, FMROUTINES func)
template<class VOXELIN , class VOXELOUT >
void GeodesicDistance (Image3d< VOXELIN > &ImgIn, Image3d< VOXELOUT > &ImgOut, SeedPointsVector &SeedPoints)
template<class VOXELOUT , class FMROUTINES >
void GeodesicDistanceComp (Image3d< VOXELOUT > &ImgOut, SeedPointsVector &SeedPoints, HASH_SET< size_t > &boundary, FMROUTINES func)
template<class VOXELOUT , class FMROUTINES >
void WeightedGeodesicDistanceComp (Image3d< VOXELOUT > &ImgOut, Image3d< VOXELOUT > &Speed, SeedPointsVector &SeedPoints, HASH_SET< size_t > &boundary, FMROUTINES func)
template<class VOXELIN , class VOXELOUT >
void LocalRadius (const Image3d< VOXELIN > &ImgIn, Image3d< VOXELOUT > &ImgOut, SeedPointsVector &SeedPoints)
template<class VOXELIN , class VOXELOUT >
void FastMarchingSignedDistance (VOXELIN Speed, Image3d< VOXELOUT > &ImgOut, std::vector< size_t > &indexes, std::vector< VOXELOUT > &values)
template<class VOXELIN , class VOXELOUT , class FMROUTINES >
void FastMarchingMethodComp (VOXELIN Speed, Image3d< VOXELOUT > &ImgOut, std::vector< size_t > &indexes, std::vector< VOXELOUT > &values, FMROUTINES func)
template<class VOXEL >
void FindContourLevel (Image3d< VOXEL > &Img, VOXEL &value, size_t Start=3, VOXEL Threshold=2.0, size_t Bins=100, size_t Step=1, double Sigma=1.0, double Radius=3.0)
template I3D_ALGO_EXPORT void FindContourLevel (Image3d< float > &Img, float &value, size_t Start, float Threshold, size_t Bins, size_t Step, double Sigma, double Radius)
template I3D_ALGO_EXPORT void FastMarchingMethod (Image3d< float > &SpeedImg, Image3d< float > &ImgOut, SeedPointsVector &SeedPoints)
template I3D_ALGO_EXPORT void GeodesicDistance (Image3d< bool > &ImgIn, Image3d< float > &ImgOut, SeedPointsVector &SeedPoints)
template I3D_ALGO_EXPORT void GeodesicDistance (Image3d< GRAY8 > &ImgIn, Image3d< float > &ImgOut, SeedPointsVector &SeedPoints)
template I3D_ALGO_EXPORT void LocalRadius (const Image3d< bool > &ImgIn, Image3d< float > &ImgOut, SeedPointsVector &SeedPoints)
template I3D_ALGO_EXPORT void LocalRadius (const Image3d< GRAY8 > &ImgIn, Image3d< float > &ImgOut, SeedPointsVector &SeedPoints)
template I3D_ALGO_EXPORT void LocalRadius (const Image3d< GRAY16 > &ImgIn, Image3d< float > &ImgOut, SeedPointsVector &SeedPoints)
template I3D_ALGO_EXPORT void SpeedFunctionStandard (Image3d< GRAY8 > &ImgIn, Image3d< float > &SpeedImg, double sigmax, double sigmay, double sigmaz, double width)
template I3D_ALGO_EXPORT void SpeedFunctionExponential (Image3d< GRAY8 > &ImgIn, Image3d< float > &SpeedImg, double sigmax, double sigmay, double sigmaz, double width, double alpha)
template I3D_ALGO_EXPORT void SpeedFunctionStandard (Image3d< GRAY16 > &ImgIn, Image3d< float > &SpeedImg, double sigmax, double sigmay, double sigmaz, double width)
template I3D_ALGO_EXPORT void SpeedFunctionExponential (Image3d< GRAY16 > &ImgIn, Image3d< float > &SpeedImg, double sigmax, double sigmay, double sigmaz, double width, double alpha)
template I3D_ALGO_EXPORT
i3d::Vector3d< float > 
ComputeNormedSpacing (i3d::Image3d< float > &img)
template I3D_ALGO_EXPORT
i3d::Vector3d< float > 
ComputeNormedSpacing (i3d::Image3d< GRAY8 > &img)
template<class VOXELIN , class VOXELOUT >
I3D_ALGO_EXPORT void FastMarchingMethod (i3d::Image3d< VOXELIN > &SpeedImg, i3d::Image3d< VOXELOUT > &ImgOut, SeedPointsVector &SeedPoints)
template<class LABEL , class VOXELOUT >
I3D_ALGO_EXPORT void LocalRadiusFlat (const i3d::LabeledImage3d< LABEL, bool > &ImgIn, Image3d< VOXELOUT > &ImgOut, const i3d::Vector3d< size_t > &centroid)
template<class LABEL , class VOXELOUT >
I3D_ALGO_EXPORT void LocalRadiusFlat (const i3d::LabeledImage3d< LABEL, bool > &ImgIn, Image3d< VOXELOUT > &ImgOut, const i3d::SeedPointsVector &seeds)
template I3D_ALGO_EXPORT void LocalRadiusFlat (const i3d::LabeledImage3d< GRAY16, bool > &ImgIn, Image3d< float > &ImgOut, const i3d::Vector3d< size_t > &centroid)
template I3D_ALGO_EXPORT void LocalRadiusFlat (const i3d::LabeledImage3d< GRAY16, bool > &ImgIn, Image3d< float > &ImgOut, const i3d::SeedPointsVector &seeds)
template<class T >
void MeanShiftFiltering (const i3d::Image3d< T > &in, i3d::Image3d< T > &out, double spatial_kernel_size, double range_kernel_size, bool optimized)
template I3D_ALGO_EXPORT void MeanShiftFiltering (const i3d::Image3d< i3d::GRAY8 > &in, i3d::Image3d< i3d::GRAY8 > &out, double spatial_kernel_size, double range_kernel_size, bool optimized)
template I3D_ALGO_EXPORT void MeanShiftFiltering (const i3d::Image3d< i3d::GRAY16 > &in, i3d::Image3d< i3d::GRAY16 > &out, double spatial_kernel_size, double range_kernel_size, bool optimized)
template<class T , class F , class G >
bool Rec1DForward (const Image3d< T > &mask, Image3d< T > &out, size_t start1, size_t start2, size_t num1, size_t num2, size_t num3, size_t stride2, size_t stride3, F func_f, G func_g)
template<class T , class F , class G >
bool Rec1DBackward (const Image3d< T > &mask, Image3d< T > &out, size_t start1, size_t start2, size_t num1, size_t num2, size_t num3, size_t stride2, size_t stride3, F func_f, G func_g)
template<class T >
void Dilation (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Dilation (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Dilation (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Dilation (const Image3d< size_t > &in, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Dilation (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template<class T >
void LocalDilation (const Image3d< T > &in, Image3d< T > &out, const Image3d< bool > &mask, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalDilation (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalDilation (const Image3d< bool > &in, Image3d< bool > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalDilation (const Image3d< size_t > &in, Image3d< size_t > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalDilation (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template<class T >
void Erosion (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Erosion (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Erosion (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Erosion (const Image3d< size_t > &in, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Erosion (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template<class T >
void LocalErosion (const Image3d< T > &in, Image3d< T > &out, const Image3d< bool > &mask, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalErosion (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalErosion (const Image3d< bool > &in, Image3d< bool > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalErosion (const Image3d< size_t > &in, Image3d< size_t > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalErosion (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template<class T >
void Closing (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Closing (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Closing (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Closing (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &neib)
template<class T >
void LocalClosing (const Image3d< T > &in, Image3d< T > &out, const Image3d< bool > &mask, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalClosing (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalClosing (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalClosing (const Image3d< bool > &in, Image3d< bool > &out, const Image3d< bool > &, const Neighbourhood &neib)
template<class T >
void Closing (Image3d< T > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Closing (Image3d< GRAY8 > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Closing (Image3d< GRAY16 > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Closing (Image3d< bool > &in, const Neighbourhood &neib)
template<class T >
void Opening (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neigh)
template I3D_ALGO_EXPORT void Opening (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Opening (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Opening (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &neib)
template<class T >
void LocalOpening (const Image3d< T > &in, Image3d< T > &out, const Image3d< bool > &mask, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalOpening (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalOpening (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Image3d< bool > &, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void LocalOpening (const Image3d< bool > &in, Image3d< bool > &out, const Image3d< bool > &, const Neighbourhood &neib)
template<class T >
void Opening (Image3d< T > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Opening (Image3d< GRAY8 > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Opening (Image3d< GRAY16 > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Opening (Image3d< bool > &in, const Neighbourhood &neib)
template<class T >
void WhiteTopHat (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void WhiteTopHat (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void WhiteTopHat (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template<class T >
void BlackTopHat (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void BlackTopHat (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void BlackTopHat (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template<class T >
void TopHat (Image3d< T > &in, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void TopHat (Image3d< GRAY8 > &in, const Neighbourhood &neib)
template<class T >
void HitOrMiss (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &b, const Neighbourhood &w)
template I3D_ALGO_EXPORT void HitOrMiss (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &b, const Neighbourhood &w)
template<class T >
void Thinning (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &b, const Neighbourhood &w)
template I3D_ALGO_EXPORT void Thinning (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &b, const Neighbourhood &w)
template I3D_ALGO_EXPORT void Thinning (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &b, const Neighbourhood &w)
template<class T >
void Thicking (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &b, const Neighbourhood &w)
template I3D_ALGO_EXPORT void Thicking (const Image3d< bool > &in, Image3d< bool > &out, const Neighbourhood &b, const Neighbourhood &w)
template I3D_ALGO_EXPORT void Thicking (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &b, const Neighbourhood &w)
I3D_ALGO_EXPORT void Dilation (const Image3d< bool > &in, Image3d< bool > &out, const float radius)
I3D_ALGO_EXPORT void Erosion (const Image3d< bool > &in, Image3d< bool > &out, const float radius)
I3D_ALGO_EXPORT void Closing (const Image3d< bool > &in, Image3d< bool > &out, const float radius)
I3D_ALGO_EXPORT void Opening (const Image3d< bool > &in, Image3d< bool > &out, const float radius)
template<class T >
void Geodesic_dilation (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Geodesic_dilation (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template<class T >
void Geodesic_erosion (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void Geodesic_erosion (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template<class T >
void h_Max (const Image3d< T > &in, T h, Image3d< T > &out)
template I3D_ALGO_EXPORT void h_Max (const Image3d< GRAY8 > &in, GRAY8 h, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void h_Max (const Image3d< GRAY16 > &in, GRAY16 h, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void h_Max (const Image3d< float > &in, float h, Image3d< float > &out)
template<class T >
void HRA_h_Max (const Image3d< T > &in, T h, Image3d< T > &out)
template I3D_ALGO_EXPORT void HRA_h_Max (const Image3d< GRAY8 > &in, GRAY8 h, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void HRA_h_Max (const Image3d< GRAY16 > &in, GRAY16 h, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void HRA_h_Max (const Image3d< float > &in, float h, Image3d< float > &out)
template<class T >
void h_Convex (const Image3d< T > &in, T h, Image3d< T > &out)
template I3D_ALGO_EXPORT void h_Convex (const Image3d< GRAY8 > &in, GRAY8 h, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void h_Convex (const Image3d< GRAY16 > &in, GRAY16 h, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void h_Convex (const Image3d< float > &in, float h, Image3d< float > &out)
template<class T >
void r_Max_bysweeping (const Image3d< T > &in, Image3d< T > &out)
template I3D_ALGO_EXPORT void r_Max_bysweeping (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void r_Max_bysweeping (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void r_Max_bysweeping (const Image3d< size_t > &in, Image3d< size_t > &out)
template I3D_ALGO_EXPORT void r_Max_bysweeping (const Image3d< float > &in, Image3d< float > &out)
template<typename T , typename compFuncType >
static void r_Extrema (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib, const T value, size_t paddingSize)
template<typename T >
void r_Max (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Max (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Max (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Max (const Image3d< size_t > &in, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Max (const Image3d< float > &in, Image3d< float > &out, const Neighbourhood &neib)
template<typename T >
void HRA_r_Max (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Max (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Max (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Max (const Image3d< size_t > &in, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Max (const Image3d< float > &in, Image3d< float > &out, const Neighbourhood &neib)
template<typename T >
void r_Min (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Min (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Min (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Min (const Image3d< size_t > &in, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void r_Min (const Image3d< float > &in, Image3d< float > &out, const Neighbourhood &neib)
template<typename T >
void HRA_r_Min (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Min (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Min (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Min (const Image3d< size_t > &in, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_r_Min (const Image3d< float > &in, Image3d< float > &out, const Neighbourhood &neib)
template<class T >
void impose_minima (Image3d< T > &in_out, const Image3d< bool > &mask_bin)
template I3D_ALGO_EXPORT void impose_minima (Image3d< GRAY8 > &in_out, const Image3d< bool > &mask)
template I3D_ALGO_EXPORT void impose_minima (Image3d< GRAY16 > &in_out, const Image3d< bool > &mask)
template I3D_ALGO_EXPORT void impose_minima (Image3d< float > &in_out, const Image3d< bool > &mask)
template<class T >
void e_Max (const Image3d< T > &in, T h, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void e_Max (const Image3d< GRAY8 > &in, GRAY8 h, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void e_Max (const Image3d< GRAY16 > &in, GRAY16 h, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void e_Max (const Image3d< size_t > &in, size_t h, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void e_Max (const Image3d< float > &in, float h, Image3d< float > &out, const Neighbourhood &neib)
template<class T >
void HRA_e_Max (const Image3d< T > &in, T h, Image3d< T > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_e_Max (const Image3d< GRAY8 > &in, GRAY8 h, Image3d< GRAY8 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_e_Max (const Image3d< GRAY16 > &in, GRAY16 h, Image3d< GRAY16 > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_e_Max (const Image3d< size_t > &in, size_t h, Image3d< size_t > &out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void HRA_e_Max (const Image3d< float > &in, float h, Image3d< float > &out, const Neighbourhood &neib)
template<class T >
void Fillhole (const Image3d< T > &in, Image3d< T > &out)
template I3D_ALGO_EXPORT void Fillhole (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Fillhole (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Fillhole (const Image3d< float > &in, Image3d< float > &out)
template I3D_ALGO_EXPORT void Fillhole (const Image3d< double > &in, Image3d< double > &out)
template<class T , class F , class G >
void Reconstruction_by_DilEro (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, const Neighbourhood &neib, F func_f, G func_g)
template<class T , class F , class G >
void Reconstruction_by_DilEro (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, F func_f, G func_g)
template I3D_ALGO_EXPORT void Reconstruction_by_DilEro (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out, const Neighbourhood &neib, minimum< GRAY8 > func_f, maximum< GRAY8 > func_g)
template I3D_ALGO_EXPORT void Reconstruction_by_DilEro (const Image3d< bool > &marker, const Image3d< bool > &mask, Image3d< bool > &out, const Neighbourhood &neib, maximum< bool > func_f, minimum< bool > func_g)
template I3D_ALGO_EXPORT void Reconstruction_by_DilEro (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out, maximum< GRAY8 > func_f, minimum< GRAY8 > func_g)
template I3D_ALGO_EXPORT void Reconstruction_by_DilEro (const Image3d< GRAY16 > &marker, const Image3d< GRAY16 > &mask, Image3d< GRAY16 > &out, maximum< GRAY16 > func_f, minimum< GRAY16 > func_g)
template I3D_ALGO_EXPORT void Reconstruction_by_DilEro (const Image3d< float > &marker, const Image3d< float > &mask, Image3d< float > &out, maximum< float > func_f, minimum< float > func_g)
template<class T >
void Reconstruction_by_dilation (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, const Neighbourhood &neib)
template<class T >
void Reconstruction_by_dilation (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_dilation (const Image3d< float > &marker, const Image3d< float > &mask, Image3d< float > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_dilation (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_dilation (const Image3d< GRAY16 > &marker, const Image3d< GRAY16 > &mask, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_dilation (const Image3d< bool > &marker, const Image3d< bool > &mask, Image3d< bool > &out)
template<class T >
void Reconstruction_by_erosion (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, const Neighbourhood &neib)
template<class T >
void Reconstruction_by_erosion (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_erosion (const Image3d< float > &marker, const Image3d< float > &mask, Image3d< float > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_erosion (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_erosion (const Image3d< GRAY16 > &marker, const Image3d< GRAY16 > &mask, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void Reconstruction_by_erosion (const Image3d< bool > &marker, const Image3d< bool > &mask, Image3d< bool > &out)
template<class T >
void HRA_Reconstruction_by_dilation (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_dilation (const Image3d< float > &marker, const Image3d< float > &mask, Image3d< float > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_dilation (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_dilation (const Image3d< GRAY16 > &marker, const Image3d< GRAY16 > &mask, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_dilation (const Image3d< bool > &marker, const Image3d< bool > &mask, Image3d< bool > &out)
template<class T >
void HRA_Reconstruction_by_erosion (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_erosion (const Image3d< float > &marker, const Image3d< float > &mask, Image3d< float > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_erosion (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_erosion (const Image3d< GRAY16 > &marker, const Image3d< GRAY16 > &mask, Image3d< GRAY16 > &out)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_erosion (const Image3d< bool > &marker, const Image3d< bool > &mask, Image3d< bool > &out)
template<class T , class F , class G >
void HRA_Reconstruction_by_DilEro (const Image3d< T > &marker, const Image3d< T > &mask, Image3d< T > &out, F func_f, G func_g)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_DilEro (const Image3d< GRAY8 > &marker, const Image3d< GRAY8 > &mask, Image3d< GRAY8 > &out, maximum< GRAY8 > func_f, minimum< GRAY8 > func_g)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_DilEro (const Image3d< GRAY16 > &marker, const Image3d< GRAY16 > &mask, Image3d< GRAY16 > &out, maximum< GRAY16 > func_f, minimum< GRAY16 > func_g)
template I3D_ALGO_EXPORT void HRA_Reconstruction_by_DilEro (const Image3d< float > &marker, const Image3d< float > &mask, Image3d< float > &out, maximum< float > func_f, minimum< float > func_g)
template<class T , class F >
void DilEro (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib, F function)
template<class T , class F >
void LocalDilEro (const Image3d< T > &in, Image3d< T > &out, const Image3d< bool > &mask, const Neighbourhood &neib, F function)
template<class T1 , class T2 , class Pred >
void DiscreteDistance (const Image3d< T1 > &in, Image3d< T2 > &out, const Neighbourhood &neib, Pred p)
template I3D_ALGO_EXPORT void DiscreteDistance (const Image3d< bool > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib, less_than< bool > p)
template I3D_ALGO_EXPORT void DiscreteDistance (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib, less_than< GRAY8 > p)
template I3D_ALGO_EXPORT void DiscreteDistance (const Image3d< bool > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib, greater_than< bool > p)
template I3D_ALGO_EXPORT void DiscreteDistance (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const Neighbourhood &neib, greater_than< GRAY8 > p)
template I3D_ALGO_EXPORT void DiscreteDistance (const Image3d< bool > &in, Image3d< GRAY16 > &out, const Neighbourhood &neib, less_than< bool > p)
template<class T >
bool Correspond (std::vector< T * > &b, std::vector< T * > &w)
template<class T >
I3D_ALGO_EXPORT void DilationO (const Image3d< T > &in, Image3d< T > &out, const int radius_size)
template<class T >
I3D_ALGO_EXPORT void ErosionO (const Image3d< T > &in, Image3d< T > &out, const int radius_size)
template<class T >
I3D_ALGO_EXPORT void ClosingO (const Image3d< T > &in, Image3d< T > &out, const int radius_size)
template<class T >
I3D_ALGO_EXPORT void OpeningO (const Image3d< T > &in, Image3d< T > &out, const int radius_size)
template<class T >
I3D_ALGO_EXPORT void WhiteTopHatO (const Image3d< T > &in, Image3d< T > &out, const int radius_size)
template<class T >
I3D_ALGO_EXPORT void BlackTopHatO (const Image3d< T > &in, Image3d< T > &out, const int radius_size)
template I3D_ALGO_EXPORT void DilationO (const Image3d< bool > &in, Image3d< bool > &out, const int radius_size)
template I3D_ALGO_EXPORT void DilationO (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const int radius_size)
template I3D_ALGO_EXPORT void DilationO (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const int radius_size)
template I3D_ALGO_EXPORT void ErosionO (const Image3d< bool > &in, Image3d< bool > &out, const int radius_size)
template I3D_ALGO_EXPORT void ErosionO (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const int radius_size)
template I3D_ALGO_EXPORT void ErosionO (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const int radius_size)
template I3D_ALGO_EXPORT void ClosingO (const Image3d< bool > &in, Image3d< bool > &out, const int radius_size)
template I3D_ALGO_EXPORT void ClosingO (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const int radius_size)
template I3D_ALGO_EXPORT void ClosingO (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const int radius_size)
template I3D_ALGO_EXPORT void OpeningO (const Image3d< bool > &in, Image3d< bool > &out, const int radius_size)
template I3D_ALGO_EXPORT void OpeningO (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const int radius_size)
template I3D_ALGO_EXPORT void OpeningO (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const int radius_size)
template I3D_ALGO_EXPORT void WhiteTopHatO (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const int radius_size)
template I3D_ALGO_EXPORT void WhiteTopHatO (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const int radius_size)
template I3D_ALGO_EXPORT void BlackTopHatO (const Image3d< GRAY8 > &in, Image3d< GRAY8 > &out, const int radius_size)
template I3D_ALGO_EXPORT void BlackTopHatO (const Image3d< GRAY16 > &in, Image3d< GRAY16 > &out, const int radius_size)
template<class T >
I3D_ALGO_EXPORT void MaximaDynamic (const Image3d< T > &in, Image3d< bool > &out, const T dynamic)
template I3D_ALGO_EXPORT void MaximaDynamic (const Image3d< GRAY8 > &in, Image3d< bool > &out, const GRAY8 dynamic)
template I3D_ALGO_EXPORT void MaximaDynamic (const Image3d< GRAY16 > &in, Image3d< bool > &out, const GRAY16 dynamic)
template<class T , class F >
I3D_ALGO_EXPORT void LocalDilEro (const Image3d< T > &in, Image3d< T > &out, Image3d< bool > &, const Neighbourhood &neib, F function)
bool in_range (size_t coord, size_t max, int offset, size_t &how_long)
const Neighbourhood nb2D_4
const Neighbourhood 
nb2D_o4 (cube2d, 5)
const Neighbourhood nb2D_8
const Neighbourhood 
nb2D_o8 (cube2d, 9)
const Neighbourhood nb3D_6
const Neighbourhood 
nb3D_o6 (cube, 7)
const Neighbourhood nb3D_18
const Neighbourhood 
nb3D_o18 (cube, 19)
const Neighbourhood nb3D_26
const Neighbourhood 
nb3D_o26 (cube, 27)
std::ostream & operator<< (std::ostream &out, const Neighbourhood &n)
void ConstructBoxNeighbourhood (Neighbourhood &nb, double r1, double r2, double r3, bool include_origin=false)
template<class T >
size_t GetNbh (const Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, Neighbourhood &rnb)
template<class T >
size_t GetNbh (const Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool > &valid)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, Neighbourhood &rnb)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, Neighbourhood &rnb)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< GRAY16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, Neighbourhood &rnb)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, Neighbourhood &rnb)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool > &valid)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool > &valid)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< GRAY16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool > &valid)
template I3D_ALGO_EXPORT size_t GetNbh (const Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool > &valid)
template<class T >
void MakeWindow (Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< T * > &valid)
template<class T >
void MakeWindow (const Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const T * > &valid)
template I3D_ALGO_EXPORT void MakeWindow (Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool * > &valid)
template I3D_ALGO_EXPORT void MakeWindow (Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< GRAY8 * > &valid)
template I3D_ALGO_EXPORT void MakeWindow (Image3d< GRAY16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< GRAY16 * > &valid)
template I3D_ALGO_EXPORT void MakeWindow (Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< size_t * > &valid)
template I3D_ALGO_EXPORT void MakeWindow (Image3d< int > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< int * > &valid)
template<class T >
size_t GetWindow (Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< T * > &valid)
template<class T >
size_t GetWindow (const Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const T * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< GRAY8 * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< RGB > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< RGB * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< RGB16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< RGB16 * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< GRAY16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< GRAY16 * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< size_t * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< int > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< int * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (Image3d< float > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< float * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const bool * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const GRAY8 * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< RGB > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const RGB * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< RGB16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const RGB16 * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< GRAY16 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const GRAY16 * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const size_t * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< int > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const int * > &valid)
template I3D_ALGO_EXPORT size_t GetWindow (const Image3d< float > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const float * > &valid)
template<class T >
size_t GetFullWindow (Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< T * > &valid)
template<class T >
size_t GetFullWindow (const Image3d< T > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const T * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< bool * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< GRAY8 * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< size_t * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (const Image3d< bool > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const bool * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (const Image3d< GRAY8 > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const GRAY8 * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (const Image3d< size_t > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const size_t * > &valid)
template I3D_ALGO_EXPORT size_t GetFullWindow (const Image3d< unsigned short > &img, size_t x, size_t y, size_t z, const Neighbourhood &nb, std::vector< const unsigned short * > &valid)
template<class T >
GetMedian (const std::vector< const T * > &win)
template I3D_ALGO_EXPORT GRAY8 GetMedian (const std::vector< const GRAY8 * > &win)
template I3D_ALGO_EXPORT GRAY16 GetMedian (const std::vector< const GRAY16 * > &win)
template I3D_ALGO_EXPORT float GetMedian (const std::vector< const float * > &win)
 I3D_ALGO_EXPORT_DATA (extern const Neighbourhood) nb2D_4
template<class T >
void MoveFullWindow (std::vector< T * > &v)
template<class T >
void MoveWindow (std::vector< T * > &v)
template<class T >
void MoveWindow (std::vector< T * > &v, int shift)
template<class FLOATING_VOXEL >
FLOATING_VOXEL UpWindSchemeN (FLOATING_VOXEL c, FLOATING_VOXEL x1, FLOATING_VOXEL x2, FLOATING_VOXEL y1, FLOATING_VOXEL y2, FLOATING_VOXEL z1, FLOATING_VOXEL z2, FLOATING_VOXEL tau)
template<class FLOATING_VOXEL >
FLOATING_VOXEL UpWindSchemeP (FLOATING_VOXEL c, FLOATING_VOXEL x1, FLOATING_VOXEL x2, FLOATING_VOXEL y1, FLOATING_VOXEL y2, FLOATING_VOXEL z1, FLOATING_VOXEL z2, FLOATING_VOXEL tau)
void Pol2Cart (const PointSet< double > &p_in, PointSet< double > &p_out, Direction axis)
void Cart2Pol (const PointSet< double > &p_in, PointSet< double > &p_out, Direction axis)
void Cart2Spherical (const PointSet< double > &p_in, PointSet< double > &p_out)
void Spherical2Cart (const PointSet< double > &p_in, PointSet< double > &p_out)
template<class T >
std::ostream & operator<< (std::ostream &os, const Point3d< T > &p)
template<class T >
std::istream & operator>> (std::istream &is, Point3d< T > &p)
template<class T >
norm2 (const Point3d< T > &p)
template<class T >
dot_prod (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > vec_prod (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > operator- (const Point3d< T > &p)
template<class T >
double norm (const Point3d< T > &p)
template<class T >
double dist (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > min (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > max (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > abs (const Point3d< T > &p)
template<class T >
Point3d< T > operator+ (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > operator- (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > operator/ (const Point3d< T > &p1, const Point3d< T > &p2)
template<class T >
Point3d< T > operator* (const T &k, const Point3d< T > &p)
template<class T >
Point3d< T > operator* (const Point3d< T > &p, const T &k)
template<class T >
Point3d< T > operator/ (const T &k, const Point3d< T > &p)
template<class T >
Point3d< T > operator/ (const Point3d< T > &p, const T &k)
template<class T >
bool PointSetIsContinuous (void)
template<class T >
std::ostream & operator<< (std::ostream &os, const PointSet< T > &ps)
template<class T >
Point3d< T > CenterOfGravity (const PointSet< T > &ps)
template<class T >
void MedianFilter2D (const i3d::Image3d< T > &input, i3d::Image3d< T > &output, int radius)
template<class T >
void MedianFilter3D (const i3d::Image3d< T > &input, i3d::Image3d< T > &output, int lat_radius, int axi_radius)
template<class T >
void SeparableMedianFilter2D (const i3d::Image3d< T > &input, i3d::Image3d< T > &output, int radius)
template<class T >
void SeparableMedianFilter3D (const i3d::Image3d< T > &input, i3d::Image3d< T > &output, int lat_radius, int axi_radius)
template<typename T >
static T MedianFilterQuickSelect (T arr[], int n)
template<typename T >
I3D_ALGO_EXPORT void MedianFilter (const Image3d< T > &img_in, Image3d< T > &img_out, const Neighbourhood &neib)
template<class T >
I3D_ALGO_EXPORT void MedianFilter (const i3d::Image3d< T > &input, i3d::Image3d< T > &output, int lat_radius=1, int axi_radius=1)
template<class T >
I3D_ALGO_EXPORT void SeparableMedianFilter (const i3d::Image3d< T > &input, i3d::Image3d< T > &output, int lat_radius=1, int axi_radius=1)
template I3D_ALGO_EXPORT void MedianFilter (const Image3d< GRAY8 > &img_in, Image3d< GRAY8 > &img_out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void MedianFilter (const Image3d< GRAY16 > &img_in, Image3d< GRAY16 > &img_out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void MedianFilter (const Image3d< float > &img_in, Image3d< float > &img_out, const Neighbourhood &neib)
template I3D_ALGO_EXPORT void MedianFilter (const i3d::Image3d< i3d::GRAY8 > &input, i3d::Image3d< i3d::GRAY8 > &output, int lat_radius, int axi_radius)
template I3D_ALGO_EXPORT void MedianFilter (const i3d::Image3d< i3d::GRAY16 > &input, i3d::Image3d< i3d::GRAY16 > &output, int lat_radius, int axi_radius)
template I3D_ALGO_EXPORT void MedianFilter (const i3d::Image3d< float > &input, i3d::Image3d< float > &output, int lat_radius, int axi_radius)
template I3D_ALGO_EXPORT void SeparableMedianFilter (const i3d::Image3d< i3d::GRAY8 > &input, i3d::Image3d< i3d::GRAY8 > &output, int lat_radius, int axi_radius)
template I3D_ALGO_EXPORT void SeparableMedianFilter (const i3d::Image3d< i3d::GRAY16 > &input, i3d::Image3d< i3d::GRAY16 > &output, int lat_radius, int axi_radius)
template I3D_ALGO_EXPORT void SeparableMedianFilter (const i3d::Image3d< float > &input, i3d::Image3d< float > &output, int lat_radius, int axi_radius)
void analyze (const std::vector< Vector3d< int > > &SE, std::vector< Vector3d< int > > &oldPoints, std::vector< Vector3d< int > > &newPoints, Vector3d< int > &direction, Vector3d< int > &SEmin, Vector3d< int > &SEmax)
template<typename T >
void rankFilterByHistogram (const i3d::Image3d< T > &imgIn, i3d::Image3d< T > &imgOut, Neighbourhood &SEin, int rank)
template I3D_ALGO_EXPORT void rankFilterByHistogram (const i3d::Image3d< i3d::GRAY8 > &imgIn, i3d::Image3d< i3d::GRAY8 > &imgOut, Neighbourhood &SEin, int rank)
template I3D_ALGO_EXPORT void rankFilterByHistogram (const i3d::Image3d< i3d::GRAY16 > &imgIn, i3d::Image3d< i3d::GRAY16 > &imgOut, Neighbourhood &SEin, int rank)
static void Restrict (const Neighbourhood &nb, Neighbourhood &rnb)
template<class LABEL >
static void AdjustL2R (std::vector< LABEL > &l2r, std::list< LABEL > &l, LABEL new_r)
template<class LABEL , class VOXEL >
static void GetLabels (const VOXEL v, const std::vector< VOXEL * > &win1, const std::vector< LABEL * > &win2, std::vector< LABEL > &val)
template<class LABEL >
static void ComputeTransitiveClosure (std::map< LABEL, std::set< LABEL > > &neigh_list, std::vector< LABEL > &remap_list)
template<class ORIGVOXEL , class LABEL , class VOXEL >
bool WeightedCenter (const Image3d< ORIGVOXEL > &img, const LabeledImage3d< LABEL, VOXEL > &labels, LABEL label, Vector3d< float > &center)
template I3D_ALGO_EXPORT bool WeightedCenter (const Image3d< GRAY8 > &, const LabeledImage3d< size_t, bool > &, size_t, Vector3d< float > &)
template I3D_ALGO_EXPORT bool WeightedCenter (const Image3d< GRAY8 > &, const LabeledImage3d< size_t, GRAY8 > &, size_t, Vector3d< float > &)
template I3D_ALGO_EXPORT bool WeightedCenter (const Image3d< GRAY8 > &, const LabeledImage3d< bool, bool > &, bool, Vector3d< float > &)
template I3D_ALGO_EXPORT bool WeightedCenter (const Image3d< GRAY8 > &, const LabeledImage3d< unsigned short, bool > &, unsigned short, Vector3d< float > &)
template I3D_ALGO_EXPORT bool WeightedCenter (const Image3d< GRAY16 > &, const LabeledImage3d< unsigned short, bool > &, unsigned short, Vector3d< float > &)
template I3D_ALGO_EXPORT bool WeightedCenter (const Image3d< GRAY16 > &, const LabeledImage3d< size_t, GRAY16 > &, size_t, Vector3d< float > &)
template<class LABEL , class VOXEL >
bool Center (const LabeledImage3d< LABEL, VOXEL > &labels, LABEL label, Vector3d< float > &center)
template I3D_ALGO_EXPORT bool Center (const LabeledImage3d< size_t, bool > &, size_t, Vector3d< float > &)
template I3D_ALGO_EXPORT bool Center (const LabeledImage3d< size_t, GRAY8 > &, size_t, Vector3d< float > &)
template I3D_ALGO_EXPORT bool Center (const LabeledImage3d< bool, bool > &, bool, Vector3d< float > &)
template<class LABEL , class VOXEL >
double Surface (const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label, size_t &volume)
template I3D_ALGO_EXPORT double Surface (const LabeledImage3d< size_t, GRAY8 > &, size_t, size_t &)
template I3D_ALGO_EXPORT double Surface (const LabeledImage3d< size_t, bool > &, size_t, size_t &)
template I3D_ALGO_EXPORT double Surface (const LabeledImage3d< bool, bool > &, bool, size_t &)
template I3D_ALGO_EXPORT double Surface (const LabeledImage3d< GRAY16, bool > &, GRAY16, size_t &)
template<class LABEL , class VOXEL >
double Roundness (const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label)
template I3D_ALGO_EXPORT double Roundness (const LabeledImage3d< size_t, GRAY8 > &, size_t)
template<class LABEL , class VOXEL >
double RoundnessFactor (const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label, const Vector3d< float > &wcenter, double volume=-1)
template I3D_ALGO_EXPORT double RoundnessFactor (const LabeledImage3d< GRAY16, bool > &limg, GRAY16 label, const Vector3d< float > &wcenter, double volume)
template<class LABEL , class VOXEL >
Boundary GetComponentBoundary (const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label)
template I3D_ALGO_EXPORT Boundary GetComponentBoundary (const LabeledImage3d< size_t, GRAY8 > &, size_t)
template<class LABEL , class VOXEL >
void Radius (const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label, const Vector3d< float > &center, float &min, float &max, float &mean)
template I3D_ALGO_EXPORT void Radius (const LabeledImage3d< size_t, GRAY8 > &, size_t, const Vector3d< float > &, float &, float &, float &)
template<class ORIGVOXEL , class LABEL , class VOXEL >
void IntensityHist (const Image3d< ORIGVOXEL > &img, const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label, Histogram &hist)
template I3D_ALGO_EXPORT void IntensityHist (const Image3d< GRAY8 > &, const LabeledImage3d< size_t, GRAY8 > &, size_t, Histogram &)
template<class ORIGVOXEL , class LABEL , class VOXEL >
void MinMaxComponentValue (const Image3d< ORIGVOXEL > &img, const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label, ORIGVOXEL &min, ORIGVOXEL &max)
template I3D_ALGO_EXPORT void MinMaxComponentValue (const Image3d< float > &, const LabeledImage3d< size_t, GRAY8 > &, size_t, float &, float &)
template I3D_ALGO_EXPORT void MinMaxComponentValue (const Image3d< float > &, const LabeledImage3d< GRAY16, bool > &, GRAY16, float &, float &)
template<class ORIGVOXEL , class LABEL , class VOXEL , class Predicate >
void RemoveComponents (Image3d< ORIGVOXEL > &img, const LabeledImage3d< LABEL, VOXEL > &limg, Predicate &pred)
template I3D_ALGO_EXPORT void RemoveComponents (Image3d< GRAY8 > &, const LabeledImage3d< size_t, GRAY8 > &, ComponentToRemove< size_t, GRAY8 > &)
template I3D_ALGO_EXPORT void RemoveComponents (Image3d< GRAY16 > &, const LabeledImage3d< size_t, GRAY16 > &, ComponentToRemove< size_t, GRAY16 > &)
template<class ORIGVOXEL , class LABEL , class VOXEL , class Predicate >
void EraseComponents (Image3d< ORIGVOXEL > &img, LabeledImage3d< LABEL, VOXEL > &limg, Predicate &pred)
template I3D_ALGO_EXPORT void EraseComponents (Image3d< bool > &, LabeledImage3d< GRAY16, bool > &, ComponentToRemove< GRAY16, bool > &)
template I3D_ALGO_EXPORT void EraseComponents (Image3d< GRAY16 > &, LabeledImage3d< size_t, GRAY16 > &, ComponentToRemove< size_t, GRAY16 > &)
bool HasIntersection (const VOI< UPIXELS > &img_voi, const VOI< UPIXELS > &obj_voi, bool bdr_x, bool bdr_y, bool bdr_z)
template<class LABEL , class VOXEL >
void bbox_init_and_copy (Image3d< LABEL > &tmp, const LabeledImage3d< LABEL, VOXEL > &limg, const VOI< UPIXELS > &bbox, const LABEL pvalue)
template<class LABEL >
std::vector< Vector3d< float > > * ExtractBorderPoints (const Image3d< LABEL > &img, const Vector3d< size_t > &offset)
template<class LABEL , class VOXEL >
components_distance_matrixCreateDistMatrix (const LabeledImage3d< LABEL, VOXEL > &limgA, const LabeledImage3d< LABEL, VOXEL > &limgB, const double max_dist=DMAX)
static void MC_BuildPerimeterLookup (const Vector3d< float > &res, double *lt)
void MC_BuildSurfaceLookup (const Vector3d< float > &res, double *lt)
static void MC_BuildAreaLookup (const Vector3d< float > &res, double *lt)
void MC_BuildVolumeLookup (const Vector3d< float > &res, double *lt)
template<class LABEL , class VOXEL >
double MC_Estimate (const LabeledImage3d< LABEL, VOXEL > &limg, LABEL label, McEstimateType type)
template I3D_ALGO_EXPORT double MC_Estimate (const LabeledImage3d< size_t, bool > &, size_t, McEstimateType)
template I3D_ALGO_EXPORT double MC_Estimate (const LabeledImage3d< GRAY16, bool > &, GRAY16, McEstimateType)
template I3D_ALGO_EXPORT double MC_Estimate (const LabeledImage3d< GRAY16, GRAY16 > &, GRAY16, McEstimateType)
template struct
I3D_ALGO_EXPORT
components_distance_matrix
CreateDistMatrix (const LabeledImage3d< size_t, bool > &, const LabeledImage3d< size_t, bool > &, const double)
template struct
I3D_ALGO_EXPORT
components_distance_matrix
CreateDistMatrix (const LabeledImage3d< size_t, GRAY8 > &, const LabeledImage3d< size_t, GRAY8 > &, const double)
template I3D_ALGO_EXPORT void bbox_init_and_copy (Image3d< size_t > &tmp, const LabeledImage3d< size_t, GRAY8 > &limg, const VOI< UPIXELS > &bbox, const size_t pvalue)
template I3D_ALGO_EXPORT
std::vector< Vector3d< float > > * 
ExtractBorderPoints (const Image3d< size_t > &img, const Vector3d< size_t > &offset)
template<class LABEL , class VOXEL >
std::ostream & operator<< (std::ostream &o, const ComponentInfo< LABEL, VOXEL > &ci)
template<class Index , class Container , class Predicate >
void Remove (std::map< Index, Container > &cont, Predicate pred)
template<class Container >
void RemoveBlack (std::map< size_t, Container > &cont)
template<class Image , class LImage , class Component , class Object , class Predicate >
void CreateObjectsFromComponents (const Image &img, const LImage &limg, const std::map< size_t, Component > &components, std::map< size_t, Object > &objects, Predicate pred)
template<class VOXEL >
I3D_ALGO_EXPORT std::vector
< Vector3d< float > > * 
ExtractBorderPoints (const Image3d< VOXEL > &img, const Vector3d< size_t > &offset)
bool SegmentNuclei2d (const Image3d< i3d::GRAY16 > &in, Image3d< i3d::GRAY16 > &out, const SNR_Params &params)
void CreateLUT (std::vector< bool > &table)
size_t IndexUD (const Image3d< unsigned char > &img, const Vector3d< size_t > &point)
size_t IndexNS (const Image3d< unsigned char > &img, const Vector3d< size_t > &point)
size_t IndexEW (const Image3d< unsigned char > &img, const Vector3d< size_t > &point)
bool IsBorderPoint (const Image3d< uchar > &img, const Vector3d< size_t > &point)
bool IsDeletable (const Image3d< unsigned char > &img, Vector3d< size_t > &point, const std::vector< bool > &table)
size_t ThinningIter (std::list< Vector3d< size_t > > &border, Image3d< uchar > &img, const std::vector< bool > &table)
void I3D_ALGO_EXPORT Thinning (Image3d< bool > &img)
bool IsDeletable (const Image3d< unsigned char > &img, const Vector3d< size_t > &point, const std::vector< bool > &table)
template<class T >
void Threshold (Image3d< T > &i, T t1, T t2=std::numeric_limits< T >::max(), T lower_value=std::numeric_limits< T >::min(), T upper_value=std::numeric_limits< T >::max())
template<class VOXELIN , class VOXELOUT >
void Threshold (const Image3d< VOXELIN > &imgin, Image3d< VOXELOUT > &imgout, VOXELIN t1, VOXELIN t2=std::numeric_limits< VOXELIN >::max())
template<class VOXELIN , class VOXELOUT , class TF >
void Threshold (const Image3d< VOXELIN > &imgin, Image3d< VOXELOUT > &imgout, const TF &tf)
void InitDivisionPoints (std::vector< size_t > &div, size_t sz, size_t n)
void RecomputeDivisionPoints (std::vector< size_t > &div)
template<class VOXELIN , class VOXELOUT >
void SemiThreshold (const Image3d< VOXELIN > &imgin, Image3d< VOXELOUT > &imgout, VOXELIN t)
float compute_sigma2 (const std::vector< float > &omega, const std::vector< float > &mu)
bool ComputeMultilevelOtsuThresholds (const Histogram &hist, size_t k, std::vector< int > &thresholds)
template<class VOXEL >
void DoMultilevelThresholding (const Image3d< VOXEL > &img, Image3d< GRAY8 > &imgout, const std::vector< int > &thresholds)
template void DoMultilevelThresholding (const Image3d< GRAY8 > &img, Image3d< GRAY8 > &imgout, const std::vector< int > &thresholds)
template void DoMultilevelThresholding (const Image3d< GRAY16 > &img, Image3d< GRAY8 > &imgout, const std::vector< int > &thresholds)
template<class T , class OUTVOXEL , class TF >
void LocalThreshold (const Image3d< T > &, Image3d< OUTVOXEL > &, size_t nx, size_t ny, size_t nz, const TF &)
template I3D_ALGO_EXPORT void Threshold (Image3d< GRAY8 > &, GRAY8, GRAY8, GRAY8, GRAY8)
template I3D_ALGO_EXPORT void Threshold (Image3d< GRAY16 > &, GRAY16, GRAY16, GRAY16, GRAY16)
template I3D_ALGO_EXPORT void Threshold (Image3d< size_t > &, size_t, size_t, size_t, size_t)
template I3D_ALGO_EXPORT void Threshold (Image3d< float > &, float, float, float, float)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY8 > &, Image3d< bool > &, GRAY8, GRAY8)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, GRAY8, GRAY8)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY16 > &, Image3d< GRAY16 > &, GRAY16, GRAY16)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY16 > &, Image3d< bool > &, GRAY16, GRAY16)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY16 > &, Image3d< size_t > &, GRAY16, GRAY16)
template I3D_ALGO_EXPORT void Threshold (const Image3d< float > &, Image3d< float > &, float, float)
template I3D_ALGO_EXPORT void Threshold (const Image3d< float > &, Image3d< bool > &, float, float)
template I3D_ALGO_EXPORT void Threshold (const Image3d< double > &, Image3d< bool > &, double, double)
template I3D_ALGO_EXPORT void Threshold (const Image3d< size_t > &, Image3d< bool > &, size_t, size_t)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY8 > &, Image3d< bool > &, const MaxPlusKDeltaFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY8 > &, Image3d< bool > &, const UnimodalThresholdFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY8 > &, Image3d< bool > &, const OtsuThresholdFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY16 > &, Image3d< bool > &, const MaxPlusKDeltaFinder< GRAY16 > &)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY16 > &, Image3d< bool > &, const UnimodalThresholdFinder< GRAY16 > &)
template I3D_ALGO_EXPORT void Threshold (const Image3d< GRAY16 > &, Image3d< bool > &, const OtsuThresholdFinder< GRAY16 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY8 > &, Image3d< GRAY8 > &out, size_t, size_t, size_t, const MaxPlusKDeltaFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY8 > &, Image3d< bool > &out, size_t, size_t, size_t, const MaxPlusKDeltaFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY16 > &, Image3d< bool > &out, size_t, size_t, size_t, const MaxPlusKDeltaFinder< GRAY16 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY8 > &, Image3d< GRAY8 > &out, size_t, size_t, size_t, const OtsuThresholdFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY8 > &, Image3d< bool > &out, size_t, size_t, size_t, const OtsuThresholdFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY16 > &, Image3d< bool > &out, size_t, size_t, size_t, const OtsuThresholdFinder< GRAY16 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY8 > &, Image3d< GRAY8 > &out, size_t, size_t, size_t, const UnimodalThresholdFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY8 > &, Image3d< bool > &out, size_t, size_t, size_t, const UnimodalThresholdFinder< GRAY8 > &)
template I3D_ALGO_EXPORT void LocalThreshold (const Image3d< GRAY16 > &, Image3d< bool > &out, size_t, size_t, size_t, const UnimodalThresholdFinder< GRAY16 > &)
template<class VOXELIN , class VOXELOUT , class PREC >
void GibouFedkiw (const Image3d< VOXELIN > &src, Image3d< VOXELOUT > &dst, PREC fg_weight, PREC bg_weight, PREC &fg_mean, PREC &bg_mean, size_t max_iter=30)
template I3D_ALGO_EXPORT void GibouFedkiw (const Image3d< GRAY8 > &src, Image3d< bool > &dst, float fg_weight, float bg_weight, float &fg_mean, float &bg_mean, size_t max_iter)
template I3D_ALGO_EXPORT void GibouFedkiw (const Image3d< GRAY8 > &src, Image3d< bool > &dst, double fg_weight, double bg_weight, double &fg_mean, double &bg_mean, size_t max_iter)
template I3D_ALGO_EXPORT void GibouFedkiw (const Image3d< GRAY16 > &src, Image3d< bool > &dst, float fg_weight, float bg_weight, float &fg_mean, float &bg_mean, size_t max_iter)
template I3D_ALGO_EXPORT void GibouFedkiw (const Image3d< GRAY16 > &src, Image3d< bool > &dst, double fg_weight, double bg_weight, double &fg_mean, double &bg_mean, size_t max_iter)
template I3D_ALGO_EXPORT void GibouFedkiw (const Image3d< float > &src, Image3d< bool > &dst, float fg_weight, float bg_weight, float &fg_mean, float &bg_mean, size_t max_iter)
template I3D_ALGO_EXPORT void GibouFedkiw (const Image3d< double > &src, Image3d< bool > &dst, double fg_weight, double bg_weight, double &fg_mean, double &bg_mean, size_t max_iter)
template<class NUMBER >
void allocate (NUMBER *&address, unsigned long int count, const char *var_name, const char *function_name)
template<class WHATEVER >
void single_allocate (WHATEVER *&address, const char *var_name, const char *function_name)
template<class VOXEL >
void RemapIntensities (Image3d< VOXEL > &img, std::vector< VOXEL > &map_fun)
template<class VOXEL >
void MirrorRow (const VOXEL *&in_ptr, VOXEL *&out_ptr, size_t row_size)
template<class VOXEL >
void MirrorSlice (const VOXEL *&in_ptr, VOXEL *&out_ptr, size_t row_size, size_t column_size)
template<class VOXEL >
void Mirror (const Image3d< VOXEL > &in, Image3d< VOXEL > &out)
template<class T >
void Resample (const Image3d< T > &src, Image3d< T > &dest, const Vector3d< size_t > &v, SamplingMode m)
template<class T >
void Resample (const Image3d< T > &src, Image3d< T > &dest, size_t new_x, size_t new_y, size_t new_z, SamplingMode m=NEAREST_NEIGHBOUR)
template<class T >
void Resize (const Image3d< T > &src, Image3d< T > &dest, size_t new_x, size_t new_y, size_t new_z, SamplingMode m=NEAREST_NEIGHBOUR)
template<class T >
void ResizeInMicrons (const Image3d< T > &src, Image3d< T > &dest, float new_x, float new_y, float new_z, SamplingMode m)
RGB max (const RGB &v1, const RGB &v2)
template<class T >
I3D_ALGO_EXPORT void CopySlice (const Image3d< T > &slc, Image3d< T > &img, size_t z)
template<class T >
void Resize (const Image3d< T > &src, Image3d< T > &dest, const Vector3d< size_t > &v, SamplingMode m)
template<class T >
void ResizeInMicrons (const Image3d< T > &src, Image3d< T > &dest, const Vector3d< float > &size, SamplingMode m)
template<class VOXEL >
void Get_AF_XY (const Image3d< VOXEL > &src, Image3d< VOXEL > &dest)
template<class VOXEL >
void Get_AF_XZ (const Image3d< VOXEL > &src, Image3d< VOXEL > &dest)
template<class VOXEL >
void Get_AF_YZ (const Image3d< VOXEL > &src, Image3d< VOXEL > &dest)
template<class LABEL , class VOXEL >
void Get_Labeled_AF_XY (const LabeledImage3d< LABEL, VOXEL > &src, Image3d< LABEL > &dest, const bool vis[], bool only_boundary)
template<class LABEL , class VOXEL >
void Get_Labeled_AF_XZ (const LabeledImage3d< LABEL, VOXEL > &src, Image3d< LABEL > &dest, const bool vis[], bool only_boundary)
template<class LABEL , class VOXEL >
void Get_Labeled_AF_YZ (const LabeledImage3d< LABEL, VOXEL > &src, Image3d< LABEL > &dest, const bool vis[], bool only_boundary)
static float ComputeFrom (float srcOff, float dstOff, float dstRes)
static float ComputeTo (float srcOff, size_t srcWidth, float srcRes, float dstOff, size_t dstWidth, float dstRes)
template<class VOXEL >
void CopyToImage (const i3d::Image3d< VOXEL > &src, i3d::Image3d< VOXEL > &dst)
template<class VOXEL >
I3D_ALGO_EXPORT void GetResampledSubimage (const Image3d< VOXEL > &src, Image3d< VOXEL > &dest, const VOI< PIXELS > &ivoi, const Vector3d< size_t > &size)
template<class VOXEL >
float * ImgToFloat (Image3d< VOXEL > &im)
template<class VOXEL >
void FloatToImg (Image3d< VOXEL > &im, float *fi)
template<class VOXEL >
void AffineTransform (Image3d< VOXEL > &img, const double matrix[4][4], const Vector3d< double > &origin, int degree=0, VOXEL bgcol=0, bool use_resolution=false)
template<class T2 , class PRED >
void MapCondColor (const Image3d< T2 > &Iin, Image3d< T2 > &Iout, PRED pred, T2 color, const int direction)
template<class T1 , class T2 >
void MapColor (const Image3d< T1 > &Iselect, const Image3d< T2 > &Imask, Image3d< RGB > &Iout, const std::vector< RGB > &rgb_map)
double sinc (double x)
double lanczos_windowed_sinc (double x, int n)
template<class VOXEL >
void lanczos_resample (const Image3d< VOXEL > *input, Image3d< VOXEL > *&output, const float factor[3], const int n)
template<class VOXEL >
void lanczos_resample (const Image3d< VOXEL > *input, Image3d< VOXEL > *&output, const Vector3d< float > factor, const int n)
template<class VOXEL >
void ResampleToDesiredResolution (Image3d< VOXEL > &img, const Resolution &res, SamplingMode m)
template<class VOXEL >
void ResampleToDesiredResolution (Image3d< VOXEL > &image, float xRes, float yRes, float zRes, SamplingMode m)
template I3D_ALGO_EXPORT void Resample (const Image3d< float > &, Image3d< float > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< GRAY16 > &, Image3d< GRAY16 > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< RGB > &, Image3d< RGB > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< RGB16 > &, Image3d< RGB16 > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< RGB > &src, Image3d< RGB > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< RGB > &src, Image3d< RGB > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< RGB > &src, Image3d< RGB > &dest)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< RGB16 > &src, Image3d< RGB16 > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< RGB16 > &src, Image3d< RGB16 > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< RGB16 > &src, Image3d< RGB16 > &dest)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< GRAY8 > &src, Image3d< GRAY8 > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< GRAY8 > &src, Image3d< GRAY8 > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< GRAY8 > &src, Image3d< GRAY8 > &dest)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< GRAY16 > &src, Image3d< GRAY16 > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< GRAY16 > &src, Image3d< GRAY16 > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< GRAY16 > &src, Image3d< GRAY16 > &dest)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< bool > &src, Image3d< bool > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< bool > &src, Image3d< bool > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< bool > &src, Image3d< bool > &dest)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< float > &src, Image3d< float > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< float > &src, Image3d< float > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< float > &src, Image3d< float > &dest)
template I3D_ALGO_EXPORT void Get_AF_XY (const Image3d< int > &src, Image3d< int > &dest)
template I3D_ALGO_EXPORT void Get_AF_XZ (const Image3d< int > &src, Image3d< int > &dest)
template I3D_ALGO_EXPORT void Get_AF_YZ (const Image3d< int > &src, Image3d< int > &dest)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XY (const LabeledImage3d< size_t, GRAY8 > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XZ (const LabeledImage3d< size_t, GRAY8 > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_YZ (const LabeledImage3d< size_t, GRAY8 > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XY (const LabeledImage3d< byte, GRAY8 > &src, Image3d< byte > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XZ (const LabeledImage3d< byte, GRAY8 > &src, Image3d< byte > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_YZ (const LabeledImage3d< byte, GRAY8 > &src, Image3d< byte > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XY (const LabeledImage3d< size_t, bool > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XZ (const LabeledImage3d< size_t, bool > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_YZ (const LabeledImage3d< size_t, bool > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XY (const LabeledImage3d< byte, bool > &src, Image3d< byte > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XZ (const LabeledImage3d< byte, bool > &src, Image3d< byte > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_YZ (const LabeledImage3d< byte, bool > &src, Image3d< byte > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XY (const LabeledImage3d< size_t, GRAY16 > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XZ (const LabeledImage3d< size_t, GRAY16 > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_YZ (const LabeledImage3d< size_t, GRAY16 > &src, Image3d< size_t > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XY (const LabeledImage3d< GRAY16, bool > &src, Image3d< GRAY16 > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_XZ (const LabeledImage3d< GRAY16, bool > &src, Image3d< GRAY16 > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void Get_Labeled_AF_YZ (const LabeledImage3d< GRAY16, bool > &src, Image3d< GRAY16 > &dest, const bool vis[], bool only_boundary)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< float > &src, Image3d< float > &dst)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< GRAY16 > &src, Image3d< GRAY16 > &dst)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< GRAY8 > &src, Image3d< GRAY8 > &dst)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< RGB > &src, Image3d< RGB > &dst)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< RGB16 > &src, Image3d< RGB16 > &dst)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< size_t > &src, Image3d< size_t > &dst)
template I3D_ALGO_EXPORT void CopyToImage (const Image3d< int > &src, Image3d< int > &dst)
template I3D_ALGO_EXPORT void GetResampledSubimage (const Image3d< GRAY8 > &src, Image3d< GRAY8 > &dest, const VOI< PIXELS > &ivoi, const Vector3d< size_t > &size)
template I3D_ALGO_EXPORT void GetResampledSubimage (const Image3d< RGB > &src, Image3d< RGB > &dest, const VOI< PIXELS > &ivoi, const Vector3d< size_t > &size)
template I3D_ALGO_EXPORT void CopySlice (const Image3d< GRAY8 > &slc, Image3d< GRAY8 > &img, size_t z)
template I3D_ALGO_EXPORT void CopySlice (const Image3d< GRAY16 > &slc, Image3d< GRAY16 > &img, size_t z)
template I3D_ALGO_EXPORT void CopySlice (const Image3d< float > &slc, Image3d< float > &img, size_t z)
template I3D_ALGO_EXPORT void CopySlice (const Image3d< RGB > &slc, Image3d< RGB > &img, size_t z)
template I3D_ALGO_EXPORT void CopySlice (const Image3d< RGB16 > &slc, Image3d< RGB16 > &img, size_t z)
template I3D_ALGO_EXPORT void CopySlice (const Image3d< bool > &slc, Image3d< bool > &img, size_t z)
template I3D_ALGO_EXPORT void MapColor (const Image3d< GRAY8 > &, const Image3d< GRAY8 > &, Image3d< RGB > &, const std::vector< RGB > &)
template I3D_ALGO_EXPORT void MapColor (const Image3d< size_t > &, const Image3d< GRAY8 > &, Image3d< RGB > &, const std::vector< RGB > &)
template I3D_ALGO_EXPORT void MapCondColor (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, is_background< GRAY8 > pred, GRAY8 color, const int)
template I3D_ALGO_EXPORT void MapCondColor (const Image3d< size_t > &, Image3d< size_t > &, is_background< size_t > pred, size_t color, const int)
template I3D_ALGO_EXPORT void RemapIntensities (Image3d< GRAY8 > &img, std::vector< GRAY8 > &map_fun)
template I3D_ALGO_EXPORT void AffineTransform (Image3d< GRAY8 > &img, const double matrix[4][4], const Vector3d< double > &origin, int degree, GRAY8 bgcol, bool use_resolution)
template I3D_ALGO_EXPORT void AffineTransform (Image3d< GRAY16 > &img, const double matrix[4][4], const Vector3d< double > &origin, int degree, GRAY16 bgcol, bool use_resolution)
template I3D_ALGO_EXPORT void Mirror (const Image3d< GRAY8 > &, Image3d< GRAY8 > &)
template I3D_ALGO_EXPORT void Mirror (const Image3d< GRAY16 > &, Image3d< GRAY16 > &)
template I3D_ALGO_EXPORT void Mirror (const Image3d< float > &, Image3d< float > &)
template I3D_ALGO_EXPORT void Mirror (const Image3d< double > &, Image3d< double > &)
template I3D_ALGO_EXPORT void Mirror (const Image3d< bool > &, Image3d< bool > &)
template I3D_ALGO_EXPORT void Resample (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< GRAY16 > &, Image3d< GRAY16 > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< RGB > &, Image3d< RGB > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< RGB16 > &, Image3d< RGB16 > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resample (const Image3d< float > &, Image3d< float > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< float > &, Image3d< float > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< GRAY16 > &, Image3d< GRAY16 > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< RGB > &, Image3d< RGB > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< RGB16 > &, Image3d< RGB16 > &, size_t, size_t, size_t, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< GRAY16 > &, Image3d< GRAY16 > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< RGB > &, Image3d< RGB > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void Resize (const Image3d< bool > &, Image3d< bool > &, const Vector3d< size_t > &, SamplingMode)
template I3D_ALGO_EXPORT void ResizeInMicrons (const Image3d< GRAY8 > &, Image3d< GRAY8 > &, const Vector3d< float > &, SamplingMode)
template I3D_ALGO_EXPORT void ResizeInMicrons (const Image3d< RGB > &, Image3d< RGB > &, const Vector3d< float > &, SamplingMode)
template I3D_ALGO_EXPORT void ResizeInMicrons (const Image3d< RGB16 > &, Image3d< RGB16 > &, const Vector3d< float > &, SamplingMode)
template I3D_ALGO_EXPORT void RemapIntensities (Image3d< size_t > &img, std::vector< size_t > &map_fun)
template I3D_ALGO_EXPORT void RemapIntensities (Image3d< int > &img, std::vector< int > &map_fun)
template I3D_ALGO_EXPORT void RemapIntensities (Image3d< GRAY16 > &img, std::vector< GRAY16 > &map_fun)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< GRAY8 > *input, Image3d< GRAY8 > *&output, const float factor[3], const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< GRAY16 > *input, Image3d< GRAY16 > *&output, const float factor[3], const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< float > *input, Image3d< float > *&output, const float factor[3], const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< bool > *input, Image3d< bool > *&output, const float factor[3], const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< GRAY8 > *input, Image3d< GRAY8 > *&output, const Vector3d< float > factor, const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< GRAY16 > *input, Image3d< GRAY16 > *&output, const Vector3d< float > factor, const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< float > *input, Image3d< float > *&output, const Vector3d< float > factor, const int n)
template I3D_ALGO_EXPORT void lanczos_resample (const Image3d< bool > *input, Image3d< bool > *&output, const Vector3d< float > factor, const int n)
template I3D_ALGO_EXPORT void ResampleToDesiredResolution (Image3d< bool > &img, const Resolution &, SamplingMode m)
template I3D_ALGO_EXPORT void ResampleToDesiredResolution (Image3d< GRAY8 > &img, const Resolution &, SamplingMode m)
template I3D_ALGO_EXPORT void ResampleToDesiredResolution (Image3d< GRAY16 > &img, const Resolution &, SamplingMode m)
template I3D_ALGO_EXPORT void ResampleToDesiredResolution (Image3d< float > &img, const Resolution &, SamplingMode m)
template<class VOXEL >
I3D_ALGO_EXPORT void CopyToImage (const Image3d< VOXEL > &src, Image3d< VOXEL > &dest)
template<class VOXEL >
I3D_ALGO_EXPORT void ResampleToDesiredResolution (i3d::Image3d< VOXEL > &image, float xRes, float yRes, float zRes, SamplingMode m=LANCZOS)
template<class VOXEL >
I3D_ALGO_EXPORT void ResampleToDesiredResolution (i3d::Image3d< VOXEL > &image, const i3d::Resolution &res, SamplingMode m=LANCZOS)
template<typename T >
I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< T > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines=false)
template<typename T >
I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< T > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines=false)
template I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< i3d::GRAY8 > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines)
template I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< i3d::GRAY16 > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines)
template I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< float > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines)
template I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< i3d::GRAY8 > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines)
template I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< i3d::GRAY16 > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines)
template I3D_ALGO_EXPORT void WatershedBeucher (const Image3d< float > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood, bool drawWsLines)
template<typename T >
I3D_ALGO_EXPORT void WatershedContourDynamics (const Image3d< T > &input, const Image3d< size_t > &labels, Image3d< T > &saliencyMap, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedContourDynamics (const Image3d< i3d::GRAY8 > &input, const Image3d< size_t > &labels, Image3d< i3d::GRAY8 > &saliencyMap, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedContourDynamics (const Image3d< i3d::GRAY16 > &input, const Image3d< size_t > &labels, Image3d< i3d::GRAY16 > &saliencyMap, const Neighbourhood &neighbourhood)
template<class T >
void WatershedToboggan (const Image3d< T > &in, Image3d< int > &out, int connectivity, bool drawLines=false)
template I3D_ALGO_EXPORT void WatershedToboggan (const Image3d< i3d::GRAY8 > &in_grad, Image3d< int > &out, int connectivity, bool drawLines)
template I3D_ALGO_EXPORT void WatershedToboggan (const Image3d< i3d::GRAY16 > &in_grad, Image3d< int > &out, int connectivity, bool drawLines)
template I3D_ALGO_EXPORT void WatershedToboggan (const Image3d< float > &in_grad, Image3d< int > &out, int connectivity, bool drawLines)
template<class T >
void WatershedToboggan2D (const Image3d< T > &in, Image3d< int > &out, int connectivity)
template I3D_ALGO_EXPORT void WatershedToboggan2D (const Image3d< i3d::GRAY8 > &in_grad, Image3d< int > &out, int connectivity)
template I3D_ALGO_EXPORT void WatershedToboggan2D (const Image3d< i3d::GRAY16 > &in_grad, Image3d< int > &out, int connectivity)
template I3D_ALGO_EXPORT void WatershedToboggan2D (const Image3d< float > &in_grad, Image3d< int > &out, int connectivity)
template<class T >
void WatershedLin (const Image3d< T > &in, Image3d< int > &out, int connectivity, bool drawLines=false)
template I3D_ALGO_EXPORT void WatershedLin (const Image3d< i3d::GRAY8 > &in_grad, Image3d< int > &out, int connectivity, bool drawLines)
template I3D_ALGO_EXPORT void WatershedLin (const Image3d< i3d::GRAY16 > &in_grad, Image3d< int > &out, int connectivity, bool drawLines)
template I3D_ALGO_EXPORT void WatershedLin (const Image3d< float > &in_grad, Image3d< int > &out, int connectivity, bool drawLines)
template<class T >
void WatershedLin2D (const Image3d< T > &in, Image3d< int > &out, int connectivity)
template I3D_ALGO_EXPORT void WatershedLin2D (const Image3d< i3d::GRAY8 > &in_grad, Image3d< int > &out, int connectivity)
template I3D_ALGO_EXPORT void WatershedLin2D (const Image3d< i3d::GRAY16 > &in_grad, Image3d< int > &out, int connectivity)
template I3D_ALGO_EXPORT void WatershedLin2D (const Image3d< float > &in_grad, Image3d< int > &out, int connectivity)
template<typename T >
I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< T > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template<typename T >
I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< T > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< i3d::GRAY8 > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< i3d::GRAY16 > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< float > &input, const Image3d< size_t > &marker, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< i3d::GRAY8 > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< i3d::GRAY16 > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WatershedMeyer (const Image3d< float > &input, Image3d< size_t > &output, const Neighbourhood &neighbourhood)
template<typename T >
I3D_ALGO_EXPORT std::ostream & operator<< (std::ostream &ost, const SCompTreeTW< T > &compTree)
template<typename T >
I3D_ALGO_EXPORT std::ostream & operator<< (std::ostream &ost, const SCompTreeTW< T > *compTree)
template<typename T >
I3D_ALGO_EXPORT void WatershedTopological (const Image3d< T > &input, Image3d< T > &output, const Neighbourhood &neighbourhood, bool justMWS=false, Image3d< size_t > *labels=NULL)
template I3D_ALGO_EXPORT void WatershedTopological (const Image3d< i3d::GRAY8 > &input, Image3d< i3d::GRAY8 > &output, const Neighbourhood &neighbourhood, bool justMWS, Image3d< size_t > *labels)
template I3D_ALGO_EXPORT void WatershedTopological (const Image3d< i3d::GRAY16 > &input, Image3d< i3d::GRAY16 > &output, const Neighbourhood &neighbourhood, bool justMWS, Image3d< size_t > *labels)
template<typename T >
I3D_ALGO_EXPORT void WSInternalMarkerFromMinima (const Image3d< T > &input, Image3d< size_t > &marker, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WSInternalMarkerFromMinima (const Image3d< i3d::GRAY8 > &input, Image3d< size_t > &marker, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WSInternalMarkerFromMinima (const Image3d< i3d::GRAY16 > &input, Image3d< size_t > &marker, const Neighbourhood &neighbourhood)
template I3D_ALGO_EXPORT void WSInternalMarkerFromMinima (const Image3d< float > &input, Image3d< size_t > &marker, const Neighbourhood &neighbourhood)
Separable convolution
template<class VOXEL >
void PrepareZeroBoundaryForFilter (struct Separable3dFilter< VOXEL > const &filter, BorderPadding< VOXEL > &b)
template<class VOXEL >
I3D_ALGO_EXPORT int SeparableConvolution (Image3d< VOXEL > const &d, Image3d< VOXEL > &res, struct Separable3dFilter< VOXEL > const &f, struct BorderPadding< VOXEL > const &b)

Variables

const unsigned int NumOfCuts = 9
const int cuts [][3 *8]
struct I3D_ALGO_EXPORT SCompTreeNode
static edge edgeCases [16]
static int edgeVert [4][2] = {{0,1}, {1,3}, {2,3}, {0,2}}
static int mask [4] = {1,2,8,4}
const float max_saito = 100000000
const float max_DT = 10000
const float Infinity = 10000
static int Maska [42][3][3][3]
static int CompassSobel3DKernel [3][3][3] = {{{1,2,1},{2,4,2},{1,2,1}},{{0,0,0},{0,0,0},{0,0,0}},{{-1,-2,-1},{-2,-4,-2},{-1,-2,-1}}}
static int Prewitt3DKernel [3][3][3] = {{{1,1,1},{1,1,1},{1,1,1}},{{0,0,0},{0,0,0},{0,0,0}},{{-1,-1,-1},{-1,-1,-1},{-1,-1,-1}}}
static int Kirsch3DKernel [3][3][3] = {{{17,17,17},{17,17,17},{17,17,17}},{{-9,-9,-9},{-9,0,-9},{-9,-9,-9}},{{-9,-9,-9},{-9,-9,-9},{-9,-9,-9}}}
static int Robinson3DKernel [3][3][3] = {{{-1,-1,-1},{-1,-1,-1},{-1,-1,-1}},{{1,1,1},{1,-8,1},{1,1,1}},{{1,1,1},{1,1,1},{1,1,1}}}
static int XX [3][3][3] = {{{1,2,1},{2,4,2},{1,2,1}},{{0,0,0},{0,0,0},{0,0,0}},{{-1,-2,-1},{-2,-4,-2},{-1,-2,-1}}}
static int YY [3][3][3] = {{{-1,0,1},{-2,0,2},{-1,0,1}},{{-2,0,2},{-4,0,4},{-2,0,2}},{{-1,0,1},{-2,0,2},{-1,0,1}}}
static int ZZ [3][3][3] = {{{1,2,1},{0,0,0},{-1,-2,-1}},{{2,4,2},{0,0,0},{-2,-4,-2}},{{1,2,1},{0,0,0},{-1,-2,-1}}}
int X2D [3][3] = {{-1,-2,-1},{ 0,0,0},{1,2,1}}
int Y2D [3][3] = {{-1,0,1},{-2,0,2},{-1,0,1}}
static int K2D [8][3][3]
static int P2D [8][3][3]
static int R2D [8][3][3]
static int S2D [8][3][3]
template struct I3D_ALGO_EXPORT Filter< double >
template struct I3D_ALGO_EXPORT Filter< GRAY8 >
template struct I3D_ALGO_EXPORT Filter< GRAY16 >
template I3D_ALGO_EXPORT struct Separable3dFilter< float >
template I3D_ALGO_EXPORT struct Separable3dFilter< double >
template I3D_ALGO_EXPORT struct BorderPadding< float >
template I3D_ALGO_EXPORT struct BorderPadding< double >
struct I3D_ALGO_EXPORT SumOf
struct I3D_ALGO_EXPORT StrictSumOf
template class I3D_ALGO_EXPORT HRCA_LUT< GRAY8, GRAY8 >
template class I3D_ALGO_EXPORT HRCA_LUT< GRAY16, GRAY8 >
template class I3D_ALGO_EXPORT HRCA_LUT< GRAY8, GRAY16 >
template class I3D_ALGO_EXPORT HRCA_LUT< GRAY16, GRAY16 >
template class I3D_ALGO_EXPORT HRCA_LUT< GRAY8, RGB >
template class I3D_ALGO_EXPORT HRCA_LUT< GRAY16, RGB >
template class I3D_ALGO_EXPORT HRCA_LUT< size_t, RGB >
template class I3D_ALGO_EXPORT SpatialDerivatives< float >
template class I3D_ALGO_EXPORT ExplicitScheme< GRAY8, float >
template class I3D_ALGO_EXPORT PDESolver< GRAY8, float >
template class I3D_ALGO_EXPORT PDESolver< GRAY16, float >
template class I3D_ALGO_EXPORT MCFFilter< GRAY8, float >
template class I3D_ALGO_EXPORT PMFilter< GRAY8, float >
template class I3D_ALGO_EXPORT MCDEFilter< GRAY8, float >
template class I3D_ALGO_EXPORT PDESolver< float, float >
template class I3D_ALGO_EXPORT AOSCLMCFilter< GRAY8, float >
template class I3D_ALGO_EXPORT AOSTVFilter< float, float >
template class I3D_ALGO_EXPORT AOSTVFilter< GRAY8, float >
template class I3D_ALGO_EXPORT AOSTVFilter< GRAY16, float >
template class I3D_ALGO_EXPORT AOSPMFilter< GRAY8, float >
template class I3D_ALGO_EXPORT LODGaussianBlur< GRAY8, float >
template class I3D_ALGO_EXPORT LODGaussianBlur< float, float >
template class I3D_ALGO_EXPORT KMeansLS< GRAY8, float >
template class I3D_ALGO_EXPORT KMeansLS< float, float >
template class I3D_ALGO_EXPORT KMeansLS< GRAY16, float >
template class I3D_ALGO_EXPORT ThresholdActiveContours< GRAY8, float >
template class I3D_ALGO_EXPORT ThresholdActiveContours< float, float >
template class I3D_ALGO_EXPORT ThresholdActiveContours< double, double >
class I3D_ALGO_EXPORT LODGaussianBlur
template I3D_ALGO_EXPORT class less_than< bool >
template I3D_ALGO_EXPORT class less_than< GRAY8 >
template I3D_ALGO_EXPORT class greater_than< bool >
template I3D_ALGO_EXPORT class greater_than< GRAY8 >
const int cube []
const int cube2d []
template class I3D_ALGO_EXPORT PDE_Erosion< float >
template class I3D_ALGO_EXPORT PDE_Dilation< float >
template class I3D_ALGO_EXPORT Point3d< float >
template class I3D_ALGO_EXPORT Point3d< int >
template class I3D_ALGO_EXPORT ComponentToRemove< size_t, GRAY8 >
template class I3D_ALGO_EXPORT ComponentToRemove< size_t, GRAY16 >
template class I3D_ALGO_EXPORT ComponentToRemove< size_t, bool >
template class I3D_ALGO_EXPORT ComponentToRemove< GRAY8, bool >
template class I3D_ALGO_EXPORT ComponentToRemove< GRAY16, bool >
template class I3D_ALGO_EXPORT LabeledImage3d< size_t, GRAY8 >
template class I3D_ALGO_EXPORT LabeledImage3d< GRAY8, GRAY8 >
template class I3D_ALGO_EXPORT LabeledImage3d< size_t, bool >
template class I3D_ALGO_EXPORT LabeledImage3d< GRAY8, bool >
template class I3D_ALGO_EXPORT LabeledImage3d< GRAY16, bool >
template class I3D_ALGO_EXPORT LabeledImage3d< size_t, GRAY16 >
template class I3D_ALGO_EXPORT LabeledImage3d< GRAY8, GRAY16 >
template class I3D_ALGO_EXPORT LabeledImage3d< GRAY16, GRAY16 >
template class I3D_ALGO_EXPORT LabeledImage3d< int, bool >
template class I3D_ALGO_EXPORT MaxPlusKDeltaFinder< GRAY8 >
template class I3D_ALGO_EXPORT MaxPlusKDeltaFinder< GRAY16 >
template class I3D_ALGO_EXPORT UnimodalThresholdFinder< GRAY8 >
template class I3D_ALGO_EXPORT UnimodalThresholdFinder< GRAY16 >
template class I3D_ALGO_EXPORT OtsuThresholdFinder< GRAY8 >
template class I3D_ALGO_EXPORT OtsuThresholdFinder< GRAY16 >

Gauss filtering

struct I3D_ALGO_EXPORT Separable3dFilter
template<class VOXEL >
void SimpleGauss (Image3d< VOXEL > &img, double sigma=STD_SIGMA, bool exact=true)
Filter< double > MakeGaussFilter1D (double sigma, double widthFactor=3.0)
template<class VOXEL >
void Gauss (Image3d< VOXEL > &, double sigmax, double sigmay=0.0, double sigmaz=0.0, double widthFactor=3.0, bool exact=true)
template<class VOXEL >
void EstimateGaussKernel (struct Separable3dFilter< VOXEL > &filter, const VOXEL sigmaX, const VOXEL sigmaY, const VOXEL sigmaZ, const float widthX=3.0, const float widthY=3.0, const float widthZ=3.0)
template<class VOXEL >
void GaussIIR (Image3d< VOXEL > &img, const VOXEL Sigma)
template<class VOXEL , class PRECISION >
void GrayGaussIIR (Image3d< VOXEL > &img, const PRECISION Sigma)
template<class VOXEL >
void GaussIIR (Image3d< VOXEL > &img, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ)
template<class VOXEL , class PRECISION >
void GrayGaussIIR (Image3d< VOXEL > &img, const PRECISION SigmaX, const PRECISION SigmaY, const PRECISION SigmaZ)
template<class VOXEL >
I3D_ALGO_EXPORT void ApplyGauss1D (VOXEL *data, const std::slice &slc, Filter< double > &filter, Buffer &buf, bool divide=true)
template<class VOXEL >
I3D_ALGO_EXPORT void GaussFIR (Image3d< VOXEL > const &In, Image3d< VOXEL > &Out, const VOXEL Sigma, const float Width=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void GaussFIR (Image3d< VOXEL > &img, const VOXEL Sigma, const float Width=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void GaussFIR (Image3d< VOXEL > const &In, Image3d< VOXEL > &Out, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ, const float WidthX=3.0, const float WidthY=3.0, const float WidthZ=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void GaussFIR (Image3d< VOXEL > &img, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ, const float WidthX=3.0, const float WidthY=3.0, const float WidthZ=3.0)

Typedef Documentation

typedef int i3d::edge[5]
typedef std::valarray<unsigned long> i3d::Histogram

Histogram definition.

typedef std::vector< Vector3d<int> > i3d::VectContainer
typedef std::vector<Vector3d<size_t> > i3d::Boundary

Set of voxels forming the boundary.


Enumeration Type Documentation

Supported methods for cluster initialization.

Enumerator:
ClusterRandom 

assign pixels to clusters randomly

ClusterEqualMass 

create clusters with equal mass and similar intensity

ClusterAlternating 

pixels are assigned to clusters alternately (their position modulo k)

ClusterMask 

output image is taken as initial partioning

ClusterMultilevelOtsu 

pixels are clustered according to multilevel Otsu method.

Enumerator:
BoundaryDirichlet 
BoundaryNeumann 
Enumerator:
AXIS_X 
AXIS_Y 
AXIS_Z 

Two estimation types used in the MC_Estimate procedure.

Enumerator:
MC_ESTIMATE_SURFACE 
MC_ESTIMATE_VOLUME 
Enumerator:
NEAREST_NEIGHBOUR 
LINEAR 
LANCZOS 

Function Documentation

void i3d::EraseProtrusionVoxels ( Image3d< bool > &  img,
const Image3d< bool > &  img_boundary 
)
bool i3d::EraseUnambiguousVoxels ( Image3d< bool > &  img,
const Image3d< bool > &  img_boundary 
)
void i3d::FindBoundaryVoxels ( const Image3d< bool > &  img,
Image3d< bool > &  img_boundary 
)
template<class T >
I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< T > &  input,
i3d::Image3d< T > &  output,
const i3d::ChromAberParams params,
bool  cut 
)

A template function for correcting chromatic aberrations of scalar images.

This function can be efficiently used for both 2D and 3D images. The output image can be automatically cut to remove undesired black border of corrected image. Therefore, its size does not have to correspond to the input image one.

template I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< i3d::GRAY8 > &  input,
i3d::Image3d< i3d::GRAY8 > &  output,
const ChromAberParams &  params,
bool  cut 
)
template I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< i3d::GRAY16 > &  input,
i3d::Image3d< i3d::GRAY16 > &  output,
const ChromAberParams &  params,
bool  cut 
)
template I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< float > &  input,
i3d::Image3d< float > &  output,
const ChromAberParams &  params,
bool  cut 
)
template<class T >
I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< i3d::RGB_generic< T > > &  input,
i3d::Image3d< i3d::RGB_generic< T > > &  output,
const i3d::ChromAberParams red_params,
const i3d::ChromAberParams green_params,
const i3d::ChromAberParams blue_params,
bool  cut 
)

A template function for correcting chromatic aberrations of multi-channel images.

This function can be efficiently used for both 2D and 3D images. The output image can be automatically cut to remove undesired black border of corrected image. Therefore, its size does not have to correspond to the input image one.

template I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< i3d::RGB_generic< i3d::GRAY8 > > &  input,
i3d::Image3d< i3d::RGB_generic< i3d::GRAY8 > > &  output,
const ChromAberParams &  red_params,
const ChromAberParams &  green_params,
const ChromAberParams &  blue_params,
bool  cut 
)
template I3D_ALGO_EXPORT void i3d::CorrectChromaticAberration ( const i3d::Image3d< i3d::RGB_generic< i3d::GRAY16 > > &  input,
i3d::Image3d< i3d::RGB_generic< i3d::GRAY16 > > &  output,
const ChromAberParams &  red_params,
const ChromAberParams &  green_params,
const ChromAberParams &  blue_params,
bool  cut 
)
I3D_ALGO_EXPORT void i3d::GetCuttingPosition ( const i3d::Offset &  img_offset,
const i3d::Resolution &  img_resolution,
const i3d::Vector3d< size_t > &  img_size,
const i3d::ChromAberParams params,
i3d::Vector3d< size_t > &  minimum,
i3d::Vector3d< size_t > &  maximum 
)

A function for computing a minimal and maximal cutting position of scalar images.

This function can be efficiently used for both 2D and 3D images. It detects undesirable black border in the input image steming from its chromatic aberration correction. The zero-based indices for all axes are returned. Since the input image data is not taken into account during the compuation, the input image is defined just using its offset, resolution and size.

I3D_ALGO_EXPORT void i3d::GetCuttingPosition ( const i3d::Offset &  img_offset,
const i3d::Resolution &  img_resolution,
const i3d::Vector3d< size_t > &  img_size,
const i3d::ChromAberParams red_params,
const i3d::ChromAberParams green_params,
const i3d::ChromAberParams blue_params,
i3d::Vector3d< size_t > &  minimum,
i3d::Vector3d< size_t > &  maximum 
)

A template function for computing a minimal and maximal cutting position of multi-channel images.

This function can be efficiently used for both 2D and 3D images. It detects undesirable black border in the input image steming from its chromatic aberration correction. The zero-based indices for all axes are returned. * Since the input image data is not taken into account during the compuation, the input image is defined just using its offset, resolution and size.

template<class VOXEL >
void i3d::ComputeMeans ( const i3d::Image3d< VOXEL > &  imgin,
const i3d::Image3d< i3d::GRAY8 > &  imgout,
std::vector< float > &  means 
)
template<class VOXEL >
void i3d::CreateEqualMassClusters ( const Image3d< VOXEL > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k 
)
template<>
void i3d::CreateEqualMassClusters ( const Image3d< float > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k 
)
template<class VOXEL >
void i3d::CreateOtsuClusters ( const Image3d< VOXEL > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k 
)
template<>
void i3d::CreateOtsuClusters ( const Image3d< float > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k 
)
template<class VOXEL >
I3D_ALGO_EXPORT bool i3d::kMeans ( const Image3d< VOXEL > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k,
InitClusterMethod  method,
int  max_iters = 50,
std::vector< float > *  means = NULL 
)

Segmentation using k-Mean clustering.

Partitions the image into k segments so that the variance of pixel intensity in each cluster is minimised. Clusters may be disconnected. Global optimum is not guaranteed because Lloyd's iterative algorithm is used.

Parameters:
imginput image
imgoutoutput image
knumber of clusters required
methodmethod used for initial partioning
max_itersmaximal number of iterations allowed
meanswhere to store means of clusters (if means = NULL then they are not returned)
Returns:
true if max_iters is not reached (i.e. the process has converged) and false otherwise

ClusterRandom ........ pixels are assignet to clusters randomly ClusterEqualMass ..... histogram of the input image is computed and then the pixels are divided into segments with equal mass. This method is not implemented for float images. ClusterAlternating ... pixel membership to clusters is alternating as one go through the image buffer ClusterMask .......... imgout is taken as the initial partioning. All pixels must have values 0, 1, ..., k - 1

template I3D_ALGO_EXPORT bool i3d::kMeans ( const Image3d< GRAY8 > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k,
InitClusterMethod  method,
int  max_iters,
std::vector< float > *  means 
)
template I3D_ALGO_EXPORT bool i3d::kMeans ( const Image3d< GRAY16 > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k,
InitClusterMethod  method,
int  max_iters,
std::vector< float > *  means 
)
template I3D_ALGO_EXPORT bool i3d::kMeans ( const Image3d< float > &  img,
Image3d< GRAY8 > &  imgout,
GRAY8  k,
InitClusterMethod  method,
int  max_iters,
std::vector< float > *  means 
)
template<class VOXEL >
void i3d::Manders ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
Image3d< GRAY16 > &  o1,
unsigned int  threshold 
)
template<class VOXEL >
void i3d::Pearson ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
Image3d< GRAY16 > &  o1 
)
template<class VOXEL >
void i3d::Overlap ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
Image3d< GRAY16 > &  o1 
)
template<class VOXEL >
double i3d::PearsonC ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label 
)
template<class VOXEL >
double i3d::MandersC ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label,
unsigned int  threshold 
)
template<class VOXEL >
double i3d::OverlapC ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label 
)
template<class VOXEL >
double i3d::PearsonC ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2 
)
template<class VOXEL >
double i3d::MandersC ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
unsigned int  threshold 
)
template<class VOXEL >
double i3d::OverlapC ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2 
)
template<class VOXEL >
std::map< unsigned short, double > i3d::PearsonM ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask 
)
template<class VOXEL >
std::map< unsigned short, double > i3d::MandersM ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
unsigned int  threshold 
)
template<class VOXEL >
std::map< unsigned short, double > i3d::OverlapM ( const Image3d< VOXEL > &  i1,
const Image3d< VOXEL > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask 
)
template I3D_ALGO_EXPORT void i3d::Manders ( const Image3d< GRAY8 > &  ,
const Image3d< GRAY8 > &  ,
Image3d< GRAY16 > &  ,
unsigned  int 
)
template I3D_ALGO_EXPORT void i3d::Manders ( const Image3d< GRAY16 > &  ,
const Image3d< GRAY16 > &  ,
Image3d< GRAY16 > &  ,
unsigned  int 
)
template I3D_ALGO_EXPORT void i3d::Pearson ( const Image3d< GRAY8 > &  ,
const Image3d< GRAY8 > &  ,
Image3d< GRAY16 > &   
)
template I3D_ALGO_EXPORT void i3d::Pearson ( const Image3d< GRAY16 > &  ,
const Image3d< GRAY16 > &  ,
Image3d< GRAY16 > &   
)
template I3D_ALGO_EXPORT void i3d::Overlap ( const Image3d< GRAY8 > &  ,
const Image3d< GRAY8 > &  ,
Image3d< GRAY16 > &   
)
template I3D_ALGO_EXPORT void i3d::Overlap ( const Image3d< GRAY16 > &  ,
const Image3d< GRAY16 > &  ,
Image3d< GRAY16 > &   
)
template I3D_ALGO_EXPORT std::map<GRAY16,double> i3d::PearsonM ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask 
)
template I3D_ALGO_EXPORT std::map<GRAY16,double> i3d::MandersM ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
unsigned int  threshold 
)
template I3D_ALGO_EXPORT std::map<GRAY16,double> i3d::OverlapM ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask 
)
template I3D_ALGO_EXPORT std::map<GRAY16,double> i3d::PearsonM ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask 
)
template I3D_ALGO_EXPORT std::map<GRAY16,double> i3d::MandersM ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
unsigned int  threshold 
)
template I3D_ALGO_EXPORT std::map<GRAY16,double> i3d::OverlapM ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask 
)
template I3D_ALGO_EXPORT double i3d::OverlapC ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label 
)
template I3D_ALGO_EXPORT double i3d::MandersC ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label,
unsigned int  threshold 
)
template I3D_ALGO_EXPORT double i3d::PearsonC ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label 
)
template I3D_ALGO_EXPORT double i3d::OverlapC ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2 
)
template I3D_ALGO_EXPORT double i3d::MandersC ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2,
unsigned int  threshold 
)
template I3D_ALGO_EXPORT double i3d::PearsonC ( const Image3d< GRAY8 > &  i1,
const Image3d< GRAY8 > &  i2 
)
template I3D_ALGO_EXPORT double i3d::OverlapC ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label 
)
template I3D_ALGO_EXPORT double i3d::MandersC ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label,
unsigned int  threshold 
)
template I3D_ALGO_EXPORT double i3d::PearsonC ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
const LabeledImage3d< GRAY16, bool > &  mask,
int  label 
)
template I3D_ALGO_EXPORT double i3d::OverlapC ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2 
)
template I3D_ALGO_EXPORT double i3d::MandersC ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2,
unsigned int  threshold 
)
template I3D_ALGO_EXPORT double i3d::PearsonC ( const Image3d< GRAY16 > &  i1,
const Image3d< GRAY16 > &  i2 
)
template I3D_ALGO_EXPORT std::ostream& i3d::operator<< ( std::ostream &  ost,
const SCompTree< i3d::GRAY8 > &  compTreeNode 
)
template I3D_ALGO_EXPORT std::ostream& i3d::operator<< ( std::ostream &  ost,
const SCompTree< i3d::GRAY16 > &  compTreeNode 
)
template I3D_ALGO_EXPORT std::ostream& i3d::operator<< ( std::ostream &  ost,
const SCompTree< i3d::GRAY8 > *  compTreeNode 
)
template I3D_ALGO_EXPORT std::ostream& i3d::operator<< ( std::ostream &  ost,
const SCompTree< i3d::GRAY16 > *  compTreeNode 
)
template<typename T >
static size_t* i3d::CompTreeSort ( const Image3d< T > &  input) [static]

returns array of indices into the given image that allows scanning of the voxels in decreasing order

template I3D_ALGO_EXPORT void i3d::BuildComponentTree ( const Image3d< i3d::GRAY8 > &  input,
SCompTree< i3d::GRAY8 > &  componentTree,
const Neighbourhood &  neighbourhood 
)
template I3D_ALGO_EXPORT void i3d::BuildComponentTree ( const Image3d< i3d::GRAY16 > &  input,
SCompTree< i3d::GRAY16 > &  componentTree,
const Neighbourhood &  neighbourhood 
)
template I3D_ALGO_EXPORT void i3d::BuildComponentTree ( const Image3d< i3d::GRAY8 > &  input,
SCompTree< i3d::GRAY8 > &  componentTree,
NeighbourhoodWalker &  nbhWalker 
)
template I3D_ALGO_EXPORT void i3d::BuildComponentTree ( const Image3d< i3d::GRAY16 > &  input,
SCompTree< i3d::GRAY16 > &  componentTree,
NeighbourhoodWalker &  nbhWalker 
)
template<class VOXEL >
void i3d::ApplyMarchingSquaresOnOneSlice ( i3d::Image3d< VOXEL > &  ImgIn,
VOXEL  value,
std::vector< Point3d< float > > &  points,
size_t  start,
size_t *  cellSize,
size_t *  incr,
size_t *  dir 
)
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::MarchingSquaresOneSlice ( i3d::Image3d< VOXEL > &  ImgIn,
VOXEL  Value,
Direction  Axis,
std::vector< Point3d< float > > &  Lines,
size_t  SliceNumber 
)

This functions finds isolines ofthe "VOXEL Value" in the "Image3d ImgIn" on the "size_t SliceNumber"-th slice orthogonal to the "Directin Axis".

The isolines are saved in the referenced vector of Point3d<float>. There is no error detection (if the number of the slice is not out of the range, or if the vector of Point3d is initialized.) There should be some space reserved in the "std::vector<Point3d>& Lines" before calling this function. For example Lines.reserve(500)

template<class VOXELIN , class VOXELOUT >
I3D_ALGO_EXPORT void i3d::MarchingSquares ( i3d::Image3d< VOXELIN > &  ImgIn,
i3d::Image3d< VOXELOUT > &  ImgOut,
VOXELIN  Value,
Direction  Axis = AXIS_Z,
VOXELOUT  Colour = std::numeric_limits< VOXELOUT >::max() 
)

Draws isolines of "Value" computed from "Image3d ImgIn" on the 2d slices of the "Image3d ImgOut" with colour "colour".

The slice plane direction (xy, xz, yz) depends on the variable Axis, where the name of the axis is orthogonal to the slice plane. So AXIS_Z means that the isolines will be drawn in the xy slices.

template I3D_ALGO_EXPORT void i3d::MarchingSquares ( i3d::Image3d< float > &  ImgIn,
i3d::Image3d< GRAY8 > &  ImgOut,
float  Value,
Direction  Axis,
GRAY8  Colour 
)
void i3d::generate_descending_sequence ( const Vector3d< size_t > &  dim,
std::queue< Vector3d< size_t >> &  seq 
)
bool i3d::is_factorable ( size_t  number)

Function checks if the given number can be factored into product of small primes.

fftw documentation: FFTW is best at handling sizes of the form: 2^a * 3^b * 5^c * 7^d * 11^e * 13^f, where e+f is either 0 or 1, and the other exponents are arbitrary.

template<class T_in , class T_out , class PRECISION >
double i3d::estimate_needed_space ( const Vector3d< size_t > &  F_voi_sz,
const Vector3d< size_t > &  G_voi_sz 
)

This function gives you the estimate, how much memory you will need if performing fft-based convolution over two real images of specified size.

The precision of the evaluation is also taken into account.

Memory vs time line:

memory usage x-------------------------------------------------------> | | F_pad | G_pad | (padded memory buffers) | F_pad | G_pad | FFT(F_pad) | FFT_buff | (FFT of signal) | F_pad | G_pad | FFT(F_pad) | FFT(G_pad) | FFT_buff | (FFT of kernel) | F_pad | G_pad | FFT(H_pad) | (point-wise multiplication) | F_pad | G_pad | FFT(H_pad) | H_pad | FFT_buff | (IFFT of the product) | F_pad | G_pad | | H_pad | (finish) | | | time V

All the previous memory blocks are of the same dimensions (expect for some small alignment). However, their size differs because they may represent the data of various datatypes.

Please note that sizeof(F_pad) = sizeof(G_pad), as both the buffers are aligned and padded to the same size. Moreover, sizeof(FFT(F_pad)) = sizeof(FFT(G_pad)) = sizeof(FFT_buff) = sizeof(FFT(H_pad)).

The function 'estimate_needed_space()' should give you the maximum memory usage during the convolution process. The expression below stems from the plot above:

estimate = sizeof(F_pad) + sizeof(G_pad) + sizeof(FFT(F_pad)) + sizeof(FFT_buff) + max(sizeof(H_pad), sizeof(FFT_buff))

template<class T_in , class T_out , class PRECISION >
bool i3d::find_optimal_tile_size ( const Vector3d< size_t > &  img_dim,
const Vector3d< size_t > &  ker_dim,
Vector3d< size_t > &  tile_dim 
)

Function that checks the available memory and the possibilities of saving the memory by splitting the huge images.

It we have too few memory, then splitting is required. Let us split both the image and the kernel into the blocks of the same size of ANY shape. Why? (a) using the same division for image and kernel is an optimal solution (b) the complexity of convolution over chopped image is independent of the shape of the tiles. It depends only on the number of pixels processed.

Return values:

  • true ... Succeeded :) then vector 'tile_dim' stores the proposed tile dimensions
  • false ... Failed to allocate memory :(
template<class T_in , class T_out , class PRECISION >
void i3d::convolution_via_fft ( const Image3d< T_in > &  F,
const Image3d< T_in > &  G,
Image3d< T_out > &  H,
PRECISION  factor 
)

This function implements convolution via convolution theorem using fast Fourier transform.

template<class T_in , class T_out , class PRECISION >
void i3d::convolution_in_voi ( const Image3d< T_in > &  F,
const Image3d< T_in > &  G,
Image3d< T_out > &  H,
const VOI< PIXELS > &  F_voi,
const VOI< PIXELS > &  G_voi,
PRECISION  factor,
BoundaryConditionType  boundary_condition 
)

This function performs FFTW based convolution over given VOIs (tiles).

It also solves the problem with both image and kernel tile padding. If the VOI goes beyond or touches the image boundary, the padding algorithm pads the area with zeros. If the VOI (as the small part of some larger image) is completely inside an image, the padding algorithm copies the values from the corresponding positions.

This function DO NOT allocate the input/output memory buffers!

H = F (x) G

image 'F': image 'G': |-----------------------| | | |----------------| | |-------| | | |-------| | | | | | | | G_voi | | | | F_voi | | (x) | |-------| | | |-------| | | | | | |----------------| | | |-----------------------|

image 'H': |-----------------------| | | | |-------| | | | |<-------- output area for F_voi (x) G_voi | | | | | |-------| | | | | | |-----------------------|

F_voi is a small particle of some large scale image F. The convolution between F_voi and the whole G can be performed if you guarantee some padding of F_voi. Particularly, F_voi must be padded with the dimension of G minus one. After that a convolution with this padded F_voi and G can be performed without the lost of generality.

G_voi is a small particle of some large scale image G (convolution kernel). However splitting G into small G_voi-s is not as simple as in the case of image F. It is important to know that convolution F_voi with G_voi gives only a small portion of the final solution. All the possible (nonoverlapping) G_voi's must be convolved with the selected F_voi. All the results will be ADDED together to get the final values in 'X'.

AN IDEA OF SPLITTING 'G' INTO SMALL PARTS (TILES)

Given the original kernel 'G' we can split it into two parts G = G_voi + G_rest

'G': 'G_voi': 'G_rest': |----------------| |----------------| |----------------| |xxxxxxxxxxxxxxxx| | | |xxxxxxxxxxxxxxxx| |xxxxxxxxxxxxxxxx| | xxxxxxxx | |x xxxxxxxx| |xxxxxxxxxxxxxxxx| | xxxxxxxx | |x xxxxxxxx| |xxxxxxxxxxxxxxxx| | xxxxxxxx | |x xxxxxxxx| |----------------| |----------------| |----------------|

As convolution keeps the distribution rules, we can write: F (x) G = F (x) G_voi + F (x) G_rest

If we generalize our idea, we can split G into many tiles: G = G_1 + G_2 + G_3 + G_4 + ... G_n which leads to the following: F (x) G = F (x) G_1 + F (x) G_2 + ... + F(x) G_n

One can simply see, that splitting G into small part won't save the memory, as all the particles (tiles) are of the same size. There is another good convolution property - shift invariance:

If we remove all the zeros from G_voi we get smaller tile G_voi_cropped. Aside from this, we must remember the vector S, which defines the position of G_voi_cropped inside the original G_voi. Doing the two steps above (cropping and remembering the shift vector) we can state that F (x) G_voi = shift_by_S{F} (x) G_voi_cropped which saves the memory.

void i3d::establish_location_of_tiles ( const Vector3d< size_t > &  image_dim,
const Vector3d< size_t > &  tile_dim,
std::vector< VOI< PIXELS >> &  list_of_VOIs 
)
template<class T >
void i3d::validate_images ( const Image3d< T > &  img_in,
const Image3d< T > &  kernel 
)
template I3D_ALGO_EXPORT void i3d::Convolution< float, bool, float > ( const Image3d< bool > &  ,
const Image3d< bool > &  ,
Image3d< float > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< double, bool, float > ( const Image3d< bool > &  ,
const Image3d< bool > &  ,
Image3d< float > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< float, GRAY8, GRAY8 > ( const Image3d< GRAY8 > &  ,
const Image3d< GRAY8 > &  ,
Image3d< GRAY8 > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< float, GRAY16, GRAY16 > ( const Image3d< GRAY16 > &  ,
const Image3d< GRAY16 > &  ,
Image3d< GRAY16 > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< float, float, float > ( const Image3d< float > &  ,
const Image3d< float > &  ,
Image3d< float > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< double, GRAY8, GRAY8 > ( const Image3d< GRAY8 > &  ,
const Image3d< GRAY8 > &  ,
Image3d< GRAY8 > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< double, GRAY16, GRAY16 > ( const Image3d< GRAY16 > &  ,
const Image3d< GRAY16 > &  ,
Image3d< GRAY16 > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< double, float, float > ( const Image3d< float > &  ,
const Image3d< float > &  ,
Image3d< float > &  ,
bool  ,
BoundaryConditionType   
)
template I3D_ALGO_EXPORT void i3d::Convolution< double, double, double > ( const Image3d< double > &  ,
const Image3d< double > &  ,
Image3d< double > &  ,
bool  ,
BoundaryConditionType   
)
template<class T >
static void i3d::TridiagonalMatrixSolver ( T *  a,
T *  b,
T *  c,
T *  d,
T *  x,
size_t  n 
) [static]

Solve a tridiagonal system of linear equations using the Thomas algorithm.

template<class VOXEL >
static void i3d::ForwardBackwardSubstitution ( const VOXEL *  M,
const VOXEL *  L,
VOXEL *  d,
size_t  n,
VOXEL  tau,
size_t  shift 
) [static]

Forward and backward substitution of the Thomas algorithm intended for a linear diffusion filtering.

template<class VOXEL >
static void i3d::PrepareLRDecomposition ( VOXEL *  M,
VOXEL *  L,
size_t  n,
VOXEL  tau 
) [static]

Prepare the LR decomposition of a tridiagonal matrix intended for a linear diffusion filtering.

template<class T >
static void i3d::PrepareDiagonals ( T *  Diag,
T *  UDiag,
T *  LDiag,
const T *  data,
size_t  N,
tau,
size_t  shift 
) [static]

Create a tridiagonal matrix intended for a AOS scheme.

template<class T >
static void i3d::CopyFrom ( const T *  src,
T *  dst,
size_t  num,
size_t  step 
) [static]

Copy values from one buffer to the other one.

template<class T >
static void i3d::Add ( const T *  src,
T *  dst,
size_t  num,
size_t  step 
) [static]

Add values from one buffer to the other one.

template<class T >
static void i3d::AddAndAvg ( const T *  src,
T *  dst,
size_t  num,
size_t  step,
coef 
) [static]

Add values from one buffer to the other one and multiply them by a given coefficient.

template<class T >
static void i3d::EigDecomposition ( a,
b,
c,
double *  eigval,
double *  eigvec 
) [static]

Compute the eigenvalue decomposition of a symmetric 2x2 matrix in the form A = [a b; b c].

The eigenvalues are always sorted in the ascending order.

template<class T >
static void i3d::EigDecomposition3D ( a,
b,
c,
d,
e,
f,
double *  eigval,
double *  eigvec 
) [static]

Compute the eigenvalue decomposition of a symmetric 3x3 matrix in the form A = [Da Db Dc; Db Dd De; Dc De Df].

The eigenvalues are always sorted in the ascending order.

template<class T >
static void i3d::StructureTensor ( const Image3d< T > &  in,
Image3d< T > &  Da,
Image3d< T > &  Db,
Image3d< T > &  Dc 
) [static]

Construct a structure tensor J = [Da Db; Db Dc] for each image pixel.

template<class T >
static void i3d::StructureTensor3D ( const Image3d< T > &  in,
Image3d< T > &  Da,
Image3d< T > &  Db,
Image3d< T > &  Dc,
Image3d< T > &  Dd,
Image3d< T > &  De,
Image3d< T > &  Df 
) [static]

Construct a structure tensor J = [Da Db Dc; Db Dd De; Dc De Df] for each image voxel.

template<class T >
static void i3d::EEDTensor ( Image3d< T > &  Da,
Image3d< T > &  Db,
Image3d< T > &  Dc,
lambda 
) [static]

Construct a diffusion tensor D = [Da Db; Db Dc] for the edge-enhancing diffusion.

template<class T >
static void i3d::EEDTensor3D ( Image3d< T > &  Da,
Image3d< T > &  Db,
Image3d< T > &  Dc,
Image3d< T > &  Dd,
Image3d< T > &  De,
Image3d< T > &  Df,
lambda 
) [static]

Construct a diffusion tensor D = [Da Db Dc; Db Dd De; Dc De Df] for the edge-enhancing diffusion.

template<class T >
static void i3d::CEDTensor ( Image3d< T > &  Da,
Image3d< T > &  Db,
Image3d< T > &  Dc 
) [static]

Construct a diffusion tensor D = [Da Db; Db Dc] for the coherence-enhancing diffusion.

template<class T >
static void i3d::CEDTensor3D ( Image3d< T > &  Da,
Image3d< T > &  Db,
Image3d< T > &  Dc,
Image3d< T > &  Dd,
Image3d< T > &  De,
Image3d< T > &  Df 
) [static]

Construct a diffusion tensor D = [Da Db Dc; Db Dd De; Dc De Df] for the coherence-enhancing diffusion.

template<class T >
static void i3d::AnisoDiffStep_AOS ( const Image3d< T > &  in,
const Image3d< T > &  Da,
const Image3d< T > &  Db,
const Image3d< T > &  Dc,
Image3d< T > &  out,
tau 
) [static]

Execute one step of the anisotropic diffusion for given time step tau and diffusion tensor [Da Db; Db Dc] using the semi-implicit AOS-stabilized scheme.

template<class T >
static void i3d::AnisoDiffStep3D_AOS ( const Image3d< T > &  in,
const Image3d< T > &  Da,
const Image3d< T > &  Db,
const Image3d< T > &  Dc,
const Image3d< T > &  Dd,
const Image3d< T > &  De,
const Image3d< T > &  Df,
Image3d< T > &  out,
tau 
) [static]

Execute one step of the anisotropic diffusion for given time step tau and diffusion tensor [Da Db Dc; Db Dd De; Dc De Df] using the semi-implicit AOS-stabilized scheme.

template<class VOXEL >
void i3d::Gauss_LOD ( Image3d< VOXEL > &  img,
VOXEL  sigma,
size_t  num_iter 
)

Gaussian (Linear isotropic diffusion) filtering based on the LOD (locally one-dimensional) scheme.

The sigma parameter determines the standard deviation of the Gaussian filter. Total time of the diffusion process T is given as T = (sigma * sigma) / 2. A time step for one iteration is computed as T / num_iter. The LOD scheme is unconditionally stable, i.e. scale-space properties such as the min-max principle or average gray value are preserved for an arbitrary time step. However, to obtain a good compromise between efficiency and accuracy, the time step of one iteration should be less than 5.

Note: This function is intended only for floating-point scalar images.

template I3D_ALGO_EXPORT void i3d::Gauss_LOD ( Image3d< float > &  img,
float  sigma,
size_t  num_iter 
)

Explicit instantiations.

template I3D_ALGO_EXPORT void i3d::Gauss_LOD ( Image3d< double > &  img,
double  sigma,
size_t  num_iter 
)
template<class VOXEL , class PRECISION >
void i3d::GrayGauss_LOD ( Image3d< VOXEL > &  img,
PRECISION  sigma,
size_t  num_iter 
)

Gaussian (Linear isotropic diffusion) filtering based on the LOD (locally one-dimensional) scheme.

A wrapper of the Gauss_LOD() function for grayscale scalar images.

template I3D_ALGO_EXPORT void i3d::GrayGauss_LOD ( Image3d< GRAY8 > &  img,
float  sigma,
size_t  num_iter 
)

Explicit instantiations.

template I3D_ALGO_EXPORT void i3d::GrayGauss_LOD ( Image3d< GRAY16 > &  img,
float  sigma,
size_t  num_iter 
)
template I3D_ALGO_EXPORT void i3d::GrayGauss_LOD ( Image3d< GRAY8 > &  img,
double  sigma,
size_t  num_iter 
)
template I3D_ALGO_EXPORT void i3d::GrayGauss_LOD ( Image3d< GRAY16 > &  img,
double  sigma,
size_t  num_iter 
)
template<class VOXEL >
void i3d::EED_AOS ( Image3d< VOXEL > &  img,
VOXEL  sigma,
VOXEL  lambda,
VOXEL  tau,
size_t  num_iter 
)

Edge-enhancing diffusion filtering based on the semi-implicit AOS-stabilized scheme.

The sigma parameter determines the standard deviation of the Gaussian filter that is applied before the gradient estimation. The lambda parameter determines a threshold contrast for edges. The tau parameter determines a time step of one iteration.

Note: This function is intended only for floating-point scalar images.

template I3D_ALGO_EXPORT void i3d::EED_AOS ( Image3d< float > &  img,
float  sigma,
float  lambda,
float  tau,
size_t  num_iter 
)

Explicit instantiations.

template I3D_ALGO_EXPORT void i3d::EED_AOS ( Image3d< double > &  img,
double  sigma,
double  lambda,
double  tau,
size_t  num_iter 
)
template<class VOXEL , class PRECISION >
void i3d::GrayEED_AOS ( Image3d< VOXEL > &  img,
PRECISION  sigma,
PRECISION  lambda,
PRECISION  tau,
size_t  num_iter 
)

Edge-enhancing diffusion filtering based on the semi-implicit AOS-stabilized scheme.

A wrapper of the EED_AOS() function for grayscale scalar images.

template I3D_ALGO_EXPORT void i3d::GrayEED_AOS ( Image3d< GRAY8 > &  img,
float  sigma,
float  lambda,
float  tau,
size_t  num_iter 
)

Explicit instantiations.

template I3D_ALGO_EXPORT void i3d::GrayEED_AOS ( Image3d< GRAY16 > &  img,
float  sigma,
float  lambda,
float  tau,
size_t  num_iter 
)
template I3D_ALGO_EXPORT void i3d::GrayEED_AOS ( Image3d< GRAY8 > &  img,
double  sigma,
double  lambda,
double  tau,
size_t  num_iter 
)
template I3D_ALGO_EXPORT void i3d::GrayEED_AOS ( Image3d< GRAY16 > &  img,
double  sigma,
double  lambda,
double  tau,
size_t  num_iter 
)
template<class VOXEL >
void i3d::CED_AOS ( Image3d< VOXEL > &  img,
VOXEL  sigma,
VOXEL  rho,
VOXEL  tau,
size_t  num_iter 
)

Coherence-enhancing diffusion filtering based on the semi-implicit AOS-stabilized scheme.

The sigma parameter determines the standard deviation of the Gaussian filter that is applied before the gradient estimation. The rho parameter determines the standard deviation of the Gaussian filter that is applied in order to smooth structure tensors. The tau parameter determines a time step of one iteration.

Note: This function is intended only for floating-point scalar images.

template I3D_ALGO_EXPORT void i3d::CED_AOS ( Image3d< float > &  img,
float  sigma,
float  rho,
float  tau,
size_t  num_iter 
)

Explicit instantiations.

template I3D_ALGO_EXPORT void i3d::CED_AOS ( Image3d< double > &  img,
double  sigma,
double  rho,
double  tau,
size_t  num_iter 
)
template<class VOXEL , class PRECISION >
void i3d::GrayCED_AOS ( Image3d< VOXEL > &  img,
PRECISION  sigma,
PRECISION  rho,
PRECISION  tau,
size_t  num_iter 
)

Coherence-enhancing diffusion filtering based on the semi-implicit AOS-stabilized scheme.

A wrapper of the CED_AOS() function for grayscale scalar images.

template I3D_ALGO_EXPORT void i3d::GrayCED_AOS ( Image3d< GRAY8 > &  img,
float  sigma,
float  rho,
float  tau,
size_t  num_iter 
)

Explicit instantiations.

template I3D_ALGO_EXPORT void i3d::GrayCED_AOS ( Image3d< GRAY16 > &  img,
float  sigma,
float  rho,
float  tau,
size_t  num_iter 
)
template I3D_ALGO_EXPORT void i3d::GrayCED_AOS ( Image3d< GRAY8 > &  img,
double  sigma,
double  rho,
double  tau,
size_t  num_iter 
)
template I3D_ALGO_EXPORT void i3d::GrayCED_AOS ( Image3d< GRAY16 > &  img,
double  sigma,
double  rho,
double  tau,
size_t  num_iter 
)
template<typename T >
void i3d::scanCityBlock ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
int  xmax,
int  ymax,
int  zmax,
xp,
yp,
zp,
std::valarray< T > &  mapa 
)

Scan for algorithm that computes City Blocks distance.

template<typename T >
void i3d::scanChamfer ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
int  xmax,
int  ymax,
int  zmax,
xp,
yp,
zp,
std::valarray< T > &  mapa 
)

Scan for algorithm that computes Chamfer distance.

template<typename T >
void i3d::scan4N ( int  pocx,
int  konx,
int  pocy,
int  kony,
size_t  xm,
size_t  ym,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< voxelxy > &  pole 
)
template<typename T >
void i3d::scan8N ( int  pocx,
int  konx,
int  pocy,
int  kony,
size_t  xm,
size_t  ym,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< voxelxy > &  pole 
)
template<typename T >
void i3d::EDM2D ( Image3d< T > &  Obraz,
byte  kvalita,
Image_Background,
bool  odmocnina 
)
template<typename T >
void i3d::scan6N ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
size_t  xm,
size_t  ym,
size_t  zm,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< T > &  mocninaz,
std::valarray< voxelxyz > &  pole 
)
template<typename T >
void i3d::scan26N ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
size_t  xm,
size_t  ym,
size_t  zm,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< T > &  mocninaz,
std::valarray< voxelxyz > &  pole 
)
template<typename T >
void i3d::EDM3D ( Image3d< T > &  Obraz,
byte  kvalita,
Image_Background,
bool  odmocnina 
)
template<typename T >
void i3d::Saito4Sed ( Image3d< T > &  Obraz,
Image_Background,
bool  odmocnina 
)

This algorithm is combination of Danielsson's algoritm and Saito's algorithm.

template<typename T >
void i3d::Saito8Sed ( Image3d< T > &  Obraz,
Image_Background,
bool  odmocnina 
)
template<typename T >
void i3d::scanDED4N ( int  pocx,
int  konx,
int  pocy,
int  kony,
size_t  xmax,
size_t  ymax,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< voxelxy > &  pole 
)
template<typename T >
void i3d::scanDED8N ( int  pocx,
int  konx,
int  pocy,
int  kony,
size_t  xmax,
size_t  ymax,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< voxelxy > &  pole 
)
template<typename T >
void i3d::DeuclideanDistance2D ( Image3d< T > &  Obraz,
byte  kvalita,
Image_Background,
bool  odmocnina 
)
template<typename T >
void i3d::scanDED26N ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
size_t  xmax,
size_t  ymax,
size_t  zmax,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< T > &  mocninaz,
std::valarray< voxelxyz > &  pole 
)
template<typename T >
void i3d::scanDED18N ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
size_t  xmax,
size_t  ymax,
size_t  zmax,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< T > &  mocninaz,
std::valarray< voxelxyz > &  pole 
)
template<typename T >
void i3d::scanDED6N ( int  pocx,
int  konx,
int  pocy,
int  kony,
int  pocz,
int  konz,
size_t  xmax,
size_t  ymax,
size_t  zmax,
std::valarray< T > &  mocninax,
std::valarray< T > &  mocninay,
std::valarray< T > &  mocninaz,
std::valarray< voxelxyz > &  pole 
)
template<typename T >
void i3d::DeuclideanDistance3D ( Image3d< T > &  Obraz,
byte  kvalita,
Image_Background,
bool  odmocnina 
)
template I3D_ALGO_EXPORT void i3d::CityBlock ( Image3d< float > &  Obraz,
float  Image_background 
)
template I3D_ALGO_EXPORT void i3d::Chamfer ( Image3d< float > &  Obraz,
float  Image_background 
)
template I3D_ALGO_EXPORT void i3d::EDM ( Image3d< float > &  Obraz,
byte  kvalita,
float  Image_background,
bool  odmocnina 
)
template I3D_ALGO_EXPORT void i3d::HybridSaito ( Image3d< float > &  Obraz,
byte  kvalita,
float  Image_background,
bool  odmocnina 
)
template I3D_ALGO_EXPORT void i3d::SlowSaito ( Image3d< float > &  Obraz,
float  Image_background,
bool  odmocnina 
)
template I3D_ALGO_EXPORT void i3d::FastSaito ( Image3d< float > &  Obraz,
float  Image_background,
bool  odmocnina 
)
template void i3d::DeuclideanDistance ( Image3d< float > &  Obraz,
byte  kvalita,
float  Image_background,
bool  odmocnina 
)
size_t i3d::PrepareLine ( Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
Vector3d< double > &  d 
)
void i3d::ShiftPenAlongLine ( Vector3d< double > &  D,
int &  dx,
int &  dy,
int &  dz 
) [inline]
template<class T >
void i3d::RasterizeLineBres ( const T &  Dest,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2 
)

Drawing line using Bressenham algorithm.

`Dest` is an appropriate functor storing generated points to required place in memory/display.

template<class VOXEL1 , class VOXEL2 >
size_t i3d::FillRow ( std::stack< size_t > &  buf,
const Image3d< VOXEL1 > &  input,
Image3d< VOXEL2 > &  output,
VOXEL2  NewColor,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::DrawLine ( Image3d< bool > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
bool  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLine ( Image3d< GRAY8 > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
GRAY8  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLine ( Image3d< GRAY16 > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
GRAY16  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLine ( Image3d< RGB > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
RGB  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLine ( Image3d< RGB16 > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
RGB16  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLines ( Image3d< GRAY8 > &  img,
const std::vector< Offset > &  pnts,
GRAY8  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLines ( Image3d< GRAY16 > &  img,
const std::vector< Offset > &  pnts,
GRAY16  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLines ( Image3d< RGB > &  img,
const std::vector< Offset > &  pnts,
RGB  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLines ( Image3d< RGB16 > &  img,
const std::vector< Offset > &  pnts,
RGB16  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLineBres ( Image3d< bool > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
bool  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLineBres ( Image3d< GRAY8 > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
GRAY8  color 
)
template I3D_ALGO_EXPORT void i3d::DrawLineBres ( Image3d< GRAY16 > &  img,
Vector3d< size_t >  p1,
Vector3d< size_t >  p2,
GRAY16  color 
)
template I3D_ALGO_EXPORT void i3d::DrawCube ( Image3d< bool > &  img,
const VOI< PIXELS > &  voi,
bool  color 
)
template I3D_ALGO_EXPORT void i3d::DrawCube ( Image3d< GRAY8 > &  img,
const VOI< PIXELS > &  voi,
GRAY8  color 
)
template I3D_ALGO_EXPORT ComponentInfo<bool, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< bool > &  out,
bool  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<int, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< int > &  out,
int  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY8, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< GRAY8 > &  out,
GRAY8  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY8, GRAY16> i3d::FloodFill ( const Image3d< GRAY16 > &  in,
Image3d< byte > &  out,
GRAY8  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY8, GRAY8> i3d::FloodFill ( const Image3d< GRAY8 > &  in,
Image3d< GRAY8 > &  out,
GRAY8  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY16, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< GRAY16 > &  out,
GRAY16  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY16, GRAY16> i3d::FloodFill ( const Image3d< GRAY16 > &  in,
Image3d< GRAY16 > &  out,
GRAY16  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, GRAY8> i3d::FloodFill ( const Image3d< GRAY8 > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, GRAY16> i3d::FloodFill ( const Image3d< GRAY16 > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, float> i3d::FloodFill ( const Image3d< float > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<bool, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< bool > &  out,
bool  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<int, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< int > &  out,
int  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY8, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< GRAY8 > &  out,
GRAY8  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY8, GRAY8> i3d::FloodFill ( const Image3d< GRAY8 > &  in,
Image3d< GRAY8 > &  out,
GRAY8  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY8, GRAY16> i3d::FloodFill ( const Image3d< GRAY16 > &  in,
Image3d< byte > &  out,
GRAY8  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY16, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< GRAY16 > &  out,
GRAY16  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<GRAY16, GRAY16> i3d::FloodFill ( const Image3d< GRAY16 > &  in,
Image3d< GRAY16 > &  out,
GRAY16  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, bool> i3d::FloodFill ( const Image3d< bool > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, GRAY8> i3d::FloodFill ( const Image3d< GRAY8 > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, GRAY16> i3d::FloodFill ( const Image3d< GRAY16 > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT ComponentInfo<size_t, float> i3d::FloodFill ( const Image3d< float > &  in,
Image3d< size_t > &  out,
size_t  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< bool > &  img,
bool  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< GRAY8 > &  img,
GRAY8  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< GRAY16 > &  img,
GRAY16  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< RGB > &  img,
RGB  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< RGB16 > &  img,
RGB16  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< size_t > &  img,
size_t  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< float > &  img,
float  color,
size_t  x,
size_t  y,
size_t  z,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< bool > &  img,
bool  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< GRAY8 > &  img,
GRAY8  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< GRAY16 > &  img,
GRAY16  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< RGB > &  img,
RGB  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< RGB16 > &  img,
RGB16  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< size_t > &  img,
size_t  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::FloodFill ( Image3d< float > &  img,
float  color,
size_t  seed_index,
const Neighbourhood &  neib 
)
template I3D_ALGO_EXPORT void i3d::Negative ( Image3d< bool > &  img)
template I3D_ALGO_EXPORT void i3d::Negative ( Image3d< GRAY8 > &  img)
template I3D_ALGO_EXPORT void i3d::Negative ( Image3d< GRAY16 > &  img)
template<class T >
static T i3d::Sqr ( val) [inline, static]

Get the square of a given value.

template<class T >
static T i3d::Abs ( x) [inline, static]
template<class T >
static T i3d::Max ( x,
y,
z 
) [inline, static]
template<class VOXEL >
static Vector3d<float> i3d::get_relative_resolution ( const Image3d< VOXEL > &  in) [static]
template<class VOXEL >
static bool i3d::is_anisotropic ( const Image3d< VOXEL > &  in) [static]
static void i3d::Make3DKernel ( int  vstup[3][3][3],
JADRO &  vystup 
) [static]
template<class VOXEL >
static void i3d::Apply3DCompassFilter ( const Image3d< VOXEL > &  in,
Image3d< VOXEL > &  out,
JADRO  filtr 
) [static]
template<class VOXEL >
static float i3d::AGetVoxel ( const Image3d< VOXEL > &  in,
float  x,