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

details vigra Namespace Reference VIGRA


Classes

class  ArrayOfRegionStatistics
 Calculate statistics for all regions of a labeled image. More...

class  ArrayVector
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  ConstValueIterator
 Iterator that always returns the constant specified in the constructor. More...

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  CoordinateIterator
 Simulate an image where each pixel contains its coordinate. More...

class  CoscotFunction
class  DiffusivityFunctor
 Diffusivity functor for non-linear diffusion. More...

class  FindAverage
 Find the average pixel value 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  GrayToRGBAccessor
class  GreenAccessor
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  IteratorAdaptor
 Quckly 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  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  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  MultiArrayView
 Base class for, and view to, vigra::MultiArray. More...

class  MultiIterator
 A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView if it is not strided. More...

class  MultiIteratorBase
 Enclosing class for vigra::MultiIterator base classes. 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  Polynomial
class  PolynomialView
class  Rational
class  RedAccessor
class  ReduceFunctor
 Apply a functor to reduce the dimensionality of an array. More...

class  RGBAccessor
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  SplineImageView
 Create a continuous view onto a discrete image using splines. More...

class  StaticPolynomial
struct  StridedArrayTag
class  StridedImageIterator
 Iterator to be used when pixels are to be skipped. More...

class  BasicImage
 Fundamental class template for images. More...

class  BasicImageIterator
class  BasicImageIteratorBase
class  BasicImageView
 BasicImage using foreign memory. More...

class  ConstBasicImageIterator
class  CrackContourCirculator
 Circulator that walks around a given region. More...

class  Diff2D
 Two dimensional difference vector. 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  FunctorTraits
 Export associated information for a functor. More...

class  GaborFilterFamily
 Family of gabor filters of different scale and direction. More...

class  Gaussian
class  ImageArray
 Fundamental class template for arrays of equal-sized images. More...

class  ImageExportInfo
 Argument object for the function exportImage(). See exportImage() for usage example. This object must be used to define the properties of an image to be written to disk. More...

class  ImageImportInfo
 Argument object for the function importImage(). See importImage() for a usage example. This object must be used to read an image from disk and enquire about its properties. 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  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  MultiImageAccessor2
 Access two images simultaneously. More...

class  Point2D
 Two dimensional point or position. More...

class  Rect2D
 Two dimensional rectangle. 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  RGB2XYZFunctor
 Convert linear (raw) RGB into standardized tri-stimulus XYZ. More...

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  SequenceAccessor
 Accessor for items that are STL compatible sequences. More...

class  Size2D
 Two dimensional size object. 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  type
 Base class for vigra::MultiIterator. More...

class  StridedMultiIterator
 A multi-dimensional hierarchical iterator to be used with vigra::MultiArrayView is it is strided. More...

class  StridedMultiIteratorBase
 Encloses the base class for vigra::StridedMultiIterator. More...

class  type
 Base class for vigra::StridedMultiIterator. 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...

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...


Typedefs

typedef BasicImage< fftw_real > FFTWRealImage
typedef BasicImage< FFTWComplexFFTWComplexImage
typedef FourNeighborhood::NeighborCode FourNeighborCode
typedef EightNeighborhood::NeighborCode EightNeighborCode
typedef NeighborOffsetCirculator<
EightNeighborCode
EightNeighborOffsetCirculator
typedef NeighborOffsetCirculator<
FourNeighborCode
FourNeighborOffsetCirculator
typedef BasicImage< unsigned
char > 
BImage
typedef BasicImage< short > SImage
typedef BasicImage< int > IImage
typedef BasicImage< float > FImage
typedef BasicImage< double > DImage
typedef BasicImage< RGBValue<
unsigned char > > 
BRGBImage
typedef BasicImage< RGBValue<
int > > 
IRGBImage
typedef BasicImage< RGBValue<
float > > 
FRGBImage
typedef BasicImage< RGBValue<
double > > 
DRGBImage
typedef BasicImage< TinyVector<
float, 2 > > 
FVector2Image
typedef BasicImage< TinyVector<
float, 3 > > 
FVector3Image
typedef BasicImage< TinyVector<
float, 4 > > 
FVector4Image
typedef BasicImage< TinyVector<
double, 2 > > 
DVector2Image
typedef BasicImage< TinyVector<
double, 3 > > 
DVector3Image
typedef BasicImage< TinyVector<
double, 4 > > 
DVector4Image

Functions

template<...> void rotateImage (SrcIterator is, SrcIterator end, SrcAccessor as, DestIterator id, DestAccessor ad, int rotation)
 Rotate image by a multiple of 90 degrees.

template<...> void reflectImage (SrcIterator is, SrcIterator end, SrcAccessor as, DestIterator id, DestAccessor ad, Reflect reflect)
 Reflect image horizontally or vertically.

template<...> void transposeImage (SrcIterator is, SrcIterator end, SrcAccessor as, DestIterator id, DestAccessor ad, Transpose transpose)
 Transpose an image over the major or minor diagonal.

template<...> void resampleImage (SrcIterator is, SrcIterator iend, SrcAccessor sa, DestIterator id, DestAccessor ad, double factor)
 Resample image by a given factor.

