Population
Image processing library in C++
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
pop Namespace Reference

Namespaces

 Private
 inner product of two vector $<v1,v2>=\sum_i v1_i v2_i$
 

Classes

struct  _caractere
 
class  Analysis
 Analyse a 2D/3D matrix. More...
 
class  Application
 
struct  ArithmeticsSaturation< Complex< F32 >, RGB< Scalar > >
 
struct  ArithmeticsSaturation< Complex< R >, Complex< T > >
 
struct  ArithmeticsSaturation< Complex< R >, Scalar >
 
struct  ArithmeticsSaturation< F32, VecN< DIM, T > >
 
struct  ArithmeticsSaturation< RGB< R >, RGB< T > >
 
struct  ArithmeticsSaturation< RGB< R >, Scalar >
 
struct  ArithmeticsSaturation< RGB< Scalar >, Complex< F32 > >
 
struct  ArithmeticsSaturation< Scalar, Complex< R > >
 
struct  ArithmeticsSaturation< Scalar, RGB< T > >
 
struct  ArithmeticsSaturation< UI16, VecN< DIM, T > >
 
struct  ArithmeticsSaturation< UI32, VecN< DIM, T > >
 
struct  ArithmeticsSaturation< UI8, VecN< DIM, T > >
 
struct  ArithmeticsSaturation< VecN< DIM, R >, Complex< T > >
 
struct  ArithmeticsSaturation< VecN< DIM, R >, RGB< T > >
 
struct  ArithmeticsSaturation< VecN< DIM, R >, T >
 
struct  ArithmeticsSaturation< VecN< DIM, R >, VecN< DIM, T > >
 
class  BasicUtility
 String functionnality. More...
 
class  Complex
 Complex number a+ib. More...
 
class  Convertor
 convertor facilities More...
 
class  Distribution
 abstract class for Distribution More...
 
class  DistributionBinomial
 binomial distribution More...
 
class  DistributionDirac
 dirac distribution More...
 
class  DistributionDiscrete
 allowing operations on discrete distributions More...
 
class  DistributionDisplay
 
class  DistributionExponential
 exponential distribution More...
 
class  DistributionMultiVariate
 abstract class for mapping from multi variate real numbers to the real numbers More...
 
class  DistributionMultiVariateExpression
 Pencil function. More...
 
class  DistributionMultiVariateNormal
 Multivariate normal distribution. More...
 
class  DistributionMultiVariateProduct
 h(x,y)=f(x)*g(y) More...
 
class  DistributionMultiVariateRegularStep
 step function with regular spacing More...
 
class  DistributionMultiVariateUnitSphere
 unit sphere distribution More...
 
class  DistributionNormal
 normal(gaussian) distribution More...
 
class  DistributionPoisson
 poisson distribution More...
 
class  DistributionSign
 probability distribution returning randomly 1 or -1 More...
 
class  DistributionTriangle
 the triangle function, hat function, or tent function More...
 
class  DistributionUniformInt
 probability distribution returning an integer number in a intervalle More...
 
class  DistributionUniformReal
 probability distribution returning a real number in a given range More...
 
class  Draw
 Draw objects on the matrix. More...
 
class  Feature
 Feature detection for 2D/3D matrix. More...
 
class  FigureArrow
 
class  FigureCone
 
class  FigureLine
 
class  FigurePolygon
 
class  FigureSphere
 
class  FigureTriangle
 
class  FigureUnitSquare
 
struct  FunctionTypeTraitsSubstituteDIM< MatN< D1, F1 >, D2 >
 
struct  FunctionTypeTraitsSubstituteF< Complex< TypeIn >, TypeOut >
 
struct  FunctionTypeTraitsSubstituteF< MatN< D, F1 >, F2 >
 
struct  FunctionTypeTraitsSubstituteF< RGB< TypeIn >, TypeOut >
 
struct  FunctionTypeTraitsSubstituteF< VecN< DIM, TypeIn >, TypeOut >
 
struct  FunctorMeanStandardDeviationIntegral
 
class  GeometricalFigure
 abtract interface for gl geometrical figure More...
 
class  GeometricalTransformation
 Geometrical Transformation. More...
 
struct  Identity
 
struct  Int2Type
 
struct  isVectoriel< Complex< PixelType > >
 
