cvr Namespace Reference

Namespace in which all classes, functions and constants of the CVR-Lib are defined. More...

Namespaces

namespace internal

Classes

class allocException

allocException is thrown if a memory allocation problem occurs More...

class className

Provides methods for getting the class names of cvr::objects. More...

class constReferenceException

constReferenceException class More...

class exception

Base class for all CVR-Libexceptions. More...

class factory

Factory of objects of base type T. More...

class factoryReferences

Factory references. More...

class functor

Base class for all lti functors. More...

class invalidParametersException

Exception thrown when the parameters are not set. More...

class object

Base class for most objects in the CVR-Lib. More...

class parametersManager

Base class for all classes with parameters. More...

class progressInfo

This class can be overloaded to display the training progress of a process. More...

class progressReporter

Interface for all objects that provide progressInfo interface. More...

class status

Base class for all CVR-Lib objects that have a status for error handling. More...

class streamProgressInfo

This class is a default implementation for the progress info interface. More...

class bresenhamCircle

Functor for rendering circle segments with the Bresenham circle drawing algorithm. More...

class bresenhamLine

Functor for rendering line segments with the Bresenham line drawing algorithm. More...

class draw

Object for drawing a number of geometric figures and lists thereof, simple texts and a few other types with graphic representation in a cvr::matrix. More...

class drawBase

Abstract parent class for draw and epsDraw. More...

class viewer2DPainter

Class viewer2DPainter. More...

class affineLocation

The affineLocation class is simply used to store the parameters associated with an affine location. More...

class areaPoints

List of all points within an area. More...

class bilinearInterpolation

This functor use bilinear interpolation to approximate values between the pixels or elements of vectors and matrices. More...

class borderPoints

Direct border point representation of a contour. More...

class boundaryExpansion

Class boundaryExpansion. More...

class chainCode

Elements of a Chaincode. More...

class channel

A format for float channels. More...

class channel32

A format for 32-bit channels. More...

class channel8

A format for 8-bit channels. More...

class channelC

Complex channel. More...

class channelProcessingInterface

Class channelProcessingInterface. More...

class colorQuantization

Abstract parent class for all color quantization algorithms. More...

class contrastEnhancement

Class contrastEnhancement. More...

class convexHull

Computes the convex hull of a set of points. More...

class fastHessianDetection

Class fastHessianDetection. More...

class filledUpsampling

Filled upsampling (or upsampling with zero-order interpolation). More...

class genericChannel

Class genericChannel. More...

class genericInterpolation

This functor uses a generic interpolation concept based on look-up-tables for the interpolation kernels. More...

class geometricTransformBase

Class geometricTransformBase. More...

class geometricTransform

Class geometricTransform. More...

class histogramEqualization

Histogram equalization. More...

class hueLUT

Following class provides a mono-state object that contains a 0.5MB Look-up Table to accelerate the computation of hues. More...

class image

The one and only RGBA-image format. More...

class integralImage

Class integralImage. More...

class ioPoints

Input-Output discrete contour representation. More...

class kernel1D

One-dimensional filter kernel. More...

class kernel2D

Two-dimensional filter kernel. More...

class kMColorQuantization

k-Means based color quantization. More...

class labelAdjacencyMap

Visualize a label mask in a color image. More...

class location

The location class specifies an interest point and a small surrounding region in an image or channel. More...

class locationDetection

Abstract class locationDetection. More...

class locationMatch

Class locationMatch. More...

class matrixProcessingInterface

Class matrixProcessingInterface. More...

class matrixTransform

Class matrixTransform. More...

class mergeHSIToImage

Merge HSI (Hue Saturation Intensity) channels. More...

class mergeImage

Abstract base class for all merge image functor-classes. More...

class mergeRGBToImage

Merge RGB channels. More...

class mergeYCbCrToImage

Creates RGB values from given YCbCr values by merging float or ubyte values to an rgbPixel, merging channels(floats) or channel8s(ubytes) to an Image. More...

class mergeYIQToImage

Merge YIQ channels (Luminance, Inphase, Quadrature). More...

class mergeYPbPrToImage

Creates RGB values from given YPbPr values by merging float or ubyte values to an rgbaPixel, merging channels(floats) or channel8s(ubytes) to an Image. More...

class mergeYUVToImage

Compute RGB values from given YUV values by merging float or ubyte values to an rgbaPixel, merging channels(floats) or matrix<ubyte>s(ubytes) to an Image. More...

class nearestNeighborInterpolation

This functor use nearestNeighbor interpolation to approximate values between the pixels or elements of vectors and matrices. More...

class polygonPoints

Contour classes: polygonPoints. More...

class rectLocation

The rectLocation class specifies a small region in an image or channel around an interest point. More...

class separableKernel

Separable Kernel. More...

class splitImage

Abstract parent class for all classes that split an image into different color spaces components (color channels). More...

class splitImageToHSI

Split image into its Hue - Saturation - Intensity channels. More...

class splitImageToRGB

Split image into its Red - Green - Blue channels. More...

class splitImageTorgI

Split image in its chromaticity channels. More...

class splitImageToYCbCr

Computes the YCbCr values from a given RGB color representation (rgbaPixel). More...

class splitImageToYIQ

Split image in its Luminance Inphase Quadrature channels. More...

class splitImageToYPbPr

Computes the YPbPr values from a given RGB color representation (rgbaPixel). More...

class splitImageToYUV

Computes the YUV values from a given RGB color representation (rgbaPixel). More...

class surfLocalDescriptor

Class surfLocalDescriptor. More...

class usePalette

Use color or gray-valued palette. More...

class endianness

Endianness. More...

class ioBMP

Class to load and save images and channels in the BMP format. More...

class ioImage

Class to read/write image files. More...

class ioImageInterface

Base class to all classes that read from or write to a image file. More...

class ioJPEG

Class to read and write images store in the Joint Picture Expert Group file format (JPEG). More...

class ioPNG

Class to read and write files with images and channels in PNG format. More...

class loadImageList

This class allows convenient loading of a set of images. More...

class ioHandler

Input/output handlers. More...

class ioObject

Basic input/output class for data objects. More...

class lispStreamHandler

The lispStreamHandler class offers an interface for the functor parameters and other classes to read() and write() them in a LISP-like format. More...

class statusMonitor

Class statusMonitor. More...

class statusMonitorCerr

Class statusMonitorCerr. More...

class statusMonitorException

Class statusMonitorException. More...

class affineTransformation2D

Class affineTransformation2D. More...

class arctanLUT

Following class provides a mono-state object that contains a 1MB Look-up Table to accelerate the computation of the arc-tangens. More...

class complex

Class to represent and manipulate complex numbers. More...

class constants

This class is a container of some mathematical and physical constants as static member functions. More...

class decompositionSolution

Abstract base class for all lti linear equation system solution functors using matrix decomposition to solve Ax=b. More...

class distanceFunctor

This class is the base class for all functors which compute distances between two vectors or matrices. More...

class euclideanDistanceFunctor

This class is the base class for all functors which compute distances between two vectors or matrices. More...

class euclideanSqrDistantor

Policy class used by several classifiers/trees to measure the square of the euclidean distance between two points of type T. More...

class euclideanDistantor

Policy class used by several classifiers/trees to measure the euclidean distance between two points of type T. More...

class euclideanTransformation2D

Class euclideanTransformation2D. More...

class fixedGridInterpolation

This abstract class parents all interpolation functors, whose samples have equal distances to each other (per dimension), i.e. More...

