Namespaces |
namespace | fft |
Classes |
struct | InvalidMatrixDimensionException |
| Special linear algebra exception type \. More...
|
struct | IncompatibleMatrixDimensionException |
| Special linear algebra exception type \. More...
|
struct | InvalidIndexException |
| Special linear algebra exception type \. More...
|
struct | SingularMatrixException |
| Special linear algebra exception type \. More...
|
struct | DynMatrix |
| Highly flexible and optimized matrix class implementation. More...
|
struct | DynColVector |
| Extension class for the DynMatrix<T> template, that restricts the the matrix column count to 'one'. More...
|
struct | DynRowVector |
class | FFTException |
| Special exception implementation for the FFT package. More...
|
struct | FixedMatrixBase |
| FixedMatrix base struct defining datamode enum. More...
|
class | FixedMatrixPart |
| Utility struct for FixedMatrix sub-parts. More...
|
class | FixedMatrix |
| Powerful and highly flexible matrix class implementation. More...
|
struct | FixedColVector |
struct | FixedRowVector |
struct | GenericHomography2D |
| Utility structure that represents a 2D homography (implemented for float and double) More...
|
class | KDTree |
| Simple KD-Tree implementation. More...
|
class | KMeans |
| Generic Implementation of the K-Means algorithm. More...
|
class | LeastSquareModelFitting |
| Direct Least Square Fitting Algorithm. More...
|
class | LeastSquareModelFitting2D |
| Direct Least Square Fitting specialization for 2D input data. More...
|
class | LevenbergMarquardtFitter |
| Utility class implementing the multidimensional Levenberg Marquardt Algorithm for non-linear Optimization. More...
|
struct | LinearTransform1D |
| A standard linear mapping class for the 1D case f(x) = m * x + b. More...
|
class | LLM |
| Local Linear Map implementation (LLM) More...
|
class | MatrixSubRectIterator |
| Iterator class used to iterate through a sub rect of 2D data. More...
|
class | Octree |
| Generic Octree Implementation. More...
|
class | PolynomialRegression |
| Generic Implementation of the Polynomial Regression algorithm. More...
|
class | QuadTree |
| Generic QuadTree Implementation. More...
|
class | RansacFitter |
| Generic RANSAC (RAndom SAmpling Consensus) Implementation. More...
|
struct | SimplexOptimizationResult |
| Utility structure, that is used as accumulator for results of the SimplexOptimizer class. More...
|
class | SimplexOptimizer |
| Template based implementation for the Downhill Simplex Optimiztation method. More...
|
class | SOM |
| Generic implementation of D to K dim Self Organizing Map (SOM) More...
|
class | SOM2D |
| Simple Wrapper class of the generic SOM Implementation for 2D SOMs. More...
|
struct | StochasticOptimizerResult |
| Utility structure for the stochastic optimizer class. More...
|
class | StochasticOptimizer |
| The StochasticOptimizer is a tiny frame-work for simple stochastic optimization processes. More...
|
struct | StraightLine2D |
| A straight line is parameterized in offset/direction form. More...
|
Typedefs |
typedef GenericHomography2D
< float > | Homography2D |
| default homography 2D type definition (usually fload depth is enough)
|
Functions |
template<class T > |
std::ostream & | operator<< (std::ostream &s, const DynMatrix< T > &m) |
| ostream operator implemented for uchar, short, int, float and double matrices
|
template<class T > |
std::istream & | operator>> (std::istream &s, DynMatrix< T > &m) |
| istream operator implemented for uchar, short, int, float and double matrices
|
template<class T > |
DynMatrix< T > | operator, (const DynMatrix< T > &left, const DynMatrix< T > &right) |
| vertical concatenation of matrices
|
template<class T > |
DynMatrix< T > | operator% (const DynMatrix< T > &top, const DynMatrix< T > &bottom) |
| horizontal concatenation of matrices
|
template<class T , class Init > |
DynMatrix< T > & | matrix_init (DynMatrix< T > &m, Init init) |
| Matrix initialization template.
|
template<class T > |
DynMatrix< T > & | matrix_abs (DynMatrix< T > &m) |
| element-wise absolute value (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_abs (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise absolute value [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_log (DynMatrix< T > &m) |
| element-wise logarith (basis E) (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_log (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise logarith (basis E) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_exp (DynMatrix< T > &m) |
| element-wise exp-function (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_exp (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise exp-function [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_sqrt (DynMatrix< T > &m) |
| element-wise square-root-function (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_sqrt (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise square-root-function [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_sqr (DynMatrix< T > &m) |
| element-wise square-function (x*x) (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_sqr (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise square-function (x*x) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_sin (DynMatrix< T > &m) |
| element-wise sinus-function (x*x) (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_sin (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise sinus-function (x*x)
|
template<class T > |
DynMatrix< T > & | matrix_cos (DynMatrix< T > &m) |
| element-wise cosinus-function (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_cos (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise cosinus-function
|
template<class T > |
DynMatrix< T > & | matrix_tan (DynMatrix< T > &m) |
| element-wise tangent-function (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_tan (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise tangent-function
|
template<class T > |
DynMatrix< T > & | matrix_arcsin (DynMatrix< T > &m) |
| element-wise arcus sinus-function (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_arcsin (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise arcus sinus-function
|
template<class T > |
DynMatrix< T > & | matrix_arccos (DynMatrix< T > &m) |
| element-wise arcus cosinus-function (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_arccos (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise arcus cosinus-function
|
template<class T > |
DynMatrix< T > & | matrix_arctan (DynMatrix< T > &m) |
| element-wise arcus tangent-function (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_arctan (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise arcus tangent-function
|
template<class T > |
DynMatrix< T > & | matrix_reciprocal (DynMatrix< T > &m) |
| element-wise reciprocal-function (1/x) (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_reciprocal (const DynMatrix< T > &m, DynMatrix< T > &dst) |
| element-wise reciprocal-function (1/x)
|
template<class T > |
DynMatrix< T > & | matrix_powc (DynMatrix< T > &m, T exponent) |
| element-wise power-function (x^exponent) (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_powc (const DynMatrix< T > &m, T exponent, DynMatrix< T > &dst) |
| element-wise power-function (x^exponent)
|
template<class T > |
DynMatrix< T > & | matrix_addc (DynMatrix< T > &m, T val) |
| element-wise addition of constant value (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_addc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst) |
| element-wise addition of constant value [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_subc (DynMatrix< T > &m, T val) |
| element-wise substraction of constant value (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_subc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst) |
| element-wise substraction of constant value [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_divc (DynMatrix< T > &m, T val) |
| element-wise division by constant value (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_divc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst) |
| element-wise division by constant value [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_mulc (DynMatrix< T > &m, T val) |
| element-wise multiplication with constant value (inplace) [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_mulc (const DynMatrix< T > &m, T val, DynMatrix< T > &dst) |
| element-wise multiplication with constant value [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_arctan2 (const DynMatrix< T > &my, const DynMatrix< T > &mx, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| element-wise atan2 function atan2(y,x)
|
template<class T > |
DynMatrix< T > & | matrix_add (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| element-wise addition [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_sub (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| element-wise substraction [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_mul (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| element-wise multiplication [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_div (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| element-wise division [IPP-optimized]
|
template<class T > |
DynMatrix< T > & | matrix_pow (const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| element-wise power
|
template<class T > |
void | svd_dyn (const DynMatrix< T > &A, DynMatrix< T > &U, DynMatrix< T > &S, DynMatrix< T > &V) throw (utils::ICLException) |
| SVD function - decomposes A into USV' (only icl32f and icl64f)
|
template<class T , unsigned int WIDTH, unsigned int HEIGHT, unsigned int HEIGHT2> |
FixedMatrix< T, WIDTH, HEIGHT+HEIGHT2 > | operator% (const FixedMatrix< T, WIDTH, HEIGHT > &a, const FixedMatrix< T, WIDTH, HEIGHT2 > &b) |
| Vertical Matrix concatenation.
|
template<class T , unsigned int WIDTH, unsigned int HEIGHT, unsigned int WIDTH2> |
FixedMatrix< T, WIDTH+WIDTH2,
HEIGHT > | operator, (const FixedMatrix< T, WIDTH, HEIGHT > &a, const FixedMatrix< T, WIDTH2, HEIGHT > &b) |
| Horizontal Matrix concatenation.
|
template<class T , unsigned int M_ROWS_AND_COLS, unsigned int V_COLS> |
FixedMatrix< T, V_COLS,
M_ROWS_AND_COLS > & | operator*= (FixedMatrix< T, V_COLS, M_ROWS_AND_COLS > &v, const FixedMatrix< T, M_ROWS_AND_COLS, M_ROWS_AND_COLS > &m) |
| Matrix multiplication (inplace)
|
template<class T , unsigned int COLS, unsigned int ROWS> |
std::ostream & | operator<< (std::ostream &s, const FixedMatrix< T, COLS, ROWS > &m) |
| put the matrix into a std::ostream (human readable)
|
template<class T , unsigned int COLS, unsigned int ROWS> |
std::istream & | operator>> (std::istream &s, FixedMatrix< T, COLS, ROWS > &m) |
| read matrix from std::istream (human readable)
|
template<class T > |
FixedMatrix< T, 2, 2 > | create_rot_2D (T angle) |
| creates a 2D rotation matrix (defined for float and double)
|
template<class T > |
FixedMatrix< T, 3, 3 > | create_hom_3x3 (T angle, T dx=0, T dy=0, T v0=0, T v1=0) |
| creates a 2D homogen matrix (defined for float and double)
|
template<class T > |
FixedMatrix< T, 3, 3 > | create_hom_3x3_trans (T dx, T dy) |
| creates a 2D homogen matrix with translation part only (defined for float and double)
|
template<class T > |
FixedMatrix< T, 3, 3 > | create_rot_3D (T axisX, T axisY, T axisZ, T angle) |
| create 3D rotation matrix that rotates about given axis by given angle (float and double only)
|
template<class T > |
FixedMatrix< T, 3, 3 > | create_rot_3D (T rx, T ry, T rz) |
| creates a 3D rotation matrix (defined for float and double)
|
template<class T > |
FixedMatrix< T, 4, 4 > | create_hom_4x4 (T rx, T ry, T rz, T dx=0, T dy=0, T dz=0, T v0=0, T v1=0, T v2=0) |
| creates a 3D homogeneous matrix (defined for float and double)
|
template<class T > |
FixedMatrix< T, 4, 4 > | create_rot_4x4 (T axisX, T axisY, T axisZ, T angle) |
| create 4D homogeneous matrix that rotates about given axis by given angle float and double only)
|
template<class T > |
FixedMatrix< T, 4, 4 > | create_hom_4x4_trans (T dx, T dy, T dz) |
| creates a 3D homogen matrix with translation part only (defined for float and double)
|
template<class T , unsigned int COLS, unsigned int ROWS> |
FixedMatrix< T, 1, 3 > | extract_euler_angles (const FixedMatrix< T, COLS, ROWS > &m) throw (InvalidMatrixDimensionException) |
| extracts the euler angles from the given rotation matrix
|
| OPTIMIZED_MATRIX_MULTIPLICATION (2, 2, 2, float, 32f) |
| OPTIMIZED_MATRIX_MULTIPLICATION (3, 3, 3, float, 32f) |
| OPTIMIZED_MATRIX_MULTIPLICATION (4, 4, 4, float, 32f) |
| OPTIMIZED_MATRIX_MULTIPLICATION (2, 2, 2, double, 64f) |
| OPTIMIZED_MATRIX_MULTIPLICATION (3, 3, 3, double, 64f) |
| OPTIMIZED_MATRIX_MULTIPLICATION (4, 4, 4, double, 64f) |
template<class ForwardIterator > |
float | euclidian (ForwardIterator v1Begin, ForwardIterator v1End, ForwardIterator v2Begin) |
| Calculate the euclidian distance of two vectors v1 and v2.
|
template<class T > |
float | euclidian (const std::vector< T > &a, const std::vector< T > &b) |
| Calculate the euclidian distance of points a and b.
|
template<class ForwardIterator > |
double | mean (ForwardIterator begin, ForwardIterator end) |
| computes the mean value of a data range
|
template<class ForwardIterator > |
double | variance (ForwardIterator begin, ForwardIterator end, double mean, bool empiricMean=true) |
| Compute the variance of a given data range with given mean value.
|
template<class ForwardIterator > |
double | variance (ForwardIterator begin, ForwardIterator end) |
| Compute the variance of a given data range.
|
template<class ForwardIterator > |
double | stdDeviation (ForwardIterator begin, ForwardIterator end, double mean, bool empiricMean=true) |
| Compute std-deviation of a data set with given mean (calls sqrt(variance(..))
|
template<class ForwardIterator > |
double | stdDeviation (ForwardIterator begin, ForwardIterator end) |
| Compute std-deviation of a data set.
|
template<class ForwardIterator > |
std::pair< double, double > | meanAndStdDev (ForwardIterator begin, ForwardIterator end) |
| Calculates mean and standard deviation of given data range simultanously.
|
matrix distance measurement |
template<class T > |
T | matrix_distance (const DynMatrix< T > &m1, const DynMatrix< T > &m2, T norm=2) throw (IncompatibleMatrixDimensionException) |
| computes norm between matrix vectors
|
template<class T > |
T | matrix_divergence (const DynMatrix< T > &m1, const DynMatrix< T > &m2) throw (IncompatibleMatrixDimensionException) |
| computes generalized Kullback-Leibler-divergence between matrix vectors
|
statistical functions |
template<class T > |
T | matrix_min (const DynMatrix< T > &m, int *x=0, int *y=0) |
| find minimum element of matrix (optionally find location too) [IPP-optimized]
|
template<class T > |
T | matrix_max (const DynMatrix< T > &m, int *x=0, int *y=0) |
| find maximum element of matrix (optionally find location too) [IPP-optimized]
|
template<class T > |
void | matrix_minmax (const DynMatrix< T > &m, T dst[2], int *minx=0, int *miny=0, int *maxx=0, int *maxy=0) |
| find min- and maxinim element at once (optionally with locations) [IPP-optimized]
|
template<class T > |
T | matrix_mean (const DynMatrix< T > &m) |
| calculate matrix mean value [IPP-optimized]
|
template<class T > |
T | matrix_var (const DynMatrix< T > &m) |
| calculate matrix variance [IPP-optimized]
|
template<class T > |
T | matrix_var (const DynMatrix< T > &m, T mean, bool empiricalMean=true) |
| calculate matrix variance with given mean
|
template<class T > |
void | matrix_meanvar (const DynMatrix< T > &m, T *mean, T *var) |
| computes matrix mean and variance at once [IPP-optimized]
|
template<class T > |
T | matrix_stddev (const DynMatrix< T > &m) |
| computes matrix standard deviation (sqrt(var)) [IPP-optimized]
|
template<class T > |
T | matrix_stddev (const DynMatrix< T > &m, T mean, bool empiricalMean=true) |
| calculate matrix standard deviation with given mean
|
other functions ... |
template<class T > |
DynMatrix< T > & | matrix_muladd (const DynMatrix< T > &a, T alpha, const DynMatrix< T > &b, T beta, T gamma, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| computes alpha*a + beta*b + gamma
|
template<class T > |
DynMatrix< T > & | matrix_muladd (const DynMatrix< T > &a, T alpha, T gamma, DynMatrix< T > &dst) |
| computes alpha*a + gamma
|
template<class T > |
DynMatrix< T > & | matrix_mask (const DynMatrix< unsigned char > &mask, DynMatrix< T > &m) throw (IncompatibleMatrixDimensionException) |
| applies masking operation (m(i,j) is set to 0 if mask(i,j) is 0) (inplace)
|
template<class T > |
DynMatrix< T > & | matrix_mask (const DynMatrix< unsigned char > &mask, const DynMatrix< T > &m, DynMatrix< T > &dst) throw (IncompatibleMatrixDimensionException) |
| applies masking operation (m(i,j) is set to 0 if mask(i,j) is 0)
|
special functions for transposed matrices ... |
enum | transposedDef { NONE_T = 0,
SRC1_T = 1<<0,
SRC2_T = 1<<1,
BOTH_T = SRC1_T | SRC2_T
} |
| special utility type for definition of transposed states for matrices More...
|
template<class T > |
DynMatrix< T > & | matrix_mult_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException) |
| applies matrix mutliplication on optionally transposed matrices
|
template<class T > |
DynMatrix< T > & | big_matrix_mult_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException) |
| applies matrix mutliplication on optionally transposed matrices (specialized for big matrices)
|
template<class T > |
DynMatrix< T > & | matrix_add_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException) |
| applies matrix addition on optionally transposed matrices
|
template<class T > |
DynMatrix< T > & | matrix_sub_t (const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef) throw (IncompatibleMatrixDimensionException) |
| applies matrix substraction on optionally transposed matrices
|