opencv 2.2.0
/usr/src/RPM/BUILD/libopencv2.2-2.2.0/modules/core/include/opencv2/core/internal.hpp
Go to the documentation of this file.
00001 /*M///////////////////////////////////////////////////////////////////////////////////////
00002 //
00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
00004 //
00005 //  By downloading, copying, installing or using the software you agree to this license.
00006 //  If you do not agree to this license, do not download, install,
00007 //  copy or use the software.
00008 //
00009 //
00010 //                           License Agreement
00011 //                For Open Source Computer Vision Library
00012 //
00013 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
00014 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
00015 // Third party copyrights are property of their respective owners.
00016 //
00017 // Redistribution and use in source and binary forms, with or without modification,
00018 // are permitted provided that the following conditions are met:
00019 //
00020 //   * Redistribution's of source code must retain the above copyright notice,
00021 //     this list of conditions and the following disclaimer.
00022 //
00023 //   * Redistribution's in binary form must reproduce the above copyright notice,
00024 //     this list of conditions and the following disclaimer in the documentation
00025 //     and/or other materials provided with the distribution.
00026 //
00027 //   * The name of the copyright holders may not be used to endorse or promote products
00028 //     derived from this software without specific prior written permission.
00029 //
00030 // This software is provided by the copyright holders and contributors "as is" and
00031 // any express or implied warranties, including, but not limited to, the implied
00032 // warranties of merchantability and fitness for a particular purpose are disclaimed.
00033 // In no event shall the Intel Corporation or contributors be liable for any direct,
00034 // indirect, incidental, special, exemplary, or consequential damages
00035 // (including, but not limited to, procurement of substitute goods or services;
00036 // loss of use, data, or profits; or business interruption) however caused
00037 // and on any theory of liability, whether in contract, strict liability,
00038 // or tort (including negligence or otherwise) arising in any way out of
00039 // the use of this software, even if advised of the possibility of such damage.
00040 //
00041 //M*/
00042 
00043 /* The header is for internal use and it is likely to change.
00044    It contains some macro definitions that are used in cxcore, cv, cvaux
00045    and, probably, other libraries. If you need some of this functionality,
00046    the safe way is to copy it into your code and rename the macros.
00047 */
00048 #ifndef __OPENCV_CORE_INTERNAL_HPP__
00049 #define __OPENCV_CORE_INTERNAL_HPP__
00050 
00051 #include <vector>
00052 
00053 #if defined WIN32 || defined _WIN32
00054 #  ifndef WIN32
00055 #    define WIN32
00056 #  endif
00057 #  ifndef _WIN32
00058 #    define _WIN32
00059 #  endif
00060 #endif
00061 
00062 #if defined WIN32 || defined WINCE
00063 #ifndef _WIN32_WINNT         // This is needed for the declaration of TryEnterCriticalSection in winbase.h with Visual Studio 2005 (and older?)
00064 #define _WIN32_WINNT 0x0400  // http://msdn.microsoft.com/en-us/library/ms686857(VS.85).aspx
00065 #endif
00066 #include <windows.h>
00067 #undef small
00068 #undef min
00069 #undef max
00070 #else
00071 #include <pthread.h>
00072 #include <sys/mman.h>
00073 #endif
00074 
00075 #ifdef __BORLANDC__
00076 #ifndef WIN32
00077     #define     WIN32
00078 #endif
00079 #ifndef _WIN32
00080     #define     _WIN32
00081 #endif
00082     #define     CV_DLL
00083     #undef      _CV_ALWAYS_PROFILE_
00084     #define     _CV_ALWAYS_NO_PROFILE_
00085 #endif
00086 
00087 #ifndef FALSE
00088 #define FALSE 0
00089 #endif
00090 #ifndef TRUE
00091 #define TRUE 1
00092 #endif
00093 
00094 #define __BEGIN__ __CV_BEGIN__
00095 #define __END__ __CV_END__
00096 #define EXIT __CV_EXIT__
00097 
00098 #ifdef HAVE_IPP
00099 #include "ipp.h"
00100 
00101 CV_INLINE IppiSize ippiSize(int width, int height)
00102 {
00103     IppiSize size = { width, height };
00104     return size;
00105 }
00106 #endif
00107 
00108 #if defined __SSE2__ || _MSC_VER >= 1300
00109 #include "emmintrin.h"
00110 #define CV_SSE 1
00111 #define CV_SSE2 1
00112 #if defined __SSE3__ || _MSC_VER >= 1500
00113 #include "pmmintrin.h"
00114 #define CV_SSE3 1
00115 #endif
00116 #else
00117 #define CV_SSE 0
00118 #define CV_SSE2 0
00119 #define CV_SSE3 0
00120 #endif
00121 
00122 #ifndef IPPI_CALL
00123 #define IPPI_CALL(func) CV_Assert((func) >= 0)
00124 #endif
00125 
00126 #ifdef HAVE_TBB
00127     #include "tbb/tbb_stddef.h"
00128     #if TBB_VERSION_MAJOR*100 + TBB_VERSION_MINOR >= 202
00129         #include "tbb/tbb.h"
00130         #undef min
00131         #undef max
00132     #else
00133         #undef HAVE_TBB
00134     #endif
00135 #endif
00136 
00137 #ifdef HAVE_EIGEN2
00138     #include <Eigen/Core>
00139     #include "opencv2/core/eigen.hpp"
00140 #endif
00141 
00142 #ifdef __cplusplus
00143 
00144 #ifdef HAVE_TBB
00145     namespace cv
00146     {
00147         typedef tbb::blocked_range<int> BlockedRange;
00148         
00149         template<typename Body> static inline
00150         void parallel_for( const BlockedRange& range, const Body& body )
00151         {
00152             tbb::parallel_for(range, body);
00153         }
00154         
00155         template<typename Iterator, typename Body> static inline
00156         void parallel_do( Iterator first, Iterator last, const Body& body )
00157         {
00158             tbb::parallel_do(first, last, body);
00159         }
00160         
00161         typedef tbb::split Split;
00162         
00163         template<typename Body> static inline
00164         void parallel_reduce( const BlockedRange& range, Body& body )
00165         {
00166             tbb::parallel_reduce(range, body);
00167         }
00168         
00169         typedef tbb::concurrent_vector<Rect> ConcurrentRectVector;
00170     }
00171 #else
00172     namespace cv
00173     {
00174         class BlockedRange
00175         {
00176         public:
00177             BlockedRange() : _begin(0), _end(0), _grainsize(0) {}
00178             BlockedRange(int b, int e, int g=1) : _begin(b), _end(e), _grainsize(g) {}
00179             int begin() const { return _begin; }
00180             int end() const { return _end; }
00181             int grainsize() const { return _grainsize; }
00182             
00183         protected:
00184             int _begin, _end, _grainsize;
00185         };
00186 
00187         template<typename Body> static inline
00188         void parallel_for( const BlockedRange& range, const Body& body )
00189         {
00190             body(range);
00191         }
00192         
00193         template<typename Iterator, typename Body> static inline
00194         void parallel_do( Iterator first, Iterator last, const Body& body )
00195         {
00196             for( ; first != last; ++first )
00197                 body(*first);
00198         }
00199         
00200         class Split {};
00201         
00202         template<typename Body> static inline
00203         void parallel_reduce( const BlockedRange& range, Body& body )
00204         {
00205             body(range);
00206         }
00207         
00208         typedef std::vector<Rect> ConcurrentRectVector;
00209     }
00210 #endif
00211 #endif
00212 
00213 /* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */
00214 #define  CV_MAX_INLINE_MAT_OP_SIZE  10
00215 
00216 /* maximal linear size of matrix to allocate it on stack. */
00217 #define  CV_MAX_LOCAL_MAT_SIZE  32
00218 
00219 /* maximal size of local memory storage */
00220 #define  CV_MAX_LOCAL_SIZE  \
00221     (CV_MAX_LOCAL_MAT_SIZE*CV_MAX_LOCAL_MAT_SIZE*(int)sizeof(double))
00222 
00223 /* default image row align (in bytes) */
00224 #define  CV_DEFAULT_IMAGE_ROW_ALIGN  4
00225 
00226 /* matrices are continuous by default */
00227 #define  CV_DEFAULT_MAT_ROW_ALIGN  1
00228 
00229 /* maximum size of dynamic memory buffer.
00230    cvAlloc reports an error if a larger block is requested. */
00231 #define  CV_MAX_ALLOC_SIZE    (((size_t)1 << (sizeof(size_t)*8-2)))
00232 
00233 /* the alignment of all the allocated buffers */
00234 #define  CV_MALLOC_ALIGN    16
00235 
00236 /* default alignment for dynamic data strucutures, resided in storages. */
00237 #define  CV_STRUCT_ALIGN    ((int)sizeof(double))
00238 
00239 /* default storage block size */
00240 #define  CV_STORAGE_BLOCK_SIZE   ((1<<16) - 128)
00241 
00242 /* default memory block for sparse array elements */
00243 #define  CV_SPARSE_MAT_BLOCK    (1<<12)
00244 
00245 /* initial hash table size */
00246 #define  CV_SPARSE_HASH_SIZE0    (1<<10)
00247 
00248 /* maximal average node_count/hash_size ratio beyond which hash table is resized */
00249 #define  CV_SPARSE_HASH_RATIO    3
00250 
00251 /* max length of strings */
00252 #define  CV_MAX_STRLEN  1024
00253 
00254 #if 0 /*def  CV_CHECK_FOR_NANS*/
00255     #define CV_CHECK_NANS( arr ) cvCheckArray((arr))
00256 #else
00257     #define CV_CHECK_NANS( arr )
00258 #endif
00259 
00260 /****************************************************************************************\
00261 *                                  Common declarations                                   *
00262 \****************************************************************************************/
00263 
00264 /* get alloca declaration */
00265 #ifdef __GNUC__
00266     #undef alloca
00267     #define alloca __builtin_alloca
00268 #elif defined WIN32 || defined _WIN32 || \
00269       defined WINCE || defined _MSC_VER || defined __BORLANDC__
00270     #include <malloc.h>
00271 #elif defined HAVE_ALLOCA_H
00272     #include <alloca.h>
00273 #elif defined HAVE_ALLOCA
00274     #include <stdlib.h>
00275 #else
00276     #error "No alloca!"
00277 #endif
00278 
00279 #ifdef __GNUC__
00280 #define CV_DECL_ALIGNED(x) __attribute__ ((aligned (x)))
00281 #elif defined _MSC_VER
00282 #define CV_DECL_ALIGNED(x) __declspec(align(x))
00283 #else
00284 #define CV_DECL_ALIGNED(x)
00285 #endif
00286 
00287 /* ! DO NOT make it an inline function */
00288 #define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN )
00289 
00290 #if defined _MSC_VER || defined __BORLANDC__
00291     #define CV_BIG_INT(n)   n##I64
00292     #define CV_BIG_UINT(n)  n##UI64
00293 #else
00294     #define CV_BIG_INT(n)   n##LL
00295     #define CV_BIG_UINT(n)  n##ULL
00296 #endif
00297 
00298 #ifndef CV_IMPL
00299 #define CV_IMPL CV_EXTERN_C
00300 #endif
00301 
00302 #define CV_DBG_BREAK() { volatile int* crashMe = 0; *crashMe = 0; }
00303 
00304 /* default step, set in case of continuous data
00305    to work around checks for valid step in some ipp functions */
00306 #define  CV_STUB_STEP     (1 << 30)
00307 
00308 #define  CV_SIZEOF_FLOAT ((int)sizeof(float))
00309 #define  CV_SIZEOF_SHORT ((int)sizeof(short))
00310 
00311 #define  CV_ORIGIN_TL  0
00312 #define  CV_ORIGIN_BL  1
00313 
00314 /* IEEE754 constants and macros */
00315 #define  CV_POS_INF       0x7f800000
00316 #define  CV_NEG_INF       0x807fffff /* CV_TOGGLE_FLT(0xff800000) */
00317 #define  CV_1F            0x3f800000
00318 #define  CV_TOGGLE_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0))
00319 #define  CV_TOGGLE_DBL(x) \
00320     ((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0))
00321 
00322 #define  CV_NOP(a)      (a)
00323 #define  CV_ADD(a, b)   ((a) + (b))
00324 #define  CV_SUB(a, b)   ((a) - (b))
00325 #define  CV_MUL(a, b)   ((a) * (b))
00326 #define  CV_AND(a, b)   ((a) & (b))
00327 #define  CV_OR(a, b)    ((a) | (b))
00328 #define  CV_XOR(a, b)   ((a) ^ (b))
00329 #define  CV_ANDN(a, b)  (~(a) & (b))
00330 #define  CV_ORN(a, b)   (~(a) | (b))
00331 #define  CV_SQR(a)      ((a) * (a))
00332 
00333 #define  CV_LT(a, b)    ((a) < (b))
00334 #define  CV_LE(a, b)    ((a) <= (b))
00335 #define  CV_EQ(a, b)    ((a) == (b))
00336 #define  CV_NE(a, b)    ((a) != (b))
00337 #define  CV_GT(a, b)    ((a) > (b))
00338 #define  CV_GE(a, b)    ((a) >= (b))
00339 
00340 #define  CV_NONZERO(a)      ((a) != 0)
00341 #define  CV_NONZERO_FLT(a)  (((a)+(a)) != 0)
00342 
00343 /* general-purpose saturation macros */
00344 #define  CV_CAST_8U(t)  (uchar)(!((t) & ~255) ? (t) : (t) > 0 ? 255 : 0)
00345 #define  CV_CAST_8S(t)  (schar)(!(((t)+128) & ~255) ? (t) : (t) > 0 ? 127 : -128)
00346 #define  CV_CAST_16U(t) (ushort)(!((t) & ~65535) ? (t) : (t) > 0 ? 65535 : 0)
00347 #define  CV_CAST_16S(t) (short)(!(((t)+32768) & ~65535) ? (t) : (t) > 0 ? 32767 : -32768)
00348 #define  CV_CAST_32S(t) (int)(t)
00349 #define  CV_CAST_64S(t) (int64)(t)
00350 #define  CV_CAST_32F(t) (float)(t)
00351 #define  CV_CAST_64F(t) (double)(t)
00352 
00353 #define  CV_PASTE2(a,b) a##b
00354 #define  CV_PASTE(a,b)  CV_PASTE2(a,b)
00355 
00356 #define  CV_EMPTY
00357 #define  CV_MAKE_STR(a) #a
00358 
00359 #define  CV_ZERO_OBJ(x) memset((x), 0, sizeof(*(x)))
00360 
00361 #define  CV_DIM(static_array) ((int)(sizeof(static_array)/sizeof((static_array)[0])))
00362 
00363 #define  cvUnsupportedFormat "Unsupported format"
00364 
00365 CV_INLINE void* cvAlignPtr( const void* ptr, int align CV_DEFAULT(32) )
00366 {
00367     assert( (align & (align-1)) == 0 );
00368     return (void*)( ((size_t)ptr + align - 1) & ~(size_t)(align-1) );
00369 }
00370 
00371 CV_INLINE int cvAlign( int size, int align )
00372 {
00373     assert( (align & (align-1)) == 0 && size < INT_MAX );
00374     return (size + align - 1) & -align;
00375 }
00376 
00377 CV_INLINE  CvSize  cvGetMatSize( const CvMat* mat )
00378 {
00379     CvSize size;
00380     size.width = mat->cols;
00381     size.height = mat->rows;
00382     return size;
00383 }
00384 
00385 #define  CV_DESCALE(x,n)     (((x) + (1 << ((n)-1))) >> (n))
00386 #define  CV_FLT_TO_FIX(x,n)  cvRound((x)*(1<<(n)))
00387 
00388 /****************************************************************************************\
00389 
00390   Generic implementation of QuickSort algorithm.
00391   ----------------------------------------------
00392   Using this macro user can declare customized sort function that can be much faster
00393   than built-in qsort function because of lower overhead on elements
00394   comparison and exchange. The macro takes less_than (or LT) argument - a macro or function
00395   that takes 2 arguments returns non-zero if the first argument should be before the second
00396   one in the sorted sequence and zero otherwise.
00397 
00398   Example:
00399 
00400     Suppose that the task is to sort points by ascending of y coordinates and if
00401     y's are equal x's should ascend.
00402 
00403     The code is:
00404     ------------------------------------------------------------------------------
00405            #define cmp_pts( pt1, pt2 ) \
00406                ((pt1).y < (pt2).y || ((pt1).y < (pt2).y && (pt1).x < (pt2).x))
00407 
00408            [static] CV_IMPLEMENT_QSORT( icvSortPoints, CvPoint, cmp_pts )
00409     ------------------------------------------------------------------------------
00410 
00411     After that the function "void icvSortPoints( CvPoint* array, size_t total, int aux );"
00412     is available to user.
00413 
00414   aux is an additional parameter, which can be used when comparing elements.
00415   The current implementation was derived from *BSD system qsort():
00416 
00417     * Copyright (c) 1992, 1993
00418     *  The Regents of the University of California.  All rights reserved.
00419     *
00420     * Redistribution and use in source and binary forms, with or without
00421     * modification, are permitted provided that the following conditions
00422     * are met:
00423     * 1. Redistributions of source code must retain the above copyright
00424     *    notice, this list of conditions and the following disclaimer.
00425     * 2. Redistributions in binary form must reproduce the above copyright
00426     *    notice, this list of conditions and the following disclaimer in the
00427     *    documentation and/or other materials provided with the distribution.
00428     * 3. All advertising materials mentioning features or use of this software
00429     *    must display the following acknowledgement:
00430     *  This product includes software developed by the University of
00431     *  California, Berkeley and its contributors.
00432     * 4. Neither the name of the University nor the names of its contributors
00433     *    may be used to endorse or promote products derived from this software
00434     *    without specific prior written permission.
00435     *
00436     * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
00437     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00438     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00439     * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
00440     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00441     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
00442     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
00443     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00444     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
00445     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00446     * SUCH DAMAGE.
00447 
00448 \****************************************************************************************/
00449 
00450 #define CV_IMPLEMENT_QSORT_EX( func_name, T, LT, user_data_type )                   \
00451 void func_name( T *array, size_t total, user_data_type aux )                        \
00452 {                                                                                   \
00453     int isort_thresh = 7;                                                           \
00454     T t;                                                                            \
00455     int sp = 0;                                                                     \
00456                                                                                     \
00457     struct                                                                          \
00458     {                                                                               \
00459         T *lb;                                                                      \
00460         T *ub;                                                                      \
00461     }                                                                               \
00462     stack[48];                                                                      \
00463                                                                                     \
00464     aux = aux;                                                                      \
00465                                                                                     \
00466     if( total <= 1 )                                                                \
00467         return;                                                                     \
00468                                                                                     \
00469     stack[0].lb = array;                                                            \
00470     stack[0].ub = array + (total - 1);                                              \
00471                                                                                     \
00472     while( sp >= 0 )                                                                \
00473     {                                                                               \
00474         T* left = stack[sp].lb;                                                     \
00475         T* right = stack[sp--].ub;                                                  \
00476                                                                                     \
00477         for(;;)                                                                     \
00478         {                                                                           \
00479             int i, n = (int)(right - left) + 1, m;                                  \
00480             T* ptr;                                                                 \
00481             T* ptr2;                                                                \
00482                                                                                     \
00483             if( n <= isort_thresh )                                                 \
00484             {                                                                       \
00485             insert_sort:                                                            \
00486                 for( ptr = left + 1; ptr <= right; ptr++ )                          \
00487                 {                                                                   \
00488                     for( ptr2 = ptr; ptr2 > left && LT(ptr2[0],ptr2[-1]); ptr2--)   \
00489                         CV_SWAP( ptr2[0], ptr2[-1], t );                            \
00490                 }                                                                   \
00491                 break;                                                              \
00492             }                                                                       \
00493             else                                                                    \
00494             {                                                                       \
00495                 T* left0;                                                           \
00496                 T* left1;                                                           \
00497                 T* right0;                                                          \
00498                 T* right1;                                                          \
00499                 T* pivot;                                                           \
00500                 T* a;                                                               \
00501                 T* b;                                                               \
00502                 T* c;                                                               \
00503                 int swap_cnt = 0;                                                   \
00504                                                                                     \
00505                 left0 = left;                                                       \
00506                 right0 = right;                                                     \
00507                 pivot = left + (n/2);                                               \
00508                                                                                     \
00509                 if( n > 40 )                                                        \
00510                 {                                                                   \
00511                     int d = n / 8;                                                  \
00512                     a = left, b = left + d, c = left + 2*d;                         \
00513                     left = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))     \
00514                                       : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
00515                                                                                     \
00516                     a = pivot - d, b = pivot, c = pivot + d;                        \
00517                     pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))    \
00518                                       : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
00519                                                                                     \
00520                     a = right - 2*d, b = right - d, c = right;                      \
00521                     right = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))    \
00522                                       : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
00523                 }                                                                   \
00524                                                                                     \
00525                 a = left, b = pivot, c = right;                                     \
00526                 pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))        \
00527                                    : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));       \
00528                 if( pivot != left0 )                                                \
00529                 {                                                                   \
00530                     CV_SWAP( *pivot, *left0, t );                                   \
00531                     pivot = left0;                                                  \
00532                 }                                                                   \
00533                 left = left1 = left0 + 1;                                           \
00534                 right = right1 = right0;                                            \
00535                                                                                     \
00536                 for(;;)                                                             \
00537                 {                                                                   \
00538                     while( left <= right && !LT(*pivot, *left) )                    \
00539                     {                                                               \
00540                         if( !LT(*left, *pivot) )                                    \
00541                         {                                                           \
00542                             if( left > left1 )                                      \
00543                                 CV_SWAP( *left1, *left, t );                        \
00544                             swap_cnt = 1;                                           \
00545                             left1++;                                                \
00546                         }                                                           \
00547                         left++;                                                     \
00548                     }                                                               \
00549                                                                                     \
00550                     while( left <= right && !LT(*right, *pivot) )                   \
00551                     {                                                               \
00552                         if( !LT(*pivot, *right) )                                   \
00553                         {                                                           \
00554                             if( right < right1 )                                    \
00555                                 CV_SWAP( *right1, *right, t );                      \
00556                             swap_cnt = 1;                                           \
00557                             right1--;                                               \
00558                         }                                                           \
00559                         right--;                                                    \
00560                     }                                                               \
00561                                                                                     \
00562                     if( left > right )                                              \
00563                         break;                                                      \
00564                     CV_SWAP( *left, *right, t );                                    \
00565                     swap_cnt = 1;                                                   \
00566                     left++;                                                         \
00567                     right--;                                                        \
00568                 }                                                                   \
00569                                                                                     \
00570                 if( swap_cnt == 0 )                                                 \
00571                 {                                                                   \
00572                     left = left0, right = right0;                                   \
00573                     goto insert_sort;                                               \
00574                 }                                                                   \
00575                                                                                     \
00576                 n = MIN( (int)(left1 - left0), (int)(left - left1) );               \
00577                 for( i = 0; i < n; i++ )                                            \
00578                     CV_SWAP( left0[i], left[i-n], t );                              \
00579                                                                                     \
00580                 n = MIN( (int)(right0 - right1), (int)(right1 - right) );           \
00581                 for( i = 0; i < n; i++ )                                            \
00582                     CV_SWAP( left[i], right0[i-n+1], t );                           \
00583                 n = (int)(left - left1);                                            \
00584                 m = (int)(right1 - right);                                          \
00585                 if( n > 1 )                                                         \
00586                 {                                                                   \
00587                     if( m > 1 )                                                     \
00588                     {                                                               \
00589                         if( n > m )                                                 \
00590                         {                                                           \
00591                             stack[++sp].lb = left0;                                 \
00592                             stack[sp].ub = left0 + n - 1;                           \
00593                             left = right0 - m + 1, right = right0;                  \
00594                         }                                                           \
00595                         else                                                        \
00596                         {                                                           \
00597                             stack[++sp].lb = right0 - m + 1;                        \
00598                             stack[sp].ub = right0;                                  \
00599                             left = left0, right = left0 + n - 1;                    \
00600                         }                                                           \
00601                     }                                                               \
00602                     else                                                            \
00603                         left = left0, right = left0 + n - 1;                        \
00604                 }                                                                   \
00605                 else if( m > 1 )                                                    \
00606                     left = right0 - m + 1, right = right0;                          \
00607                 else                                                                \
00608                     break;                                                          \
00609             }                                                                       \
00610         }                                                                           \
00611     }                                                                               \
00612 }
00613 
00614 #define CV_IMPLEMENT_QSORT( func_name, T, cmp )  \
00615     CV_IMPLEMENT_QSORT_EX( func_name, T, cmp, int )
00616 
00617 /****************************************************************************************\
00618 *                     Structures and macros for integration with IPP                     *
00619 \****************************************************************************************/
00620 
00621 /* IPP-compatible return codes */
00622 typedef enum CvStatus
00623 {
00624     CV_BADMEMBLOCK_ERR          = -113,
00625     CV_INPLACE_NOT_SUPPORTED_ERR= -112,
00626     CV_UNMATCHED_ROI_ERR        = -111,
00627     CV_NOTFOUND_ERR             = -110,
00628     CV_BADCONVERGENCE_ERR       = -109,
00629 
00630     CV_BADDEPTH_ERR             = -107,
00631     CV_BADROI_ERR               = -106,
00632     CV_BADHEADER_ERR            = -105,
00633     CV_UNMATCHED_FORMATS_ERR    = -104,
00634     CV_UNSUPPORTED_COI_ERR      = -103,
00635     CV_UNSUPPORTED_CHANNELS_ERR = -102,
00636     CV_UNSUPPORTED_DEPTH_ERR    = -101,
00637     CV_UNSUPPORTED_FORMAT_ERR   = -100,
00638 
00639     CV_BADARG_ERR      = -49,  //ipp comp
00640     CV_NOTDEFINED_ERR  = -48,  //ipp comp
00641 
00642     CV_BADCHANNELS_ERR = -47,  //ipp comp
00643     CV_BADRANGE_ERR    = -44,  //ipp comp
00644     CV_BADSTEP_ERR     = -29,  //ipp comp
00645 
00646     CV_BADFLAG_ERR     =  -12,
00647     CV_DIV_BY_ZERO_ERR =  -11, //ipp comp
00648     CV_BADCOEF_ERR     =  -10,
00649 
00650     CV_BADFACTOR_ERR   =  -7,
00651     CV_BADPOINT_ERR    =  -6,
00652     CV_BADSCALE_ERR    =  -4,
00653     CV_OUTOFMEM_ERR    =  -3,
00654     CV_NULLPTR_ERR     =  -2,
00655     CV_BADSIZE_ERR     =  -1,
00656     CV_NO_ERR          =   0,
00657     CV_OK              =   CV_NO_ERR
00658 }
00659 CvStatus;
00660 
00661 #define CV_NOTHROW throw()
00662 
00663 typedef struct CvFuncTable
00664 {
00665     void*   fn_2d[CV_DEPTH_MAX];
00666 }
00667 CvFuncTable;
00668 
00669 typedef struct CvBigFuncTable
00670 {
00671     void*   fn_2d[CV_DEPTH_MAX*4];
00672 }
00673 CvBigFuncTable;
00674 
00675 #define CV_INIT_FUNC_TAB( tab, FUNCNAME, FLAG )         \
00676     (tab).fn_2d[CV_8U] = (void*)FUNCNAME##_8u##FLAG;    \
00677     (tab).fn_2d[CV_8S] = 0;                             \
00678     (tab).fn_2d[CV_16U] = (void*)FUNCNAME##_16u##FLAG;  \
00679     (tab).fn_2d[CV_16S] = (void*)FUNCNAME##_16s##FLAG;  \
00680     (tab).fn_2d[CV_32S] = (void*)FUNCNAME##_32s##FLAG;  \
00681     (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG;  \
00682     (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG
00683 
00684 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines