generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Drop outdated definitions from internal.hpp

Browse Source 
This also fixes few clang build errors
This commit is contained in:
Andrey Kamaev 2013-03-31 13:26:21 +04:00
parent 605382562d
commit 3890a74565
34 changed files with 248 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
apps/haartraining/cvhaartraining.cpp
View File

@ -2676,7 +2676,7 @@ void cvCreateTreeCascadeClassifier( const char* dirname,
CvSplit* curSplit; CvSplit* curSplit;
CV_CALL( curSplit = (CvSplit*) cvAlloc( sizeof( *curSplit ) ) ); CV_CALL( curSplit = (CvSplit*) cvAlloc( sizeof( *curSplit ) ) );
CV_ZERO_OBJ( curSplit ); memset(curSplit, 0, sizeof(*curSplit));
if( last_split ) last_split->next = curSplit; if( last_split ) last_split->next = curSplit;
else first_split = curSplit; else first_split = curSplit;

2
modules/calib3d/src/calibration.cpp
View File

@ -2688,7 +2688,7 @@ void cv::reprojectImageTo3D( InputArray _disparity,
for( x = 0; x < cols*3; x++ ) for( x = 0; x < cols*3; x++ )
{ {
int ival = cvRound(dptr[x]); int ival = cvRound(dptr[x]);
dptr0[x] = CV_CAST_16S(ival); dptr0[x] = cv::saturate_cast<short>(ival);
} }
} }
else if( dtype == CV_32SC3 ) else if( dtype == CV_32SC3 )

2
modules/calib3d/src/stereobm.cpp
View File

@ -183,7 +183,7 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero )
if( useSIMD ) if( useSIMD )
{ {
__m128i z = _mm_setzero_si128(), ftz = _mm_set1_epi16((short)ftzero), __m128i z = _mm_setzero_si128(), ftz = _mm_set1_epi16((short)ftzero),
ftz2 = _mm_set1_epi8(CV_CAST_8U(ftzero*2)); ftz2 = _mm_set1_epi8(cv::saturate_cast<uchar>(ftzero*2));
for( ; x <= size.width-9; x += 8 ) for( ; x <= size.width-9; x += 8 )
{ {
__m128i c0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow0 + x - 1)), z); __m128i c0 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow0 + x - 1)), z);

2
modules/core/include/opencv2/core/base.hpp
View File

