Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

IP3D Namespace Reference

ImageStats.hpp. More...


Functions

template<class ImageType>
void Addition (const ImageType &im1, const ImageType &im2, ImageType &imDest)
template<class ImageType>
void AdditionWithConstant (const ImageType &im1, const typename ImageType::value_type &scalarValue, ImageType &imDest)
template<class ImageType>
void Difference (const ImageType &im1, const ImageType &im2, ImageType &imDest)
template<class ImageType>
void DifferenceWithConstant (const ImageType &im1, const typename ImageType::value_type &scalarValue, ImageType &imDest)
template<class ImageType>
void Multiplication (const ImageType &im1, const ImageType &im2, ImageType &imDest)
template<class ImageType>
void MultiplicationWithConstant (const ImageType &im1, double scalarValue, ImageType &imDest)
template<class ImageType>
void Division (const ImageType &im1, const ImageType &im2, ImageType &imDest)
template<class ImageType>
void MaxImage (const ImageType &im1, const ImageType &im2, ImageType &imDest)
template<class ImageType>
void Abs (const ImageType &im1, ImageType &imDest)
template<class ImageType1, class ImageType2>
void ImageTypeConversion (const ImageType1 &src, ImageType2 &res)
template<class ImageType>
void Crop (const ImageType &src, const RectZone3Di &zone, ImageType &res0)
template<class ImageType>
void FindFirstDifference (const ImageType &src1, const ImageType &src2, bool &found, Vect3Di &pos)
template<class ImageType>
void FindMinMax (const ImageType &src, typename ImageType::value_type &vmin, typename ImageType::value_type &vmax, Vect3Di *posMin=NULL, Vect3Di *posMax=NULL)
template<class ImageType>
void L2Norm (const ImageType &src, double &energy)
template<class ImageType>
void SetAllVoxels (const ImageType &src, const typename ImageType::value_type &v, ImageType &res)
template<class ImageType>
void AddMask (const ImageType &src, ImageType &res, const Mask3D *mask=NULL)
template<class ImageType>
void GetMask (const ImageType &src, Mask3D &res)
template<class ImageType>
void ApplyMask (const ImageType &src, ImageType &res, byte maskvalue=0, const Mask3D *optmask=NULL)
template<class ImageType>
void SetDefaultInterpolator (const ImageType &src, const string &name, ImageType &res)
template<class ComplexImageType>
void ExtractFromComplexImage (const ComplexImageType &src, const string &type, Image3Df &res)
template<class ImageType>
void SetProperty (const ImageType &src, const string &name, const string &typeName, string value, ImageType &res)
template<class ImageType>
void RemoveProperty (const ImageType &src, const string &name, ImageType &res)
template<class ImageType>
void Pad (const ImageType &src, Vect3Di paddingV, ImageType &res, bool padLinear=false)
template<class ImageType>
void Convolution (const ImageType &imToConvolve, const Filter &imFilter, ImageType &imResult)
template<class ImageType>
void SeparableConvolution (const ImageType &imToConvolve, const SeparableFilter &filter, ImageType &imResult)
template<class ImageType>
void ConvolutionFFT (const ImageType &imToConvolve, const Filter &imFilter, ImageType &imResult)
template<class ImageType>
void PartialSum (const ImageType &cumSum, const RectZone3Di &r0, typename ImageType::value_type &res)
template<class ImageType>
void CumulativeSum (const ImageType &src, ImageType &res0)
template<class ImageType>
void BoxFilter (const ImageType &src, int size, ImageType &res0)
template<class ImageType>
void GaussianApproxFilter (const ImageType &src, int order, int size, ImageType &res)
template<class ImageType>
void BorderCorrectedGaussianApproxFilter (const ImageType &src, int size, int nbFilterIter, ImageType &res)
template<class ImageType>
void SymmetricBinomialFilter (const ImageType &src, int order, ImageType &res)
void FFTLowPassFilterApodizedIdeal (const Image3Df &src, float cutoffFreq, Image3Df &res, float rolloffFactor=0)
void FFTLowPassFilterButterworth (const Image3Df &src, float cutoffFreq, float order, Image3Df &res)
void FFTLowPassFilterChebyscheff (const Image3Df &src, float cutoffFreq, float order, Image3Df &res)
template<>
void Convolution< Image3Dcomplex > (const Image3Dcomplex &imToConvolute, const Filter &imFilter, Image3Dcomplex &imResult)
template<class ImageType>
void DrawSegment3D (const ImageType &src, const Segment3D &segment, const Pen< typename ImageType::value_type > &pen, ImageType &res)
void FFT (const Image3Df &src, Image3Dcomplexf &res, bool resultFullSize=true)
void FFT (const Image3Dd &src, Image3Dcomplexd &res, bool resultFullSize=true)
void FFT (const Image3Dcomplexf &src, Image3Dcomplexf &res, bool resultFullSize=true)
void FFT (const Image3Dcomplexd &src, Image3Dcomplexd &res, bool resultFullSize=true)
void FFTInverse (const Image3Dcomplexf &src, Image3Dcomplexf &res, int resultWidth=0, bool overwriteSrc=false)
void FFTInverse (const Image3Dcomplexd &src, Image3Dcomplexd &res, int resultWidth=0, bool overwriteSrc=false)
void FFTInverse (const Image3Dcomplexf &src, Image3Df &res, int resultWidth=0, bool overwriteSrc=false)
void FFTInverse (const Image3Dcomplexd &src, Image3Dd &res, int resultWidth=0, bool overwriteSrc=false)
template<class ImageType>
void ImageFromRawData (const typename ImageType::value_type *data, const Size3D &size, string order, ImageType &res, bool reverseEndian=false)
template<class ImageType>
void RawDataFromImage (const ImageType &src, string order, typename ImageType::value_type **pres, bool reverseEndian=false)
template<class ImageType>
void WriteToFileAVW (const ImageType &src, const string &fname)
template<class ImageType>
void ReadFromFileAVW (const string &fname, ImageType &res)
void ReadFromFileBruker (const string &fname, int imageNumber, Image3Dlinear< short int > &res)
template<class ImageType>
void ExportImageSlice (const ImageType &src, int direction, int position, const string &fname, float rescale=1)
template<class ImageType>
void ScalarProduct (const ImageType &im1, const ImageType &im2, double &retValue)
void RobustAverageAndVariance (const Image3Df &src, double &average, double &variance)
template<class ImageType>
void Average (const ImageType &src, typename ImageType::value_type &average)
template<class ImageType>
void AverageAndVariance (const ImageType &src, double &average, double &variance)
template<class ImageType>
void Median (const ImageType &src, double &res, double part=.5, double precision=-.1)
template<class ImageType>
void InsertImage (const ImageType &src, const ImageType &insert, const Vect3Di &pos, ImageType &res)
template<class ImageType>
void ResizeImageSupport (const ImageType &src, const Size3D &newSize, ImageType &res0, const typename ImageType::value_type *fillValue=NULL)
template<class ImageType>
void MedianFilter (const ImageType &src, const StructureElement &mask, ImageType &res)
template<class ImageType>
void SharpeningFilter (const ImageType &src, const StructureElement &mask, ImageType &res)
template<class ImageType>
void Erosion (const ImageType &src, const StructureElement &mask, ImageType &res)
template<class ImageType>
void Dilation (const ImageType &src, const StructureElement &mask, ImageType &res)
template<class ImageType>
void Opening (const ImageType &src, const StructureElement &mask, ImageType &res)
template<class ImageType>
void Closing (const ImageType &src, const StructureElement &mask, ImageType &res)
void DistanceTransform (const Mask3D &src, const StructureElement &mask, Image3Df &res, bool borderExtend=false)
template<class ImageType>
void ConnectedComponentLabelling (const ImageType &src, const StructureElement &mask0, LabelImage3D &res, typename ImageType::value_type *background0=NULL)
void FillHoles (const Mask3D &src, const StructureElement &mask, Mask3D &res)
template<class ImageType>
void MakeValueList (const ImageType &src, ImageValues< typename ImageType::value_type > &res)
void LargestConnectedComponent (const Mask3D &src, Mask3D &res)
void NoiseVarianceEstimation (const Image3Df &_image, double &variance)
void NormalizeAverage (const Image3Df &src, const Image3Df &ref, Image3Df &res)
void NormalizeAverageAndVariance (const Image3Df &src, const Image3Df &ref, Image3Df &res)
void ComputeJointHistogramImage (const Image3Df &src, const Image3Df &ref, Image3Df &res, int drawTransferFunction=0, int nbSrcBins=100, int nbRefBins=200)
void NormalizeJointHistogram (const Image3Df &src, const Image3Df &ref, Image3Df &res, int nbSrcBins=100, int nbRefBins=200)
template<class ImageType>
void CenterOfGravity (const ImageType &src, double &mass, Vect3Df &centerOfGravity)
template<class ImageType>
void PrincipalAxes (const ImageType &src, vector< Vect3Df > &pprincipalAxes, double *_mass=NULL, Vect3Df *_centerOfGravity=NULL)
void BoundingBox (const Mask3D &mask, RectZone3Di &bbox)
void Sphere (const Size3D &size, const Vect3Df &C, float r, Image3Df &ima)
void Explode (const Size3D &size, const Vect3Df &C, Field3Df &ima)
void Cone (const Size3D &size, const Vect3Df &P0, const Vect3Df &P1, float r, Image3Df &ima, float ar=4.0)
void NoiseUniform (const Size3D &size, Image3Df &ima, float v0=0, float v1=1)
void NoiseGaussian (const Size3D &size, Image3Df &ima, float v0=0, float v1=1)
void Target (const Size3D &size, Image3Df &ima)
void Bump (const Size3D &size, const Vect3Df &center, float height, float gsize, Image3Df &ima)
void Ramp (const Size3D &size, int direction, float v0, float v1, Image3Df &res, int pos0=-1, int pos1=-1)
void Parallellogram (const Size3D &size, const RectZone3Di &rect, Image3Df &ima)
void RectangularGrid (const Size3D &size, const Size3D &masksize, Image3Df &ima, const Vect3Di *pintersection=NULL)
void ColoredGrid (const Size3D &size, const Size3D &masksize, Mask3D &ima, StructureElementType neighborhoodtype=MORPHO_Cross7)
template<class ImageType>
void SimpleThreshold (const ImageType &src, const typename ImageType::value_type &t, Mask3D &res)
template<class ImageType>
void SimpleThresholds2 (const ImageType &src, const typename ImageType::value_type &t1, const typename ImageType::value_type &t2, Mask3D &res)
template<class ImageType>
void LimitThreshold (const ImageType &src, const typename ImageType::value_type &t1, const typename ImageType::value_type &t2, ImageType &res)
template<class ImageType>
void OtsuThresholds (const ImageType &src, Mask3D &res, int nbClasses=2, vector< double > *pthresholds=NULL, int nbBins=1000)
void UniModalThreshold (const Image3Df &src, double &threshold, Mask3D *res=NULL)
template<class ImageType>
void TransformWithInverseField (const ImageType &imOrig, const Field3Df &field, ImageType &imRes)
template<class ImageType>
void TransformAffine (const ImageType &imOrig, const Affine3DTransform &transfo, ImageType &imDest, const Size3D *resSize=NULL)
template<class ImageType>
void Scale (const ImageType &src, const Size3D &newSize, ImageType &res)
template<class ImageType>
void WrapTranslate (const ImageType &src, const Vect3Di &t0, ImageType &res0)
template<class ImageType>
void Flip (const ImageType &src, const string &axes, ImageType &res0)
template<class ImageType>
void SwapAxes (const ImageType &src, const string &axes, ImageType &res0)
template<>
void TransformWithInverseField< Mask3D > (const Mask3D &imOrig, const Field3Df &field, Mask3D &_imRes)
 Transforming a mask is more complex than for a normal image.
