fixed GCC4.1 warnings

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

diff --git a/opencv/include/opencv/cvvidsurv.hpp b/opencv/include/opencv/cvvidsurv.hpp
index de18d5fa3dd7c314d3043c3384b82f46453d038e..0778e4efbf6206a81e6c48ca7cd562fa4e665f08 100644 (file)
--- a/opencv/include/opencv/cvvidsurv.hpp
+++ b/opencv/include/opencv/cvvidsurv.hpp
@@ -1042,9 +1042,10 @@ public:
 
 
 /* Trajectory Analyser module */
-class CvBlobTrackAnalysisOne
+class CV_EXPORTS CvBlobTrackAnalysisOne
 {
 public:
+    virtual ~CvBlobTrackAnalysisOne() {};
     virtual int     Process(CvBlob* pBlob, IplImage* pImg, IplImage* pFG) = 0;
     /* return 0 if trajectory is normal
        return >0 if trajectory abnormal */
@@ -1171,6 +1172,7 @@ CV_EXPORTS void cvCreateTracks_AreaErr(CvBlobTrackSeq *TS1, CvBlobTrackSeq *TS2,
 class CV_EXPORTS CvProb
 {
 public:
+    virtual ~CvProb() {};
     /* calculate probability value */ 
     virtual double Value(int* /*comp*/, int /*x*/ = 0, int /*y*/ = 0){return -1;};
     /* update histograpp Pnew = (1-W)*Pold + W*Padd*/

diff --git a/opencv/src/cv/cvconvhull.cpp b/opencv/src/cv/cvconvhull.cpp
index 57b10af3340257f6a8eed2636b3f7605a0a490c4..ddbea5c974bd19bad10cc332d38b1b0915fa09b3 100644 (file)
--- a/opencv/src/cv/cvconvhull.cpp
+++ b/opencv/src/cv/cvconvhull.cpp
@@ -494,7 +494,9 @@ finish_hull:
     else
     {
         hull.s = hullseq;
-        hull.c->rect = cvBoundingRect( ptseq, ptseq == (CvSeq*)&contour_header );
+        hull.c->rect = cvBoundingRect( ptseq,
+            ptseq->header_size < (int)sizeof(CvContour) ||
+            &ptseq->flags == &contour_header.flags );
         
         /*if( ptseq != (CvSeq*)&contour_header )
             hullseq->v_prev = ptseq;*/

diff --git a/opencv/src/cv/cvthresh.cpp b/opencv/src/cv/cvthresh.cpp
index 66645562fb465412f4821f6bad69160cf3483e4e..31bdc95f7e90ccc2444ed3808265dd44841eb28b 100644 (file)
--- a/opencv/src/cv/cvthresh.cpp
+++ b/opencv/src/cv/cvthresh.cpp
@@ -335,12 +335,13 @@ cvThreshold( const void* srcarr, void* dstarr, double thresh, double maxval, int
         float _ranges[] = { 0, 256 };
         float* ranges = _ranges;
         int hist_size = 256;
+        void* srcarr0 = src;
 
         if( CV_MAT_TYPE(src->type) != CV_8UC1 )
             CV_ERROR( CV_StsNotImplemented, "Otsu method can only be used with 8uC1 images" );
 
         CV_CALL( hist = cvCreateHist( 1, &hist_size, CV_HIST_ARRAY, &ranges ));
-        cvCalcArrHist( (void**)&src, hist );
+        cvCalcArrHist( &srcarr0, hist );
         thresh = cvFloor(icvGetThreshVal_Otsu( hist ));
     }
 

diff --git a/opencv/src/cvaux/camshift.cpp b/opencv/src/cvaux/camshift.cpp
index c4f843972d44d0e09289043a8486dd17b5c48999..23cff7d6162153834361a2b7add9bc03bed2b378 100644 (file)
--- a/opencv/src/cvaux/camshift.cpp
+++ b/opencv/src/cvaux/camshift.cpp
@@ -204,6 +204,12 @@ CvCamShiftTracker::track_object( const IplImage* cur_frame )
     CvRect rect;
     CvSize bp_size;
     
+    union
+    {
+        void** arr;
+        IplImage** img;
+    } u;
+    
     if( m_comp.rect.width == 0 || m_comp.rect.height == 0 ||
         m_hist == 0 )
     {
@@ -211,7 +217,8 @@ CvCamShiftTracker::track_object( const IplImage* cur_frame )
     }
     
     color_transform( cur_frame );
-    cvCalcBackProject( m_color_planes, m_back_project, m_hist );
+    u.img = m_color_planes;
+    cvCalcArrBackProject( u.arr, m_back_project, m_hist );
     cvAnd( m_back_project, m_mask, m_back_project );
 
     rect = m_comp.rect;

diff --git a/opencv/src/cvaux/cvbgfg_acmmm2003.cpp b/opencv/src/cvaux/cvbgfg_acmmm2003.cpp
index edc867f2559287cce7cab3ad3f8fc0e1cb1a10a0..99e849f8cd54b12fe4025a47d9e60cd7966e5c88 100644 (file)
--- a/opencv/src/cvaux/cvbgfg_acmmm2003.cpp
+++ b/opencv/src/cvaux/cvbgfg_acmmm2003.cpp
@@ -143,10 +143,13 @@ cvCreateFGDStatModel( IplImage* first_frame, CvFGDStatModelParams* parameters )
 
     if( cvGetErrStatus() < 0 )
     {
+        CvBGStatModel* base_ptr = (CvBGStatModel*)p_model;
+
         if( p_model && p_model->release )
-            p_model->release( (CvBGStatModel**)&p_model );
+            p_model->release( &base_ptr );
         else
             cvFree( &p_model );
+        p_model = 0;
     }
 
     return (CvBGStatModel*)p_model;

diff --git a/opencv/src/cvaux/cvbgfg_gaussmix.cpp b/opencv/src/cvaux/cvbgfg_gaussmix.cpp
index e196dbee1ef01e98be635f255f1eb30820feea4d..86ac7b9578c092b7778f8c99750ad572b1950de0 100644 (file)
--- a/opencv/src/cvaux/cvbgfg_gaussmix.cpp
+++ b/opencv/src/cvaux/cvbgfg_gaussmix.cpp
@@ -218,10 +218,13 @@ cvCreateGaussianBGModel( IplImage* first_frame, CvGaussBGStatModelParams* parame
     
     if( cvGetErrStatus() < 0 )
     {
+        CvBGStatModel* base_ptr = (CvBGStatModel*)bg_model;
+        
         if( bg_model && bg_model->release )
-            bg_model->release( (CvBGStatModel**)&bg_model );
+            bg_model->release( &base_ptr );
         else
             cvFree( &bg_model );
+        bg_model = 0;
     }
     
     return (CvBGStatModel*)bg_model;

diff --git a/opencv/src/cvaux/vs/blobtrackanalysishist.cpp b/opencv/src/cvaux/vs/blobtrackanalysishist.cpp
index 936c4dc28fa2b276a6541d420260beae81704593..7a4efa22c64ca58393ab75d2738c8803d4aba35e 100644 (file)
--- a/opencv/src/cvaux/vs/blobtrackanalysishist.cpp
+++ b/opencv/src/cvaux/vs/blobtrackanalysishist.cpp
@@ -426,7 +426,7 @@ public:
     {
         if(m_pSparse)cvReleaseSparseMat(&m_pSparse);
         if(m_pND)cvReleaseMatND(&m_pND);
-        if(m_IDXs) cvFree((void**)&m_IDXs);
+        if(m_IDXs) cvFree(&m_IDXs);
     }
 
     void Realloc(int dim, int* sizes, int type = SPARSE)
@@ -718,10 +718,10 @@ private:
 //            pF->pFVGen->Release();
             m_TrackFGList.DelBlob(i-1);
         }
-        cvFree((void**)&m_pFVi);
-        cvFree((void**)&m_pFViVar);
-        cvFree((void**)&m_pFViVarRes);
-        cvFree((void**)&m_Sizes);
+        cvFree(&m_pFVi);
+        cvFree(&m_pFViVar);
+        cvFree(&m_pFViVarRes);
+        cvFree(&m_Sizes);
     }/* FreeData */
     virtual void ParamUpdate()
     {
@@ -1255,7 +1255,7 @@ public:
             //pF->pFVGen->Release();
         }
         if(m_pStatImg)cvReleaseImage(&m_pStatImg);
-        cvFree((void**)&m_pFV);
+        cvFree(&m_pFV);
     }/* destructor */
 
     /*-----------------  interface --------------------*/

diff --git a/opencv/src/cvaux/vs/blobtrackanalysisior.cpp b/opencv/src/cvaux/vs/blobtrackanalysisior.cpp
index 1a44f8daf37e9fdb86b04ff86a07afa1a9a9d883..7dd8482823bdded01f8d7bf5b41adaf291446c5a 100644 (file)
--- a/opencv/src/cvaux/vs/blobtrackanalysisior.cpp
+++ b/opencv/src/cvaux/vs/blobtrackanalysisior.cpp
@@ -57,7 +57,7 @@ protected:
 public:
     CvBlobTrackAnalysisIOR()
     {
-        m_AnNum = NULL;
+        m_AnNum = 0;
     }
     ~CvBlobTrackAnalysisIOR()
     {

diff --git a/opencv/src/cvaux/vs/blobtrackinglist.cpp b/opencv/src/cvaux/vs/blobtrackinglist.cpp
index 290056600ce5d0ed22194be5235c03b59b3ce337..d2e370b125a15c6c26bc7cc06a7a23b9d0a1c09f 100644 (file)
--- a/opencv/src/cvaux/vs/blobtrackinglist.cpp
+++ b/opencv/src/cvaux/vs/blobtrackinglist.cpp
@@ -139,7 +139,7 @@ public:
     ~CvBGEstimPixHist()
     {
         cvReleaseImage(&bg_image);
-        cvFree((void**)&m_PixHists);
+        cvFree(&m_PixHists);
     }/* destructor */
 
 

diff --git a/opencv/src/cvaux/vs/blobtrackingmsfg.cpp b/opencv/src/cvaux/vs/blobtrackingmsfg.cpp
index 86f1b62b51862f78b6fbd186fad32aecbb68fa16..147599251fabdd3f9d5d1c6b4c46e370d94e18a2 100644 (file)
--- a/opencv/src/cvaux/vs/blobtrackingmsfg.cpp
+++ b/opencv/src/cvaux/vs/blobtrackingmsfg.cpp
@@ -777,8 +777,8 @@ public:
     }
     ~CvBlobTrackerOneMSPF()
     {
-        if(m_pParticlesResampled)cvFree((void**)&m_pParticlesResampled);
-        if(m_pParticlesPredicted)cvFree((void**)&m_pParticlesPredicted);
+        if(m_pParticlesResampled)cvFree(&m_pParticlesResampled);
+        if(m_pParticlesPredicted)cvFree(&m_pParticlesPredicted);
 #ifdef _OPENMP
         if(m_HistForParalel) delete[] m_HistForParalel;
 #endif
@@ -786,8 +786,8 @@ public:
 private:
     void Realloc()
     {
-        if(m_pParticlesResampled)cvFree((void**)&m_pParticlesResampled);
-        if(m_pParticlesPredicted)cvFree((void**)&m_pParticlesPredicted);
+        if(m_pParticlesResampled)cvFree(&m_pParticlesResampled);
+        if(m_pParticlesPredicted)cvFree(&m_pParticlesPredicted);
         m_pParticlesPredicted = (DefParticle*)cvAlloc(sizeof(DefParticle)*m_ParticleNum);
         m_pParticlesResampled = (DefParticle*)cvAlloc(sizeof(DefParticle)*m_ParticleNum);
     };/* Realloc*/

diff --git a/opencv/src/cvaux/vs/enteringblobdetectionreal.cpp b/opencv/src/cvaux/vs/enteringblobdetectionreal.cpp
index 620a2bc9379a40ddb84a3baa85feec493ae2b371..de46493201db9467ca833356420b5f370b27ae0d 100644 (file)
--- a/opencv/src/cvaux/vs/enteringblobdetectionreal.cpp
+++ b/opencv/src/cvaux/vs/enteringblobdetectionreal.cpp
@@ -59,7 +59,7 @@ public:
     CvBlobDetectorReal(CvTestSeq* pTestSeq)
     {
         m_pTestSeq = pTestSeq;
-        m_pMem = cvCreateMemStorage(NULL);
+        m_pMem = cvCreateMemStorage(0);
     }
     /* destructor of BlobDetector*/
     ~CvBlobDetectorReal()

diff --git a/opencv/src/cvaux/vs/testseq.cpp b/opencv/src/cvaux/vs/testseq.cpp
index 5b0972ded689f5f5e171cc5c3a84177aac49ae59..238eab90cdb1cb3988aec492657064b7cf841f43 100644 (file)
--- a/opencv/src/cvaux/vs/testseq.cpp
+++ b/opencv/src/cvaux/vs/testseq.cpp
@@ -296,7 +296,7 @@ static void icvTestSeqAllocTrans(CvTestSeqElem* p)
             else
                 SET_TRANS_0(pNewTrans+i);
         }
-        if(p->pTrans)cvFree((void**)&p->pTrans);
+        if(p->pTrans)cvFree(&p->pTrans);
         p->pTrans = pNewTrans;
         p->TransNum = num;
     }/* allocate new transforamtion array */
@@ -746,11 +746,11 @@ static void icvTestSeqReleaseAll(CvTestSeqElem** ppElemList)
         }
         if(p->pImg)cvReleaseImage(&p->pImg);
         if(p->pImgMask)cvReleaseImage(&p->pImgMask);
