completely new C++ persistence implementation (opencv#13011)

* integrated the new C++ persistence; removed old persistence; most of OpenCV compiles fine! the tests have not been run yet

* fixed multiple bugs in the new C++ persistence

* fixed raw size of the parsed empty sequences

* [temporarily] excluded obsolete applications traincascade and createsamples from build

* fixed several compiler warnings and multiple test failures

* undo changes in cocoa window rendering (that was fixed in another PR)

* fixed more compile warnings and the remaining test failures (hopefully)

* trying to fix the last little warning

Author: vpisarev

apps/CMakeLists.txt

@@ -49,8 +49,8 @@ macro(ocv_add_app directory)
   endif()
 endmacro()
 
-ocv_add_app(traincascade)
-ocv_add_app(createsamples)
+#ocv_add_app(traincascade)
+#ocv_add_app(createsamples)
 ocv_add_app(annotation)
 ocv_add_app(visualisation)
 ocv_add_app(interactive-calibration)

apps/traincascade/old_ml.hpp

@@ -144,8 +144,8 @@ class CvStatModel
     CV_WRAP virtual void save( const char* filename, const char* name=0 ) const;
     CV_WRAP virtual void load( const char* filename, const char* name=0 );
 
-    virtual void write( CvFileStorage* storage, const char* name ) const;
-    virtual void read( CvFileStorage* storage, CvFileNode* node );
+    virtual void write( cv::FileStorage& storage, const char* name ) const;
+    virtual void read( const cv::FileNode& node );
 
 protected:
     const char* default_model_name;
@@ -210,8 +210,8 @@ class CvNormalBayesClassifier : public CvStatModel
                        bool update=false );
     CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0, CV_OUT cv::Mat* results_prob=0 ) const;
 
-    virtual void write( CvFileStorage* storage, const char* name ) const;
-    virtual void read( CvFileStorage* storage, CvFileNode* node );
+    virtual void write( cv::FileStorage& storage, const char* name ) const;
+    virtual void read( const cv::FileNode& node );
 
 protected:
     int     var_count, var_all;
@@ -521,8 +521,8 @@ class CvSVM : public CvStatModel
 
     static CvParamGrid get_default_grid( int param_id );
 
-    virtual void write( CvFileStorage* storage, const char* name ) const;
-    virtual void read( CvFileStorage* storage, CvFileNode* node );
+    virtual void write( cv::FileStorage& storage, const char* name ) const;
+    virtual void read( const cv::FileNode& node );
     CV_WRAP int get_var_count() const { return var_idx ? var_idx->cols : var_all; }
 
 protected:
@@ -538,8 +538,8 @@ class CvSVM : public CvStatModel
 
     virtual float predict( const float* row_sample, int row_len, bool returnDFVal=false ) const;
 
-    virtual void write_params( CvFileStorage* fs ) const;
-    virtual void read_params( CvFileStorage* fs, CvFileNode* node );
+    virtual void write_params( cv::FileStorage& fs ) const;
+    virtual void read_params( const cv::FileNode& node );
 
     void optimize_linear_svm();
 
@@ -673,8 +673,8 @@ struct CvDTreeTrainData
 
     virtual CvDTreeNode* subsample_data( const CvMat* _subsample_idx );
 
-    virtual void write_params( CvFileStorage* fs ) const;
-    virtual void read_params( CvFileStorage* fs, CvFileNode* node );
+    virtual void write_params( cv::FileStorage& fs ) const;
+    virtual void read_params( const cv::FileNode& node );
 
     // release all the data
     virtual void clear();
@@ -1738,7 +1738,7 @@ class CvGBTrees : public CvStatModel
     // Read parameters of the gtb model and data.
     //
     // API
-    // virtual void read_params( CvFileStorage* fs );
+    // virtual void read_params( const cv::FileStorage& fs );
     //
     // INPUT
     // fs           - file storage to read parameters from.

modules/calib3d/include/opencv2/calib3d.hpp

@@ -843,6 +843,12 @@ square grouping and ordering algorithm fails.
 CV_EXPORTS_W bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners,
                                          int flags = CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE );
 