class kdTree

A class for k-d tree. More...

class lattice1D

Mathematical lattice1D container class. More...

class lattice2D

Container class for two dimensional lattices with arithmetical operations. More...

class linearAlgebraFunctor

Base class for all lti linear algebra functors. More...

class linearLeastSquares

Class linearLeastSquares. More...

class luDecomposition

LU decomposition functor. More...

class luSolution

LU solution functor. More...

class matrix

Mathematical matrix container class. More...

class minimizeBasis

Functor for the minimization of a basis. More...

class noise

Class noise. More...

class normalDistribution

Class normalDistribution. More...

class pca

Principal Components Analysis (PCA). More...

class qrDecomposition

This functor computes a QRDecomposition of a given rectangular m x n Matrix A of the Form:. More...

class qrSolution

QR solution functor. More...

class quickMedian

Quick median search. More...

class quickMedian2

Quick median for two vectors. More...

class quickPartialSort

Quick partial sort. More...

class randomDistribution

Class randomDistribution. More...

class ransacEstimation

Template Class ransacEstimation<E>. More...

class secondOrderStatistics

Computes mean, variance, and/or covariance matrix of data matrices and vectors. More...

class similarityTransformation2D

Class similarityTransformation2D. More...

class sort

Sort vectors. More...

class sort2

Sort two vectors, using the first one as key. More...

class svd

Singular Value Decomposition (SVD). More...

class symmetricEigenSystem

Computes the Eigenvectors and Eigenvalues of a symmetric, positive definite, real matrix. More...

class uniformContinuousDistribution

Class uniformContinuousDistribution. More...

class uniformDiscreteDistribution

Class uniformDiscreteDistribution. More...

class univariateContinuousDistribution

Class univariateContinuousDistribution. More...

class univariateDiscreteDistribution

Class univariateDiscreteDistribution. More...

class validator

Matrix and Vector validity check. More...

class vector

Mathematical vector container class. More...

class mutex

Mutex class for the library. More...

class semaphore

Class for inter-thread synchronisation concept of semaphores. More...

class thread

CVR-Lib thread class. More...

class timer

The timer allows to measure time with a precision of about 30us on Linux systems and a value dependent on the performance counter on Windows systems. More...

class container

Abstract base class to all container classes. More...

class distanceType

This class defines the appropriate return types when calculating the distance between two values of type T. More...

class genericLattice1D

Generic Lattice 1D container. More...

class genericLattice2D

Container class for two dimensional lattices. More...

class genericMatrix

Container class for generic matrices. More...

class genericVector

Vector container class. More...

class interval

A one dimensional interval, giving the from and to values. More...

class line

Type for computations with lines. More...

class list

A linked list, implemented either as a cvr::smallObjectList for objects whose size is less than or equal to _CVR_PERFORMANCE_LIST_OBJECT_SIZE_THRESHOLD, or as a std::list for bigger objects. More...

class point

Two dimensional point, containing the coordinates x, y. More...

class point3D

Three dimensional point, containing the coordinates x, y, z. More...

class pointList

Template class to store a list of points. More...

class rectangleSide

Policy class to compute the size of a rectangle's side and the inverse transformation. More...

class rectangle

Rectangle representation class. More...

class rgbaPixel

Color pixel representation in RGB color space with an alpha channel. More...

class rgbPixel

Color pixel representation in RGB color space. More...

class smallObjectList

List of objects of small size. More...

class typeInfo

This class allows to ask some information required in the CVR-Libfor some types. More...

class typeInfo< U< T > >

This tricky specialization lets the typeInfo of any template class with a single template parameter make use of the typeInfo of its template parameter. More...

class externViewer2D

External viewer for 2D images. More...

class guiServer

Class guiServer. More...

class viewer2D

Class viewer2D. More...

class gtkCurveSelection

Dialog for curve selection. More...

class viewerBase

Class viewerBase. More...

class lapackInterface

Interface object for LAPACK functions. More...

Typedefs

typedef vector< rgbaPixel > palette

typedef kernel1D< int32 > ikernel1D

typedef kernel1D< float > fkernel1D

typedef kernel1D< double > dkernel1D

typedef kernel1D< ubyte > bkernel1D

typedef kernel2D< int32 > ikernel2D

typedef kernel2D< float > fkernel2D

typedef kernel2D< double > dkernel2D

typedef kernel2D< ubyte > bkernel2D

typedef polygonPoints< int > ipolygonPoints

typedef separableKernel< int > iseparableKernel

typedef separableKernel< float > fseparableKernel

typedef separableKernel< double > dseparableKernel

typedef separableKernel< ubyte > bseparableKernel

typedef lattice1D< double > dlattice1D

typedef lattice1D< float > flattice1D

typedef lattice1D< int32 > ilattice1D

typedef lattice2D< double > dlattice2D

typedef lattice2D< float > flattice2D

typedef lattice2D< int32 > ilattice2D

typedef _CVR_F2C_INTEGER integer

typedef matrix< double > dmatrix

typedef matrix< float > fmatrix

typedef matrix< int32 > imatrix

typedef vector< double > dvector

typedef vector< float > fvector

typedef vector< int32 > ivector

typedef interval< int > iinterval

typedef interval< unsigned int > uiinterval

typedef interval< double > dinterval

typedef interval< float > finterval

typedef line< int > iline

typedef line< double > dline

typedef line< float > fline

typedef point< int > ipoint

typedef point< unsigned int > uipoint

typedef point< double > dpoint

typedef point< float > fpoint

typedef point3D< int > ipoint3D

typedef point3D< float > fpoint3D

typedef point3D< double > dpoint3D

typedef pointList< int > ipointList

typedef rectangle< int > irectangle

typedef rectangle< float > frectangle

typedef rectangle< double > drectangle

typedef rgbPixel< int > irgbPixel

typedef rgbPixel< float > frgbPixel

typedef rgbPixel< double > drgbPixel

typedef unsigned _CVR_BYTE ubyte

typedef signed _CVR_BYTE byte

typedef unsigned _CVR_WORD16 uint16

typedef signed _CVR_WORD16 int16

typedef unsigned _CVR_WORD32 uint32

typedef signed _CVR_WORD32 int32

typedef float sreal

typedef double dreal

Enumerations

enum eInterpolationType { NearestNeighborInterpolation, BilinearInterpolation, BiquadraticInterpolation, BicubicInterpolation }

enum eEndiannessType { LittleEndian, BigEndian }

enum eDataRepresentationType { Rows, Columns }

enum eMedianEvenCase { TakeLower, TakeHigher }

enum eSortingOrder { Ascending, Descending }

enum eBoundaryType {
Zero, Mirror, Periodic, Constant,
NoBoundary
}

enum eConstantReference { VariableReference, ConstantReference }

enum eResizeType { AllocateOnly, Copy, Init, CopyAndInit }

Functions

bool isNull (const void *p)

bool notNull (const void *p)

void setStatusMonitor (statusMonitor &monitor)

bool read (ioHandler &handler, affineLocation &loc, const bool complete=true)

bool write (ioHandler &handler, const affineLocation &loc, const bool complete=true)

bool read (ioHandler &handler, chainCode &cc, const bool complete=true)

bool write (ioHandler &handler, const chainCode &cc, const bool complete=true)

bool read (ioHandler &handler, fastHessianDetection::eExtremaType &data)

bool write (ioHandler &handler, const fastHessianDetection::eExtremaType &data)

bool read (ioHandler &handler, fastHessianDetection::eLevelSelectionMethod &data)

