reworked nearly all of the OpenCV tests (except for opencv_gpu tests) - they...

reworked nearly all of the OpenCV tests (except for opencv_gpu tests) - they now use the Google Test engine.

CMakeLists.txt

@@ -1275,10 +1275,10 @@ if(BUILD_EXAMPLES OR INSTALL_PYTHON_EXAMPLES)
     add_subdirectory(samples)
 endif()
 
-if(BUILD_TESTS)
-    enable_testing()
-    add_subdirectory(tests)
-endif()
+#if(BUILD_TESTS)
+#    enable_testing()
+#    add_subdirectory(tests)
+#endif()
 
 add_subdirectory(3rdparty)
 

OpenCVModule.cmake

@@ -82,13 +82,13 @@ macro(define_opencv_module name)
         DESTINATION include/opencv2/${name}
         COMPONENT main)
         
-        if(BUILD_TESTS AND NOT ANDROID AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
+    if(BUILD_TESTS AND NOT ANDROID AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
         include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
                             "${CMAKE_CURRENT_SOURCE_DIR}/test"
-                            "${CMAKE_CURRENT_BINARY_DIR}"
-                            "${CMAKE_SOURCE_DIR}/modules/gtest/include")
+                            "${CMAKE_CURRENT_BINARY_DIR}")
 
-        foreach(d ${ARGN})
+        set(test_deps opencv_${name} ${ARGN} opencv_ts opencv_highgui ${EXTRA_${the_target}_DEPS})
+        foreach(d ${test_deps})
             if(${d} MATCHES "opencv_")
                 if(${d} MATCHES "opencv_lapack")
                 else()
@@ -101,7 +101,7 @@ macro(define_opencv_module name)
         file(GLOB test_srcs "test/*.cpp")
         file(GLOB test_hdrs "test/*.h*")
 
-        set(the_target "opencv_gtest_${name}")
+        set(the_target "opencv_test_${name}")
 
         add_executable(${the_target} ${test_srcs} ${test_hdrs})
 
@@ -123,10 +123,10 @@ macro(define_opencv_module name)
             RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
             )
 
-        add_dependencies(${the_target} ${ARGN} opencv_gtest)
+        add_dependencies(${the_target} ${test_deps})
 
         # Add the required libraries for linking:
-        target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${ARGN} opencv_gtest)
+        target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${test_deps})
 
         enable_testing()
         get_target_property(LOC ${the_target} LOCATION)
@@ -138,66 +138,3 @@ macro(define_opencv_module name)
     endif()    
         
 endmacro()
-
-if(0)
-macro(define_opencv_test name)
-
-    if(BUILD_TESTS AND NOT ANDROID AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
-        include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
-                            "${CMAKE_CURRENT_SOURCE_DIR}/test"
-                            "${CMAKE_CURRENT_BINARY_DIR}"
-                            "${CMAKE_SOURCE_DIR}/modules/gtest/include")
-
-        foreach(d ${ARGN})
-            if(${d} MATCHES "opencv_")
-                if(${d} MATCHES "opencv_lapack")
-                else()
-                    string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
-                    include_directories("${d_dir}/include")
-                endif()
-            endif()
-        endforeach()
-
-        file(GLOB test_srcs "test/*.cpp")
-        file(GLOB test_hdrs "test/*.h*")
-
-        set(the_target "opencv_gtest_${name}")
-
-        add_executable(${the_target} ${test_srcs} ${test_hdrs})
-
-        if(PCHSupport_FOUND)
-            set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/test/precomp.hpp)
-            if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-                if(${CMAKE_GENERATOR} MATCHES "Visual*")
-                    set(${the_target}_pch "test/precomp.cpp")
-                endif()            
-                add_native_precompiled_header(${the_target} ${pch_header})
-            elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-                add_precompiled_header(${the_target} ${pch_header})
-            endif()
-        endif()
-
-        # Additional target properties
-        set_target_properties(${the_target} PROPERTIES
-            DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-            RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
-            )
-
-        add_dependencies(${the_target} ${ARGN} opencv_gtest)
-
-        # Add the required libraries for linking:
-        target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${ARGN} opencv_gtest)
-
-        enable_testing()
-        get_target_property(LOC ${the_target} LOCATION)
-        add_test(${the_target} "${LOC}")
-
-        if(WIN32)
-            install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)
-        endif()
-    endif()
-
-endmacro()
-endif()
-
-

modules/CMakeLists.txt

@@ -13,7 +13,7 @@ if(MSVC OR MINGW)
    endif()
 endif()
 
-add_subdirectory(gtest)
+add_subdirectory(ts)
 add_subdirectory(highgui)
 add_subdirectory(imgproc)
 add_subdirectory(legacy)

modules/calib3d/include/opencv2/calib3d/calib3d.hpp

@@ -534,6 +534,10 @@ CV_EXPORTS_W bool findChessboardCorners( const Mat& image, Size patternSize,
                                          int flags=CALIB_CB_ADAPTIVE_THRESH+
                                               CALIB_CB_NORMALIZE_IMAGE );
 
+//! finds subpixel-accurate positions of the chessboard corners                                              
+CV_EXPORTS bool find4QuadCornerSubpix(const Mat& img, std::vector<Point2f>& corners,
+                                      Size region_size);
+
 //! draws the checkerboard pattern (found or partly found) in the image
 CV_EXPORTS_W void drawChessboardCorners( Mat& image, Size patternSize,
                                          const Mat& corners,

modules/calib3d/test/test_affine3d_estimator.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+using namespace cv;
+using namespace std;
+
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <iterator>
+#include <limits>
+#include <numeric>
+
+class CV_Affine3D_EstTest : public cvtest::BaseTest
+{
+public:
+    CV_Affine3D_EstTest();
+    ~CV_Affine3D_EstTest();    
+protected:
+    void run(int);    
+
+    bool test4Points();
+    bool testNPoints();
+};
+
+CV_Affine3D_EstTest::CV_Affine3D_EstTest()
+{
+}
+CV_Affine3D_EstTest::~CV_Affine3D_EstTest() {}
+
+
+float rngIn(float from, float to) { return from + (to-from) * (float)theRNG(); }
+
+
+struct WrapAff
+{
+    const double *F;
+    WrapAff(const Mat& aff) : F(aff.ptr<double>()) {}
+    Point3f operator()(const Point3f& p)
+    {
+        return Point3d( p.x * F[0] + p.y * F[1] + p.z *  F[2] +  F[3],
+                        p.x * F[4] + p.y * F[5] + p.z *  F[6] +  F[7],
+                        p.x * F[8] + p.y * F[9] + p.z * F[10] + F[11]  );      
+    }
+};
+
+bool CV_Affine3D_EstTest::test4Points()
+{   
+    Mat aff(3, 4, CV_64F);
+    cv::randu(aff, Scalar(1), Scalar(3));
+      
+    // setting points that are no in the same line
+
+    Mat fpts(1, 4, CV_32FC3);
+    Mat tpts(1, 4, CV_32FC3);
+        
+    fpts.ptr<Point3f>()[0] = Point3f( rngIn(1,2), rngIn(1,2), rngIn(5, 6) );
+    fpts.ptr<Point3f>()[1] = Point3f( rngIn(3,4), rngIn(3,4), rngIn(5, 6) );
+    fpts.ptr<Point3f>()[2] = Point3f( rngIn(1,2), rngIn(3,4), rngIn(5, 6) );
+    fpts.ptr<Point3f>()[3] = Point3f( rngIn(3,4), rngIn(1,2), rngIn(5, 6) );
+       
+    transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + 4, tpts.ptr<Point3f>(), WrapAff(aff));
+
+    Mat aff_est;
+    vector<uchar> outliers;
+    estimateAffine3D(fpts, tpts, aff_est, outliers);
+
+    const double thres = 1e-3;
+    if (norm(aff_est, aff, NORM_INF) > thres)
+    {
+        //cout << norm(aff_est, aff, NORM_INF) << endl;
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        return false;
+    }    
+    return true;
+}
+
+struct Noise
+{
+    float l;
+    Noise(float level) : l(level) {}
+    Point3f operator()(const Point3f& p)
+    {
+        RNG& rng = theRNG();        
+        return Point3f( p.x + l * (float)rng,  p.y + l * (float)rng,  p.z + l * (float)rng);                 
+    }
+};
+
+bool CV_Affine3D_EstTest::testNPoints()
+{       
+    Mat aff(3, 4, CV_64F);
+    cv::randu(aff, Scalar(-2), Scalar(2));
+      
+    // setting points that are no in the same line
+    
+    const int n = 100;
+    const int m = 3*n/5;
+    const Point3f shift_outl = Point3f(15, 15, 15);
+    const float noise_level = 20.f;
+    
+    Mat fpts(1, n, CV_32FC3);
+    Mat tpts(1, n, CV_32FC3);
+   
+    randu(fpts, Scalar::all(0), Scalar::all(100));           
+    transform(fpts.ptr<Point3f>(), fpts.ptr<Point3f>() + n, tpts.ptr<Point3f>(), WrapAff(aff));
+
+    /* adding noise*/
+    transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, bind2nd(plus<Point3f>(), shift_outl));
+    transform(tpts.ptr<Point3f>() + m, tpts.ptr<Point3f>() + n, tpts.ptr<Point3f>() + m, Noise(noise_level));
+    
+    Mat aff_est;
+    vector<uchar> outl;
+    int res = estimateAffine3D(fpts, tpts, aff_est, outl);
+
+    if (!res)
+    {     
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        return false;
+    }
+
+    const double thres = 1e-4;
+    if (norm(aff_est, aff, NORM_INF) > thres)
+    {        
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        return false;
+    }    
+
+    bool outl_good = count(outl.begin(), outl.end(), 1) == m && 
+        m == accumulate(outl.begin(), outl.begin() + m, 0);
+
+    if (!outl_good)
+    {
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        return false;
+    }
+    return true;
+}
+
+
+void CV_Affine3D_EstTest::run( int /* start_from */)
+{	
+    cvtest::DefaultRngAuto dra;
+    
+    if (!test4Points())
+        return;
+
+    if (!testNPoints())
+        return;
+
+    ts->set_failed_test_info(cvtest::TS::OK);
+}
+
+TEST(Calib3d_EstimateAffineTransform, accuracy) { CV_Affine3D_EstTest test; test.safe_run(); }
+

