Wondercoll
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
cxmisc.h
Go to the documentation of this file.
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41 
42 /* The header is mostly for internal use and it is likely to change.
43  It contains some macro definitions that are used in cxcore, cv, cvaux
44  and, probably, other libraries. If you need some of this functionality,
45  the safe way is to copy it into your code and rename the macros.
46 */
47 #ifndef _CXCORE_MISC_H_
48 #define _CXCORE_MISC_H_
49 
50 #ifdef HAVE_CONFIG_H
51  #include "cvconfig.h"
52 #endif
53 
54 #include <limits.h>
55 #ifdef _OPENMP
56 #include "omp.h"
57 #endif
58 
59 /****************************************************************************************\
60 * Compile-time tuning parameters *
61 \****************************************************************************************/
62 
63 /* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */
64 #define CV_MAX_INLINE_MAT_OP_SIZE 10
65 
66 /* maximal linear size of matrix to allocate it on stack. */
67 #define CV_MAX_LOCAL_MAT_SIZE 32
68 
69 /* maximal size of local memory storage */
70 #define CV_MAX_LOCAL_SIZE \
71  (CV_MAX_LOCAL_MAT_SIZE*CV_MAX_LOCAL_MAT_SIZE*(int)sizeof(double))
72 
73 /* default image row align (in bytes) */
74 #define CV_DEFAULT_IMAGE_ROW_ALIGN 4
75 
76 /* matrices are continuous by default */
77 #define CV_DEFAULT_MAT_ROW_ALIGN 1
78 
79 /* maximum size of dynamic memory buffer.
80  cvAlloc reports an error if a larger block is requested. */
81 #define CV_MAX_ALLOC_SIZE (((size_t)1 << (sizeof(size_t)*8-2)))
82 
83 /* the alignment of all the allocated buffers */
84 #define CV_MALLOC_ALIGN 32
85 
86 /* default alignment for dynamic data strucutures, resided in storages. */
87 #define CV_STRUCT_ALIGN ((int)sizeof(double))
88 
89 /* default storage block size */
90 #define CV_STORAGE_BLOCK_SIZE ((1<<16) - 128)
91 
92 /* default memory block for sparse array elements */
93 #define CV_SPARSE_MAT_BLOCK (1<<12)
94 
95 /* initial hash table size */
96 #define CV_SPARSE_HASH_SIZE0 (1<<10)
97 
98 /* maximal average node_count/hash_size ratio beyond which hash table is resized */
99 #define CV_SPARSE_HASH_RATIO 3
100 
101 /* max length of strings */
102 #define CV_MAX_STRLEN 1024
103 
104 /* maximum possible number of threads in parallel implementations */
105 #ifdef _OPENMP
106 #define CV_MAX_THREADS 128
107 #else
108 #define CV_MAX_THREADS 1
109 #endif
110 
111 #if 0 /*def CV_CHECK_FOR_NANS*/
112  #define CV_CHECK_NANS( arr ) cvCheckArray((arr))
113 #else
114  #define CV_CHECK_NANS( arr )
115 #endif
116 
117 /****************************************************************************************\
118 * Common declarations *
119 \****************************************************************************************/
120 
121 /* get alloca declaration */
122 #ifdef __GNUC__
123  #undef alloca
124  #define alloca __builtin_alloca
125 #elif defined WIN32 || defined WIN64
126  #if defined _MSC_VER || defined __BORLANDC__
127  #include <malloc.h>
128  #endif
129 #elif defined HAVE_ALLOCA_H
130  #include <alloca.h>
131 #elif defined HAVE_ALLOCA
132  #include <stdlib.h>
133 #else
134  #error
135 #endif
136 
137 /* ! DO NOT make it an inline function */
138 #define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN )
139 
140 #if defined _MSC_VER || defined __BORLANDC__
141  #define CV_BIG_INT(n) n##I64
142  #define CV_BIG_UINT(n) n##UI64
143 #else
144  #define CV_BIG_INT(n) n##LL
145  #define CV_BIG_UINT(n) n##ULL
146 #endif
147 
148 #define CV_IMPL CV_EXTERN_C
149 
150 #define CV_DBG_BREAK() { volatile int* crashMe = 0; *crashMe = 0; }
151 
152 /* default step, set in case of continuous data
153  to work around checks for valid step in some ipp functions */
154 #define CV_STUB_STEP (1 << 30)
155 
156 #define CV_SIZEOF_FLOAT ((int)sizeof(float))
157 #define CV_SIZEOF_SHORT ((int)sizeof(short))
158 
159 #define CV_ORIGIN_TL 0
160 #define CV_ORIGIN_BL 1
161 
162 /* IEEE754 constants and macros */
163 #define CV_POS_INF 0x7f800000
164 #define CV_NEG_INF 0x807fffff /* CV_TOGGLE_FLT(0xff800000) */
165 #define CV_1F 0x3f800000
166 #define CV_TOGGLE_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0))
167 #define CV_TOGGLE_DBL(x) \
168  ((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0))
169 
170 #define CV_NOP(a) (a)
171 #define CV_ADD(a, b) ((a) + (b))
172 #define CV_SUB(a, b) ((a) - (b))
173 #define CV_MUL(a, b) ((a) * (b))
174 #define CV_AND(a, b) ((a) & (b))
175 #define CV_OR(a, b) ((a) | (b))
176 #define CV_XOR(a, b) ((a) ^ (b))
177 #define CV_ANDN(a, b) (~(a) & (b))
178 #define CV_ORN(a, b) (~(a) | (b))
179 #define CV_SQR(a) ((a) * (a))
180 
181 #define CV_LT(a, b) ((a) < (b))
182 #define CV_LE(a, b) ((a) <= (b))
183 #define CV_EQ(a, b) ((a) == (b))
184 #define CV_NE(a, b) ((a) != (b))
185 #define CV_GT(a, b) ((a) > (b))
186 #define CV_GE(a, b) ((a) >= (b))
187 
188 #define CV_NONZERO(a) ((a) != 0)
189 #define CV_NONZERO_FLT(a) (((a)+(a)) != 0)
190 
191 /* general-purpose saturation macros */
192 #define CV_CAST_8U(t) (uchar)(!((t) & ~255) ? (t) : (t) > 0 ? 255 : 0)
193 #define CV_CAST_8S(t) (schar)(!(((t)+128) & ~255) ? (t) : (t) > 0 ? 127 : -128)
194 #define CV_CAST_16U(t) (ushort)(!((t) & ~65535) ? (t) : (t) > 0 ? 65535 : 0)
195 #define CV_CAST_16S(t) (short)(!(((t)+32768) & ~65535) ? (t) : (t) > 0 ? 32767 : -32768)
196 #define CV_CAST_32S(t) (int)(t)
197 #define CV_CAST_64S(t) (int64)(t)
198 #define CV_CAST_32F(t) (float)(t)
199 #define CV_CAST_64F(t) (double)(t)
200 
201 #define CV_PASTE2(a,b) a##b
202 #define CV_PASTE(a,b) CV_PASTE2(a,b)
203 
204 #define CV_EMPTY
205 #define CV_MAKE_STR(a) #a
206 
207 #define CV_DEFINE_MASK \
208  float maskTab[2]; maskTab[0] = 0.f; maskTab[1] = 1.f;
209 #define CV_ANDMASK( m, x ) ((x) & (((m) == 0) - 1))
210 
211 /* (x) * ((m) == 1 ? 1.f : (m) == 0 ? 0.f : <ERR> */
212 #define CV_MULMASK( m, x ) (maskTab[(m) != 0]*(x))
213 
214 /* (x) * ((m) == -1 ? 1.f : (m) == 0 ? 0.f : <ERR> */
215 #define CV_MULMASK1( m, x ) (maskTab[(m)+1]*(x))
216 
217 #define CV_ZERO_OBJ(x) memset((x), 0, sizeof(*(x)))
218 
219 #define CV_DIM(static_array) ((int)(sizeof(static_array)/sizeof((static_array)[0])))
220 
221 #define CV_UN_ENTRY_C1(worktype) \
222  worktype s0 = scalar[0]
223 
224 #define CV_UN_ENTRY_C2(worktype) \
225  worktype s0 = scalar[0], s1 = scalar[1]
226 
227 #define CV_UN_ENTRY_C3(worktype) \
228  worktype s0 = scalar[0], s1 = scalar[1], s2 = scalar[2]
229 
230 #define CV_UN_ENTRY_C4(worktype) \
231  worktype s0 = scalar[0], s1 = scalar[1], s2 = scalar[2], s3 = scalar[3]
232 
233 #define cvUnsupportedFormat "Unsupported format"
234 
235 CV_INLINE void* cvAlignPtr( const void* ptr, int align=32 )
236 {
237  assert( (align & (align-1)) == 0 );
238  return (void*)( ((size_t)ptr + align - 1) & ~(size_t)(align-1) );
239 }
240 
241 CV_INLINE int cvAlign( int size, int align )
242 {
243  assert( (align & (align-1)) == 0 && size < INT_MAX );
244  return (size + align - 1) & -align;
245 }
246 
247 CV_INLINE CvSize cvGetMatSize( const CvMat* mat )
248 {
249  CvSize size = { mat->width, mat->height };
250  return size;
251 }
252 
253 #define CV_DESCALE(x,n) (((x) + (1 << ((n)-1))) >> (n))
254 #define CV_FLT_TO_FIX(x,n) cvRound((x)*(1<<(n)))
255 
256 #if 0
257 /* This is a small engine for performing fast division of multiple numbers
258  by the same constant. Most compilers do it too if they know the divisor value
259  at compile-time. The algorithm was taken from Agner Fog's optimization guide
260  at http://www.agner.org/assem */
261 typedef struct CvFastDiv
262 {
263  unsigned delta, scale, divisor;
264 }
265 CvFastDiv;
266 
267 #define CV_FAST_DIV_SHIFT 32
268 
269 CV_INLINE CvFastDiv cvFastDiv( int divisor )
270 {
271  CvFastDiv fastdiv;
272 
273  assert( divisor >= 1 );
274  uint64 temp = ((uint64)1 << CV_FAST_DIV_SHIFT)/divisor;
275 
276  fastdiv.divisor = divisor;
277  fastdiv.delta = (unsigned)(((temp & 1) ^ 1) + divisor - 1);
278  fastdiv.scale = (unsigned)((temp + 1) >> 1);
279 
280  return fastdiv;
281 }
282 
283 #define CV_FAST_DIV( x, fastdiv ) \
284  ((int)(((int64)((x)*2 + (int)(fastdiv).delta))*(int)(fastdiv).scale>>CV_FAST_DIV_SHIFT))
285 
286 #define CV_FAST_UDIV( x, fastdiv ) \
287  ((int)(((uint64)((x)*2 + (fastdiv).delta))*(fastdiv).scale>>CV_FAST_DIV_SHIFT))
288 #endif
289 
290 #define CV_MEMCPY_CHAR( dst, src, len ) \
291 { \
292  size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \
293  char* _icv_memcpy_dst_ = (char*)(dst); \
294  const char* _icv_memcpy_src_ = (const char*)(src); \
295  \
296  for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++ ) \
297  _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_]; \
298 }
299 
300 
301 #define CV_MEMCPY_INT( dst, src, len ) \
302 { \
303  size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \
304  int* _icv_memcpy_dst_ = (int*)(dst); \
305  const int* _icv_memcpy_src_ = (const int*)(src); \
306  assert( ((size_t)_icv_memcpy_src_&(sizeof(int)-1)) == 0 && \
307  ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 ); \
308  \
309  for(_icv_memcpy_i_=0;_icv_memcpy_i_<_icv_memcpy_len_;_icv_memcpy_i_++) \
310  _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_]; \
311 }
312 
313 
314 #define CV_MEMCPY_AUTO( dst, src, len ) \
315 { \
316  size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \
317  char* _icv_memcpy_dst_ = (char*)(dst); \
318  const char* _icv_memcpy_src_ = (const char*)(src); \
319  if( (_icv_memcpy_len_ & (sizeof(int)-1)) == 0 ) \
320  { \
321  assert( ((size_t)_icv_memcpy_src_&(sizeof(int)-1)) == 0 && \
322  ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 ); \
323  for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; \
324  _icv_memcpy_i_+=sizeof(int) ) \
325  { \
326  *(int*)(_icv_memcpy_dst_+_icv_memcpy_i_) = \
327  *(const int*)(_icv_memcpy_src_+_icv_memcpy_i_); \
328  } \
329  } \
330  else \
331  { \
332  for(_icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++)\
333  _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_]; \
334  } \
335 }
336 
337 
338 #define CV_ZERO_CHAR( dst, len ) \
339 { \
340  size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \
341  char* _icv_memcpy_dst_ = (char*)(dst); \
342  \
343  for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++ ) \
344  _icv_memcpy_dst_[_icv_memcpy_i_] = '\0'; \
345 }
346 
347 
348 #define CV_ZERO_INT( dst, len ) \
349 { \
350  size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \
351  int* _icv_memcpy_dst_ = (int*)(dst); \
352  assert( ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 ); \
353  \
354  for(_icv_memcpy_i_=0;_icv_memcpy_i_<_icv_memcpy_len_;_icv_memcpy_i_++) \
355  _icv_memcpy_dst_[_icv_memcpy_i_] = 0; \
356 }
357 
358 
359 /****************************************************************************************\
360 
361  Generic implementation of QuickSort algorithm.
362  ----------------------------------------------
363  Using this macro user can declare customized sort function that can be much faster
364  than built-in qsort function because of lower overhead on elements
365  comparison and exchange. The macro takes less_than (or LT) argument - a macro or function
366  that takes 2 arguments returns non-zero if the first argument should be before the second
367  one in the sorted sequence and zero otherwise.
368 
369  Example:
370 
371  Suppose that the task is to sort points by ascending of y coordinates and if
372  y's are equal x's should ascend.
373 
374  The code is:
375  ------------------------------------------------------------------------------
376  #define cmp_pts( pt1, pt2 ) \
377  ((pt1).y < (pt2).y || ((pt1).y < (pt2).y && (pt1).x < (pt2).x))
378 
379  [static] CV_IMPLEMENT_QSORT( icvSortPoints, CvPoint, cmp_pts )
380  ------------------------------------------------------------------------------
381 
382  After that the function "void icvSortPoints( CvPoint* array, size_t total, int aux );"
383  is available to user.
384 
385  aux is an additional parameter, which can be used when comparing elements.
386  The current implementation was derived from *BSD system qsort():
387 
388  * Copyright (c) 1992, 1993
389  * The Regents of the University of California. All rights reserved.
390  *
391  * Redistribution and use in source and binary forms, with or without
392  * modification, are permitted provided that the following conditions
393  * are met:
394  * 1. Redistributions of source code must retain the above copyright
395  * notice, this list of conditions and the following disclaimer.
396  * 2. Redistributions in binary form must reproduce the above copyright
397  * notice, this list of conditions and the following disclaimer in the
398  * documentation and/or other materials provided with the distribution.
399  * 3. All advertising materials mentioning features or use of this software
400  * must display the following acknowledgement:
401  * This product includes software developed by the University of
402  * California, Berkeley and its contributors.
403  * 4. Neither the name of the University nor the names of its contributors
404  * may be used to endorse or promote products derived from this software
405  * without specific prior written permission.
406  *
407  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
408  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
409  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
410  * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
411  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
412  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
413  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
414  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
415  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
416  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
417  * SUCH DAMAGE.
418 
419 \****************************************************************************************/
420 
421 #define CV_IMPLEMENT_QSORT_EX( func_name, T, LT, user_data_type ) \
422 void func_name( T *array, size_t total, user_data_type aux ) \
423 { \
424  int isort_thresh = 7; \
425  T t; \
426  int sp = 0; \
427  \
428  struct \
429  { \
430  T *lb; \
431  T *ub; \
432  } \
433  stack[48]; \
434  \
435  aux = aux; \
436  \
437  if( total <= 1 ) \
438  return; \
439  \
440  stack[0].lb = array; \
441  stack[0].ub = array + (total - 1); \
442  \
443  while( sp >= 0 ) \
444  { \
445  T* left = stack[sp].lb; \
446  T* right = stack[sp--].ub; \
447  \
448  for(;;) \
449  { \
450  int i, n = (int)(right - left) + 1, m; \
451  T* ptr; \
452  T* ptr2; \
453  \
454  if( n <= isort_thresh ) \
455  { \
456  insert_sort: \
457  for( ptr = left + 1; ptr <= right; ptr++ ) \
458  { \
459  for( ptr2 = ptr; ptr2 > left && LT(ptr2[0],ptr2[-1]); ptr2--) \
460  CV_SWAP( ptr2[0], ptr2[-1], t ); \
461  } \
462  break; \
463  } \
464  else \
465  { \
466  T* left0; \
467  T* left1; \
468  T* right0; \
469  T* right1; \
470  T* pivot; \
471  T* a; \
472  T* b; \
473  T* c; \
474  int swap_cnt = 0; \
475  \
476  left0 = left; \
477  right0 = right; \
478  pivot = left + (n/2); \
479  \
480  if( n > 40 ) \
481  { \
482  int d = n / 8; \
483  a = left, b = left + d, c = left + 2*d; \
484  left = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
485  : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
486  \
487  a = pivot - d, b = pivot, c = pivot + d; \
488  pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
489  : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
490  \
491  a = right - 2*d, b = right - d, c = right; \
492  right = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
493  : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
494  } \
495  \
496  a = left, b = pivot, c = right; \
497  pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
498  : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
499  if( pivot != left0 ) \
500  { \
501  CV_SWAP( *pivot, *left0, t ); \
502  pivot = left0; \
503  } \
504  left = left1 = left0 + 1; \
505  right = right1 = right0; \
506  \
507  for(;;) \
508  { \
509  while( left <= right && !LT(*pivot, *left) ) \
510  { \
511  if( !LT(*left, *pivot) ) \
512  { \
513  if( left > left1 ) \
514  CV_SWAP( *left1, *left, t ); \
515  swap_cnt = 1; \
516  left1++; \
517  } \
518  left++; \
519  } \
520  \
521  while( left <= right && !LT(*right, *pivot) ) \
522  { \
523  if( !LT(*pivot, *right) ) \
524  { \
525  if( right < right1 ) \
526  CV_SWAP( *right1, *right, t ); \
527  swap_cnt = 1; \
528  right1--; \
529  } \
530  right--; \
531  } \
532  \
533  if( left > right ) \
534  break; \
535  CV_SWAP( *left, *right, t ); \
536  swap_cnt = 1; \
537  left++; \
538  right--; \
539  } \
540  \
541  if( swap_cnt == 0 ) \
542  { \
543  left = left0, right = right0; \
544  goto insert_sort; \
545  } \
546  \
547  n = MIN( (int)(left1 - left0), (int)(left - left1) ); \
548  for( i = 0; i < n; i++ ) \
549  CV_SWAP( left0[i], left[i-n], t ); \
550  \
551  n = MIN( (int)(right0 - right1), (int)(right1 - right) ); \
552  for( i = 0; i < n; i++ ) \
553  CV_SWAP( left[i], right0[i-n+1], t ); \
554  n = (int)(left - left1); \
555  m = (int)(right1 - right); \
556  if( n > 1 ) \
557  { \
558  if( m > 1 ) \
559  { \
560  if( n > m ) \
561  { \
562  stack[++sp].lb = left0; \
563  stack[sp].ub = left0 + n - 1; \
564  left = right0 - m + 1, right = right0; \
565  } \
566  else \
567  { \
568  stack[++sp].lb = right0 - m + 1; \
569  stack[sp].ub = right0; \
570  left = left0, right = left0 + n - 1; \
571  } \
572  } \
573  else \
574  left = left0, right = left0 + n - 1; \
575  } \
576  else if( m > 1 ) \
577  left = right0 - m + 1, right = right0; \
578  else \
579  break; \
580  } \
581  } \
582  } \
583 }
584 
585 #define CV_IMPLEMENT_QSORT( func_name, T, cmp ) \
586  CV_IMPLEMENT_QSORT_EX( func_name, T, cmp, int )
587 
588 /****************************************************************************************\
589 * Structures and macros for integration with IPP *
590 \****************************************************************************************/
591 
592 /* IPP-compatible return codes */
593 typedef enum CvStatus
594 {
595  CV_BADMEMBLOCK_ERR = -113,
596  CV_INPLACE_NOT_SUPPORTED_ERR= -112,
597  CV_UNMATCHED_ROI_ERR = -111,
598  CV_NOTFOUND_ERR = -110,
599  CV_BADCONVERGENCE_ERR = -109,
600 
601  CV_BADDEPTH_ERR = -107,
602  CV_BADROI_ERR = -106,
603  CV_BADHEADER_ERR = -105,
604  CV_UNMATCHED_FORMATS_ERR = -104,
605  CV_UNSUPPORTED_COI_ERR = -103,
606  CV_UNSUPPORTED_CHANNELS_ERR = -102,
607  CV_UNSUPPORTED_DEPTH_ERR = -101,
608  CV_UNSUPPORTED_FORMAT_ERR = -100,
609 
610  CV_BADARG_ERR = -49, //ipp comp
611  CV_NOTDEFINED_ERR = -48, //ipp comp
612 
613  CV_BADCHANNELS_ERR = -47, //ipp comp
614  CV_BADRANGE_ERR = -44, //ipp comp
615  CV_BADSTEP_ERR = -29, //ipp comp
616 
617  CV_BADFLAG_ERR = -12,
618  CV_DIV_BY_ZERO_ERR = -11, //ipp comp
619  CV_BADCOEF_ERR = -10,
620 
621  CV_BADFACTOR_ERR = -7,
622  CV_BADPOINT_ERR = -6,
623  CV_BADSCALE_ERR = -4,
624  CV_OUTOFMEM_ERR = -3,
625  CV_NULLPTR_ERR = -2,
626  CV_BADSIZE_ERR = -1,
627  CV_NO_ERR = 0,
628  CV_OK = CV_NO_ERR
629 }
630 CvStatus;
631 
632 #define CV_ERROR_FROM_STATUS( result ) \
633  CV_ERROR( cvErrorFromIppStatus( result ), "OpenCV function failed" )
634 
635 #define IPPI_CALL( Func ) \
636 { \
637  CvStatus ippi_call_result; \
638  ippi_call_result = Func; \
639  \
640  if( ippi_call_result < 0 ) \
641  CV_ERROR_FROM_STATUS( (ippi_call_result)); \
642 }
643 
644 #define CV_PLUGIN_NONE 0
645 #define CV_PLUGIN_OPTCV 1 /* custom "emerged" ippopencv library */
646 #define CV_PLUGIN_IPPCV 2 /* IPP: computer vision */
647 #define CV_PLUGIN_IPPI 3 /* IPP: image processing */
648 #define CV_PLUGIN_IPPS 4 /* IPP: signal processing */
649 #define CV_PLUGIN_IPPVM 5 /* IPP: vector math functions */
650 #define CV_PLUGIN_IPPCC 6 /* IPP: color space conversion */
651 #define CV_PLUGIN_MKL 8 /* Intel Math Kernel Library */
652 
653 #define CV_PLUGIN_MAX 16
654 
655 #define CV_PLUGINS1(lib1) ((lib1)&15)
656 #define CV_PLUGINS2(lib1,lib2) (((lib1)&15)|(((lib2)&15)<<4))
657 #define CV_PLUGINS3(lib1,lib2,lib3) (((lib1)&15)|(((lib2)&15)<<4)|(((lib2)&15)<<8))
658 
659 #define CV_NOTHROW throw()
660 
661 #ifndef IPCVAPI
662 #define IPCVAPI(type,declspec,name,args) \
663  /* function pointer */ \
664  typedef type (declspec* name##_t) args; \
665  extern name##_t name##_p; \
666  type declspec name args;
667 #endif
668 
669 #define IPCVAPI_EX(type,name,ipp_name,ipp_search_modules,args) \
670  IPCVAPI(type,CV_STDCALL,name,args)
671 
672 #define IPCVAPI_C_EX(type,name,ipp_name,ipp_search_modules,args)\
673  IPCVAPI(type,CV_CDECL,name,args)
674 
675 #ifndef IPCVAPI_IMPL
676 #define IPCVAPI_IMPL(type,name,args,arg_names) \
677  static type CV_STDCALL name##_f args; \
678  name##_t name##_p = name##_f; \
679  type CV_STDCALL name args { return name##_p arg_names; } \
680  static type CV_STDCALL name##_f args
681 #endif
682 
683 /* IPP types' enumeration */
684 typedef enum CvDataType {
685  cv1u,
686  cv8u, cv8s,
687  cv16u, cv16s, cv16sc,
688  cv32u, cv32s, cv32sc,
689  cv32f, cv32fc,
690  cv64u, cv64s, cv64sc,
691  cv64f, cv64fc
692 } CvDataType;
693 
694 typedef enum CvHintAlgorithm {
695  cvAlgHintNone,
696  cvAlgHintFast,
697  cvAlgHintAccurate
698 } CvHintAlgorithm;
699 
700 typedef enum CvCmpOp {
701  cvCmpLess,
702  cvCmpLessEq,
703  cvCmpEq,
704  cvCmpGreaterEq,
705  cvCmpGreater
706 } CvCmpOp;
707 
708 typedef struct CvFuncTable
709 {
710  void* fn_2d[CV_DEPTH_MAX];
711 }
712 CvFuncTable;
713 
714 typedef struct CvBigFuncTable
715 {
716  void* fn_2d[CV_DEPTH_MAX*CV_CN_MAX];
717 }
718 CvBigFuncTable;
719 
720 
721 typedef struct CvBtFuncTable
722 {
723  void* fn_2d[33];
724 }
725 CvBtFuncTable;
726 
727 typedef CvStatus (CV_STDCALL *CvFunc2D_1A)(void* arr, int step, CvSize size);
728 
729 typedef CvStatus (CV_STDCALL *CvFunc2D_1A1P)(void* arr, int step, CvSize size, void* param);
730 
731 typedef CvStatus (CV_STDCALL *CvFunc2D_1A1P1I)(void* arr, int step, CvSize size,
732  void* param, int flag);
733 
734 typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A1P)( void* arr, int step, CvSize size,
735  int cn, int coi, void* param );
736 
737 typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A1P)( void* arr, int step, CvSize size,
738  int cn, int coi, void* param );
739 
740 typedef CvStatus (CV_STDCALL *CvFunc2D_1A2P)( void* arr, int step, CvSize size,
741  void* param1, void* param2 );
742 
743 typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A2P)( void* arr, int step,
744  CvSize size, int cn, int coi,
745  void* param1, void* param2 );
746 
747 typedef CvStatus (CV_STDCALL *CvFunc2D_1A4P)( void* arr, int step, CvSize size,
748  void* param1, void* param2,
749  void* param3, void* param4 );
750 
751 typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A4P)( void* arr, int step,
752  CvSize size, int cn, int coi,
753  void* param1, void* param2,
754  void* param3, void* param4 );
755 
756 typedef CvStatus (CV_STDCALL *CvFunc2D_2A)( void* arr0, int step0,
757  void* arr1, int step1, CvSize size );
758 
759 typedef CvStatus (CV_STDCALL *CvFunc2D_2A1P)( void* arr0, int step0,
760  void* arr1, int step1,
761  CvSize size, void* param );
762 
763 typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A1P)( void* arr0, int step0,
764  void* arr1, int step1,
765  CvSize size, int cn,
766  int coi, void* param );
767 
768 typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A1P)( void* arr0, int step0,
769  void* arr1, int step1,
770  CvSize size, int cn,
771  int coi, void* param );
772 
773 typedef CvStatus (CV_STDCALL *CvFunc2D_2A2P)( void* arr0, int step0,
774  void* arr1, int step1, CvSize size,
775  void* param1, void* param2 );
776 
777 typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A2P)( void* arr0, int step0,
778  void* arr1, int step1,
779  CvSize size, int cn, int coi,
780  void* param1, void* param2 );
781 
782 typedef CvStatus (CV_STDCALL *CvFunc2D_2A1P1I)( void* arr0, int step0,
783  void* arr1, int step1, CvSize size,
784  void* param, int flag );
785 
786 typedef CvStatus (CV_STDCALL *CvFunc2D_2A4P)( void* arr0, int step0,
787  void* arr1, int step1, CvSize size,
788  void* param1, void* param2,
789  void* param3, void* param4 );
790 
791 typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A4P)( void* arr0, int step0,
792  void* arr1, int step1, CvSize size,
793  int cn, int coi,
794  void* param1, void* param2,
795  void* param3, void* param4 );
796 
797 typedef CvStatus (CV_STDCALL *CvFunc2D_3A)( void* arr0, int step0,
798  void* arr1, int step1,
799  void* arr2, int step2, CvSize size );
800 
801 typedef CvStatus (CV_STDCALL *CvFunc2D_3A1P)( void* arr0, int step0,
802  void* arr1, int step1,
803  void* arr2, int step2,
804  CvSize size, void* param );
805 
806 typedef CvStatus (CV_STDCALL *CvFunc2D_3A1I)( void* arr0, int step0,
807  void* arr1, int step1,
808  void* arr2, int step2,
809  CvSize size, int flag );
810 
811 typedef CvStatus (CV_STDCALL *CvFunc2DnC_3A1P)( void* arr0, int step0,
812  void* arr1, int step1,
813  void* arr2, int step2,
814  CvSize size, int cn,
815  int coi, void* param );
816 
817 typedef CvStatus (CV_STDCALL *CvFunc2D_4A)( void* arr0, int step0,
818  void* arr1, int step1,
819  void* arr2, int step2,
820  void* arr3, int step3,
821  CvSize size );
822 
823 typedef CvStatus (CV_STDCALL *CvFunc0D)( const void* src, void* dst, int param );
824 
825 #define CV_DEF_INIT_FUNC_TAB_2D( FUNCNAME, FLAG ) \
826 static void icvInit##FUNCNAME##FLAG##Table( CvFuncTable* tab ) \
827 { \
828  assert( tab ); \
829  \
830  tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u_##FLAG; \
831  tab->fn_2d[CV_8S] = (void*)icv##FUNCNAME##_8s_##FLAG; \
832  tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_##FLAG; \
833  tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_##FLAG; \
834  tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s_##FLAG; \
835  tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_##FLAG; \
836  tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_##FLAG; \
837 }
838 
839 
840 #define CV_DEF_INIT_BIG_FUNC_TAB_2D( FUNCNAME, FLAG ) \
841 static void icvInit##FUNCNAME##FLAG##Table( CvBigFuncTable* tab ) \
842 { \
843  assert( tab ); \
844  \
845  tab->fn_2d[CV_8UC1] = (void*)icv##FUNCNAME##_8u_C1##FLAG; \
846  tab->fn_2d[CV_8UC2] = (void*)icv##FUNCNAME##_8u_C2##FLAG; \
847  tab->fn_2d[CV_8UC3] = (void*)icv##FUNCNAME##_8u_C3##FLAG; \
848  tab->fn_2d[CV_8UC4] = (void*)icv##FUNCNAME##_8u_C4##FLAG; \
849  \
850  tab->fn_2d[CV_8SC1] = (void*)icv##FUNCNAME##_8s_C1##FLAG; \
851  tab->fn_2d[CV_8SC2] = (void*)icv##FUNCNAME##_8s_C2##FLAG; \
852  tab->fn_2d[CV_8SC3] = (void*)icv##FUNCNAME##_8s_C3##FLAG; \
853  tab->fn_2d[CV_8SC4] = (void*)icv##FUNCNAME##_8s_C4##FLAG; \
854  \
855  tab->fn_2d[CV_16UC1] = (void*)icv##FUNCNAME##_16u_C1##FLAG; \
856  tab->fn_2d[CV_16UC2] = (void*)icv##FUNCNAME##_16u_C2##FLAG; \
857  tab->fn_2d[CV_16UC3] = (void*)icv##FUNCNAME##_16u_C3##FLAG; \
858  tab->fn_2d[CV_16UC4] = (void*)icv##FUNCNAME##_16u_C4##FLAG; \
859  \
860  tab->fn_2d[CV_16SC1] = (void*)icv##FUNCNAME##_16s_C1##FLAG; \
861  tab->fn_2d[CV_16SC2] = (void*)icv##FUNCNAME##_16s_C2##FLAG; \
862  tab->fn_2d[CV_16SC3] = (void*)icv##FUNCNAME##_16s_C3##FLAG; \
863  tab->fn_2d[CV_16SC4] = (void*)icv##FUNCNAME##_16s_C4##FLAG; \
864  \
865  tab->fn_2d[CV_32SC1] = (void*)icv##FUNCNAME##_32s_C1##FLAG; \
866  tab->fn_2d[CV_32SC2] = (void*)icv##FUNCNAME##_32s_C2##FLAG; \
867  tab->fn_2d[CV_32SC3] = (void*)icv##FUNCNAME##_32s_C3##FLAG; \
868  tab->fn_2d[CV_32SC4] = (void*)icv##FUNCNAME##_32s_C4##FLAG; \
869  \
870  tab->fn_2d[CV_32FC1] = (void*)icv##FUNCNAME##_32f_C1##FLAG; \
871  tab->fn_2d[CV_32FC2] = (void*)icv##FUNCNAME##_32f_C2##FLAG; \
872  tab->fn_2d[CV_32FC3] = (void*)icv##FUNCNAME##_32f_C3##FLAG; \
873  tab->fn_2d[CV_32FC4] = (void*)icv##FUNCNAME##_32f_C4##FLAG; \
874  \
875  tab->fn_2d[CV_64FC1] = (void*)icv##FUNCNAME##_64f_C1##FLAG; \
876  tab->fn_2d[CV_64FC2] = (void*)icv##FUNCNAME##_64f_C2##FLAG; \
877  tab->fn_2d[CV_64FC3] = (void*)icv##FUNCNAME##_64f_C3##FLAG; \
878  tab->fn_2d[CV_64FC4] = (void*)icv##FUNCNAME##_64f_C4##FLAG; \
879 }
880 
881 #define CV_DEF_INIT_FUNC_TAB_0D( FUNCNAME ) \
882 static void icvInit##FUNCNAME##Table( CvFuncTable* tab ) \
883 { \
884  tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u; \
885  tab->fn_2d[CV_8S] = (void*)icv##FUNCNAME##_8s; \
886  tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u; \
887  tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s; \
888  tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s; \
889  tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f; \
890  tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f; \
891 }
892 
893 #define CV_DEF_INIT_FUNC_TAB_1D CV_DEF_INIT_FUNC_TAB_0D
894 
895 
896 #define CV_DEF_INIT_PIXSIZE_TAB_2D( FUNCNAME, FLAG ) \
897 static void icvInit##FUNCNAME##FLAG##Table( CvBtFuncTable* table ) \
898 { \
899  table->fn_2d[1] = (void*)icv##FUNCNAME##_8u_C1##FLAG; \
900  table->fn_2d[2] = (void*)icv##FUNCNAME##_8u_C2##FLAG; \
901  table->fn_2d[3] = (void*)icv##FUNCNAME##_8u_C3##FLAG; \
902  table->fn_2d[4] = (void*)icv##FUNCNAME##_16u_C2##FLAG; \
903  table->fn_2d[6] = (void*)icv##FUNCNAME##_16u_C3##FLAG; \
904  table->fn_2d[8] = (void*)icv##FUNCNAME##_32s_C2##FLAG; \
905  table->fn_2d[12] = (void*)icv##FUNCNAME##_32s_C3##FLAG; \
906  table->fn_2d[16] = (void*)icv##FUNCNAME##_64s_C2##FLAG; \
907  table->fn_2d[24] = (void*)icv##FUNCNAME##_64s_C3##FLAG; \
908  table->fn_2d[32] = (void*)icv##FUNCNAME##_64s_C4##FLAG; \
909 }
910 
911 #define CV_GET_FUNC_PTR( func, table_entry ) \
912  func = (table_entry); \
913  \
914  if( !func ) \
915  CV_ERROR( CV_StsUnsupportedFormat, "" )
916 
917 
918 #endif /*_CXCORE_MISC_H_*/
Generated on Thu Apr 4 2013 14:33:04 for Wondercoll by   doxygen 1.8.3.1