void TransformRectangularGrid (Image3Df &image, const Field3Df &field, const Size3D masksize, bool bAverageField=true)
template<class ImageType>
void AnimateField (const ImageType &imSrc, const Field3Df &field, Image3DSet< ImageType > &resImages, int nSteps=5)
void VoxelCode (const Mask3D &shape, const Mask3D &seeds, int m0, int m1, int m2, LabelImage3D &res, const Vect3Di *stopPoint=NULL)
void SSCode (const Mask3D &shape, const Vect3Di &sourcePoint, int m0, int m1, int m2, LabelImage3D &res, const Vect3Di *stopPoint=NULL)
void BSCode (const Mask3D &shape, int m0, int m1, int m2, LabelImage3D &res)
void ShortestPathExtraction (const Mask3D &shape, const Vect3Di &start, const Vect3Di &end, vector< Vect3Di > &path, Mask3D *pres=NULL, StructureElement *psel=NULL, const LabelImage3D *pssCode0=NULL, ShortestPathExtractionHelpers::StopCBType stopCB=ShortestPathExtractionHelpers::StopCBType(NULL, NULL))
void Skeleton (const Mask3D &shape, Mask3D &res)
template<class ImageType>
void MyTestThreshold (const ImageType &src, const typename ImageType::value_type &t, Mask3D &res, int optional=0)
 Simple Threshold : Result=1 if value>threshold.

Detailed Description

ImageStats.hpp.

Result=1 if value>threshold

Function Documentation

template<class ImageType>
void IP3D::Addition (  const ImageType &  im1,
const ImageType &  im2,
ImageType &  imDest
) 
 

#&Addition&# Adds 2 images Ignores masks.

Source image 1 type:ImageType Source image 2 type:ImageType Result image type:ImageType ~

template<class ImageType>
void IP3D::AdditionWithConstant (  const ImageType &  im1,
const typename ImageType::value_type &  scalarValue,
ImageType &  imDest
) 
 

#&AdditionWithConstant&# Adds an image with a constant scalar value Ignores masks.

Source image 1 type:ImageType Constant type:Im3DValue Result image type:ImageType ~

Referenced by BitImage3D< FieldType, bitsPerValue, ValueType >::operator+=(), and Image3Dlinear< Im3DValue >::operator+=().

template<class ImageType>
void IP3D::Difference (  const ImageType &  im1,
const ImageType &  im2,
ImageType &  imDest
) 
 