template<...> void rieszTransformOfLOG (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor src, DestIterator dupperleft, DestAccessor dest, double scale, unsigned int xorder, unsigned int yorder)
 Calculate Riesz transforms of the Laplacian of Gaussian.

template<...> void boundaryTensor (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor src, DestIterator dupperleft, DestAccessor dest, double scale)
 Calculate the boundary tensor for a scalar valued image.

TinyVector< float, 3 > polar2Lab (double color, double brightness, double saturation)
 Init L*a*b* color triple from polar representation.

template<...> TinyVector< float, 3 > lab2Polar (V const &lab)
 Create polar representation form L*a*b*.

TinyVector< float, 3 > polar2Luv (double color, double brightness, double saturation)
 Init L*u*v* color triple from polar representation.

template<...> TinyVector< float, 3 > luv2Polar (V const &luv)
 Create polar representation form L*u*v*.

TinyVector< float, 3 > polar2YPrimePbPr (double color, double brightness, double saturation)
 Init Y'PbPr color triple from polar representation.

template<...> TinyVector< float, 3 > yPrimePbPr2Polar (V const &ypbpr)
 Create polar representation form Y'PbPr.

TinyVector< float, 3 > polar2YPrimeCbCr (double color, double brightness, double saturation)
 Init Y'CbCr color triple from polar representation.

template<...> TinyVector< float, 3 > yPrimeCbCr2Polar (V const &ycbcr)
 Create polar representation form Y'CbCr.

TinyVector< float, 3 > polar2YPrimeIQ (double color, double brightness, double saturation)
 Init Y'IQ color triple from polar representation.

template<...> TinyVector< float, 3 > yPrimeIQ2Polar (V const &yiq)
 Create polar representation form Y'IQ.

TinyVector< float, 3 > polar2YPrimeUV (double color, double brightness, double saturation)
 Init Y'UV color triple from polar representation.

template<...> TinyVector< float, 3 > yPrimeUV2Polar (V const &yuv)
 Create polar representation form Y'UV.

template<...> void combineTwoImages (SrcImageIterator1 src1_upperleft, SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, DestImageIterator dest_upperleft, DestAccessor da, Functor const &f)
 Combine two source images into destination image.

template<...> void combineTwoImagesIf (SrcImageIterator1 src1_upperleft, SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, MaskImageIterator mask_upperleft, MaskAccessor ma, DestImageIterator dest_upperleft, DestAccessor da, Functor const &f)
 Combine ROI of two source images into destination image.

template<...> void combineThreeImages (SrcImageIterator1 src1_upperleft, SrcImageIterator1 src1_lowerright, SrcAccessor1 sa1, SrcImageIterator2 src2_upperleft, SrcAccessor2 sa2, SrcImageIterator3 src3_upperleft, SrcAccessor3 sa3, DestImageIterator dest_upperleft, DestAccessor da, Functor const &f)
 Combine three source images into destination image.

template<...> 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 simpleSharpening (SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc, DestIterator dest_ul, DestAccessor dest_acc, double sharpening_factor)
 Perform simple sharpening function.

template<...> void gaussianSharpening (SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc, DestIterator dest_ul, DestAccessor dest_acc, double sharpening_factor, double scale)
 Perform sharpening function with gaussian filter.

template<...> void gaussianSmoothing (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIterator dupperleft, DestAccessor da, double scale)
 Perform isotropic Gaussian convolution.

template<...> void gaussianGradient (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIteratorX dupperleftx, DestAccessorX dax, DestIteratorY dupperlefty, DestAccessorY day, double scale)
 Calculate the gradient vector by means of a 1st derivatives of Gaussian filter.

template<...> void laplacianOfGaussian (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIterator dupperleft, DestAccessor da, double scale)
 Filter image with the Laplacian of Gaussian operator at the given scale.

template<...> void hessianMatrixOfGaussian (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIteratorX dupperleftx, DestAccessorX dax, DestIteratorXY dupperleftxy, DestAccessorXY daxy, DestIteratorY dupperlefty, DestAccessorY day, double scale)
 Filter image with the 2nd derivatives of the Gaussian at the given scale to get the Hessian matrix.

template<...> void structureTensor (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIteratorX dupperleftx, DestAccessorX dax, DestIteratorXY dupperleftxy, DestAccessorXY daxy, DestIteratorY dupperlefty, DestAccessorY day, double inner_scale, double outer_scale)
 Calculate the Structure Tensor for each pixel of and image, using Gaussian (derivative) filters.

template<...> void copyImage (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da)
 Copy source image into destination image.

template<...> void copyImageIf (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, MaskImageIterator mask_upperleft, MaskAccessor ma, DestImageIterator dest_upperleft, DestAccessor da)
 Copy source ROI into destination image.

template<...> void cornerResponseFunction (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, double scale)
 Find corners in an image (1).

template<...> void foerstnerCornerDetector (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, double scale)
 Find corners in an image (2).

template<...> void rohrCornerDetector (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, double scale)
 Find corners in an image (3).

template<...> void beaudetCornerDetector (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, double scale)
 Find corners in an image (4).

Diff2D operator- (Diff2D const &a, Diff2D const &b)
Size2D operator- (Size2D const &s, Diff2D const &offset)
Point2D operator- (Point2D const &s, Diff2D const &offset)
Size2D operator- (Point2D const &s, Point2D const &p)
Diff2D operator+ (Diff2D const &a, Diff2D const &b)
Size2D operator+ (Size2D const &a, Diff2D const &b)
Point2D operator+ (Point2D const &a, Diff2D const &b)
Point2D operator+ (Size2D const &s, Point2D const &p)
template<...> void distanceTransform (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da, ValueType background, int norm)
template<...> void differenceOfExponentialEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, double scale, GradValue gradient_threshold, DestValue edge_marker)
 Detect and mark edges in an edge image using the Shen/Castan zero-crossing detector.

template<...> void differenceOfExponentialCrackEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, double scale, GradValue gradient_threshold, DestValue edge_marker)
 Detect and mark edges in a crack edge image using the Shen/Castan zero-crossing detector.

template<...> void removeShortEdges (Iterator sul, Iterator slr, Accessor sa, unsigned int min_edge_length, Value non_edge_marker)
 Remove short edges from an edge image.

template<...> void closeGapsInCrackEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, SrcValue edge_marker)
 Close one-pixel wide gaps in a cell grid edge image.

template<...> void beautifyCrackEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, SrcValue edge_marker, SrcValue background_marker)
 Beautify crack edge image for visualization.

template<...> void cannyEdgelList (SrcIterator ul, SrcIterator lr, SrcAccessor src, std::vector< Edgel > &edgels, double scale)
 Simple implementation of Canny's edge detector.

template<...> void cannyEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, double scale, GradValue gradient_threshold, DestValue edge_marker)
 Detect and mark edges in an edge image using Canny's algorithm.

bool operator== (FFTWComplex const &a, const FFTWComplex &b)
 equal

bool operator!= (FFTWComplex const &a, const FFTWComplex &b)
 not equal

FFTWComplexoperator+= (FFTWComplex &a, const FFTWComplex &b)
 add-assignment

FFTWComplexoperator-= (FFTWComplex &a, const FFTWComplex &b)
 subtract-assignment

FFTWComplexoperator *= (FFTWComplex &a, const FFTWComplex &b)
 multiply-assignment

FFTWComplexoperator/= (FFTWComplex &a, const FFTWComplex &b)
 divide-assignment

FFTWComplexoperator *= (FFTWComplex &a, const double &b)
 multiply-assignment with scalar double

FFTWComplexoperator/= (FFTWComplex &a, const double &b)
 divide-assignment with scalar double

FFTWComplex operator+ (FFTWComplex a, const FFTWComplex &b)
 addition

FFTWComplex operator- (FFTWComplex a, const FFTWComplex &b)
 subtraction

FFTWComplex operator * (FFTWComplex a, const FFTWComplex &b)
 multiplication

FFTWComplex operator * (FFTWComplex a, const double &b)
 right multiplication with scalar double

FFTWComplex operator * (const double &a, FFTWComplex b)
 left multiplication with scalar double

FFTWComplex operator/ (FFTWComplex a, const FFTWComplex &b)
 division

FFTWComplex operator/ (FFTWComplex a, const double &b)
 right division with scalar double

FFTWComplex::value_type abs (const FFTWComplex &a)
 absolute value (= magnitude)

FFTWComplex conj (const FFTWComplex &a)
 complex conjugate

template<...> void moveDCToCenter (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da)
 Rearrange the quadrants of a Fourier image so that the origin is in the image center.

template<...> void moveDCToUpperLeft (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da)
 Rearrange the quadrants of a Fourier image so that the origin is in the image's upper left.

template<...> void applyFourierFilter (triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, pair< FilterImageIterator, FilterAccessor > filter, pair< DestImageIterator, DestAccessor > dest)
 Apply a filter (defined in the frequency domain) to an image.

template<...> void applyFourierFilterFamily (triple< SrcImageIterator, SrcImageIterator, SrcAccessor > src, const ImageArray< FilterType > &filters, ImageArray< DestImage > &results)
 Apply an array of filters (defined in the frequency domain) to an image.

template<...> void fourierTransformRealEE (triple< SrcTraverser, SrcTraverser, SrcAccessor > src, pair< DestTraverser, DestAccessor > dest, fftw_real norm)
 Real Fourier transforms for even and odd boundary conditions (aka. cosine and sine transforms).

template<...> void discRankOrderFilter (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius, float rank)
 Apply rank order filter with disc structuring function to the image.

template<...> void discErosion (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius)
 Apply erosion (minimum) filter with disc of given radius to image.

template<...> void discDilation (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius)
 Apply dilation (maximum) filter with disc of given radius to image.

template<...> void discMedian (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius)
 Apply median filter with disc of given radius to image.

template<...> void discRankOrderFilterWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius, float rank)
 Apply rank order filter with disc structuring function to the image using a mask.

template<...> void discErosionWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius)
 Apply erosion (minimum) filter with disc of given radius to image using a mask.

template<...> void discDilationWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius)
 Apply dilation (maximum) filter with disc of given radius to image using a mask.