struct  isVectoriel< RGB< Type > >
 
struct  isVectoriel< VecN< DIM, Type > >
 
class  LinearAlgebra
 class to act on matrix More...
 
class  Mat2x
 
class  MatN
 template class for matrix (or Image) More...
 
class  MatNDisplay
 
class  MatNDisplayInterface
 
struct  MNISTNeuralNetLeCun5
 
class  NeuralLayer
 
struct  NeuralLayerLinear
 
class  NeuralLayerLinearFullyConnected
 
class  NeuralLayerLinearInput
 
class  NeuralLayerMatrix
 
class  NeuralLayerMatrixConvolutionSubScaling
 
class  NeuralLayerMatrixInput
 
class  NeuralLayerMatrixMaxPool
 
class  NeuralNet
 neural network organised in feedforward topology More...
 
struct  NeuronSigmoid
 
class  NormalizationMatrixInput
 
class  NormalizationMatrixInputCentering
 
class  NormalizationMatrixInputMass
 
class  NullType
 
struct  NumericLimits< MatN< DIM, PixelType > >
 
struct  NumericLimits< pop::Complex< T > >
 
struct  NumericLimits< pop::RGB< T > >
 
struct  NumericLimits< pop::VecN< DIM, Type > >
 
class  PDE
 Algorithm based on partial differential equations. More...
 
struct  PowerGP
 
struct  PowerGP< Value, 0 >
 
struct  Processing
 
class  RandomGeometry
 Germ-Grain framework. More...
 
class  Representation
 Working with representation. More...
 
class  RGB
 Red Green Blue channel. More...
 
class  Scene3d
 contain the list of glfigue More...
 
class  Statistics
 Mathematical analysis of function with symbolic link (mathematics) oriented stastistics. More...
 
struct  Type2Type
 
class  Vec
 tuple of numbers of variable size for the representation of the coordinate vector More...
 
class  VecN
 tuple of numbers of fixed for the representation of a point or a vector as element position of a matrix More...
 
struct  VecN2IndiceByTable
 
struct  VecNIndice
 
struct  VecNIndice< 2 >
 
struct  VecNIndice< 3 >
 
class  VecNIteratorEDomain
 
class  Video
 simple class to read video (rtsp stream, avi file ...) More...
 
class  Visualization
 matrix visualization with opengl layer More...
 

Typedefs

typedef unsigned char UI8
 Unsigned Integers of 8 bits (0,1,2...255) More...
 
typedef signed char I8
 Signed Integers of 8 bits (-128,-127,...,126,127)
 
typedef unsigned short UI16
 Unsigned Integers of 16 bits (0,1,...,65535) More...
 
typedef short I16
 Signed Integers of 16 bits (-32768,-32767,...,32766,32767)
 
typedef unsigned int UI32
 Unsigned Integers of 32 bits (0,1,...,4294967295) More...
 
typedef int I32
 Signed Integers of 32 bits (-2147483648,...,2147483646,2147483647)
 
typedef float F32
 float type 32 bits More...
 
typedef double F64
 float type 64 bits More...
 
typedef RGB< UI8RGBUI8
 
typedef RGB< F32RGBF32
 
typedef Complex< F32ComplexF32
 
typedef VecN< 2, I32Vec2I32
 
typedef VecN< 3, I32Vec3I32
 
typedef VecN< 2, F32Vec2F32
 
typedef VecN< 3, F32Vec3F32
 
typedef Vec< ComplexF32VecComplexF32
 
typedef Vec< F32VecF32
 
typedef Vec< I32VecI32
 
typedef MatN< 2, UI8Mat2UI8
 
typedef MatN< 2, UI16Mat2UI16
 
typedef MatN< 2, UI32Mat2UI32
 
typedef MatN< 2, F32Mat2F32
 
typedef MatN< 2, RGBUI8Mat2RGBUI8
 
typedef MatN< 2, RGBF32Mat2RGBF32
 
typedef MatN< 2, ComplexF32Mat2ComplexF32
 
typedef MatN< 2, Vec2F32Mat2Vec2F32
 
typedef MatN< 3, UI8Mat3UI8
 
typedef MatN< 3, UI16Mat3UI16
 
typedef MatN< 3, UI32Mat3UI32
 
