00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
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 #if defined ANDROID && defined __ARM_NEON__
00123 #include "arm_neon.h"
00124 #define CV_NEON 1
00125
00126 #define CPU_HAS_NEON_FEATURE (true)
00127
00128
00129 #else
00130 #define CV_NEON 0
00131 #define CPU_HAS_NEON_FEATURE (false)
00132 #endif
00133
00134 #ifndef IPPI_CALL
00135 #define IPPI_CALL(func) CV_Assert((func) >= 0)
00136 #endif
00137
00138 #ifdef HAVE_TBB
00139 #include "tbb/tbb_stddef.h"
00140 #if TBB_VERSION_MAJOR*100 + TBB_VERSION_MINOR >= 202
00141 #include "tbb/tbb.h"
00142 #include "tbb/task.h"
00143 #undef min
00144 #undef max
00145 #else
00146 #undef HAVE_TBB
00147 #endif
00148 #endif
00149
00150 #ifdef HAVE_EIGEN
00151 #include <Eigen/Core>
00152 #include "opencv2/core/eigen.hpp"
00153 #endif
00154
00155 #ifdef __cplusplus
00156
00157 #ifdef HAVE_TBB
00158 namespace cv
00159 {
00160 typedef tbb::blocked_range<int> BlockedRange;
00161
00162 template<typename Body> static inline
00163 void parallel_for( const BlockedRange& range, const Body& body )
00164 {
00165 tbb::parallel_for(range, body);
00166 }
00167
00168 template<typename Iterator, typename Body> static inline
00169 void parallel_do( Iterator first, Iterator last, const Body& body )
00170 {
00171 tbb::parallel_do(first, last, body);
00172 }
00173
00174 typedef tbb::split Split;
00175
00176 template<typename Body> static inline
00177 void parallel_reduce( const BlockedRange& range, Body& body )
00178 {
00179 tbb::parallel_reduce(range, body);
00180 }
00181
00182 typedef tbb::concurrent_vector<Rect> ConcurrentRectVector;
00183 }
00184 #else
00185 namespace cv
00186 {
00187 class BlockedRange
00188 {
00189 public:
00190 BlockedRange() : _begin(0), _end(0), _grainsize(0) {}
00191 BlockedRange(int b, int e, int g=1) : _begin(b), _end(e), _grainsize(g) {}
00192 int begin() const { return _begin; }
00193 int end() const { return _end; }
00194 int grainsize() const { return _grainsize; }
00195
00196 protected:
00197 int _begin, _end, _grainsize;
00198 };
00199
00200
00201 #ifdef HAVE_THREADING_FRAMEWORK
00202 #include "threading_framework.hpp"
00203
00204 template<typename Body>
00205 static void parallel_for( const BlockedRange& range, const Body& body )
00206 {
00207 tf::parallel_for<Body>(range, body);
00208 }
00209 typedef tf::ConcurrentVector<Rect> ConcurrentRectVector;
00210 #else
00211 template<typename Body> static inline
00212 void parallel_for( const BlockedRange& range, const Body& body )
00213 {
00214 body(range);
00215 }
00216 typedef std::vector<Rect> ConcurrentRectVector;
00217 #endif
00218
00219 template<typename Iterator, typename Body> static inline
00220 void parallel_do( Iterator first, Iterator last, const Body& body )
00221 {
00222 for( ; first != last; ++first )
00223 body(*first);
00224 }
00225
00226 class Split {};
00227
00228 template<typename Body> static inline
00229 void parallel_reduce( const BlockedRange& range, Body& body )
00230 {
00231 body(range);
00232 }
00233
00234 }
00235 #endif
00236 #endif
00237
00238
00239 #define CV_MAX_INLINE_MAT_OP_SIZE 10
00240
00241
00242 #define CV_MAX_LOCAL_MAT_SIZE 32
00243
00244
00245 #define CV_MAX_LOCAL_SIZE \
00246 (CV_MAX_LOCAL_MAT_SIZE*CV_MAX_LOCAL_MAT_SIZE*(int)sizeof(double))
00247
00248
00249 #define CV_DEFAULT_IMAGE_ROW_ALIGN 4
00250
00251
00252 #define CV_DEFAULT_MAT_ROW_ALIGN 1
00253
00254
00255
00256 #define CV_MAX_ALLOC_SIZE (((size_t)1 << (sizeof(size_t)*8-2)))
00257
00258
00259 #define CV_MALLOC_ALIGN 16
00260
00261
00262 #define CV_STRUCT_ALIGN ((int)sizeof(double))
00263
00264
00265 #define CV_STORAGE_BLOCK_SIZE ((1<<16) - 128)
00266
00267
00268 #define CV_SPARSE_MAT_BLOCK (1<<12)
00269
00270
00271 #define CV_SPARSE_HASH_SIZE0 (1<<10)
00272
00273
00274 #define CV_SPARSE_HASH_RATIO 3
00275
00276
00277 #define CV_MAX_STRLEN 1024
00278
00279 #if 0
00280 #define CV_CHECK_NANS( arr ) cvCheckArray((arr))
00281 #else
00282 #define CV_CHECK_NANS( arr )
00283 #endif
00284
00285
00286
00287
00288
00289
00290 #ifdef __GNUC__
00291 #undef alloca
00292 #define alloca __builtin_alloca
00293 #define CV_HAVE_ALLOCA 1
00294 #elif defined WIN32 || defined _WIN32 || \
00295 defined WINCE || defined _MSC_VER || defined __BORLANDC__
00296 #include <malloc.h>
00297 #define CV_HAVE_ALLOCA 1
00298 #elif defined HAVE_ALLOCA_H
00299 #include <alloca.h>
00300 #define CV_HAVE_ALLOCA 1
00301 #elif defined HAVE_ALLOCA
00302 #include <stdlib.h>
00303 #define CV_HAVE_ALLOCA 1
00304 #else
00305 #undef CV_HAVE_ALLOCA
00306 #endif
00307
00308 #ifdef __GNUC__
00309 #define CV_DECL_ALIGNED(x) __attribute__ ((aligned (x)))
00310 #elif defined _MSC_VER
00311 #define CV_DECL_ALIGNED(x) __declspec(align(x))
00312 #else
00313 #define CV_DECL_ALIGNED(x)
00314 #endif
00315
00316 #if CV_HAVE_ALLOCA
00317
00318 #define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN )
00319 #endif
00320
00321 #ifndef CV_IMPL
00322 #define CV_IMPL CV_EXTERN_C
00323 #endif
00324
00325 #define CV_DBG_BREAK() { volatile int* crashMe = 0; *crashMe = 0; }
00326
00327
00328
00329 #define CV_STUB_STEP (1 << 30)
00330
00331 #define CV_SIZEOF_FLOAT ((int)sizeof(float))
00332 #define CV_SIZEOF_SHORT ((int)sizeof(short))
00333
00334 #define CV_ORIGIN_TL 0
00335 #define CV_ORIGIN_BL 1
00336
00337
00338 #define CV_POS_INF 0x7f800000
00339 #define CV_NEG_INF 0x807fffff
00340 #define CV_1F 0x3f800000
00341 #define CV_TOGGLE_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0))
00342 #define CV_TOGGLE_DBL(x) \
00343 ((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0))
00344
00345 #define CV_NOP(a) (a)
00346 #define CV_ADD(a, b) ((a) + (b))
00347 #define CV_SUB(a, b) ((a) - (b))
00348 #define CV_MUL(a, b) ((a) * (b))
00349 #define CV_AND(a, b) ((a) & (b))
00350 #define CV_OR(a, b) ((a) | (b))
00351 #define CV_XOR(a, b) ((a) ^ (b))
00352 #define CV_ANDN(a, b) (~(a) & (b))
00353 #define CV_ORN(a, b) (~(a) | (b))
00354 #define CV_SQR(a) ((a) * (a))
00355
00356 #define CV_LT(a, b) ((a) < (b))
00357 #define CV_LE(a, b) ((a) <= (b))
00358 #define CV_EQ(a, b) ((a) == (b))
00359 #define CV_NE(a, b) ((a) != (b))
00360 #define CV_GT(a, b) ((a) > (b))
00361 #define CV_GE(a, b) ((a) >= (b))
00362
00363 #define CV_NONZERO(a) ((a) != 0)
00364 #define CV_NONZERO_FLT(a) (((a)+(a)) != 0)
00365
00366
00367 #define CV_CAST_8U(t) (uchar)(!((t) & ~255) ? (t) : (t) > 0 ? 255 : 0)
00368 #define CV_CAST_8S(t) (schar)(!(((t)+128) & ~255) ? (t) : (t) > 0 ? 127 : -128)
00369 #define CV_CAST_16U(t) (ushort)(!((t) & ~65535) ? (t) : (t) > 0 ? 65535 : 0)
00370 #define CV_CAST_16S(t) (short)(!(((t)+32768) & ~65535) ? (t) : (t) > 0 ? 32767 : -32768)
00371 #define CV_CAST_32S(t) (int)(t)
00372 #define CV_CAST_64S(t) (int64)(t)
00373 #define CV_CAST_32F(t) (float)(t)
00374 #define CV_CAST_64F(t) (double)(t)
00375
00376 #define CV_PASTE2(a,b) a##b
00377 #define CV_PASTE(a,b) CV_PASTE2(a,b)
00378
00379 #define CV_EMPTY
00380 #define CV_MAKE_STR(a) #a
00381
00382 #define CV_ZERO_OBJ(x) memset((x), 0, sizeof(*(x)))
00383
00384 #define CV_DIM(static_array) ((int)(sizeof(static_array)/sizeof((static_array)[0])))
00385
00386 #define cvUnsupportedFormat "Unsupported format"
00387
00388 CV_INLINE void* cvAlignPtr( const void* ptr, int align CV_DEFAULT(32) )
00389 {
00390 assert( (align & (align-1)) == 0 );
00391 return (void*)( ((size_t)ptr + align - 1) & ~(size_t)(align-1) );
00392 }
00393
00394 CV_INLINE int cvAlign( int size, int align )
00395 {
00396 assert( (align & (align-1)) == 0 && size < INT_MAX );
00397 return (size + align - 1) & -align;
00398 }
00399
00400 CV_INLINE CvSize cvGetMatSize( const CvMat* mat )
00401 {
00402 CvSize size;
00403 size.width = mat->cols;
00404 size.height = mat->rows;
00405 return size;
00406 }
00407
00408 #define CV_DESCALE(x,n) (((x) + (1 << ((n)-1))) >> (n))
00409 #define CV_FLT_TO_FIX(x,n) cvRound((x)*(1<<(n)))
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473 #define CV_IMPLEMENT_QSORT_EX( func_name, T, LT, user_data_type ) \
00474 void func_name( T *array, size_t total, user_data_type aux ) \
00475 { \
00476 int isort_thresh = 7; \
00477 T t; \
00478 int sp = 0; \
00479 \
00480 struct \
00481 { \
00482 T *lb; \
00483 T *ub; \
00484 } \
00485 stack[48]; \
00486 \
00487 aux = aux; \
00488 \
00489 if( total <= 1 ) \
00490 return; \
00491 \
00492 stack[0].lb = array; \
00493 stack[0].ub = array + (total - 1); \
00494 \
00495 while( sp >= 0 ) \
00496 { \
00497 T* left = stack[sp].lb; \
00498 T* right = stack[sp--].ub; \
00499 \
00500 for(;;) \
00501 { \
00502 int i, n = (int)(right - left) + 1, m; \
00503 T* ptr; \
00504 T* ptr2; \
00505 \
00506 if( n <= isort_thresh ) \
00507 { \
00508 insert_sort: \
00509 for( ptr = left + 1; ptr <= right; ptr++ ) \
00510 { \
00511 for( ptr2 = ptr; ptr2 > left && LT(ptr2[0],ptr2[-1]); ptr2--) \
00512 CV_SWAP( ptr2[0], ptr2[-1], t ); \
00513 } \
00514 break; \
00515 } \
00516 else \
00517 { \
00518 T* left0; \
00519 T* left1; \
00520 T* right0; \
00521 T* right1; \
00522 T* pivot; \
00523 T* a; \
00524 T* b; \
00525 T* c; \
00526 int swap_cnt = 0; \
00527 \
00528 left0 = left; \
00529 right0 = right; \
00530 pivot = left + (n/2); \
00531 \
00532 if( n > 40 ) \
00533 { \
00534 int d = n / 8; \
00535 a = left, b = left + d, c = left + 2*d; \
00536 left = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
00537 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
00538 \
00539 a = pivot - d, b = pivot, c = pivot + d; \
00540 pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
00541 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
00542 \
00543 a = right - 2*d, b = right - d, c = right; \
00544 right = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
00545 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
00546 } \
00547 \
00548 a = left, b = pivot, c = right; \
00549 pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \
00550 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \
00551 if( pivot != left0 ) \
00552 { \
00553 CV_SWAP( *pivot, *left0, t ); \
00554 pivot = left0; \
00555 } \
00556 left = left1 = left0 + 1; \
00557 right = right1 = right0; \
00558 \
00559 for(;;) \
00560 { \
00561 while( left <= right && !LT(*pivot, *left) ) \
00562 { \
00563 if( !LT(*left, *pivot) ) \
00564 { \
00565 if( left > left1 ) \
00566 CV_SWAP( *left1, *left, t ); \
00567 swap_cnt = 1; \
00568 left1++; \
00569 } \
00570 left++; \
00571 } \
00572 \
00573 while( left <= right && !LT(*right, *pivot) ) \
00574 { \
00575 if( !LT(*pivot, *right) ) \
00576 { \
00577 if( right < right1 ) \
00578 CV_SWAP( *right1, *right, t ); \
00579 swap_cnt = 1; \
00580 right1--; \
00581 } \
00582 right--; \
00583 } \
00584 \
00585 if( left > right ) \
00586 break; \
00587 CV_SWAP( *left, *right, t ); \
00588 swap_cnt = 1; \
00589 left++; \
00590 right--; \
00591 } \
00592 \
00593 if( swap_cnt == 0 ) \
00594 { \
00595 left = left0, right = right0; \
00596 goto insert_sort; \
00597 } \
00598 \
00599 n = MIN( (int)(left1 - left0), (int)(left - left1) ); \
00600 for( i = 0; i < n; i++ ) \
00601 CV_SWAP( left0[i], left[i-n], t ); \
00602 \
00603 n = MIN( (int)(right0 - right1), (int)(right1 - right) ); \
00604 for( i = 0; i < n; i++ ) \
00605 CV_SWAP( left[i], right0[i-n+1], t ); \
00606 n = (int)(left - left1); \
00607 m = (int)(right1 - right); \
00608 if( n > 1 ) \
00609 { \
00610 if( m > 1 ) \
00611 { \
00612 if( n > m ) \
00613 { \
00614 stack[++sp].lb = left0; \
00615 stack[sp].ub = left0 + n - 1; \
00616 left = right0 - m + 1, right = right0; \
00617 } \
00618 else \
00619 { \
00620 stack[++sp].lb = right0 - m + 1; \
00621 stack[sp].ub = right0; \
00622 left = left0, right = left0 + n - 1; \
00623 } \
00624 } \
00625 else \
00626 left = left0, right = left0 + n - 1; \
00627 } \
00628 else if( m > 1 ) \
00629 left = right0 - m + 1, right = right0; \
00630 else \
00631 break; \
00632 } \
00633 } \
00634 } \
00635 }
00636
00637 #define CV_IMPLEMENT_QSORT( func_name, T, cmp ) \
00638 CV_IMPLEMENT_QSORT_EX( func_name, T, cmp, int )
00639
00640
00641
00642
00643
00644
00645 typedef enum CvStatus
00646 {
00647 CV_BADMEMBLOCK_ERR = -113,
00648 CV_INPLACE_NOT_SUPPORTED_ERR= -112,
00649 CV_UNMATCHED_ROI_ERR = -111,
00650 CV_NOTFOUND_ERR = -110,
00651 CV_BADCONVERGENCE_ERR = -109,
00652
00653 CV_BADDEPTH_ERR = -107,
00654 CV_BADROI_ERR = -106,
00655 CV_BADHEADER_ERR = -105,
00656 CV_UNMATCHED_FORMATS_ERR = -104,
00657 CV_UNSUPPORTED_COI_ERR = -103,
00658 CV_UNSUPPORTED_CHANNELS_ERR = -102,
00659 CV_UNSUPPORTED_DEPTH_ERR = -101,
00660 CV_UNSUPPORTED_FORMAT_ERR = -100,
00661
00662 CV_BADARG_ERR = -49,
00663 CV_NOTDEFINED_ERR = -48,
00664
00665 CV_BADCHANNELS_ERR = -47,
00666 CV_BADRANGE_ERR = -44,
00667 CV_BADSTEP_ERR = -29,
00668
00669 CV_BADFLAG_ERR = -12,
00670 CV_DIV_BY_ZERO_ERR = -11,
00671 CV_BADCOEF_ERR = -10,
00672
00673 CV_BADFACTOR_ERR = -7,
00674 CV_BADPOINT_ERR = -6,
00675 CV_BADSCALE_ERR = -4,
00676 CV_OUTOFMEM_ERR = -3,
00677 CV_NULLPTR_ERR = -2,
00678 CV_BADSIZE_ERR = -1,
00679 CV_NO_ERR = 0,
00680 CV_OK = CV_NO_ERR
00681 }
00682 CvStatus;
00683
00684 #define CV_NOTHROW throw()
00685
00686 typedef struct CvFuncTable
00687 {
00688 void* fn_2d[CV_DEPTH_MAX];
00689 }
00690 CvFuncTable;
00691
00692 typedef struct CvBigFuncTable
00693 {
00694 void* fn_2d[CV_DEPTH_MAX*4];
00695 }
00696 CvBigFuncTable;
00697
00698 #define CV_INIT_FUNC_TAB( tab, FUNCNAME, FLAG ) \
00699 (tab).fn_2d[CV_8U] = (void*)FUNCNAME##_8u##FLAG; \
00700 (tab).fn_2d[CV_8S] = 0; \
00701 (tab).fn_2d[CV_16U] = (void*)FUNCNAME##_16u##FLAG; \
00702 (tab).fn_2d[CV_16S] = (void*)FUNCNAME##_16s##FLAG; \
00703 (tab).fn_2d[CV_32S] = (void*)FUNCNAME##_32s##FLAG; \
00704 (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG; \
00705 (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG
00706
00707 #endif