template<...> void discMedianWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius)
 Apply median filter with disc of given radius to image using a mask.

template<...> void createGaborFilter (DestImageIterator destUpperLeft, DestImageIterator destLowerRight, DestAccessor da, double orientation, double centerFrequency, double angularSigma, double radialSigma)
 Create a gabor filter in frequency space.

double radialGaborSigma (double centerFrequency)
 Calculate sensible radial sigma for given parameters.

double angularGaborSigma (int directionCount, double centerFrequency)
 Calculate sensible angular sigma for given parameters.

std::string impexListFormats ()
 List the image formats VIGRA can read and write.

std::string impexListExtensions ()
 List the file extension VIGRA understands.

bool isImage (char const *filename)
 Test whether a file is an image format known to VIGRA.

template<...> 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 read_band (Decoder *dec, ImageIterator ys, Accessor a, SrcValueType)
 used for reading bands after the source data type has been figured out.

template<...> void importVectorImage (const ImageImportInfo &info, ImageIterator iter, Accessor a)
 used for reading images of vector type, such as integer of float rgb.

template<...> void importScalarImage (const ImageImportInfo &info, ImageIterator iter, Accessor a)
 used for reading images of scalar type, such as integer and float grayscale.

template<...> void importImage (const ImageImportInfo &info, ImageIterator iter, Accessor a)
 Read an image, given an vigra::ImageImportInfo object.

template<...> 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 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<...> void exportFloatingVectorImage (SrcIterator sul, SrcIterator slr, SrcAccessor sget, const ImageExportInfo &info)
 Deprecated.

template<...> void exportIntegralVectorImage (SrcIterator sul, SrcIterator slr, SrcAccessor sget, const ImageExportInfo &info)
 Deprecated.

template<...> void exportFloatingScalarImage (SrcIterator sul, SrcIterator slr, SrcAccessor sget, const ImageExportInfo &info)
 Deprecated.

template<...> void exportIntegralScalarImage (SrcIterator sul, SrcIterator slr, SrcAccessor sget, const ImageExportInfo &info)
 Deprecated.

template<...> void exportImage (SrcIterator sul, SrcIterator slr, SrcAccessor sget, const ImageExportInfo &info)
 Write an image, given an vigra::ImageExportInfo object.

template<...> void initImage (ImageIterator upperleft, ImageIterator lowerright, Accessor a, VALUETYPE v)
 Write a value to every pixel in an image or rectangular ROI.

template<...> void initImageWithFunctor (ImageIterator upperleft, ImageIterator lowerright, Accessor a, FUNCTOR f)
 Write the result of a functor call to every pixel in an image or rectangular ROI.

template<...> void initImageIf (ImageIterator upperleft, ImageIterator lowerright, Accessor a, MaskImageIterator mask_upperleft, MaskAccessor ma, VALUETYPE v)
 Write value to pixel in the image if mask is true.

template<...> void initImageBorder (ImageIterator upperleft, ImageIterator lowerright, Accessor a, int border_width, VALUETYPE v)
 Write value to the specified border pixels in the image.

template<...> void inspectImage (ImageIterator upperleft, ImageIterator lowerright, Accessor a, Functor &f)
 Apply read-only functor to every pixel in the image.

template<...> void inspectImageIf (ImageIterator upperleft, ImageIterator lowerright, Accessor a, MaskImageIterator mask_upperleft, MaskAccessor ma, Functor &f)
 Apply read-only functor to every pixel in the ROI.

template<...> void inspectTwoImages (ImageIterator1 upperleft1, ImageIterator1 lowerright1, Accessor1 a1, ImageIterator2 upperleft2, Accessor2 a2, Functor &f)
 Apply read-only functor to every pixel of both images.

template<...> void inspectTwoImagesIf (ImageIterator1 upperleft1, ImageIterator1 lowerright1, Accessor1 a1, ImageIterator2 upperleft2, Accessor2 a2, MaskImageIterator mupperleft, MaskAccessor mask, Functor &f)
 Apply read-only functor to those pixels of both images where the mask image is non-zero.

template<...> unsigned int labelImage (SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa, DestIterator upperleftd, DestAccessor da, bool eight_neighbors, EqualityFunctor equal)
 Find the connected components of a segmented image.

template<...> unsigned int labelImageWithBackground (SrcIterator upperlefts, SrcIterator lowerrights, SrcAccessor sa, DestIterator upperleftd, DestAccessor da, bool eight_neighbors, ValueType background_value, EqualityFunctor equal)
 Find the connected components of a segmented image, excluding the background from labeling.

template<...> void regionImageToCrackEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, DestValue edge_marker)
 Transform a labeled image into a crack edge image.

template<...> void regionImageToEdgeImage (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, DestValue edge_marker)
 Transform a labeled image into an edge image.

template<...> void localMinima (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, DestValue marker)
 Find local minima in an image.

template<...> void localMaxima (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, DestValue marker)
 Find local maxima in an image.

template<...> void extendedLocalMinima (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, DestValue marker)
 Find local minimal regions in an image.