typedef MatN< 3, F32Mat3F32
 
typedef MatN< 3, RGBUI8Mat3RGBUI8
 
typedef MatN< 3, RGBF32Mat3RGBF32
 
typedef MatN< 3, ComplexF32Mat3ComplexF32
 
typedef MatN< 3, VecN< 3, F32 > > Mat3Vec3F32
 

Enumerations

enum  FFT_WAY { FFT_FORWARD =1, FFT_BACKWARD =-1 }
 

Functions

template<class T1 >
RGB< T1 > operator+ (T1 v, const RGB< T1 > &c1)
 
template<typename T1 >
RGB< T1 > operator- (T1 v, const RGB< T1 > &c1)
 
template<class T1 >
RGB< T1 > operator* (T1 v, const RGB< T1 > &c1)
 
template<class T1 >
RGB< T1 > operator/ (T1 v, const RGB< T1 > &c1)
 
template<class T1 >
pop::RGB< T1 > minimum (const pop::RGB< T1 > &x1, const pop::RGB< T1 > &x2)
 return the RGB with the minimum luminance More...
 
template<class T1 >
pop::RGB< T1 > maximum (const pop::RGB< T1 > &x1, const pop::RGB< T1 > &x2)
 return the RGB with the maximum luminance More...
 
template<class T1 >
F32 productInner (const pop::RGB< T1 > &x1, const pop::RGB< T1 > &x2)
 scalar product More...
 
template<class T1 >
F32 normValue (const pop::RGB< T1 > &x1, int p=-1)
 return the luminance as default norm More...
 
template<class T1 >
F32 normPowerValue (const pop::RGB< T1 > &x1, int p=-1)
 return the luminance as default norm More...
 
template<class T1 >
F32 distance (const pop::RGB< T1 > &x1, const pop::RGB< T1 > &x2, int p=-1)
 return the luminance as default norm More...
 
template<class T1 >
pop::RGB< T1 > absolute (const pop::RGB< T1 > &x1)
 
template<typename T1 >
pop::RGB< T1 > round (const pop::RGB< T1 > &v)
 return round of each channel More...
 
template<typename T1 >
pop::RGB< T1 > squareRoot (const pop::RGB< T1 > &v)
 
template<class T1 >
std::ostream & operator<< (std::ostream &out, const pop::RGB< T1 > &h)
 
template<>
std::ostream & operator<< (std::ostream &out, const pop::RGB< UI8 > &h)
 
template<class T1 >
std::istream & operator>> (std::istream &in, pop::RGB< T1 > &h)
 
template<class T1 >
Complex< T1 > operator* (T1 x2, const Complex< T1 > &x1)
 
template<class T1 >
Complex< T1 > operator/ (T1 x2, const Complex< T1 > &x1)
 
template<class T1 >
Complex< T1 > operator+ (T1 x2, const Complex< T1 > &x1)
 
template<class T1 >
Complex< T1 > operator- (T1 x2, const Complex< T1 > &x1)
 
template<class T1 >
pop::Complex< T1 > minimum (const pop::Complex< T1 > &x1, const pop::Complex< T1 > &x2)
 minimum of the two numbers More...
 
template<class T1 >
pop::Complex< T1 > maximum (const pop::Complex< T1 > &x1, const pop::Complex< T1 > &x2)
 maximum of the two numbers More...
 
template<class T1 >
pop::Complex< T1 > squareRoot (const pop::Complex< T1 > &x1)
 sqrt of the number http://en.wikipedia.org/wiki/Complex_number#Square_root More...
 
template<class T1 >
F32 productInner (const pop::Complex< T1 > &x1, const pop::Complex< T1 > &x2)
 inner product <x1=(a+ib)|x2=(c+id)>=a*c+b*d More...
 
template<class T1 >
F32 normValue (const pop::Complex< T1 > &x1, F32 p=2)
 norm of the number a^2+b^2 with x1 = a+ib More...
 
template<class T1 >
F32 normPowerValue (const pop::Complex< T1 > &x1, F32 p=2)
 norm of the number a^2+b^2 with x1 = a+ib More...
 
template<class T1 >
F32 distance (const pop::Complex< T1 > &x1, const pop::Complex< T1 > &x2, F32 p=2)
 distance between two complex numbers More...
 
