- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

# /usr/ports/pobj/OpenCV-2.2.0/OpenCV-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