template<...> void extendedLocalMaxima (SrcIterator sul, SrcIterator slr, SrcAccessor sa, DestIterator dul, DestAccessor da, DestValue marker)
 Find local maximal regions in an image.

template<...> double erf (T x)
template<...> NumericTraits< T >::Promote sq (T t)
template<...> T sign (T t)
template<...> T1 sign (T1 t1, T2 t2)
template<...> BasicImageView< T > makeBasicImageView (MultiArrayView< 2, T, UnstridedArrayTag > const &array)
template<...> BasicImageView< T > makeBasicImageView (MultiArray< 3, T > const &array)
template<...> BasicImageView< RGBValue<
T > > 
makeRGBImageView (MultiArray< 3, T > const &array)
template<...> void separableConvolveMultiArray (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest, KernelIterator kernels)
 Separated convolution on multi-dimensional arrays.

template<...> void convolveMultiArrayOneDimension (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest, unsigned int dim, vigra::Kernel1D< T > const &kernel)
 Convolution along a single dimension of a multi-dimensional arrays.

template<...> void gaussianSmoothMultiArray (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest, double sigma)
 Isotropic Gaussian smoothing of a multi-dimensional arrays.

template<...> void gaussianGradientMultiArray (SrcIterator si, SrcShape const &shape, SrcAccessor src, DestIterator di, DestAccessor dest, double sigma)
 Calculate Gaussian gradient of a multi-dimensional arrays.

template<...> void symmetricGradientMultiArray (SrcIterator si, SrcShape const &shape, SrcAccessor src, DestIterator di, DestAccessor dest)
 Calculate gradient of a multi-dimensional arrays using symmetric difference filters.

template<...> 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 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 initMultiArray (Iterator s, Shape const &shape, Accessor a, VALUETYPE v)
 Write a value to every pixel in a multi-dimensional array.

template<...> void copyMultiArray (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest)
 Copy a multi-dimensional array.

template<...> void transformMultiArray (SrcIterator s, SrcShape const &shape, SrcAccessor src, DestIterator d, DestAccessor dest, Functor const &f)
 Transform a multi-dimensional array with a unary function or functor.

template<...> void combineTwoMultiArrays (SrcIterator1 s1, SrcShape const &shape, SrcAccessor1 src1, SrcIterator2 s2, SrcAccessor2 src2, DestIterator d, DestAccessor dest, Functor const &f)
 Combine two multi-dimensional arrays into one using a binary function or functor.

template<...> void combineThreeMultiArrays (SrcIterator1 s1, SrcShape const &shape, SrcAccessor1 src1, SrcIterator2 s2, SrcAccessor2 src2, SrcIterator3 s3, SrcAccessor3 src3, DestIterator d, DestAccessor dest, Functor const &f)
 Combine three multi-dimensional arrays into one using a ternary function or functor.

template<...> void inspectMultiArray (Iterator s, Shape const &shape, Accessor a, Functor &f)
 Call an analyzing functor at every element of a multi-dimensional array.

template<...> void inspectTwoMultiArrays (Iterator1 s1, Shape const &shape, Accessor1 a1, Iterator2 s2, Accessor2 a2, Functor &f)
 Call an analyzing functor at all corresponding elements of two multi-dimensional arrays.

template<...> void nonlinearDiffusion (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, DiffusivityFunc const &weight, double scale)
 Perform edge-preserving smoothing at the given scale.

template<...> void hourGlassFilter (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, double sigma, double rho)
 Anisotropic tensor smoothing with the hourglass filter.

template<...> bool polynomialRoots (POLYNOMIAL const &poriginal, VECTOR &roots, bool polishRoots)
template<...> bool polynomialRealRoots (POLYNOMIAL const &p, VECTOR &roots, bool polishRoots)
template<...> IntType gcd (IntType n, IntType m)
template<...> IntType lcm (IntType n, IntType m)
template<...> Rational< IntType > abs (const Rational< IntType > &r)
 absolute value

template<...> Rational< IntType > pow (const Rational< IntType > &r, int n)
template<...> Rational< IntType > floor (const Rational< IntType > &r)
 largest integer not larger than r

template<...> Rational< IntType > ceil (const Rational< IntType > &r)
 smallest integer not smaller than r

template<...> Rational< IntType > operator+ (const Rational< IntType > &r)
 unary plus

template<...> Rational< IntType > operator- (const Rational< IntType > &r)
 unary minus (negation)

template<...> Rational< IntType > operator+ (Rational< IntType > l, Rational< IntType > const &r)
 addition

template<...> Rational< IntType > operator- (Rational< IntType > l, Rational< IntType > const &r)
 subtraction

template<...> Rational< IntType > operator * (Rational< IntType > l, Rational< IntType > const &r)
 multiplication

template<...> Rational< IntType > operator/ (Rational< IntType > l, Rational< IntType > const &r)
 division

template<...> Rational< IntType > operator+ (Rational< IntType > l, typename Rational< IntType >::param_type r)
 addition of right-hand IntType argument

template<...> Rational< IntType > operator- (Rational< IntType > l, typename Rational< IntType >::param_type r)
 subtraction of right-hand IntType argument

