topical media & game development

topical media & game development

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

lib-of-vs-addons-ofxOpenCv-libs-opencv-include-cxmisc.h / h


  /*M/////////////////////////////////////////////////////////////////////////////////


  //
  //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  //
  //  By downloading, copying, installing or using the software you agree to this license.
  //  If you do not agree to this license, do not download, install,
  //  copy or use the software.
  //
  //
  //                        Intel License Agreement
  //                For Open Source Computer Vision Library
  //
  // Copyright (C) 2000, Intel Corporation, all rights reserved.
  // Third party copyrights are property of their respective owners.
  //
  // Redistribution and use in source and binary forms, with or without modification,
  // are permitted provided that the following conditions are met:
  //
  //   * Redistribution's of source code must retain the above copyright notice,
  //     this list of conditions and the following disclaimer.
  //
  //   * Redistribution's in binary form must reproduce the above copyright notice,
  //     this list of conditions and the following disclaimer in the documentation
  //     and/or other materials provided with the distribution.
  //
  //   * The name of Intel Corporation may not be used to endorse or promote products
  //     derived from this software without specific prior written permission.
  //
  // This software is provided by the copyright holders and contributors "as is" and
  // any express or implied warranties, including, but not limited to, the implied
  // warranties of merchantability and fitness for a particular purpose are disclaimed.
  // In no event shall the Intel Corporation or contributors be liable for any direct,
  // indirect, incidental, special, exemplary, or consequential damages
  // (including, but not limited to, procurement of substitute goods or services;
  // loss of use, data, or profits; or business interruption) however caused
  // and on any theory of liability, whether in contract, strict liability,
  // or tort (including negligence or otherwise) arising in any way out of
  // the use of this software, even if advised of the possibility of such damage.
  //
  //M*/
  
  /* The header is mostly for internal use and it is likely to change.
     It contains some macro definitions that are used in cxcore, cv, cvaux
     and, probably, other libraries. If you need some of this functionality,
     the safe way is to copy it into your code and rename the macros.
  */
  ifndef _CXCORE_MISC_H_
  define _CXCORE_MISC_H_
  
  ifdef HAVE_CONFIG_H
      #include <cvconfig.h>
  endif
  
  include <limits.h>
  ifdef _OPENMP
  include <omp.h>
  endif

**************************************************************************************\ Compile-time tuning parameters * \***************************************************************************************


  
  
  /* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */
  define  CV_MAX_INLINE_MAT_OP_SIZE  10
  
  /* maximal linear size of matrix to allocate it on stack. */
  define  CV_MAX_LOCAL_MAT_SIZE  32
  
  /* maximal size of local memory storage */
  define  CV_MAX_LOCAL_SIZE  \
      (CV_MAX_LOCAL_MAT_SIZE*CV_MAX_LOCAL_MAT_SIZE*(int)sizeof(double))
  
  /* default image row align (in bytes) */
  define  CV_DEFAULT_IMAGE_ROW_ALIGN  4
  
  /* matrices are continuous by default */
  define  CV_DEFAULT_MAT_ROW_ALIGN  1
  
  /* maximum size of dynamic memory buffer.
     cvAlloc reports an error if a larger block is requested. */
  define  CV_MAX_ALLOC_SIZE    (((size_t)1 << (sizeof(size_t)*8-2)))
  
  /* the alignment of all the allocated buffers */
  define  CV_MALLOC_ALIGN    32
  
  /* default alignment for dynamic data strucutures, resided in storages. */
  define  CV_STRUCT_ALIGN    ((int)sizeof(double))
  
  /* default storage block size */
  define  CV_STORAGE_BLOCK_SIZE   ((1<<16) - 128)
  
  /* default memory block for sparse array elements */
  define  CV_SPARSE_MAT_BLOCK    (1<<12)
  
  /* initial hash table size */
  define  CV_SPARSE_HASH_SIZE0    (1<<10)
  
  /* maximal average node_count/hash_size ratio beyond which hash table is resized */
  define  CV_SPARSE_HASH_RATIO    3
  
  /* max length of strings */
  define  CV_MAX_STRLEN  1024
  
  /* maximum possible number of threads in parallel implementations */
  ifdef _OPENMP
  define CV_MAX_THREADS 128
  else
  define CV_MAX_THREADS 1
  endif
  
  if 0 /*def  CV_CHECK_FOR_NANS*/
      #define CV_CHECK_NANS( arr ) cvCheckArray((arr))
  else
      #define CV_CHECK_NANS( arr )
  endif