#&Difference&# Substracts two images. Ignores masks.

Source image 1 type:ImageType Source image 2 type:ImageType Result image type:ImageType ~

template<class ImageType>
void IP3D::DifferenceWithConstant (  const ImageType &  im1,
const typename ImageType::value_type &  scalarValue,
ImageType &  imDest
) 
 

#&DifferenceWithConstant&# Substracts a constant scalar value from an image. Ignores masks.

Source image 1 type:ImageType Constant type:Im3DValue Result image type:ImageType ~

Referenced by BitImage3D< FieldType, bitsPerValue, ValueType >::operator-=(), and Image3Dlinear< Im3DValue >::operator-=().

template<class ImageType>
void IP3D::Multiplication (  const ImageType &  im1,
const ImageType &  im2,
ImageType &  imDest
) 
 

#&Multiplication&# Multiplies two images. Ignores masks.

Source image 1 type:ImageType Source image 2 type:ImageType Result image type:ImageType ~

template<class ImageType>
void IP3D::MultiplicationWithConstant (  const ImageType &  im1,
double  scalarValue,
ImageType &  imDest
) 
 

#&MultiplicationWithConstant&# Multiplies an image by a constant floating point value. The constant is double-precision. Ignores masks.

Source image type:ImageType Constant type:double Result image type:ImageType ~

Referenced by BitImage3D< FieldType, bitsPerValue, ValueType >::operator *=(), and Image3Dlinear< Im3DValue >::operator *=().

template<class ImageType>
void IP3D::Division (  const ImageType &  im1,
const ImageType &  im2,
ImageType &  imDest
) 
 

#&Division&# Divides two images. Ignores masks.

Source image 1 type:ImageType Source image 2 type:ImageType Result image type:ImageType ~

template<class ImageType>
void IP3D::MaxImage (  const ImageType &  im1,
const ImageType &  im2,
ImageType &  imDest
) 
 

#&MaxImage&# Maximum of two images. Ignores masks.

Source image 1 type:ImageType Source image 2 type:ImageType Result image type:ImageType ~

template<class ImageType>
void IP3D::Abs (  const ImageType &  im1,
ImageType &  imDest
) 
 

#&Abs&# Absolute value of an image. Ignores masks.

Source image 1 type:ImageType Result image type:ImageType ~

Referenced by RobustAverageAndVariance().

template<class ImageType1, class ImageType2>
void IP3D::ImageTypeConversion (  const ImageType1 &  src,
ImageType2 &  res
) 
 

#&ImageTypeConversion&# Converts one image type to another. The conversion must be valid (ie. a conversion operator must exist for the contaned types). Examples use: converting a mask into a floating point image.

Source image type:ImageType Result image type:ImageType Result typename type:ImageTypeName ~

Definition at line 40 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::Crop (  const ImageType &  src,
const RectZone3Di &  zone,
ImageType &  res0
) 
 

#&Crop&# Extract part of an image. (x0,y0,z0) and (x1,y1,z1) Are the bounding boints of the subimage. Both are included. Properties are copied and mask is croped too.

Source image type:ImageType zone type:RectZone3Di Result image type:ImageType ~

template<class ImageType>
void IP3D::FindFirstDifference (  const ImageType &  src1,
const ImageType &  src2,
bool &  found,
Vect3Di &  pos
) 
 

#&FindFirstDifference&# Compares two images til it finds a difference, and returns position. Images must have same size. Ignores masks.

Source image1 type:ImageType Source image2 type:ImageType found difference type:bool position type:Vect3Di ~

Definition at line 71 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::FindMinMax (  const ImageType &  src,
typename ImageType::value_type &  vmin,
typename ImageType::value_type &  vmax,
Vect3Di *  posMin = NULL,
Vect3Di *  posMax = NULL
) 
 

#&FindMinMax&# Finds minimum and maximum values of an image. Optionally resturns position of those values Ignores masks.

Source image type:ImageType min type:Im3DValue max type:Im3DValue min position type:Vect3Di max position type:Vect3Di ~

Definition at line 95 of file ConvenienceProcessors.hpp.

Referenced by ProbabilityDistribution::SetWithImage3Dlinear3().

template<class ImageType>
void IP3D::L2Norm (  const ImageType &  src,
double &  energy
) 
 

#&L2Norm&# ~

Definition at line 121 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::SetAllVoxels (  const ImageType &  src,
const typename ImageType::value_type &  v,
ImageType &  res
) 
 

#&SetAllVoxels&# Sets all voxels of image to a specified value. Value is constructed from string argument using the FromString overloaded template.

Source image type:ImageType v type:Im3DValue Result image type:ImageType ~

Definition at line 139 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::AddMask (  const ImageType &  src,
ImageType &  res,
const Mask3D *  mask = NULL
) 
 

#&AddMask&# Adds a mask to an image. Mask image can be specified by an optional third argument. Otherwise mask is intialized to 1. If image already contains a mask, this mask will be assigned the optional argument or will be left untouched.

Source image type:ImageType Result image type:ImageType Mask type:Mask3D ~

Definition at line 159 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::GetMask (  const ImageType &  src,
Mask3D &  res
) 
 

#&GetMask&# Gets the mask of an image.

Source image type:ImageType Result Mask type:Mask3D ~

Definition at line 180 of file ConvenienceProcessors.hpp.

References Image3D::Mask().

template<class ImageType>
void IP3D::ApplyMask (  const ImageType &  src,
ImageType &  res,
byte  maskvalue = 0,
const Mask3D *  optmask = NULL
) 
 

#&ApplyMask&# Applies a mask on an image. For maskvalue=0, image will be masked for all non-zero mask values. For maskvalues > 0, the mask will be first thresholded so that a mask corresponding to the label maskvalue will be used for masking. If no mask is provided the mask of the source will be used.

Source image type:ImageType Result image type:ImageType Mask value type:byte Mask type:Mask3D ~

template<class ImageType>
void IP3D::SetDefaultInterpolator (  const ImageType &  src,
const string &  name,
ImageType &  res
) 
 

#&SetDefaultInterpolator&# Sets the default interpolator type name. By default spline degree 5 interpolation is used (this can be slow).

Source image type:ImageType Interpolator type name type:string Result image type:ImageType ~

Definition at line 216 of file ConvenienceProcessors.hpp.

template<class ComplexImageType>
void IP3D::ExtractFromComplexImage (  const ComplexImageType &  src,
const string &  type,
Image3Df &  res
) 
 

#&ExtractFromComplexImage&# Extracts Imag, Real, Norm2 or Module from a complex valued image into a Image3Df. No masks

Source image type:Image3Dcomplexf result type type:string Result image type:Image3Df ~

template<class ImageType>
void IP3D::SetProperty (  const ImageType &  src,
const string &  name,
const string &  typeName,
string  value,
ImageType &  res
) 
 

#&SetProperty&# Set a named image property. Image properties are referenced by name, have a type (float,int, string etc.).

Source image type:ImageType name type:string typeName type:string value type:string Result image type:ImageType ~

Definition at line 252 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::RemoveProperty (  const ImageType &  src,
const string &  name,
ImageType &  res
) 
 