template<...> Rational< IntType > operator * (Rational< IntType > l, typename Rational< IntType >::param_type r)
 multiplication with right-hand IntType argument

template<...> Rational< IntType > operator/ (Rational< IntType > l, typename Rational< IntType >::param_type r)
 division by right-hand IntType argument

template<...> Rational< IntType > operator+ (typename Rational< IntType >::param_type l, Rational< IntType > r)
 addition of left-hand IntType argument

template<...> Rational< IntType > operator- (typename Rational< IntType >::param_type l, Rational< IntType > const &r)
 subtraction from left-hand IntType argument

template<...> Rational< IntType > operator * (typename Rational< IntType >::param_type l, Rational< IntType > r)
 multiplication with left-hand IntType argument

template<...> Rational< IntType > operator/ (typename Rational< IntType >::param_type l, Rational< IntType > const &r)
 division of left-hand IntType argument

template<...> bool operator== (const Rational< IntType1 > &l, const Rational< IntType2 > &r)
 equality

template<...> bool operator== (const Rational< IntType1 > &l, IntType2 const &i)
 equality with right-hand IntType2 argument

template<...> bool operator== (IntType1 const &l, Rational< IntType2 > const &r)
 equality with left-hand IntType1 argument

template<...> bool operator!= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 inequality

template<...> bool operator!= (const Rational< IntType1 > &l, IntType2 const &i)
 inequality with right-hand IntType2 argument

template<...> bool operator!= (IntType1 const &l, Rational< IntType2 > const &r)
 inequality with left-hand IntType1 argument

template<...> bool operator< (const Rational< IntType1 > &l, const Rational< IntType2 > &r)
 less-than

template<...> bool operator< (const Rational< IntType1 > &l, IntType2 const &i)
 less-than with right-hand IntType2 argument

template<...> bool operator< (IntType1 const &l, Rational< IntType2 > const &r)
 less-than with left-hand IntType1 argument