bool write (ioHandler &handler, const fastHessianDetection::eLevelSelectionMethod &data)

bool read (ioHandler &handler, fastHessianDetection::eLocationSelectionMode &data)

bool write (ioHandler &handler, const fastHessianDetection::eLocationSelectionMode &data)

bool read (ioHandler &handler, geometricTransformBase::eResizeMode &data)

bool write (ioHandler &handler, const geometricTransformBase::eResizeMode &data)

bool read (ioHandler &handler, eInterpolationType &data)

bool write (ioHandler &handler, const eInterpolationType &data)

bool read (ioHandler &handler, location &mat, const bool complete=true)

bool write (ioHandler &handler, const location &mat, const bool complete=true)

bool read (ioHandler &handler, locationMatch::eMatchType &data)

bool write (ioHandler &handler, const locationMatch::eMatchType &data)

template<typename T >

matrix< T > rotation (const point3D< T > &center, const point3D< T > &axis, const T &angle)

template<typename T >

matrix< T > rotation (const point< T > &center, const T &angle)

template<typename T >

matrix< T > translation (const point3D< T > &s)

template<typename T >

matrix< T > translation (const point< T > &s)

template<typename T >

matrix< T > scaling (const point3D< T > &s)

template<typename T >

matrix< T > scaling (const point< T > &s)

template<typename T >

matrix< T > projection (const T &f)

bool read (ioHandler &handler, rectLocation &mat, const bool complete=true)

bool write (ioHandler &handler, const rectLocation &mat, const bool complete=true)

template<class T >

std::ostream & operator<< (std::ostream &s, const separableKernel< T > &kern)

bool read (ioHandler &handler, surfLocalDescriptor::eOrientationMode &data)

bool write (ioHandler &handler, const surfLocalDescriptor::eOrientationMode &data)

bool write (ioHandler &handler, const ioObject &p, const bool complete=true)

bool read (ioHandler &handler, ioObject &p, const bool complete=true)

bool read (ioHandler &handler, eDataRepresentationType &data)

bool write (ioHandler &handler, const eDataRepresentationType &data)

template<class T >

bool intersection (const point< T > &p1, const point< T > &p2, const point< T > &p3, const point< T > &p4, point< T > &p)

template<class T >

bool intersection (const point< T > &p1, const point< T > &p2, const point< T > &p3, const point< T > &p4)

template<class T >

T minDistanceSqr (const point< T > &p1, const point< T > &p2, const point< T > &p3, point< T > &p)

template<class T >

T minDistanceSqr (const point< T > &p1, const point< T > &p2, const point< T > &p3)

template<class T >

T minDistanceSqr (const point< T > &p1, const point< T > &p2, const point< T > &p3, const point< T > &p4, point< T > &pa, point< T > &pb)

template<class T >

int clockwiseTurn (const point< T > &p0, const point< T > &p1, const point< T > &p2)

bool read (ioHandler &handler, linearLeastSquares::eAlgorithm &data)

bool write (ioHandler &handler, const linearLeastSquares::eAlgorithm &data)

template<class T >

bool closeTo (const T &a, const T &b, const T epsilon=std::numeric_limits< T >::epsilon())

template<class T >

bool closeToZero (const T &a, const T epsilon=std::numeric_limits< T >::epsilon())

template<typename T >

T min (const T x, const T y)

template<typename T >

T max (const T x, const T y)

template<typename T >

T min (const T x, const T y, const T z)

template<typename T >

T max (const T x, const T y, const T z)

template<typename T >

T within (const T x, const T lower, const T upper)

template<typename T >

void minmax (const T x, const T y, T &theMin, T &theMax)

template<typename T >

void minmax (T &theMin, T &theMax)

template<typename T >

void minmax (const T x, T &theMin, T &theMax)

double degToRad (const double &deg)

float degToRad (const float &deg)

double degToRad (const int deg)

double radToDeg (const double &rad)

float radToDeg (const float &rad)

byte abs (byte x)

int abs (int x)

float abs (float x)

double abs (const double &x)

template<typename T >

T absdiff (const T &x, const T &y)

double reciprocal (const double &x)

float reciprocal (const float &x)

double oneMinus (const double &x)

float oneMinus (const float &x)

int oneMinus (const int x)

template<typename T >

T rectify (const T &x)

template<typename T >

T sqr (const T &x)

template<typename T >

T sqrAbs (const T &x)

template<typename T >

T conj (const T cn)

int sqrt (int x)

unsigned int sqrt (unsigned int x)

float sqrt (const float &x)

double sqrt (const double &x)

template<typename T >

T sqrtrect (const T x)

float sigmoid (const float x)

double sigmoid (const double &x)

double sigmoid (const int x)

template<typename T >

T signum (T x)

template<typename T >

T signum0 (T x)

template<typename T >

bool even (const T x)

template<typename T >

bool odd (const T x)

template<typename T >

void householder (vector< T > &v, T &beta)

template<typename T >

void householder (const vector< T > &src, vector< T > &v, T &beta)

template<typename T >

void givens (const T &a, const T &b, T &c, T &s)

bool read (ioHandler &handler, eMedianEvenCase &data)

bool write (ioHandler &handler, const eMedianEvenCase &data)

bool read (ioHandler &handler, minimizeBasis::eDeviationType &data)

bool write (ioHandler &handler, const minimizeBasis::eDeviationType &data)

bool read (ioHandler &handler, randomDistribution::eNumberGenerator &data)

bool write (ioHandler &handler, const randomDistribution::eNumberGenerator &data)

template<typename T >

T round (T x)

template<typename T >

int iround (T x)

template<typename T >

long lround (T x)

template<typename T , typename F >

T cround_cast (const F from)

template<class T >

void sincos (T angle, T &sval, T &cval)

bool read (ioHandler &handler, eSortingOrder &data)

bool write (ioHandler &handler, const eSortingOrder &data)

void passiveWait (const int usTime)

bool read (ioHandler &handler, eBoundaryType &data)

bool write (ioHandler &handler, const eBoundaryType &data)

bool read (ioHandler &handler, eConstantReference &data)

bool write (ioHandler &handler, const eConstantReference &data)

template<typename T >

bool read (ioHandler &handler, interval< T > &p, const bool complete=true)

template<typename T >

bool write (ioHandler &handler, const interval< T > &p, const bool complete=true)

template<class T >

bool read (ioHandler &handler, line< T > &l, const bool complete=true)

template<class T >

bool write (ioHandler &handler, const line< T > &l, const bool complete=true)

template<typename T >

bool read (ioHandler &handler, point< T > &p, const bool complete=true)

template<typename T >

bool write (ioHandler &handler, const point< T > &p, const bool complete=true)

template<typename T >

bool read (ioHandler &handler, point3D< T > &p, const bool complete=true)

template<typename T >

bool write (ioHandler &handler, const point3D< T > &p, const bool complete=true)

template<class T >

bool read (ioHandler &handler, pointList< T > &plst, const bool complete=true)

template<class T >

bool write (ioHandler &handler, const pointList< T > &plst, const bool complete=true)

template<typename T , class S >

bool read (ioHandler &handler, rectangle< T, S > &p, const bool complete=true)

template<typename T , class S >

bool write (ioHandler &handler, const rectangle< T, S > &p, const bool complete=true)

bool read (ioHandler &handler, eResizeType &data)

bool write (ioHandler &handler, const eResizeType &data)

rgbaPixel operator* (const int p, const rgbaPixel &other)