@ -184,11 +184,9 @@ enum { DFT_INVERSE = 1,
# if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC_MINOR__ > 2) # if defined(__GNUC__) && (__GNUC__ > 3) && (__GNUC_MINOR__ > 2)
# define CV_StaticAssert(condition, reason) ({ extern int __attribute__((error("CV_StaticAssert: " reason " " #condition))) CV_StaticAssert(); ((condition) ? 0 : CV_StaticAssert()); }) # define CV_StaticAssert(condition, reason) ({ extern int __attribute__((error("CV_StaticAssert: " reason " " #condition))) CV_StaticAssert(); ((condition) ? 0 : CV_StaticAssert()); })
# else # else
namespace cv {
template <bool x> struct CV_StaticAssert_failed; template <bool x> struct CV_StaticAssert_failed;
template <> struct CV_StaticAssert_failed<true> { enum { val = 1 }; }; template <> struct CV_StaticAssert_failed<true> { enum { val = 1 }; };
template<int x> struct CV_StaticAssert_test {}; template<int x> struct CV_StaticAssert_test {};
}
# define CV_StaticAssert(condition, reason)\ # define CV_StaticAssert(condition, reason)\
typedef cv::CV_StaticAssert_test< sizeof(cv::CV_StaticAssert_failed< static_cast<bool>(condition) >) > CVAUX_CONCAT(CV_StaticAssert_failed_at_, __LINE__) typedef cv::CV_StaticAssert_test< sizeof(cv::CV_StaticAssert_failed< static_cast<bool>(condition) >) > CVAUX_CONCAT(CV_StaticAssert_failed_at_, __LINE__)
# endif # endif

5
modules/core/include/opencv2/core/core_c.h
View File

@ -55,7 +55,12 @@
C++ construrtors for simpler interoperability with C++ API of the library C++ construrtors for simpler interoperability with C++ API of the library
*/ */
# pragma warning(disable:4190) # pragma warning(disable:4190)
# elif defined __clang__ && __clang_major__ >= 3
# pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
# endif # endif
#endif
#ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif

249
modules/core/include/opencv2/core/internal.hpp
View File

@ -48,40 +48,6 @@
#ifndef __OPENCV_CORE_INTERNAL_HPP__ #ifndef __OPENCV_CORE_INTERNAL_HPP__
#define __OPENCV_CORE_INTERNAL_HPP__ #define __OPENCV_CORE_INTERNAL_HPP__
#include <vector>
#if defined WIN32 || defined _WIN32
# ifndef WIN32
# define WIN32
# endif
# ifndef _WIN32
# define _WIN32
# endif
#endif
#if !defined WIN32 && !defined WINCE
# include <pthread.h>
#endif
#ifdef __BORLANDC__
# ifndef WIN32
# define WIN32
# endif
# ifndef _WIN32
# define _WIN32
# endif
# define CV_DLL
# undef _CV_ALWAYS_PROFILE_
# define _CV_ALWAYS_NO_PROFILE_
#endif
#ifndef FALSE
# define FALSE 0
#endif
#ifndef TRUE
# define TRUE 1
#endif
#define __BEGIN__ __CV_BEGIN__ #define __BEGIN__ __CV_BEGIN__
#define __END__ __CV_END__ #define __END__ __CV_END__
#define EXIT __CV_EXIT__ #define EXIT __CV_EXIT__
@ -100,70 +66,6 @@ CV_INLINE IppiSize ippiSize(int width, int height)
# define IPPI_CALL(func) CV_Assert((func) >= 0) # define IPPI_CALL(func) CV_Assert((func) >= 0)
#endif #endif
#if defined __SSE2__ || defined _M_X64 || (defined _M_IX86_FP && _M_IX86_FP >= 2)
# include "emmintrin.h"
# define CV_SSE 1
# define CV_SSE2 1
# if defined __SSE3__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include "pmmintrin.h"
# define CV_SSE3 1
# endif
# if defined __SSSE3__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include "tmmintrin.h"
# define CV_SSSE3 1
# endif
# if defined __SSE4_1__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include <smmintrin.h>
# define CV_SSE4_1 1
# endif
# if defined __SSE4_2__ || (defined _MSC_VER && _MSC_VER >= 1500)
# include <nmmintrin.h>
# define CV_SSE4_2 1
# endif
# if defined __AVX__ || (defined _MSC_FULL_VER && _MSC_FULL_VER >= 160040219)
// MS Visual Studio 2010 (2012?) has no macro pre-defined to identify the use of /arch:AVX
// See: http://connect.microsoft.com/VisualStudio/feedback/details/605858/arch-avx-should-define-a-predefined-macro-in-x64-and-set-a-unique-value-for-m-ix86-fp-in-win32
# include <immintrin.h>
# define CV_AVX 1
# if defined(_XCR_XFEATURE_ENABLED_MASK)
# define __xgetbv() _xgetbv(_XCR_XFEATURE_ENABLED_MASK)
# else
# define __xgetbv() 0
# endif
# endif
#endif
#ifdef __ARM_NEON__
# include <arm_neon.h>
# define CV_NEON 1
# define CPU_HAS_NEON_FEATURE (true)
#endif
#ifndef CV_SSE
# define CV_SSE 0
#endif
#ifndef CV_SSE2
# define CV_SSE2 0
#endif
#ifndef CV_SSE3
# define CV_SSE3 0
#endif
#ifndef CV_SSSE3
# define CV_SSSE3 0
#endif
#ifndef CV_SSE4_1
# define CV_SSE4_1 0
#endif
#ifndef CV_SSE4_2
# define CV_SSE4_2 0
#endif
#ifndef CV_AVX
# define CV_AVX 0
#endif
#ifndef CV_NEON
# define CV_NEON 0
#endif
#ifdef HAVE_TBB #ifdef HAVE_TBB
# include "tbb/tbb_stddef.h" # include "tbb/tbb_stddef.h"
# if TBB_VERSION_MAJOR*100 + TBB_VERSION_MINOR >= 202 # if TBB_VERSION_MAJOR*100 + TBB_VERSION_MINOR >= 202
@ -198,12 +100,6 @@ namespace cv
tbb::parallel_for(range, body); tbb::parallel_for(range, body);
} }
template<typename Iterator, typename Body> static inline
void parallel_do( Iterator first, Iterator last, const Body& body )
{
tbb::parallel_do(first, last, body);
}
typedef tbb::split Split; typedef tbb::split Split;
template<typename Body> static inline template<typename Body> static inline
@ -213,7 +109,6 @@ namespace cv
} }
typedef tbb::concurrent_vector<Rect> ConcurrentRectVector; typedef tbb::concurrent_vector<Rect> ConcurrentRectVector;
typedef tbb::concurrent_vector<double> ConcurrentDoubleVector;
#else #else
class BlockedRange class BlockedRange
{ {
@ -234,14 +129,6 @@ namespace cv
body(range); body(range);
} }
typedef std::vector<Rect> ConcurrentRectVector; typedef std::vector<Rect> ConcurrentRectVector;
typedef std::vector<double> ConcurrentDoubleVector;
template<typename Iterator, typename Body> static inline
void parallel_do( Iterator first, Iterator last, const Body& body )
{
for( ; first != last; ++first )
body(*first);
}
class Split {}; class Split {};
@ -282,26 +169,9 @@ namespace cv
#endif //__cplusplus #endif //__cplusplus
/* 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) */ /* default image row align (in bytes) */
#define CV_DEFAULT_IMAGE_ROW_ALIGN 4 #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 */ /* the alignment of all the allocated buffers */
#define CV_MALLOC_ALIGN 16 #define CV_MALLOC_ALIGN 16
@ -320,38 +190,10 @@ namespace cv
/* maximal average node_count/hash_size ratio beyond which hash table is resized */ /* maximal average node_count/hash_size ratio beyond which hash table is resized */
#define CV_SPARSE_HASH_RATIO 3 #define CV_SPARSE_HASH_RATIO 3
/* max length of strings */
#define CV_MAX_STRLEN 1024
#if 0 /*def CV_CHECK_FOR_NANS*/
# define CV_CHECK_NANS( arr ) cvCheckArray((arr))
#else
# define CV_CHECK_NANS( arr )
#endif
/****************************************************************************************\ /****************************************************************************************\
* Common declarations * * Common declarations *
\****************************************************************************************/ \****************************************************************************************/
/* get alloca declaration */
#ifdef __GNUC__
# undef alloca
# define alloca __builtin_alloca
# define CV_HAVE_ALLOCA 1
#elif defined WIN32 || defined _WIN32 || \
defined WINCE || defined _MSC_VER || defined __BORLANDC__
# include <malloc.h>
# define CV_HAVE_ALLOCA 1
#elif defined HAVE_ALLOCA_H
# include <alloca.h>
# define CV_HAVE_ALLOCA 1
#elif defined HAVE_ALLOCA
# include <stdlib.h>
# define CV_HAVE_ALLOCA 1
#else
# undef CV_HAVE_ALLOCA
#endif
#ifdef __GNUC__ #ifdef __GNUC__
# define CV_DECL_ALIGNED(x) __attribute__ ((aligned (x))) # define CV_DECL_ALIGNED(x) __attribute__ ((aligned (x)))
#elif defined _MSC_VER #elif defined _MSC_VER
@ -360,77 +202,20 @@ namespace cv
# define CV_DECL_ALIGNED(x) # define CV_DECL_ALIGNED(x)
#endif #endif
#if CV_HAVE_ALLOCA
/* ! DO NOT make it an inline function */
# define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN )
#endif
#ifndef CV_IMPL #ifndef CV_IMPL
# define CV_IMPL CV_EXTERN_C # define CV_IMPL CV_EXTERN_C
#endif #endif
#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_TL 0
#define CV_ORIGIN_BL 1 #define CV_ORIGIN_BL 1
/* IEEE754 constants and macros */ /* 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_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0))
#define CV_TOGGLE_DBL(x) \ #define CV_TOGGLE_DBL(x) \
((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0)) ((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0))
#define CV_NOP(a) (a) //TODO: remove after dropping sorts
#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_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_ZERO_OBJ(x) memset((x), 0, sizeof(*(x)))
#define CV_DIM(static_array) ((int)(sizeof(static_array)/sizeof((static_array)[0])))
#define cvUnsupportedFormat "Unsupported format"
CV_INLINE void* cvAlignPtr( const void* ptr, int align CV_DEFAULT(32) ) CV_INLINE void* cvAlignPtr( const void* ptr, int align CV_DEFAULT(32) )
{ {
@ -499,36 +284,4 @@ typedef enum CvStatus
} }
CvStatus; CvStatus;
#define CV_NOTHROW throw()
typedef struct CvFuncTable
{
void* fn_2d[CV_DEPTH_MAX];
}
CvFuncTable;
typedef struct CvBigFuncTable
{
void* fn_2d[CV_DEPTH_MAX*4];
} CvBigFuncTable;
#define CV_INIT_FUNC_TAB( tab, FUNCNAME, FLAG ) \
(tab).fn_2d[CV_8U] = (void*)FUNCNAME##_8u##FLAG; \
(tab).fn_2d[CV_8S] = 0; \
(tab).fn_2d[CV_16U] = (void*)FUNCNAME##_16u##FLAG; \
(tab).fn_2d[CV_16S] = (void*)FUNCNAME##_16s##FLAG; \
(tab).fn_2d[CV_32S] = (void*)FUNCNAME##_32s##FLAG; \
(tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG; \
(tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG
namespace cv { namespace ogl {
CV_EXPORTS bool checkError(const char* file, const int line, const char* func = "");
}}
#if defined(__GNUC__)
#define CV_CheckGlError() CV_DbgAssert( (cv::ogl::checkError(__FILE__, __LINE__, __func__)) )
#else
#define CV_CheckGlError() CV_DbgAssert( (cv::ogl::checkError(__FILE__, __LINE__)) )
#endif
#endif // __OPENCV_CORE_INTERNAL_HPP__ #endif // __OPENCV_CORE_INTERNAL_HPP__

2
modules/core/include/opencv2/core/mat.inl.hpp
View File

@ -122,7 +122,7 @@ template<typename _Tp> inline
_OutputArray::_OutputArray(const std::vector<_Tp>& vec) _OutputArray::_OutputArray(const std::vector<_Tp>& vec)
: _InputArray(vec) : _InputArray(vec)
{ {
flags |= FIXED_SIZE flags |= FIXED_SIZE;
} }
template<typename _Tp> inline template<typename _Tp> inline

2
modules/core/include/opencv2/core/matx.hpp
View File

@ -956,7 +956,7 @@ Vec<double, 4> Vec<double, 4>::conj() const
template<typename _Tp, int cn> inline template<typename _Tp, int cn> inline
Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn>&) const Vec<_Tp, cn> Vec<_Tp, cn>::cross(const Vec<_Tp, cn>&) const
{ {
CV_StaticAssert(false, "for arbitrary-size vector there is no cross-product defined"); CV_StaticAssert(cn == 3, "for arbitrary-size vector there is no cross-product defined");
return Vec<_Tp, cn>(); return Vec<_Tp, cn>();
} }

18
modules/core/src/array.cpp
View File

@ -1464,28 +1464,28 @@ cvScalarToRawData( const CvScalar* scalar, void* data, int type, int extend_to_1
while( cn-- ) while( cn-- )
{ {
int t = cvRound( scalar->val[cn] ); int t = cvRound( scalar->val[cn] );
((uchar*)data)[cn] = CV_CAST_8U(t); ((uchar*)data)[cn] = cv::saturate_cast<uchar>(t);
} }
break; break;
case CV_8SC1: case CV_8SC1:
while( cn-- ) while( cn-- )
{ {
int t = cvRound( scalar->val[cn] ); int t = cvRound( scalar->val[cn] );
((char*)data)[cn] = CV_CAST_8S(t); ((char*)data)[cn] = cv::saturate_cast<schar>(t);
} }
break; break;
case CV_16UC1: case CV_16UC1:
while( cn-- ) while( cn-- )
{ {
int t = cvRound( scalar->val[cn] ); int t = cvRound( scalar->val[cn] );
((ushort*)data)[cn] = CV_CAST_16U(t); ((ushort*)data)[cn] = cv::saturate_cast<ushort>(t);
} }
break; break;
case CV_16SC1: case CV_16SC1:
while( cn-- ) while( cn-- )
{ {
int t = cvRound( scalar->val[cn] ); int t = cvRound( scalar->val[cn] );
((short*)data)[cn] = CV_CAST_16S(t); ((short*)data)[cn] = cv::saturate_cast<short>(t);
} }
break; break;
case CV_32SC1: case CV_32SC1:
@ -1602,19 +1602,19 @@ static void icvSetReal( double value, const void* data, int type )
switch( type ) switch( type )
{ {
case CV_8U: case CV_8U:
*(uchar*)data = CV_CAST_8U(ivalue); *(uchar*)data = cv::saturate_cast<uchar>(ivalue);
break; break;
case CV_8S: case CV_8S:
*(char*)data = CV_CAST_8S(ivalue); *(schar*)data = cv::saturate_cast<schar>(ivalue);
break; break;
case CV_16U: case CV_16U:
*(ushort*)data = CV_CAST_16U(ivalue); *(ushort*)data = cv::saturate_cast<ushort>(ivalue);
break; break;
case CV_16S: case CV_16S:
*(short*)data = CV_CAST_16S(ivalue); *(short*)data = cv::saturate_cast<short>(ivalue);
break; break;
case CV_32S: case CV_32S:
*(int*)data = CV_CAST_32S(ivalue); *(int*)data = cv::saturate_cast<int>(ivalue);
break; break;
} }
} }

4
modules/core/src/drawing.cpp
View File

@ -2343,7 +2343,7 @@ cvColorToScalar( double packed_color, int type )
} }
else else
{ {
scalar.val[0] = CV_CAST_8U( icolor ); scalar.val[0] = cv::saturate_cast<uchar>( icolor );
scalar.val[1] = scalar.val[2] = scalar.val[3] = 0; scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
} }
} }
@ -2359,7 +2359,7 @@ cvColorToScalar( double packed_color, int type )
} }
else else
{ {
scalar.val[0] = CV_CAST_8S( icolor ); scalar.val[0] = cv::saturate_cast<schar>( icolor );
scalar.val[1] = scalar.val[2] = scalar.val[3] = 0; scalar.val[1] = scalar.val[2] = scalar.val[3] = 0;
} }
} }

11
modules/core/src/opengl_interop.cpp
View File

@ -69,9 +69,8 @@ namespace
void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); } void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); }
#endif #endif
#endif #endif
}
bool cv::ogl::checkError(const char* file, const int line, const char* func) bool checkError(const char* file, const int line, const char* func = 0)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void) file; (void) file;
@ -116,6 +115,14 @@ bool cv::ogl::checkError(const char* file, const int line, const char* func)
#endif #endif
} }
#if defined(__GNUC__)
#define CV_CheckGlError() CV_DbgAssert( (checkError(__FILE__, __LINE__, __func__)) )
#else
#define CV_CheckGlError() CV_DbgAssert( (checkError(__FILE__, __LINE__)) )
#endif
} // namespace
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
namespace namespace
{ {

16
modules/core/src/persistence.cpp
View File

@ -3246,19 +3246,19 @@ cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
switch( elem_type ) switch( elem_type )
{ {
case CV_8U: case CV_8U:
*(uchar*)data = CV_CAST_8U(ival); *(uchar*)data = cv::saturate_cast<uchar>(ival);
data++; data++;
break; break;
case CV_8S: case CV_8S:
*(char*)data = CV_CAST_8S(ival); *(char*)data = cv::saturate_cast<schar>(ival);
data++; data++;
break; break;
case CV_16U: case CV_16U:
*(ushort*)data = CV_CAST_16U(ival); *(ushort*)data = cv::saturate_cast<ushort>(ival);
data += sizeof(ushort); data += sizeof(ushort);
break; break;
case CV_16S: case CV_16S:
*(short*)data = CV_CAST_16S(ival); *(short*)data = cv::saturate_cast<short>(ival);
data += sizeof(short); data += sizeof(short);
break; break;
case CV_32S: case CV_32S:
@ -3291,22 +3291,22 @@ cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader,
{ {
case CV_8U: case CV_8U:
ival = cvRound(fval); ival = cvRound(fval);
*(uchar*)data = CV_CAST_8U(ival); *(uchar*)data = cv::saturate_cast<uchar>(ival);
data++; data++;
break; break;
case CV_8S: case CV_8S:
ival = cvRound(fval); ival = cvRound(fval);
*(char*)data = CV_CAST_8S(ival); *(char*)data = cv::saturate_cast<schar>(ival);
data++; data++;
break; break;
case CV_16U: case CV_16U:
ival = cvRound(fval); ival = cvRound(fval);
*(ushort*)data = CV_CAST_16U(ival); *(ushort*)data = cv::saturate_cast<ushort>(ival);
data += sizeof(ushort); data += sizeof(ushort);
break; break;
case CV_16S: case CV_16S:
ival = cvRound(fval); ival = cvRound(fval);
*(short*)data = CV_CAST_16S(ival); *(short*)data = cv::saturate_cast<short>(ival);
data += sizeof(short); data += sizeof(short);
break; break;
case CV_32S: case CV_32S:

4
modules/core/src/stat.cpp
View File

@ -999,7 +999,6 @@ static int normHamming(const uchar* a, int n)
{ {
int i = 0, result = 0; int i = 0, result = 0;
#if CV_NEON #if CV_NEON
if (CPU_HAS_NEON_FEATURE)
{ {
uint32x4_t bits = vmovq_n_u32(0); uint32x4_t bits = vmovq_n_u32(0);
for (; i <= n - 16; i += 16) { for (; i <= n - 16; i += 16) {
@ -1013,7 +1012,6 @@ static int normHamming(const uchar* a, int n)
result = vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),0); result = vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),0);
result += vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),2); result += vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),2);
} }
else
#endif #endif
for( ; i <= n - 4; i += 4 ) for( ; i <= n - 4; i += 4 )
result += popCountTable[a[i]] + popCountTable[a[i+1]] + result += popCountTable[a[i]] + popCountTable[a[i+1]] +
@ -1027,7 +1025,6 @@ int normHamming(const uchar* a, const uchar* b, int n)
{ {
int i = 0, result = 0; int i = 0, result = 0;
#if CV_NEON #if CV_NEON
if (CPU_HAS_NEON_FEATURE)
{ {
uint32x4_t bits = vmovq_n_u32(0); uint32x4_t bits = vmovq_n_u32(0);
for (; i <= n - 16; i += 16) { for (; i <= n - 16; i += 16) {
@ -1043,7 +1040,6 @@ int normHamming(const uchar* a, const uchar* b, int n)
result = vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),0); result = vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),0);
result += vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),2); result += vgetq_lane_s32 (vreinterpretq_s32_u64(bitSet2),2);
} }
else
#endif #endif
for( ; i <= n - 4; i += 4 ) for( ; i <= n - 4; i += 4 )
result += popCountTable[a[i] ^ b[i]] + popCountTable[a[i+1] ^ b[i+1]] + result += popCountTable[a[i] ^ b[i]] + popCountTable[a[i+1] ^ b[i+1]] +

2
modules/highgui/src/cap_dshow.cpp
View File

@ -87,8 +87,6 @@ Thanks to:
*/ */
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
#include "precomp.hpp"
#if defined _MSC_VER && _MSC_VER >= 100 #if defined _MSC_VER && _MSC_VER >= 100
//'sprintf': name was marked as #pragma deprecated //'sprintf': name was marked as #pragma deprecated
#pragma warning(disable: 4995) #pragma warning(disable: 4995)