+/*
+   Checks whether the image contains chessboard of the specific size or not.
+   If yes, nonzero value is returned.
+*/
+CV_EXPORTS_W bool checkChessboard(InputArray img, Size size);
+
 /** @brief Finds the positions of internal corners of the chessboard using a sector based approach.
 
 @param image Source chessboard view. It must be an 8-bit grayscale or color image.

modules/calib3d/src/calibinit.cpp

@@ -526,7 +526,7 @@ bool findChessboardCorners(InputArray image_, Size pattern_size,
         //image is binarised using a threshold dependent on the image histogram
         if (checkChessboardBinary(thresh_img_new, pattern_size) <= 0) //fall back to the old method
         {
-            if (checkChessboard(img, pattern_size) <= 0)
+            if (!checkChessboard(img, pattern_size))
             {
                 corners_.release();
                 return false;

modules/calib3d/src/checkchessboard.cpp

@@ -163,11 +163,12 @@ static bool checkQuads(vector<pair<float, int> > & quads, const cv::Size & size)
 int cvCheckChessboard(IplImage* src, CvSize size)
 {
     cv::Mat img = cv::cvarrToMat(src);
-    return checkChessboard(img, size);
+    return (int)cv::checkChessboard(img, size);
 }
 
-int checkChessboard(const cv::Mat & img, const cv::Size & size)
+bool cv::checkChessboard(InputArray _img, Size size)
 {
+    Mat img = _img.getMat();
     CV_Assert(img.channels() == 1 && img.depth() == CV_8U);
 
     const int erosion_count = 1;
@@ -180,13 +181,13 @@ int checkChessboard(const cv::Mat & img, const cv::Size & size)
     erode(img, white, Mat(), Point(-1, -1), erosion_count);
     dilate(img, black, Mat(), Point(-1, -1), erosion_count);
 
-    int result = 0;
+    bool result = false;
     for(float thresh_level = black_level; thresh_level < white_level && !result; thresh_level += 20.0f)
     {
         vector<pair<float, int> > quads;
         fillQuads(white, black, thresh_level + black_white_gap, thresh_level, quads);
         if (checkQuads(quads, size))
-            result = 1;
+            result = true;
     }
     return result;
 }

modules/calib3d/src/precomp.hpp

@@ -153,7 +153,6 @@ static inline bool haveCollinearPoints( const Mat& m, int count )
 
 } // namespace cv
 
-int checkChessboard(const cv::Mat & img, const cv::Size & size);
 int checkChessboardBinary(const cv::Mat & img, const cv::Size & size);
 
 #endif

modules/calib3d/test/test_cameracalibration.cpp

@@ -51,7 +51,7 @@ class CV_ProjectPointsTest : public cvtest::ArrayTest
     CV_ProjectPointsTest();
 
 protected:
-    int read_params( CvFileStorage* fs );
+    int read_params( const cv::FileStorage& fs );
     void fill_array( int test_case_idx, int i, int j, Mat& arr );
     int prepare_test_case( int test_case_idx );
     void get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types );
@@ -83,7 +83,7 @@ CV_ProjectPointsTest::CV_ProjectPointsTest()
 }
 
 
-int CV_ProjectPointsTest::read_params( CvFileStorage* fs )
+int CV_ProjectPointsTest::read_params( const cv::FileStorage& fs )
 {
     int code = cvtest::ArrayTest::read_params( fs );
     return code;

modules/calib3d/test/test_chesscorners_timing.cpp

@@ -40,8 +40,8 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/calib3d/calib3d_c.h"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/calib3d.hpp"
 
 namespace opencv_test { namespace {
 
@@ -67,117 +67,90 @@ void CV_ChessboardDetectorTimingTest::run( int start_from )
     std::string   filepath;
     std::string   filename;
 
-    CvMat*  _v = 0;
-    CvPoint2D32f* v;
-
-    IplImage img;
-    IplImage* gray = 0;
-    IplImage* thresh = 0;
+    std::vector<Point2f> v;
+    Mat img, gray, thresh;
 
     int  idx, max_idx;
     int  progress = 0;
 
     filepath = cv::format("%scv/cameracalibration/", ts->get_data_path().c_str() );
     filename = cv::format("%schessboard_timing_list.dat", filepath.c_str() );
-    CvFileStorage* fs = cvOpenFileStorage( filename.c_str(), 0, CV_STORAGE_READ );
-    CvFileNode* board_list = fs ? cvGetFileNodeByName( fs, 0, "boards" ) : 0;
+    cv::FileStorage fs( filename, FileStorage::READ );
+    cv::FileNode board_list = fs["boards"];
+    cv::FileNodeIterator bl_it = board_list.begin();
 
-    if( !fs || !board_list || !CV_NODE_IS_SEQ(board_list->tag) ||
-        board_list->data.seq->total % 4 != 0 )
+    if( !fs.isOpened() || !board_list.isSeq() || board_list.size() % 4 != 0 )
     {
         ts->printf( cvtest::TS::LOG, "chessboard_timing_list.dat can not be read or is not valid" );
         code = cvtest::TS::FAIL_MISSING_TEST_DATA;
         goto _exit_;
     }
 
-    max_idx = board_list->data.seq->total/4;
+    max_idx = (int)(board_list.size()/4);
+    for( idx = 0; idx < start_from; idx++ )
+    {
+        bl_it += 4;
+    }
 
     for( idx = start_from; idx < max_idx; idx++ )
     {
-        int count0 = -1;
-        int count = 0;
         Size 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);
+        std::string imgname; read(*bl_it++, imgname, "dummy.txt");
+        int is_chessboard = 0;
+        read(*bl_it++, is_chessboard, 0);
+        read(*bl_it++, pattern_size.width, -1);
+        read(*bl_it++, pattern_size.height, -1);
 
         ts->update_context( this, idx-1, true );
 
         /* read the image */