#&RemoveProperty&# Sets the default interpolator type name. By default spline degree 5 interpolation is used (this can be slow).

Source image type:ImageType Interpolator type name type:string Result image type:ImageType ~

Definition at line 276 of file ConvenienceProcessors.hpp.

template<class ImageType>
void IP3D::Pad (  const ImageType &  src,
Vect3Di  paddingV,
ImageType &  res,
bool  padLinear = false
) 
 

#&Pad&# Add space around an image. If padLinear is true, the border will be filled with linearly decreasing values. The padding argument gives the amount of space to be added in each 6 directions.

Source image type:ImageType padding type:Vect3Di Result image type:ImageType pad linear type:bool ~

Definition at line 298 of file ConvenienceProcessors.hpp.

References InsertImage(), Vect3D< Value, Real >::Norm(), Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

template<class ImageType>
void IP3D::Convolution (  const ImageType &  imToConvolve,
const Filter &  imFilter,
ImageType &  imResult
) 
 

#&Convolution&# Convolution of an image by a user defined filter. The filter class is just like a float valued image, with a center point added. Ignores masks.

Source image type:ImageType Filter type:Filter Result image type:ImageType ~

template<class ImageType>
void IP3D::SeparableConvolution (  const ImageType &  imToConvolve,
const SeparableFilter &  filter,
ImageType &  imResult
) 
 

#&SeparableConvolution&# Convolution of an image by a user defined filter. The filter class is just like a float valued image, with a center point added. Ignores masks.

Source image type:ImageType Separable filter type:SeparableFilter Result image type:ImageType ~

Referenced by SymmetricBinomialFilter().

template<class ImageType>
void IP3D::ConvolutionFFT (  const ImageType &  imToConvolve,
const Filter &  imFilter,
ImageType &  imResult
) 
 

#&ConvolutionFFT&# Convolution of an image by a user defined filter using FFT. It uses multiplication in fourier domain with forward and inverse fft. This is faster than normal convolution for lmarge filter sizes. Ignores masks. UNIMPLEMENTED!

Source image type:ImageType Filter type:Filter Result image type:ImageType ~

template<class ImageType>
void IP3D::PartialSum (  const ImageType &  cumSum,
const RectZone3Di &  r0,
typename ImageType::value_type &  res
) 
 

#&PartialSum&# Computes the sum of an image in a rectangular zone. It uses an image computed using CumulativeSum. This is a fast way of doing filtering with big square convolution filters. Result is the sum of all points in the rectzone: the rectzone *includes both* of its defining points.

CumulativeSum image type:ImageType zone type:RectZone3Di result type:Im3DValue ~

Definition at line 100 of file Convolution.hpp.

Referenced by CumulativeSum().

template<class ImageType>
void IP3D::CumulativeSum (  const ImageType &  src,
ImageType &  res0
) 
 

#&CumulativeSum&# Computes an image that I(i,j,k)=Sum(0<=r<=i, 0<=s<=j , 0<=t<=k : S(r,s,t) ) This can be used by PartialSum for fast filtering.

Source image type:ImageType Result image type:ImageType ~

Definition at line 128 of file Convolution.hpp.

References PartialSum(), Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

template<class ImageType>
void IP3D::BoxFilter (  const ImageType &  src,
int  size,
ImageType &  res0
) 
 

#&BoxFilter&# Very fast convolution by an integer sized box signal Ignores masks. Variance of the filter is 1/12*(size*size-1).

Source image type:ImageType size type:int Result image type:ImageType ~

Definition at line 157 of file Convolution.hpp.

Referenced by GaussianApproxFilter().

template<class ImageType>
void IP3D::GaussianApproxFilter (  const ImageType &  src,
int  order,
int  size,
ImageType &  res
) 
 

#&GaussianApproxFilter&# Fast convolution by an approximate "integer" guassian filter/ This just applies several boxfilters (boxsize=size and order times), and is only efficient for low orders. Ignores masks. If size is pair, the order must also be pair for the resulting image to lay on the same grid (else translated 0.5 voxel towards (0,0,0).

Source image type:ImageType order type:int size type:int Result image type:ImageType ~

Definition at line 225 of file Convolution.hpp.

References BoxFilter(), and WrapTranslate().

Referenced by BorderCorrectedGaussianApproxFilter().

template<class ImageType>
void IP3D::BorderCorrectedGaussianApproxFilter (  const ImageType &  src,
int  size,
int  nbFilterIter,
ImageType &  res
) 
 

#&BorderCorrectedGaussianApproxFilter&# GaussianApproxFilter with compensation on image borders and mask borders Attenuation on border regions and border of masked regions is compensated. This is equivalent of gaussian filtering using only filter coefficients that are inside the "shape" being considered.

Source image type:ImageType order type:int size type:int Result image type:ImageType ~

Definition at line 253 of file Convolution.hpp.

References Container3D< Im3DValue >::Fill(), GaussianApproxFilter(), and Image3D::Mask().

template<class ImageType>
void IP3D::SymmetricBinomialFilter (  const ImageType &  src,
int  order,
ImageType &  res
) 
 

#&SymmetricBinomialFilter&# Convolution by a binomial filter/ Order should be pair to permit resulting image to be on the same grid as the original image. The filtering is quite long for high orders. This is equivalent to using the BoxFilter of size=2 of the same order, but a lot faster for high orders. A BinomialFilter approximates the Gaussian so that the variance=order/4.

Source image type:ImageType order type:int Result image type:ImageType ~

Definition at line 299 of file Convolution.hpp.

References SeparableConvolution().

void IP3D::FFTLowPassFilterApodizedIdeal (  const Image3Df &  src,
float  cutoffFreq,
Image3Df &  res,
float  rolloffFactor = 0
) 
 

#&FFTLowPassFilterApodizedIdeal&# Low pass filtering using fft. Multiplies in fourrier domain by an cosine-shaped apodized rectangular window. Cutoff frequency should be between 0 and 1. Rolloff factor between 0 and 1 describes smoothness of cutoff. rolloff=0 means filter is square.

Source image type:Image3Df cutoff frequency type:float Result image type:Image3Df rolloff factor type:float ~

void IP3D::FFTLowPassFilterButterworth (  const Image3Df &  src,
float  cutoffFreq,
float  order,
Image3Df &  res
) 
 

#&FFTLowPassFilterButterworth&# Low pass filtering using fft. Multiplies in fourrier domain by 1/(1+(r/r0)^2n). Cutoff frequency should be between 0 and 1. For n=inf this is an ideal lowpass filter. For n=1 this is a smooth filter.

Source image type:Image3Df cutoff frequency type:float order type:float Result image type:Image3Df ~

void IP3D::FFTLowPassFilterChebyscheff (  const Image3Df &  src,
float  cutoffFreq,
float  order,
Image3Df &  res
) 
 

#&FFTLowPassFilterChebyscheff&# Low pass filtering using fft. Multiplies in fourrier domain by 1/(1+(cos(n*acos(r/r0))^2)). Cutoff frequency should be between 0 and 1. For n=inf this is an ideal lowpass filter. For n=1 this is a smooth filter.

Source image type:Image3Df cutoff frequency type:float order type:float Result image type:Image3Df ~