template<class T1 >
pop::Complex< T1 > absolute (const pop::Complex< T1 > &x1)
 Returns the absolute value of each channel. More...
 
template<class T1 >
std::ostream & operator<< (std::ostream &out, const pop::Complex< T1 > x1)
 
template<class T1 >
std::istream & operator>> (std::istream &in, pop::Complex< T1 > &x1)
 
template<typename T1 >
pop::Complex< T1 > round (const pop::Complex< T1 > &v)
 
template<int D, class Type1 >
VecN< D, Type1 > operator+ (Type1 value, const VecN< D, Type1 > &x)
 
template<int D, class Type1 >
VecN< D, Type1 > operator- (Type1 value, const VecN< D, Type1 > &x)
 
template<int D, class Type1 >
VecN< D, Type1 > operator* (Type1 value, const VecN< D, Type1 > &x)
 
template<int D, class Type1 >
VecN< D, Type1 > operator/ (Type1 value, const VecN< D, Type1 > &x)
 
template<int DIM, typename Type1 >
pop::VecN< DIM, Type1 > maximum (const pop::VecN< DIM, Type1 > &p1, const pop::VecN< DIM, Type1 > &p2)
 maximum of VecN u by the VecN v $\max(u,v)=(\max(u_0,v_0),\max(u_1,v_1))$ for each coordinate More...
 
template<typename Type1 >
pop::VecN< 2, Type1 > maximum (const pop::VecN< 2, Type1 > &p1, const pop::VecN< 2, Type1 > &p2)
 
template<typename Type1 >
pop::VecN< 3, Type1 > maximum (const pop::VecN< 3, Type1 > &p1, const pop::VecN< 3, Type1 > &p2)
 
template<typename Type1 >
pop::VecN< 4, Type1 > maximum (const pop::VecN< 4, Type1 > &p1, const pop::VecN< 4, Type1 > &p2)
 
template<int DIM, typename Type1 >
pop::VecN< DIM, Type1 > minimum (const pop::VecN< DIM, Type1 > &p1, const pop::VecN< DIM, Type1 > &p2)
 minimum of VecN u by the VecN v $\min(u,v)=(\min(u_0,v_0),\min(u_1,v_1))$ for each coordinate More...
 
template<typename Type1 >
pop::VecN< 2, Type1 > minimum (const pop::VecN< 2, Type1 > &p1, const pop::VecN< 2, Type1 > &p2)
 
template<typename Type1 >
pop::VecN< 3, Type1 > minimum (const pop::VecN< 3, Type1 > &p1, const pop::VecN< 3, Type1 > &p2)
 
template<typename Type1 >
pop::VecN< 4, Type1 > minimum (const pop::VecN< 4, Type1 > &p1, const pop::VecN< 4, Type1 > &p2)
 
template<int DIM, typename Type1 >
pop::VecN< DIM, Type1 > absolute (const pop::VecN< DIM, Type1 > &p1)
 absolute value of the VecN abs(u)=(abs(u_0),abs(u_1)) for each coordinate More...
 
template<typename Type1 >
pop::VecN< 2, Type1 > absolute (const pop::VecN< 2, Type1 > &p1)
 
template<typename Type1 >
pop::VecN< 3, Type1 > absolute (const pop::VecN< 3, Type1 > &p1)
 
template<typename Type1 >
pop::VecN< 4, Type1 > absolute (const pop::VecN< 4, Type1 > &p1)
 
template<int DIM, typename Type1 >
pop::VecN< DIM, Type1 > floor (const pop::VecN< DIM, Type1 > &p1)
 floor value of the VecN for each coordinate More...
 
template<typename Type1 >
pop::VecN< 2, Type1 > floor (const pop::VecN< 2, Type1 > &p1)
 
template<typename Type1 >
pop::VecN< 3, Type1 > floor (const pop::VecN< 3, Type1 > &p1)
 
template<typename Type1 >
pop::VecN< 4, Type1 > floor (const pop::VecN< 4, Type1 > &p1)
 
template<int DIM, typename Type1 >
F32 normValue (const pop::VecN< DIM, Type1 > &x, int p=2)
 norm of the VecN $\vert u \vert_p=(\sum|u_i|^p)^{1/p}$ More...
 