modules/calib3d/test/test_cameracalibration_artificial.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#include <string>
+#include <limits>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <iomanip>
+
+#include "test_chessboardgenerator.hpp"
+
+using namespace cv;
+using namespace std;
+
+//template<class T> ostream& operator<<(ostream& out, const Mat_<T>& mat)
+//{    
+//    for(Mat_<T>::const_iterator pos = mat.begin(), end = mat.end(); pos != end; ++pos)
+//        out << *pos << " ";
+//    return out;
+//}
+//ostream& operator<<(ostream& out, const Mat& mat) { return out << Mat_<double>(mat); } 
+
+Mat calcRvec(const vector<Point3f>& points, const Size& cornerSize)
+{  
+    Point3f p00 = points[0];
+    Point3f p10 = points[1];
+    Point3f p01 = points[cornerSize.width];            
+
+    Vec3d ex(p10.x - p00.x, p10.y - p00.y, p10.z - p00.z);
+    Vec3d ey(p01.x - p00.x, p01.y - p00.y, p01.z - p00.z);        
+    Vec3d ez = ex.cross(ey); 
+
+    Mat rot(3, 3, CV_64F);
+    *rot.ptr<Vec3d>(0) = ex;
+    *rot.ptr<Vec3d>(1) = ey;
+    *rot.ptr<Vec3d>(2) = ez * (1.0/norm(ez));
+
+    Mat res;
+    Rodrigues(rot.t(), res);
+    return res.reshape(1, 1);
+}
+
+class CV_CalibrateCameraArtificialTest : public cvtest::BaseTest
+{
+public:
+    CV_CalibrateCameraArtificialTest()
+    {
+    }
+    ~CV_CalibrateCameraArtificialTest() {}
+protected:     
+    int r;
+
+    const static int JUST_FIND_CORNERS = 0;
+    const static int USE_CORNERS_SUBPIX = 1;
+    const static int USE_4QUAD_CORNERS = 2;
+    const static int ARTIFICIAL_CORNERS = 4;
+
+
+    bool checkErr(double a, double a0, double eps, double delta)
+    {
+        return fabs(a - a0) > eps * (fabs(a0) + delta);
+    }
+
+    void compareCameraMatrs(const Mat_<double>& camMat, const Mat& camMat_est)
+    {
+        if ( camMat_est.at<double>(0, 1) != 0 || camMat_est.at<double>(1, 0) != 0 ||
+            camMat_est.at<double>(2, 0) != 0 || camMat_est.at<double>(2, 1) != 0 ||
+            camMat_est.at<double>(2, 2) != 1)
+        {
+            ts->printf( cvtest::TS::LOG, "Bad shape of camera matrix returned \n");
+            ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        }        
+
+        double fx_e = camMat_est.at<double>(0, 0), fy_e = camMat_est.at<double>(1, 1);
+        double cx_e = camMat_est.at<double>(0, 2), cy_e = camMat_est.at<double>(1, 2);
+
+        double fx = camMat(0, 0), fy = camMat(1, 1), cx = camMat(0, 2), cy = camMat(1, 2);
+
+        const double eps = 1e-2;
+        const double dlt = 1e-5;
+
+        bool fail = checkErr(fx_e, fx, eps, dlt) || checkErr(fy_e, fy, eps, dlt) || 
+            checkErr(cx_e, cx, eps, dlt) || checkErr(cy_e, cy, eps, dlt);        
+
+        if (fail)
+        {
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);                                        
+        }        
+        ts->printf( cvtest::TS::LOG, "%d) Expected  [Fx Fy Cx Cy] = [%.3f %.3f %.3f %.3f]\n", r, fx, fy, cx, cy);
+        ts->printf( cvtest::TS::LOG, "%d) Estimated [Fx Fy Cx Cy] = [%.3f %.3f %.3f %.3f]\n", r, fx_e, fy_e, cx_e, cy_e);                        
+    }
+
+    void compareDistCoeffs(const Mat_<double>& distCoeffs, const Mat& distCoeffs_est)
+    {          
+        const double *dt_e = distCoeffs_est.ptr<double>();
+
+        double k1_e = dt_e[0], k2_e = dt_e[1], k3_e = dt_e[4];
+        double p1_e = dt_e[2], p2_e = dt_e[3];
+
+        double k1 = distCoeffs(0, 0), k2 = distCoeffs(0, 1), k3 = distCoeffs(0, 4);
+        double p1 = distCoeffs(0, 2), p2 = distCoeffs(0, 3);
+
+        const double eps = 5e-2;
+        const double dlt = 1e-3;   
+
+        const double eps_k3 = 5;
+        const double dlt_k3 = 1e-3;   
+
+        bool fail = checkErr(k1_e, k1, eps, dlt) || checkErr(k2_e, k2, eps, dlt) || checkErr(k3_e, k3, eps_k3, dlt_k3) || 
+            checkErr(p1_e, p1, eps, dlt) || checkErr(p2_e, p2, eps, dlt);        
+
+        if (fail)
+        {
+            // commented according to vp123's recomendation. TODO - improve accuaracy
+            //ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ss                                    
+        }                
+        ts->printf( cvtest::TS::LOG, "%d) DistCoeff exp=(%.2f, %.2f, %.4f, %.4f %.2f)\n", r, k1, k2, p1, p2, k3);
+        ts->printf( cvtest::TS::LOG, "%d) DistCoeff est=(%.2f, %.2f, %.4f, %.4f %.2f)\n", r, k1_e, k2_e, p1_e, p2_e, k3_e);                                    
+        ts->printf( cvtest::TS::LOG, "%d) AbsError = [%.5f %.5f %.5f %.5f %.5f]\n", r, fabs(k1-k1_e), fabs(k2-k2_e), fabs(p1-p1_e), fabs(p2-p2_e), fabs(k3-k3_e));
+    }
+
+    void compareShiftVecs(const vector<Mat>& tvecs, const vector<Mat>& tvecs_est)
+    {
+        const double eps = 1e-2;
+        const double dlt = 1e-4;
+
+        int err_count = 0;
+        const int errMsgNum = 4;
+        for(size_t i = 0; i < tvecs.size(); ++i)
+        {
+            const Point3d& tvec = *tvecs[i].ptr<Point3d>();
+            const Point3d& tvec_est = *tvecs_est[i].ptr<Point3d>();
+
+            if (norm(tvec_est - tvec) > eps* (norm(tvec) + dlt))            
+            {
+                if (err_count++ < errMsgNum)
+                {
+                    if (err_count == errMsgNum)       
+                        ts->printf( cvtest::TS::LOG, "%d) ...\n", r);                                            
+                    else                
+                    {
+                        ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned tvecs. Index = %d\n", r, i);                        
+                        ts->printf( cvtest::TS::LOG, "%d) norm(tvec_est - tvec) = %f, norm(tvec_exp) = %f \n", r, norm(tvec_est - tvec), norm(tvec));
+                    }
+                }
+                ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            }            
+        }
+    }
+
+    void compareRotationVecs(const vector<Mat>& rvecs, const vector<Mat>& rvecs_est)
+    {
+        const double eps = 2e-2;
+        const double dlt = 1e-4;
+
+        Mat rmat, rmat_est;
+        int err_count = 0;
+        const int errMsgNum = 4;
+        for(size_t i = 0; i < rvecs.size(); ++i)
+        {             
+            Rodrigues(rvecs[i], rmat);
+            Rodrigues(rvecs_est[i], rmat_est);            
+
+            if (norm(rmat_est, rmat) > eps* (norm(rmat) + dlt))
+            {
+                if (err_count++ < errMsgNum)
+                {
+                    if (err_count == errMsgNum)
+                        ts->printf( cvtest::TS::LOG, "%d) ...\n", r);                                            
+                    else
+                    {
+                        ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned rvecs (rotation matrs). Index = %d\n", r, i);                                                                
+                        ts->printf( cvtest::TS::LOG, "%d) norm(rot_mat_est - rot_mat_exp) = %f, norm(rot_mat_exp) = %f \n", r, norm(rmat_est, rmat), norm(rmat));                                
+
+                    }
+                }
+                ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+            }
+        }
+    }
+
+    double reprojectErrorWithoutIntrinsics(const vector<Point3f>& cb3d, const vector<Mat>& rvecs_exp, const vector<Mat>& tvecs_exp,
+        const vector<Mat>& rvecs_est, const vector<Mat>& tvecs_est)
+    {                        
+        const static Mat eye33 = Mat::eye(3, 3, CV_64F);
+        const static Mat zero15 = Mat::zeros(1, 5, CV_64F);
+        Mat chessboard3D(cb3d);
+        vector<Point2f> uv_exp, uv_est;
+        double res = 0;        
+
+        for(size_t i = 0; i < rvecs_exp.size(); ++i)  
+        {                        
+            projectPoints(chessboard3D, rvecs_exp[i], tvecs_exp[i], eye33, zero15, uv_exp);            
+            projectPoints(chessboard3D, rvecs_est[i], tvecs_est[i], eye33, zero15, uv_est);
+            for(size_t j = 0; j < cb3d.size(); ++j)
+                res += norm(uv_exp[i] - uv_est[i]);
+        }
+        return res;
+    }
+
+    Size2f sqSile;
+
+    vector<Point3f> chessboard3D;
+    vector<Mat> boards, rvecs_exp, tvecs_exp, rvecs_spnp, tvecs_spnp;                
+    vector< vector<Point3f> > objectPoints;
+    vector< vector<Point2f> > imagePoints_art;
+    vector< vector<Point2f> > imagePoints_findCb;
+
+
+    void prepareForTest(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, size_t brdsNum, const ChessBoardGenerator& cbg)
+    {
+        sqSile = Size2f(1.f, 1.f);
+        Size cornersSize = cbg.cornersSize();
+
+        chessboard3D.clear();
+        for(int j = 0; j < cornersSize.height; ++j)
+            for(int i = 0; i < cornersSize.width; ++i)
+                chessboard3D.push_back(Point3f(sqSile.width * i, sqSile.height * j, 0));
+
+        boards.resize(brdsNum);
+        rvecs_exp.resize(brdsNum);
+        tvecs_exp.resize(brdsNum);
+        objectPoints.clear();
+        objectPoints.resize(brdsNum, chessboard3D);
+        imagePoints_art.clear();
+        imagePoints_findCb.clear();
+
+        vector<Point2f> corners_art, corners_fcb;
+        for(size_t i = 0; i < brdsNum; ++i)        
+        {                                    
+            for(;;)
+            {
+                boards[i] = cbg(bg, camMat, distCoeffs, sqSile, corners_art);
+                if(findChessboardCorners(boards[i], cornersSize, corners_fcb))                    
+                    break;                    
+            }                   
+
+            //cv::namedWindow("CB"); imshow("CB", boards[i]); cv::waitKey();
+
+            imagePoints_art.push_back(corners_art);                        
+            imagePoints_findCb.push_back(corners_fcb);
+
+            tvecs_exp[i].create(1, 3, CV_64F);
+            *tvecs_exp[i].ptr<Point3d>() = cbg.corners3d[0];
+            rvecs_exp[i] = calcRvec(cbg.corners3d, cbg.cornersSize());            
+        }
+
+    }
+
+    void runTest(const Size& imgSize, const Mat_<double>& camMat, const Mat_<double>& distCoeffs, size_t brdsNum, const Size& cornersSize, int flag = 0)
+    {           
+        const TermCriteria tc(TermCriteria::EPS|TermCriteria::MAX_ITER, 30, 0.1);
+
+        vector< vector<Point2f> > imagePoints;
+
+        switch(flag)
+        {
+        case JUST_FIND_CORNERS: imagePoints = imagePoints_findCb; break;
+        case ARTIFICIAL_CORNERS: imagePoints = imagePoints_art; break;
+
+        case USE_CORNERS_SUBPIX: 
+            for(size_t i = 0; i < brdsNum; ++i)
+            {                
+                Mat gray;
+                cvtColor(boards[i], gray, CV_BGR2GRAY);
+                vector<Point2f> tmp = imagePoints_findCb[i];
+                cornerSubPix(gray, tmp, Size(5, 5), Size(-1,-1), tc);
+                imagePoints.push_back(tmp);
+            }
+            break;
+        case USE_4QUAD_CORNERS:
+            for(size_t i = 0; i < brdsNum; ++i)
+            {                
+                Mat gray;
+                cvtColor(boards[i], gray, CV_BGR2GRAY);                
+                vector<Point2f> tmp = imagePoints_findCb[i];
+                find4QuadCornerSubpix(gray, tmp, Size(5, 5));
+                imagePoints.push_back(tmp);
+            }
+            break;
+        default:
+            throw std::exception();
+        }
+     
+        Mat camMat_est = Mat::eye(3, 3, CV_64F), distCoeffs_est = Mat::zeros(1, 5, CV_64F);
+        vector<Mat> rvecs_est, tvecs_est;
+
+        int flags = /*CV_CALIB_FIX_K3|*/CV_CALIB_FIX_K4|CV_CALIB_FIX_K5|CV_CALIB_FIX_K6; //CALIB_FIX_K3; //CALIB_FIX_ASPECT_RATIO |  | CALIB_ZERO_TANGENT_DIST;
+        double rep_error = calibrateCamera(objectPoints, imagePoints, imgSize, camMat_est, distCoeffs_est, rvecs_est, tvecs_est, flags);
+        rep_error /= brdsNum * cornersSize.area();
+
+        const double thres = 1;
+        if (rep_error > thres)
+        {
+            ts->printf( cvtest::TS::LOG, "%d) Too big reproject error = %f\n", r, rep_error);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        }
+
+        compareCameraMatrs(camMat, camMat_est);
+        compareDistCoeffs(distCoeffs, distCoeffs_est);
+        compareShiftVecs(tvecs_exp, tvecs_est);
+        compareRotationVecs(rvecs_exp, rvecs_est);  
+
+        double rep_errorWOI = reprojectErrorWithoutIntrinsics(chessboard3D, rvecs_exp, tvecs_exp, rvecs_est, tvecs_est);        
+        rep_errorWOI /= brdsNum * cornersSize.area();
+
+        const double thres2 = 0.01;
+        if (rep_errorWOI > thres2)
+        {
+            ts->printf( cvtest::TS::LOG, "%d) Too big reproject error without intrinsics = %f\n", r, rep_errorWOI);
+            ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        }    
+        
+        ts->printf( cvtest::TS::LOG, "%d) Testing solvePnP...\n", r);
+        rvecs_spnp.resize(brdsNum);
+        tvecs_spnp.resize(brdsNum);
+        for(size_t i = 0; i < brdsNum; ++i)
+            solvePnP(Mat(objectPoints[i]), Mat(imagePoints[i]), camMat, distCoeffs, rvecs_spnp[i], tvecs_spnp[i]);
+
+        compareShiftVecs(tvecs_exp, tvecs_spnp);
+        compareRotationVecs(rvecs_exp, rvecs_spnp);         
+    }
+
+    void run(int)
+    {   
+
+        ts->set_failed_test_info(cvtest::TS::OK);
+        RNG& rng = theRNG();
+
+        int progress = 0;
+        int repeat_num = 3;
+        for(r = 0; r < repeat_num; ++r)
+        {                        
+            const int brds_num = 20;              
+
+            Mat bg(Size(640, 480), CV_8UC3);                
+            randu(bg, Scalar::all(32), Scalar::all(255));    
+            GaussianBlur(bg, bg, Size(5, 5), 2);
+
+            double fx = 300 + (20 * (double)rng - 10);
+            double fy = 300 + (20 * (double)rng - 10);
+
+            double cx = bg.cols/2 + (40 * (double)rng - 20);
+            double cy = bg.rows/2 + (40 * (double)rng - 20);
+
+            Mat_<double> camMat(3, 3);
+            camMat << fx, 0., cx, 0, fy, cy, 0., 0., 1.;
+
+            double k1 = 0.5 + (double)rng/5;
+            double k2 = (double)rng/5;
+            double k3 = (double)rng/5;
+
+            double p1 = 0.001 + (double)rng/10;
+            double p2 = 0.001 + (double)rng/10;
+
+            Mat_<double> distCoeffs(1, 5, 0.0);
+            distCoeffs << k1, k2, p1, p2, k3;
+
+            ChessBoardGenerator cbg(Size(9, 8)); 
+            cbg.min_cos = 0.9;
+            cbg.cov = 0.8;
+
+            progress = update_progress(progress, r, repeat_num, 0);
+            ts->printf( cvtest::TS::LOG, "\n");            
+            prepareForTest(bg, camMat, distCoeffs, brds_num, cbg);
+
+            ts->printf( cvtest::TS::LOG, "artificial corners\n");            
+            runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), ARTIFICIAL_CORNERS);       
+            progress = update_progress(progress, r, repeat_num, 0);
+
+            ts->printf( cvtest::TS::LOG, "findChessboard corners\n");
+            runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), JUST_FIND_CORNERS);       
+            progress = update_progress(progress, r, repeat_num, 0);
+
+            ts->printf( cvtest::TS::LOG, "cornersSubPix corners\n");
+            runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), USE_CORNERS_SUBPIX);
+            progress = update_progress(progress, r, repeat_num, 0);
+
+            ts->printf( cvtest::TS::LOG, "4quad corners\n");
+            runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), USE_4QUAD_CORNERS);
+            progress = update_progress(progress, r, repeat_num, 0);
+        }
+    }
+};   
+
+TEST(Calib3d_CalibrateCamera_CPP, accuracy_on_artificial_data) { CV_CalibrateCameraArtificialTest test; test.safe_run(); }

