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

| vigra Namespace Reference |

## 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< UInt8 > | BImage
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< Int32 > | IImage
typedef detail::SelectIntegerType < 16, detail::SignedIntTypes > ::type | Int16
| 16-bit signed int
typedef BasicImage< Int16 > | Int16Image
typedef BasicImage< RGBValue < Int16 > > | Int16RGBImage
typedef detail::SelectIntegerType < 32, detail::SignedIntTypes > ::type | Int32
| 32-bit signed int
typedef BasicImage< Int32 > | Int32Image
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< Int8 > | Int8Image
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< Int16 > | SImage
typedef BasicImage< RGBValue < Int16 > > | SRGBImage
typedef RandomNumberGenerator | TemperedTwister
typedef detail::SelectIntegerType < 16, detail::UnsignedIntTypes > ::type | UInt16
| 16-bit unsigned int
typedef BasicImage< UInt16 > | UInt16Image
typedef BasicImage< RGBValue < UInt16 > > | UInt16RGBImage
typedef detail::SelectIntegerType < 32, detail::UnsignedIntTypes > ::type | UInt32
| 32-bit unsigned int
typedef BasicImage< UInt32 > | UInt32Image
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< UInt8 > | UInt8Image
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 >
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 >
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 >
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 >
T | 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.
RandomMT19937 & | randomMT19937 ()
RandomTT800 & | randomTT800 ()
template<typename T , typename IntType >
T | 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 >
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 >
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

typedef RidgeSplit<BestGiniOfColumn<GiniCriterion> > GiniRidgeSplit

Standard ridge regression split

## Enumeration Type Documentation

enum RF_OptionTag

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:

  rf | Random forest object to be exported
  h5context | HDF5File object to use
  pathname | If 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:

  rf | Random forest object to be exported
  filename | Name of an HDF5 file to open
  pathname | If 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:

  rf | Random forest object to be imported
  h5context | HDF5File object to use
  pathname | If 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:

  rf | Random forest object to be imported
  filename | Name of an HDF5 file to open
  pathname | If 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 | 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)