[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

details vigra Namespace Reference VIGRA

Namespaces

namespace  acc
namespace  linalg
namespace  multi_math
namespace  FourNeighborhood
namespace  EightNeighborhood
namespace  Neighborhood3DSix
namespace  Neighborhood3DTwentySix

Classes

class  ArrayOfRegionStatistics
 Calculate statistics for all regions of a labeled image. More...
class  ArrayVector
class  ArrayVectorView
class  BasicImage
 Fundamental class template for images. More...
class  BasicImageIterator
class  BasicImageIteratorBase
class  BasicImageView
 BasicImage using foreign memory. More...
class  BestGiniOfColumn
class  BilinearInterpolatingAccessor
 Bilinear interpolation at non-integer positions. More...
class  BlueAccessor
class  Box
 Represent an n-dimensional box as a (begin, end) pair. Depending on the value type, end() is considered to be outside the box (as in the STL, for integer types), or inside (for floating point types). size() will always be end() - begin(). More...
class  BrightnessContrastFunctor
 Adjust brightness and contrast of an image. More...
class  BSpline
class  BSplineBase
class  BucketQueue
 Priority queue implemented using bucket sort. More...
class  CatmullRomSpline
class  ColumnIterator
 Iterator adapter to linearly access columns. More...
class  ConstBasicImageIterator
class  ConstImageIterator
 Standard 2D random access const iterator for images that store the data as a linear array. More...
class  ConstStridedImageIterator
 Const iterator to be used when pixels are to be skipped. More...
class  ConstValueIterator
 Iterator that always returns the constant specified in the constructor. More...
class  ConvolutionOptions
 Options class template for convolutions. More...
class  CoordinateConstValueAccessor
 Forward accessor to the value() part of the values an iterator points to. More...
class  CoscotFunction
class  CoupledHandle
struct  CoupledIteratorType
class  CoupledScanOrderIterator
 Iterate over multiple images simultaneously in scan order. More...
class  CrackContourCirculator
 Circulator that walks around a given region. More...
class  Diff2D
 Two dimensional difference vector. More...
class  DiffusivityFunctor
 Diffusivity functor for non-linear diffusion. More...
class  Dist2D
class  DT_StackEntry
class  EarlyStoppStd
 Standard early stopping criterion. More...
class  Edgel
class  EntropyCriterion
class  FFTWComplex
 Wrapper class for the FFTW complex types 'fftw_complex'. More...
class  FFTWConvolvePlan
class  FFTWImaginaryAccessor
class  FFTWMagnitudeAccessor
class  FFTWPhaseAccessor
class  FFTWPlan
class  FFTWRealAccessor
class  FFTWSquaredMagnitudeAccessor
class  FFTWWriteRealAccessor
class  FindAverage
 Find the average pixel value in an image or ROI. More...
class  FindAverageAndVariance
 Find the average pixel value and its variance in an image or ROI. More...
class  FindBoundingRectangle
 Calculate the bounding rectangle of an ROI in an image. More...
class  FindMinMax
 Find the minimum and maximum pixel value in an image or ROI. More...
class  FindROISize
 Calculate the size of an ROI in an image. More...
class  FindSum
 Find the sum of the pixel values in an image or ROI. More...
class  FixedPoint
class  FixedPoint16
class  FunctorTraits
 Export associated information for a functor. More...
class  GaborFilterFamily
 Family of gabor filters of different scale and direction. More...
class  GammaFunctor
 Perform gamma correction of an image. More...
class  Gaussian
class  GiniCriterion
class  GrayToRGBAccessor
class  GreenAccessor
class  HDF5File
 Access to HDF5 files. More...
class  HDF5Handle
 Wrapper for hid_t objects. More...
class  HDF5ImportInfo
 Argument object for the function readHDF5(). More...
class  HistogramOptions
 Set histogram options. More...
class  ImageArray
 Fundamental class template for arrays of equal-sized images. More...
class  ImageExportInfo
 Argument object for the function exportImage(). More...
class  ImageImportInfo
 Argument object for the function importImage(). More...
class  ImageIterator
 Standard 2D random access iterator for images that store the data in a linear array. More...
class  ImageIteratorBase
 Base class for 2D random access iterators. More...
class  ImagePyramid
 Class template for logarithmically tapering image pyramids. More...
class  IteratorAdaptor
 Quickly create 1-dimensional iterator adapters. More...
struct  IteratorTraits
 Export associated information for each image iterator. More...
class  Kernel1D
 Generic 1 dimensional convolution kernel. More...
class  Kernel2D
 Generic 2 dimensional convolution kernel. More...
class  Lab2RGBFunctor
 Convert perceptual uniform CIE L*a*b* into linear (raw) RGB. More...
class  Lab2RGBPrimeFunctor
 Convert perceptual uniform CIE L*a*b* into non-linear (gamma corrected) R'G'B'. More...
class  Lab2XYZFunctor
 Convert perceptual uniform CIE L*a*b* into standardized tri-stimulus XYZ. More...
class  LastValueFunctor
 Stores and returns the last value it has seen. More...
class  LineIterator
 Iterator adapter to iterate along an arbitrary line on the image. More...
class  LocalMinmaxOptions
 Options object for localMinima() and localMaxima(). More...
class  Luv2RGBFunctor
 Convert perceptual uniform CIE L*u*v* into linear (raw) RGB. More...
class  Luv2RGBPrimeFunctor
 Convert perceptual uniform CIE L*u*v* into non-linear (gamma corrected) R'G'B'. More...
class  Luv2XYZFunctor
 Convert perceptual uniform CIE L*u*v* into standardized tri-stimulus XYZ. More...
class  MagnitudeFunctor
class  MappedBucketQueue
 Priority queue implemented using bucket sort (STL compatible). More...
struct  MeshGridAccessor
class  MultiArray
 Main MultiArray class containing the memory management. More...
class  MultiArrayNavigator
 A navigator that provides access to the 1D subranges of an n-dimensional range given by a vigra::MultiIterator and an nD shape. More...
class  MultiArrayShape
class  MultiArrayView
 Base class for, and view to, vigra::MultiArray. More...
class  MultiCoordinateNavigator
 A navigator that provides access to the 1D subranges of an n-dimensional range given by an nD shape. More...
class  MultiImageAccessor2
 Access two images simultaneously. More...
class  MultiIterator
 A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided. More...
class  NeighborhoodCirculator
 Circulator that walks around a given location in a given image. More...
class  NeighborOffsetCirculator
 Circulator that walks around a given location. More...
class  Node< e_ConstProbNode >
class  NodeBase
class  NoiseNormalizationOptions
 Pass options to one of the noise normalization functions. More...
class  NormalRandomFunctor
class  NumpyAnyArray
class  NumpyArray
class  PLSAOptions
 Option object for the pLSA algorithm. More...
class  Point2D
 Two dimensional point or position. More...
class  Polynomial
class  PolynomialView
class  PriorityQueue
 Heap-based priority queue compatible to BucketQueue. More...
class  ProblemSpec
 problem specification class for the random forest. More...
class  Processor< ClassificationTag, LabelType, T1, C1, T2, C2 >
class  Processor< RegressionTag, LabelType, T1, C1, T2, C2 >
class  Quaternion
class  RandomForest
class  RandomForestClassCounter
class  RandomForestOptions
 Options object for the random forest. More...
class  RandomNumberGenerator
class  Rational
class  Rect2D
 Two dimensional rectangle. More...
class  RedAccessor
class  ReduceFunctor
 Apply a functor to reduce the dimensionality of an array. More...
class  RestrictedNeighborhoodCirculator
 Circulator that walks around a given location in a given image, using a restricted neighborhood. More...
class  RGB2LabFunctor
 Convert linear (raw) RGB into perceptual uniform CIE L*a*b*. More...
class  RGB2LuvFunctor
 Convert linear (raw) RGB into perceptual uniform CIE L*u*v*. More...
class  RGB2RGBPrimeFunctor
 Convert linear (raw) RGB into non-linear (gamma corrected) R'G'B'. More...
class  RGB2sRGBFunctor
 Convert linear (raw) RGB into standardized sRGB. More...
class  RGB2XYZFunctor
 Convert linear (raw) RGB into standardized tri-stimulus XYZ. More...
class  RGBAccessor
class  RGBGradientMagnitudeFunctor
class  RGBPrime2LabFunctor
 Convert non-linear (gamma corrected) R'G'B' into perceptual uniform CIE L*a*b*. More...
class  RGBPrime2LuvFunctor
 Convert non-linear (gamma corrected) R'G'B' into perceptual uniform CIE L*u*v*. More...
class  RGBPrime2RGBFunctor
 Convert non-linear (gamma corrected) R'G'B' into non-linear (raw) RGB. More...
class  RGBPrime2XYZFunctor
 Convert non-linear (gamma corrected) R'G'B' into standardized tri-stimulus XYZ. More...
class  RGBPrime2YPrimeCbCrFunctor
 Convert non-linear (gamma corrected) R'G'B' into Y'CbCr color difference components. More...
class  RGBPrime2YPrimeIQFunctor
 Convert non-linear (gamma corrected) R'G'B' into Y'IQ components. More...
class  RGBPrime2YPrimePbPrFunctor
 Convert non-linear (gamma corrected) R'G'B' into Y'PbPr color difference components. More...
class  RGBPrime2YPrimeUVFunctor
 Convert non-linear (gamma corrected) R'G'B' into Y'UV components. More...
class  RGBToGrayAccessor
class  RGBValue
 Class for a single RGB value. More...
class  RowIterator
 Iterator adapter to linearly access row. More...
class  Sampler
 Create random samples from a sequence of indices. More...
class  SamplerOptions
 Options object for the Sampler class. More...
class  SeedOptions
 Options object for generateWatershedSeeds(). More...
class  SeedRgDirectValueFunctor
 Statistics functor to be used for seeded region growing. More...
class  SequenceAccessor
 Accessor for items that are STL compatible sequences. More...
class  SIFImportInfo
 Extracts image properties from an Andor SIF file header. More...
class  Size2D
 Two dimensional size object. More...
class  SlantedEdgeMTFOptions
 Pass options to one of the slantedEdgeMTF() functions. More...
class  SortSamplesByDimensions
class  Splice
class  SplineImageView
 Create a continuous view onto a discrete image using splines. More...
class  SplineImageView0
 Create an image view for nearest-neighbor interpolation. More...
class  SplineImageView1
 Create an image view for bi-linear interpolation. More...
class  SplitBase
class  sRGB2RGBFunctor
 Convert standardized sRGB into non-linear (raw) RGB. More...
class  StandardAccessor
 Encapsulate access to the values an iterator points to. More...
class  StandardConstAccessor
 Encapsulate read access to the values an iterator points to. More...
class  StandardConstValueAccessor
 Encapsulate access to the values an iterator points to. More...
class  StandardValueAccessor
 Encapsulate access to the values an iterator points to. More...
class  StaticPolynomial
class  StopAfterTree
class  StopAfterVoteCount
class  StopBase
class  StopIfBinTest
class  StopIfConverging
class  StopIfMargin
class  StopIfProb
struct  StridedArrayTag
class  StridedImageIterator
 Iterator to be used when pixels are to be skipped. More...
class  StridedMultiIterator
 A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided. More...
class  StridedScanOrderIterator
 Sequential iterator for MultiArrayView. More...
class  Threshold
 Threshold an image. More...
class  ThresholdSplit
class  TinyVector
 Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE. The interface conforms to STL vector, except that there are no functions that change the size of a TinyVector. More...
class  TinyVectorBase
 Base class for fixed size vectors. More...
class  TinyVectorView
 Wrapper for fixed size vectors. More...
class  UniformIntRandomFunctor
class  UniformRandomFunctor
struct  UnstridedArrayTag
class  VectorAccessor
 Accessor for items that are STL compatible vectors. More...
class  VectorComponentAccessor
 Accessor for one component of a vector. More...
class  VectorComponentValueAccessor
 Accessor for one component of a vector. More...
class  VectorElementAccessor
 Accessor for one component of a vector. More...
class  VectorNormFunctor
 A functor for computing the vector norm. More...
class  VectorNormSqFunctor
 A functor for computing the squared vector norm. More...
class  VolumeExportInfo
 Argument object for the function exportVolume(). More...
class  VolumeImportInfo
 Argument object for the function importVolume(). More...
class  WatershedOptions
 Options object for watershedsRegionGrowing(). More...
class  WignerMatrix
 computation of Wigner D matrix + rotation functions in SH,VH and R³ More...
class  XYZ2LabFunctor
 Convert standardized tri-stimulus XYZ into perceptual uniform CIE L*a*b*. More...
class  XYZ2LuvFunctor
 Convert standardized tri-stimulus XYZ into perceptual uniform CIE L*u*v*. More...
class  XYZ2RGBFunctor
 Convert standardized tri-stimulus XYZ into linear (raw) RGB. More...
class  XYZ2RGBPrimeFunctor
 Convert standardized tri-stimulus XYZ into non-linear (gamma corrected) R'G'B'. More...
class  YPrimeCbCr2RGBPrimeFunctor
 Convert Y'CbCr color difference components into non-linear (gamma corrected) R'G'B'. More...
class  YPrimeIQ2RGBPrimeFunctor
 Convert Y'IQ color components into non-linear (gamma corrected) R'G'B'. More...
class  YPrimePbPr2RGBPrimeFunctor
 Convert Y'PbPr color difference components into non-linear (gamma corrected) R'G'B'. More...
class  YPrimeUV2RGBPrimeFunctor
 Convert Y'UV color components into non-linear (gamma corrected) R'G'B'. More...

Typedefs

typedef AtImageBorder AtVolumeBorder
 Encode whether a voxel is near the volume border.
typedef BasicImage< UInt8BImage
typedef BasicImage< RGBValue
< UInt8 > > 
BRGBImage
typedef Diff2D CoordinateIterator
 Simulate an image where each pixel contains its coordinate.
typedef vigra::TinyVector< int, 3 > Diff3D
 3-dimensional difference vector
typedef BasicImage< double > DImage
typedef BasicImage< RGBValue
< double > > 
DRGBImage
typedef BasicImage< TinyVector
< double, 2 > > 
DVector2Image
typedef BasicImage< TinyVector
< double, 3 > > 
DVector3Image
typedef BasicImage< TinyVector
< double, 4 > > 
DVector4Image
typedef
EightNeighborhood::NeighborCode 
EightNeighborCode
typedef
NeighborOffsetCirculator
< EightNeighborCode
EightNeighborOffsetCirculator
typedef BasicImage< FFTWComplex<> > FFTWComplexImage
typedef BasicImage< fftw_real > FFTWRealImage
typedef BasicImage< float > FImage
typedef
FourNeighborhood::NeighborCode 
FourNeighborCode
typedef
NeighborOffsetCirculator
< FourNeighborCode
FourNeighborOffsetCirculator
typedef BasicImage< RGBValue
< float > > 
FRGBImage
typedef BasicImage< TinyVector
< float, 2 > > 
FVector2Image
typedef BasicImage< TinyVector
< float, 3 > > 
FVector3Image
typedef BasicImage< TinyVector
< float, 4 > > 
FVector4Image
typedef RidgeSplit
< BestGiniOfColumn
< GiniCriterion > > 
GiniRidgeSplit
typedef BasicImage< Int32IImage
typedef
detail::SelectIntegerType
< 16, detail::SignedIntTypes >
::type 
Int16
 16-bit signed int
typedef BasicImage< Int16Int16Image
typedef BasicImage< RGBValue
< Int16 > > 
Int16RGBImage
typedef
detail::SelectIntegerType
< 32, detail::SignedIntTypes >
::type 
Int32
 32-bit signed int
typedef BasicImage< Int32Int32Image
typedef BasicImage< RGBValue
< Int32 > > 
Int32RGBImage
typedef
detail::SelectIntegerType
< 64, detail::SignedIntTypes >
::type 
Int64
 64-bit signed int
typedef
detail::SelectIntegerType
< 8, detail::SignedIntTypes >
::type 
Int8
 8-bit signed int
typedef BasicImage< Int8Int8Image
typedef BasicImage< RGBValue
< Int8 > > 
Int8RGBImage
typedef
detail::SelectBiggestIntegerType
< detail::SignedIntTypes >
::type 
IntBiggest
 the biggest signed integer type of the system
typedef BasicImage< RGBValue
< Int32 > > 
IRGBImage
typedef RandomNumberGenerator
< detail::RandomState
< detail::MT19937 > > 
MersenneTwister
typedef std::ptrdiff_t MultiArrayIndex
typedef
Neighborhood3DSix::NeighborCode3D 
NeighborCode3DSix
typedef
Neighborhood3DTwentySix::NeighborCode3D 
NeighborCode3DTwentySix
typedef RandomNumberGenerator
< detail::RandomState
< detail::MT19937 > > 
RandomMT19937
typedef RandomNumberGenerator RandomTT800
typedef MultiArrayShape< 1 >::type Shape1
 shape type for MultiArray<1, T>
typedef MultiArrayShape< 2 >::type Shape2
 shape type for MultiArray<2, T>
typedef MultiArrayShape< 3 >::type Shape3
 shape type for MultiArray<3, T>
typedef MultiArrayShape< 4 >::type Shape4
 shape type for MultiArray<4, T>
typedef MultiArrayShape< 5 >::type Shape5
 shape type for MultiArray<5, T>
typedef BasicImage< Int16SImage
typedef BasicImage< RGBValue
< Int16 > > 
SRGBImage
typedef RandomNumberGenerator TemperedTwister
typedef
detail::SelectIntegerType
< 16, detail::UnsignedIntTypes >
::type 
UInt16
 16-bit unsigned int
typedef BasicImage< UInt16UInt16Image
typedef BasicImage< RGBValue
< UInt16 > > 
UInt16RGBImage
typedef
detail::SelectIntegerType
< 32, detail::UnsignedIntTypes >
::type 
UInt32
 32-bit unsigned int
typedef BasicImage< UInt32UInt32Image
typedef BasicImage< RGBValue
< UInt32 > > 
UInt32RGBImage
typedef
detail::SelectIntegerType
< 64, detail::UnsignedIntTypes >
::type 
UInt64
 64-bit unsigned int
typedef
detail::SelectIntegerType
< 8, detail::UnsignedIntTypes >
::type 
UInt8
 8-bit unsigned int
typedef BasicImage< UInt8UInt8Image
typedef BasicImage< RGBValue
< UInt8 > > 
UInt8RGBImage
typedef
detail::SelectBiggestIntegerType
< detail::UnsignedIntTypes >
::type 
UIntBiggest
 the biggest unsigned integer type of the system

Enumerations

enum  AtImageBorder {
  NotAtBorder = 0, RightBorder = 1, LeftBorder = 2, TopBorder = 4,
  BottomBorder = 8, FrontBorder = 16
}
 Encode whether a point is near the image border. More...
enum  Problem_t
 problem types
enum  RF_OptionTag
enum  SRGType

Functions

template<typename IntType >
Rational< IntType > abs (const Rational< IntType > &r)
 absolute value
template<typename Type >
Quaternion< Type >::NormType abs (Quaternion< Type > const &q)
 norm
template<unsigned IntBits, unsigned FracBits>
FixedPoint< IntBits, FracBits > abs (FixedPoint< IntBits, FracBits > v)
 absolute value.
template<class T , unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
RGBValue< T, RIDX, GIDX, BIDX > abs (RGBValue< T, RIDX, GIDX, BIDX > const &v)
 component-wise absolute value
template<class R >
FFTWComplex< R >::NormType abs (const FFTWComplex< R > &a)
 absolute value (= magnitude)
template<class V , int SIZE, class D1 , class D2 >
TinyVector< V, SIZE > abs (TinyVectorBase< V, SIZE, D1, D2 > const &v)
 component-wise absolute value
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits,
OverflowHandling > 
abs (FixedPoint16< IntBits, OverflowHandling > v)
 absolute value.
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2, unsigned IntBits3, unsigned FracBits3>
void add (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
 addition with enforced result type.
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2, int IntBits3>
FixedPoint16< IntBits3,
OverflowHandling > & 
add (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r, FixedPoint16< IntBits3, OverflowHandling > &result)
 addition with enforced result type.
template<class SrcIterator , class DestIterator >
linalg::TemporaryMatrix< double > affineMatrix2DFromCorrespondingPoints (SrcIterator s, SrcIterator send, DestIterator d)
 Create homogeneous matrix that maps corresponding points onto each other.
template<... >
void affineWarpImage (...)
 Warp an image according to an affine transformation.
double angularGaborSigma (int directionCount, double centerFrequency)
 Calculate sensible angular sigma for given parameters.
template<... >
void anisotropicTotalVariationFilter (...)
 Performs Anisotropic Total Variation Regularization.
template<... >
void applyFourierFilter (...)
 Apply a filter (defined in the frequency domain) to an image.
template<... >
void applyFourierFilterFamily (...)
 Apply an array of filters (defined in the frequency domain) to an image.
template<class IndexIterator , class InIterator , class OutIterator >
void applyPermutation (IndexIterator index_first, IndexIterator index_last, InIterator in, OutIterator out)
template<class R >
arg (const FFTWComplex< R > &a)
 pahse
template<class Iterator >
Iterator argMax (Iterator first, Iterator last)
template<class Iterator , class UnaryFunctor >
Iterator argMaxIf (Iterator first, Iterator last, UnaryFunctor condition)
template<class Iterator >
Iterator argMin (Iterator first, Iterator last)
template<class Iterator , class UnaryFunctor >
Iterator argMinIf (Iterator first, Iterator last, UnaryFunctor condition)
template<class T >
std::string asString (T t)(...)
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< 2, OverflowHandling > atan2 (FixedPoint16< IntBits, OverflowHandling > y, FixedPoint16< IntBits, OverflowHandling > x)
 Arctangent. Accuracy better than 1/3 degree (9 significant bits).
template<... >
void beaudetCornerDetector (...)
 Find corners in an image (4).
template<... >
void beautifyCrackEdgeImage (...)
 Beautify crack edge image for visualization.
double besselJ (int n, double x)
double besselY (int n, double x)
template<... >
void boundaryTensor (...)
 Calculate the boundary tensor for a scalar valued image.
template<... >
void boundaryTensor1 (...)
 Boundary tensor variant.
template<... >
void cannyEdgeImage (...)
 Detect and mark edges in an edge image using Canny's algorithm.
template<... >
void cannyEdgeImageFromGradWithThinning (...)
 Detect and mark edges in an edge image using Canny's algorithm.
template<... >
void cannyEdgeImageWithThinning (...)
 Detect and mark edges in an edge image using Canny's algorithm.
template<... >
void cannyEdgelList (...)
 Simple implementation of Canny's edge detector.
template<... >
void cannyEdgelList3x3 (...)
 Improved implementation of Canny's edge detector.
template<... >
void cannyEdgelList3x3Threshold (...)
 Improved implementation of Canny's edge detector with thresholding.
template<... >
void cannyEdgelListThreshold (...)
 Canny's edge detector with thresholding.
template<typename IntType >
Rational< IntType > ceil (const Rational< IntType > &r)
 smallest integer not smaller than r
template<unsigned IntBits, unsigned FracBits>
int ceil (FixedPoint< IntBits, FracBits > v)
 rounding up.
template<class V , unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
RGBValue< V, RIDX, GIDX, BIDX > ceil (RGBValue< V, RIDX, GIDX, BIDX > const &r)
template<class V , int SIZE, class D1 , class D2 >
TinyVector< V, SIZE > ceil (TinyVectorBase< V, SIZE, D1, D2 > const &v)
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 ceil (FixedPoint16< IntBits, OverflowHandling > v)
 rounding up.
UInt32 ceilPower2 (UInt32 x)
UInt32 checksum (const char *data, unsigned int size)
double chi2 (unsigned int degreesOfFreedom, double arg, double accuracy=1e-7)
double chi2CDF (unsigned int degreesOfFreedom, double arg, double accuracy=1e-7)
template<class T1 , class T2 >
bool closeAtTolerance (T1 l, T2 r, typename PromoteTraits< T1, T2 >::Promote epsilon)
template<... >
void closeGapsInCrackEdgeImage (...)
 Close one-pixel wide gaps in a cell grid edge image.
template<... >
void combineThreeImages (...)
 Combine three source images into destination image.
template<... >
void combineThreeMultiArrays (...)
 Combine three multi-dimensional arrays into one using a ternary function or functor.
template<... >
void combineTwoImages (...)
 Combine two source images into destination image.
template<... >
void combineTwoImagesIf (...)
 Combine ROI of two source images into destination image.
template<... >
void combineTwoMultiArrays (...)
 Combine two multi-dimensional arrays into one using a binary function or functor.
UInt32 concatenateChecksum (UInt32 checksum, const char *data, unsigned int size)
template<class ValueType >
Quaternion< ValueType > conj (Quaternion< ValueType > const &q)
 Create conjugate quaternion.
template<class R >
FFTWComplex< R > conj (const FFTWComplex< R > &a)
 complex conjugate
template<class PointArray1 , class PointArray2 >
void convexHull (const PointArray1 &points, PointArray2 &convex_hull)
 Compute convex hull of a 2D polygon.
template<... >
void convolveFFT (...)
 Convolve an array with a kernel by means of the Fourier transform.
template<... >
void convolveFFTComplex (...)
 Convolve a complex-valued array by means of the Fourier transform.
template<... >
void convolveFFTComplexMany (...)
 Convolve a complex-valued array with a sequence of kernels by means of the Fourier transform.
template<... >
void convolveFFTMany (...)
 Convolve a real-valued array with a sequence of kernels by means of the Fourier transform.
template<class SrcIterator , class SrcAccessor , class DestIterator , class DestAccessor , class KernelIterator , class KernelAccessor >
void convolveImage (SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc, DestIterator dest_ul, DestAccessor dest_acc, KernelIterator ki, KernelAccessor ak, Diff2D kul, Diff2D klr, BorderTreatmentMode border)
 Performs a 2 dimensional convolution of the source image using the given kernel.
template<class SrcIterator , class SrcAccessor , class DestIterator , class DestAccessor , class T >
void convolveImage (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIterator dupperleft, DestAccessor da, Kernel1D< T > const &kx, Kernel1D< T > const &ky)
 Apply two separable filters successively, the first in x-direction, the second in y-direction.
template<... >
void convolveImageWithMask (...)
 Deprecated name of 2-dimensional normalized convolution, i.e. convolution with a mask image.
template<... >
void convolveLine (...)
 Performs a 1-dimensional convolution of the source signal using the given kernel.
template<... >
void convolveMultiArrayOneDimension (...)
 Convolution along a single dimension of a multi-dimensional arrays.
template<... >
void copyImage (...)
 Copy source image into destination image.
template<... >
void copyImageIf (...)
 Copy source ROI into destination image.
template<... >
void copyMultiArray (...)
 Copy a multi-dimensional array.
template<... >
void cornerResponseFunction (...)
 Find corners in an image (1).
template<class REAL >
REAL cos_pi (REAL x)
template<int N>
CoupledIteratorType< N >::type createCoupledIterator (TinyVector< MultiArrayIndex, N > const &shape)
template<unsigned int N1, class T1 , class S1 >
CoupledIteratorType< N1, T1 >::type createCoupledIterator (MultiArrayView< N1, T1, S1 > const &m1)
template<unsigned int N1, class T1 , class S1 , unsigned int N2, class T2 , class S2 >
CoupledIteratorType< N1, T1,
T2 >::type 
createCoupledIterator (MultiArrayView< N1, T1, S1 > const &m1, MultiArrayView< N2, T2, S2 > const &m2)
template<unsigned int N1, class T1 , class S1 , unsigned int N2, class T2 , class S2 , unsigned int N3, class T3 , class S3 >
CoupledIteratorType< N1, T1,
T2, T3 >::type 
createCoupledIterator (MultiArrayView< N1, T1, S1 > const &m1, MultiArrayView< N2, T2, S2 > const &m2, MultiArrayView< N3, T3, S3 > const &m3)
template<unsigned int N1, class T1 , class S1 , unsigned int N2, class T2 , class S2 , unsigned int N3, class T3 , class S3 , unsigned int N4, class T4 , class S4 >
CoupledIteratorType< N1, T1,
T2, T3, T4 >::type 
createCoupledIterator (MultiArrayView< N1, T1, S1 > const &m1, MultiArrayView< N2, T2, S2 > const &m2, MultiArrayView< N3, T3, S3 > const &m3, MultiArrayView< N4, T4, S4 > const &m4)
template<unsigned int N1, class T1 , class S1 , unsigned int N2, class T2 , class S2 , unsigned int N3, class T3 , class S3 , unsigned int N4, class T4 , class S4 , unsigned int N5, class T5 , class S5 >
CoupledIteratorType< N1, T1,
T2, T3, T4, T5 >::type 
createCoupledIterator (MultiArrayView< N1, T1, S1 > const &m1, MultiArrayView< N2, T2, S2 > const &m2, MultiArrayView< N3, T3, S3 > const &m3, MultiArrayView< N4, T4, S4 > const &m4, MultiArrayView< N5, T5, S5 > const &m5)
template<... >
void createGaborFilter (...)
 Create a gabor filter in frequency space.
template<... >
void createRGBTiffImage (...)
 Create a 3-band TiffImage from the given RGB image.
template<... >
void createScalarTiffImage (...)
 Create a single-band TiffImage from the given scalar image.
template<... >
void createTiffImage (...)
 Create a TiffImage from the given iterator range.
template<class V1 , unsigned int R, unsigned int G, unsigned int B, class V2 >
PromoteTraits< RGBValue< V1, R,
G, B >, RGBValue< V2, R, G, B >
>::Promote 
cross (RGBValue< V1, R, G, B > const &r1, RGBValue< V2, R, G, B > const &r2)
 cross product
template<class V1 , class D1 , class D2 , class V2 , class D3 , class D4 >
TinyVector< typename
PromoteTraits< V1, V2 >
::Promote, 3 > 
cross (TinyVectorBase< V1, 3, D1, D2 > const &r1, TinyVectorBase< V2, 3, D3, D4 > const &r2)
 cross product
template<class V , int SIZE, class D1 , class D2 >
TinyVector< typename
NumericTraits< V >::Promote,
SIZE > 
cumprod (TinyVectorBase< V, SIZE, D1, D2 > const &l)
 cumulative product of the vector's elements
template<class V , int SIZE, class D1 , class D2 >
TinyVector< typename
NumericTraits< V >::Promote,
SIZE > 
cumsum (TinyVectorBase< V, SIZE, D1, D2 > const &l)
 cumulative sum of the vector's elements
template<... >
void differenceOfExponentialCrackEdgeImage (...)
 Detect and mark edges in a crack edge image using the Shen/Castan zero-crossing detector.
template<... >
void differenceOfExponentialEdgeImage (...)
 Detect and mark edges in an edge image using the Shen/Castan zero-crossing detector.
template<... >
void discDilation (...)
 Apply dilation (maximum) filter with disc of given radius to image.
template<... >
void discDilationWithMask (...)
 Apply dilation (maximum) filter with disc of given radius to image using a mask.
template<... >
void discErosion (...)
 Apply erosion (minimum) filter with disc of given radius to image.
template<... >
void discErosionWithMask (...)
 Apply erosion (minimum) filter with disc of given radius to image using a mask.
template<... >
void discMedian (...)
 Apply median filter with disc of given radius to image.
template<... >
void discMedianWithMask (...)
 Apply median filter with disc of given radius to image using a mask.
template<... >
void discRankOrderFilter (...)
 Apply rank order filter with disc structuring function to the image.
template<... >
void discRankOrderFilterWithMask (...)
 Apply rank order filter with disc structuring function to the image using a mask.
template<... >
void distanceTransform (...)
template<class V , int SIZE, class D1 , class D2 >
TinyVector< V, SIZE > div (TinyVectorBase< V, SIZE, D1, D2 > const &l, V v)
 component-wise scalar division without type promotion
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2, int IntBits3>
FixedPoint16< IntBits3,
OverflowHandling > & 
div (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r, FixedPoint16< IntBits3, OverflowHandling > &result)
 division with enforced result type.
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
PromoteTraits< V1, V2 >::Promote dot (RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &r1, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r2)
 dot product
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
PromoteTraits< V1, V2 >::Promote dot (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 dot product
template<unsigned IntBits, unsigned FracBits>
FixedPoint< 0, FracBits > dual_frac (FixedPoint< IntBits, FracBits > v)
 dual fractional part: 1 - frac(v).
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits,
OverflowHandling > 
dual_frac (FixedPoint16< IntBits, OverflowHandling > v)
 dual fractional part. (1 - frac(v))
double ellipticIntegralE (double x, double k)
double ellipticIntegralF (double x, double k)
template<... >
void estimateAffineTransform (...)
 Estimate the optical flow between two images according to an affine transform model (e.g. translation, rotation, non-uniform scaling, and shearing).
template<... >
void estimateSimilarityTransform (...)
 Estimate the optical flow between two images according to a similarity transform model (e.g. translation, rotation, and uniform scaling).
template<... >
void estimateTranslation (...)
 Estimate the optical flow between two images according to a translation model.
bool even (int t)
template<... >
void exportImage (...)
 Write an image given a vigra::ImageExportInfo object.
template<... >
void exportImageAlpha (...)
 Write the image specified by the given vigra::ImageExportInfo object including an alpha channel.
template<class T , class Tag >
void exportVolume (MultiArrayView< 3, T, Tag > const &volume, const VolumeExportInfo &volinfo)
 Function for exporting a 3D volume.
template<... >
void extendedLocalMaxima (...)
 Find local maximal regions in an image or volume.
template<... >
void extendedLocalMaxima3D (...)
 Find local maximal regions in 3D multi array.
template<... >
void extendedLocalMinima (...)
 Find local minimal regions in an image or volume.
template<... >
void extendedLocalMinima3D (...)
 Find local minimal regions in a volume.
template<class T , int N>
TinyVector< T, N > fftwCorrespondingShapeR2C (TinyVector< T, N > shape)
 Find frequency domain shape for a R2C Fourier transform.
template<class TARGET , unsigned IntBits, unsigned FracBits>
TARGET fixed_point_cast (FixedPoint< IntBits, FracBits > v)
template<class TARGET , int IntBits, FPOverflowHandling OverflowHandling>
TARGET fixed_point_cast (FixedPoint16< IntBits, OverflowHandling > v)
template<typename IntType >
Rational< IntType > floor (const Rational< IntType > &r)
 largest integer not larger than r
template<unsigned IntBits, unsigned FracBits>
int floor (FixedPoint< IntBits, FracBits > v)
 rounding down.
template<class V , unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
RGBValue< V, RIDX, GIDX, BIDX > floor (RGBValue< V, RIDX, GIDX, BIDX > const &r)
template<class V , int SIZE, class D1 , class D2 >
TinyVector< V, SIZE > floor (TinyVectorBase< V, SIZE, D1, D2 > const &v)
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 floor (FixedPoint16< IntBits, OverflowHandling > v)
 rounding down.
UInt32 floorPower2 (UInt32 x)
template<... >
void foerstnerCornerDetector (...)
 Find corners in an image (2).
template<... >
void fourierTransform (...)
 Compute forward and inverse Fourier transforms.
template<... >
void fourierTransformInverse (...)
 Compute inverse Fourier transforms.
template<... >
void fourierTransformReal (...)
 Real Fourier transforms for even and odd boundary conditions (aka. cosine and sine transforms).
template<unsigned IntBits, unsigned FracBits>
FixedPoint< 0, FracBits > frac (FixedPoint< IntBits, FracBits > v)
 fractional part.
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits,
OverflowHandling > 
frac (FixedPoint16< IntBits, OverflowHandling > v)
 fractional part. (difference between v and its floor)
double gamma (double x)
template<... >
void gaussianGradient (...)
 Calculate the gradient vector by means of a 1st derivatives of Gaussian filter.
template<... >
void gaussianGradientMagnitude (...)
 Calculate the gradient magnitude by means of a 1st derivatives of Gaussian filter.
template<... >
void gaussianGradientMultiArray (...)
 Calculate Gaussian gradient of a multi-dimensional arrays.
template<... >
void gaussianSharpening (...)
 Perform sharpening function with gaussian filter.
template<... >
void gaussianSmoothing (...)
 Perform isotropic Gaussian convolution.
template<... >
void gaussianSmoothMultiArray (...)
 Isotropic Gaussian smoothing of a multi-dimensional arrays.
template<typename IntType >
IntType gcd (IntType n, IntType m)
template<... >
unsigned int generateWatershedSeeds (...)
 Generate seeds for watershed computation and seeded region growing.
template<... >
unsigned int generateWatershedSeeds3D (...)
 Generate seeds for watershed computation and seeded region growing.
template<unsigned int TARGET_INDEX, class Handle >
CoupledHandleCast
< TARGET_INDEX, Handle >
::type::reference 
get (Handle &handle)
template<unsigned int TARGET_INDEX, class Handle >
CoupledHandleCast
< TARGET_INDEX, Handle >
::type::const_reference 
get (Handle const &handle)
template<... >
void getAnisotropy (...)
 Sets up directional data for anisotropic regularization.
template<... >
void gradientBasedTransform (...)
 Calculate a function of the image gradient.
template<... >
void gradientEnergyTensor (...)
 Calculate the gradient energy tensor for a scalar valued image.
template<... >
void hessianMatrixOfGaussian (...)
 Filter image with the 2nd derivatives of the Gaussian at the given scale to get the Hessian matrix.
template<... >
void hessianOfGaussianMultiArray (...)
 Calculate Hessian matrix of a N-dimensional arrays using Gaussian derivative filters.
template<... >
void hourGlassFilter (...)
 Anisotropic tensor smoothing with the hourglass filter.
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits,
OverflowHandling > 
hypot (FixedPoint16< IntBits, OverflowHandling > v1, FixedPoint16< IntBits, OverflowHandling > v2)
 Length of hypotenuse.
template<class R >
imag (const FFTWComplex< R > &a)
 imaginary part
std::string impexListExtensions ()
 List the file extension VIGRA understands.
std::string impexListFormats ()
 List the image formats VIGRA can read and write.
template<... >
void importImage (...)
 Read the image specified by the given vigra::ImageImportInfo object.
template<... >
void importImageAlpha (...)
 Read the image specified by the given vigra::ImageImportInfo object including its alpha channel.
template<... >
void importTiffImage (...)
 Convert given TiffImage into image specified by iterator range.
template<class T , class Allocator >
void importVolume (MultiArray< 3, T, Allocator > &volume, const std::string &name_base, const std::string &name_ext)
 Function for importing a 3D volume.
template<class T , class Allocator >
void importVolume (MultiArray< 3, T, Allocator > &volume, const std::string &filename)
 Function for importing a 3D volume.
template<class T , class Stride >
void importVolume (VolumeImportInfo const &info, MultiArrayView< 3, T, Stride > &volume)
 Function for importing a 3D volume.
template<class Iterator , class IndexIterator , class Compare >
void indexSort (Iterator first, Iterator last, IndexIterator index_first, Compare c)
template<... >
void initImage (...)
 Write a value to every pixel in an image or rectangular ROI.
template<... >
void initImageBorder (...)
 Write value to the specified border pixels in the image.
template<... >
void initImageIf (...)
 Write value to pixel in the image if mask is true.
template<... >
void initImageWithFunctor (...)
 Write the result of a functor call to every pixel in an image or rectangular ROI.
template<... >
void initMultiArray (...)
 Write a value to every pixel in a multi-dimensional array.
template<class Iterator , class Diff_type , class Accessor , class VALUETYPE >
void initMultiArrayBorder (Iterator upperleft, Diff_type shape, Accessor a, int border_width, VALUETYPE v)
 Write value to the specified border values in the array.
template<... >
void inspectImage (...)
 Apply read-only functor to every pixel in the image.
template<... >
void inspectImageIf (...)
 Apply read-only functor to every pixel in the ROI.
template<... >
void inspectMultiArray (...)
 Call an analyzing functor at every element of a multi-dimensional array.
template<... >
void inspectSequence (...)
 Call an analyzing functor at every element of a sequence.
template<... >
void inspectTwoImages (...)
 Apply read-only functor to every pixel of both images.
template<... >
void inspectTwoImagesIf (...)
 Apply read-only functor to those pixels of both images where the mask image is non-zero.
template<... >
void inspectTwoMultiArrays (...)
 Call an analyzing functor at all corresponding elements of two multi-dimensional arrays.
template<class InIterator , class OutIterator >
void inversePermutation (InIterator first, InIterator last, OutIterator out)
AtImageBorder isAtImageBorder (int x, int y, int width, int height)
 Find out whether a point is at the image border.
AtVolumeBorder isAtVolumeBorder (int x, int y, int z, int width, int height, int depth)
 Find out whether a voxel is at the volume border.
AtVolumeBorder isAtVolumeBorderAntiCausal (int x, int y, int z, int width, int height, int depth)
 Find out whether a voxel is at a scan-order relevant volume border. This function checks if x == 0 or y == 0 or z == 0 and returns the appropriate value of vigra::AtVolumeBorder, or zero when the voxel is not at te volume border. The behavior of the function is undefined if (x,y,z) is not inside the volume.
AtVolumeBorder isAtVolumeBorderCausal (int x, int y, int z, int width, int height, int)
 Find out whether a voxel is at a scan-order relevant volume border. This function checks if x == 0 or y == 0 or z == 0 and returns the appropriate value of vigra::AtVolumeBorder, or zero when the voxel is not at te volume border. The behavior of the function is undefined if (x,y,z) is not inside the volume.
bool isImage (char const *filename)
 Test whether a file is an image format known to VIGRA.
template<class V >
TinyVector< float, 3 > lab2Polar (V const &lab)
 Create polar representation form L*a*b*.
template<... >
unsigned int labelImage (...)
 Find the connected components of a segmented image.
template<... >
unsigned int labelImageWithBackground (...)
 Find the connected components of a segmented image, excluding the background from labeling.
template<... >
unsigned int labelVolume (...)
 Find the connected components of a segmented volume.
template<class SrcIterator , class SrcAccessor , class SrcShape , class DestIterator , class DestAccessor >
unsigned int labelVolumeSix (triple< SrcIterator, SrcShape, SrcAccessor > src, pair< DestIterator, DestAccessor > dest)
 Find the connected components of a segmented volume using the 6-neighborhood.
template<... >
unsigned int labelVolumeWithBackground (...)
 Find the connected components of a segmented volume, excluding the background from labeling.
template<... >
void laplacianOfGaussian (...)
 Filter image with the Laplacian of Gaussian operator at the given scale.
template<... >
void laplacianOfGaussianMultiArray (...)
 Calculate Laplacian of a N-dimensional arrays using Gaussian derivative filters.
template<typename IntType >
IntType lcm (IntType n, IntType m)
template<class REAL >
REAL legendre (unsigned int l, int m, REAL x)
template<class REAL >
REAL legendre (unsigned int l, REAL x)
template<class Multiplier , class DestValueType >
LinearIntensityTransform
< DestValueType, Multiplier > 
linearIntensityTransform (Multiplier scale, DestValueType offset)
 Apply a linear transform to the source pixel values.
template<... >
bool linearNoiseNormalization (...)
 Noise normalization by means of an estimated linear noise model.
template<class SrcValueType , class DestValueType >
LinearIntensityTransform
< DestValueType, typename
NumericTraits< DestValueType >
::RealPromote > 
linearRangeMapping (SrcValueType src_min, SrcValueType src_max, DestValueType dest_min, DestValueType dest_max)
 Map a source intensity range linearly to a destination range.
template<class Iterator , class Value >
void linearSequence (Iterator first, Iterator last, Value start, Value step)
template<... >
void localMaxima (...)
 Find local maxima in an image or multi-dimensional array.
template<... >
void localMaxima3D (...)
 Find local maxima in a 3D multi array.
template<... >
void localMinima (...)
 Find local minima in an image or multi-dimensional array.
template<... >
void localMinima3D (...)
 Find local minima in a 3D multi array.
Int32 log2i (UInt32 x)
double loggamma (double x)
template<class V >
TinyVector< float, 3 > luv2Polar (V const &luv)
 Create polar representation form L*u*v*.
template<class T >
BasicImageView< T > makeBasicImageView (MultiArrayView< 2, T, UnstridedArrayTag > const &array)
template<class T >
BasicImageView< T > makeBasicImageView (MultiArray< 3, T > const &array)
template<class T >
BasicImageView< RGBValue< T > > makeRGBImageView (MultiArray< 3, T > const &array)
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
TinyVector< typename
PromoteTraits< V1, V2 >
::Promote, SIZE > 
max (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 element-wise maximum
template<class V , int SIZE, class D1 , class D2 >
V const & max (TinyVectorBase< V, SIZE, D1, D2 > const &l)
 maximum element
triple< Diff2D, Diff2D,
MeshGridAccessor
meshGrid (Diff2D upperLeft, Diff2D lowerRight)
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
TinyVector< typename
PromoteTraits< V1, V2 >
::Promote, SIZE > 
min (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 element-wise minimum
template<class V , int SIZE, class D1 , class D2 >
V const & min (TinyVectorBase< V, SIZE, D1, D2 > const &l)
 minimum element
template<... >
void moveDCToCenter (...)
 Rearrange the quadrants of a Fourier image so that the origin is in the image center.
template<... >
void moveDCToUpperLeft (...)
 Rearrange the quadrants of a Fourier image so that the origin is in the image's upper left.
template<class Vector >
double mtfFitGaussian (Vector const &mtf)
 Fit a Gaussian function to a given MTF.
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2, unsigned IntBits3, unsigned FracBits3>
void mul (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
 multiplication with enforced result type.
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2, int IntBits3>
FixedPoint16< IntBits3,
OverflowHandling > & 
mul (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r, FixedPoint16< IntBits3, OverflowHandling > &result)
 multiplication with enforced result type.
template<... >
void multiBinaryDilation (...)
 Binary dilation on multi-dimensional arrays.
template<... >
void multiBinaryErosion (...)
 Binary erosion on multi-dimensional arrays.
template<... >
void multiGrayscaleDilation (...)
 Parabolic grayscale dilation on multi-dimensional arrays.
template<... >
void multiGrayscaleErosion (...)
 Parabolic grayscale erosion on multi-dimensional arrays.
template<... >
void noiseVarianceClustering (...)
 Determine the noise variance as a function of the image intensity and cluster the results.
template<... >
void noiseVarianceEstimation (...)
 Determine the noise variance as a function of the image intensity.
double noncentralChi2 (unsigned int degreesOfFreedom, double noncentrality, double arg, double accuracy=1e-7)
double noncentralChi2CDF (unsigned int degreesOfFreedom, double noncentrality, double arg, double accuracy=1e-7)
double noncentralChi2CDFApprox (unsigned int degreesOfFreedom, double noncentrality, double arg)
template<... >
void nonlinearDiffusion (...)
 Perform edge-preserving smoothing at the given scale.
template<... >
bool nonparametricNoiseNormalization (...)
 Noise normalization by means of an estimated non-parametric noise model.
template<unsigned IntBits, unsigned FracBits>
FixedPoint< IntBits, FracBits > norm (FixedPoint< IntBits, FracBits > const &v)
 norm (same as abs).
template<class T >
NormTraits< T >::NormType norm (T const &t)
template<class R >
FFTWComplex< R >::NormType norm (const FFTWComplex< R > &a)
 norm (= magnitude)
template<typename IntType >
Rational< IntType > norm (const Rational< IntType > &r)
 norm (same as abs(r))
template<int IntBits, FPOverflowHandling OverflowHandling>
NormTraits< FixedPoint16
< IntBits, OverflowHandling >
>::NormType 
norm (FixedPoint16< IntBits, OverflowHandling > const &v)
 norm (same as abs).
template<... >
void normalizedConvolveImage (...)
 Performs a 2-dimensional normalized convolution, i.e. convolution with a mask image.
std::string normalizeString (std::string const &s)
bool odd (int t)
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
bool operator!= (RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &l, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r)
 component-wise not equal
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool operator!= (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 not equal
template<class R >
bool operator!= (FFTWComplex< R > const &a, const FFTWComplex< R > &b)
 not equal
template<class R >
bool operator!= (FFTWComplex< R > const &a, double b)
 not equal
template<class R >
bool operator!= (double a, const FFTWComplex< R > &b)
 not equal
template<typename IntType1 , typename IntType2 >
bool operator!= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 inequality
template<typename IntType1 , typename IntType2 >
bool operator!= (const Rational< IntType1 > &l, IntType2 const &i)
 inequality with right-hand IntType2 argument
template<typename IntType1 , typename IntType2 >
bool operator!= (IntType1 const &l, Rational< IntType2 > const &r)
 inequality with left-hand IntType1 argument
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
bool operator!= (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise not equal
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool operator!= (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 not equal
template<typename Type >
Quaternion< Type > operator* (const Quaternion< Type > &t1, const Quaternion< Type > &t2)
 Multiplication.
template<typename Type >
Quaternion< Type > operator* (const Quaternion< Type > &t1, double t2)
 Multiplication with a scalar on the right.
template<typename Type >
Quaternion< Type > operator* (double t1, const Quaternion< Type > &t2)
 Multiplication with a scalar on the left.
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
FixedPointTraits< FixedPoint
< IntBits1, FracBits1 >
, FixedPoint< IntBits2,
FracBits2 > >::MultipliesType 
operator* (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 multiplication with automatic determination of the appropriate result type.
template<class V1 , unsigned int R, unsigned int G, unsigned int B, class V2 >
PromoteTraits< RGBValue< V1, R,
G, B >, RGBValue< V2, R, G, B >
>::Promote 
operator* (RGBValue< V1, R, G, B > const &r1, RGBValue< V2, R, G, B > const &r2)
 component-wise multiplication
template<class V , unsigned int R, unsigned int G, unsigned int B>
NumericTraits< RGBValue< V, R,
G, B > >::RealPromote 
operator* (double v, RGBValue< V, R, G, B > const &r)
 component-wise left scalar multiplication
template<class V , unsigned int R, unsigned int G, unsigned int B>
NumericTraits< RGBValue< V, R,
G, B > >::RealPromote 
operator* (RGBValue< V, R, G, B > const &r, double v)
 component-wise right scalar multiplication
template<typename IntType >
Rational< IntType > operator* (Rational< IntType > l, Rational< IntType > const &r)
 multiplication
template<typename IntType >
Rational< IntType > operator* (Rational< IntType > l, typename Rational< IntType >::param_type r)
 multiplication with right-hand IntType argument
template<typename IntType >
Rational< IntType > operator* (typename Rational< IntType >::param_type l, Rational< IntType > r)
 multiplication with left-hand IntType argument
template<class R >
FFTWComplex< R > operator* (FFTWComplex< R > a, const FFTWComplex< R > &b)
 multiplication
template<class R >
FFTWComplex< R > operator* (FFTWComplex< R > a, double b)
 right multiplication with scalar double
template<class R >
FFTWComplex< R > operator* (double a, FFTWComplex< R > b)
 left multiplication with scalar double
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
PromoteTraits< TinyVector< V1,
SIZE >, TinyVector< V2, SIZE >
>::Promote 
operator* (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise multiplication
template<class V , int SIZE, class D1 , class D2 >
NumericTraits< TinyVector< V,
SIZE > >::RealPromote 
operator* (double v, TinyVectorBase< V, SIZE, D1, D2 > const &r)
 component-wise left scalar multiplication
template<class V , int SIZE, class D1 , class D2 >
NumericTraits< TinyVector< V,
SIZE > >::RealPromote 
operator* (TinyVectorBase< V, SIZE, D1, D2 > const &l, double v)
 component-wise right scalar multiplication
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
PromoteTraits< FixedPoint16
< IntBits1, OverflowHandling >
, FixedPoint16< IntBits2,
OverflowHandling > >::Promote 
operator* (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 multiplication with automatic determination of the appropriate result type.
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
RGBValue< V1, RIDX1, GIDX1,
BIDX1 > & 
operator*= (RGBValue< V1, RIDX1, GIDX1, BIDX1 > &l, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r)
 componentwise multiply-assignment
template<class V , unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
RGBValue< V, RIDX, GIDX, BIDX > & operator*= (RGBValue< V, RIDX, GIDX, BIDX > &l, double r)
 componentwise scalar multiply-assignment
template<class R >
FFTWComplex< R > & operator*= (FFTWComplex< R > &a, const FFTWComplex< R > &b)
 multiply-assignment
template<class R >
FFTWComplex< R > & operator*= (FFTWComplex< R > &a, double b)
 multiply-assignment with scalar double
template<typename Type >
Quaternion< Type > operator+ (const Quaternion< Type > &t1, const Quaternion< Type > &t2)
 Addition.
template<typename Type >
Quaternion< Type > operator+ (const Quaternion< Type > &t1, const Type &t2)
 Addition of a scalar on the right.
template<typename Type >
Quaternion< Type > operator+ (const Type &t1, const Quaternion< Type > &t2)
 Addition of a scalar on the left.
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
FixedPointTraits< FixedPoint
< IntBits1, FracBits1 >
, FixedPoint< IntBits2,
FracBits2 > >::PlusType 
operator+ (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 addition with automatic determination of the appropriate result type.
Diff2D operator+ (Diff2D const &a, Diff2D const &b)
Size2D operator+ (Size2D const &a, Diff2D const &b)
Point2D operator+ (Point2D const &a, Diff2D const &b)
Point2D operator+ (Size2D const &s, Point2D const &p)
template<class V1 , unsigned int R, unsigned int G, unsigned int B, class V2 >
PromoteTraits< RGBValue< V1, R,
G, B >, RGBValue< V2, R, G, B >
>::Promote 
operator+ (RGBValue< V1, R, G, B > const &r1, RGBValue< V2, R, G, B > const &r2)
 component-wise addition
template<typename IntType >
Rational< IntType > operator+ (const Rational< IntType > &r)
 unary plus
template<typename IntType >
Rational< IntType > operator+ (Rational< IntType > l, Rational< IntType > const &r)
 addition
template<typename IntType >
Rational< IntType > operator+ (Rational< IntType > l, typename Rational< IntType >::param_type r)
 addition of right-hand IntType argument
template<typename IntType >
Rational< IntType > operator+ (typename Rational< IntType >::param_type l, Rational< IntType > r)
 addition of left-hand IntType argument
template<class R >
FFTWComplex< R > operator+ (FFTWComplex< R > a, const FFTWComplex< R > &b)
 addition
template<class R >
FFTWComplex< R > operator+ (FFTWComplex< R > a, double b)
 right addition with scalar double
template<class R >
FFTWComplex< R > operator+ (double a, FFTWComplex< R > b)
 left addition with scalar double
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
PromoteTraits< TinyVector< V1,
SIZE >, TinyVector< V2, SIZE >
>::Promote 
operator+ (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise addition
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
PromoteTraits< FixedPoint16
< IntBits1, OverflowHandling >
, FixedPoint16< IntBits2,
OverflowHandling > >::Promote 
operator+ (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 addition with automatic determination of the appropriate result type.
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
RGBValue< V1, RIDX1, GIDX1,
BIDX1 > & 
operator+= (RGBValue< V1, RIDX1, GIDX1, BIDX1 > &l, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r)
 componentwise add-assignment
template<class R >
FFTWComplex< R > & operator+= (FFTWComplex< R > &a, const FFTWComplex< R > &b)
 add-assignment
template<class R >
FFTWComplex< R > & operator+= (FFTWComplex< R > &a, double b)
 add-assignment with scalar double
template<typename Type >
Quaternion< Type > operator- (const Quaternion< Type > &t1, const Quaternion< Type > &t2)
 Subtraction.
template<typename Type >
Quaternion< Type > operator- (const Quaternion< Type > &t1, const Type &t2)
 Subtraction of a scalar on the right.
template<typename Type >
Quaternion< Type > operator- (const Type &t1, const Quaternion< Type > &t2)
 Subtraction of a scalar on the left.
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
FixedPointTraits< FixedPoint
< IntBits1, FracBits1 >
, FixedPoint< IntBits2,
FracBits2 > >::MinusType 
operator- (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 subtraction with automatic determination of the appropriate result type.
Diff2D operator- (Diff2D const &a, Diff2D const &b)
Size2D operator- (Size2D const &s, Diff2D const &offset)
Point2D operator- (Point2D const &s, Diff2D const &offset)
Size2D operator- (Point2D const &s, Point2D const &p)
template<class V1 , unsigned int R, unsigned int G, unsigned int B, class V2 >
PromoteTraits< RGBValue< V1, R,
G, B >, RGBValue< V2, R, G, B >
>::Promote 
operator- (RGBValue< V1, R, G, B > const &r1, RGBValue< V2, R, G, B > const &r2)
 component-wise subtraction
template<typename IntType >
Rational< IntType > operator- (const Rational< IntType > &r)
 unary minus (negation)
template<typename IntType >
Rational< IntType > operator- (Rational< IntType > l, Rational< IntType > const &r)
 subtraction
template<typename IntType >
Rational< IntType > operator- (Rational< IntType > l, typename Rational< IntType >::param_type r)
 subtraction of right-hand IntType argument
template<typename IntType >
Rational< IntType > operator- (typename Rational< IntType >::param_type l, Rational< IntType > const &r)
 subtraction from left-hand IntType argument
template<class R >
FFTWComplex< R > operator- (FFTWComplex< R > a, const FFTWComplex< R > &b)
 subtraction
template<class R >
FFTWComplex< R > operator- (FFTWComplex< R > a, double b)
 right subtraction with scalar double
template<class R >
FFTWComplex< R > operator- (double a, FFTWComplex< R > const &b)
 left subtraction with scalar double
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
PromoteTraits< TinyVector< V1,
SIZE >, TinyVector< V2, SIZE >
>::Promote 
operator- (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise subtraction
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
PromoteTraits< FixedPoint16
< IntBits1, OverflowHandling >
, FixedPoint16< IntBits2,
OverflowHandling > >::Promote 
operator- (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 subtraction with automatic determination of the appropriate result type.
template<class V , int SIZE, class D1 , class D2 >
TinyVector< V, SIZE > operator- (TinyVectorBase< V, SIZE, D1, D2 > const &v)
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
RGBValue< V1, RIDX1, GIDX1,
BIDX1 > & 
operator-= (RGBValue< V1, RIDX1, GIDX1, BIDX1 > &l, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r)
 componentwise subtract-assignment
template<class R >
FFTWComplex< R > & operator-= (FFTWComplex< R > &a, const FFTWComplex< R > &b)
 subtract-assignment
template<class R >
FFTWComplex< R > & operator-= (FFTWComplex< R > &a, double b)
 subtract-assignment with scalar double
template<typename Type >
Quaternion< Type > operator/ (const Quaternion< Type > &t1, const Quaternion< Type > &t2)
 Division.
template<typename Type >
Quaternion< Type > operator/ (const Quaternion< Type > &t1, double t2)
 Division by a scalar.
template<typename Type >
Quaternion< Type > operator/ (double t1, const Quaternion< Type > &t2)
 Division of a scalar by a Quaternion.
template<class V1 , unsigned int R, unsigned int G, unsigned int B, class V2 >
PromoteTraits< RGBValue< V1, R,
G, B >, RGBValue< V2, R, G, B >
>::Promote 
operator/ (RGBValue< V1, R, G, B > const &r1, RGBValue< V2, R, G, B > const &r2)
 component-wise division
template<class V , unsigned int R, unsigned int G, unsigned int B>
NumericTraits< RGBValue< V, R,
G, B > >::RealPromote 
operator/ (RGBValue< V, R, G, B > const &r, double v)
 component-wise scalar division
template<typename IntType >
Rational< IntType > operator/ (Rational< IntType > l, Rational< IntType > const &r)
 division
template<typename IntType >
Rational< IntType > operator/ (Rational< IntType > l, typename Rational< IntType >::param_type r)
 division by right-hand IntType argument
template<typename IntType >
Rational< IntType > operator/ (typename Rational< IntType >::param_type l, Rational< IntType > const &r)
 division of left-hand IntType argument
template<class R >
FFTWComplex< R > operator/ (FFTWComplex< R > a, const FFTWComplex< R > &b)
 division
template<class R >
FFTWComplex< R > operator/ (FFTWComplex< R > a, double b)
 right division with scalar double
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
PromoteTraits< TinyVector< V1,
SIZE >, TinyVector< V2, SIZE >
>::Promote 
operator/ (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise division
template<class V , int SIZE, class D1 , class D2 >
NumericTraits< TinyVector< V,
SIZE > >::RealPromote 
operator/ (TinyVectorBase< V, SIZE, D1, D2 > const &l, double v)
 component-wise scalar division
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
PromoteTraits< FixedPoint16
< IntBits1, OverflowHandling >
, FixedPoint16< IntBits2,
OverflowHandling > >::Promote 
operator/ (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 division with automatic determination of the appropriate result type.
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
RGBValue< V1, RIDX1, GIDX1,
BIDX1 > & 
operator/= (RGBValue< V1, RIDX1, GIDX1, BIDX1 > &l, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r)
 componentwise divide-assignment
template<class V , unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
RGBValue< V, RIDX, GIDX, BIDX > & operator/= (RGBValue< V, RIDX, GIDX, BIDX > &l, double r)
 componentwise scalar divide-assignment
template<class R >
FFTWComplex< R > & operator/= (FFTWComplex< R > &a, const FFTWComplex< R > &b)
 divide-assignment
template<class R >
FFTWComplex< R > & operator/= (FFTWComplex< R > &a, double b)
 divide-assignment with scalar double
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool operator< (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 less than
template<typename IntType1 , typename IntType2 >
bool operator< (const Rational< IntType1 > &l, const Rational< IntType2 > &r)
 less-than
template<typename IntType1 , typename IntType2 >
bool operator< (const Rational< IntType1 > &l, IntType2 const &i)
 less-than with right-hand IntType2 argument
template<typename IntType1 , typename IntType2 >
bool operator< (IntType1 const &l, Rational< IntType2 > const &r)
 less-than with left-hand IntType1 argument
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
bool operator< (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise lexicographical comparison
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool operator< (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 less than
std::ostream & operator<< (std::ostream &os, const SIFImportInfo &info)
template<class V1 , int SIZE, class DATA , class DERIVED >
std::ostream & operator<< (std::ostream &out, TinyVectorBase< V1, SIZE, DATA, DERIVED > const &l)
 stream output
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool operator<= (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 less or equal
template<typename IntType1 , typename IntType2 >
bool operator<= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 less-equal
template<typename IntType1 , typename IntType2 >
bool operator<= (Rational< IntType1 > const &l, IntType2 const &r)
 less-equal with right-hand IntType2 argument
template<typename IntType1 , typename IntType2 >
bool operator<= (IntType1 const &l, Rational< IntType2 > const &r)
 less-equal with left-hand IntType1 argument
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool operator<= (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 less or equal
template<class V1 , unsigned int RIDX1, unsigned int GIDX1, unsigned int BIDX1, class V2 , unsigned int RIDX2, unsigned int GIDX2, unsigned int BIDX2>
bool operator== (RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &l, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r)
 component-wise equal
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool operator== (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 equal
template<class R >
bool operator== (FFTWComplex< R > const &a, const FFTWComplex< R > &b)
 equal
template<typename IntType1 , typename IntType2 >
bool operator== (const Rational< IntType1 > &l, const Rational< IntType2 > &r)
 equality
template<typename IntType1 , typename IntType2 >
bool operator== (const Rational< IntType1 > &l, IntType2 const &i)
 equality with right-hand IntType2 argument
template<typename IntType1 , typename IntType2 >
bool operator== (IntType1 const &l, Rational< IntType2 > const &r)
 equality with left-hand IntType1 argument
template<class V1 , int SIZE, class D1 , class D2 , class V2 , class D3 , class D4 >
bool operator== (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise equal
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool operator== (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 equal
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool operator> (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 greater
template<typename IntType1 , typename IntType2 >
bool operator> (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 greater-than
template<typename IntType1 , typename IntType2 >
bool operator> (const Rational< IntType1 > &l, IntType2 const &i)
 greater-than with right-hand IntType2 argument
template<typename IntType1 , typename IntType2 >
bool operator> (IntType1 const &l, Rational< IntType2 > const &r)
 greater-than with left-hand IntType1 argument
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool operator> (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 greater
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool operator>= (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
 greater or equal
template<typename IntType1 , typename IntType2 >
bool operator>= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 greater-equal
template<typename IntType1 , typename IntType2 >
bool operator>= (Rational< IntType1 > const &l, IntType2 const &r)
 greater-equal with right-hand IntType2 argument
template<typename IntType1 , typename IntType2 >
bool operator>= (IntType1 const &l, Rational< IntType2 > const &r)
 greater-equal with left-hand IntType1 argument
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool operator>= (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
 greater or equal
template<... >
void pLSA (...)
 Decompose a matrix according to the pLSA algorithm.
TinyVector< float, 3 > polar2Lab (double color, double brightness, double saturation)
 Init L*a*b* color triple from polar representation.
TinyVector< float, 3 > polar2Luv (double color, double brightness, double saturation)
 Init L*u*v* color triple from polar representation.
TinyVector< float, 3 > polar2YPrimeCbCr (double color, double brightness, double saturation)
 Init Y'CbCr color triple from polar representation.
TinyVector< float, 3 > polar2YPrimeIQ (double color, double brightness, double saturation)
 Init Y'IQ color triple from polar representation.
TinyVector< float, 3 > polar2YPrimePbPr (double color, double brightness, double saturation)
 Init Y'PbPr color triple from polar representation.
TinyVector< float, 3 > polar2YPrimeUV (double color, double brightness, double saturation)
 Init Y'UV color triple from polar representation.
template<class POLYNOMIAL , class VECTOR >
bool polynomialRealRoots (POLYNOMIAL const &p, VECTOR &roots, bool polishRoots)
template<class POLYNOMIAL , class VECTOR >
bool polynomialRoots (POLYNOMIAL const &poriginal, VECTOR &roots, bool polishRoots)
template<typename IntType >
Rational< IntType > pow (const Rational< IntType > &r, int n)
template<class V , int SIZE, class D1 , class D2 , class E >
TinyVector< V, SIZE > pow (TinyVectorBase< V, SIZE, D1, D2 > const &v, E exponent)
template<unsigned n, class V >
power (const V &x)
template<class T , class C1 , class C2 , class C3 >
void principleComponents (MultiArrayView< 2, T, C1 > const &features, MultiArrayView< 2, T, C2 > fz, MultiArrayView< 2, T, C3 > zv)
 Decompose a matrix according to the PCA algorithm.
template<class V , int SIZE, class D1 , class D2 >
NumericTraits< V >::Promote prod (TinyVectorBase< V, SIZE, D1, D2 > const &l)
 product of the vector's elements
template<... >
void pyramidExpandBurtFilter (...)
 Two-fold up-sampling for image pyramid reconstruction.
template<class Image , class Alloc >
void pyramidExpandBurtLaplacian (ImagePyramid< Image, Alloc > &pyramid, int fromLevel, int toLevel, double centerValue=0.4)
 Reconstruct a Laplacian pyramid.
template<... >
void pyramidReduceBurtFilter (...)
 Two-fold down-sampling for image pyramid construction.
template<class Image , class Alloc >
void pyramidReduceBurtLaplacian (ImagePyramid< Image, Alloc > &pyramid, int fromLevel, int toLevel, double centerValue=0.4)
 Create a Laplacian pyramid.
template<... >
bool quadraticNoiseNormalization (...)
 Noise normalization by means of an estimated quadratic noise model.
template<class T , class C1 , class C2 , class C3 , class C4 , class C5 , class C6 , class C7 >
quadraticProgramming (MultiArrayView< 2, T, C1 > const &G, MultiArrayView< 2, T, C2 > const &g, MultiArrayView< 2, T, C3 > const &CE, MultiArrayView< 2, T, C4 > const &ce, MultiArrayView< 2, T, C5 > const &CI, MultiArrayView< 2, T, C6 > const &ci, MultiArrayView< 2, T, C7 > &x)
double radialGaborSigma (double centerFrequency)
 Calculate sensible radial sigma for given parameters.
template<... >
void radialSymmetryTransform (...)
 Find centers of radial symmetry in an image.
RandomMT19937randomMT19937 ()
RandomTT800randomTT800 ()
template<typename T , typename IntType >
rational_cast (const Rational< IntType > &src)
template<... >
void readHDF5 (...)
 Read the data specified by the given vigra::HDF5ImportInfo object and write the into the given 'array'.
void readSIF (const SIFImportInfo &info, MultiArrayView< 3, float, UnstridedArrayTag > array)
 Read the image data specified by the given vigra::SIFImportInfo object and write them into the given 'array'.
void readSIFBlock (const SIFImportInfo &info, Shape3 offset, Shape3 shape, MultiArrayView< 3, float, UnstridedArrayTag > array)
 Read parts of the image data from an Andor SIF file specified with an SIFImportinfo object and write them into the MultiArray array.
template<class R >
real (const FFTWComplex< R > &a)
 real part
template<... >
void recursiveFilterLine (...)
 Performs a 1-dimensional recursive convolution of the source signal.
template<... >
void recursiveFilterX (...)
 Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction.
template<... >
void recursiveFilterY (...)
 Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction.
template<... >
void recursiveFirstDerivativeLine (...)
 Performs a 1 dimensional recursive convolution of the source signal.
template<... >
void recursiveFirstDerivativeX (...)
 Recursively calculates the 1 dimensional first derivative in x direction.
template<... >
void recursiveFirstDerivativeY (...)
 Recursively calculates the 1 dimensional first derivative in y direction.
template<... >
void recursiveGaussianFilterLine (...)
 Compute a 1-dimensional recursive approximation of Gaussian smoothing.
template<... >
void recursiveGaussianFilterX (...)
 Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
template<... >
void recursiveGaussianFilterY (...)
 Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
template<... >
void recursiveSecondDerivativeLine (...)
 Performs a 1 dimensional recursive convolution of the source signal.
template<... >
void recursiveSecondDerivativeX (...)
 Recursively calculates the 1 dimensional second derivative in x direction.
template<... >
void recursiveSecondDerivativeY (...)
 Recursively calculates the 1 dimensional second derivative in y direction.
template<... >
void recursiveSmoothLine (...)
 Convolves the image with a 1-dimensional exponential filter.
template<... >
void recursiveSmoothX (...)
 Performs 1 dimensional recursive smoothing in x direction.
template<... >
void recursiveSmoothY (...)
 Performs 1 dimensional recursive smoothing in y direction.
template<... >
void reflectImage (...)
 Reflect image horizontally or vertically.
template<... >
void regionImageToCrackEdgeImage (...)
 Transform a labeled image into a crack edge image.
template<... >
void regionImageToEdgeImage (...)
 Transform a labeled image into an edge image.
template<... >
void removeShortEdges (...)
 Remove short edges from an edge image.
template<... >
void resampleImage (...)
 Resample image by a given factor.
template<... >
void resamplingConvolveImage (...)
 Apply two separable resampling filters successively, the first in x-direction, the second in y-direction.
template<... >
void resamplingConvolveLine (...)
 Performs a 1-dimensional resampling convolution of the source signal using the given set of kernels.
template<... >
void resamplingConvolveX (...)
 Apply a resampling filter in the x-direction.
template<... >
void resamplingConvolveY (...)
 Apply a resampling filter in the y-direction.
template<... >
void resizeImageCatmullRomInterpolation (...)
 Resize image using the Catmull/Rom interpolation function.
template<... >
void resizeImageCoscotInterpolation (...)
 Resize image using the Coscot interpolation function.
template<... >
void resizeImageLinearInterpolation (...)
 Resize image using linear interpolation.
template<... >
void resizeImageNoInterpolation (...)
 Resize image by repeating the nearest pixel values.
template<... >
void resizeImageSplineInterpolation (...)
 Resize image using B-spline interpolation.
template<... >
void resizeMultiArraySplineInterpolation (...)
 Resize MultiArray using B-spline interpolation.
detail::RF_DEFAULT & rf_default ()
 factory function to return a RF_DEFAULT tag
template<class T , class Tag >
void rf_export_HDF5 (const RandomForest< T, Tag > &rf, HDF5File &h5context, const std::string &pathname="")
 Save a random forest to an HDF5File object into a specified HDF5 group.
template<class T , class Tag >
void rf_export_HDF5 (const RandomForest< T, Tag > &rf, const std::string &filename, const std::string &pathname="")
 Save a random forest to a named HDF5 file into a specified HDF5 group.
template<class T , class Tag >
bool rf_import_HDF5 (RandomForest< T, Tag > &rf, HDF5File &h5context, const std::string &pathname="")
 Read a random forest from an HDF5File object's specified group.
template<class T , class Tag >
bool rf_import_HDF5 (RandomForest< T, Tag > &rf, const std::string &filename, const std::string &pathname="")
 Read a random forest from a named HDF5 file's specified group.
template<... >
void rieszTransformOfLOG (...)
 Calculate Riesz transforms of the Laplacian of Gaussian.
template<... >
void rohrCornerDetector (...)
 Find corners in an image (3).
template<... >
void rotateImage (...)
 Rotate image by an arbitrary angle.
linalg::TemporaryMatrix< double > rotationMatrix2DDegrees (double angle)
 Create homogeneous matrix representing a 2D rotation about the coordinate origin.
linalg::TemporaryMatrix< double > rotationMatrix2DDegrees (double angle, TinyVector< double, 2 > const &center)
 Create homogeneous matrix representing a 2D rotation about the given point.
linalg::TemporaryMatrix< double > rotationMatrix2DRadians (double angle)
 Create homogeneous matrix representing a 2D rotation about the coordinate origin.
linalg::TemporaryMatrix< double > rotationMatrix2DRadians (double angle, TinyVector< double, 2 > const &center)
 Create homogeneous matrix representing a 2D rotation about the given point.
REAL round (REAL v)
template<unsigned IntBits, unsigned FracBits>
int round (FixedPoint< IntBits, FracBits > v)
 rounding to the nearest integer.
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 round (FixedPoint16< IntBits, OverflowHandling > v)
 rounding to the nearest integer.
int roundi (double t)
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 roundi (FixedPoint16< IntBits, OverflowHandling > v)
 rounding to the nearest integer.
linalg::TemporaryMatrix< double > scalingMatrix2D (double scalingFactor)
 Create homogeneous matrix representing a 2D uniform scaling about the coordinate origin.
linalg::TemporaryMatrix< double > scalingMatrix2D (double sx, double sy)
 Create homogeneous matrix representing a 2D non-uniform scaling about the coordinate origin.
template<... >
void secondOrderTotalVariationFilter (...)
 Performs Anisotropic Total Variation Regularization.
template<... >
void seededRegionGrowing (...)
 Region Segmentation by means of Seeded Region Growing.
template<... >
void seededRegionGrowing3D (...)
 Three-dimensional Region Segmentation by means of Seeded Region Growing.
template<... >
void separableConvolveMultiArray (...)
 Separated convolution on multi-dimensional arrays.
template<... >
void separableConvolveX (...)
 Performs a 1 dimensional convolution in x direction.
template<... >
void separableConvolveY (...)
 Performs a 1 dimensional convolution in y direction.
template<... >
void separableMultiDistance (...)
 Euclidean distance on multi-dimensional arrays.
template<... >
void separableMultiDistSquared (...)
 Euclidean distance squared on multi-dimensional arrays.
linalg::TemporaryMatrix< double > shearMatrix2D (double s01, double s10)
 Create homogeneous matrix representing a 2D shearing.
template<class T >
sign (T t)
template<class T1 , class T2 >
T1 sign (T1 t1, T2 t2)
template<class T >
int signi (T t)
template<... >
void simpleSharpening (...)
 Perform simple sharpening function.
template<class REAL >
REAL sin_pi (REAL x)
template<... >
void slantedEdgeMTF (...)
 Determine the magnitude transfer function of the camera.
template<class T >
NumericTraits< T >::Promote sq (T t)
template<unsigned IntBits, unsigned FracBits>
SquareRootTraits< FixedPoint
< IntBits, FracBits >
>::SquareRootResult 
sqrt (FixedPoint< IntBits, FracBits > v)
 square root.
template<int IntBits, FPOverflowHandling OverflowHandling>
SquareRootTraits< FixedPoint16
< IntBits, OverflowHandling >
>::SquareRootResult 
sqrt (FixedPoint16< IntBits, OverflowHandling > v)
 square root.
template<class V , int SIZE, class D1 , class D2 >
TinyVector< V, SIZE > sqrt (TinyVectorBase< V, SIZE, D1, D2 > const &v)
Int32 sqrti (Int32 v)
template<class V1 , int SIZE, class D1 , class D2 >
TinyVectorBase< V1, SIZE, D1,
D2 >::SquaredNormType 
squaredNorm (TinyVectorBase< V1, SIZE, D1, D2 > const &t)
 squared norm
template<typename Type >
Quaternion< Type >::SquaredNormType squaredNorm (Quaternion< Type > const &q)
 squared norm
template<unsigned IntBits, unsigned FracBits>
FixedPointTraits< FixedPoint
< IntBits, FracBits >
, FixedPoint< IntBits,
FracBits > >::MultipliesType 
squaredNorm (FixedPoint< IntBits, FracBits > v)
 squared norm (same as v*v).
NormTraits< T >::SquaredNormType squaredNorm (T const &t)
template<class R >
FFTWComplex< R >::SquaredNormType squaredNorm (const FFTWComplex< R > &a)
 squared norm (= squared magnitude)
template<typename IntType >
NormTraits< Rational< IntType >
>::SquaredNormType 
squaredNorm (const Rational< IntType > &r)
 squared norm
template<int IntBits, FPOverflowHandling OverflowHandling>
NormTraits< FixedPoint16
< IntBits, OverflowHandling >
>::SquaredNormType 
squaredNorm (FixedPoint16< IntBits, OverflowHandling > v)
 squared norm (same as v*v).
template<class V , int SIZE>
TinyVector< V, SIZE >
::SquaredNormType 
squaredNorm (TinyVector< V, SIZE > const &t)
 squared norm
template<... >
void structureTensor (...)
 Calculate the Structure Tensor for each pixel of and image, using Gaussian (derivative) filters.
template<... >
void structureTensorMultiArray (...)
 Calculate th structure tensor of a multi-dimensional arrays.
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2, unsigned IntBits3, unsigned FracBits3>
void sub (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
 subtraction with enforced result type.
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2, int IntBits3>
FixedPoint16< IntBits3,
OverflowHandling > & 
sub (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r, FixedPoint16< IntBits3, OverflowHandling > &result)
 subtraction with enforced result type.
template<class V , int SIZE, class D1 , class D2 >
NumericTraits< V >::Promote sum (TinyVectorBase< V, SIZE, D1, D2 > const &l)
 sum of the vector's elements
template<class T >
void symmetric2x2Eigenvalues (T a00, T a01, T a11, T *r0, T *r1)
template<class T >
void symmetric3x3Eigenvalues (T a00, T a01, T a02, T a11, T a12, T a22, T *r0, T *r1, T *r2)
template<... >
void symmetricGradientMultiArray (...)
 Calculate gradient of a multi-dimensional arrays using symmetric difference filters.
template<... >
void tensorDeterminantMultiArray (...)
 Calculate the tensor determinant for every element of a ND tensor array.
template<... >
void tensorEigenRepresentation (...)
 Calculate eigen representation of a symmetric 2x2 tensor.
template<... >
void tensorEigenvaluesMultiArray (...)
 Calculate the tensor eigenvalues for every element of a N-D tensor array.
template<... >
void tensorToEdgeCorner (...)
 Decompose a symmetric 2x2 tensor into its edge and corner parts.
template<... >
void tensorTrace (...)
 Calculate the trace of a 2x2 tensor.
template<... >
void tensorTraceMultiArray (...)
 Calculate the tensor trace for every element of a N-D tensor array.
template<... >
void tiffToRGBImage (...)
 Convert RGB (3-band or color-mapped) TiffImage to RGB image.
template<... >
void tiffToScalarImage (...)
 Convert single-band TiffImage to scalar image.
std::string tolower (std::string s)
template<... >
void totalVariationFilter (...)
 Performs standard Total Variation Regularization.
template<... >
void transformImage (...)
 Apply unary point transformation to each pixel.
template<... >
void transformImageIf (...)
 Apply unary point transformation to each pixel within the ROI (i.e., where the mask is non-zero).
template<... >
void transformMultiArray (...)
 Transform a multi-dimensional array with a unary function or functor.
linalg::TemporaryMatrix< double > translationMatrix2D (TinyVector< double, 2 > const &shift)
 Create homogeneous matrix representing a 2D translation.
template<... >
void transposeImage (...)
 Transpose an image over the major or minor diagonal.
template<... >
void vectorToTensor (...)
 Calculate the tensor (outer) product of a 2D vector with itself.
template<... >
void vectorToTensorMultiArray (...)
 Calculate the tensor (outer) product of a N-D vector with itself.
template<... >
unsigned int watersheds3D (...)
 Region Segmentation by means of the watershed algorithm.
template<... >
unsigned int watershedsRegionGrowing (...)
 Region segmentation by means of a flooding-based watershed algorithm.
template<... >
unsigned int watershedsUnionFind (...)
 Region segmentation by means of the union-find watershed algorithm.
template<... >
void writeHDF5 (...)
 Store array data in an HDF5 file.
template<size_t N, class T , class C >
void writeHDF5Attr (hid_t loc, const char *name, MultiArrayView< N, T, C > const &array)
template<size_t N, class C >
void writeHDF5Attr (hid_t loc, const char *name, MultiArrayView< N, std::string, C > const &array)
template<class T >
void writeHDF5Attr (hid_t loc, const char *name, ArrayVectorView< T > &array)
template<class Arr >
void writeHDF5Attr (std::string filePath, std::string pathInFile, Arr &ar)
template<class V >
TinyVector< float, 3 > yPrimeCbCr2Polar (V const &ycbcr)
 Create polar representation form Y'CbCr.
template<class V >
TinyVector< float, 3 > yPrimeIQ2Polar (V const &yiq)
 Create polar representation form Y'IQ.
template<class V >
TinyVector< float, 3 > yPrimePbPr2Polar (V const &ypbpr)
 Create polar representation form Y'PbPr.
template<class V >
TinyVector< float, 3 > yPrimeUV2Polar (V const &yuv)
 Create polar representation form Y'UV.


Detailed Description

all VIGRA functionality is located in namespace vigra


Typedef Documentation

Standard ridge regression split


Enumeration Type Documentation

tags used with the RandomForestOptions class

See also:
RF_Traits::Option_t

Function Documentation

detail::RF_DEFAULT & rf_default ( )

factory function to return a RF_DEFAULT tag

See also:
RandomForest<>::learn()
void vigra::rf_export_HDF5 ( const RandomForest< T, Tag > &  rf,
HDF5File &  h5context,
const std::string &  pathname = "" 
)

Save a random forest to an HDF5File object into a specified HDF5 group.

The random forest is saved as a set of HDF5 datasets, groups, and attributes below a certain HDF5 group (default: current group of the HDF5File object). No additional data should be stored in that group.

Parameters:
rfRandom forest object to be exported
h5contextHDF5File object to use
pathnameIf empty or not supplied, save the random forest to the current group of the HDF5File object. Otherwise, save to a new-created group specified by the path name, which may be either relative or absolute.
void vigra::rf_export_HDF5 ( const RandomForest< T, Tag > &  rf,
const std::string &  filename,
const std::string &  pathname = "" 
)

Save a random forest to a named HDF5 file into a specified HDF5 group.

The random forest is saved as a set of HDF5 datasets, groups, and attributes below a certain HDF5 group (default: root). No additional data should be stored in that group.

Parameters:
rfRandom forest object to be exported
filenameName of an HDF5 file to open
pathnameIf empty or not supplied, save the random forest to the root group of the HDF5 file. Otherwise, save to a new-created group specified by the path name (relative to the root group).
bool vigra::rf_import_HDF5 ( RandomForest< T, Tag > &  rf,
HDF5File &  h5context,
const std::string &  pathname = "" 
)

Read a random forest from an HDF5File object's specified group.

The random forest is read from a certain HDF5 group (default: current group of the HDF5File object) as a set of HDF5 datasets, groups, and attributes. No additional data should be present in that group.

Parameters:
rfRandom forest object to be imported
h5contextHDF5File object to use
pathnameIf empty or not supplied, read from the random forest from the current group of the HDF5File object. Otherwise, use the group specified by the path name, which may be either relative or absolute.
bool vigra::rf_import_HDF5 ( RandomForest< T, Tag > &  rf,
const std::string &  filename,
const std::string &  pathname = "" 
)

Read a random forest from a named HDF5 file's specified group.

The random forest is read from a certain HDF5 group (default: root group of the HDF5 file) as a set of HDF5 datasets, groups, and attributes. No additional data should be present in that group.

Parameters:
rfRandom forest object to be imported
filenameName of an HDF5 file to open
pathnameIf empty or not supplied, read from the random forest from the current group of the HDF5 file. Otherwise, use the group specified by the path name, which may be either relative or absolute.
std::string vigra::asString ( t)

Convert a value to a string. Available for integral and floating point types and void *.

std::string vigra::tolower ( std::string  s)

Convert string to lower case.

std::string vigra::normalizeString ( std::string const &  s)

Convert string to lower case and remove any white space characters.

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.9.0 (Tue Nov 6 2012)