modules/calib3d/test/test_chessboardgenerator.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                           License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of the copyright holders may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include "test_chessboardgenerator.hpp"
+
+#include <vector>
+#include <iterator>
+#include <algorithm>
+
+using namespace cv;
+using namespace std;
+
+ChessBoardGenerator::ChessBoardGenerator(const Size& _patternSize) : sensorWidth(32), sensorHeight(24),
+    squareEdgePointsNum(200), min_cos(sqrt(2.f)*0.5f), cov(0.5), 
+    patternSize(_patternSize), rendererResolutionMultiplier(4), tvec(Mat::zeros(1, 3, CV_32F))
+{    
+    Rodrigues(Mat::eye(3, 3, CV_32F), rvec);
+}
+
+void cv::ChessBoardGenerator::generateEdge(const Point3f& p1, const Point3f& p2, vector<Point3f>& out) const
+{    
+    Point3f step = (p2 - p1) * (1.f/squareEdgePointsNum);    
+    for(size_t n = 0; n < squareEdgePointsNum; ++n)
+        out.push_back( p1 + step * (float)n);
+}    
+
+Size cv::ChessBoardGenerator::cornersSize() const
+{
+    return Size(patternSize.width-1, patternSize.height-1);
+}
+
+struct Mult
+{
+    float m;
+    Mult(int mult) : m((float)mult) {}
+    Point2f operator()(const Point2f& p)const { return p * m; }    
+};
+
+void cv::ChessBoardGenerator::generateBasis(Point3f& pb1, Point3f& pb2) const
+{
+    RNG& rng = theRNG();
+
+    Vec3f n;
+    for(;;)
+    {        
+        n[0] = rng.uniform(-1.f, 1.f);
+        n[1] = rng.uniform(-1.f, 1.f);
+        n[2] = rng.uniform(-1.f, 1.f);        
+        float len = (float)norm(n);    
+        n[0]/=len;  
+        n[1]/=len;  
+        n[2]/=len;
+        
+        if (n[2] > min_cos)
+            break;
+    }
+
+    Vec3f n_temp = n; n_temp[0] += 100;
+    Vec3f b1 = n.cross(n_temp); 
+    Vec3f b2 = n.cross(b1);
+    float len_b1 = (float)norm(b1);
+    float len_b2 = (float)norm(b2);    
+
+    pb1 = Point3f(b1[0]/len_b1, b1[1]/len_b1, b1[2]/len_b1);
+    pb2 = Point3f(b2[0]/len_b1, b2[1]/len_b2, b2[2]/len_b2);
+}
+
+
+Mat cv::ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, 
+                                                const Point3f& zero, const Point3f& pb1, const Point3f& pb2, 
+                                                float sqWidth, float sqHeight, const vector<Point3f>& whole,
+                                                vector<Point2f>& corners) const
+{    
+    vector< vector<Point> > squares_black;    
+    for(int i = 0; i < patternSize.width; ++i)
+        for(int j = 0; j < patternSize.height; ++j)
+            if ( (i % 2 == 0 && j % 2 == 0) || (i % 2 != 0 && j % 2 != 0) ) 
+            {            
+                vector<Point3f> pts_square3d;
+                vector<Point2f> pts_square2d;
+
+                Point3f p1 = zero + (i + 0) * sqWidth * pb1 + (j + 0) * sqHeight * pb2;
+                Point3f p2 = zero + (i + 1) * sqWidth * pb1 + (j + 0) * sqHeight * pb2;
+                Point3f p3 = zero + (i + 1) * sqWidth * pb1 + (j + 1) * sqHeight * pb2;
+                Point3f p4 = zero + (i + 0) * sqWidth * pb1 + (j + 1) * sqHeight * pb2;
+                generateEdge(p1, p2, pts_square3d);
+                generateEdge(p2, p3, pts_square3d);
+                generateEdge(p3, p4, pts_square3d);
+                generateEdge(p4, p1, pts_square3d);  
+                
+                projectPoints(Mat(pts_square3d), rvec, tvec, camMat, distCoeffs, pts_square2d);
+                squares_black.resize(squares_black.size() + 1);  
+                vector<Point2f> temp; 
+                approxPolyDP(Mat(pts_square2d), temp, 1.0, true); 
+                transform(temp.begin(), temp.end(), back_inserter(squares_black.back()), Mult(rendererResolutionMultiplier));             
+            }  
+
+    /* calculate corners */    
+    corners3d.clear();
+    for(int j = 0; j < patternSize.height - 1; ++j)
+        for(int i = 0; i < patternSize.width - 1; ++i)
+            corners3d.push_back(zero + (i + 1) * sqWidth * pb1 + (j + 1) * sqHeight * pb2);
+    corners.clear();
+    projectPoints(Mat(corners3d), rvec, tvec, camMat, distCoeffs, corners);
+ 
+    vector<Point3f> whole3d;
+    vector<Point2f> whole2d;
+    generateEdge(whole[0], whole[1], whole3d);
+    generateEdge(whole[1], whole[2], whole3d);
+    generateEdge(whole[2], whole[3], whole3d);
+    generateEdge(whole[3], whole[0], whole3d);
+    projectPoints(Mat(whole3d), rvec, tvec, camMat, distCoeffs, whole2d);
+    vector<Point2f> temp_whole2d; 
+    approxPolyDP(Mat(whole2d), temp_whole2d, 1.0, true); 
+
+    vector< vector<Point > > whole_contour(1);
+    transform(temp_whole2d.begin(), temp_whole2d.end(), 
+        back_inserter(whole_contour.front()), Mult(rendererResolutionMultiplier));    
+
+    Mat result;
+    if (rendererResolutionMultiplier == 1)
+    {        
+        result = bg.clone();
+        drawContours(result, whole_contour, -1, Scalar::all(255), CV_FILLED, CV_AA);       
+        drawContours(result, squares_black, -1, Scalar::all(0), CV_FILLED, CV_AA);
+    }
+    else
+    {
+        Mat tmp;        
+        resize(bg, tmp, bg.size() * rendererResolutionMultiplier);
+        drawContours(tmp, whole_contour, -1, Scalar::all(255), CV_FILLED, CV_AA);       
+        drawContours(tmp, squares_black, -1, Scalar::all(0), CV_FILLED, CV_AA);
+        resize(tmp, result, bg.size(), 0, 0, INTER_AREA);
+    }        
+
+    return result;
+}
+
+Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, vector<Point2f>& corners) const
+{      
+    cov = min(cov, 0.8);
+    double fovx, fovy, focalLen;
+    Point2d principalPoint;
+    double aspect;
+    calibrationMatrixValues( camMat, bg.size(), sensorWidth, sensorHeight, 
+        fovx, fovy, focalLen, principalPoint, aspect);
+
+    RNG& rng = theRNG();
+
+    float d1 = static_cast<float>(rng.uniform(0.1, 10.0)); 
+    float ah = static_cast<float>(rng.uniform(-fovx/2 * cov, fovx/2 * cov) * CV_PI / 180);
+    float av = static_cast<float>(rng.uniform(-fovy/2 * cov, fovy/2 * cov) * CV_PI / 180);        
+    
+    Point3f p;
+    p.z = cos(ah) * d1;
+    p.x = sin(ah) * d1;
+    p.y = p.z * tan(av);  
+
+    Point3f pb1, pb2;    
+    generateBasis(pb1, pb2);
+            
+    float cbHalfWidth = static_cast<float>(norm(p) * sin( min(fovx, fovy) * 0.5 * CV_PI / 180));
+    float cbHalfHeight = cbHalfWidth * patternSize.height / patternSize.width;    
+
+    float cbHalfWidthEx  =  cbHalfWidth * ( patternSize.width + 1) / patternSize.width;
+    float cbHalfHeightEx = cbHalfHeight * (patternSize.height + 1) / patternSize.height;
+    
+    vector<Point3f> pts3d(4);
+    vector<Point2f> pts2d(4);
+    for(;;)
+    {        
+        pts3d[0] = p + pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
+        pts3d[1] = p + pb1 * cbHalfWidthEx - cbHalfHeightEx * pb2;
+        pts3d[2] = p - pb1 * cbHalfWidthEx - cbHalfHeightEx * pb2;
+        pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
+        
+        /* can remake with better perf */
+        projectPoints(Mat(pts3d), rvec, tvec, camMat, distCoeffs, pts2d);
+
+        bool inrect1 = pts2d[0].x < bg.cols && pts2d[0].y < bg.rows && pts2d[0].x > 0 && pts2d[0].y > 0;
+        bool inrect2 = pts2d[1].x < bg.cols && pts2d[1].y < bg.rows && pts2d[1].x > 0 && pts2d[1].y > 0;
+        bool inrect3 = pts2d[2].x < bg.cols && pts2d[2].y < bg.rows && pts2d[2].x > 0 && pts2d[2].y > 0;
+        bool inrect4 = pts2d[3].x < bg.cols && pts2d[3].y < bg.rows && pts2d[3].x > 0 && pts2d[3].y > 0;
+        
+        if (inrect1 && inrect2 && inrect3 && inrect4)
+            break;
+
+        cbHalfWidth*=0.8f;
+        cbHalfHeight = cbHalfWidth * patternSize.height / patternSize.width;   
+        
+        cbHalfWidthEx  = cbHalfWidth * ( patternSize.width + 1) / patternSize.width;
+        cbHalfHeightEx = cbHalfHeight * (patternSize.height + 1) / patternSize.height;
+    }
+    
+    Point3f zero = p - pb1 * cbHalfWidth - cbHalfHeight * pb2;
+    float sqWidth  = 2 * cbHalfWidth/patternSize.width;
+    float sqHeight = 2 * cbHalfHeight/patternSize.height;
+        
+    return generateChessBoard(bg, camMat, distCoeffs, zero, pb1, pb2, sqWidth, sqHeight,  pts3d, corners);      
+}
+
+
+Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, 
+                                         const Size2f& squareSize, vector<Point2f>& corners) const
+{        
+    cov = min(cov, 0.8);
+    double fovx, fovy, focalLen;
+    Point2d principalPoint;
+    double aspect;
+    calibrationMatrixValues( camMat, bg.size(), sensorWidth, sensorHeight, 
+        fovx, fovy, focalLen, principalPoint, aspect);
+
+    RNG& rng = theRNG();
+
+    float d1 = static_cast<float>(rng.uniform(0.1, 10.0)); 
+    float ah = static_cast<float>(rng.uniform(-fovx/2 * cov, fovx/2 * cov) * CV_PI / 180);
+    float av = static_cast<float>(rng.uniform(-fovy/2 * cov, fovy/2 * cov) * CV_PI / 180);        
+    
+    Point3f p;
+    p.z = cos(ah) * d1;
+    p.x = sin(ah) * d1;
+    p.y = p.z * tan(av);  
+
+    Point3f pb1, pb2;    
+    generateBasis(pb1, pb2);   
+
+    float cbHalfWidth  =  squareSize.width *  patternSize.width * 0.5f;
+    float cbHalfHeight = squareSize.height * patternSize.height * 0.5f;
+
+    float cbHalfWidthEx  =  cbHalfWidth * ( patternSize.width + 1) / patternSize.width;
+    float cbHalfHeightEx = cbHalfHeight * (patternSize.height + 1) / patternSize.height;
+    
+    vector<Point3f> pts3d(4);
+    vector<Point2f> pts2d(4);
+    for(;;)
+    {        
+        pts3d[0] = p + pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
+        pts3d[1] = p + pb1 * cbHalfWidthEx - cbHalfHeightEx * pb2;
+        pts3d[2] = p - pb1 * cbHalfWidthEx - cbHalfHeightEx * pb2;
+        pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
+        
+        /* can remake with better perf */
+        projectPoints(Mat(pts3d), rvec, tvec, camMat, distCoeffs, pts2d);
+
+        bool inrect1 = pts2d[0].x < bg.cols && pts2d[0].y < bg.rows && pts2d[0].x > 0 && pts2d[0].y > 0;
+        bool inrect2 = pts2d[1].x < bg.cols && pts2d[1].y < bg.rows && pts2d[1].x > 0 && pts2d[1].y > 0;
+        bool inrect3 = pts2d[2].x < bg.cols && pts2d[2].y < bg.rows && pts2d[2].x > 0 && pts2d[2].y > 0;
+        bool inrect4 = pts2d[3].x < bg.cols && pts2d[3].y < bg.rows && pts2d[3].x > 0 && pts2d[3].y > 0;
+        
+        if ( inrect1 && inrect2 && inrect3 && inrect4)
+            break;
+
+        p.z *= 1.1f;
+    }
+    
+    Point3f zero = p - pb1 * cbHalfWidth - cbHalfHeight * pb2;
+            
+    return generateChessBoard(bg, camMat, distCoeffs, zero, pb1, pb2, 
+        squareSize.width, squareSize.height, pts3d, corners);      
+}
+
+Mat cv::ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, 
+                                         const Size2f& squareSize, const Point3f& pos, vector<Point2f>& corners) const
+{           
+    cov = min(cov, 0.8);
+    Point3f p = pos;    
+    Point3f pb1, pb2;    
+    generateBasis(pb1, pb2);   
+
+    float cbHalfWidth  =  squareSize.width *  patternSize.width * 0.5f;
+    float cbHalfHeight = squareSize.height * patternSize.height * 0.5f;
+
+    float cbHalfWidthEx  =  cbHalfWidth * ( patternSize.width + 1) / patternSize.width;
+    float cbHalfHeightEx = cbHalfHeight * (patternSize.height + 1) / patternSize.height;
+    
+    vector<Point3f> pts3d(4);
+    vector<Point2f> pts2d(4);
+      
+    pts3d[0] = p + pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
+    pts3d[1] = p + pb1 * cbHalfWidthEx - cbHalfHeightEx * pb2;
+    pts3d[2] = p - pb1 * cbHalfWidthEx - cbHalfHeightEx * pb2;
+    pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
+        
+    /* can remake with better perf */
+    projectPoints(Mat(pts3d), rvec, tvec, camMat, distCoeffs, pts2d);
+    
+    Point3f zero = p - pb1 * cbHalfWidth - cbHalfHeight * pb2;
+            
+    return generateChessBoard(bg, camMat, distCoeffs, zero, pb1, pb2, 
+        squareSize.width, squareSize.height,  pts3d, corners);      
+}
+

