[ 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 | BilinearInterpolatingAccessor | 
| Bilinear interpolation at non-integer positions.  More... | |
| class | BlueAccessor | 
| 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 | Edgel | 
| 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 | FixedPoint | 
| 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 | GrayToRGBAccessor | 
| class | GreenAccessor | 
| 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 | 
| class | MultiArray | 
| Main MultiArrayclass 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 | NoiseNormalizationOptions | 
| Pass options to one of the noise normalization functions.  More... | |
| struct | NormalRandomFunctor | 
| class | Point2D | 
| Two dimensional point or position.  More... | |
| class | Polynomial | 
| class | PolynomialView | 
| 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 | SeedRgDirectValueFunctor | 
| Statistics functor to be used for seeded region growing.  More... | |
| class | SequenceAccessor | 
| Accessor for items that are STL compatible sequences.  More... | |
| class | Size2D | 
| Two dimensional size object.  More... | |
| class | SlantedEdgeMTFOptions | 
| Pass options to one of the slantedEdgeMTF() functions.  More... | |
| 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 | 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 | 
| 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 | TinyVector | 
| Class for fixed size vectors.  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 | 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 | 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 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 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 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... | |
| 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<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<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<... > | |
| 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<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 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<class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> | |
| void | discRankOrderFilter (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius, float rank) | 
| template<... > | |
| void | discRankOrderFilter (...) | 
| Apply rank order filter with disc structuring function to the image. | |
| template<class SrcIterator, class SrcAccessor, class MaskIterator, class MaskAccessor, class DestIterator, class DestAccessor> | |
| void | discRankOrderFilterWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius, float rank) | 
| template<... > | |
| void | discRankOrderFilterWithMask (...) | 
| Apply rank order filter with disc structuring function to the image using a mask. | |
| template<... > | |
| void | distanceTransform (...) | 
| 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<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) | 
| double | erf (double x) | 
| 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 std::string &name_base, const std::string &name_ext) | 
| 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, 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<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<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 | hourGlassFilter (...) | 
| Anisotropic tensor smoothing with the hourglass filter. | |
| double | hypot (double a, double b) | 
| 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 Allocator> | |
| void | importVolume (VolumeImportInfo const &info, MultiArray< 3, T, Allocator > &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 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. | |
| 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<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) | 
| 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<... > | |
| 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<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 IntType1argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator!= (const Rational< IntType1 > &l, IntType2 const &i) | 
| inequality with right-hand IntType2argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator!= (Rational< IntType1 > const &l, Rational< IntType2 > const &r) | 
| inequality | |
| 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 IntTypeargument | |
| template<typename IntType> | |
| Rational< IntType > | operator* (Rational< IntType > l, typename Rational< IntType >::param_type r) | 
| multiplication with right-hand IntTypeargument | |
| template<typename IntType> | |
| Rational< IntType > | operator* (Rational< IntType > l, Rational< IntType > const &r) | 
| multiplication | |
| 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 IntTypeargument | |
| template<typename IntType> | |
| Rational< IntType > | operator+ (Rational< IntType > l, typename Rational< IntType >::param_type r) | 
| addition of right-hand IntTypeargument | |
| 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<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 IntTypeargument | |
| template<typename IntType> | |
| Rational< IntType > | operator- (Rational< IntType > l, typename Rational< IntType >::param_type r) | 
| subtraction of right-hand IntTypeargument | |
| 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<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 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/ (typename Rational< IntType >::param_type l, Rational< IntType > const &r) | 
| division of left-hand IntTypeargument | |
| template<typename IntType> | |
| Rational< IntType > | operator/ (Rational< IntType > l, typename Rational< IntType >::param_type r) | 
| division by right-hand IntTypeargument | |
| template<typename IntType> | |
| Rational< IntType > | operator/ (Rational< IntType > l, Rational< IntType > const &r) | 
| division | |
| 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 | |
| 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 IntType1argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator< (const Rational< IntType1 > &l, IntType2 const &i) | 
| less-than with right-hand IntType2argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator< (const Rational< IntType1 > &l, const Rational< IntType2 > &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 | |
| template<class T, class C> | |
| std::ostream & | operator<< (std::ostream &s, const vigra::MultiArrayView< 2, T, C > &m) | 
| std::ostream & | operator<< (std::ostream &s, vigra::Rect2D const &r) | 
| std::ostream & | operator<< (std::ostream &s, vigra::Size2D const &d) | 
| std::ostream & | operator<< (std::ostream &o, vigra::Diff2D const &d) | 
| template<typename IntType1, typename IntType2> | |
| bool | operator<= (IntType1 const &l, Rational< IntType2 > const &r) | 
| less-equal with left-hand IntType1argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator<= (Rational< IntType1 > const &l, IntType2 const &r) | 
| less-equal with right-hand IntType2argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator<= (Rational< IntType1 > const &l, Rational< IntType2 > const &r) | 
| less-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 IntType1argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator== (const Rational< IntType1 > &l, IntType2 const &i) | 
| equality with right-hand IntType2argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator== (const Rational< IntType1 > &l, const Rational< IntType2 > &r) | 
| equality | |
| 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 IntType1argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator> (const Rational< IntType1 > &l, IntType2 const &i) | 
| greater-than with right-hand IntType2argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator> (Rational< IntType1 > const &l, Rational< IntType2 > const &r) | 
| greater-than | |
| 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 IntType1argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator>= (Rational< IntType1 > const &l, IntType2 const &r) | 
| greater-equal with right-hand IntType2argument | |
| template<typename IntType1, typename IntType2> | |
| bool | operator>= (Rational< IntType1 > const &l, Rational< IntType2 > const &r) | 
| greater-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. | |
| 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 | 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 | 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. | |
| 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 ¢er) | 
| 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 ¢er) | 
| 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<unsigned IntBits, unsigned FracBits> | |
| int | round (FixedPoint< IntBits, FracBits > 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<... > | |
| 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<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<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<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<... > | |
| void | symmetricGradientMultiArray (...) | 
| Calculate gradient of a multi-dimensional arrays using symmetric difference filters. | |
| template<... > | |
| void | tensorEigenRepresentation (...) | 
| Calculate eigen representation of a symmetric 2x2 tensor. | |
| 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 | 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<... > | |
| 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<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 | |
| std::ostream& vigra::operator<< | ( | std::ostream & | o, | |
| vigra::Diff2D const & | d | |||
| ) | 
Output a vigra::Diff2D as a tuple. Example Diff2D(-12, 13) -> "(-12, 13)"
| std::ostream& vigra::operator<< | ( | std::ostream & | s, | |
| vigra::Size2D const & | d | |||
| ) | 
Output a vigra::Size2D. Example Size2D(100, 200) -> "(100x200)"
| std::ostream& vigra::operator<< | ( | std::ostream & | s, | |
| vigra::Rect2D const & | r | |||
| ) | 
Output a description of a vigra::Rect2D. Example Rect2D(10, 10, 30, 20) -> "[(10, 10) to (30, 20) = (20x10)]"
| 
© Ullrich Köthe     (ullrich.koethe@iwr.uni-heidelberg.de)  | 
html generated using doxygen and Python
 |