12
modules/highgui/src/cap_gstreamer.cpp
View File

@ -103,8 +103,8 @@ private:
gst_initializer() gst_initializer()
{ {
gst_init(NULL, NULL); gst_init(NULL, NULL);
// gst_debug_set_active(TRUE); // gst_debug_set_active(1);
// gst_debug_set_colored(TRUE); // gst_debug_set_colored(1);
// gst_debug_set_default_threshold(GST_LEVEL_INFO); // gst_debug_set_default_threshold(GST_LEVEL_INFO);
} }
}; };
@ -701,7 +701,7 @@ bool CvCapture_GStreamer::open( int type, const char* filename )
gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1); gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1);
gst_app_sink_set_drop (GST_APP_SINK(sink), stream); gst_app_sink_set_drop (GST_APP_SINK(sink), stream);
//do not emit signals: all calls will be synchronous and blocking //do not emit signals: all calls will be synchronous and blocking
gst_app_sink_set_emit_signals (GST_APP_SINK(sink), FALSE); gst_app_sink_set_emit_signals (GST_APP_SINK(sink), 0);
#if GST_VERSION_MAJOR == 0 #if GST_VERSION_MAJOR == 0
caps = gst_caps_new_simple("video/x-raw-rgb", caps = gst_caps_new_simple("video/x-raw-rgb",
@ -1261,9 +1261,9 @@ bool CvVideoWriter_GStreamer::open( const char * filename, int fourcc,
gst_app_src_set_size (GST_APP_SRC(source), -1); gst_app_src_set_size (GST_APP_SRC(source), -1);
g_object_set(G_OBJECT(source), "format", GST_FORMAT_TIME, NULL); g_object_set(G_OBJECT(source), "format", GST_FORMAT_TIME, NULL);
g_object_set(G_OBJECT(source), "block", TRUE, NULL); g_object_set(G_OBJECT(source), "block", 1, NULL);
g_object_set(G_OBJECT(source), "is-live", FALSE, NULL); g_object_set(G_OBJECT(source), "is-live", 0, NULL);
g_object_set(G_OBJECT(source), "emit-signals", TRUE, NULL); g_object_set(G_OBJECT(source), "emit-signals", 1, NULL);
if(!manualpipeline) if(!manualpipeline)
{ {

2
modules/highgui/src/cap_qt.cpp
View File

@ -1196,7 +1196,7 @@ static void icvReleaseVideoWriter_QT( CvVideoWriter_QT ** writer ) {
// force compression session to complete encoding of outstanding source // force compression session to complete encoding of outstanding source
// frames // frames
ICMCompressionSessionCompleteFrames( ICMCompressionSessionCompleteFrames(
video_writer->compression_session_ref, TRUE, 0, 0 video_writer->compression_session_ref, 1, 0, 0
); );
EndMediaEdits( video_writer->video ); EndMediaEdits( video_writer->video );

17
modules/highgui/src/grfmt_exr.cpp
View File

@ -348,8 +348,7 @@ bool ExrDecoder::readData( Mat& img )
float *fi = (float *)buffer; float *fi = (float *)buffer;
for( x = 0; x < m_width * 3; x++) for( x = 0; x < m_width * 3; x++)
{ {
int t = cvRound(fi[x]*5); out[x] = cv::saturate_cast<uchar>(fi[x]*5);
out[x] = CV_CAST_8U(t);
} }
} }
else else
@ -357,8 +356,7 @@ bool ExrDecoder::readData( Mat& img )
unsigned *ui = (unsigned *)buffer; unsigned *ui = (unsigned *)buffer;
for( x = 0; x < m_width * 3; x++) for( x = 0; x < m_width * 3; x++)
{ {
unsigned t = ui[x]; out[x] = cv::saturate_cast<uchar>(ui[x]);
out[x] = CV_CAST_8U(t);
} }
} }
} }
@ -487,12 +485,9 @@ void ExrDecoder::ChromaToBGR( float *data, int numlines, int step )
if( !m_native_depth ) if( !m_native_depth )
{ {
int t = cvRound(b); ((uchar *)data)[y * step + x * 3 + 0] = cv::saturate_cast<uchar>(b);
((uchar *)data)[y * step + x * 3] = CV_CAST_8U(t); ((uchar *)data)[y * step + x * 3 + 1] = cv::saturate_cast<uchar>(Y);
t = cvRound(Y); ((uchar *)data)[y * step + x * 3 + 2] = cv::saturate_cast<uchar>(r);
((uchar *)data)[y * step + x * 3 + 1] = CV_CAST_8U(t);
t = cvRound(r);
((uchar *)data)[y * step + x * 3 + 2] = CV_CAST_8U(t);
} }
else if( m_type == FLOAT ) else if( m_type == FLOAT )
{ {
@ -503,7 +498,7 @@ void ExrDecoder::ChromaToBGR( float *data, int numlines, int step )
else else
{ {
int t = cvRound(b); int t = cvRound(b);
((unsigned *)data)[y * step + x * 3] = (unsigned)MAX(t,0); ((unsigned *)data)[y * step + x * 3 + 0] = (unsigned)MAX(t, 0);
t = cvRound(Y); t = cvRound(Y);
((unsigned *)data)[y * step + x * 3 + 1] = (unsigned)MAX(t, 0); ((unsigned *)data)[y * step + x * 3 + 1] = (unsigned)MAX(t, 0);
t = cvRound(r); t = cvRound(r);

16
modules/highgui/src/grfmt_jpeg2000.cpp
View File

@ -297,26 +297,26 @@ bool Jpeg2KDecoder::readComponent8u( uchar *data, void *_buffer,
for( x = 0; x < xend - xstart; x++ ) for( x = 0; x < xend - xstart; x++ )
{ {
int pix = pix_row[x]; int pix = pix_row[x];
dst[x*ncmpts] = CV_CAST_8U(pix); dst[x*ncmpts] = cv::saturate_cast<uchar>(pix);
} }
else else
for( x = 0; x < xend - xstart; x++ ) for( x = 0; x < xend - xstart; x++ )
{ {
int pix = ((pix_row[x] + delta) >> rshift) << lshift; int pix = ((pix_row[x] + delta) >> rshift) << lshift;
dst[x*ncmpts] = CV_CAST_8U(pix); dst[x*ncmpts] = cv::saturate_cast<uchar>(pix);
} }
} }
else if( xstep == 2 && offset == 0 ) else if( xstep == 2 && offset == 0 )
for( x = 0, j = 0; x < xend - xstart; x += 2, j++ ) for( x = 0, j = 0; x < xend - xstart; x += 2, j++ )
{ {
int pix = ((pix_row[j] + delta) >> rshift) << lshift; int pix = ((pix_row[j] + delta) >> rshift) << lshift;
dst[x*ncmpts] = dst[(x+1)*ncmpts] = CV_CAST_8U(pix); dst[x*ncmpts] = dst[(x+1)*ncmpts] = cv::saturate_cast<uchar>(pix);
} }
else else
for( x = 0, j = 0; x < xend - xstart; j++ ) for( x = 0, j = 0; x < xend - xstart; j++ )
{ {
int pix = ((pix_row[j] + delta) >> rshift) << lshift; int pix = ((pix_row[j] + delta) >> rshift) << lshift;
pix = CV_CAST_8U(pix); pix = cv::saturate_cast<uchar>(pix);
for( x1 = x + xstep; x < x1; x++ ) for( x1 = x + xstep; x < x1; x++ )
dst[x*ncmpts] = (uchar)pix; dst[x*ncmpts] = (uchar)pix;
} }
@ -361,26 +361,26 @@ bool Jpeg2KDecoder::readComponent16u( unsigned short *data, void *_buffer,
for( x = 0; x < xend - xstart; x++ ) for( x = 0; x < xend - xstart; x++ )
{ {
int pix = pix_row[x]; int pix = pix_row[x];
dst[x*ncmpts] = CV_CAST_16U(pix); dst[x*ncmpts] = cv::saturate_cast<ushort>(pix);
} }
else else
for( x = 0; x < xend - xstart; x++ ) for( x = 0; x < xend - xstart; x++ )
{ {
int pix = ((pix_row[x] + delta) >> rshift) << lshift; int pix = ((pix_row[x] + delta) >> rshift) << lshift;
dst[x*ncmpts] = CV_CAST_16U(pix); dst[x*ncmpts] = cv::saturate_cast<ushort>(pix);
} }
} }
else if( xstep == 2 && offset == 0 ) else if( xstep == 2 && offset == 0 )
for( x = 0, j = 0; x < xend - xstart; x += 2, j++ ) for( x = 0, j = 0; x < xend - xstart; x += 2, j++ )
{ {
int pix = ((pix_row[j] + delta) >> rshift) << lshift; int pix = ((pix_row[j] + delta) >> rshift) << lshift;
dst[x*ncmpts] = dst[(x+1)*ncmpts] = CV_CAST_16U(pix); dst[x*ncmpts] = dst[(x+1)*ncmpts] = cv::saturate_cast<ushort>(pix);
} }
else else
for( x = 0, j = 0; x < xend - xstart; j++ ) for( x = 0, j = 0; x < xend - xstart; j++ )
{ {
int pix = ((pix_row[j] + delta) >> rshift) << lshift; int pix = ((pix_row[j] + delta) >> rshift) << lshift;
pix = CV_CAST_16U(pix); pix = cv::saturate_cast<ushort>(pix);
for( x1 = x + xstep; x < x1; x++ ) for( x1 = x + xstep; x < x1; x++ )
dst[x*ncmpts] = (ushort)pix; dst[x*ncmpts] = (ushort)pix;
} }

2
modules/highgui/src/utils.cpp
View File

@ -647,7 +647,7 @@ cvConvertImage( const CvArr* srcarr, CvArr* dstarr, int flags )
{ {
size.width *= size.height; size.width *= size.height;
size.height = 1; size.height = 1;
s_step = d_step = CV_STUB_STEP; s_step = d_step = /*CV_STUB_STEP*/ (1 << 30);
} }
switch( code ) switch( code )

3
modules/highgui/src/window_w32.cpp
View File

@ -1107,8 +1107,7 @@ cvShowImage( const char* name, const CvArr* arr )
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
if (window->useGl) if (window->useGl)
{ {
cv::Mat im(image); cv::imshow(name, cv::cvarrToMat(image));
cv::imshow(name, im);
return; return;
} }
#endif #endif

6
modules/imgproc/src/demosaicing.cpp
View File

@ -1018,9 +1018,9 @@ static void Bayer2RGB_VNG_8u( const Mat& srcmat, Mat& dstmat, int code )
R = G + cvRound((Rs - Gs)*scale[ng]); R = G + cvRound((Rs - Gs)*scale[ng]);
B = G + cvRound((Bs - Gs)*scale[ng]); B = G + cvRound((Bs - Gs)*scale[ng]);
} }
dstrow[blueIdx] = CV_CAST_8U(B); dstrow[blueIdx] = cv::saturate_cast<uchar>(B);
dstrow[1] = CV_CAST_8U(G); dstrow[1] = cv::saturate_cast<uchar>(G);
dstrow[blueIdx^2] = CV_CAST_8U(R); dstrow[blueIdx^2] = cv::saturate_cast<uchar>(R);
greenCell = !greenCell; greenCell = !greenCell;
} }