-        if(p->pPos)cvFree((void**)&p->pPos);
-        if(p->pTrans)cvFree((void**)&p->pTrans);
-        if(p->pSize)cvFree((void**)&p->pSize);
+        if(p->pPos)cvFree(&p->pPos);
+        if(p->pTrans)cvFree(&p->pTrans);
+        if(p->pSize)cvFree(&p->pSize);
         p=p->next;
-        cvFree((void**)&pd);
+        cvFree(&pd);
     }/* next element */
     ppElemList[0] = NULL;
 }/* icvTestSeqReleaseAll */

diff --git a/opencv/src/highgui/window_w32.cpp b/opencv/src/highgui/window_w32.cpp
index 45afda8e1b832d80d8842d8c1f8de84a3bab71c1..de5b14a2cc51236aa3063407a9b34456b219f3d3 100644 (file)
--- a/opencv/src/highgui/window_w32.cpp
+++ b/opencv/src/highgui/window_w32.cpp
@@ -204,7 +204,7 @@ CV_IMPL int cvInitSystem( int, char** )
         wndc.lpszClassName = "HighGUI class";
         wndc.lpszMenuName = "HighGUI class";
         wndc.hIcon = LoadIcon(0, IDI_APPLICATION);
-        wndc.hCursor = (HCURSOR)LoadCursor(0, MAKEINTRESOURCE(IDC_CROSS));
+        wndc.hCursor = (HCURSOR)LoadCursor(0, (LPSTR)(size_t)IDC_CROSS );
         wndc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
 
         RegisterClass(&wndc);