template<int DIM, typename Type1 >
F32 distance (const pop::VecN< DIM, Type1 > &u, const pop::VecN< DIM, Type1 > &v, int p=2)
 distance between two vectors $\vert u-v \vert^p$ More...
 
template<int DIM, typename Type1 >
F32 normPowerValue (const pop::VecN< DIM, Type1 > &p1, int p=2)
 norm of the VecN $\vert u \vert_p=\sum|u_i|^p$ More...
 
template<int DIM, typename Type1 >
pop::VecN< DIM, Type1 > round (const pop::VecN< DIM, Type1 > &v1)
 round functions return the integral value nearest to v1 rounding half-way cases away for each coordinate More...
 
template<typename Type1 >
pop::VecN< 2, Type1 > round (const pop::VecN< 2, Type1 > &p1)
 
template<typename Type1 >
pop::VecN< 3, Type1 > round (const pop::VecN< 3, Type1 > &p1)
 
template<typename Type1 >
pop::VecN< 4, Type1 > round (const pop::VecN< 4, Type1 > &p1)
 
template<int D, class Type1 >
Type1 productInner (const pop::VecN< D, Type1 > &x1, const pop::VecN< D, Type1 > &x2)
 inner product between two 3d vector More...
 
template<class Type1 >
Type1 productInner (const pop::VecN< 2, Type1 > &x1, const pop::VecN< 2, Type1 > &x2)
 
template<class Type1 >
Type1 productInner (const pop::VecN< 3, Type1 > &x1, const pop::VecN< 3, Type1 > &x2)
 
template<class Type1 >
Type1 productInner (const pop::VecN< 4, Type1 > &x1, const pop::VecN< 4, Type1 > &x2)
 
template<class Type1 >
pop::VecN< 3, Type1 > productVectoriel (const pop::VecN< 3, Type1 > &x1, const pop::VecN< 3, Type1 > &x2)
 vectoriel product between two 3d vector More...
 
template<int D, class Type >
std::ostream & operator<< (std::ostream &out, const pop::VecN< D, Type > &x)
 
template<int D, class Type >
std::istream & operator>> (std::istream &in, pop::VecN< D, Type > &x)
 
template<typename T1 >
Vec< T1 > operator+ (T1 a, const Vec< T1 > &v)
 
template<typename T1 >
Vec< T1 > operator- (T1 a, const Vec< T1 > &v)
 
template<typename T1 >
Vec< T1 > operator* (T1 a, const Vec< T1 > &v)
 
template<typename T1 >
Vec< T1 > operator/ (T1 a, const Vec< T1 > &v)
 
template<typename T1 >
pop::Vec< T1 > absolute (const pop::Vec< T1 > &v1)
 absolute value for each coordinate More...
 
template<typename T1 >
pop::Vec< T1 > floor (const pop::Vec< T1 > &v1)
 Rounds x downward for each coordinate. More...
 
template<typename T1 >
F32 normValue (const pop::Vec< T1 > &v1, int p=2)
 norm of the VecN $\vert u \vert^p=(\sum_i |u_i|^p)^{1/p}$ More...
 
template<typename T1 >
F32 normPowerValue (const pop::Vec< T1 > &v1, int p=2)
 norm of the VecN $\vert u \vert^p=\sum_i |u_i|^p$ More...
 
template<typename CoordinateType1 >
F32 distance (const pop::Vec< CoordinateType1 > &u, const pop::Vec< CoordinateType1 > &v, int p=2)
 distance between two vectors $\vert u-v \vert^p$ More...
 
template<typename T1 >
pop::Vec< T1 > round (const pop::Vec< T1 > &v1)
 round functions return the integral value nearest to x rounding half-way cases away for each coordinate More...
 
template<typename T1 >
pop::Vec< T1 > maximum (const pop::Vec< T1 > &v1, const pop::Vec< T1 > &v2)
 maximum of VecN v1 by the VecN v2 $\min(v1,v2)=(\min(v1_0,v2_0),\min(v1_1,v2_1))$ for each coordinate More...
 
template<typename T1 >
pop::Vec< T1 > minimum (const pop::Vec< T1 > &v1, const pop::Vec< T1 > &v2)
 minimum of VecN u by the vector v $\max(v1,v2)=(\max(v1_0,v2_0),\max(v1_1,v2_1))$ for each coordinate More...
 