2
modules/imgproc/src/distransform.cpp
View File

@ -619,7 +619,7 @@ distanceATS_L1_8u( const Mat& src, Mat& dst )
////////////////////// forward scan //////////////////////// ////////////////////// forward scan ////////////////////////
for( x = 0; x < 256; x++ ) for( x = 0; x < 256; x++ )
lut[x] = CV_CAST_8U(x+1); lut[x] = cv::saturate_cast<uchar>(x+1);
//init first pixel to max (we're going to be skipping it) //init first pixel to max (we're going to be skipping it)
dbase[0] = (uchar)(sbase[0] == 0 ? 0 : 255); dbase[0] = (uchar)(sbase[0] == 0 ? 0 : 255);

121
modules/imgproc/src/geometry.cpp
View File

@ -589,124 +589,3 @@ float cv::intersectConvexConvex( InputArray _p1, InputArray _p2, OutputArray _p1
} }
return (float)fabs(area); return (float)fabs(area);
} }
/*
static void testConvConv()
{
static const int P1[] =
{
0, 0,
100, 0,
100, 100,
0, 100,
};
static const int Q1[] =
{
100, 80,
50, 80,
50, 50,
100, 50
};
static const int P2[] =
{
0, 0,
200, 0,
200, 100,
100, 200,
0, 100
};
static const int Q2[] =
{
100, 100,
300, 100,
300, 200,
100, 200
};
static const int P3[] =
{
0, 0,
100, 0,
100, 100,
0, 100
};
static const int Q3[] =
{
50, 50,
150, 50,
150, 150,
50, 150
};
static const int P4[] =
{
0, 160,
50, 80,
130, 0,
190, 20,
240, 100,
240, 260,
190, 290,
130, 320,
70, 320,
30, 290
};
static const int Q4[] =
{
160, -30,
280, 160,
160, 320,
0, 220,
30, 100
};
static const void* PQs[] =
{
P1, Q1, P2, Q2, P3, Q3, P4, Q4
};
static const int lens[] =
{
CV_DIM(P1), CV_DIM(Q1),
CV_DIM(P2), CV_DIM(Q2),
CV_DIM(P3), CV_DIM(Q3),
CV_DIM(P4), CV_DIM(Q4)
};
Mat img(800, 800, CV_8UC3);
for( int i = 0; i < CV_DIM(PQs)/2; i++ )
{
Mat Pm = Mat(lens[i*2]/2, 1, CV_32SC2, (void*)PQs[i*2]) + Scalar(100, 100);
Mat Qm = Mat(lens[i*2+1]/2, 1, CV_32SC2, (void*)PQs[i*2+1]) + Scalar(100, 100);
Point* P = Pm.ptr<Point>();
Point* Q = Qm.ptr<Point>();
flip(Pm, Pm, 0);
flip(Qm, Qm, 0);
Mat Rm;
intersectConvexConvex(Pm, Qm, Rm);
std::cout << Rm << std::endl << std::endl;
img = Scalar::all(0);
polylines(img, Pm, true, Scalar(0,255,0), 1, CV_AA, 0);
polylines(img, Qm, true, Scalar(0,0,255), 1, CV_AA, 0);
Mat temp;
Rm.convertTo(temp, CV_32S, 256);
polylines(img, temp, true, Scalar(128, 255, 255), 3, CV_AA, 8);
namedWindow("test", 1);
imshow("test", img);
waitKey();
}
}
*/
/* End of file. */