template<class ImageType>
void IP3D::DrawSegment3D (  const ImageType &  src,
const Segment3D &  segment,
const Pen< typename ImageType::value_type > &  pen,
ImageType &  res
) 
 

#&DrawSegment3D&# ~

template<class ImageType>
void IP3D::ImageFromRawData (  const typename ImageType::value_type *  data,
const Size3D &  size,
string  order,
ImageType &  res,
bool  reverseEndian = false
) 
 

#&ImageFromRawData&# Create an ImLib3D image from raw data. The image type determines the raw data type (for example Image3Df will assume data is float). The byte ordering in the raw data is given by a three letter string (ex."ZXY"). Example: imlib3d ImageFromRawData "Image3Dlinear<short int>" rare_cra.img 128 128 128 ZXY res.im3D true im ImageTypeConversion res.im3D res1.im3D Image3Df imlib3dview res1.im3D

Result typename type:ImageTypeName Raw data type:raw data Image size type:Size3D Raw data ordering type:string Result image type:ImageType ReverseEndian type:bool ~

Definition at line 92 of file FileConversion.hpp.

References Size3D::GetV(), Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

template<class ImageType>
void IP3D::RawDataFromImage (  const ImageType &  src,
string  order,
typename ImageType::value_type **  pres,
bool  reverseEndian = false
) 
 

#&RawDataFromImage&# Create an raw binary data from an image. The image type determines the raw data type (for example Image3Df will assume data is float). The byte ordering in the raw data is given by a three letter string (ex."ZXY").

Source image type:ImageType Raw data ordering type:string Raw data type:data ReverseEndian type:bool ~

Definition at line 130 of file FileConversion.hpp.

References Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

template<class ImageType>
void IP3D::WriteToFileAVW (  const ImageType &  src,
const string &  fname
) 
 

#&WriteToFileAVW&# Write an image in AVW/Analyze format.

Source image type:ImageType Filename Base type:string ~

Definition at line 167 of file FileConversion.hpp.

template<class ImageType>
void IP3D::ReadFromFileAVW (  const string &  fname,
ImageType &  res
) 
 

#&ReadFromFileAVW&# Read an image in AVW/Analyze format.

Filename Base type:string Image type:ImageType ~

Definition at line 195 of file FileConversion.hpp.

void IP3D::ReadFromFileBruker (  const string &  fname,
int  imageNumber,
Image3Dlinear< short int > &  res
) 
 

#&ReadFromFileBruker&# Dirty hack for reading an image in brucker format. This probably wont work for you...

Filename Base type:string Image number type:int Image type:Image3Dlinear<short int> ~

template<class ImageType>
void IP3D::ExportImageSlice (  const ImageType &  src,
int  direction,
int  position,
const string &  fname,
float  rescale = 1
) 
 

#&ExportImageSlice&# Save a slice of an image in ppm format Takes a slice in a given direction (0=yz 1=xy 2=xy) and position and saves it in ppm format. By default image values are scaled to fit in ppm range. rescale=0, specifies that no rescaling should be done. rescale between 0 and 1, specifies that rescaling should be done so that the specified portion of the image values fits into the ppm range. If rescale values are between -1 and 0, then rescaling is done using values of the whole image (not just the slice), this is usefull if you want extracting a series of slices from the same image and want all thes slices to have the same constrast. -.98 is generally good for medical images.

src type:ImageType direction type:int position type:int filename type:string rescale type:float ~

Definition at line 257 of file FileConversion.hpp.

template<class ImageType>
void IP3D::ScalarProduct (  const ImageType &  im1,
const ImageType &  im2,
double &  retValue
) 
 

#&ScalarProduct&# No Doc Ignores masks.

Source image 1 type:ImageType Source image 2 type:ImageType Result type:double ~

void IP3D::RobustAverageAndVariance (  const Image3Df &  src,
double &  average,
double &  variance
) 
 

#&RobustAverageAndVariance&# Computes the average and the variance of an images using a robust technique. Robust (outlier rejection) technique is: median for average, 1.4826 median absolute deviation for std dev.

Source image type:Image3Df Average type:double Variance type:double ~

Definition at line 28 of file ImageStats.cpp.

References Abs(), and Median().

template<class ImageType>
void IP3D::Average (  const ImageType &  src,
typename ImageType::value_type &  average
) 
 

#&Average&# Computes the average and the variance of an images. Only for positions where mask is not 0.

Source image type:ImageType Average type:Im3DValue ~

Definition at line 40 of file ImageStats.hpp.

template<class ImageType>
void IP3D::AverageAndVariance (  const ImageType &  src,
double &  average,
double &  variance
) 
 

#&AverageAndVariance&# Computes the average and the variance of an images. Only for positions where mask is not 0.

Source image type:ImageType Average type:double Variance type:double ~

Definition at line 60 of file ImageStats.hpp.

template<class ImageType>
void IP3D::Median (  const ImageType &  src,
double &  res,
double  part = .5,
double  precision = -.1
) 
 

#&Median&# Median value of an image, or more generaly: portion of histogram. This is NOT a median filter (see MedianFilter). For 0<=p<=1, Image I. Computes value v of image for which Porba(I(P)<v)=p. For exmaple, for p=.5, v=median value of I. Uses mask.

Source image. type:ImageType Histogram portion type:double Variance type:double ~
Parameters:
part  .5 for median

Definition at line 102 of file ImageStats.hpp.

Referenced by RobustAverageAndVariance().

template<class ImageType>
void IP3D::InsertImage (  const ImageType &  src,
const ImageType &  insert,
const Vect3Di &  pos,
ImageType &  res
) 
 

#&InsertImage&# Draws an image into another image. (x,y,z) Position where to insert image.

Source image type:ImageType Image to insert type:ImageType position type:Vect3Di Result image type:ImageType ~

Definition at line 46 of file InsertImage.hpp.

Referenced by Pad().

template<class ImageType>
void IP3D::MedianFilter (  const ImageType &  src,
const StructureElement &  mask,
ImageType &  res
) 
 

#&MedianFilter&# Median filter. Replaces each voxel by the median value of all of it's neighbors. Neighbors are defined by structure element argument. Ignores masks.

Source image type:ImageType StructureElement type:StructureElement Result image type:ImageType ~

template<class ImageType>
void IP3D::SharpeningFilter (  const ImageType &  src,
const StructureElement &  mask,
ImageType &  res
) 
 

#&SharpeningFilter&# Sharpening filter. Replaces each voxel by the min or max value of all of it's neighbors, whichever value is closer. If both are equivalent, leaves voxel untouched. Neighbors are defined by structure element argument. Ignores masks.

Source image type:ImageType StructureElement type:StructureElement Result image type:ImageType ~

template<class ImageType>
void IP3D::Erosion (  const ImageType &  src,
const StructureElement &  mask,
ImageType &  res
) 
 

#&Erosion&# Morphological erosion. Replaces each voxel by the minimum value of all of it's neighbors. Ignores masks.

Source image type:ImageType StructureElement type:StructureElement Result image type:ImageType ~

Referenced by BSCode(), Closing(), and Opening().

template<class ImageType>
void IP3D::Dilation (  const ImageType &  src,
const StructureElement &  mask,
ImageType &  res
) 
 