template<typename T1 >
F32 productInner (const pop::Vec< T1 > &v1, const pop::Vec< T1 > &v2)
 
template<typename T1 >
std::ostream & operator<< (std::ostream &out, const pop::Vec< T1 > &m)
 
template<typename T1 >
std::istream & operator>> (std::istream &in, pop::Vec< T1 > &m)
 
template<int Dim1, int Dim2, typename PixelType >
MatN< Dim1+Dim2, PixelType > productTensoriel (const MatN< Dim1, PixelType > &f, const MatN< Dim2, PixelType > &g)
 
template<int Dim, typename PixelType >
MatN< Dim, PixelType > operator* (PixelType value, const MatN< Dim, PixelType > &f)
 
template<int Dim, typename PixelType >
MatN< Dim, PixelType > operator- (PixelType value, const MatN< Dim, PixelType > &f)
 
template<int Dim, typename PixelType >
MatN< Dim, PixelType > operator+ (PixelType value, const MatN< Dim, PixelType > &f)
 
template<int D1, int D2, typename F1 , typename F2 >
void FunctionAssert (const MatN< D1, F1 > &f, const MatN< D2, F2 > &g, std::string message)
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > minimum (const pop::MatN< Dim, PixelType > &f, const pop::MatN< Dim, PixelType > &g)
 minimum value for each VecN $h(x)=\min(f(x),g(x))$ More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > maximum (const pop::MatN< Dim, PixelType > &f, const pop::MatN< Dim, PixelType > &g)
 maximum value for each VecN $h(x)=\max(f(x),g(x))$ More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > absolute (const pop::MatN< Dim, PixelType > &f)
 absolute value for each VecN $h(x)=abs(f(x))$ More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > squareRoot (const pop::MatN< Dim, PixelType > &f)
 square value for each pixel value $h(x)=\sqrt{f(x)}$ More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > log (const pop::MatN< Dim, PixelType > &f)
 log value in e-base for each VecN h(x)=std::log(f(x)) More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > log10 (const pop::MatN< Dim, PixelType > &f)
 log value in 10-base for each pixel value h(x)=std::log10(f(x)) More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > exp (const pop::MatN< Dim, PixelType > &f)
 exponentiel value for each pixel value h(x)=std::exp(f(x)) More...
 
template<int Dim, typename PixelType >
pop::MatN< Dim, PixelType > pow (const pop::MatN< Dim, PixelType > &f, F32 exponant)
 pow value for each pixel value h(x)=std::pow(f(x),exponant) More...
 
template<int Dim, typename PixelType >
F32 normValue (const pop::MatN< Dim, PixelType > &A, int p=2)
 "Entrywise" norms normValue(A,p) = $ \Vert A \Vert_{p} = \left( \sum_{i=1}^m \sum_{j=1}^n | a_{ij} |^p \right)^{1/p}. $ More...
 
template<int Dim, typename PixelType >
F32 distance (const pop::MatN< Dim, PixelType > &A, const pop::MatN< Dim, PixelType > &B, int p=2)
 distance between two vectors $\vert u-v \vert^p$ More...
 
template<int Dim, typename PixelType >
F32 normPowerValue (const pop::MatN< Dim, PixelType > &f, int p=2)
 "Entrywise" norms normPowerValue(A,p) = $ \Vert A \Vert_{p}^p = \sum_{i=1}^m \sum_{j=1}^n | a_{ij} |^p $ More...
 
template<class PixelType >
std::ostream & operator<< (std::ostream &out, const pop::MatN< 1, PixelType > &in)
 
template<class PixelType >
std::ostream & operator<< (std::ostream &out, const pop::MatN< 2, PixelType > &in)
 
template<class PixelType >
std::ostream & operator<< (std::ostream &out, const pop::MatN< 3, PixelType > &in)
 
template<int Dim, class PixelType >
std::istream & operator>> (std::istream &in, pop::MatN< Dim, PixelType > &f)
 
template<typename T1 >
pop::MatN< 2, T1 > productTensoriel (const pop::Vec< T1 > &v1, const pop::Vec< T1 > &v2)
 tensorial product of two vector More...
 