modules/calib3d/test/test_chessboardgenerator.hpp

+#ifndef CV_CHESSBOARDGENERATOR_H143KJTVYM389YTNHKFDHJ89NYVMO3VLMEJNTBGUEIYVCM203P
+#define CV_CHESSBOARDGENERATOR_H143KJTVYM389YTNHKFDHJ89NYVMO3VLMEJNTBGUEIYVCM203P
+
+#include "opencv2/calib3d/calib3d.hpp"
+
+namespace cv
+{
+
+class ChessBoardGenerator
+{
+public:
+    double sensorWidth; 
+    double sensorHeight;     
+    size_t squareEdgePointsNum;
+    double min_cos;
+    mutable double cov;
+    Size patternSize;
+    int rendererResolutionMultiplier;
+
+    ChessBoardGenerator(const Size& patternSize = Size(8, 6));
+    Mat operator()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, vector<Point2f>& corners) const;    
+    Mat operator()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, const Size2f& squareSize, vector<Point2f>& corners) const;  
+    Mat operator()(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, const Size2f& squareSize, const Point3f& pos, vector<Point2f>& corners) const;
+    Size cornersSize() const;
+
+    mutable vector<Point3f> corners3d;
+private:
+    void generateEdge(const Point3f& p1, const Point3f& p2, vector<Point3f>& out) const;
+    Mat generateChessBoard(const Mat& bg, const Mat& camMat, const Mat& distCoeffs, 
+        const Point3f& zero, const Point3f& pb1, const Point3f& pb2, 
+        float sqWidth, float sqHeight, const vector<Point3f>& whole, vector<Point2f>& corners) const;
+    void generateBasis(Point3f& pb1, Point3f& pb2) const;  
+    
+    Mat rvec, tvec;
+};
+
+};
+
+
+#endif

