fixed GCC 4.3 warnings (and couple of real yet minor bugs)

git-svn-id: https://code.ros.org/svn/opencv/trunk@1329 73c94f0f-984f-4a5f-82bc-2d8db8d8ee08

diff --git a/opencv/src/cxcore/cxarray.cpp b/opencv/src/cxcore/cxarray.cpp
index b4d4e698263b07fb1787ff67b1adb0fb023f51a4..03f6dac0dd61ee0a6b353f00dfde0668e9650f27 100644 (file)
--- a/opencv/src/cxcore/cxarray.cpp
+++ b/opencv/src/cxcore/cxarray.cpp
@@ -2983,7 +2983,7 @@ cvReshapeMatND( const CvArr* arr,
         header->cols = total_width / new_cn;
 
         if( header->cols * new_cn != total_width ||
-            new_sizes && header->cols != new_sizes[1] )
+            (new_sizes && header->cols != new_sizes[1]) )
             CV_ERROR( CV_StsBadArg, "The total matrix width is not "
                             "divisible by the new number of columns" );
 
@@ -3256,9 +3256,9 @@ static IplROI* icvCreateROI( int coi, int xOffset, int yOffset, int width, int h
 }
 
 static  void
-icvGetColorModel( int nchannels, char** colorModel, char** channelSeq )
+icvGetColorModel( int nchannels, const char** colorModel, const char** channelSeq )
 {
-    static char* tab[][2] =
+    static const char* tab[][2] =
     {
         {"GRAY", "GRAY"},
         {"",""},
@@ -3295,12 +3295,11 @@ cvCreateImageHeader( CvSize size, int depth, int channels )
     }
     else
     {
-        char *colorModel;
-        char *channelSeq;
+        const char *colorModel, *channelSeq;
 
         icvGetColorModel( channels, &colorModel, &channelSeq );
 
-        img = CvIPL.createHeader( channels, 0, depth, colorModel, channelSeq,
+        img = CvIPL.createHeader( channels, 0, depth, (char*)colorModel, (char*)channelSeq,
                                   IPL_DATA_ORDER_PIXEL, IPL_ORIGIN_TL,
                                   CV_DEFAULT_IMAGE_ROW_ALIGN,
                                   size.width, size.height, 0, 0, 0, 0 );
@@ -3349,7 +3348,7 @@ cvInitImageHeader( IplImage * image, CvSize size, int depth,
 
     __BEGIN__;
 
-    char *colorModel, *channelSeq;
+    const char *colorModel, *channelSeq;
 
     if( !image )
         CV_ERROR( CV_HeaderIsNull, "null pointer to header" );

diff --git a/opencv/src/cxcore/cxdxt.cpp b/opencv/src/cxcore/cxdxt.cpp
index 5791b838d026e774f35c097cf5b96330bf76a3bc..60b3c89cdebab94675e44e8e6b45820a280caed5 100644 (file)
--- a/opencv/src/cxcore/cxdxt.cpp
+++ b/opencv/src/cxcore/cxdxt.cpp
@@ -1820,7 +1820,7 @@ cvDFT( const CvArr* srcarr, CvArr* dstarr, int flags, int nonzero_rows )
     else if( !inv && CV_MAT_CN(src->type) == 1 && CV_MAT_CN(dst->type) == 2 )
     {
         if( (src->cols != 1 || dst->cols != 1 ||
-            src->rows/2+1 != dst->rows && src->rows != dst->rows) &&
+            (src->rows/2+1 != dst->rows && src->rows != dst->rows)) &&
             (src->cols/2+1 != dst->cols || src->rows != dst->rows) )
             CV_ERROR( CV_StsUnmatchedSizes, "" );
         real_transform = 1;
@@ -1828,7 +1828,7 @@ cvDFT( const CvArr* srcarr, CvArr* dstarr, int flags, int nonzero_rows )
     else if( inv && CV_MAT_CN(src->type) == 2 && CV_MAT_CN(dst->type) == 1 )
     {
         if( (src->cols != 1 || dst->cols != 1 ||
-            dst->rows/2+1 != src->rows && src->rows != dst->rows) &&
+            (dst->rows/2+1 != src->rows && src->rows != dst->rows)) &&
             (dst->cols/2+1 != src->cols || src->rows != dst->rows) )
             CV_ERROR( CV_StsUnmatchedSizes, "" );
         real_transform = 1;
@@ -1845,8 +1845,8 @@ cvDFT( const CvArr* srcarr, CvArr* dstarr, int flags, int nonzero_rows )
     // determine, which transform to do first - row-wise
     // (stage 0) or column-wise (stage 1) transform
     if( !(flags & CV_DXT_ROWS) && src->rows > 1 &&
-        (src->cols == 1 && !CV_IS_MAT_CONT(src->type & dst->type) ||
-        src->cols > 1 && inv && real_transform) )
+        ((src->cols == 1 && !CV_IS_MAT_CONT(src->type & dst->type)) ||
+        (src->cols > 1 && inv && real_transform)) )
         stage = 1;
 
     ipp_norm_flag = !(flags & CV_DXT_SCALE) ? 8 : (flags & CV_DXT_INVERSE) ? 2 : 1;
@@ -1938,8 +1938,8 @@ cvDFT( const CvArr* srcarr, CvArr* dstarr, int flags, int nonzero_rows )
             if( (factors[i] & 1) != 0 && factors[i] > 5 )
                 sz += (factors[i]+1)*complex_elem_size;
 
-            if( stage == 0 && (src->data.ptr == dst->data.ptr && !inplace_transform || odd_real) ||
-                stage == 1 && !inplace_transform )
+            if( (stage == 0 && ((src->data.ptr == dst->data.ptr && !inplace_transform) || odd_real)) ||
+                (stage == 1 && !inplace_transform) )
             {
                 use_buf = 1;
                 sz += len*complex_elem_size;
@@ -1948,7 +1948,7 @@ cvDFT( const CvArr* srcarr, CvArr* dstarr, int flags, int nonzero_rows )
 
         if( sz > buf_size )
         {
-            prev_len = 0; // because we release the buffer, 
+            prev_len = 0; // because we release the buffer,
                           // force recalculation of
                           // twiddle factors and permutation table
             if( !local_alloc && buffer )
@@ -2238,8 +2238,8 @@ cvMulSpectrums( const CvArr* srcAarr, const CvArr* srcBarr,
     rows = srcA->rows;
     cols = srcA->cols;
     is_1d = (flags & CV_DXT_ROWS) ||
-            (rows == 1 || cols == 1 &&
-             CV_IS_MAT_CONT( srcA->type & srcB->type & dst->type ));
+            (rows == 1 || (cols == 1 &&
+             CV_IS_MAT_CONT( srcA->type & srcB->type & dst->type )));
 
     if( is_1d && !(flags & CV_DXT_ROWS) )
         cols = cols + rows - 1, rows = 1;
@@ -2647,7 +2647,7 @@ cvDCT( const CvArr* srcarr, CvArr* dstarr, int flags )
     dct_func = dct_tbl[inv + (depth == CV_64F)*2];
 
     if( (flags & CV_DXT_ROWS) || src->rows == 1 ||
-        src->cols == 1 && CV_IS_MAT_CONT(src->type & dst->type))
+        (src->cols == 1 && CV_IS_MAT_CONT(src->type & dst->type)))
     {
         stage = end_stage = 0;
     }

diff --git a/opencv/src/cxcore/cximage.cpp b/opencv/src/cxcore/cximage.cpp
index c016680b6431e080741a4b965f7bac7db3b9c64f..2f67ee19ef8d216db43add96d258641a798e08fa 100644 (file)
--- a/opencv/src/cxcore/cximage.cpp
+++ b/opencv/src/cxcore/cximage.cpp
@@ -59,7 +59,7 @@ icvIsXmlOrYaml( const char* filename )
 {
     const char* suffix = strrchr( filename, '.' );
     return suffix &&
-        strcmp( suffix, ".xml" ) == 0 ||
+        (strcmp( suffix, ".xml" ) == 0 ||
         strcmp( suffix, ".Xml" ) == 0 ||
         strcmp( suffix, ".XML" ) == 0 ||
         strcmp( suffix, ".yml" ) == 0 ||
@@ -67,7 +67,7 @@ icvIsXmlOrYaml( const char* filename )
         strcmp( suffix, ".YML" ) == 0 ||
         strcmp( suffix, ".yaml" ) == 0 ||
         strcmp( suffix, ".Yaml" ) == 0 ||
-        strcmp( suffix, ".YAML" ) == 0;
+        strcmp( suffix, ".YAML" ) == 0);
 }
 
 

diff --git a/opencv/src/cxcore/cxlut.cpp b/opencv/src/cxcore/cxlut.cpp
index 166e6cebb92561f31eb4d3b228ffc8e4231e4c4c..589d9b91d714bddc4029637f555321f348e0b75a 100644 (file)
--- a/opencv/src/cxcore/cxlut.cpp
+++ b/opencv/src/cxcore/cxlut.cpp
@@ -295,11 +295,11 @@ cvLUT( const void* srcarr, void* dstarr, const void* lutarr )
         lut_data = shuffled_lut;
     }
 
-    if( lut_cn == 1 || lut_cn <= 4 && depth == CV_8U )
+    if( lut_cn == 1 || (lut_cn <= 4 && depth == CV_8U) )
     {
         CvLUT_TransformFunc func = depth == CV_8U ? lut_8u_tab[cn-1] :
             (CvLUT_TransformFunc)(lut_c1_tab.fn_2d[depth]);
-    
+
         if( !func )
             CV_ERROR( CV_StsUnsupportedFormat, "" );
 

diff --git a/opencv/src/cxcore/cxmathfuncs.cpp b/opencv/src/cxcore/cxmathfuncs.cpp
index bf12588eaeba8f72b3020d01e3497dac474e3d76..dfac47bf167aa1964226a2527f85eb5158ed5e83 100644 (file)
--- a/opencv/src/cxcore/cxmathfuncs.cpp
+++ b/opencv/src/cxcore/cxmathfuncs.cpp
@@ -722,7 +722,7 @@ typedef union
 DBLINT;
 
 #define EXPTAB_SCALE 6
-#define EXPTAB_MASK  (1 << EXPTAB_SCALE) - 1
+#define EXPTAB_MASK  ((1 << EXPTAB_SCALE) - 1)
 
 #define EXPPOLY_32F_A0 .9670371139572337719125840413672004409288e-2
 

diff --git a/opencv/src/cxcore/cxmatmul.cpp b/opencv/src/cxcore/cxmatmul.cpp
index 0466b19c9d9c152800637a161f18456bea3b755b..f6d31425ce0ed6ce16d753eb10c4f6d625f7410b 100644 (file)
--- a/opencv/src/cxcore/cxmatmul.cpp
+++ b/opencv/src/cxcore/cxmatmul.cpp
@@ -675,8 +675,8 @@ cvGEMM( const CvArr* Aarr, const CvArr* Barr, double alpha,
         if( !CV_ARE_TYPES_EQ( C, D ))
             CV_ERROR( CV_StsUnmatchedFormats, "" );
 
-        if( (flags&CV_GEMM_C_T) == 0 && (C->cols != D->cols || C->rows != D->rows) ||
-            (flags&CV_GEMM_C_T) != 0 && (C->rows != D->cols || C->cols != D->rows))
+        if( ((flags&CV_GEMM_C_T) == 0 && (C->cols != D->cols || C->rows != D->rows)) ||
+            ((flags&CV_GEMM_C_T) != 0 && (C->rows != D->cols || C->cols != D->rows)))
             CV_ERROR( CV_StsUnmatchedSizes, "" );
 
         if( (flags & CV_GEMM_C_T) != 0 && C->data.ptr == D->data.ptr )
@@ -1090,9 +1090,9 @@ cvGEMM( const CvArr* Aarr, const CvArr* Barr, double alpha,
                        &_beta, D->data.ptr, &ldd );
             }
         }
-        else if( (d_size.height <= block_lin_size/2 || d_size.width <= block_lin_size/2) &&
-            len <= 10000 || len <= 10 ||
-            d_size.width <= block_lin_size && d_size.height <= block_lin_size && len <= block_lin_size )
+        else if( ((d_size.height <= block_lin_size/2 || d_size.width <= block_lin_size/2) &&
+            len <= 10000) || len <= 10 ||
+            (d_size.width <= block_lin_size && d_size.height <= block_lin_size && len <= block_lin_size) )
         {
             single_mul_func( A->data.ptr, A->step, B->data.ptr, b_step,
                              C->data.ptr, C->step, D->data.ptr, D->step,
@@ -1213,7 +1213,7 @@ cvGEMM( const CvArr* Aarr, const CvArr* Barr, double alpha,
                             CV_SWAP( a_bl_size.width, a_bl_size.height, t );
                             _a = a_buf;
                         }
-                
+
                         if( dj < d_size.width )
                         {
                             CvSize b_size;
@@ -1647,7 +1647,7 @@ cvTransform( const CvArr* srcarr, CvArr* dstarr,
     {
         if( !src_seq )
         {
-            if( CV_IS_MAT_CONT(src->type) || src->rows != 1 && src->cols != 1 )
+            if( CV_IS_MAT_CONT(src->type) || (src->rows != 1 && src->cols != 1) )
                 CV_ERROR( CV_StsBadSize, "if eigher the source or destination is a sequence, "
                 "the other array must be also a sequence of continous 1d vector" );
             src_seq = cvMakeSeqHeaderForArray( CV_MAT_TYPE(src->type), sizeof(hdr),
@@ -1657,7 +1657,7 @@ cvTransform( const CvArr* srcarr, CvArr* dstarr,
 
         if( !dst_seq )
         {
-            if( CV_IS_MAT_CONT(dst->type) || dst->rows != 1 && dst->cols != 1 )
+            if( CV_IS_MAT_CONT(dst->type) || (dst->rows != 1 && dst->cols != 1) )
                 CV_ERROR( CV_StsBadSize, "if eigher the source or destination is a sequence, "
                 "the other array must be also a sequence of continous 1d vector" );
             if( dst->rows + dst->cols - 1 != src_seq->total )
@@ -1725,8 +1725,7 @@ cvTransform( const CvArr* srcarr, CvArr* dstarr,
             CV_CALL( shift = cvGetMat( shift, &shiftstub, &coi ));
 
         if( CV_MAT_CN( shift->type ) * shift->cols * shift->rows == dst_cn &&
-            (shift->rows == 1 || shift->rows == dst_cn) ||
-            (shift->cols == 1 || shift->cols == dst_cn) )
+            (shift->rows == 1 || shift->cols == 1) )
         {
             if( CV_MAT_DEPTH( shift->type ) == CV_64F )
             {
@@ -2615,7 +2614,7 @@ cvCalcCovarMatrix( const CvArr** vecarr, int count,
         if( !dot_func )
             CV_ERROR( CV_StsUnsupportedFormat,
             "The format of input vectors is not supported" );
-        
+
         for( i = 0; i < count; i++ )
         {
             int a, b, delta;
@@ -3161,9 +3160,9 @@ cvMulTransposed( const CvArr* srcarr, CvArr* dstarr,
         (order == 0 && src->rows != dst->rows))
         CV_ERROR( CV_StsUnmatchedSizes, "" );
 
-    if( src->data.ptr == dst->data.ptr || stype == dtype &&
+    if( src->data.ptr == dst->data.ptr || (stype == dtype &&
         (dst->cols >= gemm_level && dst->rows >= gemm_level &&
-         src->cols >= gemm_level && src->rows >= gemm_level))
+         src->cols >= gemm_level && src->rows >= gemm_level)))
     {
         if( deltaarr )
         {
@@ -3172,7 +3171,7 @@ cvMulTransposed( const CvArr* srcarr, CvArr* dstarr,
             cvSub( src, src2, src2 );
             src = src2;
         }
-        cvGEMM( src, src, scale, 0, 0, dst, order == 0 ? CV_GEMM_B_T : CV_GEMM_A_T ); 
+        cvGEMM( src, src, scale, 0, 0, dst, order == 0 ? CV_GEMM_B_T : CV_GEMM_A_T );
     }
     else
     {

diff --git a/opencv/src/cxcore/cxmatrix.cpp b/opencv/src/cxcore/cxmatrix.cpp
index e0e95355fc409eb393ea2996915107513f5a6b83..3e594281c2725bd8aa0d98bfa6a11cd821bfff26 100644 (file)
--- a/opencv/src/cxcore/cxmatrix.cpp
+++ b/opencv/src/cxcore/cxmatrix.cpp
@@ -1784,7 +1784,7 @@ cvProjectPCA( const CvArr* data_arr, const CvArr* avg_arr,
     if( CV_MAT_CN(data->type) != 1 || CV_MAT_CN(avg->type) != 1 )
         CV_ERROR( CV_StsUnsupportedFormat, "All the input and output arrays must be 1-channel" );
 
-    if( CV_MAT_TYPE(avg->type) != CV_32FC1 && CV_MAT_TYPE(avg->type) != CV_64FC1 ||
+    if( (CV_MAT_TYPE(avg->type) != CV_32FC1 && CV_MAT_TYPE(avg->type) != CV_64FC1) ||
         !CV_ARE_TYPES_EQ(avg, evects) || !CV_ARE_TYPES_EQ(avg, result) )
         CV_ERROR( CV_StsUnsupportedFormat,
         "All the input and output arrays (except for data) must have the same type, 32fC1 or 64fC1" );
@@ -1917,7 +1917,7 @@ cvBackProjectPCA( const CvArr* proj_arr, const CvArr* avg_arr,
     if( !CV_IS_MAT(result) )
         CV_CALL( result = cvGetMat( result, &rstub ));
 
-    if( CV_MAT_TYPE(avg->type) != CV_32FC1 && CV_MAT_TYPE(avg->type) != CV_64FC1 ||
+    if( (CV_MAT_TYPE(avg->type) != CV_32FC1 && CV_MAT_TYPE(avg->type) != CV_64FC1) ||
         !CV_ARE_TYPES_EQ(avg, data) || !CV_ARE_TYPES_EQ(avg, evects) || !CV_ARE_TYPES_EQ(avg, result) )
         CV_ERROR( CV_StsUnsupportedFormat,
         "All the input and output arrays must have the same type, 32fC1 or 64fC1" );

diff --git a/opencv/src/cxcore/cxpersistence.cpp b/opencv/src/cxcore/cxpersistence.cpp
index ac2c7b593aa9eea1816daebc0c745e2431ec30dd..75efa94e0cdf65dca35fb8a1d1c6bc5b1a0bd7a5 100644 (file)
--- a/opencv/src/cxcore/cxpersistence.cpp
+++ b/opencv/src/cxcore/cxpersistence.cpp
@@ -998,8 +998,8 @@ icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
     }
 
     if( isdigit(c) ||
-        (c == '-' || c == '+') && (isdigit(d) || d == '.') ||
-        c == '.' && isalnum(d)) // a number
+        ((c == '-' || c == '+') && (isdigit(d) || d == '.')) ||
+        (c == '.' && isalnum(d))) // a number
     {
         double fval;
         int ival;
@@ -1072,7 +1072,7 @@ force_int:
                         buf[len++] = '\r';
                     else if( d == 't' )
                         buf[len++] = '\t';
-                    else if( d == 'x' || isdigit(d) && d < '8' )
+                    else if( d == 'x' || (isdigit(d) && d < '8') )
                     {
                         int val, is_hex = d == 'x';
                         c = ptr[3];
@@ -1166,7 +1166,7 @@ force_string:
 
             do c = *++endptr;
             while( cv_isprint(c) &&
-                   (!is_parent_flow || c != ',' && c != '}' && c != ']') &&
+                   (!is_parent_flow || (c != ',' && c != '}' && c != ']')) &&
                    (is_parent_flow || c != ':' || value_type == CV_NODE_STRING));
 
             if( endptr == ptr )
@@ -1581,7 +1581,7 @@ icvYMLWriteString( CvFileStorage* fs, const char* key,
     if( len > CV_FS_MAX_LEN )
         CV_ERROR( CV_StsBadArg, "The written string is too long" );
 
-    if( quote || len == 0 || str[0] != str[len-1] || str[0] != '\"' && str[0] != '\'' )
+    if( quote || len == 0 || str[0] != str[len-1] || (str[0] != '\"' && str[0] != '\'') )
     {
         int need_quote = quote || len == 0;
         data = buf;
@@ -1798,7 +1798,7 @@ icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
         char c = *ptr, d;
         char* endptr;
 
-        if( isspace(c) || c == '\0' || c == '<' && ptr[1] == '!' && ptr[2] == '-' )
+        if( isspace(c) || c == '\0' || (c == '<' && ptr[1] == '!' && ptr[2] == '-') )
         {
             CV_CALL( ptr = icvXMLSkipSpaces( fs, ptr, 0 ));
             have_space = 1;
@@ -1886,8 +1886,8 @@ icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
             }
 
             if( value_type != CV_NODE_STRING &&
-                (isdigit(c) || (c == '-' || c == '+') &&
-                (isdigit(d) || d == '.') || c == '.' && isalnum(d)) ) // a number
+                (isdigit(c) || ((c == '-' || c == '+') &&
+                (isdigit(d) || d == '.')) || (c == '.' && isalnum(d))) ) // a number
             {
                 double fval;
                 int ival;
@@ -2000,8 +2000,8 @@ icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node,
     }
 
     if( (CV_NODE_TYPE(node->tag) == CV_NODE_NONE ||
-        CV_NODE_TYPE(node->tag) != value_type &&
-        !CV_NODE_IS_COLLECTION(node->tag)) &&
+        (CV_NODE_TYPE(node->tag) != value_type &&
+        !CV_NODE_IS_COLLECTION(node->tag))) &&
         CV_NODE_IS_COLLECTION(value_type) )
     {
         CV_CALL( icvFSCreateCollection( fs, CV_NODE_IS_MAP(value_type) ?
@@ -4240,11 +4240,11 @@ icvWriteSeqTree( CvFileStorage* fs, const char* name,
 
     const CvSeq* seq = (CvSeq*)struct_ptr;
     const char* recursive_value = cvAttrValue( &attr, "recursive" );
-    int is_recursive = !(!recursive_value || strcmp(recursive_value,"0") == 0 ||
-                       strlen(recursive_value) == 5 &&
-                       (strcmp(recursive_value,"false") == 0 ||
-                       strcmp(recursive_value,"False") == 0 ||
-                       strcmp(recursive_value,"FALSE") == 0 ));
+    int is_recursive = recursive_value &&
+                       strcmp(recursive_value,"0") != 0 &&
+                       strcmp(recursive_value,"false") != 0 &&
+                       strcmp(recursive_value,"False") != 0 &&
+                       strcmp(recursive_value,"FALSE") != 0;
 
     assert( CV_IS_SEQ( seq ));
 
@@ -4706,7 +4706,7 @@ icvReadGraph( CvFileStorage* fs, CvFileNode* node )
         for( i = 0; i < fmt_pair_count; i += 2 )
             edge_items_per_elem += fmt_pairs[i];
 
-        if( edge_dt[2] == 'f' || edge_dt[2] == '1' && edge_dt[3] == 'f' )
+        if( edge_dt[2] == 'f' || (edge_dt[2] == '1' && edge_dt[3] == 'f') )
             dst_edge_dt = edge_dt + 3 + isdigit(edge_dt[2]);
         else
         {

diff --git a/opencv/src/cxcore/cxsumpixels.cpp b/opencv/src/cxcore/cxsumpixels.cpp
index 50fe95ed973a9c2dc077f79fa6d9576f87f75646..a44517a649a46cb884413228c466d618239cba22 100644 (file)
--- a/opencv/src/cxcore/cxsumpixels.cpp
+++ b/opencv/src/cxcore/cxsumpixels.cpp
@@ -910,8 +910,8 @@ cvReduce( const CvArr* srcarr, CvArr* dstarr, int dim, int op )
     if( dim > 1 )
         CV_ERROR( CV_StsOutOfRange, "The reduced dimensionality index is out of range" );
 
-    if( dim == 0 && (dst->cols != src->cols || dst->rows != 1) ||
-        dim == 1 && (dst->rows != src->rows || dst->cols != 1) )
+    if( (dim == 0 && (dst->cols != src->cols || dst->rows != 1)) ||
+        (dim == 1 && (dst->rows != src->rows || dst->cols != 1)) )
         CV_ERROR( CV_StsBadSize, "The output array size is incorrect" );
 
     if( op == CV_REDUCE_AVG )

diff --git a/opencv/src/cxcore/cxutils.cpp b/opencv/src/cxcore/cxutils.cpp
index f989cf57789bcecba09211479ec0de5828c31a4f..fa4d166cec1ef7d722f16c47081a3ed9d63e6df7 100644 (file)
--- a/opencv/src/cxcore/cxutils.cpp
+++ b/opencv/src/cxcore/cxutils.cpp
@@ -75,7 +75,7 @@ cvKMeans2( const CvArr* samples_arr, int cluster_count,
         CV_ERROR( CV_StsUnsupportedFormat,
         "samples should be floating-point matrix, cluster_idx - integer vector" );
 
-    if( labels->rows != 1 && (labels->cols != 1 || !CV_IS_MAT_CONT(labels->type)) ||
+    if( (labels->rows != 1 && (labels->cols != 1 || !CV_IS_MAT_CONT(labels->type))) ||
         labels->rows + labels->cols - 1 != samples->rows )
         CV_ERROR( CV_StsUnmatchedSizes,
         "cluster_idx should be 1D vector of the same number of elements as samples' number of rows" );
@@ -274,25 +274,25 @@ cvSolveCubic( const CvMat* coeffs, CvMat* roots )
     double a0 = 1., a1, a2, a3;
     double x0 = 0., x1 = 0., x2 = 0.;
     int step = 1, coeff_count;
-    
+
     if( !CV_IS_MAT(coeffs) )
         CV_ERROR( !coeffs ? CV_StsNullPtr : CV_StsBadArg, "Input parameter is not a valid matrix" );
 
     if( !CV_IS_MAT(roots) )
         CV_ERROR( !roots ? CV_StsNullPtr : CV_StsBadArg, "Output parameter is not a valid matrix" );
 
-    if( CV_MAT_TYPE(coeffs->type) != CV_32FC1 && CV_MAT_TYPE(coeffs->type) != CV_64FC1 ||
-        CV_MAT_TYPE(roots->type) != CV_32FC1 && CV_MAT_TYPE(roots->type) != CV_64FC1 )
+    if( (CV_MAT_TYPE(coeffs->type) != CV_32FC1 && CV_MAT_TYPE(coeffs->type) != CV_64FC1) ||
+        (CV_MAT_TYPE(roots->type) != CV_32FC1 && CV_MAT_TYPE(roots->type) != CV_64FC1) )
         CV_ERROR( CV_StsUnsupportedFormat,
         "Both matrices should be floating-point (single or double precision)" );
 
     coeff_count = coeffs->rows + coeffs->cols - 1;
 
-    if( coeffs->rows != 1 && coeffs->cols != 1 || coeff_count != 3 && coeff_count != 4 )
+    if( (coeffs->rows != 1 && coeffs->cols != 1) || (coeff_count != 3 && coeff_count != 4) )
         CV_ERROR( CV_StsBadSize,
         "The matrix of coefficients must be 1-dimensional vector of 3 or 4 elements" );
 
-    if( roots->rows != 1 && roots->cols != 1 ||
+    if( (roots->rows != 1 && roots->cols != 1) ||
         roots->rows + roots->cols - 1 != 3 )
         CV_ERROR( CV_StsBadSize,
         "The matrix of roots must be 1-dimensional vector of 3 elements" );
@@ -1159,7 +1159,7 @@ cvSort( const CvArr* _src, CvArr* _dst, CvArr* _idx, int flags )
         if( flags & CV_SORT_EVERY_COLUMN )
             CV_SWAP( len, count, t );
 
-        if( (flags & CV_SORT_DESCENDING) || idx && dst && dst->data.ptr == src->data.ptr )
+        if( (flags & CV_SORT_DESCENDING) || (idx && dst && dst->data.ptr == src->data.ptr) )
             tsrc = (uchar*)cvAlloc(len*elemSize);
 
         for( i = 0; i < count; i++ )