rgbaPixel operator* (const float p, const rgbaPixel &other)

rgbaPixel operator* (const double &p, const rgbaPixel &other)

bool read (ioHandler &handler, rgbaPixel &p, const bool complete=true)

bool write (ioHandler &handler, const rgbaPixel &p, const bool complete=true)

template<typename T >

rgbPixel< T > operator* (const int p, const rgbPixel< T > &other)

template<typename T >

rgbPixel< T > operator* (const float p, const rgbPixel< T > &other)

template<typename T >

rgbPixel< T > operator* (const double &p, const rgbPixel< T > &other)

template<typename T >

bool read (ioHandler &handler, rgbPixel< T > &p, const bool complete=true)

template<typename T >

bool write (ioHandler &handler, const rgbPixel< T > &p, const bool complete=true)

Color Constants.

These color constants are defined in the file cvrColors.h.
Note that the color names are all own creations, they are not correlated to any official naming standards at all.

static const rgbaPixel Black (0, 0, 0)

static const rgbaPixel Red (255, 0, 0)

static const rgbaPixel Green (0, 255, 0)

static const rgbaPixel Blue (0, 0, 255)

static const rgbaPixel Yellow (255, 255, 0)

static const rgbaPixel Magenta (255, 0, 255)

static const rgbaPixel Cyan (0, 255, 255)

static const rgbaPixel White (255, 255, 255)

static const rgbaPixel DarkRed (127, 0, 0)

static const rgbaPixel DarkGreen (0, 127, 0)

static const rgbaPixel DarkBlue (0, 0, 127)

static const rgbaPixel DarkYellow (127, 127, 0)

static const rgbaPixel DarkCyan (0, 127, 127)

static const rgbaPixel DarkMagenta (127, 0, 127)

static const rgbaPixel BrightGreen (0, 255, 127)

static const rgbaPixel BrightBlue (0, 127, 255)

static const rgbaPixel BrightRed (255, 127, 64)

static const rgbaPixel BrightMagenta (255, 127, 255)

static const rgbaPixel BrightYellow (255, 255, 127)

static const rgbaPixel BrightCyan (127, 255, 255)

static const rgbaPixel DarkOrange (192, 64, 0)

static const rgbaPixel Fusia (255, 0, 127)

static const rgbaPixel Pink (255, 127, 127)

static const rgbaPixel LawnGreen (127, 255, 0)

static const rgbaPixel Lemon (127, 255, 127)

static const rgbaPixel LightBlue (0, 127, 255)

static const rgbaPixel DarkViolet (127, 0, 255)

static const rgbaPixel Violet (127, 127, 255)

rgbaPixel scale (const rgbaPixel &src, double f)

rgbaPixel darker (const rgbaPixel &src, double f=0.5)

rgbaPixel brighter (const rgbaPixel &src, double f=0.5)

rgbaPixel grey (int t)

rgbaPixel gray (int t)

rgbaPixel grey (double t)

rgbaPixel gray (double t)

static const rgbaPixel Grey100 (255, 255, 255)

static const rgbaPixel Grey75 (191, 191, 191)

static const rgbaPixel Grey50 (127, 127, 127)

static const rgbaPixel Grey25 (63, 63, 63)

static const rgbaPixel Grey0 (0, 0, 0)

Read functions for standard types

bool read (ioHandler &handler, std::string &data)

bool read (ioHandler &handler, double &data)

bool read (ioHandler &handler, float &data)

bool read (ioHandler &handler, int &data)

bool read (ioHandler &handler, unsigned int &data)

bool read (ioHandler &handler, char &data)

bool read (ioHandler &handler, byte &data)

bool read (ioHandler &handler, ubyte &data)

bool read (ioHandler &handler, bool &data)

bool read (ioHandler &handler, long &data)

bool read (ioHandler &handler, unsigned long &data)

bool read (ioHandler &handler, short &data)

bool read (ioHandler &handler, unsigned short &data)

Write functions for standard types

bool write (ioHandler &handler, const std::string &data)

bool write (ioHandler &handler, const char *data)

bool write (ioHandler &handler, const double &data)

bool write (ioHandler &handler, const float &data)

bool write (ioHandler &handler, const int data)

bool write (ioHandler &handler, const unsigned int &data)

bool write (ioHandler &handler, const char &data)

bool write (ioHandler &handler, const byte &data)

bool write (ioHandler &handler, const ubyte &data)

bool write (ioHandler &handler, const bool data)

bool write (ioHandler &handler, const long &data)

bool write (ioHandler &handler, const unsigned long &data)

bool write (ioHandler &handler, const short &data)

bool write (ioHandler &handler, const unsigned short &data)

Read functions with standard storable interface

bool read (ioHandler &handler, const std::string &name, std::string &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, double &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, float &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, int &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, unsigned int &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, char &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, byte &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, ubyte &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, bool &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, long &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, unsigned long &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, short &data, const bool complete=true)

bool read (ioHandler &handler, const std::string &name, unsigned short &data, const bool complete=true)

template<class T >

bool read (ioHandler &handler, const std::string &name, T &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const std::string &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const char *data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const double &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const float &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const int data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const unsigned int &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const char &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const byte &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const ubyte &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const bool data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const long &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const unsigned long &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const short &data, const bool complete=true)

bool write (ioHandler &handler, const std::string &name, const unsigned short &data, const bool complete=true)

template<class T >

bool write (ioHandler &handler, const std::string &name, const T &data, const bool complete=true)

Euclidean Distances Functions

global functions to compute the L2 distance between two n-dimensional point representations

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const T &a, const T &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const vector< T > &a, const vector< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const matrix< T > &a, const matrix< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const std::vector< T > &a, const std::vector< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const point< T > &a, const point< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const point3D< T > &a, const point3D< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistance (const rgbPixel< T > &a, const rgbPixel< T > &b)

distanceType< rgbaPixel >
::square_distance_type euclideanDistance (const rgbaPixel &a, const rgbaPixel &b)

square of Euclidean Distances Functions

global functions to compute the square of the L2 distance between two n-dimensional point representations

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const T &a, const T &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const vector< T > &a, const vector< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const matrix< T > &a, const matrix< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const std::vector< T > &a, const std::vector< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const point< T > &a, const point< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const point3D< T > &a, const point3D< T > &b)

template<class T >

distanceType< T >
::square_distance_type euclideanDistanceSqr (const rgbPixel< T > &a, const rgbPixel< T > &b)

distanceType< rgbaPixel >
::square_distance_type euclideanDistanceSqr (const rgbaPixel &a, const rgbaPixel &b)

Variables

__extension__ typedef unsigned
_CVR_WORD64 uint64

__extension__ typedef signed
_CVR_WORD64 int64

const palette emptyPalette

const double Pi = 3.1415926535897932

const double NaN = log(-1.0)

const double Inf = tan(Pi/2.0)

const int32 MinInt24 = -0x00800000

const int32 MaxInt24 = +0x007fffff

Operators for complex numbers

typedef complex< float > fcomplex

typedef complex< double > dcomplex

template<typename T >

complex< T > operator+ (const complex< T > &a, const complex< T > &b)

template<typename T >

complex< T > operator+ (const complex< T > &a, const T &b)

template<typename T >

complex< T > operator+ (const T &a, const complex< T > &b)

template<typename T >

complex< T > operator- (const complex< T > &a, const complex< T > &b)

template<typename T >

complex< T > operator- (const complex< T > &a, const T &b)

template<typename T >