@@ -539,6 +539,11 @@ static bool icvGetBitmapData( CvWindow* window, SIZE* size, int* channels, void*
     BITMAP bmp;
     GdiFlush();
     HGDIOBJ h = GetCurrentObject( window->dc, OBJ_BITMAP );
+    if( size )
+        size->cx = size->cy = 0;
+    if( data )
+        *data = 0;
+
     if (h == NULL)
         return true;
     if (GetObject(h, sizeof(bmp), &bmp) == 0)
@@ -568,7 +573,7 @@ static void icvUpdateWindowPos( CvWindow* window )
     if( (window->flags & CV_WINDOW_AUTOSIZE) && window->image )
     {
         int i;
-        SIZE size;
+        SIZE size = {0,0};
         icvGetBitmapData( window, &size, 0, 0 );
 
         // Repeat two times because after the first resizing of the mainhWnd window
@@ -858,7 +863,7 @@ static LRESULT CALLBACK HighGUIProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM
         {
             POINT pt;
             RECT rect;
-            SIZE size;
+            SIZE size = {0,0};
 
             int flags = (wParam & MK_LBUTTON ? CV_EVENT_FLAG_LBUTTON : 0)|
                         (wParam & MK_RBUTTON ? CV_EVENT_FLAG_RBUTTON : 0)|
@@ -897,7 +902,7 @@ static LRESULT CALLBACK HighGUIProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM
         if(window->image != 0)
         {
             int nchannels = 3;
-            SIZE size;
+            SIZE size = {0,0};
             PAINTSTRUCT paint;
             HDC hdc;
             RGBQUAD table[256];

diff --git a/opencv/src/ml/ml_inner_functions.cpp b/opencv/src/ml/ml_inner_functions.cpp
index 87065185aabd80995be11710716fd7b5dad0f16c..c34007b31dd82bb61286cca3e781c8cd723e6bec 100644 (file)
--- a/opencv/src/ml/ml_inner_functions.cpp
+++ b/opencv/src/ml/ml_inner_functions.cpp
@@ -206,7 +206,7 @@ CV_IMPL void cvRandSeries( float probs[], int len, int sample[], int amount )
             }
         }
     
-    cvFree((void**)&knots);
+    cvFree(&knots);
 }
 
 /* Generates <sample> from gaussian mixture distribution */
@@ -255,8 +255,8 @@ CV_IMPL void cvRandGaussMixture( CvMat* means[],
         cvReleaseMat(&classes);
     for( i = 0; i < clsnum; i++ )
         cvReleaseMat(&utmats[i]);
-    cvFree((void**)&utmats);
-    cvFree((void**)&sample_clsnum);
+    cvFree(&utmats);
+    cvFree(&sample_clsnum);
     cvReleaseMat(&vect);    
 }
 
@@ -678,7 +678,7 @@ cvPreprocessOrderedResponses( const CvMat* responses, const CvMat* sample_idx, i
     dst = out_responses->data.fl;
     if( r_type == CV_32FC1 )
     {
-        const float* src = src = responses->data.fl;
+        const float* src = responses->data.fl;
         for( i = 0; i < sample_count; i++ )
         {
             int idx = map ? map[i] : i;
@@ -688,7 +688,7 @@ cvPreprocessOrderedResponses( const CvMat* responses, const CvMat* sample_idx, i
     }
     else
     {
-        const int* src = src = responses->data.i;
+        const int* src = responses->data.i;
         for( i = 0; i < sample_count; i++ )
         {
             int idx = map ? map[i] : i;
@@ -1837,8 +1837,8 @@ void cvCombineResponseMaps (CvMat*  _responses,
 
         __END__
 
-    cvFree ((void**)&old_data);
-    cvFree ((void**)&new_data);
+    cvFree(&old_data);
+    cvFree(&new_data);
 
 }
 

diff --git a/opencv/src/ml/mlestimate.cpp b/opencv/src/ml/mlestimate.cpp
index ebbbd506fc19592e46c1d0f184b37bd4f524bf2c..1d03a447861e9fe7efda6dd09209589631aa3b8e 100644 (file)
--- a/opencv/src/ml/mlestimate.cpp
+++ b/opencv/src/ml/mlestimate.cpp
@@ -384,13 +384,13 @@ void cvReleaseCrossValidationModel (CvStatModel** model)
         CV_ERROR (CV_StsBadArg, "");
     }
 
-    cvFree ((void**)&pModel->sampleIdxAll);
-    cvFree ((void**)&pModel->folds);
+    cvFree (&pModel->sampleIdxAll);
+    cvFree (&pModel->folds);
     cvReleaseMat (&pModel->sampleIdxEval);
     cvReleaseMat (&pModel->sampleIdxTrain);
     cvReleaseMat (&pModel->predict_results);
 
-    cvFree ((void**)model);
+    cvFree (model);
 
         __END__
 } // End of cvReleaseCrossValidationModel.

diff --git a/opencv/src/ml/mlrtrees.cpp b/opencv/src/ml/mlrtrees.cpp
index c89163019ae1b444708b908e4aeb0cff09495a09..afb00657a06ceeadbaccc58fe63ce9f053f2683c 100644 (file)
--- a/opencv/src/ml/mlrtrees.cpp
+++ b/opencv/src/ml/mlrtrees.cpp
@@ -218,7 +218,7 @@ void CvRTrees::clear()
     {
         trees[0]->share_data( false );
         delete trees[0];
-        cvFree( (void**) &trees );
+        cvFree( &trees );
     }
 
     cvReleaseMat( &active_var_mask );

diff --git a/opencv/src/ml/mlsvm.cpp b/opencv/src/ml/mlsvm.cpp
index 8ab1cc38ea1dacd70ef3ad1c51219d4d86696b18..efafd0d22adcb3f8d635af28b82013a76cb6396c 100644 (file)
--- a/opencv/src/ml/mlsvm.cpp
+++ b/opencv/src/ml/mlsvm.cpp
@@ -1218,7 +1218,7 @@ bool CvSVM::train1( int sample_count, int var_count, const float** samples,
 {
     bool ok = false;
     
-    CV_FUNCNAME( "CvSVM::train1" );
+    //CV_FUNCNAME( "CvSVM::train1" );
 
     __BEGIN__;
 
@@ -1486,7 +1486,7 @@ bool CvSVM::train( const CvMat* _train_data, const CvMat* _responses,
     solver = 0;
     cvReleaseMemStorage( &temp_storage );
     cvReleaseMat( &responses );
-    cvFree( (void**)&samples );
+    cvFree( &samples );
 
     if( cvGetErrStatus() < 0 || !ok )
         clear();
@@ -1592,7 +1592,7 @@ float CvSVM::predict( const CvMat* sample ) const
 
 void CvSVM::write_params( CvFileStorage* fs )
 {
-    CV_FUNCNAME( "CvSVM::write_params" );
+    //CV_FUNCNAME( "CvSVM::write_params" );
 
     __BEGIN__;
     

diff --git a/opencv/src/ml/mltree.cpp b/opencv/src/ml/mltree.cpp
index a1fd3e2bc0ac4629b6395baefe81d2d0d725974b..8c0bbace97dbe43f0c89f6cf6b89679ed76ec902 100644 (file)
--- a/opencv/src/ml/mltree.cpp
+++ b/opencv/src/ml/mltree.cpp
@@ -236,7 +236,7 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
     // allocate root node and the buffer for the whole training data
     max_split_size = cvAlign(sizeof(CvDTreeSplit) +
         (MAX(0,sample_count - 33)/32)*sizeof(int),sizeof(void*));
-    tree_block_size = MAX(sizeof(CvDTreeNode)*8, max_split_size);
+    tree_block_size = MAX((int)sizeof(CvDTreeNode)*8, max_split_size);
     tree_block_size = MAX(tree_block_size + block_size_delta, min_block_size);
     CV_CALL( tree_storage = cvCreateMemStorage( tree_block_size ));
     CV_CALL( node_heap = cvCreateSet( 0, sizeof(*node_heap), sizeof(CvDTreeNode), tree_storage ));
@@ -2970,7 +2970,8 @@ void CvDTree::read_train_data_params( CvFileStorage* fs, CvFileNode* node )
 
     data = new CvDTreeTrainData;
 
-    data->is_classifier = is_classifier = cvReadIntByName( fs, node, "is_classifier" ) != 0;
+    is_classifier = (cvReadIntByName( fs, node, "is_classifier" ) != 0);
+    data->is_classifier = is_classifier;
     data->var_all = cvReadIntByName( fs, node, "var_all" );
     data->var_count = cvReadIntByName( fs, node, "var_count", data->var_all );
     data->cat_var_count = cvReadIntByName( fs, node, "cat_var_count" );
@@ -3088,7 +3089,7 @@ void CvDTree::read_train_data_params( CvFileStorage* fs, CvFileNode* node )
     max_split_size = cvAlign(sizeof(CvDTreeSplit) +
         (MAX(0,data->max_c_count - 33)/32)*sizeof(int),sizeof(void*));
 
-    tree_block_size = MAX(sizeof(CvDTreeNode)*8, max_split_size);
+    tree_block_size = MAX((int)sizeof(CvDTreeNode)*8, max_split_size);
     tree_block_size = MAX(tree_block_size + block_size_delta, min_block_size);
     CV_CALL( data->tree_storage = cvCreateMemStorage( tree_block_size ));
     CV_CALL( data->node_heap = cvCreateSet( 0, sizeof(data->node_heap[0]),

diff --git a/opencv/tests/cv/src/acanny.cpp b/opencv/tests/cv/src/acanny.cpp
index 1b3689fa76265442eb1faf44d7ec18e741cc3c91..6b32448ae87809ce150415159bb14584ce674ce1 100644 (file)
--- a/opencv/tests/cv/src/acanny.cpp
+++ b/opencv/tests/cv/src/acanny.cpp
@@ -45,7 +45,6 @@
 
 /* Testing parameters */
 static char test_desc[] = "Canny Edge Detector";
-static char TestClass[] = "Algorithm";
 static int lImageWidth;
 static int lImageHeight;
 static int  Sobord;

diff --git a/opencv/tests/cv/src/acondens.cpp b/opencv/tests/cv/src/acondens.cpp
index a63f14f8d05ec6105d50e62edd10d573c5382430..561c44806e2298d16d8d95bb9c994284d0aa4f7f 100644 (file)
--- a/opencv/tests/cv/src/acondens.cpp
+++ b/opencv/tests/cv/src/acondens.cpp
@@ -49,7 +49,6 @@ static int  Steps;
 static int  SamplesNum; 
 
 static int  read_param = 0;
-static int  data_types = 0;
 static double EPSILON = 1.000;
 
 static void CondProbDens(CvConDensation* CD,  float* Measurement)

diff --git a/opencv/tests/cv/src/aeigenobjects.cpp b/opencv/tests/cv/src/aeigenobjects.cpp
index f025d2db5fc4768af75ef11c4d0fcf8176559cb0..8b391fbe4ce829bdfdb3952d07bbeda4c1262ff8 100644 (file)
--- a/opencv/tests/cv/src/aeigenobjects.cpp
+++ b/opencv/tests/cv/src/aeigenobjects.cpp
@@ -737,18 +737,18 @@ trsWrite(TW_RUN|TW_CON, "\n ROI   supported\n" );
         }
     }
 
-    cvFree( (void**)&objs     );
-    cvFree( (void**)&eigObjs  );
-    cvFree( (void**)&eigObjs0 );
-    cvFree( (void**)&coeffs   );
-    cvFree( (void**)&coeffs0  );
-    cvFree( (void**)&eigVal   );
-    cvFree( (void**)&eigVal0  );
-    cvFree( (void**)&Objs     );
-    cvFree( (void**)&EigObjs  );
-    cvFree( (void**)&EigObjs0 );
-    cvFree( (void**)&covMatr  );
-    cvFree( (void**)&covMatr0 );
+    cvFree( &objs     );
+    cvFree( &eigObjs  );
+    cvFree( &eigObjs0 );
+    cvFree( &coeffs   );
+    cvFree( &coeffs0  );
+    cvFree( &eigVal   );
+    cvFree( &eigVal0  );
+    cvFree( &Objs     );
+    cvFree( &EigObjs  );
+    cvFree( &EigObjs0 );
+    cvFree( &covMatr  );
+    cvFree( &covMatr0 );
 
 trsWrite(TW_RUN|TW_CON, "\n Errors number: %d\n", err );
 

diff --git a/opencv/tests/cv/src/aeigenobjects.inc b/opencv/tests/cv/src/aeigenobjects.inc
index c6be197a45c0fc7c70be1b70c0775110c1032345..9f25142504d79f55da849feab5b3e0bfa3e2fd0e 100644 (file)
--- a/opencv/tests/cv/src/aeigenobjects.inc
+++ b/opencv/tests/cv/src/aeigenobjects.inc
@@ -310,14 +310,14 @@ int  _cvCalcEigenObjects_8u32fR_q( int      nObjects,
 
     r = _cvCalcCovarMatrix_8u32fR_q ( nObjects, objects, objStep,
                                      avg, 4*avgStep, size, c );
-    if(r) { cvFree((void**)&c );  return r; }
+    if(r) { cvFree( &c );  return r; }
 
 /* Calculation of eigenvalues & eigenvectors */
     ev = (float*)cvAlloc ( sizeof(float)*nObjects*nObjects );
-    if(ev==NULL) { cvFree((void**)&c );  return CV_OUTOFMEM_ERR; }
+    if(ev==NULL) { cvFree( &c );  return CV_OUTOFMEM_ERR; }
 
     _cvJacobiEigens_32f( c, ev, eigVals, nObjects, 0.0f );
-    cvFree((void**)&c );
+    cvFree( &c );
 
     for(i=0; i<*nEigObjs; i++) if( fabs(eigVals[i]/eigVals[0]) < *eps ) break;
     *nEigObjs = i;
@@ -345,7 +345,7 @@ int  _cvCalcEigenObjects_8u32fR_q( int      nObjects,
         }
     }
 
-    cvFree((void**)&ev );
+    cvFree( &ev );
     return CV_NO_ERR;
 } /* --- End of _cvCalcEigenObjects_8u32fR --- */
 /*______________________________________________________________________________________*/

diff --git a/opencv/tests/cv/src/aemd.cpp b/opencv/tests/cv/src/aemd.cpp
index 8d42cf91556dc909f1df70646d6c368e22254a87..942256e6be8b05161489860b6d6fa3c0b68549a5 100644 (file)
--- a/opencv/tests/cv/src/aemd.cpp
+++ b/opencv/tests/cv/src/aemd.cpp
@@ -76,7 +76,7 @@ static float matr_dist( const float* x, const float* y, void* param )
     return  mi->matr[i*mi->cols + j];
 }
 
-static int emd_test( void* arg )
+static int emd_test( void* )
 {
     const double success_error_level = 1e-6;
     #define M 10000
@@ -92,7 +92,6 @@ static int emd_test( void* arg )
                   w2[] = { 30, 20, 70, 30, 60 };
     matr_info mi;
     float emd;
-    arg;
 
     mi.x_origin = w1;
     mi.y_origin = w2;

diff --git a/opencv/tests/cv/src/ahistograms.cpp b/opencv/tests/cv/src/ahistograms.cpp
index a63f442acb5f00878adaaab7dc8b14c5184afda0..3972addb9e277ff1bdf374ea991edf27ab3054ea 100644 (file)
--- a/opencv/tests/cv/src/ahistograms.cpp
+++ b/opencv/tests/cv/src/ahistograms.cpp
@@ -724,8 +724,8 @@ static int foaCalcHist(void* _type)
         {
             cvReleaseImage( &src8u[i] );
             cvReleaseImage( &src32f[i] );
-            cvFree( (void**)&thresh[i] );
-            cvFree( (void**)&threshe[i] );
+            cvFree( &thresh[i] );
+            cvFree( &threshe[i] );
         }
         cvReleaseHist( &hist1 );
         cvReleaseHist( &hist2 );
@@ -736,8 +736,8 @@ static int foaCalcHist(void* _type)
     {
         cvReleaseImage( &src8u[i] );
         cvReleaseImage( &src32f[i] );
-        cvFree( (void**)&thresh[i] );
-        cvFree( (void**)&threshe[i] );
+        cvFree( &thresh[i] );
+        cvFree( &threshe[i] );
     }
     cvReleaseHist( &hist1 );
     cvReleaseHist( &hist2 );
@@ -913,8 +913,8 @@ static int foaCalcHistMask(void* _type)
         {
             cvReleaseImage( &src8u[i] );
             cvReleaseImage( &src32f[i] );
-            cvFree( (void**)&thresh[i] );
-            cvFree( (void**)&threshe[i] );
+            cvFree( &thresh[i] );
+            cvFree( &threshe[i] );
         }
         cvReleaseHist( &hist1 );
         cvReleaseHist( &hist2 );
@@ -1088,8 +1088,8 @@ static int foaBackProject(void* _type)
         {
             cvReleaseImage( &src8u[i] );
             cvReleaseImage( &src32f[i] );
-            cvFree( (void**)&thresh[i] );
-            cvFree( (void**)&threshe[i] );
+            cvFree( &thresh[i] );
+            cvFree( &threshe[i] );
         }
 
         cvReleaseImage( &dst8u );
@@ -1104,8 +1104,8 @@ test_exit:
     {
         cvReleaseImage( &src8u[i] );
         cvReleaseImage( &src32f[i] );
-        cvFree( (void**)&thresh[i] );
-        cvFree( (void**)&threshe[i] );
+        cvFree( &thresh[i] );
+        cvFree( &threshe[i] );
     }
 
     cvReleaseImage( &dst8u );
@@ -1212,14 +1212,14 @@ static int myBackProjectPatch(IplImage** src8u, IplImage** src32f,
     cvReleaseHist(&model);
     for(i = 0; i < c_dims; i++)
     {
-        cvFree((void**)&_test8u[i]);
-        cvFree((void**)&_test32f[i]);
+        cvFree( &_test8u[i]);
+        cvFree( &_test32f[i]);
         cvReleaseImageHeader( img8u + i );
         cvReleaseImageHeader( img32f + i );
     }
 
-    cvFree( (void**)&img8u );
-    cvFree( (void**)&img32f );
+    cvFree( &img8u );
+    cvFree( &img32f );
 
     return TRS_OK;
 }
@@ -1335,7 +1335,7 @@ static int foaBackProjectPatch(void* _type)
         {
             cvReleaseImage( &src8u[i] );
             cvReleaseImage( &src32f[i] );
-            cvFree( (void**)&thresh[i] );
+            cvFree( &thresh[i] );
         }
 
         cvReleaseImage( &_dst8u );
@@ -1358,10 +1358,6 @@ static int foaBayesianProb(void* _type)
     static int c_dimss;
     static int dims;
     static int init = 0;
-    static int width;
-    static int height;
-    static int range_width;
-    static int range_height;
     static double acc;
 
     int    c_dims;

diff --git a/opencv/tests/cv/src/aimage.cpp b/opencv/tests/cv/src/aimage.cpp
index feb469c6cc5834c1997b844e0f6ab835716179d1..4ca23e74c54106426df4d4f2c2dc011675bbbe9c 100644 (file)
--- a/opencv/tests/cv/src/aimage.cpp
+++ b/opencv/tests/cv/src/aimage.cpp
@@ -45,7 +45,6 @@
 
 /* Testing parameters */
 static char test_desc[] = "Image Creation & access";
-static char TestClass[] = "Algorithm";
 static char func_name[] = "cvCreateImage cvCreateImageHeader cvSetImageROI cvGetImageROI "
                           "cvSetImageCOI cvCreateImageData cvReleaseImageData "
                           "cvSetImageData cvCloneImage cvCopyImage cvInitImageHeader";
@@ -95,7 +94,7 @@ static int foaImage( void )
         {
             if( depths[i] == IPL_DEPTH_1U && channels[j] != 1 ) // skip for IPL_DEPTH_1U
                 continue;                                       // all non 1 channels
-            if( depths[i] == IPL_DEPTH_8S )
+            if( depths[i] == (int)IPL_DEPTH_8S )
                 continue;
             IplImage* image = cvCreateImageHeader( size, depths[i], channels[j] );
             if( image->width != size.width || image->height != size.height )
@@ -201,7 +200,7 @@ static int foaImage( void )
         {
             if( depths[i] == IPL_DEPTH_1U && channels[j] != 1 ) // skip for IPL_DEPTH_1U
                 continue;                                       // all non 1 channels
-            if( depths[i] == IPL_DEPTH_8S )
+            if( depths[i] == (int)IPL_DEPTH_8S )
                 continue;
             IplImage* src = cvCreateImage( size, depths[i], channels[j] );
             //IplImage* dst = cvCreateImage( size, depths[i], channels[j] );

diff --git a/opencv/tests/cv/src/akalman.cpp b/opencv/tests/cv/src/akalman.cpp
index ed5c5333d58e92ebbe645d6612d7c2d6361ae1ed..4e3bf7ee86bedd28b0164b4469207799a99d815f 100644 (file)
--- a/opencv/tests/cv/src/akalman.cpp
+++ b/opencv/tests/cv/src/akalman.cpp
@@ -48,7 +48,6 @@ static int  Dim;
 static int  Steps;
 
 static int  read_param = 0;
-static int  data_types = 0;
 static double EPSILON = 1.000;
 
 static int fcaKalman( void )

diff --git a/opencv/tests/cv/src/akmeans.cpp b/opencv/tests/cv/src/akmeans.cpp
index 90e57cce3a4d95fcc0ca0f33d892c8b89823e38e..a1f7fe7e9cbf417696fbee8bc111be369dcc4d5d 100644 (file)
--- a/opencv/tests/cv/src/akmeans.cpp
+++ b/opencv/tests/cv/src/akmeans.cpp
@@ -44,14 +44,11 @@
                        
 /* Testing parameters */
 static char test_desc[] = "KMeans clustering";
-static char TestClass[] = "Algorithm";
 static char* func_name[] = 
 {
     "cvKMeans"
 };
 
-static int data_type = 0;
-
 //based on Ara Nefian's implementation
 float distance(float* vector_1, float *vector_2, int VecSize)
 {
@@ -270,11 +267,11 @@ static int fmaKMeans(void)
     //free memory
     for( i = 0; i < lNumVect; i++ )
     {
-        cvFree( (void**)&(vectors[i]) );
+        cvFree( &(vectors[i]) );
     }
-    cvFree((void**)&vectors);
-    cvFree((void**)&output);
-    cvFree((void**)&etalon_output);      
+    cvFree(&vectors);
+    cvFree(&output);
+    cvFree(&etalon_output);      
    
    if( lErrors == 0 ) return trsResult( TRS_OK, "No errors fixed for this text" );
     else return trsResult( TRS_FAIL, "Detected %d errors", lErrors );

diff --git a/opencv/tests/cv/src/amotseg.cpp b/opencv/tests/cv/src/amotseg.cpp
index 9f91be151473a3d9d516e94e0dce9a0fb2a8701f..31829e6c9466b94a00b4c077a0acfd4644695e63 100644 (file)
--- a/opencv/tests/cv/src/amotseg.cpp
+++ b/opencv/tests/cv/src/amotseg.cpp
@@ -134,8 +134,8 @@ again:
     region->rect.width = XMax - XMin + 1;
     region->rect.height = YMax - YMin + 1;
     region->value = cvScalar(nv);
-    cvFree((void**)&CurStack);
-    cvFree((void**)&NextStack);
+    cvFree(&CurStack);
+    cvFree(&NextStack);
     return;
 }
 
@@ -144,7 +144,6 @@ static char TestName[] = "Checking MotionSegmentation";
 static char TestClass[] = "Algorithm";
 static int lImageWidth;
 static int lImageHeight;
-static int  Sobord;
 
 static int  read_param = 0;
 static int  data_types = 0;

diff --git a/opencv/tests/cv/src/aoptflowhs.cpp b/opencv/tests/cv/src/aoptflowhs.cpp
index aa0b9ff6a838b32de6b56d391d94884d913c7c5b..05c6448b3126d3cda9312484c5bd80c31006b581 100644 (file)
--- a/opencv/tests/cv/src/aoptflowhs.cpp
+++ b/opencv/tests/cv/src/aoptflowhs.cpp
@@ -48,8 +48,6 @@ static char TestClass[] = "Algorithm";
 
 static long lImageWidth;
 static long lImageHeight;
-static long  lNumIterations;
-static float flEpsilon;
 static float lambda;
 
 #define EPSILON 0.0001f
@@ -400,15 +398,15 @@ for( usePrevious = 0; usePrevious < 2; usePrevious++ )
 }
 
     /* Free memory */
-    cvFree( (void**)&VelocityX );
-    cvFree( (void**)&VelocityY );
-    cvFree( (void**)&auxVelocityX );
-    cvFree( (void**)&auxVelocityY );
+    cvFree( &VelocityX );
+    cvFree( &VelocityY );
+    cvFree( &auxVelocityX );
+    cvFree( &auxVelocityY );
 
 
-    cvFree( (void**)&DerX );
-    cvFree( (void**)&DerY );
-    cvFree( (void**)&DerT );
+    cvFree( &DerX );
+    cvFree( &DerY );
+    cvFree( &DerT );
 
     cvReleaseImage( &imgA );
     cvReleaseImage( &imgB );

diff --git a/opencv/tests/cv/src/aoptflowlk.cpp b/opencv/tests/cv/src/aoptflowlk.cpp
index 08c83726a51d8083670fe02456c7d06aa6bea984..302f225de6bca70ef6cc8d9ea44669970c3bfd10 100644 (file)
--- a/opencv/tests/cv/src/aoptflowlk.cpp
+++ b/opencv/tests/cv/src/aoptflowlk.cpp
@@ -274,12 +274,12 @@ static int fmaCalcOpticalFlowLK( void )
             }
         }
     }
-    cvFree( (void**)&VelocityX );
-    cvFree( (void**)&VelocityY );
+    cvFree( &VelocityX );
+    cvFree( &VelocityY );
     
-    cvFree( (void**)&DerivativeX );
-    cvFree( (void**)&DerivativeY );
-    cvFree( (void**)&DerivativeT );
+    cvFree( &DerivativeX );
+    cvFree( &DerivativeY );
+    cvFree( &DerivativeT );
 
     cvReleaseImage( &imgA );
     cvReleaseImage( &imgB );

diff --git a/opencv/tests/cv/src/aoptflowpyrlk.cpp b/opencv/tests/cv/src/aoptflowpyrlk.cpp
index 65e772207204933a382029b274455d6c1b1d446a..a8a059fdfeb69235453ade8872258784ec9b0272 100644 (file)
--- a/opencv/tests/cv/src/aoptflowpyrlk.cpp
+++ b/opencv/tests/cv/src/aoptflowpyrlk.cpp
@@ -192,8 +192,8 @@ static int pyrlk_test( void )
 test_exit:
 
     /* release occupied memory */
-    cvFree( (void**)&status );
-    cvFree( (void**)&v2 );
+    cvFree( &status );
+    cvFree( &v2 );
     free( u );
     free( v );
     if( imgI ) atsReleaseImage( imgI );

diff --git a/opencv/tests/cv/src/aposit.cpp b/opencv/tests/cv/src/aposit.cpp
index 413d438e35e767b1e1dfef3ea79ccb871dd53abe..c65668559d3750243b472ba278b3042555199e54 100644 (file)
--- a/opencv/tests/cv/src/aposit.cpp
+++ b/opencv/tests/cv/src/aposit.cpp
@@ -48,7 +48,6 @@ static char TestName[]  = "POSIT algorithm";
 static char TestClass[]   = "Algorithm";
 
 static float flFocalLength;
-static long lMaxIter;
 static float flEpsilon;
 
 typedef float*  Vect32f;
@@ -244,8 +243,8 @@ static int fmaPOSIT(void)
                             translation.data.fl[2] );  
     }
 
-    cvFree( (void**)&obj_points );
-    cvFree( (void**)&img_points );
+    cvFree( &obj_points );
+    cvFree( &img_points );
 
     cvmFree( &true_rotationX );
     cvmFree( &true_rotationY );

diff --git a/opencv/tests/cv/src/apyrsegmentation.cpp b/opencv/tests/cv/src/apyrsegmentation.cpp
index 0c9a4aee3622ae6c6d2a75ab69771625b050e2eb..a64dd681e896227b12429b641dcd6a208055caa1 100644 (file)
--- a/opencv/tests/cv/src/apyrsegmentation.cpp
+++ b/opencv/tests/cv/src/apyrsegmentation.cpp
@@ -54,12 +54,12 @@ static char *cFuncName[] =
 
 static int aPyrSegmentation(void* agr)
 {
-    CvPoint _cp[] ={33,33, 43,33, 43,43, 33,43}; 
-    CvPoint _cp2[] ={50,50, 70,50, 70,70, 50,70};  
+    CvPoint _cp[] ={{33,33}, {43,33}, {43,43}, {33,43}}; 
+    CvPoint _cp2[] ={{50,50}, {70,50}, {70,70}, {50,70}};  
     CvPoint* cp = _cp;
     CvPoint* cp2 = _cp2;
     CvConnectedComp *dst_comp[3];
-    CvRect rect[3] = {50,50,21,21, 0,0,128,128, 33,33,11,11};
+    CvRect rect[3] = {{50,50,21,21}, {0,0,128,128}, {33,33,11,11}};
     double a[3] = {441.0, 15822.0, 121.0};
 
 /*    ippiPoint cp3[] ={130,130, 150,130, 150,150, 130,150};  */

diff --git a/opencv/tests/cv/src/asnakes.cpp b/opencv/tests/cv/src/asnakes.cpp
index 0ab48670cc12e61bd4bbb785a980c602cab08475..f1c881e5b85d1775d90da3324f2d93a7c25135f3 100644 (file)
--- a/opencv/tests/cv/src/asnakes.cpp
+++ b/opencv/tests/cv/src/asnakes.cpp
@@ -58,9 +58,6 @@ static char test_desc[] = "Snakes regression test";
 //  Test is considered to be succesfull if resultant positions 
 //  are identical.
 */    
-static char TestClass[] = "Algorithm";
-static int lImageWidth;
-static int lImageHeight;
 static char* func_name[] = 
 {
     "cvSnakeImage"

diff --git a/opencv/tests/cxcore/src/aarithm.cpp b/opencv/tests/cxcore/src/aarithm.cpp
index bddefd46cab3f7766f189c83af7c87d9aa727bb7..bb045631642116cf8c44e96ef1f805f8adfd57c8 100644 (file)
--- a/opencv/tests/cxcore/src/aarithm.cpp
+++ b/opencv/tests/cxcore/src/aarithm.cpp
@@ -1145,7 +1145,7 @@ void CxCore_SplitMergeBaseTest::print_timing_params( int test_case_idx, char* pt
 
     // at once, delete the headers, though is not very good from structural point of view ...
     for( i = 0; i < 4; i++ )
-        cvReleaseMat( (CvMat**)&hdrs[i] );
+        cvRelease( &hdrs[i] );
 
     CxCore_MemTest::print_timing_params( test_case_idx, ptr, params_left );
 }
@@ -1202,10 +1202,8 @@ void CxCore_SplitMergeBaseTest::prepare_to_validation( int )
                 cvTsExtract( input, h, i );
             else
                 cvTsInsert( h, output, i );
-            if( are_images )
-                cvReleaseImageHeader( (IplImage**)&hdrs[i] );
-            else
-                cvReleaseMat( (CvMat**)&hdrs[i] );
+            cvSetData( hdrs[i], 0, 0 );
+            cvRelease( &hdrs[i] );
             y += sz.height;
         }
     }

diff --git a/opencv/tests/cxcore/src/adatastruct.cpp b/opencv/tests/cxcore/src/adatastruct.cpp
index 54e9087abdc5e6cbb2e38b5d009a884430bd5b59..08e5e11bf71e1887be9e2754b3614b37f6523962 100644 (file)
--- a/opencv/tests/cxcore/src/adatastruct.cpp
+++ b/opencv/tests/cxcore/src/adatastruct.cpp
@@ -72,7 +72,7 @@ static CvTsSimpleSeq*  cvTsCreateSimpleSeq( int max_count, int elem_size )
 
 static void cvTsReleaseSimpleSeq( CvTsSimpleSeq** seq )
 {
-    cvFree( (void**)seq );
+    cvFree( seq );
 }
 
 
@@ -167,7 +167,7 @@ static CvTsSimpleSet*  cvTsCreateSimpleSet( int max_count, int elem_size )
 
 static void cvTsReleaseSimpleSet( CvTsSimpleSet** set_header )
 {
-    cvFree( (void**)set_header );
+    cvFree( set_header );
 }
 
 
@@ -252,7 +252,7 @@ static void cvTsReleaseSimpleGraph( CvTsSimpleGraph** graph )
     if( *graph )
     {
         cvTsReleaseSimpleSet( &(graph[0]->vtx) );
-        cvFree( (void**)graph );
+        cvFree( graph );
     }
 }
 
@@ -428,8 +428,8 @@ bool CxCore_DynStructBaseTest::can_do_fast_forward()
 void CxCore_DynStructBaseTest::clear()
 {
     cvReleaseMemStorage( &storage );
-    cvFree( (void**)&cxcore_struct );
-    cvFree( (void**)&simple_struct );
+    cvFree( &cxcore_struct );
+    cvFree( &simple_struct );
 }
 
 

diff --git a/opencv/tests/cxcore/src/amath.cpp b/opencv/tests/cxcore/src/amath.cpp
index 4cd9ce6ffda68844e488dcac310e9bdad33ffc17..a8dd336dbfa330d68d69adfacea6876af062518e 100644 (file)
--- a/opencv/tests/cxcore/src/amath.cpp
+++ b/opencv/tests/cxcore/src/amath.cpp
@@ -2102,7 +2102,7 @@ void CxCore_CovarMatrixTest::prepare_to_validation( int )
               t_flag ^ ((flags & CV_COVAR_NORMAL) != 0) ?
               CV_GEMM_A_T : CV_GEMM_B_T );
 
-    cvFree( (void**)&hdr_data );
+    cvFree( &hdr_data );
     temp_hdrs.clear();
 }
 