template<...> bool operator> (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 greater-than

template<...> bool operator> (const Rational< IntType1 > &l, IntType2 const &i)
 greater-than with right-hand IntType2 argument

template<...> bool operator> (IntType1 const &l, Rational< IntType2 > const &r)
 greater-than with left-hand IntType1 argument

template<...> bool operator<= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 less-equal

template<...> bool operator<= (Rational< IntType1 > const &l, IntType2 const &r)
 less-equal with right-hand IntType2 argument

template<...> bool operator<= (IntType1 const &l, Rational< IntType2 > const &r)
 less-equal with left-hand IntType1 argument

template<...> bool operator>= (Rational< IntType1 > const &l, Rational< IntType2 > const &r)
 greater-equal

template<...> bool operator>= (Rational< IntType1 > const &l, IntType2 const &r)
 greater-equal with right-hand IntType2 argument

template<...> bool operator>= (IntType1 const &l, Rational< IntType2 > const &r)
 greater-equal with left-hand IntType1 argument

template<...> T rational_cast (const Rational< IntType > &src)
template<...> void recursiveFilterLine (SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double b, BorderTreatmentMode border)
 Performs a 1-dimensional recursive convolution of the source signal.

template<...> void recursiveSmoothLine (SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double scale)
 Convolves the image with a 1-dimensional exponential filter.

template<...> void recursiveFirstDerivativeLine (SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double scale)
 Performs a 1 dimensional recursive convolution of the source signal.

template<...> void recursiveSecondDerivativeLine (SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double scale)
 Performs a 1 dimensional recursive convolution of the source signal.

template<...> void recursiveFilterX (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double b, BorderTreatmentMode border)
 Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction.

template<...> void recursiveSmoothX (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale)
 Performs 1 dimensional recursive smoothing in x direction.

template<...> void recursiveFilterY (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double b, BorderTreatmentMode border)
 Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction.

template<...> void recursiveSmoothY (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale)
 Performs 1 dimensional recursive smoothing in y direction.

template<...> void recursiveFirstDerivativeX (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale)
 Recursively calculates the 1 dimensional first derivative in x direction.

template<...> void recursiveFirstDerivativeY (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale)
 Recursively calculates the 1 dimensional first derivative in y direction.

template<...> void recursiveSecondDerivativeX (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale)
 Recursively calculates the 1 dimensional second derivative in x direction.

template<...> void recursiveSecondDerivativeY (SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale)
 Recursively calculates the 1 dimensional second derivative in y direction.

template<...> void resamplingConvolveX (SrcIter sul, SrcIter slr, SrcAcc src, DestIter dul, DestIter dlr, DestAcc dest, Kernel const &kernel, Rational< int > const &samplingRatio, Rational< int > const &offset)
 Apply a resampling filter in the x-direction.

template<...> void resamplingConvolveY (SrcIter sul, SrcIter slr, SrcAcc src, DestIter dul, DestIter dlr, DestAcc dest, Kernel const &kernel, Rational< int > const &samplingRatio, Rational< int > const &offset)
 Apply a resampling filter in the y-direction.

template<...> void resamplingConvolveImage (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestIterator dlr, DestAccessor dest, KernelX const &kx, Rational< int > const &samplingRatioX, Rational< int > const &offsetX, KernelY const &ky, Rational< int > const &samplingRatioY, Rational< int > const &offsetY)
 Apply two separable resampling filters successively, the first in x-direction, the second in y-direction.

template<...> void resizeImageNoInterpolation (SrcIterator is, SrcIterator iend, SrcAccessor sa, DestIterator id, DestIterator idend, DestAccessor da)
 Resize image by repeating the nearest pixel values.

template<...> void resizeImageLinearInterpolation (SrcIterator is, SrcIterator iend, SrcAccessor sa, DestIterator id, DestIterator idend, DestAccessor da)
 Resize image using linear interpolation.

template<...> void resizeImageSplineInterpolation (SrcIterator src_iter, SrcIterator src_iter_end, SrcAccessor src_acc, DestIterator dest_iter, DestIterator dest_iter_end, DestAccessor dest_acc, SPLINE const &spline)
 Resize image using B-spline interpolation.

template<...> void resizeImageCatmullRomInterpolation (SrcIterator src_iter, SrcIterator src_iter_end, SrcAccessor src_acc, DestIterator dest_iter, DestIterator dest_iter_end, DestAccessor dest_acc)
 Resize image using the Catmull/Rom interpolation function.

template<...> void resizeImageCoscotInterpolation (SrcIterator src_iter, SrcIterator src_iter_end, SrcAccessor src_acc, DestIterator dest_iter, DestIterator dest_iter_end, DestAccessor dest_acc)
 Resize image using the Coscot interpolation function.

template<...> bool operator== (RGBValue< V1 > const &l, RGBValue< V2 > const &r)
 component-wise equal

template<...> bool operator!= (RGBValue< V1 > const &l, RGBValue< V2 > const &r)
 component-wise not equal

template<...> RGBValue< V1 > & operator+= (RGBValue< V1 > &l, RGBValue< V2 > const &r)
 componentwise add-assignment

template<...> RGBValue< V1 > & operator-= (RGBValue< V1 > &l, RGBValue< V2 > const &r)
 componentwise subtract-assignment

template<...> RGBValue< V1 > & operator *= (RGBValue< V1 > &l, RGBValue< V2 > const &r)
 componentwise multiply-assignment

template<...> RGBValue< V > & operator *= (RGBValue< V > &l, double r)
 componentwise scalar multiply-assignment

template<...> RGBValue< V > & operator/= (RGBValue< V > &l, double r)
 componentwise scalar divide-assignment

template<...> RGBValue< T > abs (RGBValue< T > const &v)
 component-wise absolute value

template<...> PromoteTraits< RGBValue< V1 >,
RGBValue< V2 > >::Promote 
operator+ (RGBValue< V1 > const &r1, RGBValue< V2 > const &r2)
 component-wise addition

template<...> PromoteTraits< RGBValue< V1 >,
RGBValue< V2 > >::Promote 
operator- (RGBValue< V1 > const &r1, RGBValue< V2 > const &r2)
 component-wise subtraction

template<...> PromoteTraits< RGBValue< V1 >,
RGBValue< V2 > >::Promote 
operator * (RGBValue< V1 > const &r1, RGBValue< V2 > const &r2)
 component-wise multiplication

template<...> NumericTraits< RGBValue< V
> >::RealPromote 
operator * (double v, RGBValue< V > const &r)
 component-wise left scalar multiplication

template<...> NumericTraits< RGBValue< V
> >::RealPromote 
operator * (RGBValue< V > const &r, double v)
 component-wise right scalar multiplication

template<...> NumericTraits< RGBValue< V
> >::RealPromote 
operator/ (RGBValue< V > const &r, double v)
 component-wise scalar division

template<...> PromoteTraits< RGBValue< V1 >,
RGBValue< V2 > >::Promote 
cross (RGBValue< V1 > const &r1, RGBValue< V2 > const &r2)
 cross product

template<...> PromoteTraits< V1, V2 >::Promote dot (RGBValue< V1 > const &r1, RGBValue< V2 > const &r2)
 dot product

template<...> RGBValue< V > ceil (RGBValue< V > const &r)
template<...> RGBValue< V > floor (RGBValue< V > const &r)
template<...> void seededRegionGrowing (SrcImageIterator srcul, SrcImageIterator srclr, SrcAccessor as, SeedImageIterator seedsul, SeedAccessor aseeds, DestImageIterator destul, DestAccessor ad, RegionStatisticsArray &stats, const SRGType srgType)
 Region Segmentation by means of Seeded Region Growing.

template<...> void convolveLine (SrcIterator is, SrcIterator iend, SrcAccessor sa, DestIterator id, DestAccessor da, KernelIterator ik, KernelAccessor ka, int kleft, int kright, BorderTreatmentMode border)
 Performs a 1 dimensional convolution of the source signal using the given kernel.

template<...> void separableConvolveX (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIterator dupperleft, DestAccessor da, KernelIterator ik, KernelAccessor ka, int kleft, int kright, BorderTreatmentMode border)
 Performs a 1 dimensional convolution in x direction.

template<...> void separableConvolveY (SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIterator dupperleft, DestAccessor da, KernelIterator ik, KernelAccessor ka, int kleft, int kright, BorderTreatmentMode border)
 Performs a 1 dimensional convolution in y direction.

template<...> 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<...> void normalizedConvolveImage (SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc, MaskIterator mul, MaskAccessor am, DestIterator dest_ul, DestAccessor dest_acc, KernelIterator ki, KernelAccessor ak, Diff2D kul, Diff2D klr, BorderTreatmentMode border)
 Performs a 2-dimensional normalized convolution, i.e. convolution with a mask image.

template<...> void convolveImageWithMask (SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc, MaskIterator mul, MaskAccessor am, DestIterator dest_ul, DestAccessor dest_acc, KernelIterator ki, KernelAccessor ak, Diff2D kul, Diff2D klr, BorderTreatmentMode border)
 Deprecated name of 2-dimensional normalized convolution, i.e. convolution with a mask image.

template<...> void radialSymmetryTransform (SrcIterator sul, SrcIterator slr, SrcAccessor as, DestIterator dul, DestAccessor ad, double scale)
 Find centers of radial symmetry in an image.

template<...> void vectorToTensor (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, bool negateComponent2)
 Calculate the tensor (outer) product of a 2D vector with itself.

template<...> void tensorEigenRepresentation (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest)
 Calculate eigen representation of a symmetric 2x2 tensor.

template<...> void tensorTrace (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest)
 Calculate the trace of a 2x2 tensor.

template<...> void tensorToEdgeCorner (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator1 edgeul, DestAccessor1 edge, DestIterator2 cornerul, DestAccessor2 corner)
 Decompose a symmetric 2x2 tensor into its edge and corner parts.

template<...> void importTiffImage (TiffImage *tiff, ImageIterator iter, Accessor a)
 Convert given TiffImage into image specified by iterator range.

template<...> void tiffToScalarImage (TiffImage *tiff, ImageIterator iter, Accessor a)
 Convert single-band TiffImage to scalar image.

template<...> void tiffToRGBImage (TiffImage *tiff, RGBImageIterator iter, RGBAccessor a)
 Convert RGB (3-band or color-mapped) TiffImage to RGB image.

template<...> void createTiffImage (ImageIterator upperleft, ImageIterator lowerright, Accessor a, TiffImage *tiff)
 Create a TiffImage from the given iterator range.

template<...> void createScalarTiffImage (ImageIterator upperleft, ImageIterator lowerright, Accessor a, TiffImage *tiff)
 Create a single-band TiffImage from the given scalar image.

template<...> void createRGBTiffImage (RGBImageIterator upperleft, RGBImageIterator lowerright, RGBAccessor a, TiffImage *tiff)
 Create a 3-band TiffImage from the given RGB image.

template<...> bool operator== (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise equal

template<...> bool operator!= (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 component-wise not equal

template<...> 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<...> 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<...> 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<...> NumericTraits< TinyVector<
V, SIZE > >::RealPromote 
operator * (double v, TinyVectorBase< V, SIZE, D1, D2 > const &r)
 component-wise left scalar multiplication

template<...> NumericTraits< TinyVector<
V, SIZE > >::RealPromote 
operator * (TinyVectorBase< V, SIZE, D1, D2 > const &l, double v)
 component-wise right scalar multiplication

template<...> NumericTraits< TinyVector<
V, SIZE > >::RealPromote 
operator/ (TinyVectorBase< V, SIZE, D1, D2 > const &l, double v)
 component-wise scalar division

template<...> TinyVector< V, SIZE > operator- (TinyVectorBase< V, SIZE, D1, D2 > const &v)
template<...> TinyVector< V, SIZE > abs (TinyVectorBase< V, SIZE, D1, D2 > const &v)
 component-wise absolute value

template<...> TinyVector< V, SIZE > ceil (TinyVectorBase< V, SIZE, D1, D2 > const &v)
template<...> TinyVector< V, SIZE > floor (TinyVectorBase< V, SIZE, D1, D2 > const &v)
template<...> PromoteTraits< V1, V2 >::Promote dot (TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
 dot product

template<...> void transformImage (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, DestImageIterator dest_upperleft, DestAccessor da, Functor const &f)
 Apply unary point transformation to each pixel.

template<...> void transformImageIf (SrcImageIterator src_upperleft, SrcImageIterator src_lowerright, SrcAccessor sa, MaskImageIterator mask_upperleft, MaskAccessor ma, DestImageIterator dest_upperleft, DestAccessor da, Functor const &f)
 Apply unary point transformation to each pixel within the ROI (i.e., where the mask is non-zero).

template<...> void gradientBasedTransform (SrcImageIterator srcul, SrcImageIterator srclr, SrcAccessor sa, DestImageIterator destul, DestAccessor da, Functor const &grad)
 Calculate a function of the image gradient.

template<...> LinearIntensityTransform<
DestValueType, Multiplier > 
linearIntensityTransform (Multiplier scale, DestValueType offset)
 Apply a linear transform to the source pixel values.

template<...> 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.



Detailed Description


all VIGRA functionality is located in namespace vigra

© Ullrich Köthe (koethe@informatik.uni-hamburg.de)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.3.2 (27 Jan 2005)