complex< T > operator- (const T &a, const complex< T > &b)

template<typename T >

complex< T > operator* (const complex< T > &a, const complex< T > &b)

template<typename T >

complex< T > operator* (const complex< T > &a, const T &b)

template<typename T >

complex< T > operator* (const T &a, const complex< T > &b)

template<typename T >

complex< T > operator/ (const complex< T > &a, const complex< T > &b)

template<typename T >

complex< T > operator/ (const complex< T > &a, const T &b)

template<typename T >

complex< T > operator/ (const T &a, const complex< T > &b)

template<typename T >

complex< T > operator+ (const complex< T > &a)

template<typename T >

complex< T > operator- (const complex< T > &a)

template<typename T >

bool operator== (const complex< T > &a, const complex< T > &b)

template<typename T >

bool operator== (const complex< T > &a, const T &b)

template<typename T >

bool operator== (const T &a, const complex< T > &b)

template<typename T >

bool operator!= (const complex< T > &a, const complex< T > &b)

template<typename T >

bool operator!= (const complex< T > &a, const T &b)

template<typename T >

bool operator!= (const T &a, const complex< T > &b)

template<typename T >

bool operator< (const complex< T > &a, const complex< T > &b)

template<typename T >

bool operator< (const complex< T > &a, const T &b)

template<typename T >

bool operator< (const T &a, const complex< T > &b)

template<typename T >

bool operator> (const complex< T > &a, const complex< T > &b)

template<typename T >

bool operator> (const complex< T > &a, const T &b)

template<typename T >

bool operator> (const T &a, const complex< T > &b)

template<typename T >

T real (const complex< T > &cn)

template<typename T >

T imag (const complex< T > &cn)

template<typename T >

T sqrAbs (const complex< T > &x)

template<typename T >

T abs (const complex< T > &cn)

template<typename T >

T arg (const complex< T > &cn)

template<typename T >

T norm (const complex< T > &cn)

template<typename T >

complex< T > polar (const T &radius, const T &angle)

template<typename T >

complex< T > conj (const complex< T > &cn)

template<typename T >

complex< T > cos (const complex< T > &cn)

template<typename T >

complex< T > cosh (const complex< T > &cn)

template<typename T >

complex< T > acos (const complex< T > &cn)

template<typename T >

complex< T > exp (const complex< T > &cn)

template<typename T >

complex< T > log (const complex< T > &cn)

template<typename T >

complex< T > log10 (const complex< T > &cn)

template<typename T >

complex< T > sin (const complex< T > &cn)

template<typename T >

complex< T > sinh (const complex< T > &cn)

template<typename T >

complex< T > asin (const complex< T > &cn)

template<typename T >

complex< T > sqrt (const complex< T > &cn)

template<typename T >

complex< T > cbrt (const complex< T > &cn)

template<typename T >

complex< T > cubeRoot (const complex< T > &cn)

template<typename T >

complex< T > tan (const complex< T > &cn)

template<typename T >

complex< T > tanh (const complex< T > &cn)

template<typename T >

complex< T > atan (const complex< T > &cn)

template<typename T >

complex< T > pow (const complex< T > &a, const T &b)

template<typename T >

complex< T > pow (const complex< T > &a, const complex< T > &b)

template<typename T >

complex< T > pow (const T &a, const complex< T > &b)

template<typename T >

bool read (ioHandler &handler, complex< T > &p, const bool complete=true)

template<typename T >

bool write (ioHandler &handler, const complex< T > &p, const bool complete=true)

Detailed Description

Namespace in which all classes, functions and constants of the CVR-Lib are defined.

Typedef Documentation

typedef kernel1D<ubyte> cvr::bkernel1D

One dimensional kernel of unsigned bytes.

typedef kernel2D<ubyte> cvr::bkernel2D

One dimensional kernel of unsigned bytes.

typedef separableKernel<ubyte> cvr::bseparableKernel

Separable kernel of unsigned bytes.

typedef complex<double> cvr::dcomplex

Alias for cvr::complex<double>.

typedef interval<double> cvr::dinterval

A interval with double coordinates.

typedef kernel1D<double> cvr::dkernel1D

One dimensional kernel of doubles.

typedef kernel2D<double> cvr::dkernel2D

One dimensional kernel of doubles.

typedef lattice1D<double> cvr::dlattice1D

Lattice1D of double.

typedef lattice2D<double> cvr::dlattice2D

Lattice2D of double.

typedef line<double> cvr::dline

A line with double coordinates.

typedef matrix<double> cvr::dmatrix

Matrix of double.

typedef point<double> cvr::dpoint

A point with double coordinates.

typedef point3D<double> cvr::dpoint3D

A point3D with double coordinates.

typedef rectangle<double> cvr::drectangle

A rectangle with double coordinates.

typedef rgbPixel<double> cvr::drgbPixel

Alias for rgbPixel<double>.

typedef separableKernel<double> cvr::dseparableKernel

Separable kernel of doubles.

typedef vector<double> cvr::dvector

Vector of double.

typedef complex<float> cvr::fcomplex

Alias for cvr::complex<float>.

typedef interval<float> cvr::finterval

A interval with float coordinates.

typedef kernel1D<float> cvr::fkernel1D

One dimensional kernel of floats.

typedef kernel2D<float> cvr::fkernel2D

One dimensional kernel of floats.

typedef lattice1D<float> cvr::flattice1D

Lattice1D of float.

typedef lattice2D<float> cvr::flattice2D

Lattice2D of float.

typedef line<float> cvr::fline

A line with float coordinates.

typedef matrix<float> cvr::fmatrix

Matrix of float.

typedef point<float> cvr::fpoint

A point with float coordinates.

typedef point3D<float> cvr::fpoint3D

A point3D with float coordinates.

typedef rectangle<float> cvr::frectangle

A rectangle with float coordinates.

typedef rgbPixel<float> cvr::frgbPixel

Alias for rgbPixel<float>.

typedef separableKernel<float> cvr::fseparableKernel

Separable kernel of floats.

typedef vector<float> cvr::fvector

Vector of float.

typedef interval<int> cvr::iinterval

A interval with integer coordinates.

typedef kernel1D<int32> cvr::ikernel1D

One dimensional kernel of integers.

typedef kernel2D<int32> cvr::ikernel2D

One dimensional kernel of integers.

typedef lattice1D<int32> cvr::ilattice1D

Lattice1D of integer.

typedef lattice2D<int32> cvr::ilattice2D

Lattice2D of integer.

typedef line<int> cvr::iline

A line with integer coordinates.

typedef matrix<int32> cvr::imatrix

Matrix of integer.

typedef _CVR_F2C_INTEGER cvr::integer

Type of integer as defined in f2c.h.

This is a type used to adapt different implementations of Fortran-C adapters.

typedef point<int> cvr::ipoint

A point with integer coordinates.

typedef point3D<int> cvr::ipoint3D

A point3D with integer coordinates.

typedef pointList<int> cvr::ipointList

ipointList is a list of points with integer coordinates

typedef polygonPoints<int> cvr::ipolygonPoints

Polygon Points of Integer Points.

typedef rectangle<int> cvr::irectangle

A rectangle with integer coordinates.

typedef rgbPixel<int> cvr::irgbPixel

Alias for rgbPixel<int>.

typedef separableKernel<int> cvr::iseparableKernel

Separable kernel of integers.

typedef vector<int32> cvr::ivector

Vector of integer.

typedef vector<rgbaPixel> cvr::palette