2
modules/imgproc/src/smooth.cpp
View File

@ -1772,7 +1772,7 @@ public:
sum += val*w; sum += val*w;
wsum += w; wsum += w;
} }
// overflow is not possible here => there is no need to use CV_CAST_8U // overflow is not possible here => there is no need to use cv::saturate_cast
dptr[j] = (uchar)cvRound(sum/wsum); dptr[j] = (uchar)cvRound(sum/wsum);
} }
} }

9
modules/imgproc/src/templmatch.cpp
View File

@ -280,8 +280,7 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
integral(img, sum, sqsum, CV_64F); integral(img, sum, sqsum, CV_64F);
meanStdDev( templ, templMean, templSdv ); meanStdDev( templ, templMean, templSdv );
templNorm = CV_SQR(templSdv[0]) + CV_SQR(templSdv[1]) + templNorm = templSdv[0]*templSdv[0] + templSdv[1]*templSdv[1] + templSdv[2]*templSdv[2] + templSdv[3]*templSdv[3];
CV_SQR(templSdv[2]) + CV_SQR(templSdv[3]);
if( templNorm < DBL_EPSILON && method == CV_TM_CCOEFF_NORMED ) if( templNorm < DBL_EPSILON && method == CV_TM_CCOEFF_NORMED )
{ {
@ -289,9 +288,7 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
return; return;
} }
templSum2 = templNorm + templSum2 = templNorm + templMean[0]*templMean[0] + templMean[1]*templMean[1] + templMean[2]*templMean[2] + templMean[3]*templMean[3];
CV_SQR(templMean[0]) + CV_SQR(templMean[1]) +
CV_SQR(templMean[2]) + CV_SQR(templMean[3]);
if( numType != 1 ) if( numType != 1 )
{ {
@ -335,7 +332,7 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
for( k = 0; k < cn; k++ ) for( k = 0; k < cn; k++ )
{ {
t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k]; t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k];
wndMean2 += CV_SQR(t); wndMean2 += t*t;
num -= t*templMean[k]; num -= t*templMean[k];
} }

2
modules/legacy/src/createhandmask.cpp
View File

