merged all the latest changes from 2.4 to trunk

modules/core/test/test_arithm.cpp

@@ -1437,6 +1437,9 @@ protected:
                 Mat mask1;
                 Mat c, d;
                 
+                rng.fill(a, RNG::UNIFORM, 0, 100);
+                rng.fill(b, RNG::UNIFORM, 0, 100);
+                
                 // [-2,2) range means that the each generated random number
                 // will be one of -2, -1, 0, 1. Saturated to [0,255], it will become
                 // 0, 0, 0, 1 => the mask will be filled by ~25%.

modules/core/test/test_countnonzero.cpp

@@ -42,7 +42,7 @@
 
 #include "test_precomp.hpp"
 #include <time.h>
-
+#include <limits>
 using namespace cv;
 using namespace std;
 
@@ -82,7 +82,7 @@ private:
     void print_information(int right, int result);
 };
 
-CV_CountNonZeroTest::CV_CountNonZeroTest(): eps_32(1e-8f), eps_64(1e-16f), src(Mat()), current_type(-1) {}
+CV_CountNonZeroTest::CV_CountNonZeroTest(): eps_32(std::numeric_limits<float>::min()), eps_64(std::numeric_limits<double>::min()), src(Mat()), current_type(-1) {}
 CV_CountNonZeroTest::~CV_CountNonZeroTest() {}
 
 void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type)
@@ -252,4 +252,4 @@ void CV_CountNonZeroTest::run(int)
     }
 }
 
-// TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); }
+TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); }

modules/core/test/test_eigen.cpp

@@ -146,7 +146,6 @@ void Core_EigenTest_Scalar_32::run(int)
         float value = cv::randu<float>();
         cv::Mat src(1, 1, CV_32FC1, Scalar::all((float)value));
         test_values(src);
-        src.~Mat();
     }
 }
 
@@ -158,7 +157,6 @@ void Core_EigenTest_Scalar_64::run(int)
         float value = cv::randu<float>();
         cv::Mat src(1, 1, CV_64FC1, Scalar::all((double)value));
         test_values(src);
-        src.~Mat();
     }
 }
 
@@ -401,8 +399,6 @@ bool Core_EigenTest::check_full(int type)
         else	src.at<double>(k, j) = src.at<double>(j, k) = cv::randu<double>();
 
         if (!test_values(src)) return false;
-
-        src.~Mat();
     }
 
     return true;

modules/core/test/test_io.cpp

@@ -377,6 +377,53 @@ protected:
 
 TEST(Core_InputOutput, write_read_consistency) { Core_IOTest test; test.safe_run(); }
 
