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

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_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_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)