-        filename = cv::format("%s%s", filepath.c_str(), imgname );
+        filename = cv::format("%s%s", filepath.c_str(), imgname.c_str() );
 
-        cv::Mat img2 = cv::imread( filename );
-        img = cvIplImage(img2);
-
-        if( img2.empty() )
+        img = cv::imread( filename );
+        if( img.empty() )
         {
             ts->printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", filename.c_str() );
             code = cvtest::TS::FAIL_MISSING_TEST_DATA;
             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 );
-
+        ts->printf(cvtest::TS::LOG, "%s: chessboard %d:\n", imgname.c_str(), is_chessboard);
 
-        count0 = pattern_size.width*pattern_size.height;
+        cvtColor(img, gray, COLOR_BGR2GRAY);
 
-        /* allocate additional buffers */
-        _v = cvCreateMat(1, count0, CV_32FC2);
-        count = count0;
+        int64 _time0 = cv::getTickCount();
+        bool result = cv::checkChessboard(gray, pattern_size);
+        int64 _time01 = cv::getTickCount();
+        bool result1 = findChessboardCorners(gray, pattern_size, v, 15);
+        int64 _time1 = cv::getTickCount();
 
-        v = (CvPoint2D32f*)_v->data.fl;
-
-        int64 _time0 = cvGetTickCount();
-        result = cvCheckChessboard(gray, cvSize(pattern_size));
-        int64 _time01 = cvGetTickCount();
-
-        OPENCV_CALL( result1 = cvFindChessboardCorners(
-                 gray, cvSize(pattern_size), v, &count, 15 ));
-        int64 _time1 = cvGetTickCount();
-
-        if( result != is_chessboard )
+        if( result != (is_chessboard != 0))
         {
             ts->printf( cvtest::TS::LOG, "Error: chessboard was %sdetected in the image %s\n",
-                       result ? "" : "not ", imgname );
+                       result ? "" : "not ", imgname.c_str() );
             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)result, (int)result1);
         }
 
-        int num_pixels = gray->width*gray->height;
-        float check_chessboard_time = float(_time01 - _time0)/(float)cvGetTickFrequency(); // in us
+        int num_pixels = gray.cols*gray.rows;
+        float check_chessboard_time = float(_time01 - _time0)/(float)cv::getTickFrequency(); // 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();
+        float find_chessboard_time = float(_time1 - _time01)/(float)cv::getTickFrequency();
         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( &gray );
-        cvReleaseImage( &thresh );
         progress = update_progress( progress, idx-1, max_idx, 0 );
     }
 
 _exit_:
 
-    /* release occupied memory */
-    cvReleaseMat( &_v );
-    cvReleaseFileStorage( &fs );
-    cvReleaseImage( &gray );
-    cvReleaseImage( &thresh );
-
     if( code < 0 )
         ts->set_failed_test_info( code );
 }