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>