#&Dilation&# Morphological dilation. Replaces each voxel by the maximum value of all of it's neighbors. Ignores masks.

Source image type:ImageType StructureElement type:StructureElement Result image type:ImageType ~

Referenced by Closing(), and Opening().

template<class ImageType>
void IP3D::Opening (  const ImageType &  src,
const StructureElement &  mask,
ImageType &  res
) 
 

#&Opening&# Morphological opening. Succesively applies an erosion and a dilation.

Source image type:ImageType StructureElement type:StructureElement Result image type:ImageType ~

Definition at line 370 of file MorphologicalOperators.hpp.

References Dilation(), and Erosion().

template<class ImageType>
void IP3D::Closing (  const ImageType &  src,
const StructureElement &  mask,
ImageType &  res
) 
 

#&Closing&# Morphological closing. Succesively applies an dilation and a erosion.

Source image 1 type:ImageType StructureElement type:StructureElement Result image type:ImageType ~

Definition at line 388 of file MorphologicalOperators.hpp.

References Dilation(), and Erosion().

void IP3D::DistanceTransform (  const Mask3D &  src,
const StructureElement &  mask,
Image3Df &  res,
bool  borderExtend = false
) 
 

#&DistanceTransform&# Distance to closest non zero point. Approximate distance within set, from inside outside of set. This is a fast, two pass algorithm. The StructureElement contains coefficients that define the distance to each neighbor. FIXME: These coeficients are currently not optimal, and give a slightly biased distance. By default outside of image is considered outside of shape. If border extend is true, outside of image ignored

Source image type:Mask3D StructureElement type:StructureElement Result image type:Image3Df border extend type:bool ~

template<class ImageType>
void IP3D::ConnectedComponentLabelling (  const ImageType &  src,
const StructureElement &  mask0,
LabelImage3D &  res,
typename ImageType::value_type *  background0 = NULL
) 
 

#&ConnectedComponentLabelling&# Creates an integer valued image where each set of connected neighbors of source image has a seperate value. Result values go from 0 to n. Where n is the total number of separate connected components in the image. Definition of neighbors uses StructureElement.

Source image type:Mask3D StructureElement type:StructureElement Result image type:Image3Dlinear<int> ~

Referenced by SkeletonExtraction::CreateClusters().

void IP3D::FillHoles (  const Mask3D &  src,
const StructureElement &  mask,
Mask3D &  res
) 
 

#&FillHoles&# Sets to 1 all points that are not connected to the outside of the source image. Definition of neighbors uses StructureElement. Algorithm simply uses ConnectedComponentLabelling of an enlarged image.

Source image type:Mask3D StructureElement type:StructureElement Result image type:Mask3D ~

template<class ImageType>
void IP3D::MakeValueList (  const ImageType &  src,
ImageValues< typename ImageType::value_type > &  res
) 
 

#&MakeValueList&# Maps value to size, used for getting largest connected component... Needs name cleanup, will be renamed. Ignores masks.

Source image type:ImageType Maps value to size type:ImageValues ~

void IP3D::LargestConnectedComponent (  const Mask3D &  src,
Mask3D &  res
) 
 

#&LargestConnectedComponent&# Selects the largest connected component. Usefull after thresholding. Uses ConnectedComponentLabelling

Source image type:Mask3D Result image type:Mask3D ~

void IP3D::NoiseVarianceEstimation (  const Image3Df &  _image,
double &  variance
) 
 

#&NoiseVarianceEstimation&# Estimates the noise in an image. Uses the difference of to Laplacian filters (size 3x3x3) to estimate the noise variance.

Source image type:Image3Df Result Variance type:double ~

void IP3D::NormalizeAverage (  const Image3Df &  src,
const Image3Df &  ref,
Image3Df &  res
) 
 

#&NormalizeAverage&# Normalizes the average of two images. Uses masks.

Source image type:Image3Df Reference image type:Image3Df Result image type:Image3Df ~

void IP3D::NormalizeAverageAndVariance (  const Image3Df &  src,
const Image3Df &  ref,
Image3Df &  res
) 
 

#&NormalizeAverageAndVariance&# Forces average and variance to be the same as in reference image. Uses masks.

Source image type:Image3Df Reference image type:Image3Df Result image type:Image3Df ~

void IP3D::ComputeJointHistogramImage (  const Image3Df &  src,
const Image3Df &  ref,
Image3Df &  res,
int  drawTransferFunction = 0,
int  nbSrcBins = 100,
int  nbRefBins = 200
) 
 

#&NormalizeJointHistogram&# Forces histogram to be the nearly the same as in reference image. Uses masks.

Source image type:Image3Df Reference image type:Image3Df Result image type:Image3Df Number of src bins type:int Number of ref bins type:int ~

void IP3D::NormalizeJointHistogram (  const Image3Df &  src,
const Image3Df &  ref,
Image3Df &  res,
int  nbSrcBins = 100,
int  nbRefBins = 200
) 
 

#&NormalizeJointHistogram&# Forces histogram to be the nearly the same as in reference image. Uses masks.

Source image type:Image3Df Reference image type:Image3Df Result image type:Image3Df Number of src bins type:int Number of ref bins type:int ~

template<class ImageType>
void IP3D::CenterOfGravity (  const ImageType &  src,
double &  mass,
Vect3Df &  centerOfGravity
) 
 

#&CenterOfGravity&# Computes mass, center of mass

image of weighted shape type:ImageType mass type:double center of mass type:Vect3Df ~

Definition at line 38 of file ShapeAnalysis.hpp.

References Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

template<class ImageType>
void IP3D::PrincipalAxes (  const ImageType &  src,
vector< Vect3Df > &  pprincipalAxes,
double *  _mass = NULL,
Vect3Df *  _centerOfGravity = NULL
) 
 

#&PrincipalAxes&# Computes principal axes of weighted shape, optionally mass and center of mass,

image of weighted shape type:ImageType axes type:vector<Vect3Df> mass type:double center of mass type:Vect3Df ~

for object orientation

Definition at line 70 of file ShapeAnalysis.hpp.

References Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

void IP3D::BoundingBox (  const Mask3D &  mask,
RectZone3Di &  bbox
) 
 

#&BoundingBox&# Finds bounding box of a mask

Source Image type:Mask3D Bounding Box type:RectZone3Di ~

void IP3D::Sphere (  const Size3D &  size,
const Vect3Df &  C,
float  r,
Image3Df &  ima
) 
 

#&Sphere&# Draws a sphere. Input: image size

Image size type:Size3D center type:Vect3Df radius type:float Result image type:Image3Df ~

void IP3D::Explode (  const Size3D &  size,
const Vect3Df &  C,
Field3Df &  ima
) 
 

#&Explode&# Creates a field where vectors point away from a specified center. The falue of the field a point P is: F(P)=P-C

Image size type:Size3D Center type:Vect3Df Result image type:Field3Df ~

void IP3D::Cone (  const Size3D &  size,
const Vect3Df &  P0,
const Vect3Df &  P1,
float  r,
Image3Df &  ima,
float  ar = 4.0
) 
 

#&Cone&# Draws a cone. Input: image size,base's center. Point.

