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

| vigra Namespace Reference |

## 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 | CatmullRomSpline
class | ColumnIterator
| Iterator adapter to linearly access colums. 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 | CoscotFunction
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 type '`fftw_complex`'. More...
class | FFTWImaginaryAccessor
class | FFTWMagnitudeAccessor
class | FFTWPhaseAccessor
class | FFTWRealAccessor
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 | 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 | 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
struct | MeshGridAccessor
class | MultiArray
| Main `MultiArray` class containing the memory management. More...
class | MultiArrayNavigator
| A navigator that provides acces 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 | 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 | Point2D
| Two dimensional point or position. More...
class | Polynomial
class | PolynomialView
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 | 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, unsing 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 | 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 | 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 | 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...

## Namespaces

namespace | detail
namespace | linalg
namespace | FourNeighborhood
namespace | EightNeighborhood
namespace | Neighborhood3DSix
namespace | Neighborhood3DTwentySix

## 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 BasicImage< Int16 > | SImage
typedef BasicImage< RGBValue < Int16 > > | SRGBImage
typedef RandomNumberGenerator | TemperedTwister
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

## Functions

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<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<typename IntType>
Rational< IntType > | abs (const Rational< IntType > &r)
| absolute value
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits, OverflowHandling > | abs (FixedPoint16< IntBits, OverflowHandling > v)
| absolute value.
template<unsigned IntBits, unsigned FracBits>
FixedPoint< IntBits, FracBits > | abs (FixedPoint< IntBits, FracBits > v)
| absolute value.
FFTWComplex::value_type | abs (const FFTWComplex &a)
| absolute value (= magnitude)
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<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<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 | 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 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.
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<class V, int SIZE, class D1, class D2>
TinyVector< V, SIZE > | ceil (TinyVectorBase< V, SIZE, D1, D2 > const &v)
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<typename IntType>
Rational< IntType > | ceil (const Rational< IntType > &r)
| smallest integer not smaller than `r`
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 | ceil (FixedPoint16< IntBits, OverflowHandling > v)
| rounding up.
template<unsigned IntBits, unsigned FracBits>
int | ceil (FixedPoint< IntBits, FracBits > v)
| rounding up.
UInt32 | ceilPower2 (UInt32 x)
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.
FFTWComplex | conj (const FFTWComplex &a)
| complex conjugate
template<class PointArray1, class PointArray2>
void | convexHull (const PointArray1 &points, PointArray2 &convex_hull)
| Compute convex hull of a 2D polygon.
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<... >
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, 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 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<... >
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<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, 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<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<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits, OverflowHandling > | dual_frac (FixedPoint16< IntBits, OverflowHandling > v)
| dual fractional part. (1 - frac(v))
template<unsigned IntBits, unsigned FracBits>
FixedPoint< 0, FracBits > | dual_frac (FixedPoint< IntBits, FracBits > 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.
template<... >
void | exportFloatingScalarImage (...)
| Deprecated.
template<... >
void | exportFloatingVectorImage (...)
| Deprecated.
template<... >
void | exportImage (...)
| Write an image, given an vigra::ImageExportInfo object.
template<... >
void | exportIntegralScalarImage (...)
| Deprecated.
template<... >
void | exportIntegralVectorImage (...)
| Deprecated.
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.
template<... >
void | extendedLocalMinima (...)
| Find local minimal regions in an image.
template<class TARGET, int IntBits, FPOverflowHandling OverflowHandling>
TARGET | fixed_point_cast (FixedPoint16< IntBits, OverflowHandling > v)
template<class TARGET, unsigned IntBits, unsigned FracBits>
TARGET | fixed_point_cast (FixedPoint< IntBits, FracBits > v)
template<class V, int SIZE, class D1, class D2>
TinyVector< V, SIZE > | floor (TinyVectorBase< V, SIZE, D1, D2 > const &v)
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<typename IntType>
Rational< IntType > | floor (const Rational< IntType > &r)
| largest integer not larger than `r`
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 | floor (FixedPoint16< IntBits, OverflowHandling > v)
| rounding down.
template<unsigned IntBits, unsigned FracBits>
int | floor (FixedPoint< IntBits, FracBits > 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.
void | fourierTransformInverse (FFTWComplexImage::const_traverser sul, FFTWComplexImage::const_traverser slr, FFTWComplexImage::ConstAccessor src, FFTWComplexImage::traverser dul, FFTWComplexImage::Accessor dest)
| Compute inverse Fourier transforms.
template<... >
void | fourierTransformReal (...)
| Real Fourier transforms for even and odd boundary conditions (aka. cosine and sine transforms).
template<int IntBits, FPOverflowHandling OverflowHandling>
FixedPoint16< IntBits, OverflowHandling > | frac (FixedPoint16< IntBits, OverflowHandling > v)
| fractional part. (difference between v and its floor)
template<unsigned IntBits, unsigned FracBits>
FixedPoint< 0, FracBits > | frac (FixedPoint< IntBits, FracBits > v)
| fractional part.
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<... >
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 hypothenuse.
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 | importScalarImage (...)
| used for reading images of scalar type, such as integer and float grayscale.
template<... >
void | importTiffImage (...)
| Convert given TiffImage into image specified by iterator range.
template<... >
void | importVectorImage (...)
| used for reading images of vector type, such as integer of float rgb.
template<class T, class Stride>
void | importVolume (VolumeImportInfo const &info, MultiArrayView< 3, T, Stride > &volume)
| 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 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<... >
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 | 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.
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 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<... >
void | localMaxima (...)
| Find local maxima in an image.
template<... >
void | localMinima (...)
| Find local minima in an image.
Int32 | log2i (UInt32 x)
template<class V>
TinyVector< float, 3 > | luv2Polar (V const &luv)
| Create polar representation form L*u*v*.
template<class T>
BasicImageView< T > | makeBasicImageView (MultiArray< 3, T > const &array)
template<class T>
BasicImageView< T > | makeBasicImageView (MultiArrayView< 2, T, UnstridedArrayTag > const &array)
template<class T>
BasicImageView< RGBValue< T > > | makeRGBImageView (MultiArray< 3, T > const &array)
triple< Diff2D, Diff2D, MeshGridAccessor > | meshGrid (Diff2D upperLeft, Diff2D lowerRight)
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<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<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<... >
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<typename IntType>
Rational< IntType > | norm (const Rational< IntType > &r)
| norm (same as `abs(r)`)
template<class T>
NormTraits< T >::NormType | norm (T const &t)
template<int IntBits, FPOverflowHandling OverflowHandling>
NormTraits< FixedPoint16 < IntBits, OverflowHandling > >::NormType | norm (FixedPoint16< IntBits, OverflowHandling > const &v)
| norm (same as abs).
template<unsigned IntBits, unsigned FracBits>
FixedPoint< IntBits, FracBits > | norm (FixedPoint< IntBits, FracBits > const &v)
| norm (same as abs).
FFTWComplex::NormType | norm (const FFTWComplex &a)
| norm (= magnitude)
template<... >
void | normalizedConvolveImage (...)
| Performs a 2-dimensional normalized convolution, i.e. convolution with a mask image.
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<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<typename IntType1, typename IntType2>
bool | operator!= (IntType1 const &l, Rational< IntType2 > const &r)
| inequality with left-hand `IntType1` argument
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!= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
| inequality
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool | operator!= (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
| not equal
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool | operator!= (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
| not equal
bool | operator!= (FFTWComplex const &a, const FFTWComplex &b)
| not equal
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<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 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, 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<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 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<typename IntType>
Rational< IntType > | operator* (typename Rational< IntType >::param_type l, Rational< IntType > r)
| multiplication with left-hand `IntType` argument
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* (Rational< IntType > l, Rational< IntType > const &r)
| 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<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.
FFTWComplex | operator* (const double &a, FFTWComplex b)
| left multiplication with scalar double
FFTWComplex | operator* (FFTWComplex a, const double &b)
| right multiplication with scalar double
FFTWComplex | operator* (FFTWComplex a, const FFTWComplex &b)
| multiplication
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 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
FFTWComplex & | operator*= (FFTWComplex &a, const double &b)
| multiply-assignment with scalar double
FFTWComplex & | operator*= (FFTWComplex &a, const FFTWComplex &b)
| multiply-assignment
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<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+ (typename Rational< IntType >::param_type l, Rational< IntType > r)
| addition of left-hand `IntType` argument
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+ (Rational< IntType > l, Rational< IntType > const &r)
| addition
template<typename IntType>
Rational< IntType > | operator+ (const Rational< IntType > &r)
| unary plus
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<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.
FFTWComplex | operator+ (FFTWComplex a, const FFTWComplex &b)
| addition
Point2D | operator+ (Size2D const &s, Point2D const &p)
Point2D | operator+ (Point2D const &a, Diff2D const &b)
Size2D | operator+ (Size2D const &a, Diff2D const &b)
Diff2D | operator+ (Diff2D const &a, Diff2D const &b)
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
FFTWComplex & | operator+= (FFTWComplex &a, const FFTWComplex &b)
| add-assignment
template<class V, int SIZE, class D1, class D2>
TinyVector< V, SIZE > | operator- (TinyVectorBase< V, SIZE, D1, D2 > const &v)
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<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- (typename Rational< IntType >::param_type l, Rational< IntType > const &r)
| subtraction from left-hand `IntType` argument
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- (Rational< IntType > l, Rational< IntType > const &r)
| subtraction
template<typename IntType>
Rational< IntType > | operator- (const Rational< IntType > &r)
| unary minus (negation)
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<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.
FFTWComplex | operator- (FFTWComplex a, const FFTWComplex &b)
| subtraction
Size2D | operator- (Point2D const &s, Point2D const &p)
Point2D | operator- (Point2D const &s, Diff2D const &offset)
Size2D | operator- (Size2D const &s, Diff2D const &offset)
Diff2D | operator- (Diff2D const &a, Diff2D const &b)
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
FFTWComplex & | operator-= (FFTWComplex &a, const FFTWComplex &b)
| subtract-assignment
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<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, 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<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<typename IntType>
Rational< IntType > | operator/ (typename Rational< IntType >::param_type l, Rational< IntType > const &r)
| division of left-hand `IntType` argument
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/ (Rational< IntType > l, Rational< IntType > const &r)
| 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.
FFTWComplex | operator/ (FFTWComplex a, const double &b)
| right division with scalar double
FFTWComplex | operator/ (FFTWComplex a, const FFTWComplex &b)
| division
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 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
FFTWComplex & | operator/= (FFTWComplex &a, const double &b)
| divide-assignment with scalar double
FFTWComplex & | operator/= (FFTWComplex &a, const FFTWComplex &b)
| divide-assignment
template<typename IntType1, typename IntType2>
bool | operator< (IntType1 const &l, Rational< IntType2 > const &r)
| less-than with left-hand `IntType1` argument
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< (const Rational< IntType1 > &l, const Rational< IntType2 > &r)
| less-than
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool | operator< (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
| less than
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool | operator< (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
| less than
template<class V1, int SIZE, class DATA, class DERIVED>
std::ostream & | operator<< (std::ostream &out, TinyVectorBase< V1, SIZE, DATA, DERIVED > const &l)
| stream output
std::ostream & | operator<< (std::ostream &os, const SIFImportInfo &info)
template<typename IntType1, typename IntType2>
bool | operator<= (IntType1 const &l, Rational< IntType2 > const &r)
| less-equal with left-hand `IntType1` argument
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<= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
| less-equal
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool | operator<= (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
| less or equal
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool | operator<= (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
| less or equal
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<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<typename IntType1, typename IntType2>
bool | operator== (IntType1 const &l, Rational< IntType2 > const &r)
| equality with left-hand `IntType1` argument
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== (const Rational< IntType1 > &l, const Rational< IntType2 > &r)
| equality
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)
| equal
bool | operator== (FFTWComplex const &a, const FFTWComplex &b)
| equal
template<typename IntType1, typename IntType2>
bool | operator> (IntType1 const &l, Rational< IntType2 > const &r)
| greater-than with left-hand `IntType1` argument
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> (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
| greater-than
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
template<typename IntType1, typename IntType2>
bool | operator>= (IntType1 const &l, Rational< IntType2 > const &r)
| greater-equal with left-hand `IntType1` argument
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>= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
| greater-equal
template<int IntBits1, FPOverflowHandling OverflowHandling, int IntBits2>
bool | operator>= (FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r)
| greater or equal
template<unsigned IntBits1, unsigned FracBits1, unsigned IntBits2, unsigned FracBits2>
bool | operator>= (FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
| greater or equal
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<... >
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<class ImageIterator, class Accessor, class SrcValueType>
void | read_band (Decoder *dec, ImageIterator ys, Accessor a, SrcValueType)
| used for reading bands after the source data type has been figured out.
template<class ImageIterator, class Accessor, class SrcValueType>
void | read_bands (Decoder *dec, ImageIterator ys, Accessor a, SrcValueType)
| used for reading bands after the source data type has been figured out.
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'.
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<... >
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, TinyVector< double, 2 > const &center)
| Create homogeneous matrix representing a 2D rotation about the given point.
linalg::TemporaryMatrix< double > | rotationMatrix2DDegrees (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.
linalg::TemporaryMatrix< double > | rotationMatrix2DRadians (double angle)
| Create homogeneous matrix representing a 2D rotation about the coordinate origin.
float | round (float t)
template<int IntBits, FPOverflowHandling OverflowHandling>
Int32 | round (FixedPoint16< IntBits, OverflowHandling > v)
| rounding to the nearest integer.
template<unsigned IntBits, unsigned FracBits>
int | round (FixedPoint< IntBits, FracBits > 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 sx, double sy)
| Create homogeneous matrix representing a 2D non-uniform scaling about the coordinate origin.
linalg::TemporaryMatrix< double > | scalingMatrix2D (double scalingFactor)
| Create homogeneous matrix representing a 2D uniform scaling about the coordinate origin.
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 T1, class T2>
T1 | sign (T1 t1, T2 t2)
template<class T>
T | sign (T t)
template<class T>
int | signi (T t)
template<... >
void | simpleSharpening (...)
| Perform simple sharpening function.
template<... >
void | slantedEdgeMTF (...)
| Determine the magnitude transfer function of the camera.
template<class T>
NumericTraits< T >::Promote | sq (T t)
template<int IntBits, FPOverflowHandling OverflowHandling>
SquareRootTraits< FixedPoint16 < IntBits, OverflowHandling > >::SquareRootResult | sqrt (FixedPoint16< IntBits, OverflowHandling > v)
| square root.
template<unsigned IntBits, unsigned FracBits>
SquareRootTraits< FixedPoint < IntBits, FracBits > >::SquareRootResult | sqrt (FixedPoint< IntBits, FracBits > v)
| square root.
UInt32 | sqrti (UInt32 v)
Int32 | sqrti (Int32 v)
template<class V, int SIZE>
TinyVector< V, SIZE > ::SquaredNormType | squaredNorm (TinyVector< V, SIZE > const &t)
| squared norm
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 IntType>
NormTraits< Rational< IntType > >::SquaredNormType | squaredNorm (const Rational< IntType > &r)
| squared norm
NormTraits< T >::SquaredNormType | squaredNorm (T const &t)
template<int IntBits, FPOverflowHandling OverflowHandling>
NormTraits< FixedPoint16 < IntBits, OverflowHandling > >::SquaredNormType | squaredNorm (FixedPoint16< IntBits, OverflowHandling > v)
| squared norm (same as v*v).
template<unsigned IntBits, unsigned FracBits>
FixedPointTraits< FixedPoint < IntBits, FracBits > , FixedPoint< IntBits, FracBits > >::MultipliesType | squaredNorm (FixedPoint< IntBits, FracBits > v)
| squared norm (same as v*v).
FFTWComplex::SquaredNormType | squaredNorm (const FFTWComplex &a)
| squared norm (= squared magnitude)
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<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<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<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.
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 | watersheds (...)
| Region Segmentation by means of the watershed algorithm.
template<... >
unsigned int | watersheds3D (...)
| Region Segmentation by means of the watershed algorithm.
template<class ImageIterator, class Accessor, class DstValueType>
void | write_band (Encoder *enc, ImageIterator ul, ImageIterator lr, Accessor a, DstValueType)
| used for writing bands after the source data type has been figured out.
template<class ImageIterator, class Accessor, class DstValueType>
void | write_bands (Encoder *enc, ImageIterator ul, ImageIterator lr, Accessor a, DstValueType)
| used for writing bands after the source data type has been figured out.
template<... >
void | writeHDF5 (...)
| Store array data in an HDF5 file.
template<class Arr>
void | writeHDF5Attr (std::string filePath, std::string pathInFile, Arr &ar)
template<class T>
void | writeHDF5Attr (hid_t loc, const char *name, ArrayVectorView< T > &array)
template<size_t N, class C>
void | writeHDF5Attr (hid_t loc, const char *name, MultiArrayView< N, std::string, C > const &array)
template<size_t N, class T, class C>
void | writeHDF5Attr (hid_t loc, const char *name, MultiArrayView< N, T, C > const &array)
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.

## Variables

| UInt16
| 16-bit unsigned int

## 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()

template<class T>
std::string vigra::asString | ( | T | t | ) |

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

© 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.7.1 (3 Dec 2010)