@ -124,7 +124,7 @@ cvCreateHandMask( CvSeq * numbers, IplImage * img_mask, CvRect * roi )
__BEGIN__; __BEGIN__;
if( img_mask->depth != IPL_DEPTH_8U ) if( img_mask->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( img_mask->nChannels != 1 ) if( img_mask->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, "output image have wrong number of channels" ); CV_ERROR( CV_BadNumChannels, "output image have wrong number of channels" );

64
modules/legacy/src/eigenobjects.cpp
View File

@ -1192,9 +1192,9 @@ cvCalcCovarMatrixEx( int nObjects, void* input, int ioFlags,
cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size ); cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
if( avg->depth != IPL_DEPTH_32F ) if( avg->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( avg->nChannels != 1 ) if( avg->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( ioFlags == CV_EIGOBJ_NO_CALLBACK ) if( ioFlags == CV_EIGOBJ_NO_CALLBACK )
{ {
@ -1213,11 +1213,11 @@ cvCalcCovarMatrixEx( int nObjects, void* input, int ioFlags,
cvGetImageRawData( img, &img_data, &img_step, &img_size ); cvGetImageRawData( img, &img_data, &img_step, &img_size );
if( img->depth != IPL_DEPTH_8U ) if( img->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( img_size != avg_size || img_size != old_size ) if( img_size != avg_size || img_size != old_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( img->nChannels != 1 ) if( img->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && img_step != old_step ) if( i > 0 && img_step != old_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );
@ -1327,9 +1327,9 @@ cvCalcEigenObjects( int nObjects,
cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size ); cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
if( avg->depth != IPL_DEPTH_32F ) if( avg->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( avg->nChannels != 1 ) if( avg->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( nEigens > calcLimit->max_iter && calcLimit->type != CV_TERMCRIT_EPS ) if( nEigens > calcLimit->max_iter && calcLimit->type != CV_TERMCRIT_EPS )
nEigens = calcLimit->max_iter; nEigens = calcLimit->max_iter;
@ -1358,11 +1358,11 @@ cvCalcEigenObjects( int nObjects,
cvGetImageRawData( img, &obj_data, &obj_step, &obj_size ); cvGetImageRawData( img, &obj_data, &obj_step, &obj_size );
if( img->depth != IPL_DEPTH_8U ) if( img->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( obj_size != avg_size || obj_size != old_size ) if( obj_size != avg_size || obj_size != old_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( img->nChannels != 1 ) if( img->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && obj_step != old_step ) if( i > 0 && obj_step != old_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );
@ -1377,11 +1377,11 @@ cvCalcEigenObjects( int nObjects,
cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size ); cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
if( eig->depth != IPL_DEPTH_32F ) if( eig->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( eig_size != avg_size || eig_size != oldeig_size ) if( eig_size != avg_size || eig_size != oldeig_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( eig->nChannels != 1 ) if( eig->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && eig_step != oldeig_step ) if( i > 0 && eig_step != oldeig_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );
@ -1415,11 +1415,11 @@ cvCalcEigenObjects( int nObjects,
cvGetImageRawData( img, &obj_data, &obj_step, &obj_size ); cvGetImageRawData( img, &obj_data, &obj_step, &obj_size );
if( img->depth != IPL_DEPTH_8U ) if( img->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( obj_size != avg_size || obj_size != old_size ) if( obj_size != avg_size || obj_size != old_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( img->nChannels != 1 ) if( img->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && obj_step != old_step ) if( i > 0 && obj_step != old_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );
@ -1461,11 +1461,11 @@ cvCalcEigenObjects( int nObjects,
cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size ); cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
if( eig->depth != IPL_DEPTH_32F ) if( eig->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( eig_size != avg_size || eig_size != oldeig_size ) if( eig_size != avg_size || eig_size != oldeig_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( eig->nChannels != 1 ) if( eig->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && eig_step != oldeig_step ) if( i > 0 && eig_step != oldeig_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );
@ -1545,21 +1545,21 @@ cvCalcDecompCoeff( IplImage * obj, IplImage * eigObj, IplImage * avg )
cvGetImageRawData( obj, &obj_data, &obj_step, &obj_size ); cvGetImageRawData( obj, &obj_data, &obj_step, &obj_size );
if( obj->depth != IPL_DEPTH_8U ) if( obj->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( obj->nChannels != 1 ) if( obj->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
cvGetImageRawData( eigObj, (uchar **) & eig_data, &eig_step, &eig_size ); cvGetImageRawData( eigObj, (uchar **) & eig_data, &eig_step, &eig_size );
if( eigObj->depth != IPL_DEPTH_32F ) if( eigObj->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( eigObj->nChannels != 1 ) if( eigObj->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size ); cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
if( avg->depth != IPL_DEPTH_32F ) if( avg->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( avg->nChannels != 1 ) if( avg->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( obj_size != eig_size || obj_size != avg_size ) if( obj_size != eig_size || obj_size != avg_size )
CV_ERROR( CV_StsBadArg, "different sizes of images" ); CV_ERROR( CV_StsBadArg, "different sizes of images" );
@ -1614,15 +1614,15 @@ cvEigenDecomposite( IplImage* obj,
cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size ); cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
if( avg->depth != IPL_DEPTH_32F ) if( avg->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( avg->nChannels != 1 ) if( avg->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
cvGetImageRawData( obj, &obj_data, &obj_step, &obj_size ); cvGetImageRawData( obj, &obj_data, &obj_step, &obj_size );
if( obj->depth != IPL_DEPTH_8U ) if( obj->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( obj->nChannels != 1 ) if( obj->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( obj_size != avg_size ) if( obj_size != avg_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
@ -1644,11 +1644,11 @@ cvEigenDecomposite( IplImage* obj,
cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size ); cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
if( eig->depth != IPL_DEPTH_32F ) if( eig->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( eig_size != avg_size || eig_size != old_size ) if( eig_size != avg_size || eig_size != old_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( eig->nChannels != 1 ) if( eig->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && eig_step != old_step ) if( i > 0 && eig_step != old_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );
@ -1731,15 +1731,15 @@ cvEigenProjection( void* eigInput,
cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size ); cvGetImageRawData( avg, (uchar **) & avg_data, &avg_step, &avg_size );
if( avg->depth != IPL_DEPTH_32F ) if( avg->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( avg->nChannels != 1 ) if( avg->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
cvGetImageRawData( proj, &proj_data, &proj_step, &proj_size ); cvGetImageRawData( proj, &proj_data, &proj_step, &proj_size );
if( proj->depth != IPL_DEPTH_8U ) if( proj->depth != IPL_DEPTH_8U )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( proj->nChannels != 1 ) if( proj->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( proj_size != avg_size ) if( proj_size != avg_size )
CV_ERROR( CV_StsBadArg, "Different sizes of projects" ); CV_ERROR( CV_StsBadArg, "Different sizes of projects" );
@ -1761,11 +1761,11 @@ cvEigenProjection( void* eigInput,
cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size ); cvGetImageRawData( eig, (uchar **) & eig_data, &eig_step, &eig_size );
if( eig->depth != IPL_DEPTH_32F ) if( eig->depth != IPL_DEPTH_32F )
CV_ERROR( CV_BadDepth, cvUnsupportedFormat ); CV_ERROR( CV_BadDepth, "Unsupported format" );
if( eig_size != avg_size || eig_size != old_size ) if( eig_size != avg_size || eig_size != old_size )
CV_ERROR( CV_StsBadArg, "Different sizes of objects" ); CV_ERROR( CV_StsBadArg, "Different sizes of objects" );
if( eig->nChannels != 1 ) if( eig->nChannels != 1 )
CV_ERROR( CV_BadNumChannels, cvUnsupportedFormat ); CV_ERROR( CV_BadNumChannels, "Unsupported format" );
if( i > 0 && eig_step != old_step ) if( i > 0 && eig_step != old_step )
CV_ERROR( CV_StsBadArg, "Different steps of objects" ); CV_ERROR( CV_StsBadArg, "Different steps of objects" );

4
modules/legacy/src/pyrsegmentation.cpp
View File

@ -1843,7 +1843,7 @@ cvPyrSegmentation( IplImage * src,
int thresh2 = cvRound( threshold2 ); int thresh2 = cvRound( threshold2 );
if( src->depth != IPL_DEPTH_8U ) if( src->depth != IPL_DEPTH_8U )
CV_Error( CV_BadDepth, cvUnsupportedFormat ); CV_Error( CV_BadDepth, "Unsupported format" );
if( src->depth != dst->depth || src->nChannels != dst->nChannels ) if( src->depth != dst->depth || src->nChannels != dst->nChannels )
CV_Error( CV_StsBadArg, "src and dst have different formats" ); CV_Error( CV_StsBadArg, "src and dst have different formats" );
@ -1872,7 +1872,7 @@ cvPyrSegmentation( IplImage * src,
comp, storage, level, thresh1, thresh2 )); comp, storage, level, thresh1, thresh2 ));
break; break;
default: default:
CV_Error( CV_BadNumChannels, cvUnsupportedFormat ); CV_Error( CV_BadNumChannels, "Unsupported format" );
} }
} }

2
modules/legacy/src/snakes.cpp
View File

@ -416,7 +416,7 @@ cvSnakeImage( const IplImage* src, CvPoint* points,
CV_Error( CV_BadNumChannels, "input image has more than one channel" ); CV_Error( CV_BadNumChannels, "input image has more than one channel" );
if( src->depth != IPL_DEPTH_8U ) if( src->depth != IPL_DEPTH_8U )
CV_Error( CV_BadDepth, cvUnsupportedFormat ); CV_Error( CV_BadDepth, "Unsupported format" );
cvGetRawData( src, &data, &step, &size ); cvGetRawData( src, &data, &step, &size );

16
modules/legacy/src/testseq.cpp
View File

@ -927,7 +927,7 @@ IplImage* cvTestSeqQueryFrame(CvTestSeq* pTestSeq)
for(p=pTS->pElemList; p; p=p->next) for(p=pTS->pElemList; p; p=p->next)
{ {
int DirectCopy = FALSE; int DirectCopy = 0;
int frame = pTS->CurFrame - p->FrameBegin; int frame = pTS->CurFrame - p->FrameBegin;
//float t = p->FrameNum>1?((float)frame/(p->FrameNum-1)):0; //float t = p->FrameNum>1?((float)frame/(p->FrameNum-1)):0;
CvTSTrans* pTrans = p->pTrans + frame%p->TransNum; CvTSTrans* pTrans = p->pTrans + frame%p->TransNum;
@ -996,13 +996,13 @@ IplImage* cvTestSeqQueryFrame(CvTestSeq* pTestSeq)
{ /* Check for direct copy: */ { /* Check for direct copy: */
DirectCopy = TRUE; DirectCopy = 1;
if( fabs(CV_MAT_ELEM(pT[0],float,0,0)-1) > 0.00001) DirectCopy = FALSE; if( fabs(CV_MAT_ELEM(pT[0],float,0,0)-1) > 0.00001) DirectCopy = 0;
if( fabs(CV_MAT_ELEM(pT[0],float,1,0)) > 0.00001) DirectCopy = FALSE; if( fabs(CV_MAT_ELEM(pT[0],float,1,0)) > 0.00001) DirectCopy = 0;
if( fabs(CV_MAT_ELEM(pT[0],float,0,1)) > 0.00001) DirectCopy = FALSE; if( fabs(CV_MAT_ELEM(pT[0],float,0,1)) > 0.00001) DirectCopy = 0;
if( fabs(CV_MAT_ELEM(pT[0],float,0,1)) > 0.00001) DirectCopy = FALSE; if( fabs(CV_MAT_ELEM(pT[0],float,0,1)) > 0.00001) DirectCopy = 0;
if( fabs(CV_MAT_ELEM(pT[0],float,0,2)-(pImg->width-1)*0.5) > 0.5) DirectCopy = FALSE; if( fabs(CV_MAT_ELEM(pT[0],float,0,2)-(pImg->width-1)*0.5) > 0.5) DirectCopy = 0;
if( fabs(CV_MAT_ELEM(pT[0],float,1,2)-(pImg->height-1)*0.5) > 0.5) DirectCopy = FALSE; if( fabs(CV_MAT_ELEM(pT[0],float,1,2)-(pImg->height-1)*0.5) > 0.5) DirectCopy = 0;
} }
/* Extract image and mask: */ /* Extract image and mask: */

52
modules/legacy/src/vecfacetracking.cpp
View File

@ -152,8 +152,8 @@ struct CvFaceTracker
if ((NULL == imgray) || if ((NULL == imgray) ||
(NULL == imgThresh) || (NULL == imgThresh) ||
(NULL == mstgContours)) (NULL == mstgContours))
return FALSE; return 0;
return TRUE; return 1;
}; };
int InitNextImage(IplImage* img) int InitNextImage(IplImage* img)
{ {
@ -165,7 +165,7 @@ struct CvFaceTracker
CvMat mat = cvMat( 2, 3, CV_32FC1, m ); CvMat mat = cvMat( 2, 3, CV_32FC1, m );
if (NULL == imgGray || NULL == imgThresh) if (NULL == imgGray || NULL == imgThresh)
return FALSE; return 0;
/*m[0] = (float)cos(-dbRotateAngle*CV_PI/180.); /*m[0] = (float)cos(-dbRotateAngle*CV_PI/180.);
m[1] = (float)sin(-dbRotateAngle*CV_PI/180.); m[1] = (float)sin(-dbRotateAngle*CV_PI/180.);
@ -181,8 +181,8 @@ struct CvFaceTracker
else else
cvClearMemStorage(mstgContours); cvClearMemStorage(mstgContours);
if (NULL == mstgContours) if (NULL == mstgContours)
return FALSE; return 0;
return TRUE; return 1;
} }
}; };
@ -209,14 +209,14 @@ public:
if (NULL != mstg) if (NULL != mstg)
m_mstgRects = mstg; m_mstgRects = mstg;
if (NULL == m_mstgRects) if (NULL == m_mstgRects)
return FALSE; return 0;
if (NULL == m_seqRects) if (NULL == m_seqRects)
m_seqRects = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvTrackingRect), m_mstgRects); m_seqRects = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvTrackingRect), m_mstgRects);
else else
cvClearSeq(m_seqRects); cvClearSeq(m_seqRects);
if (NULL == m_seqRects) if (NULL == m_seqRects)
return FALSE; return 0;
return TRUE; return 1;
}; };
void FindRects(IplImage* img, IplImage* thresh, int nLayers, int dMinSize); void FindRects(IplImage* img, IplImage* thresh, int nLayers, int dMinSize);
protected: protected:
@ -433,14 +433,14 @@ cvInitFaceTracker(CvFaceTracker* pFaceTracker, const IplImage* imgGray, CvRect*
(nRects < NUM_FACE_ELEMENTS)) (nRects < NUM_FACE_ELEMENTS))
return NULL; return NULL;
//int new_face = FALSE; //int new_face = 0;
CvFaceTracker* pFace = pFaceTracker; CvFaceTracker* pFace = pFaceTracker;
if (NULL == pFace) if (NULL == pFace)
{ {
pFace = new CvFaceTracker; pFace = new CvFaceTracker;
if (NULL == pFace) if (NULL == pFace)
return NULL; return NULL;
//new_face = TRUE; //new_face = 1;
} }
pFace->Init(pRects, (IplImage*)imgGray); pFace->Init(pRects, (IplImage*)imgGray);
return pFace; return pFace;
@ -464,7 +464,7 @@ cvTrackFace(CvFaceTracker* pFaceTracker, IplImage* imgGray, CvRect* pRects, int
assert(NULL != pRects && nRects >= NUM_FACE_ELEMENTS); assert(NULL != pRects && nRects >= NUM_FACE_ELEMENTS);
if ((NULL == pFaceTracker) || if ((NULL == pFaceTracker) ||
(NULL == imgGray)) (NULL == imgGray))
return FALSE; return 0;
pFaceTracker->InitNextImage(imgGray); pFaceTracker->InitNextImage(imgGray);
*ptRotate = pFaceTracker->ptRotate; *ptRotate = pFaceTracker->ptRotate;
*dbAngleRotate = pFaceTracker->dbRotateAngle; *dbAngleRotate = pFaceTracker->dbRotateAngle;
@ -505,7 +505,7 @@ START:
if (r.y + r.height > pFaceTracker->imgGray->height - 2) if (r.y + r.height > pFaceTracker->imgGray->height - 2)
r.height = pFaceTracker->imgGray->height - 2 - r.y; r.height = pFaceTracker->imgGray->height - 2 - r.y;
if (!big_face[elem].Init(r, pFaceTracker->face[elem], pFaceTracker->mstgContours)) if (!big_face[elem].Init(r, pFaceTracker->face[elem], pFaceTracker->mstgContours))
return FALSE; return 0;
} }
// find contours // find contours
for (elem = 0; elem < NUM_FACE_ELEMENTS; elem++) for (elem = 0; elem < NUM_FACE_ELEMENTS; elem++)
@ -514,13 +514,13 @@ START:
CvTrackingRect new_face[NUM_FACE_ELEMENTS]; CvTrackingRect new_face[NUM_FACE_ELEMENTS];
int new_energy = 0; int new_energy = 0;
int found = ChoiceTrackingFace3(pFaceTracker, nElements, big_face, new_face, new_energy); int found = ChoiceTrackingFace3(pFaceTracker, nElements, big_face, new_face, new_energy);
int restart = FALSE; int restart = 0;
int find2 = FALSE; int find2 = 0;
int noel = -1; int noel = -1;
if (found) if (found)
{ {
if (new_energy > 100000 && -1 != pFaceTracker->iTrackingFaceType) if (new_energy > 100000 && -1 != pFaceTracker->iTrackingFaceType)
find2 = TRUE; find2 = 1;
else if (new_energy > 150000) else if (new_energy > 150000)
{ {
int elements = 0; int elements = 0;
@ -532,17 +532,17 @@ START:
noel = el; noel = el;
} }
if (2 == elements) if (2 == elements)
find2 = TRUE; find2 = 1;
else else
restart = TRUE; restart = 1;
} }
} }
else else
{ {
if (-1 != pFaceTracker->iTrackingFaceType) if (-1 != pFaceTracker->iTrackingFaceType)
find2 = TRUE; find2 = 1;
else else
restart = TRUE; restart = 1;
} }
RESTART: RESTART:
if (restart) if (restart)
@ -561,11 +561,11 @@ RESTART:
if (found2 && new_energy < 100000) if (found2 && new_energy < 100000)
{ {
pFaceTracker->iTrackingFaceType = noel; pFaceTracker->iTrackingFaceType = noel;
found = TRUE; found = 1;
} }
else else
{ {
restart = TRUE; restart = 1;
goto RESTART; goto RESTART;
} }
} }
@ -599,7 +599,7 @@ RESTART:
{ {
pFaceTracker->dbRotateDelta = 0; pFaceTracker->dbRotateDelta = 0;
pFaceTracker->dbRotateAngle = 0; pFaceTracker->dbRotateAngle = 0;
found = FALSE; found = 0;
} }
if (found) if (found)
{ {
@ -663,7 +663,7 @@ int ChoiceTrackingFace3(CvFaceTracker* pTF, const int nElements, const CvFaceEle
CvTrackingRect* new_face[NUM_FACE_ELEMENTS] = {NULL}; CvTrackingRect* new_face[NUM_FACE_ELEMENTS] = {NULL};
new_energy = 0x7fffffff; new_energy = 0x7fffffff;
int curr_energy = 0x7fffffff; int curr_energy = 0x7fffffff;
int found = FALSE; int found = 0;
int N = 0; int N = 0;
CvSeqReader reader_m, reader_l, reader_r; CvSeqReader reader_m, reader_l, reader_r;
cvStartReadSeq( big_face[MOUTH].m_seqRects, &reader_m ); cvStartReadSeq( big_face[MOUTH].m_seqRects, &reader_m );
@ -689,7 +689,7 @@ int ChoiceTrackingFace3(CvFaceTracker* pTF, const int nElements, const CvFaceEle
for (int elem = 0; elem < NUM_FACE_ELEMENTS; elem++) for (int elem = 0; elem < NUM_FACE_ELEMENTS; elem++)
new_face[elem] = curr_face[elem]; new_face[elem] = curr_face[elem];
new_energy = curr_energy; new_energy = curr_energy;
found = TRUE; found = 1;
} }
N++; N++;
} }
@ -722,7 +722,7 @@ int ChoiceTrackingFace2(CvFaceTracker* pTF, const int nElements, const CvFaceEle
CvTrackingRect* new_face[NUM_FACE_ELEMENTS] = {NULL}; CvTrackingRect* new_face[NUM_FACE_ELEMENTS] = {NULL};
new_energy = 0x7fffffff; new_energy = 0x7fffffff;
int curr_energy = 0x7fffffff; int curr_energy = 0x7fffffff;
int found = FALSE; int found = 0;
int N = 0; int N = 0;
CvSeqReader reader0, reader1; CvSeqReader reader0, reader1;
cvStartReadSeq( big_face[element[0]].m_seqRects, &reader0 ); cvStartReadSeq( big_face[element[0]].m_seqRects, &reader0 );
@ -739,7 +739,7 @@ int ChoiceTrackingFace2(CvFaceTracker* pTF, const int nElements, const CvFaceEle
for (int elem = 0; elem < NUM_FACE_ELEMENTS; elem++) for (int elem = 0; elem < NUM_FACE_ELEMENTS; elem++)
new_face[elem] = curr_face[elem]; new_face[elem] = curr_face[elem];
new_energy = curr_energy; new_energy = curr_energy;
found = TRUE; found = 1;
} }
N++; N++;
} }

16
modules/objdetect/src/linemod.cpp
View File

@ -175,7 +175,7 @@ void QuantizedPyramid::selectScatteredFeatures(const std::vector<Candidate>& can
size_t num_features, float distance) size_t num_features, float distance)
{ {
features.clear(); features.clear();
float distance_sq = CV_SQR(distance); float distance_sq = distance * distance;
int i = 0; int i = 0;
while (features.size() < num_features) while (features.size() < num_features)
{ {
@ -186,7 +186,7 @@ void QuantizedPyramid::selectScatteredFeatures(const std::vector<Candidate>& can
for (int j = 0; (j < (int)features.size()) && keep; ++j) for (int j = 0; (j < (int)features.size()) && keep; ++j)
{ {
Feature f = features[j]; Feature f = features[j];
keep = CV_SQR(c.f.x - f.x) + CV_SQR(c.f.y - f.y) >= distance_sq; keep = (c.f.x - f.x)*(c.f.x - f.x) + (c.f.y - f.y)*(c.f.y - f.y) >= distance_sq;
} }
if (keep) if (keep)
features.push_back(c.f); features.push_back(c.f);
@ -196,7 +196,7 @@ void QuantizedPyramid::selectScatteredFeatures(const std::vector<Candidate>& can
// Start back at beginning, and relax required distance // Start back at beginning, and relax required distance
i = 0; i = 0;
distance -= 1.0f; distance -= 1.0f;
distance_sq = CV_SQR(distance); distance_sq = distance * distance;
} }
} }
} }
@ -306,9 +306,9 @@ static void quantizedOrientations(const Mat& src, Mat& magnitude,
for (int i = 0; i < length0; i += 3) for (int i = 0; i < length0; i += 3)
{ {
// Use the gradient orientation of the channel whose magnitude is largest // Use the gradient orientation of the channel whose magnitude is largest
int mag1 = CV_SQR(ptrx[i]) + CV_SQR(ptry[i]); int mag1 = ptrx[i+0] * ptrx[i + 0] + ptry[i + 0] * ptry[i + 0];
int mag2 = CV_SQR(ptrx[i + 1]) + CV_SQR(ptry[i + 1]); int mag2 = ptrx[i+1] * ptrx[i + 1] + ptry[i + 1] * ptry[i + 1];
int mag3 = CV_SQR(ptrx[i + 2]) + CV_SQR(ptry[i + 2]); int mag3 = ptrx[i+2] * ptrx[i + 2] + ptry[i + 2] * ptry[i + 2];
if (mag1 >= mag2 && mag1 >= mag3) if (mag1 >= mag2 && mag1 >= mag3)
{ {
@ -339,7 +339,7 @@ static void quantizedOrientations(const Mat& src, Mat& magnitude,
// Calculate the final gradient orientations // Calculate the final gradient orientations
phase(sobel_dx, sobel_dy, sobel_ag, true); phase(sobel_dx, sobel_dy, sobel_ag, true);
hysteresisGradient(magnitude, angle, sobel_ag, CV_SQR(threshold)); hysteresisGradient(magnitude, angle, sobel_ag, threshold * threshold);
} }
void hysteresisGradient(Mat& magnitude, Mat& quantized_angle, void hysteresisGradient(Mat& magnitude, Mat& quantized_angle,
@ -509,7 +509,7 @@ bool ColorGradientPyramid::extractTemplate(Template& templ) const
// Create sorted list of all pixels with magnitude greater than a threshold // Create sorted list of all pixels with magnitude greater than a threshold
std::vector<Candidate> candidates; std::vector<Candidate> candidates;
bool no_mask = local_mask.empty(); bool no_mask = local_mask.empty();
float threshold_sq = CV_SQR(strong_threshold); float threshold_sq = strong_threshold*strong_threshold;
for (int r = 0; r < magnitude.rows; ++r) for (int r = 0; r < magnitude.rows; ++r)
{ {
const uchar* angle_r = angle.ptr<uchar>(r); const uchar* angle_r = angle.ptr<uchar>(r);

8
modules/video/src/affineflow.cpp
View File

@ -397,10 +397,8 @@ static CvStatus CV_STDCALL icvGetRectSubPix_8u32f_C1R
#define ICV_32F8U(x) ((uchar)cvRound(x)) #define ICV_32F8U(x) ((uchar)cvRound(x))
#define ICV_DEF_GET_QUADRANGLE_SUB_PIX_FUNC( flavor, srctype, dsttype, \ #define ICV_DEF_GET_QUADRANGLE_SUB_PIX_FUNC( flavor, srctype, dsttype, worktype, cast_macro, cvt ) \
worktype, cast_macro, cvt ) \ static CvStatus CV_STDCALL icvGetQuadrangleSubPix_##flavor##_C1R \
static CvStatus CV_STDCALL \
icvGetQuadrangleSubPix_##flavor##_C1R \
( const srctype * src, int src_step, CvSize src_size, \ ( const srctype * src, int src_step, CvSize src_size, \
dsttype *dst, int dst_step, CvSize win_size, const float *matrix ) \ dsttype *dst, int dst_step, CvSize win_size, const float *matrix ) \
{ \ { \
@ -472,7 +470,7 @@ dst[x] = cast_macro(p0 + b * (p1 - p0)); \
return CV_OK; \ return CV_OK; \
} }
ICV_DEF_GET_QUADRANGLE_SUB_PIX_FUNC( 8u32f, uchar, float, double, CV_CAST_32F, CV_8TO32F ) ICV_DEF_GET_QUADRANGLE_SUB_PIX_FUNC( 8u32f, uchar, float, double, cv::saturate_cast<float>, CV_8TO32F )
/* Affine tracking algorithm */ /* Affine tracking algorithm */

2
samples/cpp/kalman.cpp
View File

@ -40,7 +40,7 @@ int main(int, char**)
for(;;) for(;;)
{ {
randn( state, Scalar::all(0), Scalar::all(0.1) ); randn( state, Scalar::all(0), Scalar::all(0.1) );
KF.transitionMatrix = *(Mat_<float>(2, 2) << 1, 1, 0, 1); KF.transitionMatrix = (Mat_<float>(2, 2) << 1, 1, 0, 1);
setIdentity(KF.measurementMatrix); setIdentity(KF.measurementMatrix);
setIdentity(KF.processNoiseCov, Scalar::all(1e-5)); setIdentity(KF.processNoiseCov, Scalar::all(1e-5));