Image size type:Size3D center type:Vect3Df point type:Vect3Df radius type:float Result image type:Image3Df antialiasing falloff radius type:float ~

void IP3D::NoiseUniform (  const Size3D &  size,
Image3Df &  ima,
float  v0 = 0,
float  v1 = 1
) 
 

#&NoiseUniform&# Creates an image with uniform noise.

Image size type:Size3D Result image type:Image3Df min value type:float max value type:float ~

void IP3D::NoiseGaussian (  const Size3D &  size,
Image3Df &  ima,
float  v0 = 0,
float  v1 = 1
) 
 

#&NoiseGaussian&# Creates an image with gaussian noise.

Image size type:Size3D Result image type:Image3Df average type:float variance type:float ~

void IP3D::Target (  const Size3D &  size,
Image3Df &  ima
) 
 

#&Target&# Creates an image with target like pattern. Spatial frequency increases radially from center of image.

Image size type:Size3D Result image type:Image3Df ~

void IP3D::Bump (  const Size3D &  size,
const Vect3Df &  center,
float  height,
float  gsize,
Image3Df &  ima
) 
 

#&Bump&# Creates a gaussian bump. Given a center, bump height, and std dev

Image size type:Size3D center type:Vect3Df height type:float size type:float Result image type:Image3Df ~

void IP3D::Ramp (  const Size3D &  size,
int  direction,
float  v0,
float  v1,
Image3Df &  res,
int  pos0 = -1,
int  pos1 = -1
) 
 

#&Ramp&# Creates an image containing a linearly from v0 to v1 in a given direction. pos0 and pos1 give the begining and end of the ramp. If pos0 is negative (default) then pos0=0. If pos1 is negative (default) then pos1=size of image in given direction. directions:0=X 1=Y 2=Z

Image size type:Size3D direction type:int v0 type:float v1 type:float Result image type:Image3Df pos0 type:int pos1 type:int ~

void IP3D::Parallellogram (  const Size3D &  size,
const RectZone3Di &  rect,
Image3Df &  ima
) 
 

#&Parallellogram&# Creates an image with a parallellogram. Both points are included.

Image size type:Size3D zone type:RectZone3Di Result image type:Image3Df ~

void IP3D::RectangularGrid (  const Size3D &  size,
const Size3D &  masksize,
Image3Df &  ima,
const Vect3Di *  pintersection = NULL
) 
 

#&RectangularGrid&# Creates an image with a grid

Result image type:Image3df width type:int height type:int depth type:int masksize.x type:int masksize.y type:int masksize.z type:int [opt] intersection.x type:int [opt] intersection.y type:int [opt] intersection.z type:int

void IP3D::ColoredGrid (  const Size3D &  size,
const Size3D &  masksize,
Mask3D &  ima,
StructureElementType  neighborhoodtype = MORPHO_Cross7
) 
 

#&ColoredGrid&# Creates an image where no two neighbors have the same colors

Result image type:Mask3D width type:int height type:int depth type:int masksize.x type:int masksize.y type:int masksize.z type:int [opt] neighborhood type type:int

template<class ImageType>
void IP3D::SimpleThreshold (  const ImageType &  src,
const typename ImageType::value_type &  t,
Mask3D &  res
) 
 

#&SimpleThreshold&# Simple Threshold. Result=1 if value>threshold. Result is a Mask3D.

Source image type:ImageType Threshold type:Im3DValue Result mask type:Mask3D ~

Definition at line 41 of file Threshold.hpp.

References Container3D< Im3DValue >::begin(), and Container3D< Im3DValue >::Resize().

Referenced by IP3D::UniModalThreshold().

template<class ImageType>
void IP3D::SimpleThresholds2 (  const ImageType &  src,
const typename ImageType::value_type &  t1,
const typename ImageType::value_type &  t2,
Mask3D &  res
) 
 

#&SimpleThresholds2&# Simple Threshold between 2 values Result is 1 for values between t1 and t2, 0 otherwise.

Source image type:ImageType Threshold 1 type:Im3DValue Threshold 2 type:Im3DValue Result mask type:Mask3D ~

Definition at line 67 of file Threshold.hpp.

References Container3D< Im3DValue >::begin(), and Container3D< Im3DValue >::Resize().

template<class ImageType>
void IP3D::LimitThreshold (  const ImageType &  src,
const typename ImageType::value_type &  t1,
const typename ImageType::value_type &  t2,
ImageType &  res
) 
 

#&LimitThreshold&# Limits range of image values to t1 t2 If image value less than t1 or image value greater than t2 then image value equals t1 or t2 respectively, otherwise conserves original value. Keeps mask

Source image type:ImageType Lower limit type:Im3DValue Upper limit type:Im3DValue Result image type:ImageType ~

Definition at line 97 of file Threshold.hpp.

template<class ImageType>
void IP3D::OtsuThresholds (  const ImageType &  src,
Mask3D &  res,
int  nbClasses = 2,
vector< double > *  pthresholds = NULL,
int  nbBins = 1000
) 
 

#&OtsuThresholds&# Use otsu histogram partitioning to automatically determine thresholds and apply them on an image. The algorithm brute-force searches all possible threshhold combinations to find the one that minimizes interclass variance. This can be long if the number of classes is high.

Source image type:ImageType Result image type:Mask3D Number of classes type:int Result thresholds type:vector<double> Number of bins in histogram type:int ~

void IP3D::UniModalThreshold (  const Image3Df &  src,
double &  threshold,
Mask3D *  res = NULL
) 
 

#&UniModalThreshold&#

template<class ImageType>
void IP3D::TransformWithInverseField (  const ImageType &  imOrig,
const Field3Df &  field,
ImageType &  imRes
) 
 

#&TransformWithInverseField&# Use a vector field to apply a deformation on an image. If F is a vector field (3D image composed of 3D vectors), S the source image,R the result image, and P a point, we have: R(P)=S(P+F(P)). If no interpolator is present in source image, it will use a bspline 5th degree interpolator. If a mask is present, it will be transformed by creating seperate binary images for each different intensity value in the mask. Each binary (0 or 1) image is transformed using an interpolator (default bspline 5). The result mask is constructed by recombining the transformed floating point binary images. This gives MUCH better results than would be obtained by using nearest neighbor interpolation. This is however, very slow if mask contains many different intensity values.

Source image 1 type:ImageType Deformation field type:Image3Dlinear<Vect3Df> Result image type:ImageType ~

Referenced by IP3D::TransformAffine(), and IP3D::TransformWithInverseField().

template<class ImageType>
void IP3D::TransformAffine (  const ImageType &  imOrig,
const Affine3DTransform &  transfo,
ImageType &  imDest,
const Size3D *  resSize = NULL
) 
 

#&TransformAffine&# Perform an affine transformation on an image Affine transforms are described by a 3x3 matrix and a translation vector. They can be stored in an ImLib3D format file (see Affine3DTransform). If no interpolator is present in source image, it will use a bspline 5th degree interpolator. If a mask is present, it will be transformed as described in TransformWithInverseField. If optional size is not ommited, result image will have same size as source image.

Source image 1 type:ImageType Affine transform type:Affine3DTransform Result image type:ImageType Result image size type:Size3D ~