template<typename Type1 , typename Type2 , typename FunctorAccumulatorF , typename IteratorEGlobal , typename IteratorELocal >
void forEachGlobalToLocal (const MatN< 2, Type1 > &f, MatN< 2, Type2 > &h, FunctorAccumulatorF facc, IteratorELocal it_local, typename MatN< 2, Type1 >::IteratorEDomain)
 
template<typename Type1 , typename Type2 , typename FunctorAccumulatorF , typename IteratorEGlobal , typename IteratorELocal >
void forEachGlobalToLocal (const MatN< 3, Type1 > &f, MatN< 3, Type2 > &h, FunctorAccumulatorF facc, IteratorELocal it_local, typename MatN< 3, Type1 >::IteratorEDomain)
 
template<typename Type1 , typename Type2 , typename FunctorBinaryFunctionE >
void forEachFunctorBinaryFunctionE (const MatN< 2, Type1 > &f, MatN< 2, Type2 > &h, FunctorBinaryFunctionE func, typename MatN< 2, Type1 >::IteratorEDomain it)
 
template<typename Type1 , typename Type2 , typename FunctorBinaryFunctionE >
void forEachFunctorBinaryFunctionE (const MatN< 2, Type1 > &f, MatN< 2, Type2 > &h, FunctorBinaryFunctionE func, typename MatN< 2, Type1 >::IteratorERectangle it)
 
template<typename Type1 , typename Type2 , typename FunctorBinaryFunctionE >
void forEachFunctorBinaryFunctionE (const MatN< 3, Type1 > &f, MatN< 3, Type2 > &h, FunctorBinaryFunctionE func, typename MatN< 3, Type1 >::IteratorEDomain it)
 
template<int DIM, typename PixelType , typename FunctorAccumulatorF >
FunctorAccumulatorF::ReturnType forEachFunctorAccumulator (const MatN< DIM, PixelType > &f, FunctorAccumulatorF &func, typename MatN< DIM, PixelType >::IteratorEDomain &)
 
template<int DIM, typename PixelType1 , typename PixelType2 , typename FunctorUnary_F_F >
void forEachFunctorUnaryF (const MatN< DIM, PixelType1 > &f, MatN< DIM, PixelType2 > &g, FunctorUnary_F_F &func, typename MatN< DIM, PixelType1 >::IteratorEDomain)
 
POP_EXPORTS void waitKey (std::string text="")
 
template<typename T >
int POP_EXPORTS sgn (T val)
 
std::ostream & operator<< (std::ostream &out, const NullType &)
 
std::istream & operator>> (std::istream &in, NullType &)
 

Variables

const F32 PI = 3.141592f
 
const F32 EPSILON = 0.0001f
 

Detailed Description

namespace of Population library

Function Documentation

template<class T1 >
RGB<T1> pop::operator* ( T1  v,
const RGB< T1 > &  c1 
)
Parameters
vfactor
c1RGB
Returns
output RGB

multiply all channels of the RGB c1 by the factor value

template<class T1 >
RGB<T1> pop::operator+ ( T1  v,
const RGB< T1 > &  c1 
)
Parameters
c1RGB
vfactor
Returns
output RGB

addition of all channels the factor value to all channels of the RGB c1

template<int D, class Type1 >
VecN<D, Type1> pop::operator+ ( Type1  value,
const VecN< D, Type1 > &  x 
)
inline
Parameters
xinput vector
valuefactor
Returns
output vector

addition of the factor value to all elements of the VecN u

template<typename T1 >
RGB<T1> pop::operator- ( T1  v,
const RGB< T1 > &  c1 
)
Parameters
c1RGB
vfactor
Returns
output RGB

subtraction of the factor value by all channels of the RGB c1

template<int D, class Type1 >
VecN<D, Type1> pop::operator- ( Type1  value,
const VecN< D, Type1 > &  x 
)
inline
Parameters
xinput vector
valuefactor
Returns
output VecN

Subtraction of the factor value to all elements of the VecN $(value-u_1,value-u_2) $

template<class T1 >
RGB<T1> pop::operator/ ( T1  v,
const RGB< T1 > &  c1 
)
Parameters
c1RGB
vfactor
Returns
output RGB

divide the factor value by all channels of the RGB c1