modules/calib3d/test/test_chesscorners.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include "test_chessboardgenerator.hpp"
+
+#include <limits>
+#include <numeric>
+
+using namespace std;
+using namespace cv;
+
+#define _L2_ERR
+
+void show_points( const Mat& gray, const Mat& u, const vector<Point2f>& v, Size pattern_size, bool was_found )
+{
+    Mat rgb( gray.size(), CV_8U);
+    merge(vector<Mat>(3, gray), rgb);
+        
+    for(size_t i = 0; i < v.size(); i++ )
+        circle( rgb, v[i], 3, CV_RGB(255, 0, 0), CV_FILLED);            
+
+    if( !u.empty() )
+    {
+        const Point2f* u_data = u.ptr<Point2f>();
+        size_t count = u.cols * u.rows;
+        for(size_t i = 0; i < count; i++ )
+            circle( rgb, u_data[i], 3, CV_RGB(0, 255, 0), CV_FILLED);
+    }
+    if (!v.empty())
+    {
+        Mat corners((int)v.size(), 1, CV_32FC2, (void*)&v[0]);     
+        drawChessboardCorners( rgb, pattern_size, corners, was_found );
+    }
+    //namedWindow( "test", 0 ); imshow( "test", rgb ); waitKey(0);
+}
+
+
+enum Pattern { CHESSBOARD, CIRCLES_GRID };
+
+class CV_ChessboardDetectorTest : public cvtest::BaseTest
+{
+public:
+    CV_ChessboardDetectorTest( Pattern pattern );
+protected:
+    void run(int);
+    void run_batch(const string& filename);
+    bool checkByGenerator();
+
+    Pattern pattern;
+};
+
+CV_ChessboardDetectorTest::CV_ChessboardDetectorTest( Pattern _pattern )
+{
+    pattern = _pattern;
+}
+
+double calcError(const vector<Point2f>& v, const Mat& u)
+{
+    int count_exp = u.cols * u.rows;
+    const Point2f* u_data = u.ptr<Point2f>();
+
+    double err = numeric_limits<double>::max();
+    for( int k = 0; k < 2; ++k )
+    {
+        double err1 = 0;
+        for( int j = 0; j < count_exp; ++j )
+        {
+            int j1 = k == 0 ? j : count_exp - j - 1;
+            double dx = fabs( v[j].x - u_data[j1].x );
+            double dy = fabs( v[j].y - u_data[j1].y );
+
+#if defined(_L2_ERR)
+            err1 += dx*dx + dy*dy;
+#else
+            dx = MAX( dx, dy );
+            if( dx > err1 )
+                err1 = dx;
+#endif //_L2_ERR
+            //printf("dx = %f\n", dx);
+        }
+        //printf("\n");
+        err = min(err, err1);
+    }
+    
+#if defined(_L2_ERR)
+    err = sqrt(err/count_exp);
+#endif //_L2_ERR
+    
+    return err;
+}
+
+const double rough_success_error_level = 2.5;
+const double precise_success_error_level = 2;
+
+
+/* ///////////////////// chess_corner_test ///////////////////////// */
+void CV_ChessboardDetectorTest::run( int /*start_from */)
+{
+    /*if (!checkByGenerator())
+        return;*/
+    switch( pattern )
+    {
+        case CHESSBOARD:
+            checkByGenerator();
+            run_batch("chessboard_list.dat");
+            run_batch("chessboard_list_subpixel.dat");
+            break;
+        case CIRCLES_GRID:
+            run_batch("circles_list.dat");
+            break;
+    }
+}
+
+void CV_ChessboardDetectorTest::run_batch( const string& filename )
+{
+    cvtest::TS& ts = *this->ts;
+    ts.set_failed_test_info( cvtest::TS::OK );
+
+    ts.printf(cvtest::TS::LOG, "\nRunning batch %s\n", filename.c_str());
+//#define WRITE_POINTS 1
+#ifndef WRITE_POINTS    
+    double max_rough_error = 0, max_precise_error = 0;
+#endif
+    string folder;
+    switch( pattern )
+    {
+        case CHESSBOARD:
+            folder = string(ts.get_data_path()) + "cameracalibration/";
+            break;
+        case CIRCLES_GRID:
+            folder = string(ts.get_data_path()) + "cameracalibration/circles/";
+            break;
+    }
+
+    FileStorage fs( folder + filename, FileStorage::READ );
+    FileNode board_list = fs["boards"];
+        
+    if( !fs.isOpened() || board_list.empty() || !board_list.isSeq() || board_list.size() % 2 != 0 )
+    {
+        ts.printf( cvtest::TS::LOG, "%s can not be readed or is not valid\n", (folder + filename).c_str() );
+        ts.printf( cvtest::TS::LOG, "fs.isOpened=%d, board_list.empty=%d, board_list.isSeq=%d,board_list.size()%2=%d\n", 
+            fs.isOpened(), (int)board_list.empty(), board_list.isSeq(), board_list.size()%2);
+        ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );        
+        return;
+    }
+
+    int progress = 0;
+    int max_idx = board_list.node->data.seq->total/2;
+    double sum_error = 0.0;
+    int count = 0;
+
+    for(int idx = 0; idx < max_idx; ++idx )
+    {
+        ts.update_context( this, idx, true );
+        
+        /* read the image */
+        string img_file = board_list[idx * 2];                    
+        Mat gray = imread( folder + img_file, 0);
+                
+        if( gray.empty() )
+        {
+            ts.printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", img_file.c_str() );
+            ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
+            continue;
+        }
+
+        string filename = folder + (string)board_list[idx * 2 + 1];
+        Mat expected;
+        {
+            CvMat *u = (CvMat*)cvLoad( filename.c_str() );
+            if(!u )
+            {                
+                ts.printf( cvtest::TS::LOG, "one of chessboard corner files can't be read: %s\n", filename.c_str() ); 
+                ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
+                continue;                
+            }
+            expected = Mat(u, true);
+            cvReleaseMat( &u );
+        }                
+        size_t count_exp = static_cast<size_t>(expected.cols * expected.rows);                
+        Size pattern_size = expected.size();
+
+        vector<Point2f> v;
+        bool result = false;
+        switch( pattern )
+        {
+            case CHESSBOARD:
+                result = findChessboardCorners(gray, pattern_size, v, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE);
+                break;
+            case CIRCLES_GRID:
+                result = findCirclesGrid(gray, pattern_size, v);
+                break;
+        }
+        show_points( gray, Mat(), v, pattern_size, result );
+        if( !result || v.size() != count_exp )
+        {
+            ts.printf( cvtest::TS::LOG, "chessboard is not found in %s\n", img_file.c_str() );
+            ts.set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+            continue;
+        }
+
+#ifndef WRITE_POINTS
+        double err = calcError(v, expected);
+#if 0
+        if( err > rough_success_error_level )
+        {
+            ts.printf( cvtest::TS::LOG, "bad accuracy of corner guesses\n" );
+            ts.set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+            continue;
+        }
+#endif
+        max_rough_error = MAX( max_rough_error, err );
+#endif
+        if( pattern == CHESSBOARD )
+            cornerSubPix( gray, v, Size(5, 5), Size(-1,-1), TermCriteria(TermCriteria::EPS|TermCriteria::MAX_ITER, 30, 0.1));
+        //find4QuadCornerSubpix(gray, v, Size(5, 5));
+        show_points( gray, expected, v, pattern_size, result  );
+
+#ifndef WRITE_POINTS
+//        printf("called find4QuadCornerSubpix\n");
+        err = calcError(v, expected);
+        sum_error += err;
+        count++;
+#if 1
+        if( err > precise_success_error_level )
+        {
+            ts.printf( cvtest::TS::LOG, "Image %s: bad accuracy of adjusted corners %f\n", img_file.c_str(), err ); 
+            ts.set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+            continue;
+        }
+#endif
+        ts.printf(cvtest::TS::LOG, "Error on %s is %f\n", img_file.c_str(), err);
+        max_precise_error = MAX( max_precise_error, err );
+#else
+        Mat mat_v(pattern_size, CV_32FC2, (void*)&v[0]);
+        CvMat cvmat_v = mat_v;
+        cvSave( filename.c_str(), &cvmat_v );
+#endif
+        progress = update_progress( progress, idx, max_idx, 0 );
+    }    
+    
+    sum_error /= count;
+    ts.printf(cvtest::TS::LOG, "Average error is %f\n", sum_error);
+}
+
+double calcErrorMinError(const Size& cornSz, const vector<Point2f>& corners_found, const vector<Point2f>& corners_generated)
+{
+    Mat m1(cornSz, CV_32FC2, (Point2f*)&corners_generated[0]);    
+    Mat m2; flip(m1, m2, 0);
+
+    Mat m3; flip(m1, m3, 1); m3 = m3.t(); flip(m3, m3, 1);
+    
+    Mat m4 = m1.t(); flip(m4, m4, 1);
+
+    double min1 =  min(calcError(corners_found, m1), calcError(corners_found, m2));    
+    double min2 =  min(calcError(corners_found, m3), calcError(corners_found, m4));    
+    return min(min1, min2);
+}
+
+bool validateData(const ChessBoardGenerator& cbg, const Size& imgSz, 
+                  const vector<Point2f>& corners_generated)
+{
+    Size cornersSize = cbg.cornersSize();
+    Mat_<Point2f> mat(cornersSize.height, cornersSize.width, (Point2f*)&corners_generated[0]);
+
+    double minNeibDist = std::numeric_limits<double>::max();
+    double tmp = 0;
+    for(int i = 1; i < mat.rows - 2; ++i)
+        for(int j = 1; j < mat.cols - 2; ++j)
+        {
+            const Point2f& cur = mat(i, j);
+            
+            tmp = norm( cur - mat(i + 1, j + 1) );
+            if (tmp < minNeibDist)
+                tmp = minNeibDist;
+
+            tmp = norm( cur - mat(i - 1, j + 1 ) );
+            if (tmp < minNeibDist)
+                tmp = minNeibDist;
+
+            tmp = norm( cur - mat(i + 1, j - 1) );
+            if (tmp < minNeibDist)
+                tmp = minNeibDist;
+
+            tmp = norm( cur - mat(i - 1, j - 1) );
+            if (tmp < minNeibDist)
+                tmp = minNeibDist;
+        }
+
+    const double threshold = 0.25;
+    double cbsize = (max(cornersSize.width, cornersSize.height) + 1) * minNeibDist;
+    int imgsize =  min(imgSz.height, imgSz.width);    
+    return imgsize * threshold < cbsize;
+}
+
+bool CV_ChessboardDetectorTest::checkByGenerator()
+{   
+    bool res = true;
+    //theRNG() = 0x58e6e895b9913160;
+    //cv::DefaultRngAuto dra;
+    //theRNG() = *ts->get_rng();
+
+    Mat bg(Size(800, 600), CV_8UC3, Scalar::all(255));  
+    randu(bg, Scalar::all(0), Scalar::all(255)); 
+    GaussianBlur(bg, bg, Size(7,7), 3.0); 
+            
+    Mat_<float> camMat(3, 3);
+    camMat << 300.f, 0.f, bg.cols/2.f, 0, 300.f, bg.rows/2.f, 0.f, 0.f, 1.f;
+    
+    Mat_<float> distCoeffs(1, 5);
+    distCoeffs << 1.2f, 0.2f, 0.f, 0.f, 0.f;
+
+    const Size sizes[] = { Size(6, 6), Size(8, 6), Size(11, 12),  Size(5, 4) };
+    const size_t sizes_num = sizeof(sizes)/sizeof(sizes[0]);                
+    const int test_num = 16;    
+    int progress = 0;
+    for(int i = 0; i < test_num; ++i)
+    {          
+        progress = update_progress( progress, i, test_num, 0 );
+        ChessBoardGenerator cbg(sizes[i % sizes_num]);
+
+        vector<Point2f> corners_generated;
+
+        Mat cb = cbg(bg, camMat, distCoeffs, corners_generated);
+
+        if(!validateData(cbg, cb.size(), corners_generated))
+        {
+            ts->printf( cvtest::TS::LOG, "Chess board skipped - too small" );
+            continue;               
+        }
+
+        /*cb = cb * 0.8 + Scalar::all(30);            
+        GaussianBlur(cb, cb, Size(3, 3), 0.8);     */
+        //cv::addWeighted(cb, 0.8, bg, 0.2, 20, cb); 
+        //cv::namedWindow("CB"); cv::imshow("CB", cb); cv::waitKey();
+                               
+        vector<Point2f> corners_found;
+        int flags = i % 8; // need to check branches for all flags
+        bool found = findChessboardCorners(cb, cbg.cornersSize(), corners_found, flags);
+        if (!found)        
+        {            
+            ts->printf( cvtest::TS::LOG, "Chess board corners not found\n" );
+            ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+            res = false;
+            continue;          
+        }
+
+        double err = calcErrorMinError(cbg.cornersSize(), corners_found, corners_generated);            
+        if( err > rough_success_error_level )
+        {
+            ts->printf( cvtest::TS::LOG, "bad accuracy of corner guesses" );
+            ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
+            res = false;
+            continue;
+        }        
+    }  
+
+    /* ***** negative ***** */
+    {        
+        vector<Point2f> corners_found;
+        bool found = findChessboardCorners(bg, Size(8, 7), corners_found);
+        if (found)
+            res = false;
+
+        ChessBoardGenerator cbg(Size(8, 7));
+
+        vector<Point2f> cg;
+        Mat cb = cbg(bg, camMat, distCoeffs, cg);        
+
+        found = findChessboardCorners(cb, Size(3, 4), corners_found);
+        if (found)
+            res = false;        
+
+        Point2f c = std::accumulate(cg.begin(), cg.end(), Point2f(), plus<Point2f>()) * (1.f/cg.size());
+
+        Mat_<double> aff(2, 3);
+        aff << 1.0, 0.0, -(double)c.x, 0.0, 1.0, 0.0;
+        Mat sh;
+        warpAffine(cb, sh, aff, cb.size());        
+
+        found = findChessboardCorners(sh, cbg.cornersSize(), corners_found);
+        if (found)
+            res = false;        
+        
+        vector< vector<Point> > cnts(1);
+        vector<Point>& cnt = cnts[0];
+        cnt.push_back(cg[  0]); cnt.push_back(cg[0+2]); 
+        cnt.push_back(cg[7+0]); cnt.push_back(cg[7+2]);                
+        cv::drawContours(cb, cnts, -1, Scalar::all(128), CV_FILLED);
+
+        found = findChessboardCorners(cb, cbg.cornersSize(), corners_found);
+        if (found)
+            res = false;
+
+        cv::drawChessboardCorners(cb, cbg.cornersSize(), Mat(corners_found), found);
+    }
+    
+    return res;
+}
+
+TEST(Calib3d_ChessboardDetector, accuracy) {  CV_ChessboardDetectorTest test( CHESSBOARD ); test.safe_run(); }
+TEST(Calib3d_CirclesPatternDetector, accuracy) { CV_ChessboardDetectorTest test( CIRCLES_GRID ); test.safe_run(); }
+
+/* End of file. */