Referenced by Scale().

template<class ImageType>
void IP3D::Scale (  const ImageType &  src,
const Size3D &  newSize,
ImageType &  res
) 
 

#&Scale&# Change image size using resampling If no interpolator is present in source image, it will use a bspline 5th degree interpolator. If a mask is present, it will be transformed as described in TransformWithInverseField.

Source image 1 type:ImageType New Size type:Size3D Result image type:ImageType ~

Definition at line 100 of file Transformation.hpp.

References Size3D::depth, Size3D::height, Affine3DTransform::SetScale(), TransformAffine(), and Size3D::width.

template<class ImageType>
void IP3D::WrapTranslate (  const ImageType &  src,
const Vect3Di &  t0,
ImageType &  res0
) 
 

#&WrapTranslate&# Translates an image by integer vector, and wraps around Transforms any masks as well.

Source image 1 type:ImageType dV type:Vect3Di Result image type:ImageType ~

Definition at line 121 of file Transformation.hpp.

References Vect3D< Value, Real >::x, Vect3D< Value, Real >::y, and Vect3D< Value, Real >::z.

Referenced by GaussianApproxFilter().

template<class ImageType>
void IP3D::Flip (  const ImageType &  src,
const string &  axes,
ImageType &  res0
) 
 

#&Flip&# Flips image in one or more directions This is usefull when using images from various sources. Second argument is a string containing directions in which to flip. example: "XY"

Source image type:ImageType direction type:string Result image type:ImageType ~

Definition at line 162 of file Transformation.hpp.

template<class ImageType>
void IP3D::SwapAxes (  const ImageType &  src,
const string &  axes,
ImageType &  res0
) 
 

#&SwapAxes&# Swaps axes This is usefull when using images from various sources. Second argument is a string containing axes to swap. example: "XY" will invert x and y axes

Source image type:ImageType direction type:string Result image type:ImageType ~

Definition at line 204 of file Transformation.hpp.

References ImageProcessorArgs< ImageType >::GetDest(), and ImageProcessorArgs< ImageType >::SetDestSize().

template<>
void IP3D::TransformWithInverseField< Mask3D > (  const Mask3D &  src,
const Field3Df &  field,
Mask3D &  res0
) 
 

Transforming a mask is more complex than for a normal image.

Each value has to be considered as a distinct labe, and normal interpolation is meaningless (it would mix labels!). Here we solve the problem by independently transforming each label value, and then recomposing a final result mask by voting

use label=0 as default

void IP3D::TransformRectangularGrid (  Image3Df &  image,
const Field3Df &  field,
const Size3D  masksize,
bool  bAverageField = true
) 
 

#&TransformRectangularGrid&# Forward transformation of a rectangular grid. Grid points are forward transformed and lines are drawn between them. It takes quite some time...

Source image type:Image3Df Source field type:Image3Dlinear<Vect3Df> masksize type:Size3D average vector field type:bool ~

template<class ImageType>
void IP3D::AnimateField (  const ImageType &  imSrc,
const Field3Df &  field,
Image3DSet< ImageType > &  resImages,
int  nSteps = 5
) 
 

#&AnimateField&# Apply a field weighted by linear weight factors to an image. No long description

Source image type:ImageType Source field type:Image3Dlinear<Vect3Df> Save prefix type:string Number of Steps type:int ~

void IP3D::VoxelCode (  const Mask3D &  shape,
const Mask3D &  seeds,
int  m0,
int  m1,
int  m2,
LabelImage3D &  res,
const Vect3Di *  stopPoint = NULL
) 
 

#&VoxelCode&# Sort of distance transform of a shape, starting from seed points, and using an integer metric m0 is the "distance" associated with F-Neighbors (Cross7). m1 is the "distance" associated with e-Neighbors (Planar19). m2 is the "distance" associated with v-Neighbors (Cubic27). Example values are m0=1,m1=2,m2=3, or m0=3,m1=4,m2=5.

Shape type:Mask3D Seed type:Mask3D m0 type:int m1 type:int m2 type:int resulting codes type:Image3Dlinear<int> ~

Referenced by BSCode(), and SSCode().

void IP3D::SSCode (  const Mask3D &  shape,
const Vect3Di &  sourcePoint,
int  m0,
int  m1,
int  m2,
LabelImage3D &  res,
const Vect3Di *  stopPoint = NULL
)  [inline]
 

#&SSCode&# VoxelCode starting from a single seed point For example, this is usefull for shortest path extraction

Shape type:Mask3D p0 type:Vect3Di m0 type:int m1 type:int m2 type:int resulting codes type:Image3Dlinear<int> start type:Vect3Di ~

Definition at line 61 of file VoxelCoding.hpp.

References Container3D< Im3DValue >::Fill(), Image3D::Size(), and VoxelCode().

Referenced by IP3D::ShortestPathExtraction().

void IP3D::BSCode (  const Mask3D &  shape,
int  m0,
int  m1,
int  m2,
LabelImage3D &  res
)  [inline]
 

#&BSCode&# VoxelCode starting from boundary points of shape This is pretty much like a distance transform

Shape type:Mask3D m0 type:int m1 type:int m2 type:int resulting codes type:Image3Dlinear<int> ~

Definition at line 82 of file VoxelCoding.hpp.

References Erosion(), MORPHO_Cross7, and VoxelCode().

void IP3D::ShortestPathExtraction (  const Mask3D &  shape,
const Vect3Di &  start,
const Vect3Di &  end,
vector< Vect3Di > &  path,
Mask3D *  pres = NULL,
StructureElement *  psel = NULL,
const LabelImage3D *  pssCode0 = NULL,
ShortestPathExtractionHelpers::StopCBType  stopCB = ShortestPathExtractionHelpers::StopCBType(NULL, NULL)
) 
 

#&ShortestPathExtraction&# Shortest path between two points using VoxelCoding

Shape type:Mask3D start type:Vect3Di end type:Vect3Di path type:vector<Vect3Di> res image type:Mask3D sel type:StructureElement ssCode type:Image3Dlinear<int> ~

void IP3D::Skeleton (  const Mask3D &  shape,
Mask3D &  res
)  [inline]
 

#&Skeleton&# Centerline (1-D Skeleton) of a 3D shape The algorithm is described in Zhou and Toga 99. WARNING: this implementation is still a bit buggy, and the algo doesn't seem to be very good anyways.

Shape type:Mask3D Skeleton type:Mask3D ~

Definition at line 349 of file VoxelCoding.hpp.

References Container3D< Im3DValue >::Fill(), Container3D< Im3DValue >::Resize(), and Image3D::Size().

template<class ImageType>
void IP3D::MyTestThreshold (  const ImageType &  src,
const typename ImageType::value_type &  t,
Mask3D &  res,
int  optional = 0
) 
 

Simple Threshold : Result=1 if value>threshold.

An image pocessor is a function in the IP3D namespace that has a full xml description

Definition at line 13 of file plugin.hpp.

References Container3D< Im3DValue >::begin(), and Container3D< Im3DValue >::Resize().

Generated on Fri Jun 17 13:36:21 2005 for ImLib3D by  doxygen 1.4.2