diff --git a/opencv/tests/cxts/cxts.cpp b/opencv/tests/cxts/cxts.cpp
index 804aa513f93a981aa7685dc3264e76054af3dae8..9be902e5fa9f5a69cc3bd9f52e07c92daf0a2f5e 100644 (file)
--- a/opencv/tests/cxts/cxts.cpp
+++ b/opencv/tests/cxts/cxts.cpp
@@ -72,6 +72,7 @@ int CvTest::test_count = 0;
 #include <eh.h>
 #endif
 
+#ifdef _MSC_VER
 static void cv_seh_translator( unsigned int /*u*/, EXCEPTION_POINTERS* pExp )
 {
     int code = CvTS::FAIL_EXCEPTION;
@@ -105,7 +106,7 @@ static void cv_seh_translator( unsigned int /*u*/, EXCEPTION_POINTERS* pExp )
     }
     throw code;
 }
-
+#endif
 
 #define CV_TS_TRY_BLOCK_BEGIN                   \
     try {

diff --git a/opencv/tests/cxts/cxts_math.cpp b/opencv/tests/cxts/cxts_math.cpp
index d20e9d2f63240a0d591f478fad539d11f9f733f1..59199b3d3d59467ba25cf8bc08c9304bf2e83407 100644 (file)
--- a/opencv/tests/cxts/cxts_math.cpp
+++ b/opencv/tests/cxts/cxts_math.cpp
@@ -222,7 +222,7 @@ void cvTsCopy( const CvMat* a, CvMat* b, const CvMat* mask )
 
 void cvTsConvert( const CvMat* a, CvMat* b )
 {
-    int i, j, ncols = ncols = b->cols*CV_MAT_CN(b->type);
+    int i, j, ncols = b->cols*CV_MAT_CN(b->type);
     double* buf = 0;
 
     assert( CV_ARE_SIZES_EQ(a,b) && CV_ARE_CNS_EQ(a,b) );
@@ -2241,7 +2241,16 @@ void cvTsLogicS( const CvMat* a, CvScalar s, CvMat* c, int logic_op )
     int i = 0, j = 0, k;
     int cn, ncols, elem_size;
     uchar* b_data;
-    double buf[4];
+    union
+    {
+        uchar ptr[4];
+        char c[4];
+        short s[4];
+        ushort w[4];
+        int i[4];
+        float f[4];
+        double d[4];
+    } buf;
     cn = CV_MAT_CN(a->type);
     elem_size = CV_ELEM_SIZE(a->type);
     ncols = a->cols * elem_size;
@@ -2262,49 +2271,49 @@ void cvTsLogicS( const CvMat* a, CvScalar s, CvMat* c, int logic_op )
             for( k = 0; k < cn; k++ )
             {
                 int val = cvRound(s.val[k]);
-                ((uchar*)buf)[k] = CV_CAST_8U(val);
+                buf.ptr[k] = CV_CAST_8U(val);
             }
             break;
         case CV_8S:
             for( k = 0; k < cn; k++ )
             {
                 int val = cvRound(s.val[k]);
-                ((char*)buf)[k] = CV_CAST_8S(val);
+                buf.c[k] = CV_CAST_8S(val);
             }
             break;
         case CV_16U:
             for( k = 0; k < cn; k++ )
             {
                 int val = cvRound(s.val[k]);
-                ((ushort*)buf)[k] = CV_CAST_16U(val);
+                buf.w[k] = CV_CAST_16U(val);
             }
             break;
         case CV_16S:
             for( k = 0; k < cn; k++ )
             {
                 int val = cvRound(s.val[k]);
-                ((short*)buf)[k] = CV_CAST_16S(val);
+                buf.s[k] = CV_CAST_16S(val);
             }
             break;
         case CV_32S:
             for( k = 0; k < cn; k++ )
             {
                 int val = cvRound(s.val[k]);
-                ((int*)buf)[k] = CV_CAST_32S(val);
+                buf.i[k] = CV_CAST_32S(val);
             }
             break;
         case CV_32F:
             for( k = 0; k < cn; k++ )
             {
                 double val = s.val[k];
-                ((float*)buf)[k] = CV_CAST_32F(val);
+                buf.f[k] = CV_CAST_32F(val);
             }
             break;
         case CV_64F:
             for( k = 0; k < cn; k++ )
             {
                 double val = s.val[k];
-                ((double*)buf)[k] = CV_CAST_64F(val);
+                buf.d[k] = CV_CAST_64F(val);
             }
             break;
         default:
@@ -2313,7 +2322,7 @@ void cvTsLogicS( const CvMat* a, CvScalar s, CvMat* c, int logic_op )
         }
 
         for( j = 0; j < ncols; j += elem_size )
-            memcpy( b_data + j, buf, elem_size );
+            memcpy( b_data + j, buf.ptr, elem_size );
     }
 
     for( i = 0; i < a->rows; i++ )