modules/calib3d/test/test_chesscorners_badarg.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include "test_chessboardgenerator.hpp"
+
+#include <limits>
+
+using namespace std;
+using namespace cv;
+
+class CV_ChessboardDetectorBadArgTest : public cvtest::BadArgTest
+{
+public:
+    CV_ChessboardDetectorBadArgTest();
+protected:
+    void run(int);
+    bool checkByGenerator();
+
+    bool cpp;
+
+    /* cpp interface */
+    Mat img;
+    Size pattern_size;    
+    int flags;
+    vector<Point2f> corners;
+   
+    /* c interface */
+    CvMat arr;
+    CvPoint2D32f* out_corners;
+    int* out_corner_count;
+
+
+    /* c interface draw  corners */
+    bool drawCorners;
+    CvMat drawCorImg;
+    bool was_found;
+    
+    void run_func() 
+    { 
+        if (cpp)
+            findChessboardCorners(img, pattern_size, corners, flags); 
+        else
+            if (!drawCorners)
+                cvFindChessboardCorners( &arr, pattern_size, out_corners, out_corner_count, flags );
+            else
+                cvDrawChessboardCorners( &drawCorImg, pattern_size, 
+                    (CvPoint2D32f*)&corners[0], (int)corners.size(), was_found);
+    }
+};
+
+CV_ChessboardDetectorBadArgTest::CV_ChessboardDetectorBadArgTest() {}
+
+/* ///////////////////// chess_corner_test ///////////////////////// */
+void CV_ChessboardDetectorBadArgTest::run( int /*start_from */)
+{
+    Mat bg(800, 600, CV_8U, Scalar(0));
+    Mat_<float> camMat(3, 3);
+    camMat << 300.f, 0.f, bg.cols/2.f, 0, 300.f, bg.rows/2.f, 0.f, 0.f, 1.f;    
+    Mat_<float> distCoeffs(1, 5);
+    distCoeffs << 1.2f, 0.2f, 0.f, 0.f, 0.f;
+
+    ChessBoardGenerator cbg(Size(8,6));
+    vector<Point2f> exp_corn;    
+    Mat cb = cbg(bg, camMat, distCoeffs, exp_corn);
+    
+    /* /*//*/ */
+    int errors = 0;
+    flags = CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE;
+    cpp = true;
+
+    img = cb.clone();
+    pattern_size = Size(2,2);
+    errors += run_test_case( CV_StsOutOfRange, "Invlid pattern size" );        
+    
+    pattern_size = cbg.cornersSize();    
+    cb.convertTo(img, CV_32F);
+    errors += run_test_case( CV_StsUnsupportedFormat, "Not 8-bit image" );
+
+    cv::merge(vector<Mat>(2, cb), img);
+    errors += run_test_case( CV_StsUnsupportedFormat, "2 channel image" );
+
+    cpp = false;
+    drawCorners = false;
+
+    img = cb.clone();
+    arr = img; 
+    out_corner_count = 0;
+    out_corners = 0;    
+    errors += run_test_case( CV_StsNullPtr, "Null pointer to corners" );
+
+    drawCorners = true;
+    Mat cvdrawCornImg(img.size(), CV_8UC2);
+    drawCorImg = cvdrawCornImg;
+    was_found = true;
+    errors += run_test_case( CV_StsUnsupportedFormat, "2 channel image" );
+            
+
+    if (errors)
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+    else
+        ts->set_failed_test_info(cvtest::TS::OK);
+}
+
+TEST(Calib3d_ChessboardDetector, badarg) { CV_ChessboardDetectorBadArgTest test; test.safe_run(); }
+
+/* End of file. */

modules/calib3d/test/test_chesscorners_timing.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+class CV_ChessboardDetectorTimingTest : public cvtest::BaseTest
+{
+public:
+    CV_ChessboardDetectorTimingTest();
+protected:
+    void run(int);
+};
+
+
+CV_ChessboardDetectorTimingTest::CV_ChessboardDetectorTimingTest()
+{
+}
+
+/* ///////////////////// chess_corner_test ///////////////////////// */
+void CV_ChessboardDetectorTimingTest::run( int start_from )
+{
+    int code = cvtest::TS::OK;
+
+    /* test parameters */
+    char   filepath[1000];
+    char   filename[1000];
+
+    CvMat*  _v = 0;
+    CvPoint2D32f* v;
+
+    IplImage* img = 0;
+    IplImage* gray = 0;
+    IplImage* thresh = 0;
+
+    int  idx, max_idx;
+    int  progress = 0;
+
+    sprintf( filepath, "%scameracalibration/", ts->get_data_path().c_str() );
+    sprintf( filename, "%schessboard_timing_list.dat", filepath );
+    printf("Reading file %s\n", filename);
+    CvFileStorage* fs = cvOpenFileStorage( filename, 0, CV_STORAGE_READ );
+    CvFileNode* board_list = fs ? cvGetFileNodeByName( fs, 0, "boards" ) : 0;
+
+    if( !fs || !board_list || !CV_NODE_IS_SEQ(board_list->tag) ||
+        board_list->data.seq->total % 4 != 0 )
+    {
+        ts->printf( cvtest::TS::LOG, "chessboard_timing_list.dat can not be readed or is not valid" );
+        code = cvtest::TS::FAIL_MISSING_TEST_DATA;
+        goto _exit_;
+    }
+
+    max_idx = board_list->data.seq->total/4;
+
+    for( idx = start_from; idx < max_idx; idx++ )
+    {
+        int count0 = -1;
+        int count = 0;
+        CvSize pattern_size;
+        int result, result1 = 0;
+
+        const char* imgname = cvReadString((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4), "dummy.txt");
+        int is_chessboard = cvReadInt((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4+1), 0);
+        pattern_size.width = cvReadInt((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4 + 2), -1);
+        pattern_size.height = cvReadInt((CvFileNode*)cvGetSeqElem(board_list->data.seq,idx*4 + 3), -1);
+        
+        ts->update_context( this, idx-1, true );
+
+        /* read the image */
+        sprintf( filename, "%s%s", filepath, imgname );
+    
+        img = cvLoadImage( filename );
+        
+        if( !img )
+        {
+            ts->printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", filename );
+            if( max_idx == 1 )
+            {
+                code = cvtest::TS::FAIL_MISSING_TEST_DATA;
+                goto _exit_;
+            }
+            continue;
+        }
+
+        ts->printf(cvtest::TS::LOG, "%s: chessboard %d:\n", imgname, is_chessboard);
+
+        gray = cvCreateImage( cvSize( img->width, img->height ), IPL_DEPTH_8U, 1 );
+        thresh = cvCreateImage( cvSize( img->width, img->height ), IPL_DEPTH_8U, 1 );
+        cvCvtColor( img, gray, CV_BGR2GRAY );
+ 
+
+        count0 = pattern_size.width*pattern_size.height;
+
+        /* allocate additional buffers */
+        _v = cvCreateMat(1, count0, CV_32FC2);
+        count = count0;
+
+        v = (CvPoint2D32f*)_v->data.fl;
+
+        int64 _time0 = cvGetTickCount();
+        result = cvCheckChessboard(gray, pattern_size);
+        int64 _time01 = cvGetTickCount();
+        
+        OPENCV_CALL( result1 = cvFindChessboardCorners(
+                 gray, pattern_size, v, &count, 15 ));
+        int64 _time1 = cvGetTickCount();
+
+        if( result != is_chessboard )
+        {
+            ts->printf( cvtest::TS::LOG, "Error: chessboard was %sdetected in the image %s\n", 
+                       result ? "" : "not ", imgname );
+            code = cvtest::TS::FAIL_INVALID_OUTPUT;
+            goto _exit_;
+        }
+        if(result != result1)
+        {
+            ts->printf( cvtest::TS::LOG, "Warning: results differ cvCheckChessboard %d, cvFindChessboardCorners %d\n", 
+                       result, result1);
+        }
+                
+        int num_pixels = gray->width*gray->height;
+        float check_chessboard_time = float(_time01 - _time0)/(float)cvGetTickFrequency(); // in us
+        ts->printf(cvtest::TS::LOG, "    cvCheckChessboard time s: %f, us per pixel: %f\n", 
+                   check_chessboard_time*1e-6, check_chessboard_time/num_pixels);
+        
+        float find_chessboard_time = float(_time1 - _time01)/(float)cvGetTickFrequency();
+        ts->printf(cvtest::TS::LOG, "    cvFindChessboard time s: %f, us per pixel: %f\n",
+                   find_chessboard_time*1e-6, find_chessboard_time/num_pixels);
+
+        cvReleaseMat( &_v );
+        cvReleaseImage( &img );
+        cvReleaseImage( &gray );
+        cvReleaseImage( &thresh );
+        progress = update_progress( progress, idx-1, max_idx, 0 );
+    }
+
+_exit_:
+
+    /* release occupied memory */
+    cvReleaseMat( &_v );
+    cvReleaseFileStorage( &fs );
+    cvReleaseImage( &img );
+    cvReleaseImage( &gray );
+    cvReleaseImage( &thresh );
+
+    if( code < 0 )
+        ts->set_failed_test_info( code );
+}
+
+TEST(Calib3d_ChessboardDetector, timing) { CV_ChessboardDetectorTimingTest test; test.safe_run(); }
+
+/* End of file. */

