Image Component Library (ICL)
DynMatrixUtils.h
Go to the documentation of this file.
1 /********************************************************************
2 ** Image Component Library (ICL) **
3 ** **
4 ** Copyright (C) 2006-2013 CITEC, University of Bielefeld **
5 ** Neuroinformatics Group **
6 ** Website: www.iclcv.org and **
7 ** http://opensource.cit-ec.de/projects/icl **
8 ** **
9 ** File : ICLMath/src/ICLMath/DynMatrixUtils.h **
10 ** Module : ICLMath **
11 ** Authors: Christof Elbrechter, Daniel Dornbusch **
12 ** **
13 ** **
14 ** GNU LESSER GENERAL PUBLIC LICENSE **
15 ** This file may be used under the terms of the GNU Lesser General **
16 ** Public License version 3.0 as published by the **
17 ** **
18 ** Free Software Foundation and appearing in the file LICENSE.LGPL **
19 ** included in the packaging of this file. Please review the **
20 ** following information to ensure the license requirements will **
21 ** be met: http://www.gnu.org/licenses/lgpl-3.0.txt **
22 ** **
23 ** The development of this software was supported by the **
24 ** Excellence Cluster EXC 277 Cognitive Interaction Technology. **
25 ** The Excellence Cluster EXC 277 is a grant of the Deutsche **
26 ** Forschungsgemeinschaft (DFG) in the context of the German **
27 ** Excellence Initiative. **
28 ** **
29 ********************************************************************/
30 
31 #pragma once
32 
33 #include <ICLUtils/CompatMacros.h>
34 #include <ICLMath/DynMatrix.h>
35 #include <ICLUtils/BasicTypes.h>
36 #include <algorithm>
37 
38 namespace icl{
39  namespace math{
40 
43 
60  template<class T, class Init>
61  inline DynMatrix<T> &matrix_init(DynMatrix<T> &m, Init init){
62  std::fill(m.begin(),m.end(),init);
63  return m;
64  }
65 
67 
68  template<class T> ICLMath_IMP
69  DynMatrix<T> &matrix_abs(DynMatrix<T> &m);
70 
72 
73  template<class T> ICLMath_IMP
74  DynMatrix<T> &matrix_abs(const DynMatrix<T> &m, DynMatrix<T> &dst);
75 
77 
78  template<class T> ICLMath_IMP
79  DynMatrix<T> &matrix_log(DynMatrix<T> &m);
80 
82 
83  template<class T> ICLMath_IMP
84  DynMatrix<T> &matrix_log(const DynMatrix<T> &m, DynMatrix<T> &dst);
85 
87 
88  template<class T> ICLMath_IMP
89  DynMatrix<T> &matrix_exp(DynMatrix<T> &m);
90 
92 
93  template<class T> ICLMath_IMP
94  DynMatrix<T> &matrix_exp(const DynMatrix<T> &m, DynMatrix<T> &dst);
95 
97 
98  template<class T> ICLMath_IMP
99  DynMatrix<T> &matrix_sqrt(DynMatrix<T> &m);
100 
102 
103  template<class T> ICLMath_IMP
104  DynMatrix<T> &matrix_sqrt(const DynMatrix<T> &m, DynMatrix<T> &dst);
105 
107 
108  template<class T> ICLMath_IMP
109  DynMatrix<T> &matrix_sqr(DynMatrix<T> &m);
110 
112 
113  template<class T> ICLMath_IMP
114  DynMatrix<T> &matrix_sqr(const DynMatrix<T> &m, DynMatrix<T> &dst);
115 
117 
118  template<class T> ICLMath_IMP
119  DynMatrix<T> &matrix_sin(DynMatrix<T> &m);
120 
122 
123  template<class T> ICLMath_IMP
124  DynMatrix<T> &matrix_sin(const DynMatrix<T> &m, DynMatrix<T> &dst);
125 
127 
128  template<class T> ICLMath_IMP
129  DynMatrix<T> &matrix_cos(DynMatrix<T> &m);
130 
132 
133  template<class T> ICLMath_IMP
134  DynMatrix<T> &matrix_cos(const DynMatrix<T> &m, DynMatrix<T> &dst);
135 
137 
138  template<class T> ICLMath_IMP
139  DynMatrix<T> &matrix_tan(DynMatrix<T> &m);
140 
142 
143  template<class T> ICLMath_IMP
144  DynMatrix<T> &matrix_tan(const DynMatrix<T> &m, DynMatrix<T> &dst);
145 
147 
148  template<class T> ICLMath_IMP
149  DynMatrix<T> &matrix_arcsin(DynMatrix<T> &m);
150 
152 
153  template<class T> ICLMath_IMP
154  DynMatrix<T> &matrix_arcsin(const DynMatrix<T> &m, DynMatrix<T> &dst);
155 
157 
158  template<class T> ICLMath_IMP
159  DynMatrix<T> &matrix_arccos(DynMatrix<T> &m);
160 
162 
163  template<class T> ICLMath_IMP
164  DynMatrix<T> &matrix_arccos(const DynMatrix<T> &m, DynMatrix<T> &dst);
165 
167 
168  template<class T> ICLMath_IMP
169  DynMatrix<T> &matrix_arctan(DynMatrix<T> &m);
170 
172 
173  template<class T> ICLMath_IMP
174  DynMatrix<T> &matrix_arctan(const DynMatrix<T> &m, DynMatrix<T> &dst);
175 
177 
178  template<class T> ICLMath_IMP
179  DynMatrix<T> &matrix_reciprocal(DynMatrix<T> &m);
180 
182 
183  template<class T> ICLMath_IMP
184  DynMatrix<T> &matrix_reciprocal(const DynMatrix<T> &m, DynMatrix<T> &dst);
185 
188 
190  template<class T> ICLMath_IMP
191  DynMatrix<T> &matrix_powc(DynMatrix<T> &m, T exponent);
192 
194 
195  template<class T> ICLMath_IMP
196  DynMatrix<T> &matrix_powc(const DynMatrix<T> &m, T exponent, DynMatrix<T> &dst);
197 
199 
200  template<class T> ICLMath_IMP
201  DynMatrix<T> &matrix_addc(DynMatrix<T> &m, T val);
202 
204 
205  template<class T> ICLMath_IMP
206  DynMatrix<T> &matrix_addc(const DynMatrix<T> &m, T val, DynMatrix<T> &dst);
207 
209 
210  template<class T> ICLMath_IMP
211  DynMatrix<T> &matrix_subc(DynMatrix<T> &m, T val);
212 
214 
215  template<class T> ICLMath_IMP
216  DynMatrix<T> &matrix_subc(const DynMatrix<T> &m, T val, DynMatrix<T> &dst);
217 
219 
220  template<class T> ICLMath_IMP
221  DynMatrix<T> &matrix_divc(DynMatrix<T> &m, T val);
222 
224 
225  template<class T> ICLMath_IMP
226  DynMatrix<T> &matrix_divc(const DynMatrix<T> &m, T val, DynMatrix<T> &dst);
227 
229 
230  template<class T> ICLMath_IMP
231  DynMatrix<T> &matrix_mulc(DynMatrix<T> &m, T val);
232 
234 
235  template<class T> ICLMath_IMP
236  DynMatrix<T> &matrix_mulc(const DynMatrix<T> &m, T val, DynMatrix<T> &dst);
237 
240 
242  template<class T> ICLMath_IMP
243  DynMatrix<T> &matrix_arctan2(const DynMatrix<T> &my, const DynMatrix<T> &mx, DynMatrix<T> &dst)
244  ;
245 
247 
248  template<class T> ICLMath_IMP
249  DynMatrix<T> &matrix_add(const DynMatrix<T> &m1, const DynMatrix<T> &m2, DynMatrix<T> &dst)
250  ;
251 
253 
254  template<class T> ICLMath_IMP
255  DynMatrix<T> &matrix_sub(const DynMatrix<T> &m1, const DynMatrix<T> &m2, DynMatrix<T> &dst)
256  ;
257 
259 
260  template<class T> ICLMath_IMP
261  DynMatrix<T> &matrix_mul(const DynMatrix<T> &m1, const DynMatrix<T> &m2, DynMatrix<T> &dst)
262  ;
263 
265 
266  template<class T> ICLMath_IMP
267  DynMatrix<T> &matrix_div(const DynMatrix<T> &m1, const DynMatrix<T> &m2, DynMatrix<T> &dst)
268  ;
269 
271 
272  template<class T> ICLMath_IMP
273  DynMatrix<T> &matrix_pow(const DynMatrix<T> &m1, const DynMatrix<T> &m2, DynMatrix<T> &dst)
274  ;
275 
279 
283  template<class T> ICLMath_IMP
284  T matrix_distance(const DynMatrix<T> &m1, const DynMatrix<T> &m2, T norm = 2)
285  ;
286 
288 
291  template<class T> ICLMath_IMP
292  T matrix_divergence(const DynMatrix<T> &m1, const DynMatrix<T> &m2)
293  ;
294 
295 
299 
305  template<class T> ICLMath_IMP
306  T matrix_min(const DynMatrix<T> &m, int *x = 0, int *y = 0);
307 
309 
314  template<class T> ICLMath_IMP
315  T matrix_max(const DynMatrix<T> &m, int *x = 0, int *y = 0);
316 
318 
327  template<class T> ICLMath_IMP
328  void matrix_minmax(const DynMatrix<T> &m, T dst[2],
329  int *minx=0, int *miny=0,
330  int *maxx=0, int *maxy=0);
331 
332 
334 
335  template<class T> ICLMath_IMP
336  T matrix_mean(const DynMatrix<T> &m);
337 
339 
340  template<class T> ICLMath_IMP
341  T matrix_var(const DynMatrix<T> &m);
342 
344 
354  template<class T> ICLMath_IMP
355  T matrix_var(const DynMatrix<T> &m, T mean, bool empiricalMean = true);
356 
358 
361  template<class T> ICLMath_IMP
362  void matrix_meanvar(const DynMatrix<T> &m, T *mean, T*var);
363 
365 
366  template<class T> ICLMath_IMP
367  T matrix_stddev(const DynMatrix<T> &m);
368 
370 
380  template<class T> ICLMath_IMP
381  T matrix_stddev(const DynMatrix<T> &m, T mean, bool empiricalMean = true);
382 
386 
388  template<class T> ICLMath_IMP
389  DynMatrix<T> &matrix_muladd(const DynMatrix<T> &a, T alpha, const DynMatrix<T> &b, T beta, T gamma, DynMatrix<T> &dst)
390  ;
391 
393 
394  template<class T> ICLMath_IMP
395  DynMatrix<T> &matrix_muladd(const DynMatrix<T> &a, T alpha, T gamma, DynMatrix<T> &dst);
396 
398 
399  template<class T> ICLMath_IMP
400  DynMatrix<T> &matrix_mask(const DynMatrix<unsigned char> &mask, DynMatrix<T> &m)
401  ;
402 
404 
405  template<class T> ICLMath_IMP
406  DynMatrix<T> &matrix_mask(const DynMatrix<unsigned char> &mask, const DynMatrix<T> &m, DynMatrix<T> &dst)
407  ;
408 
414  enum transposedDef{
416  NONE_T=0,
417  SRC1_T=1<<0,
418  SRC2_T=1<<1,
419  BOTH_T=SRC1_T | SRC2_T,
420  };
421 
423 
434  template<class T> ICLMath_IMP
435  DynMatrix<T> &matrix_mult_t(const DynMatrix<T> &src1, const DynMatrix<T> &src2, DynMatrix<T> &dst, int transpDef)
436  ;
437 
439 
450  template<class T> ICLMath_IMP
451  DynMatrix<T> &big_matrix_mult_t(const DynMatrix<T> &src1, const DynMatrix<T> &src2, DynMatrix<T> &dst, int transpDef)
452  ;
453 
455  template<class T> ICLMath_IMP
456  DynMatrix<T> &matrix_add_t(const DynMatrix<T> &src1, const DynMatrix<T> &src2, DynMatrix<T> &dst, int transpDef)
457  ;
458 
460  template<class T> ICLMath_IMP
461  DynMatrix<T> &matrix_sub_t(const DynMatrix<T> &src1, const DynMatrix<T> &src2, DynMatrix<T> &dst, int transpDef)
462  ;
463 
466 
473  template<class T> ICLMath_IMP
474  void svd_dyn(const DynMatrix<T> &A, DynMatrix<T> &U, DynMatrix<T> &S, DynMatrix<T> &V) ;
475 
476 
477  #if 0
478  U.setBounds(A.cols(), A.rows());
479  V.setBounds(A.cols(), A.cols());
480  s.setBounds(1,A.cols());
481  DynMatrix<icl64f> A64f(A.cols(),A.rows()),U64f(U.cols(),U.rows()),s64f(1,s.rows()),V64f(V.cols(),V.rows());
482  std::copy(A.begin(),A.end(),A64f.begin());
483 
484  svd_cpp_64f(A64f,U64f,s64f,V64f);
485 
486  std::copy(U64f.begin(),U64f.end(),U.begin());
487  std::copy(V64f.begin(),V64f.end(),V.begin());
488  std::copy(s64f.begin(),s64f.end(),s.begin());
489  }
490 
492  // SVD specialization for direct call to 64f function in order to avoid unnecessary double to double conversion before hand
493  template<> inline void svd_dyn<icl64f>(const DynMatrix<icl64f> &A, DynMatrix<icl64f> &U, DynMatrix<icl64f> &s, DynMatrix<icl64f> &V) {
494  U.setBounds(A.cols(), A.rows());
495  V.setBounds(A.cols(), A.cols());
496  s.setBounds(1,A.cols());
497 
498  svd_cpp_64f(A,U,s,V);
499  }
502  #endif
503 
506  } // namespace math
507 }
icl::math::matrix_mean
ICLMath_IMP T matrix_mean(const DynMatrix< T > &m)
calculate matrix mean value [IPP-optimized]
icl::math::SRC1_T
Definition: DynMatrixUtils.h:417
icl
undocument this line if you encounter any issues!
Definition: Any.h:37
icl::math::matrix_init
DynMatrix< T > & matrix_init(DynMatrix< T > &m, Init init)
Matrix initialization template.
Definition: DynMatrixUtils.h:61
icl::qt::norm
ICLQt_API core::Img< T > norm(const core::Img< T > &image)
normalize an images range to [0,255]
icl::math::matrix_arcsin
ICLMath_IMP DynMatrix< T > & matrix_arcsin(DynMatrix< T > &m)
element-wise arcus sinus-function (inplace)
icl::math::matrix_minmax
ICLMath_IMP 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]
icl::math::matrix_pow
ICLMath_IMP DynMatrix< T > & matrix_pow(const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst)
element-wise power
icl::math::matrix_sqrt
ICLMath_IMP DynMatrix< T > & matrix_sqrt(DynMatrix< T > &m)
element-wise square-root-function (inplace) [IPP-optimized]
icl::math::matrix_sqr
ICLMath_IMP DynMatrix< T > & matrix_sqr(DynMatrix< T > &m)
element-wise square-function (x*x) (inplace) [IPP-optimized]
icl::math::mean
double mean(ForwardIterator begin, ForwardIterator end)
computes the mean value of a data range
Definition: MathFunctions.h:78
icl::math::DynMatrix
Highly flexible and optimized matrix class implementation.
Definition: DynMatrix.h:81
icl::math::matrix_mulc
ICLMath_IMP DynMatrix< T > & matrix_mulc(DynMatrix< T > &m, T val)
element-wise multiplication with constant value (inplace) [IPP-optimized]
icl::math::matrix_arctan
ICLMath_IMP DynMatrix< T > & matrix_arctan(DynMatrix< T > &m)
element-wise arcus tangent-function (inplace)
icl::math::DynMatrix::begin
iterator begin()
returns an iterator to the begin of internal data array
Definition: DynMatrix.h:751
icl::math::matrix_arctan2
ICLMath_IMP DynMatrix< T > & matrix_arctan2(const DynMatrix< T > &my, const DynMatrix< T > &mx, DynMatrix< T > &dst)
element-wise atan2 function atan2(y,x)
icl::math::matrix_reciprocal
ICLMath_IMP DynMatrix< T > & matrix_reciprocal(DynMatrix< T > &m)
element-wise reciprocal-function (1/x) (inplace)
icl::math::matrix_mask
ICLMath_IMP DynMatrix< T > & matrix_mask(const DynMatrix< unsigned char > &mask, DynMatrix< T > &m)
applies masking operation (m(i,j) is set to 0 if mask(i,j) is 0) (inplace)
icl::math::matrix_muladd
ICLMath_IMP DynMatrix< T > & matrix_muladd(const DynMatrix< T > &a, T alpha, const DynMatrix< T > &b, T beta, T gamma, DynMatrix< T > &dst)
computes alpha*a + beta*b + gamma
icl::math::matrix_powc
ICLMath_IMP DynMatrix< T > & matrix_powc(DynMatrix< T > &m, T exponent)
element-wise power-function (x^exponent) (inplace)
icl::math::matrix_var
ICLMath_IMP T matrix_var(const DynMatrix< T > &m)
calculate matrix variance [IPP-optimized]
icl::math::transposedDef
transposedDef
special utility type for definition of transposed states for matrices
Definition: DynMatrixUtils.h:415
icl::math::matrix_tan
ICLMath_IMP DynMatrix< T > & matrix_tan(DynMatrix< T > &m)
element-wise tangent-function (inplace)
icl::math::matrix_divc
ICLMath_IMP DynMatrix< T > & matrix_divc(DynMatrix< T > &m, T val)
element-wise division by constant value (inplace) [IPP-optimized]
icl::math::matrix_div
ICLMath_IMP DynMatrix< T > & matrix_div(const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst)
element-wise division [IPP-optimized]
icl::math::matrix_sub
ICLMath_IMP DynMatrix< T > & matrix_sub(const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst)
element-wise substraction [IPP-optimized]
icl::math::matrix_meanvar
ICLMath_IMP void matrix_meanvar(const DynMatrix< T > &m, T *mean, T *var)
computes matrix mean and variance at once [IPP-optimized]
icl::qt::fill
ICLQt_API void fill(float r, float g=-1, float b=-1, float alpha=255)
sets the current fill color to given r,g,b,alpha value
icl::math::matrix_add
ICLMath_IMP DynMatrix< T > & matrix_add(const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst)
element-wise addition [IPP-optimized]
icl::math::matrix_sin
ICLMath_IMP DynMatrix< T > & matrix_sin(DynMatrix< T > &m)
element-wise sinus-function (x*x) (inplace)
icl::math::NONE_T
Definition: DynMatrixUtils.h:416
icl::math::matrix_divergence
ICLMath_IMP T matrix_divergence(const DynMatrix< T > &m1, const DynMatrix< T > &m2)
computes generalized Kullback-Leibler-divergence between matrix vectors
icl::math::SRC2_T
Definition: DynMatrixUtils.h:418
icl::math::DynMatrix::end
iterator end()
returns an iterator to the end of internal data array
Definition: DynMatrix.h:754
icl::math::BOTH_T
Definition: DynMatrixUtils.h:419
icl::math::matrix_arccos
ICLMath_IMP DynMatrix< T > & matrix_arccos(DynMatrix< T > &m)
element-wise arcus cosinus-function (inplace)
icl::math::big_matrix_mult_t
ICLMath_IMP DynMatrix< T > & big_matrix_mult_t(const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef)
applies matrix mutliplication on optionally transposed matrices (specialized for big matrices)
icl::math::svd_dyn
ICLMath_IMP void svd_dyn(const DynMatrix< T > &A, DynMatrix< T > &U, DynMatrix< T > &S, DynMatrix< T > &V)
SVD function - decomposes A into USV' (only icl32f and icl64f)
icl::math::matrix_min
ICLMath_IMP T matrix_min(const DynMatrix< T > &m, int *x=0, int *y=0)
find minimum element of matrix (optionally find location too) [IPP-optimized]
icl::math::matrix_distance
ICLMath_IMP T matrix_distance(const DynMatrix< T > &m1, const DynMatrix< T > &m2, T norm=2)
computes norm between matrix vectors
icl::math::matrix_abs
ICLMath_IMP DynMatrix< T > & matrix_abs(DynMatrix< T > &m)
element-wise absolute value (inplace) [IPP-optimized]
ICLMath_IMP
#define ICLMath_IMP
Definition: CompatMacros.h:172
icl::math::matrix_mul
ICLMath_IMP DynMatrix< T > & matrix_mul(const DynMatrix< T > &m1, const DynMatrix< T > &m2, DynMatrix< T > &dst)
element-wise multiplication [IPP-optimized]
icl::math::matrix_exp
ICLMath_IMP DynMatrix< T > & matrix_exp(DynMatrix< T > &m)
element-wise exp-function (inplace) [IPP-optimized]
icl::math::matrix_sub_t
ICLMath_IMP DynMatrix< T > & matrix_sub_t(const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef)
applies matrix substraction on optionally transposed matrices
icl::math::matrix_stddev
ICLMath_IMP T matrix_stddev(const DynMatrix< T > &m)
computes matrix standard deviation (sqrt(var)) [IPP-optimized]
icl::core::copy
void copy(const T *src, const T *srcEnd, T *dst)
moves data from source to destination array (no casting possible)
Definition: CoreFunctions.h:216
icl::math::matrix_addc
ICLMath_IMP DynMatrix< T > & matrix_addc(DynMatrix< T > &m, T val)
element-wise addition of constant value (inplace) [IPP-optimized]
icl::math::matrix_log
ICLMath_IMP DynMatrix< T > & matrix_log(DynMatrix< T > &m)
element-wise logarith (basis E) (inplace) [IPP-optimized]
icl::math::matrix_cos
ICLMath_IMP DynMatrix< T > & matrix_cos(DynMatrix< T > &m)
element-wise cosinus-function (inplace)
icl::math::matrix_max
ICLMath_IMP T matrix_max(const DynMatrix< T > &m, int *x=0, int *y=0)
find maximum element of matrix (optionally find location too) [IPP-optimized]
icl::math::matrix_subc
ICLMath_IMP DynMatrix< T > & matrix_subc(DynMatrix< T > &m, T val)
element-wise substraction of constant value (inplace) [IPP-optimized]
icl::math::matrix_add_t
ICLMath_IMP DynMatrix< T > & matrix_add_t(const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef)
applies matrix addition on optionally transposed matrices
icl::math::matrix_mult_t
ICLMath_IMP DynMatrix< T > & matrix_mult_t(const DynMatrix< T > &src1, const DynMatrix< T > &src2, DynMatrix< T > &dst, int transpDef)
applies matrix mutliplication on optionally transposed matrices
Generated on Mon May 20 2019 12:00:16 for Image Component Library (ICL) by   doxygen 1.8.15