Vector of rgbaPixel: used as a color palette.

typedef interval<unsigned int> cvr::uiinterval

A interval with unsigned integer coordinates.

typedef point<unsigned int> cvr::uipoint

A point with unsigned integer coordinates.

Enumeration Type Documentation

enum cvr::eDataRepresentationType

Determines how a data sample is represented when a matrix is given.

In the CVR-Lib a row in a matrix usually corresponds to a data sample or point. Choose Rows for this behaviour. However, you can also choose Columns for the opposite.

Enumerator:

Rows	Data samples are in each row of a matrix.
Columns	Data samples are in each column of a matrix.

enum cvr::eEndiannessType

Endianness naming constants.

Enumerator:

LittleEndian	Little Endian (Like in Intel x86 Processors).
BigEndian	Big Endian (Like in IBM PowerPC Processors).

enum cvr::eInterpolationType

Interpolation Type.

This type is used to indicate how sub-pixel position should be computed.

Enumerator:

NearestNeighborInterpolation	Nearest Neighbor Interpolation.
BilinearInterpolation	Bilinear Interpolation.
BiquadraticInterpolation	Biquadratic Taps Interpolation.
BicubicInterpolation	Bicubic Interpolation.

enum cvr::eMedianEvenCase

The median value of even length vectors is undefined.

It can either be the value before or after half the length. This enum is used to specify which behaviour is desired: TakeLower or TakeHigher.

Enumerator:

TakeLower	take the element with the lower index, i.e. N/2-1 with N the number of elements in the vector
TakeHigher	take the element with the higher index, i.e. N/2 with N the number of elements in the vector

enum cvr::eSortingOrder

Type used to specify the sorting order.

Enumerator:

Ascending	ascending order
Descending	descending order

Function Documentation

template<typename T >

T cvr::abs ( const complex< T > & cn ) [inline]

Get the absolute value of a complex number.

Referenced by cvr::euclideanDistantor< T, D >::component(), and euclideanDistance().

template<typename T >

complex<T> cvr::acos ( const complex< T > & cn ) [inline]

Alias for cvr::complex<float>.

template<typename T >

T cvr::arg ( const complex< T > & cn ) [inline]

Get the argument (angle or phase) of a complex number.

template<typename T >

complex<T> cvr::asin ( const complex< T > & cn ) [inline]

Arc sine of a complex number.

template<typename T >

complex<T> cvr::atan ( const complex< T > & cn ) [inline]

Hyperbolic arc tangent of a complex number.

static const rgbaPixel cvr::Black	(	0	,
		0	,
		0
	)			`[static]`

Constant for the color black.

static const rgbaPixel cvr::Blue	(	0	,
		0	,
		255
	)			`[static]`

Constant for the color blue.

static const rgbaPixel cvr::BrightBlue	(	0	,
		127	,
		255
	)			`[static]`

constant for a kind of bright green.

static const rgbaPixel cvr::BrightCyan	(	127	,
		255	,
		255
	)			`[static]`

constant for some kind of bright cyan.

rgbaPixel cvr::brighter	(	const rgbaPixel &	src,
		double	f = `0.5`
	)			`[inline]`

Function for brightening a color.

Parameters:

	src	rgbaPixel of the original color
	f	factor which tells how much darker the new color should be. Example: 0.2 means: Make the color 20% brighter. 0 means: leave the original, 1.0 means: make it twice as bright. Warning: Saturation effects might lead to strange results.

Returns:: rgbaPixel where R, G and B have the given value t.

References scale().

static const rgbaPixel cvr::BrightGreen	(	0	,
		255	,
		127
	)			`[static]`

constant for a kind of bright green.

static const rgbaPixel cvr::BrightMagenta	(	255	,
		127	,
		255
	)			`[static]`

constant for some kind of bright magenta.

static const rgbaPixel cvr::BrightRed	(	255	,
		127	,
		64
	)			`[static]`

constant for a kind of bright red.

static const rgbaPixel cvr::BrightYellow	(	255	,
		255	,
		127
	)			`[static]`

constant for some kind of bright yellow.

template<typename T >

complex<T> cvr::cbrt ( const complex< T > & cn ) [inline]

Cube root of a complex number.

A there are always two solutions for sqrt(x+iy), this method provides the first one consisting in sqrt(m*e^(i*a))=sqrt(m)*e^(i*a/2)

template<typename T >

T cvr::conj ( const T cn ) [inline]

Return the conjugate of a scalar number, i.e.

the same number.

This function is used in generic programming algorithms in which also complex numbers are expected.

template<typename T >

complex<T> cvr::conj ( const complex< T > & cn ) [inline]

Return the conjugate of the complex number.

template<typename T >

complex<T> cvr::cos ( const complex< T > & cn ) [inline]

Cosine of a complex number.

template<typename T >

complex<T> cvr::cosh ( const complex< T > & cn ) [inline]

Hyperbolic cosine of a complex number.

template<typename T , typename F >

T cvr::cround_cast ( const F from ) [inline]

Conditional round cast.

This template functions cast the given value using rounding if necessary. This means, if you cast between different floating point types, no integer rounding will be done, but if you cast from a floating point value to an integer value, the result will be rounded. For example:

 int i   = cround_cast<int>(3.6); // i will contain 4
 float f = cround_cast<float>(3.6); // i will contain 3.6f

This sort of casting is used in the implementation of several template functions where the output type depends on the current instantiation.

template<typename T >

complex<T> cvr::cubeRoot ( const complex< T > & cn ) [inline]

Cube root of a complex number (alias for cbrt()).

static const rgbaPixel cvr::Cyan	(	0	,
		255	,
		255
	)			`[static]`

Constant for the color cyan.

static const rgbaPixel cvr::DarkBlue	(	0	,
		0	,
		127
	)			`[static]`

Constant for dark blue.

static const rgbaPixel cvr::DarkCyan	(	0	,
		127	,
		127
	)			`[static]`

constant for some kind of dark cyan.

rgbaPixel cvr::darker	(	const rgbaPixel &	src,
		double	f = `0.5`
	)			`[inline]`

Function for darkening a color.

Parameters:

	src	rgbaPixel of the original color
	f	factor which tells how much darker the new color should be. Example: 0.2 means: Make the color 20% darker. 0 means: leave the original, 1.0 means: make it black

Returns:: rgbaPixel where R, G and B have the given value t.

References scale().

static const rgbaPixel cvr::DarkGreen	(	0	,
		127	,
		0
	)			`[static]`

Constant for dark green.

static const rgbaPixel cvr::DarkMagenta	(	127	,
		0	,
		127
	)			`[static]`

constant for some kind of dark magenta.

static const rgbaPixel cvr::DarkOrange	(	192	,
		64	,
		0
	)			`[static]`

constant for the color orange.

static const rgbaPixel cvr::DarkRed	(	127	,
		0	,
		0
	)			`[static]`

Constant for dark red.

static const rgbaPixel cvr::DarkViolet	(	127	,
		0	,
		255
	)			`[static]`

constant for a light blue.

static const rgbaPixel cvr::DarkYellow	(	127	,
		127	,
		0
	)			`[static]`

constant for the color dark yellow