+
+class CV_MiscIOTest : public cvtest::BaseTest
+{
+public:
+    CV_MiscIOTest() {}
+    ~CV_MiscIOTest() {}   
+protected:
+    void run(int)
+    {
+        try
+        {
+            FileStorage fs("test.xml", FileStorage::WRITE);
+            vector<int> mi, mi2, mi3, mi4;
+            vector<Mat> mv, mv2, mv3, mv4;
+            Mat m(10, 9, CV_32F);
+            Mat empty;
+            randu(m, 0, 1);
+            mi3.push_back(5);
+            mv3.push_back(m);
+            fs << "mi" << mi;
+            fs << "mv" << mv;
+            fs << "mi3" << mi3;
+            fs << "mv3" << mv3;
+            fs << "empty" << empty;
+            fs.release();
+            fs.open("test.xml", FileStorage::READ);
+            fs["mi"] >> mi2;
+            fs["mv"] >> mv2;
+            fs["mi3"] >> mi4;
+            fs["mv3"] >> mv4;
+            fs["empty"] >> empty;
+            CV_Assert( mi2.empty() );
+            CV_Assert( mv2.empty() );
+            CV_Assert( norm(mi3, mi4, CV_C) == 0 );
+            CV_Assert( mv4.size() == 1 );
+            double n = norm(mv3[0], mv4[0], CV_C);
+            CV_Assert( n == 0 );
+        }
+        catch(...)
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        }
+    }
+};
+
+TEST(Core_InputOutput, misc) { CV_MiscIOTest test; test.safe_run(); }
+
 /*class CV_BigMatrixIOTest : public cvtest::BaseTest
 {
 public:

modules/core/test/test_mat.cpp

@@ -10,7 +10,7 @@ public:
     Core_ReduceTest() {};
 protected:
     void run( int);
-    int checkOp( const Mat& src, int dstType, int opType, const Mat& opRes, int dim, double eps );
+    int checkOp( const Mat& src, int dstType, int opType, const Mat& opRes, int dim );
     int checkCase( int srcType, int dstType, int dim, Size sz );
     int checkDim( int dim, Size sz );
     int checkSize( Size sz );
@@ -80,7 +80,7 @@ void getMatTypeStr( int type, string& str)
     type == CV_64FC1 ? "CV_64FC1" : "unsupported matrix type";
 }
 
-int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat& opRes, int dim, double eps )
+int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat& opRes, int dim )
 {
     int srcType = src.type();
     bool support = false;
@@ -117,12 +117,30 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
     }
     if( !support )
         return cvtest::TS::OK;
+
+    double eps = 0.0;
+    if ( opType == CV_REDUCE_SUM || opType == CV_REDUCE_AVG )
+    {
+        if ( dstType == CV_32F )
+            eps = 1.e-5;
+        else if( dstType == CV_64F )
+            eps = 1.e-8;
+        else if ( dstType == CV_32S )
+            eps = 0.6;
+    }
     
     assert( opRes.type() == CV_64FC1 );
-    Mat _dst, dst;
+    Mat _dst, dst, diff;
     reduce( src, _dst, dim, opType, dstType );
     _dst.convertTo( dst, CV_64FC1 );
-    if( norm( opRes, dst, NORM_INF ) > eps )
+
+    absdiff( opRes,dst,diff );
+    bool check = false;
+    if (dstType == CV_32F || dstType == CV_64F)
+        check = countNonZero(diff>eps*dst) > 0;
+    else
+        check = countNonZero(diff>eps) > 0;
+    if( check )
     {
         char msg[100];
         const char* opTypeStr = opType == CV_REDUCE_SUM ? "CV_REDUCE_SUM" :
@@ -168,21 +186,19 @@ int Core_ReduceTest::checkCase( int srcType, int dstType, int dim, Size sz )
         assert( 0 );
     
     // 1. sum
-    tempCode = checkOp( src, dstType, CV_REDUCE_SUM, sum, dim, 
-                       srcType == CV_32FC1 && dstType == CV_32FC1 ? 0.05 : FLT_EPSILON );
+    tempCode = checkOp( src, dstType, CV_REDUCE_SUM, sum, dim );
     code = tempCode != cvtest::TS::OK ? tempCode : code;
     
     // 2. avg
-    tempCode = checkOp( src, dstType, CV_REDUCE_AVG, avg, dim, 
-                       dstType == CV_32SC1 ? 0.6 : 0.00007 );
+    tempCode = checkOp( src, dstType, CV_REDUCE_AVG, avg, dim );
     code = tempCode != cvtest::TS::OK ? tempCode : code;
     
     // 3. max
-    tempCode = checkOp( src, dstType, CV_REDUCE_MAX, max, dim, FLT_EPSILON );
+    tempCode = checkOp( src, dstType, CV_REDUCE_MAX, max, dim );
     code = tempCode != cvtest::TS::OK ? tempCode : code;
     
     // 4. min
-    tempCode = checkOp( src, dstType, CV_REDUCE_MIN, min, dim, FLT_EPSILON );
+    tempCode = checkOp( src, dstType, CV_REDUCE_MIN, min, dim );
     code = tempCode != cvtest::TS::OK ? tempCode : code;
     
     return code;

modules/core/test/test_math.cpp

@@ -2347,6 +2347,41 @@ void Core_SolvePolyTest::run( int )
     }
 }
 
+class Core_CheckRange_Empty : public cvtest::BaseTest
+{
+public:
+    Core_CheckRange_Empty(){}
+    ~Core_CheckRange_Empty(){}
+protected:
+    virtual void run( int start_from );
+};
+
+void Core_CheckRange_Empty::run( int )
+{
+    cv::Mat m;
+    ASSERT_TRUE( cv::checkRange(m) );
+}
+
+TEST(Core_CheckRange_Empty, accuracy) { Core_CheckRange_Empty test; test.safe_run(); }
+
+class Core_CheckRange_INT_MAX : public cvtest::BaseTest
+{
+public:
+    Core_CheckRange_INT_MAX(){}
+    ~Core_CheckRange_INT_MAX(){}
+protected:
+    virtual void run( int start_from );
+};
+
+void Core_CheckRange_INT_MAX::run( int )
+{
+    cv::Mat m(3, 3, CV_32SC1, cv::Scalar(INT_MAX));
+    ASSERT_FALSE( cv::checkRange(m, true, 0, 0, INT_MAX) );
+    ASSERT_TRUE( cv::checkRange(m) );
+}
+
+TEST(Core_CheckRange_INT_MAX, accuracy) { Core_CheckRange_INT_MAX test; test.safe_run(); }
+
 template <typename T> class Core_CheckRange : public testing::Test {};
 
 TYPED_TEST_CASE_P(Core_CheckRange);
@@ -2402,7 +2437,17 @@ TYPED_TEST_P(Core_CheckRange, Bounds)
     delete bad_pt;
 }
 
-REGISTER_TYPED_TEST_CASE_P(Core_CheckRange, Negative, Positive, Bounds);
+TYPED_TEST_P(Core_CheckRange, Zero)
+{
+    double min_bound = 0.0;
+    double max_bound = 0.1;
+
+    cv::Mat src = cv::Mat::zeros(3,3, cv::DataDepth<TypeParam>::value);
+
+    ASSERT_TRUE( checkRange(src, true, NULL, min_bound, max_bound) );
+}
+
+REGISTER_TYPED_TEST_CASE_P(Core_CheckRange, Negative, Positive, Bounds, Zero);
 
 typedef ::testing::Types<signed char,unsigned char, signed short, unsigned short, signed int> mat_data_types;
 INSTANTIATE_TYPED_TEST_CASE_P(Negative_Test, Core_CheckRange, mat_data_types);
@@ -2428,5 +2473,129 @@ TEST(Core_SolvePoly, accuracy) { Core_SolvePolyTest test; test.safe_run(); }
 
 // TODO: eigenvv, invsqrt, cbrt, fastarctan, (round, floor, ceil(?)),
 
+
+class CV_KMeansSingularTest : public cvtest::BaseTest
+{
+public:
+    CV_KMeansSingularTest() {}
+    ~CV_KMeansSingularTest() {}   
+protected:
+    void run(int)
+    {
+        int i, iter = 0, N = 0, N0 = 0, K = 0, dims = 0;
+        Mat labels;
+        try
+        {
+            RNG& rng = theRNG();
+            const int MAX_DIM=5;
+            int MAX_POINTS = 100, maxIter = 100;
+            for( iter = 0; iter < maxIter; iter++ )
+            {
+                ts->update_context(this, iter, true);
+                dims = rng.uniform(1, MAX_DIM+1);
+                N = rng.uniform(1, MAX_POINTS+1);
+                N0 = rng.uniform(1, MAX(N/10, 2));
+                K = rng.uniform(1, N+1);
+                
+                Mat data0(N0, dims, CV_32F);
+                rng.fill(data0, RNG::UNIFORM, -1, 1);
+                
+                Mat data(N, dims, CV_32F);
+                for( i = 0; i < N; i++ )
+                    data0.row(rng.uniform(0, N0)).copyTo(data.row(i));
+                
+                kmeans(data, K, labels, TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS, 30, 0),
+                       5, KMEANS_PP_CENTERS);
+                
+                Mat hist(K, 1, CV_32S, Scalar(0));
+                for( i = 0; i < N; i++ )
+                {
+                    int l = labels.at<int>(i);
+                    CV_Assert(0 <= l && l < K);
+                    hist.at<int>(l)++;
+                }
+                for( i = 0; i < K; i++ )
+                    CV_Assert( hist.at<int>(i) != 0 );
+            }
+        }
+        catch(...)
+        {
+            ts->printf(cvtest::TS::LOG,
+                       "context: iteration=%d, N=%d, N0=%d, K=%d\n",
+                       iter, N, N0, K);
+            std::cout << labels << std::endl;
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        }
+    }
+};
+
+TEST(Core_KMeans, singular) { CV_KMeansSingularTest test; test.safe_run(); }
+
+TEST(CovariationMatrixVectorOfMat, accuracy)
+{
+    unsigned int col_problem_size = 8, row_problem_size = 8, vector_size = 16;
+    cv::Mat src(vector_size, col_problem_size * row_problem_size, CV_32F);
+    int singleMatFlags = CV_COVAR_ROWS;
+
+    cv::Mat gold;
+    cv::Mat goldMean;
+    cv::randu(src,cv::Scalar(-128), cv::Scalar(128));
+    cv::calcCovarMatrix(src,gold,goldMean,singleMatFlags,CV_32F);
+    std::vector<cv::Mat> srcVec;
+    for(size_t i = 0; i < vector_size; i++)
+    {
+        srcVec.push_back(src.row(static_cast<int>(i)).reshape(0,col_problem_size));
+    }
+
+    cv::Mat actual;
+    cv::Mat actualMean;
+    cv::calcCovarMatrix(srcVec, actual, actualMean,singleMatFlags,CV_32F);
+
+    cv::Mat diff;
+    cv::absdiff(gold, actual, diff);
+    cv::Scalar s = cv::sum(diff);
+    ASSERT_EQ(s.dot(s), 0.0);
+
+    cv::Mat meanDiff;
+    cv::absdiff(goldMean, actualMean.reshape(0,1), meanDiff);
+    cv::Scalar sDiff = cv::sum(meanDiff);
+    ASSERT_EQ(sDiff.dot(sDiff), 0.0);
+}
+
+TEST(CovariationMatrixVectorOfMatWithMean, accuracy)
+{
+    unsigned int col_problem_size = 8, row_problem_size = 8, vector_size = 16;
+    cv::Mat src(vector_size, col_problem_size * row_problem_size, CV_32F);
+    int singleMatFlags = CV_COVAR_ROWS | CV_COVAR_USE_AVG;
+
+    cv::Mat gold;
+    cv::randu(src,cv::Scalar(-128), cv::Scalar(128));
+    cv::Mat goldMean;
+
+    cv::reduce(src,goldMean,0 ,CV_REDUCE_AVG, CV_32F);
+
+    cv::calcCovarMatrix(src,gold,goldMean,singleMatFlags,CV_32F);
+
+    std::vector<cv::Mat> srcVec;
+    for(size_t i = 0; i < vector_size; i++)
+    {
+        srcVec.push_back(src.row(static_cast<int>(i)).reshape(0,col_problem_size));
+    }
+
+    cv::Mat actual;
+    cv::Mat actualMean = goldMean.reshape(0, row_problem_size);
+    cv::calcCovarMatrix(srcVec, actual, actualMean,singleMatFlags,CV_32F);
+
+    cv::Mat diff;
+    cv::absdiff(gold, actual, diff);
+    cv::Scalar s = cv::sum(diff);
+    ASSERT_EQ(s.dot(s), 0.0);
+
+    cv::Mat meanDiff;
+    cv::absdiff(goldMean, actualMean.reshape(0,1), meanDiff);
+    cv::Scalar sDiff = cv::sum(meanDiff);
+    ASSERT_EQ(sDiff.dot(sDiff), 0.0);
+}
+
 /* End of file. */
 