modules/calib3d/test/test_compose_rt.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+using namespace cv;
+using namespace std;
+
+class Differential
+{
+public:                
+    typedef Mat_<double> mat_t;    
+
+    Differential(double eps_, const mat_t& rv1_, const mat_t& tv1_, const mat_t& rv2_, const mat_t& tv2_) 
+        : rv1(rv1_), tv1(tv1_), rv2(rv2_), tv2(tv2_), eps(eps_), ev(3, 1) {}
+
+    void dRv1(mat_t& dr3_dr1, mat_t& dt3_dr1)
+    {                
+        dr3_dr1.create(3, 3);     dt3_dr1.create(3, 3);
+                    
+        for(int i = 0; i < 3; ++i) 
+        {
+            ev.setTo(Scalar(0));    ev(i, 0) = eps;                        
+                        
+            composeRT( rv1 + ev, tv1, rv2, tv2, rv3_p, tv3_p);            
+            composeRT( rv1 - ev, tv1, rv2, tv2, rv3_m, tv3_m);
+
+            dr3_dr1.col(i) = rv3_p - rv3_m;            
+            dt3_dr1.col(i) = tv3_p - tv3_m;                         
+        }
+        dr3_dr1 /= 2 * eps;       dt3_dr1 /= 2 * eps;
+    }
+
+    void dRv2(mat_t& dr3_dr2, mat_t& dt3_dr2)
+    {                
+        dr3_dr2.create(3, 3);     dt3_dr2.create(3, 3);
+                    
+        for(int i = 0; i < 3; ++i) 
+        {
+            ev.setTo(Scalar(0));    ev(i, 0) = eps;                        
+                        
+            composeRT( rv1, tv1, rv2 + ev, tv2, rv3_p, tv3_p);            
+            composeRT( rv1, tv1, rv2 - ev, tv2, rv3_m, tv3_m);
+
+            dr3_dr2.col(i) = rv3_p - rv3_m;            
+            dt3_dr2.col(i) = tv3_p - tv3_m;                         
+        }
+        dr3_dr2 /= 2 * eps;       dt3_dr2 /= 2 * eps;
+    }
+
+    void dTv1(mat_t& drt3_dt1, mat_t& dt3_dt1)
+    {                
+        drt3_dt1.create(3, 3);     dt3_dt1.create(3, 3);
+                    
+        for(int i = 0; i < 3; ++i) 
+        {
+            ev.setTo(Scalar(0));    ev(i, 0) = eps;                        
+                        
+            composeRT( rv1, tv1 + ev, rv2, tv2, rv3_p, tv3_p);            
+            composeRT( rv1, tv1 - ev, rv2, tv2, rv3_m, tv3_m);
+
+            drt3_dt1.col(i) = rv3_p - rv3_m;            
+            dt3_dt1.col(i) = tv3_p - tv3_m;                         
+        }
+        drt3_dt1 /= 2 * eps;       dt3_dt1 /= 2 * eps;
+    }
+
+    void dTv2(mat_t& dr3_dt2, mat_t& dt3_dt2)
+    {                
+        dr3_dt2.create(3, 3);     dt3_dt2.create(3, 3);
+                    
+        for(int i = 0; i < 3; ++i) 
+        {
+            ev.setTo(Scalar(0));    ev(i, 0) = eps;                        
+                        
+            composeRT( rv1, tv1, rv2, tv2 + ev, rv3_p, tv3_p);            
+            composeRT( rv1, tv1, rv2, tv2 - ev, rv3_m, tv3_m);
+
+            dr3_dt2.col(i) = rv3_p - rv3_m;            
+            dt3_dt2.col(i) = tv3_p - tv3_m;                         
+        }
+        dr3_dt2 /= 2 * eps;       dt3_dt2 /= 2 * eps;
+    }
+     
+private:
+    const mat_t& rv1, tv1, rv2, tv2;
+    double eps;
+    Mat_<double> ev;
+    
+    Differential& operator=(const Differential&);
+    Mat rv3_m, tv3_m, rv3_p, tv3_p;          
+};
+
+class CV_composeRT_Test : public cvtest::BaseTest
+{
+public:
+    CV_composeRT_Test() {}
+    ~CV_composeRT_Test() {}
+protected: 
+    
+    void run(int)
+    {
+        cvtest::TS& ts = *this->ts;
+        ts.set_failed_test_info(cvtest::TS::OK);
+        
+        Mat_<double> rvec1(3, 1), tvec1(3, 1), rvec2(3, 1), tvec2(3, 1); 
+
+        randu(rvec1, Scalar(0), Scalar(6.29));
+        randu(rvec2, Scalar(0), Scalar(6.29));
+
+        randu(tvec1, Scalar(-2), Scalar(2));
+        randu(tvec2, Scalar(-2), Scalar(2));
+        
+        Mat rvec3, tvec3;
+        composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3);
+        
+        Mat rvec3_exp, tvec3_exp;
+
+        Mat rmat1, rmat2;
+        Rodrigues(rvec1, rmat1);
+        Rodrigues(rvec2, rmat2);
+        Rodrigues(rmat2 * rmat1, rvec3_exp);
+
+        tvec3_exp = rmat2 * tvec1 + tvec2;
+
+        const double thres = 1e-5;
+        if (norm(rvec3_exp, rvec3) > thres ||  norm(tvec3_exp, tvec3) > thres)
+            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+
+        const double eps = 1e-3;
+        Differential diff(eps, rvec1, tvec1, rvec2, tvec2);
+     
+        Mat dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2;
+
+        composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, 
+            dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2);
+        
+        Mat_<double> dr3_dr1, dt3_dr1;
+           diff.dRv1(dr3_dr1, dt3_dr1);
+
+        if (norm(dr3_dr1, dr3dr1) > thres || norm(dt3_dr1, dt3dr1) > thres)
+        {            
+            ts.printf( cvtest::TS::LOG, "Invalid derivates by r1\n" );
+            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        }
+
+        Mat_<double> dr3_dr2, dt3_dr2;
+           diff.dRv2(dr3_dr2, dt3_dr2);
+
+        if (norm(dr3_dr2, dr3dr2) > thres || norm(dt3_dr2, dt3dr2) > thres)
+        {            
+            ts.printf( cvtest::TS::LOG, "Invalid derivates by r2\n" );
+            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        }
+
+        Mat_<double> dr3_dt1, dt3_dt1;
+           diff.dTv1(dr3_dt1, dt3_dt1);
+
+        if (norm(dr3_dt1, dr3dt1) > thres || norm(dt3_dt1, dt3dt1) > thres)
+        {            
+            ts.printf( cvtest::TS::LOG, "Invalid derivates by t1\n" );
+            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        }
+        
+        Mat_<double> dr3_dt2, dt3_dt2;
+           diff.dTv2(dr3_dt2, dt3_dt2);
+
+        if (norm(dr3_dt2, dr3dt2) > thres || norm(dt3_dt2, dt3dt2) > thres)
+        {            
+            ts.printf( cvtest::TS::LOG, "Invalid derivates by t2\n" );
+            ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+        }
+    }       
+};   
+    
+TEST(Calib3d_ComposeRT, accuracy) { CV_composeRT_Test test; test.safe_run(); }
+

modules/calib3d/test/test_cornerssubpix.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+ //
+ //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+ //
+ //  By downloading, copying, installing or using the software you agree to this license.
+ //  If you do not agree to this license, do not download, install,
+ //  copy or use the software.
+ //
+ //
+ //                        Intel License Agreement
+ //                For Open Source Computer Vision Library
+ //
+ // Copyright (C) 2000, Intel Corporation, all rights reserved.
+ // Third party copyrights are property of their respective owners.
+ //
+ // Redistribution and use in source and binary forms, with or without modification,
+ // are permitted provided that the following conditions are met:
+ //
+ //   * Redistribution's of source code must retain the above copyright notice,
+ //     this list of conditions and the following disclaimer.
+ //
+ //   * Redistribution's in binary form must reproduce the above copyright notice,
+ //     this list of conditions and the following disclaimer in the documentation
+ //     and/or other materials provided with the distribution.
+ //
+ //   * The name of Intel Corporation may not be used to endorse or promote products
+ //     derived from this software without specific prior written permission.
+ //
+ // This software is provided by the copyright holders and contributors "as is" and
+ // any express or implied warranties, including, but not limited to, the implied
+ // warranties of merchantability and fitness for a particular purpose are disclaimed.
+ // In no event shall the Intel Corporation or contributors be liable for any direct,
+ // indirect, incidental, special, exemplary, or consequential damages
+ // (including, but not limited to, procurement of substitute goods or services;
+ // loss of use, data, or profits; or business interruption) however caused
+ // and on any theory of liability, whether in contract, strict liability,
+ // or tort (including negligence or otherwise) arising in any way out of
+ // the use of this software, even if advised of the possibility of such damage.
+ //
+ //M*/
+
+#include "test_precomp.hpp"
+#include <limits>
+#include "test_chessboardgenerator.hpp"
+
+using namespace cv;
+
+class CV_ChessboardSubpixelTest : public cvtest::BaseTest
+{
+public:
+    CV_ChessboardSubpixelTest();
+
+protected:
+    Mat intrinsic_matrix_;
+    Mat distortion_coeffs_;
+    Size image_size_;
+    
+    void run(int);
+    void generateIntrinsicParams();
+};
+
+
+int calcDistance(const vector<Point2f>& set1, const vector<Point2f>& set2, double& mean_dist)
+{
+    if(set1.size() != set2.size())
+    {
+        return 0;
+    }
+    
+    std::vector<int> indices;
+    double sum_dist = 0.0;
+    for(size_t i = 0; i < set1.size(); i++)
+    {
+        double min_dist = std::numeric_limits<double>::max();
+        int min_idx = -1;
+        
+        for(int j = 0; j < (int)set2.size(); j++)
+        {
+            double dist = norm(set1[i] - set2[j]);
+            if(dist < min_dist)
+            {
+                min_idx = j;
+                min_dist = dist;
+            }
+        }
+        
+        // check validity of min_idx
+        if(min_idx == -1)
+        {
+            return 0;
+        }
+        std::vector<int>::iterator it = std::find(indices.begin(), indices.end(), min_idx);
+        if(it != indices.end()) 
+        {
+            // there are two points in set1 corresponding to the same point in set2
+            return 0;
+        }
+        indices.push_back(min_idx);
+        
+//        printf("dist %d = %f\n", (int)i, min_dist);
+        
+        sum_dist += min_dist*min_dist;
+    }
+    
+    mean_dist = sqrt(sum_dist/set1.size());
+//    printf("sum_dist = %f, set1.size() = %d, mean_dist = %f\n", sum_dist, (int)set1.size(), mean_dist);
+    
+    return 1;
+}
+
+CV_ChessboardSubpixelTest::CV_ChessboardSubpixelTest() :
+    intrinsic_matrix_(Size(3, 3), CV_64FC1), distortion_coeffs_(Size(1, 4), CV_64FC1), 
+    image_size_(640, 480)
+{
+}
+
+/* ///////////////////// chess_corner_test ///////////////////////// */
+void CV_ChessboardSubpixelTest::run( int )
+{
+    int code = cvtest::TS::OK;
+    int  progress = 0;
+
+    RNG& rng = ts->get_rng();
+    
+    const int runs_count = 20;
+    const int max_pattern_size = 8;
+    const int min_pattern_size = 5;
+    Mat bg(image_size_, CV_8UC1);
+    bg = Scalar(0);
+    
+    double sum_dist = 0.0;
+    int count = 0;
+    for(int i = 0; i < runs_count; i++)
+    {
+        const int pattern_width = min_pattern_size + cvtest::randInt(rng) % (max_pattern_size - min_pattern_size);
+        const int pattern_height = min_pattern_size + cvtest::randInt(rng) % (max_pattern_size - min_pattern_size);
+        Size pattern_size;
+        if(pattern_width > pattern_height)
+        {
+            pattern_size = Size(pattern_height, pattern_width);
+        }
+        else
+        {
+            pattern_size = Size(pattern_width, pattern_height);
+        }
+        ChessBoardGenerator gen_chessboard(Size(pattern_size.width + 1, pattern_size.height + 1));
+        
+        // generates intrinsic camera and distortion matrices
+        generateIntrinsicParams();
+        
+        vector<Point2f> corners;
+        Mat chessboard_image = gen_chessboard(bg, intrinsic_matrix_, distortion_coeffs_, corners); 
+        
+        vector<Point2f> test_corners;
+        bool result = findChessboardCorners(chessboard_image, pattern_size, test_corners, 15);
+        if(!result)
+        {
+#if 0
+            ts->printf(cvtest::TS::LOG, "Warning: chessboard was not detected! Writing image to test.jpg\n");
+            ts->printf(cvtest::TS::LOG, "Size = %d, %d\n", pattern_size.width, pattern_size.height);
+            ts->printf(cvtest::TS::LOG, "Intrinsic params: fx = %f, fy = %f, cx = %f, cy = %f\n", 
+                       intrinsic_matrix_.at<double>(0, 0), intrinsic_matrix_.at<double>(1, 1), 
+                       intrinsic_matrix_.at<double>(0, 2), intrinsic_matrix_.at<double>(1, 2));
+            ts->printf(cvtest::TS::LOG, "Distortion matrix: %f, %f, %f, %f, %f\n", 
+                       distortion_coeffs_.at<double>(0, 0), distortion_coeffs_.at<double>(0, 1),
+                       distortion_coeffs_.at<double>(0, 2), distortion_coeffs_.at<double>(0, 3), 
+                       distortion_coeffs_.at<double>(0, 4));
+            
+            imwrite("test.jpg", chessboard_image);
+#endif
+            continue;
+        }
+        
+        double dist1 = 0.0;
+        int ret = calcDistance(corners, test_corners, dist1);
+        if(ret == 0)
+        {
+            ts->printf(cvtest::TS::LOG, "findChessboardCorners returns invalid corner coordinates!\n");
+            code = cvtest::TS::FAIL_INVALID_OUTPUT;
+            break;            
+        }
+        
+        IplImage chessboard_image_header = chessboard_image;
+        cvFindCornerSubPix(&chessboard_image_header, (CvPoint2D32f*)&test_corners[0], 
+            (int)test_corners.size(), cvSize(3, 3), cvSize(1, 1), cvTermCriteria(CV_TERMCRIT_EPS|CV_TERMCRIT_ITER,300,0.1));
+        find4QuadCornerSubpix(chessboard_image, test_corners, Size(5, 5));
+        
+        double dist2 = 0.0;
+        ret = calcDistance(corners, test_corners, dist2);
+        if(ret == 0)
+        {
+            ts->printf(cvtest::TS::LOG, "findCornerSubpix returns invalid corner coordinates!\n");
+            code = cvtest::TS::FAIL_INVALID_OUTPUT;
+            break;            
+        }
+        
+        ts->printf(cvtest::TS::LOG, "Error after findChessboardCorners: %f, after findCornerSubPix: %f\n", 
+                   dist1, dist2);
+        sum_dist += dist2;
+        count++;
+        
+        const double max_reduce_factor = 0.8;
+        if(dist1 < dist2*max_reduce_factor)
+        {
+            ts->printf(cvtest::TS::LOG, "findCornerSubPix increases average error!\n");
+            code = cvtest::TS::FAIL_INVALID_OUTPUT;
+            break;
+        }
+        
+        progress = update_progress( progress, i-1, runs_count, 0 );
+    }
+    sum_dist /= count;
+    ts->printf(cvtest::TS::LOG, "Average error after findCornerSubpix: %f\n", sum_dist); 
+        
+    if( code < 0 )
+        ts->set_failed_test_info( code );
+}
+                                        
+void CV_ChessboardSubpixelTest::generateIntrinsicParams()
+{
+    RNG& rng = ts->get_rng();
+    const double max_focus_length = 1000.0;
+    const double max_focus_diff = 5.0;
+    
+    double fx = cvtest::randReal(rng)*max_focus_length;
+    double fy = fx + cvtest::randReal(rng)*max_focus_diff;
+    double cx = image_size_.width/2;
+    double cy = image_size_.height/2;
+    
+    double k1 = 0.5*cvtest::randReal(rng);
+    double k2 = 0.05*cvtest::randReal(rng);
+    double p1 = 0.05*cvtest::randReal(rng);
+    double p2 = 0.05*cvtest::randReal(rng);
+    double k3 = 0.0;
+    
+    intrinsic_matrix_ = (Mat_<double>(3, 3) << fx, 0.0, cx, 0.0, fy, cy, 0.0, 0.0, 1.0);
+    distortion_coeffs_ = (Mat_<double>(1, 5) << k1, k2, p1, p2, k3);
+}
+
+TEST(Calib3d_ChessboardSubPixDetector, accuracy) { CV_ChessboardSubpixelTest test; test.safe_run(); }
+
+/* End of file. */