distanceType<rgbaPixel>::square_distance_type cvr::euclideanDistance	(	const rgbaPixel &	a,
		const rgbaPixel &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the RGB values a and b in the RGB color space.

References cvr::rgbaPixel::distanceSqr(), and sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const rgbPixel< T > &	a,
		const rgbPixel< T > &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the RGB values a and b in the RGB color space.

References cvr::rgbPixel< T >::distanceSqr(), and sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const point3D< T > &	a,
		const point3D< T > &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the points a and b.

References cvr::point3D< T >::distanceSqr(), and sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const point< T > &	a,
		const point< T > &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the points a and b.

References cvr::point< T >::distanceSqr(), and sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const std::vector< T > &	a,
		const std::vector< T > &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the std::vectors a and b.

References sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const matrix< T > &	a,
		const matrix< T > &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the cvr::matrix a and b.

References cvr::genericMatrix< T >::begin(), cvr::genericMatrix< T >::end(), cvr::genericMatrix< T >::size(), and sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const vector< T > &	a,
		const vector< T > &	b
	)			`[inline]`

euclideanDistance computes the L2 distance between the vectors a and b.

References cvr::genericVector< T >::begin(), cvr::genericVector< T >::end(), cvr::genericVector< T >::size(), and sqrt().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistance	(	const T &	a,
		const T &	b
	)			`[inline]`

Default implementation of the L2 distance between two values of type T.

It is assumed that T is scalar and an efficient implementation is used. T must define the operator- and T must be castable to distanceType<T>::square_distance_type, which in turn must be a possible argument of cvr::abs().

Overloads for most CVR-Lib types are implemented.

References abs().

Referenced by cvr::euclideanDistantor< T, D >::operator()().

distanceType<rgbaPixel>::square_distance_type cvr::euclideanDistanceSqr	(	const rgbaPixel &	a,
		const rgbaPixel &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the RGB values a and b in the RGB color space.

References cvr::rgbaPixel::distanceSqr().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const rgbPixel< T > &	a,
		const rgbPixel< T > &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the RGB values a and b in the RGB color space.

References cvr::rgbPixel< T >::distanceSqr().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const point3D< T > &	a,
		const point3D< T > &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the points a and b.

References cvr::point3D< T >::distanceSqr().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const point< T > &	a,
		const point< T > &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the points a and b.

References cvr::point< T >::distanceSqr().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const std::vector< T > &	a,
		const std::vector< T > &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the std::vectors a and b.

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const matrix< T > &	a,
		const matrix< T > &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the cvr::matrix a and b.

References cvr::genericMatrix< T >::begin(), cvr::genericMatrix< T >::end(), and cvr::genericMatrix< T >::size().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const vector< T > &	a,
		const vector< T > &	b
	)			`[inline]`

euclideanDistanceSqr computes the L2 distance between the vectors a and b.

References cvr::genericVector< T >::begin(), cvr::genericVector< T >::end(), and cvr::genericVector< T >::size().

template<class T >

distanceType<T>::square_distance_type cvr::euclideanDistanceSqr	(	const T &	a,
		const T &	b
	)			`[inline]`

Default implementation of the square of the L2 distance between two values of type T.

It is assumed that T is scalar and an efficient implementation is used. T must define the operator- and T must be castable to distanceType<T>::square_distance_type, which in turn must be a possible argument of cvr::abs().

Overloads for most CVR-Lib types are implemented.

Referenced by cvr::euclideanSqrDistantor< rgbaPixel >::operator()().

template<typename T >

complex<T> cvr::exp ( const complex< T > & cn ) [inline]

Exponetial of a complex number.

static const rgbaPixel cvr::Fusia	(	255	,
		0	,
		127
	)			`[static]`

constant for the color fusia.

rgbaPixel cvr::gray ( double t ) [inline]

function for returning a gray value.

Parameters:

t

grey value must be between 0 and 1

Returns:: rgbaPixel where R, G and B have the given value t*255.

rgbaPixel cvr::gray ( int t ) [inline]

function for returning a gray value.

Parameters:

t

grey value must be between 0 and 255

Returns:: rgbaPixel where R, G and B have the given value t.

static const rgbaPixel cvr::Green	(	0	,
		255	,
		0
	)			`[static]`

Constant for the color green.

rgbaPixel cvr::grey ( double t ) [inline]

function for returning a grey value.

Parameters:

t

grey value must be between 0 and 1

Returns:: rgbaPixel where R, G and B have the given value t*255.

rgbaPixel cvr::grey ( int t ) [inline]

function for returning a grey value.

Parameters:

t

grey value must be between 0 and 255

Returns:: rgbaPixel where R, G and B have the given value t.

static const rgbaPixel cvr::Grey0	(	0	,
		0	,
		0
	)			`[static]`

Definition for a 0% bright grey, i.e.

Black

static const rgbaPixel cvr::Grey100	(	255	,
		255	,
		255
	)			`[static]`

Definition for a 100% bright grey, i.e.

White

static const rgbaPixel cvr::Grey25	(	63	,
		63	,
		63
	)			`[static]`

Definition for a 25% bright grey, i.e.

dark grey

static const rgbaPixel cvr::Grey50	(	127	,
		127	,
		127
	)			`[static]`

Definition for a 50% bright grey, i.e.

medium grey

static const rgbaPixel cvr::Grey75	(	191	,
		191	,
		191
	)			`[static]`

Definition for a 75% bright grey, i.e.

bright grey

template<typename T >

T cvr::imag ( const complex< T > & cn ) [inline]

Get the imaginary part of a complex number.

bool cvr::isNull ( const void * p ) [inline]

Check if the given pointer is NULL.

Referenced by cvr::factory< T >::factory::registration< U >::registration().

static const rgbaPixel cvr::LawnGreen	(	127	,
		255	,
		0
	)			`[static]`

constant for another kind of bright green.

static const rgbaPixel cvr::Lemon	(	127	,
		255	,
		127
	)			`[static]`

constant for some kind of lemon color

static const rgbaPixel cvr::LightBlue	(	0	,
		127	,
		255
	)			`[static]`

constant for a light blue.

template<typename T >

complex<T> cvr::log ( const complex< T > & cn ) [inline]

Natural logarithm of a complex number (base e).

template<typename T >

complex<T> cvr::log10 ( const complex< T > & cn ) [inline]

Logarithm base 10 of a complex number.

static const rgbaPixel cvr::Magenta	(	255	,
		0	,
		255
	)			`[static]`

Constant for the color magenta.

template<typename T >

T cvr::norm ( const complex< T > & cn ) [inline]

Return the square magnitude of the given complex number.

bool cvr::notNull ( const void * p ) [inline]

Check if the given pointer is not NULL.

template<typename T >

bool cvr::operator!=	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Compare if a real number and a complex one differ.

template<typename T >

bool cvr::operator!=	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Compare if a complex number and a real one differ.

template<typename T >

bool cvr::operator!=	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Compare if two complex numbers differ.

template<typename T >

rgbPixel<T> cvr::operator*	(	const double &	p,
		const rgbPixel< T > &	other
	)			`[inline]`

Multiply all components of the given pixel with an integer except the alpha channel.

template<typename T >

rgbPixel<T> cvr::operator*	(	const float	p,
		const rgbPixel< T > &	other
	)			`[inline]`

Multiply all components of the given pixel with an integer except the alpha channel.

template<typename T >

rgbPixel<T> cvr::operator*	(	const int	p,
		const rgbPixel< T > &	other
	)			`[inline]`

Multiply all components of the given pixel with an integer except the alpha channel.

rgbaPixel cvr::operator*	(	const double &	p,
		const rgbaPixel &	other
	)			`[inline]`

Multiply all components of the given pixel with an integer except the alpha channel.

rgbaPixel cvr::operator*	(	const float	p,
		const rgbaPixel &	other
	)			`[inline]`