**************************************************************************************\ Common declarations * \***************************************************************************************


  
  
  /* get alloca declaration */
  ifdef __GNUC__
      #undef alloca
      #define alloca __builtin_alloca
  #elif defined WIN32 || defined WIN64
      #if defined _MSC_VER || defined __BORLANDC__
          #include <malloc.h>
      #endif
  #elif defined HAVE_ALLOCA_H
      #include <alloca.h>
  #elif defined HAVE_ALLOCA
      #include <stdlib.h>
  #elif
      #error
  endif
  
  /* ! DO NOT make it an inline function */
  define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN )
  
  if defined _MSC_VER || defined __BORLANDC__
      #define CV_BIG_INT(n)   n##I64
      #define CV_BIG_UINT(n)  n##UI64
  else
      #define CV_BIG_INT(n)   n##LL
      #define CV_BIG_UINT(n)  n##ULL
  endif
  
  define CV_IMPL CV_EXTERN_C
  
  define CV_DBG_BREAK() { volatile int* crashMe = 0; *crashMe = 0; }
  
  /* default step, set in case of continuous data
     to work around checks for valid step in some ipp functions */
  define  CV_STUB_STEP     (1 << 30)
  
  define  CV_SIZEOF_FLOAT ((int)sizeof(float))
  define  CV_SIZEOF_SHORT ((int)sizeof(short))
  
  define  CV_ORIGIN_TL  0
  define  CV_ORIGIN_BL  1
  
  /* IEEE754 constants and macros */
  define  CV_POS_INF       0x7f800000
  define  CV_NEG_INF       0x807fffff /* CV_TOGGLE_FLT(0xff800000) */
  define  CV_1F            0x3f800000
  define  CV_TOGGLE_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0))
  define  CV_TOGGLE_DBL(x) \
      ((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0))
  
  define  CV_NOP(a)      (a)
  define  CV_ADD(a, b)   ((a) + (b))
  define  CV_SUB(a, b)   ((a) - (b))
  define  CV_MUL(a, b)   ((a) * (b))
  define  CV_AND(a, b)   ((a) & (b))
  define  CV_OR(a, b)    ((a) | (b))
  define  CV_XOR(a, b)   ((a) ^ (b))
  define  CV_ANDN(a, b)  (~(a) & (b))
  define  CV_ORN(a, b)   (~(a) | (b))
  define  CV_SQR(a)      ((a) * (a))
  
  define  CV_LT(a, b)    ((a) < (b))
  define  CV_LE(a, b)    ((a) <= (b))
  define  CV_EQ(a, b)    ((a) == (b))
  define  CV_NE(a, b)    ((a) != (b))
  define  CV_GT(a, b)    ((a) > (b))
  define  CV_GE(a, b)    ((a) >= (b))
  
  define  CV_NONZERO(a)      ((a) != 0)
  define  CV_NONZERO_FLT(a)  (((a)+(a)) != 0)
  
  /* general-purpose saturation macros */
  define  CV_CAST_8U(t)  (uchar)(!((t) & ~255) ? (t) : (t) > 0 ? 255 : 0)
  define  CV_CAST_8S(t)  (schar)(!(((t)+128) & ~255) ? (t) : (t) > 0 ? 127 : -128)
  define  CV_CAST_16U(t) (ushort)(!((t) & ~65535) ? (t) : (t) > 0 ? 65535 : 0)
  define  CV_CAST_16S(t) (short)(!(((t)+32768) & ~65535) ? (t) : (t) > 0 ? 32767 : -32768)
  define  CV_CAST_32S(t) (int)(t)
  define  CV_CAST_64S(t) (int64)(t)
  define  CV_CAST_32F(t) (float)(t)
  define  CV_CAST_64F(t) (double)(t)
  
  define  CV_PASTE2(a,b) a##b
  define  CV_PASTE(a,b)  CV_PASTE2(a,b)
  
  define  CV_EMPTY
  define  CV_MAKE_STR(a) #a
  
  define  CV_DEFINE_MASK         \
      float maskTab[2]; maskTab[0] = 0.f; maskTab[1] = 1.f;
  define  CV_ANDMASK( m, x )     ((x) & (((m) == 0) - 1))
  
  /* (x) * ((m) == 1 ? 1.f : (m) == 0 ? 0.f : <ERR> */
  define  CV_MULMASK( m, x )       (maskTab[(m) != 0]*(x))
  
  /* (x) * ((m) == -1 ? 1.f : (m) == 0 ? 0.f : <ERR> */
  define  CV_MULMASK1( m, x )      (maskTab[(m)+1]*(x))
  
  define  CV_ZERO_OBJ(x)  memset((x), 0, sizeof(*(x)))
  
  define  CV_DIM(static_array) ((int)(sizeof(static_array)/sizeof((static_array)[0])))
  
  define  CV_UN_ENTRY_C1(worktype)           \
      worktype s0 = scalar[0]
  
  define  CV_UN_ENTRY_C2(worktype)           \
      worktype s0 = scalar[0], s1 = scalar[1]
  
  define  CV_UN_ENTRY_C3(worktype)           \
      worktype s0 = scalar[0], s1 = scalar[1], s2 = scalar[2]
  
  define  CV_UN_ENTRY_C4(worktype)           \
      worktype s0 = scalar[0], s1 = scalar[1], s2 = scalar[2], s3 = scalar[3]
  
  define  cvUnsupportedFormat "Unsupported format"
  
  CV_INLINE void* cvAlignPtr( const void* ptr, int align=32 )
  {
      assert( (align & (align-1)) == 0 );
      return (void*)( ((size_t)ptr + align - 1) & ~(size_t)(align-1) );
  }
  
  CV_INLINE int cvAlign( int size, int align )
  {
      assert( (align & (align-1)) == 0 && size < INT_MAX );
      return (size + align - 1) & -align;
  }
  
  CV_INLINE  CvSize  cvGetMatSize( const CvMat* mat )
  {
      CvSize size = { mat->width, mat->height };
      return size;
  }
  
  define  CV_DESCALE(x,n)     (((x) + (1 << ((n)-1))) >> (n))
  define  CV_FLT_TO_FIX(x,n)  cvRound((x)*(1<<(n)))
  
  if 0
  /* This is a small engine for performing fast division of multiple numbers
     by the same constant. Most compilers do it too if they know the divisor value
     at compile-time. The algorithm was taken from Agner Fog's optimization guide
     at http://www.agner.org/assem */
  typedef struct CvFastDiv
  {
      unsigned delta, scale, divisor;
  }
  CvFastDiv;
  
  define CV_FAST_DIV_SHIFT 32
  
  CV_INLINE CvFastDiv cvFastDiv( int divisor )
  {
      CvFastDiv fastdiv;
  
      assert( divisor >= 1 );
      uint64 temp = ((uint64)1 << CV_FAST_DIV_SHIFT)/divisor;
  
      fastdiv.divisor = divisor;
      fastdiv.delta = (unsigned)(((temp & 1) ^ 1) + divisor - 1);
      fastdiv.scale = (unsigned)((temp + 1) >> 1);
  
      return fastdiv;
  }
  
  define CV_FAST_DIV( x, fastdiv )  \
      ((int)(((int64)((x)*2 + (int)(fastdiv).delta))*(int)(fastdiv).scale>>CV_FAST_DIV_SHIFT))
  
  define CV_FAST_UDIV( x, fastdiv )  \
      ((int)(((uint64)((x)*2 + (fastdiv).delta))*(fastdiv).scale>>CV_FAST_DIV_SHIFT))
  endif
  
  define CV_MEMCPY_CHAR( dst, src, len )                                             \
  {                                                                                   \
      size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len);                                \
      char* _icv_memcpy_dst_ = (char*)(dst);                                          \
      const char* _icv_memcpy_src_ = (const char*)(src);                              \
                                                                                      \
      for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++ )  \
          _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_];        \
  }
  
  define CV_MEMCPY_INT( dst, src, len )                                              \
  {                                                                                   \
      size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len);                                \
      int* _icv_memcpy_dst_ = (int*)(dst);                                            \
      const int* _icv_memcpy_src_ = (const int*)(src);                                \
      assert( ((size_t)_icv_memcpy_src_&(sizeof(int)-1)) == 0 &&                      \
              ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 );                      \
                                                                                      \
      for(_icv_memcpy_i_=0;_icv_memcpy_i_<_icv_memcpy_len_;_icv_memcpy_i_++)          \
          _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_];        \
  }
  
  define CV_MEMCPY_AUTO( dst, src, len )                                             \
  {                                                                                   \
      size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len);                                \
      char* _icv_memcpy_dst_ = (char*)(dst);                                          \
      const char* _icv_memcpy_src_ = (const char*)(src);                              \
      if( (_icv_memcpy_len_ & (sizeof(int)-1)) == 0 )                                 \
      {                                                                               \
          assert( ((size_t)_icv_memcpy_src_&(sizeof(int)-1)) == 0 &&                  \
                  ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 );                  \
          for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_;                 \
              _icv_memcpy_i_+=sizeof(int) )                                           \
          {                                                                           \
              *(int*)(_icv_memcpy_dst_+_icv_memcpy_i_) =                              \
              *(const int*)(_icv_memcpy_src_+_icv_memcpy_i_);                         \
          }                                                                           \
      }                                                                               \
      else                                                                            \
      {                                                                               \
          for(_icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++)\
              _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_];    \
      }                                                                               \
  }
  
  define CV_ZERO_CHAR( dst, len )                                                    \
  {                                                                                   \
      size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len);                                \
      char* _icv_memcpy_dst_ = (char*)(dst);                                          \
                                                                                      \
      for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++ )  \
          _icv_memcpy_dst_[_icv_memcpy_i_] = '\0';                                    \
  }
  
  define CV_ZERO_INT( dst, len )                                                     \
  {                                                                                   \
      size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len);                                \
      int* _icv_memcpy_dst_ = (int*)(dst);                                            \
      assert( ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 );                      \
                                                                                      \
      for(_icv_memcpy_i_=0;_icv_memcpy_i_<_icv_memcpy_len_;_icv_memcpy_i_++)          \
          _icv_memcpy_dst_[_icv_memcpy_i_] = 0;                                       \
  }