modules/calib3d/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

modules/calib3d/test/test_precomp.cpp

+#include "test_precomp.hpp"

modules/calib3d/test/test_precomp.hpp

+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts/ts.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <iostream>
+
+namespace cvtest
+{
+    void Rodrigues(const Mat& src, Mat& dst, Mat* jac=0);
+}
+
+#endif
+

modules/contrib/include/opencv2/contrib/contrib.hpp

@@ -549,8 +549,6 @@ namespace cv
     };
     
     
-    CV_EXPORTS bool find4QuadCornerSubpix(const Mat& img, std::vector<Point2f>& corners, Size region_size);
-    
     CV_EXPORTS int chamerMatching( Mat& img, Mat& templ,
                                    vector<vector<Point> >& results, vector<float>& cost,
                                    double templScale=1, int maxMatches = 20,

modules/core/include/opencv2/core/internal.hpp

@@ -288,14 +288,6 @@ CV_INLINE IppiSize ippiSize(int width, int height)
 /* ! DO NOT make it an inline function */
 #define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN )
 
-#if defined _MSC_VER || defined __BORLANDC__
-    #define CV_BIG_INT(n)   n##I64
-    #define CV_BIG_UINT(n)  n##UI64
-#else
-    #define CV_BIG_INT(n)   n##LL
-    #define CV_BIG_UINT(n)  n##ULL
-#endif
-
 #ifndef CV_IMPL
 #define CV_IMPL CV_EXTERN_C
 #endif

modules/core/include/opencv2/core/types_c.h

@@ -145,9 +145,13 @@
 #if defined _MSC_VER || defined __BORLANDC__
 typedef __int64 int64;
 typedef unsigned __int64 uint64;
+#define CV_BIG_INT(n)   n##I64
+#define CV_BIG_UINT(n)  n##UI64
 #else
 typedef int64_t int64;
 typedef uint64_t uint64;
+#define CV_BIG_INT(n)   n##LL
+#define CV_BIG_UINT(n)  n##ULL
 #endif
 
 #ifndef HAVE_IPL

modules/core/src/arithm.cpp

@@ -1158,10 +1158,10 @@ div_( const Mat& srcmat1, const Mat& srcmat2, Mat& dstmat, double scale )
                 b *= d;
                 a *= d;
 
-                T z0 = saturate_cast<T>(src2[i+1] * src1[i] * b);
-                T z1 = saturate_cast<T>(src2[i] * src1[i+1] * b);
-                T z2 = saturate_cast<T>(src2[i+3] * src1[i+2] * a);
-                T z3 = saturate_cast<T>(src2[i+2] * src1[i+3] * a);
+                T z0 = saturate_cast<T>(src2[i+1] * ((double)src1[i] * b));
+                T z1 = saturate_cast<T>(src2[i] * ((double)src1[i+1] * b));
+                T z2 = saturate_cast<T>(src2[i+3] * ((double)src1[i+2] * a));
+                T z3 = saturate_cast<T>(src2[i+2] * ((double)src1[i+3] * a));
 
                 dst[i] = z0; dst[i+1] = z1;
                 dst[i+2] = z2; dst[i+3] = z3;
@@ -1193,7 +1193,7 @@ void divide(const Mat& src1, const Mat& src2, Mat& dst, double scale)
     };
 
     MulDivFunc func = tab[src1.depth()];
-    CV_Assert( src1.size() == src2.size() && src1.type() == src2.type() && func != 0 );
+    CV_Assert( src1.type() == src2.type() && func != 0 );
 
     if( src1.dims > 2 || src2.dims > 2 )
     {
@@ -1446,7 +1446,7 @@ void addWeighted( const Mat& src1, double alpha, const Mat& src2,
         addWeighted_<ushort, float>,
         addWeighted_<short, float>,
         addWeighted_<int, double>,
-        addWeighted_<float, float>,
+        addWeighted_<float, double>,
         addWeighted_<double, double>,
         0
     };
@@ -1952,7 +1952,7 @@ void compare( const Mat& src1, double value, Mat& dst, int cmpOp )
         {
             func( it.planes[0], it.planes[1], value );
             if( invflag )
-                bitwise_not(it.planes[2], it.planes[2]);
+                bitwise_not(it.planes[1], it.planes[1]);
         }
         return;
     }

modules/core/src/convert.cpp

@@ -619,7 +619,7 @@ static const int FBITS = 15;
 typedef void (*CvtFunc)( const Mat& src, Mat& dst );
 typedef void (*CvtScaleFunc)( const Mat& src, Mat& dst, double scale, double shift );
 
-void convertScaleAbs( const Mat& src, Mat& dst, double scale, double shift )
+void convertScaleAbs( const Mat& src0, Mat& dst, double scale, double shift )
 {
     static CvtScaleFunc tab[] =
     {
@@ -632,15 +632,27 @@ void convertScaleAbs( const Mat& src, Mat& dst, double scale, double shift )
         cvtScale_<double, OpCvtAbs<double, uchar> >, 0
     };
 
-    Mat src0 = src;
-    dst.create( src.size(), CV_8UC(src.channels()) );
-    CvtScaleFunc func = tab[src0.depth()];
+    Mat src = src0;
+    dst.create( src.dims, src.size, CV_8UC(src.channels()) );
+    CvtScaleFunc func = tab[src.depth()];
     CV_Assert( func != 0 );
-    func( src0, dst, scale, shift );
+    
+    if( src.dims <= 2 )
+    {
+        func( src, dst, scale, shift );
+    }
+    else
+    {
+        const Mat* arrays[] = {&src, &dst, 0};
+        Mat planes[2];
+        NAryMatIterator it(arrays, planes);
+        
+        for( int i = 0; i < it.nplanes; i++, ++it )
+            func(it.planes[0], it.planes[1], scale, shift);
+    }
 }
 
 
-
 void Mat::convertTo(Mat& dst, int _type, double alpha, double beta) const
 {
     static CvtFunc tab[8][8] =
@@ -699,7 +711,7 @@ void Mat::convertTo(Mat& dst, int _type, double alpha, double beta) const
             cvtScaleInt_<ushort, OpCvtFixPt<int, ushort, FBITS>, OpCvt<float, ushort>, 0>,
             cvtScaleInt_<ushort, OpCvtFixPt<int, short, FBITS>, OpCvt<float, short>, 0>,
             cvtScale_<ushort, OpCvt<double, int> >,
-            cvtScale_<ushort, OpCvt<float, float> >,
+            cvtScale_<ushort, OpCvt<double, float> >,
             cvtScale_<ushort, OpCvt<double, double> >, 0,
         },
 
@@ -709,7 +721,7 @@ void Mat::convertTo(Mat& dst, int _type, double alpha, double beta) const
             cvtScaleInt_<short, OpCvtFixPt<int, ushort, FBITS>, OpCvt<float, ushort>, 1<<15>,
             cvtScaleInt_<short, OpCvtFixPt<int, short, FBITS>, OpCvt<float, short>, 1<<15>,
             cvtScale_<short, OpCvt<double, int> >,
-            cvtScale_<short, OpCvt<float, float> >,
+            cvtScale_<short, OpCvt<double, float> >,
             cvtScale_<short, OpCvt<double, double> >, 0,
         },
 
@@ -719,7 +731,7 @@ void Mat::convertTo(Mat& dst, int _type, double alpha, double beta) const
             cvtScale_<int, OpCvt<double, ushort> >,
             cvtScale_<int, OpCvt<double, short> >,
             cvtScale_<int, OpCvt<double, int> >,
-            cvtScale_<int, OpCvt<float, float> >,
+            cvtScale_<int, OpCvt<double, float> >,
             cvtScale_<int, OpCvt<double, double> >, 0,
         },
 

modules/core/test/test_main.cpp

 #include "test_precomp.hpp"
-#include "opencv2/gtest/gtest_main.hpp"
+
+CV_TEST_MAIN("cv")

modules/core/test/test_precomp.hpp

-#include "opencv2/gtest/gtestcv.hpp"
-#include "opencv2/core/core.hpp"
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts/ts.hpp"
+#include "opencv2/core/core_c.h"
+#include <iostream>
+
+#endif

modules/features2d/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

modules/features2d/test/test_precomp.cpp

+#include "test_precomp.hpp"

modules/gtest/CMakeLists.txt

-if(BUILD_SHARED_LIBS)
-add_definitions(-DGTEST_CREATE_SHARED_LIBRARY=1)
-endif()
-define_opencv_module(gtest opencv_core)