Multiply all components of the given pixel with an integer except the alpha channel.

rgbaPixel cvr::operator*	(	const int	p,
		const rgbaPixel &	other
	)			`[inline]`

Multiply all components of the given pixel with an integer except the alpha channel.

template<typename T >

complex<T> cvr::operator*	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Multiply a real number with a complex one.

template<typename T >

complex<T> cvr::operator*	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Multiply a complex number with a real one.

template<typename T >

complex<T> cvr::operator*	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Multiply two complex numbers.

template<typename T >

complex<T> cvr::operator+ ( const complex< T > & a ) [inline]

Plus sign a complex number.

template<typename T >

complex<T> cvr::operator+	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Add a real number with a complex number.

template<typename T >

complex<T> cvr::operator+	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Add a complex number with a real number.

template<typename T >

complex<T> cvr::operator+	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Add two complex numbers.

template<typename T >

complex<T> cvr::operator- ( const complex< T > & a ) [inline]

Minus sign a complex number.

template<typename T >

complex<T> cvr::operator-	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Subtract a complex number from a real one.

template<typename T >

complex<T> cvr::operator-	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Subtract a real number from a complex one.

template<typename T >

complex<T> cvr::operator-	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Subtract two complex numbers.

template<typename T >

complex<T> cvr::operator/	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Divide a real number by a complex one.

template<typename T >

complex<T> cvr::operator/	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Divide a complex number by a real one.

template<typename T >

complex<T> cvr::operator/	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Divide two complex numbers.

template<typename T >

bool cvr::operator<	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

A complex number is "less than" another one if its real part is smaller, or when both real parts are identical, if its imaginary part is smaller.

template<typename T >

bool cvr::operator<	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

A complex number is "less than" another one if its real part is smaller, or when both real parts are identical, if its imaginary part is smaller.

template<typename T >

bool cvr::operator<	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

A complex number is called here "less than" another one if its real part is smaller, or when both real parts are identical, if its imaginary part is smaller.

template<class T >

std::ostream& cvr::operator<<	(	std::ostream &	s,
		const separableKernel< T > &	kern
	)			`[inline]`

outputs the separable kernel kern on a stream s.

The kernel pairs are printed in the order they are stored in the separable kernel:

 (((first row kernel)
   (first column kernel))
  ((second row kernel)
   (second column kernel))
   ...
  ((last row kernel)
   (last column kerne)))

template<typename T >

bool cvr::operator==	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Compare if a real number and a complex number are the same.

template<typename T >

bool cvr::operator==	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Compare if two complex numbers differ.

template<typename T >

bool cvr::operator==	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Compare if two complex numbers are equal.

template<typename T >

bool cvr::operator>	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

A complex number is "greater than" another one if its real part is greater, or when both real parts are identical, if its imaginary part is greater.

template<typename T >

bool cvr::operator>	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

A complex number is "greater than" another one if its real part is greater, or when both real parts are identical, if its imaginary part is greater.

template<typename T >

bool cvr::operator>	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

A complex number is "greater than" another one if its real part is greater, or when both real parts are identical, if its imaginary part is greater.

void cvr::passiveWait ( const int usTime )

This global function is a replacement in the lti namespace for the sleep and Sleep functions of Windows and Unix.

To avoid misunderstandings the name has been chosen to be passiveWait instead of "sleep", which has different meanings on the different systems.

The time must always be given in microseconds, although the real precision will be determined by the operating system. (Windows uses milliseconds and Unixes a few microseconds, depending on the implementation of usleep.)

Parameters:

usTime

number of microseconds to wait passively

static const rgbaPixel cvr::Pink	(	255	,
		127	,
		127
	)			`[static]`

constant for the color pink.

template<typename T >

complex<T> cvr::polar	(	const T &	radius,
		const T &	angle
	)			`[inline]`

Convert the given polar values into a complex number.

Parameters:

	radius	magnitude of the number
	angle	angle of the number

Returns:: Equivalent complex number to the polar one

template<typename T >

complex<T> cvr::pow	(	const T &	a,
		const complex< T > &	b
	)			`[inline]`

Real number to the power of b, with complex.

template<typename T >

complex<T> cvr::pow	(	const complex< T > &	a,
		const complex< T > &	b
	)			`[inline]`

Complex number to the power of b, with complex.

template<typename T >

complex<T> cvr::pow	(	const complex< T > &	a,
		const T &	b
	)			`[inline]`

Complex number to the power of b, with real.

bool cvr::read	(	ioHandler &	handler,
		rectLocation &	mat,
		const bool	complete = `true`
	)

Global function to read a cvr::rectLocation from an ioHandler.

bool cvr::read	(	ioHandler &	handler,
		location &	mat,
		const bool	complete = `true`
	)

Read a location from the ioHandler.

bool cvr::read	(	ioHandler &	handler,
		affineLocation &	loc,
		const bool	complete = `true`
	)

Read a affine location from the ioHandler.

template<typename T >

T cvr::real ( const complex< T > & cn ) [inline]

Get the real part of a complex number.

static const rgbaPixel cvr::Red	(	255	,
		0	,
		0
	)			`[static]`

Constant for the color read.

rgbaPixel cvr::scale	(	const rgbaPixel &	src,
		double	f
	)			`[inline]`

Function for scaling a color's intensity.

Parameters:

	src	rgbaPixel of the original color
	f	factor by which to multiply the R, G and B values. Warning: Saturation effects might lead to strange results.

Returns:: rgbaPixel where R, G and B have the given value t.

References cvr::rgbaPixel::getBlue(), cvr::rgbaPixel::getGreen(), cvr::rgbaPixel::getRed(), and within().

Referenced by brighter(), and darker().

void cvr::setStatusMonitor ( statusMonitor & monitor )

Global function to set the status monitor in all CVR-Lib objects that manage a status string, like cvr::functor, cvr::ioHandler, cvr::classifier, etc.

template<typename T >

complex<T> cvr::sin ( const complex< T > & cn ) [inline]

Sine of a complex number.

template<class T >

void cvr::sincos	(	T	angle,
		T &	sval,
		T &	cval
	)			`[inline]`

Calculate the sine and cosine values of angle in one step if the setup allows it.

Parameters:

	angle	the angle
	sval	sine of the `angle`
	cval	cosine of the `angle`

template<typename T >

complex<T> cvr::sinh ( const complex< T > & cn ) [inline]

Hyperbolic sine of a complex number.

template<typename T >

complex<T> cvr::sqrt ( const complex< T > & cn ) [inline]

Square root of a complex number.

A there are always two solutions for sqrt(x+iy), this method provides the first one consisting in sqrt(m*e^(i*a))=sqrt(m)*e^(i*a/2)

Referenced by cvr::euclideanDistantor< T, D >::computeDistance(), and euclideanDistance().

template<typename T >

complex<T> cvr::tan ( const complex< T > & cn ) [inline]

Tangent of a complex number.

template<typename T >

complex<T> cvr::tanh ( const complex< T > & cn ) [inline]

Hyperbolic tangent of a complex number.

static const rgbaPixel cvr::Violet	(	127	,
		127	,
		255
	)			`[static]`

constant for the color violet.

static const rgbaPixel cvr::White	(	255	,
		255	,
		255
	)			`[static]`

Constant for the color white.

template<class T >

bool cvr::write	(	ioHandler &	handler,
		const std::string &	name,
		const T &	data,
		const bool	complete = `true`
	)			`[inline]`