**************************************************************************************\


    Generic implementation of QuickSort algorithm.
    ----------------------------------------------
    Using this macro user can declare customized sort function that can be much faster
    than built-in qsort function because of lower overhead on elements
    comparison and exchange. The macro takes less_than (or LT) argument - a macro or function
    that takes 2 arguments returns non-zero if the first argument should be before the second
    one in the sorted sequence and zero otherwise.
  
    Example:
  
      Suppose that the task is to sort points by ascending of y coordinates and if
      y's are equal x's should ascend.
  
      The code is:
      ------------------------------------------------------------------------------
             #define cmp_pts( pt1, pt2 ) \
                 ((pt1).y < (pt2).y || ((pt1).y < (pt2).y && (pt1).x < (pt2).x))
  
             [static] CV_IMPLEMENT_QSORT( icvSortPoints, CvPoint, cmp_pts )
      ------------------------------------------------------------------------------
  
      After that the function "void icvSortPoints( CvPoint* array, size_t total, int aux );"
      is available to user.
  
    aux is an additional parameter, which can be used when comparing elements.
    The current implementation was derived from *BSD system qsort():
  
      * Copyright (c) 1992, 1993
      *  The Regents of the University of California.  All rights reserved.
      *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions
      * are met:
      * 1. Redistributions of source code must retain the above copyright
      *    notice, this list of conditions and the following disclaimer.
      * 2. Redistributions in binary form must reproduce the above copyright
      *    notice, this list of conditions and the following disclaimer in the
      *    documentation and/or other materials provided with the distribution.
      * 3. All advertising materials mentioning features or use of this software
      *    must display the following acknowledgement:
      *  This product includes software developed by the University of
      *  California, Berkeley and its contributors.
      * 4. Neither the name of the University nor the names of its contributors
      *    may be used to endorse or promote products derived from this software
      *    without specific prior written permission.
      *
      * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
      * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
      * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      * SUCH DAMAGE.
  
  \****************************************************************************************/
  
  define CV_IMPLEMENT_QSORT_EX( func_name, T, LT, user_data_type )                   \
  void func_name( T *array, size_t total, user_data_type aux )                        \
  {                                                                                   \
      int isort_thresh = 7;                                                           \
      T t;                                                                            \
      int sp = 0;                                                                     \
                                                                                      \
      struct                                                                          \
      {                                                                               \
          T *lb;                                                                      \
          T *ub;                                                                      \
      }                                                                               \
      stack[48];                                                                      \
                                                                                      \
      aux = aux;                                                                      \
                                                                                      \
      if( total <= 1 )                                                                \
          return;                                                                     \
                                                                                      \
      stack[0].lb = array;                                                            \
      stack[0].ub = array + (total - 1);                                              \
                                                                                      \
      while( sp >= 0 )                                                                \
      {                                                                               \
          T* left = stack[sp].lb;                                                     \
          T* right = stack[sp--].ub;                                                  \
                                                                                      \
          for(;;)                                                                     \
          {                                                                           \
              int i, n = (int)(right - left) + 1, m;                                  \
              T* ptr;                                                                 \
              T* ptr2;                                                                \
                                                                                      \
              if( n <= isort_thresh )                                                 \
              {                                                                       \
              insert_sort:                                                            \
                  for( ptr = left + 1; ptr <= right; ptr++ )                          \
                  {                                                                   \
                      for( ptr2 = ptr; ptr2 > left && LT(ptr2[0],ptr2[-1]); ptr2--)   \
                          CV_SWAP( ptr2[0], ptr2[-1], t );                            \
                  }                                                                   \
                  break;                                                              \
              }                                                                       \
              else                                                                    \
              {                                                                       \
                  T* left0;                                                           \
                  T* left1;                                                           \
                  T* right0;                                                          \
                  T* right1;                                                          \
                  T* pivot;                                                           \
                  T* a;                                                               \
                  T* b;                                                               \
                  T* c;                                                               \
                  int swap_cnt = 0;                                                   \
                                                                                      \
                  left0 = left;                                                       \
                  right0 = right;                                                     \
                  pivot = left + (n/2);                                               \
                                                                                      \
                  if( n > 40 )                                                        \
                  {                                                                   \
                      int d = n / 8;                                                  \
                      a = left, b = left + d, c = left + 2*d;                         \
                      left = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))     \
                                        : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
                                                                                      \
                      a = pivot - d, b = pivot, c = pivot + d;                        \
                      pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))    \
                                        : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
                                                                                      \
                      a = right - 2*d, b = right - d, c = right;                      \
                      right = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))    \
                                        : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
                  }                                                                   \
                                                                                      \
                  a = left, b = pivot, c = right;                                     \
                  pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))        \
                                     : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));       \
                  if( pivot != left0 )                                                \
                  {                                                                   \
                      CV_SWAP( *pivot, *left0, t );                                   \
                      pivot = left0;                                                  \
                  }                                                                   \
                  left = left1 = left0 + 1;                                           \
                  right = right1 = right0;                                            \
                                                                                      \
                  for(;;)                                                             \
                  {                                                                   \
                      while( left <= right && !LT(*pivot, *left) )                    \
                      {                                                               \
                          if( !LT(*left, *pivot) )                                    \
                          {                                                           \
                              if( left > left1 )                                      \
                                  CV_SWAP( *left1, *left, t );                        \
                              swap_cnt = 1;                                           \
                              left1++;                                                \
                          }                                                           \
                          left++;                                                     \
                      }                                                               \
                                                                                      \
                      while( left <= right && !LT(*right, *pivot) )                   \
                      {                                                               \
                          if( !LT(*pivot, *right) )                                   \
                          {                                                           \
                              if( right < right1 )                                    \
                                  CV_SWAP( *right1, *right, t );                      \
                              swap_cnt = 1;                                           \
                              right1--;                                               \
                          }                                                           \
                          right--;                                                    \
                      }                                                               \
                                                                                      \
                      if( left > right )                                              \
                          break;                                                      \
                      CV_SWAP( *left, *right, t );                                    \
                      swap_cnt = 1;                                                   \
                      left++;                                                         \
                      right--;                                                        \
                  }                                                                   \
                                                                                      \
                  if( swap_cnt == 0 )                                                 \
                  {                                                                   \
                      left = left0, right = right0;                                   \
                      goto insert_sort;                                               \
                  }                                                                   \
                                                                                      \
                  n = MIN( (int)(left1 - left0), (int)(left - left1) );               \
                  for( i = 0; i < n; i++ )                                            \
                      CV_SWAP( left0[i], left[i-n], t );                              \
                                                                                      \
                  n = MIN( (int)(right0 - right1), (int)(right1 - right) );           \
                  for( i = 0; i < n; i++ )                                            \
                      CV_SWAP( left[i], right0[i-n+1], t );                           \
                  n = (int)(left - left1);                                            \
                  m = (int)(right1 - right);                                          \
                  if( n > 1 )                                                         \
                  {                                                                   \
                      if( m > 1 )                                                     \
                      {                                                               \
                          if( n > m )                                                 \
                          {                                                           \
                              stack[++sp].lb = left0;                                 \
                              stack[sp].ub = left0 + n - 1;                           \
                              left = right0 - m + 1, right = right0;                  \
                          }                                                           \
                          else                                                        \
                          {                                                           \
                              stack[++sp].lb = right0 - m + 1;                        \
                              stack[sp].ub = right0;                                  \
                              left = left0, right = left0 + n - 1;                    \
                          }                                                           \
                      }                                                               \
                      else                                                            \
                          left = left0, right = left0 + n - 1;                        \
                  }                                                                   \
                  else if( m > 1 )                                                    \
                      left = right0 - m + 1, right = right0;                          \
                  else                                                                \
                      break;                                                          \
              }                                                                       \
          }                                                                           \
      }                                                                               \
  }
  
  define CV_IMPLEMENT_QSORT( func_name, T, cmp )  \
      CV_IMPLEMENT_QSORT_EX( func_name, T, cmp, int )

**************************************************************************************\ Structures and macros for integration with IPP * \***************************************************************************************


  
  
  /* IPP-compatible return codes */
  typedef enum CvStatus
  {
      CV_BADMEMBLOCK_ERR          = -113,
      CV_INPLACE_NOT_SUPPORTED_ERR= -112,
      CV_UNMATCHED_ROI_ERR        = -111,
      CV_NOTFOUND_ERR             = -110,
      CV_BADCONVERGENCE_ERR       = -109,
  
      CV_BADDEPTH_ERR             = -107,
      CV_BADROI_ERR               = -106,
      CV_BADHEADER_ERR            = -105,
      CV_UNMATCHED_FORMATS_ERR    = -104,
      CV_UNSUPPORTED_COI_ERR      = -103,
      CV_UNSUPPORTED_CHANNELS_ERR = -102,
      CV_UNSUPPORTED_DEPTH_ERR    = -101,
      CV_UNSUPPORTED_FORMAT_ERR   = -100,
  
      CV_BADARG_ERR      = -49,  //ipp comp
      CV_NOTDEFINED_ERR  = -48,  //ipp comp
  
      CV_BADCHANNELS_ERR = -47,  //ipp comp
      CV_BADRANGE_ERR    = -44,  //ipp comp
      CV_BADSTEP_ERR     = -29,  //ipp comp
  
      CV_BADFLAG_ERR     =  -12,
      CV_DIV_BY_ZERO_ERR =  -11, //ipp comp
      CV_BADCOEF_ERR     =  -10,
  
      CV_BADFACTOR_ERR   =  -7,
      CV_BADPOINT_ERR    =  -6,
      CV_BADSCALE_ERR    =  -4,
      CV_OUTOFMEM_ERR    =  -3,
      CV_NULLPTR_ERR     =  -2,
      CV_BADSIZE_ERR     =  -1,
      CV_NO_ERR          =   0,
      CV_OK              =   CV_NO_ERR
  }
  CvStatus;
  
  define CV_ERROR_FROM_STATUS( result )                \
      CV_ERROR( cvErrorFromIppStatus( result ), "OpenCV function failed" )
  
  define IPPI_CALL( Func )                                              \
  {                                                                      \
        CvStatus  ippi_call_result;                                      \
        ippi_call_result = Func;                                         \
                                                                         \
        if( ippi_call_result < 0 )                                       \
              CV_ERROR_FROM_STATUS( (ippi_call_result));                 \
  }
  
  define CV_PLUGIN_NONE      0
  define CV_PLUGIN_OPTCV     1 /* custom "emerged" ippopencv library */
  define CV_PLUGIN_IPPCV     2 /* IPP: computer vision */
  define CV_PLUGIN_IPPI      3 /* IPP: image processing */
  define CV_PLUGIN_IPPS      4 /* IPP: signal processing */
  define CV_PLUGIN_IPPVM     5 /* IPP: vector math functions */
  define CV_PLUGIN_IPPCC     6 /* IPP: color space conversion */
  define CV_PLUGIN_MKL       8 /* Intel Math Kernel Library */
  
  define CV_PLUGIN_MAX      16
  
  define CV_PLUGINS1(lib1) ((lib1)&15)
  define CV_PLUGINS2(lib1,lib2) (((lib1)&15)|(((lib2)&15)<<4))
  define CV_PLUGINS3(lib1,lib2,lib3) (((lib1)&15)|(((lib2)&15)<<4)|(((lib2)&15)<<8))
  
  define CV_NOTHROW throw()
  
  ifndef IPCVAPI
  define IPCVAPI(type,declspec,name,args)                        \
      /* function pointer */                                      \
      typedef type (declspec* name##_t) args;                     \
      extern name##_t name##_p;                                   \
      type declspec name args;
  endif
  
  define IPCVAPI_EX(type,name,ipp_name,ipp_search_modules,args)  \
      IPCVAPI(type,CV_STDCALL,name,args)
  
  define IPCVAPI_C_EX(type,name,ipp_name,ipp_search_modules,args)\
      IPCVAPI(type,CV_CDECL,name,args)
  
  ifndef IPCVAPI_IMPL
  define IPCVAPI_IMPL(type,name,args,arg_names)                  \
      static type CV_STDCALL name##_f args;                       \
      name##_t name##_p = name##_f;                               \
      type CV_STDCALL name args { return name##_p arg_names; }    \
      static type CV_STDCALL name##_f args
  endif
  
  /* IPP types' enumeration */
  typedef enum CvDataType {
      cv1u,
      cv8u, cv8s,
      cv16u, cv16s, cv16sc,
      cv32u, cv32s, cv32sc,
      cv32f, cv32fc,
      cv64u, cv64s, cv64sc,
      cv64f, cv64fc
  } CvDataType;
  
  typedef enum CvHintAlgorithm {
      cvAlgHintNone,
      cvAlgHintFast,
      cvAlgHintAccurate
  } CvHintAlgorithm;
  
  typedef enum CvCmpOp {
      cvCmpLess,
      cvCmpLessEq,
      cvCmpEq,
      cvCmpGreaterEq,
      cvCmpGreater
  } CvCmpOp;
  
  typedef struct CvFuncTable
  {
      void*   fn_2d[CV_DEPTH_MAX];
  }
  CvFuncTable;
  
  typedef struct CvBigFuncTable
  {
      void*   fn_2d[CV_DEPTH_MAX*CV_CN_MAX];
  }
  CvBigFuncTable;
  
  typedef struct CvBtFuncTable
  {
      void*   fn_2d[33];
  }
  CvBtFuncTable;
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_1A)(void* arr, int step, CvSize size);
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_1A1P)(void* arr, int step, CvSize size, void* param);
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_1A1P1I)(void* arr, int step, CvSize size,
                                                 void* param, int flag);
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A1P)( void* arr, int step, CvSize size,
                                                  int cn, int coi, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A1P)( void* arr, int step, CvSize size,
                                                  int cn, int coi, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_1A2P)( void* arr, int step, CvSize size,
                                                void* param1, void* param2 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A2P)( void* arr, int step,
                                                  CvSize size, int cn, int coi,
                                                  void* param1, void* param2 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_1A4P)( void* arr, int step, CvSize size,
                                                void* param1, void* param2,
                                                void* param3, void* param4 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A4P)( void* arr, int step,
                                                  CvSize size, int cn, int coi,
                                                  void* param1, void* param2,
                                                  void* param3, void* param4 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_2A)( void* arr0, int step0,
                                              void* arr1, int step1, CvSize size );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_2A1P)( void* arr0, int step0,
                                                void* arr1, int step1,
                                                CvSize size, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A1P)( void* arr0, int step0,
                                                  void* arr1, int step1,
                                                  CvSize size, int cn,
                                                  int coi, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A1P)( void* arr0, int step0,
                                                  void* arr1, int step1,
                                                  CvSize size, int cn,
                                                  int coi, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_2A2P)( void* arr0, int step0,
                                                void* arr1, int step1, CvSize size,
                                                void* param1, void* param2 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A2P)( void* arr0, int step0,
                                                  void* arr1, int step1,
                                                  CvSize size, int cn, int coi,
                                                  void* param1, void* param2 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_2A1P1I)( void* arr0, int step0,
                                                  void* arr1, int step1, CvSize size,
                                                  void* param, int flag );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_2A4P)( void* arr0, int step0,
                                                void* arr1, int step1, CvSize size,
                                                void* param1, void* param2,
                                                void* param3, void* param4 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A4P)( void* arr0, int step0,
                                                  void* arr1, int step1, CvSize size,
                                                  int cn, int coi,
                                                  void* param1, void* param2,
                                                  void* param3, void* param4 );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_3A)( void* arr0, int step0,
                                              void* arr1, int step1,
                                              void* arr2, int step2, CvSize size );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_3A1P)( void* arr0, int step0,
                                                void* arr1, int step1,
                                                void* arr2, int step2,
                                                CvSize size, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_3A1I)( void* arr0, int step0,
                                                void* arr1, int step1,
                                                void* arr2, int step2,
                                                CvSize size, int flag );
  
  typedef CvStatus (CV_STDCALL *CvFunc2DnC_3A1P)( void* arr0, int step0,
                                                  void* arr1, int step1,
                                                  void* arr2, int step2,
                                                  CvSize size, int cn,
                                                  int coi, void* param );
  
  typedef CvStatus (CV_STDCALL *CvFunc2D_4A)( void* arr0, int step0,
                                              void* arr1, int step1,
                                              void* arr2, int step2,
                                              void* arr3, int step3,
                                              CvSize size );
  
  typedef CvStatus (CV_STDCALL *CvFunc0D)( const void* src, void* dst, int param );
  
  define CV_DEF_INIT_FUNC_TAB_2D( FUNCNAME, FLAG )                   \
  static void  icvInit##FUNCNAME##FLAG##Table( CvFuncTable* tab )     \
  {                                                                   \
      assert( tab );                                                  \
                                                                      \
      tab->fn_2d[CV_8U]  = (void*)icv##FUNCNAME##_8u_##FLAG;          \
      tab->fn_2d[CV_8S]  = (void*)icv##FUNCNAME##_8s_##FLAG;          \
      tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_##FLAG;         \
      tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_##FLAG;         \
      tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s_##FLAG;         \
      tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_##FLAG;         \
      tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_##FLAG;         \
  }
  
  define CV_DEF_INIT_BIG_FUNC_TAB_2D( FUNCNAME, FLAG )               \
  static void  icvInit##FUNCNAME##FLAG##Table( CvBigFuncTable* tab )  \
  {                                                                   \
      assert( tab );                                                  \
                                                                      \
      tab->fn_2d[CV_8UC1]  = (void*)icv##FUNCNAME##_8u_C1##FLAG;      \
      tab->fn_2d[CV_8UC2]  = (void*)icv##FUNCNAME##_8u_C2##FLAG;      \
      tab->fn_2d[CV_8UC3]  = (void*)icv##FUNCNAME##_8u_C3##FLAG;      \
      tab->fn_2d[CV_8UC4]  = (void*)icv##FUNCNAME##_8u_C4##FLAG;      \
                                                                      \
      tab->fn_2d[CV_8SC1]  = (void*)icv##FUNCNAME##_8s_C1##FLAG;      \
      tab->fn_2d[CV_8SC2]  = (void*)icv##FUNCNAME##_8s_C2##FLAG;      \
      tab->fn_2d[CV_8SC3]  = (void*)icv##FUNCNAME##_8s_C3##FLAG;      \
      tab->fn_2d[CV_8SC4]  = (void*)icv##FUNCNAME##_8s_C4##FLAG;      \
                                                                      \
      tab->fn_2d[CV_16UC1] = (void*)icv##FUNCNAME##_16u_C1##FLAG;     \
      tab->fn_2d[CV_16UC2] = (void*)icv##FUNCNAME##_16u_C2##FLAG;     \
      tab->fn_2d[CV_16UC3] = (void*)icv##FUNCNAME##_16u_C3##FLAG;     \
      tab->fn_2d[CV_16UC4] = (void*)icv##FUNCNAME##_16u_C4##FLAG;     \
                                                                      \
      tab->fn_2d[CV_16SC1] = (void*)icv##FUNCNAME##_16s_C1##FLAG;     \
      tab->fn_2d[CV_16SC2] = (void*)icv##FUNCNAME##_16s_C2##FLAG;     \
      tab->fn_2d[CV_16SC3] = (void*)icv##FUNCNAME##_16s_C3##FLAG;     \
      tab->fn_2d[CV_16SC4] = (void*)icv##FUNCNAME##_16s_C4##FLAG;     \
                                                                      \
      tab->fn_2d[CV_32SC1] = (void*)icv##FUNCNAME##_32s_C1##FLAG;     \
      tab->fn_2d[CV_32SC2] = (void*)icv##FUNCNAME##_32s_C2##FLAG;     \
      tab->fn_2d[CV_32SC3] = (void*)icv##FUNCNAME##_32s_C3##FLAG;     \
      tab->fn_2d[CV_32SC4] = (void*)icv##FUNCNAME##_32s_C4##FLAG;     \
                                                                      \
      tab->fn_2d[CV_32FC1] = (void*)icv##FUNCNAME##_32f_C1##FLAG;     \
      tab->fn_2d[CV_32FC2] = (void*)icv##FUNCNAME##_32f_C2##FLAG;     \
      tab->fn_2d[CV_32FC3] = (void*)icv##FUNCNAME##_32f_C3##FLAG;     \
      tab->fn_2d[CV_32FC4] = (void*)icv##FUNCNAME##_32f_C4##FLAG;     \
                                                                      \
      tab->fn_2d[CV_64FC1] = (void*)icv##FUNCNAME##_64f_C1##FLAG;     \
      tab->fn_2d[CV_64FC2] = (void*)icv##FUNCNAME##_64f_C2##FLAG;     \
      tab->fn_2d[CV_64FC3] = (void*)icv##FUNCNAME##_64f_C3##FLAG;     \
      tab->fn_2d[CV_64FC4] = (void*)icv##FUNCNAME##_64f_C4##FLAG;     \
  }
  
  define CV_DEF_INIT_FUNC_TAB_0D( FUNCNAME )                         \
  static void  icvInit##FUNCNAME##Table( CvFuncTable* tab )           \
  {                                                                   \
      tab->fn_2d[CV_8U]  = (void*)icv##FUNCNAME##_8u;                 \
      tab->fn_2d[CV_8S]  = (void*)icv##FUNCNAME##_8s;                 \
      tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u;                \
      tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s;                \
      tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s;                \
      tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f;                \
      tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f;                \
  }
  
  define CV_DEF_INIT_FUNC_TAB_1D  CV_DEF_INIT_FUNC_TAB_0D
  
  define CV_DEF_INIT_PIXSIZE_TAB_2D( FUNCNAME, FLAG )                \
  static void icvInit##FUNCNAME##FLAG##Table( CvBtFuncTable* table )  \
  {                                                                   \
      table->fn_2d[1]  = (void*)icv##FUNCNAME##_8u_C1##FLAG;          \
      table->fn_2d[2]  = (void*)icv##FUNCNAME##_8u_C2##FLAG;          \
      table->fn_2d[3]  = (void*)icv##FUNCNAME##_8u_C3##FLAG;          \
      table->fn_2d[4]  = (void*)icv##FUNCNAME##_16u_C2##FLAG;         \
      table->fn_2d[6]  = (void*)icv##FUNCNAME##_16u_C3##FLAG;         \
      table->fn_2d[8]  = (void*)icv##FUNCNAME##_32s_C2##FLAG;         \
      table->fn_2d[12] = (void*)icv##FUNCNAME##_32s_C3##FLAG;         \
      table->fn_2d[16] = (void*)icv##FUNCNAME##_64s_C2##FLAG;         \
      table->fn_2d[24] = (void*)icv##FUNCNAME##_64s_C3##FLAG;         \
      table->fn_2d[32] = (void*)icv##FUNCNAME##_64s_C4##FLAG;         \
  }
  
  define  CV_GET_FUNC_PTR( func, table_entry )  \
      func = (table_entry);                      \
                                                 \
      if( !func )                                \
          CV_ERROR( CV_StsUnsupportedFormat, "" )
  
  endif /*_CXCORE_MISC_H_*/

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.