modules/core/test/test_operations.cpp

@@ -630,7 +630,7 @@ bool CV_OperationsTest::TestTemplateMat()
 
         Mat_<uchar> matFromData(1, 4, uchar_data);
         const Mat_<uchar> mat2 = matFromData.clone();
-        CHECK_DIFF(matFromData, eye.reshape(1));
+        CHECK_DIFF(matFromData, eye.reshape(1, 1));
         if (matFromData(Point(0,0)) != uchar_data[0])throw test_excep();
         if (mat2(Point(0,0)) != uchar_data[0]) throw test_excep();
 

modules/core/test/test_rand.cpp

@@ -109,6 +109,10 @@ void Core_RandTest::run( int )
         int dist_type = cvtest::randInt(rng) % (CV_RAND_NORMAL+1);
         int i, k, SZ = N/cn;
         Scalar A, B;
+
+        double eps = 1.e-4;
+        if (depth == CV_64F)
+            eps = 1.e-7;
         
         bool do_sphere_test = dist_type == CV_RAND_UNI;
         Mat arr[2], hist[4];
@@ -170,7 +174,7 @@ void Core_RandTest::run( int )
             }
         }
         
-        if( maxk >= 1 && norm(arr[0], arr[1], NORM_INF) != 0 )
+        if( maxk >= 1 && norm(arr[0], arr[1], NORM_INF) > eps)
         {
             ts->printf( cvtest::TS::LOG, "RNG output depends on the array lengths (some generated numbers get lost?)" );
             ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );