Merge pull request #3642 from mshabunin:cleanup-imgproc-1

C-API cleanup: imgproc_c and some constants #3642

* removed all mentions of imgproc C-API headers (imgproc_c.h, types_c.h) - they were empty, included core C-API headers
* replaced usage of several C constants with C++ ones (error codes)
* minor warning fixes in _cvv_ module

Author: mshabunin

modules/ccalib/src/multicalib.cpp

@@ -225,7 +225,7 @@ void MultiCameraCalibration::loadImages()
         _xi[camera].convertTo(_xi[camera], CV_32F);
         //else
         //{
-        //    CV_Error_(CV_StsOutOfRange, "Unknown camera type, use PINHOLE or OMNIDIRECTIONAL");
+        //    CV_Error_(cv::Error::StsOutOfRange, "Unknown camera type, use PINHOLE or OMNIDIRECTIONAL");
         //}
 
         for (int i = 0; i < (int)_omEachCamera[camera].size(); ++i)

modules/cudalegacy/src/fgd.cpp

@@ -54,7 +54,6 @@ Ptr<cuda::BackgroundSubtractorFGD> cv::cuda::createBackgroundSubtractorFGD(const
 #else
 
 #include "cuda/fgd.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
 
 /////////////////////////////////////////////////////////////////////////
 // FGDParams

modules/cvv/samples/cvv_demo.cpp

@@ -4,7 +4,6 @@
 // library includes
 #include <opencv2/imgproc.hpp>
 #include <opencv2/features2d.hpp>
-#include <opencv2/imgproc/types_c.h>
 #include <opencv2/videoio.hpp>
 #include <opencv2/videoio/videoio_c.h>
 
@@ -33,8 +32,6 @@ template<class T> std::string toString(const T& p_arg)
 int
 main(int argc, char** argv)
 {
-  cv::Size* resolution = nullptr;
-
   // parser keys
   const char *keys =
       "{ help h usage ?  |   | show this message }"

modules/cvv/src/qtutil/filter/sobelfilterwidget.cpp

@@ -1,7 +1,6 @@
 #include "sobelfilterwidget.hpp"
 
 #include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/types_c.h"
 
 #include <QVBoxLayout>
 #include <QLabel>

modules/cvv/test/test_reference.cpp

@@ -6,12 +6,12 @@ namespace opencv_test { namespace {
 
 /**
  * Makes sure that
- * - creating, reassigning and comparing `cvv::util::Reference<int>`s (from /src/util/util.hpp) works, 
+ * - creating, reassigning and comparing `cvv::util::Reference<int>`s (from /src/util/util.hpp) works,
  * 	as well as the
  * - `makeRef()` and `getPtr()` functions; that
  * - `Reference<const int>`s can be created with `makeRef(const int)`, `{const int}` initializer list
- * 	and via `Reference<const int>{int}` and, finally, that 
- * - `cvv::util::Reference`s of super classes can be constructed with derived classes and 
+ * 	and via `Reference<const int>{int}` and, finally, that
+ * - `cvv::util::Reference`s of super classes can be constructed with derived classes and
  * - `Reference`s to base classes can be `castTo()` `References` to the derived classes, but not the other way.
  */
 
@@ -71,7 +71,7 @@ TEST(ReferenceTest, ConstRefs)
 
 TEST(ReferenceTest, ConstRefsFromMutable)
 {
-	int i;
+	int i = 100;
 	Reference<const int> ref{ i };
 	EXPECT_EQ(ref.getPtr(), &i);
 }

modules/dpm/src/dpm_cascade.cpp

@@ -62,7 +62,7 @@ void DPMCascade::loadCascadeModel(const string &modelPath)
     if (!is_success)
     {
         string errorMessage = format("Unable to parse the model: %s", modelPath.c_str());
-        CV_Error(CV_StsBadArg, errorMessage);
+        CV_Error(cv::Error::StsBadArg, errorMessage);
     }
 
     model.initModel();

modules/dpm/src/dpm_feature.cpp

@@ -81,7 +81,7 @@ void ParalComputePyramid::initialize()
 
     if (params.maxScale < params.interval)
     {
-        CV_Error(CV_StsBadArg, "The image is too small to create a pyramid");
+        CV_Error(cv::Error::StsBadArg, "The image is too small to create a pyramid");
         return;
     }
 

modules/img_hash/src/precomp.hpp

@@ -8,7 +8,6 @@
 #include "opencv2/core.hpp"
 #include "opencv2/core/base.hpp"
 #include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/types_c.h"
 #include "opencv2/img_hash.hpp"
 
 #include <bitset>

modules/ml/src/ann_mlp.cpp

@@ -224,7 +224,7 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
     void setActivationFunction(int _activ_func, double _f_param1, double _f_param2) CV_OVERRIDE
     {
         if( _activ_func < 0 || _activ_func > LEAKYRELU)
-            CV_Error( CV_StsOutOfRange, "Unknown activation function" );
+            CV_Error( cv::Error::StsOutOfRange, "Unknown activation function" );
 
         activ_func = _activ_func;
 
@@ -323,7 +323,7 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
             {
                 int n = layer_sizes[i];
                 if( n < 1 + (0 < i && i < l_count-1))
-                    CV_Error( CV_StsOutOfRange,
+                    CV_Error( cv::Error::StsOutOfRange,
                              "there should be at least one input and one output "
                              "and every hidden layer must have more than 1 neuron" );
                 max_lsize = std::max( max_lsize, n );
@@ -342,7 +342,7 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
     float predict( InputArray _inputs, OutputArray _outputs, int ) const CV_OVERRIDE
     {
         if( !trained )
-            CV_Error( CV_StsError, "The network has not been trained or loaded" );
+            CV_Error( cv::Error::StsError, "The network has not been trained or loaded" );
 
         Mat inputs = _inputs.getMat();
         int type = inputs.type(), l_count = layer_count();
@@ -791,7 +791,7 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
                 {
                     t = t*inv_scale[j*2] + inv_scale[2*j+1];
                     if( t < m1 || t > M1 )
-                        CV_Error( CV_StsOutOfRange,
+                        CV_Error( cv::Error::StsOutOfRange,
                                  "Some of new output training vector components run exceed the original range too much" );
                 }
             }
@@ -818,25 +818,25 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
                            Mat& sample_weights, int flags )
     {
         if( layer_sizes.empty() )
-            CV_Error( CV_StsError,
+            CV_Error( cv::Error::StsError,
                      "The network has not been created. Use method create or the appropriate constructor" );
 
         if( (inputs.type() != CV_32F && inputs.type() != CV_64F) ||
             inputs.cols != layer_sizes[0] )
-            CV_Error( CV_StsBadArg,
+            CV_Error( cv::Error::StsBadArg,
                      "input training data should be a floating-point matrix with "
                      "the number of rows equal to the number of training samples and "
                      "the number of columns equal to the size of 0-th (input) layer" );
 
         if( (outputs.type() != CV_32F && outputs.type() != CV_64F) ||
             outputs.cols != layer_sizes.back() )
-            CV_Error( CV_StsBadArg,
+            CV_Error( cv::Error::StsBadArg,
                      "output training data should be a floating-point matrix with "
                      "the number of rows equal to the number of training samples and "
                      "the number of columns equal to the size of last (output) layer" );
 
         if( inputs.rows != outputs.rows )
-            CV_Error( CV_StsUnmatchedSizes, "The numbers of input and output samples do not match" );
+            CV_Error( cv::Error::StsUnmatchedSizes, "The numbers of input and output samples do not match" );
 
         Mat temp;
         double s = sum(sample_weights)[0];
@@ -1324,7 +1324,7 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
             fs << "itePerStep" << params.itePerStep;
         }
         else
-            CV_Error(CV_StsError, "Unknown training method");
+            CV_Error(cv::Error::StsError, "Unknown training method");
 
         fs << "term_criteria" << "{";
         if( params.termCrit.type & TermCriteria::EPS )
@@ -1422,7 +1422,7 @@ class ANN_MLPImpl CV_FINAL : public ANN_MLP
                 params.itePerStep = tpn["itePerStep"];
             }
             else
-                CV_Error(CV_StsParseError, "Unknown training method (should be BACKPROP or RPROP)");
+                CV_Error(cv::Error::StsParseError, "Unknown training method (should be BACKPROP or RPROP)");
 
             FileNode tcn = tpn["term_criteria"];
             if( !tcn.empty() )

modules/ml/src/boost.cpp

@@ -308,7 +308,7 @@ class DTreesImplForBoost CV_FINAL : public DTreesImpl
             }
         }
         else
-            CV_Error(CV_StsNotImplemented, "Unknown boosting type");
+            CV_Error(cv::Error::StsNotImplemented, "Unknown boosting type");
 
         /*if( bparams.boostType != Boost::LOGIT )
         {
@@ -387,7 +387,7 @@ class DTreesImplForBoost CV_FINAL : public DTreesImpl
     void write( FileStorage& fs ) const CV_OVERRIDE
     {
         if( roots.empty() )
-            CV_Error( CV_StsBadArg, "RTrees have not been trained" );
+            CV_Error( cv::Error::StsBadArg, "RTrees have not been trained" );
 
         writeFormat(fs);
         writeParams(fs);

modules/ml/src/data.cpp

@@ -574,7 +574,7 @@ class TrainDataImpl CV_FINAL : public TrainData
             if( nvars == 0 )
             {
                 if( rowvals.empty() )
-                    CV_Error(CV_StsBadArg, "invalid CSV format; no data found");
+                    CV_Error(cv::Error::StsBadArg, "invalid CSV format; no data found");
                 nvars = (int)rowvals.size();
                 if( !varTypeSpec.empty() && varTypeSpec.size() > 0 )
                 {
@@ -637,7 +637,7 @@ class TrainDataImpl CV_FINAL : public TrainData
             {
                 for( i = ninputvars; i < nvars; i++ )
                     if( vtypes[i] == VAR_CATEGORICAL )
-                        CV_Error(CV_StsBadArg,
+                        CV_Error(cv::Error::StsBadArg,
                                  "If responses are vector values, not scalars, they must be marked as ordered responses");
             }
         }
@@ -724,14 +724,14 @@ class TrainDataImpl CV_FINAL : public TrainData
                 }
 
                 if ( ptr[3] != '[')
-                    CV_Error( CV_StsBadArg, errmsg );
+                    CV_Error( cv::Error::StsBadArg, errmsg );
 
                 ptr += 4; // pass "ord["
                 do
                 {
                     int b1 = (int)strtod( ptr, &stopstring );
                     if( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
-                        CV_Error( CV_StsBadArg, errmsg );
+                        CV_Error( cv::Error::StsBadArg, errmsg );
                     ptr = stopstring + 1;
                     if( (stopstring[0] == ',') || (stopstring[0] == ']'))
                     {
@@ -745,15 +745,15 @@ class TrainDataImpl CV_FINAL : public TrainData
                         {
                             int b2 = (int)strtod( ptr, &stopstring);
                             if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
-                                CV_Error( CV_StsBadArg, errmsg );
+                                CV_Error( cv::Error::StsBadArg, errmsg );
                             ptr = stopstring + 1;
                             CV_Assert( 0 <= b1 && b1 <= b2 && b2 < nvars );
                             for (int i = b1; i <= b2; i++)
                                 vtypes[i] = (uchar)tp;
                             specCounter += b2 - b1 + 1;
                         }
                         else
-                            CV_Error( CV_StsBadArg, errmsg );
+                            CV_Error( cv::Error::StsBadArg, errmsg );
 
                     }
                 }
@@ -762,7 +762,7 @@ class TrainDataImpl CV_FINAL : public TrainData
         }
 
         if( specCounter != nvars )
-            CV_Error( CV_StsBadArg, "type of some variables is not specified" );
+            CV_Error( cv::Error::StsBadArg, "type of some variables is not specified" );
     }
 
     void setTrainTestSplitRatio(double ratio, bool shuffle) CV_OVERRIDE

modules/ml/src/gbt.cpp

@@ -218,7 +218,7 @@ CvGBTrees::train( const CvMat* _train_data, int _tflag,
                 orig_response->data.fl[i] = (float) _responses->data.i[i*step];
         }; break;
         default:
-            CV_Error(CV_StsUnmatchedFormats, "Response should be a 32fC1 or 32sC1 vector.");
+            CV_Error(cv::Error::StsUnmatchedFormats, "Response should be a 32fC1 or 32sC1 vector.");
     }
 
     if (!is_regression)
@@ -283,7 +283,7 @@ CvGBTrees::train( const CvMat* _train_data, int _tflag,
                         sample_idx->data.i[active_samples_count++] = i;
 
             } break;
-            default: CV_Error(CV_StsUnmatchedFormats, "_sample_idx should be a 32sC1, 8sC1 or 8uC1 vector.");
+            default: CV_Error(cv::Error::StsUnmatchedFormats, "_sample_idx should be a 32sC1, 8sC1 or 8uC1 vector.");
         }
     }
     else
@@ -1072,7 +1072,7 @@ void CvGBTrees::read_params( CvFileStorage* fs, CvFileNode* fnode )
 
 
     if( params.loss_function_type < SQUARED_LOSS || params.loss_function_type > DEVIANCE_LOSS ||  params.loss_function_type == 2)
-        CV_ERROR( CV_StsBadArg, "Unknown loss function" );
+        CV_Error( cv::Error::StsBadArg, "Unknown loss function" );
 
     params.weak_count = cvReadIntByName( fs, fnode, "ensemble_length" );
     params.shrinkage = (float)cvReadRealByName( fs, fnode, "shrinkage", 0.1 );
@@ -1082,7 +1082,7 @@ void CvGBTrees::read_params( CvFileStorage* fs, CvFileNode* fnode )
     {
         class_labels = (CvMat*)cvReadByName( fs, fnode, "class_labels" );
         if( class_labels && !CV_IS_MAT(class_labels))
-            CV_ERROR( CV_StsParseError, "class_labels must stored as a matrix");
+            CV_Error( cv::Error::StsParseError, "class_labels must stored as a matrix");
     }
     data->is_classifier = 0;
 
@@ -1105,7 +1105,7 @@ void CvGBTrees::write( CvFileStorage* fs, const char* name ) const
     cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_GBT );
 
     if( !weak )
-        CV_ERROR( CV_StsBadArg, "The model has not been trained yet" );
+        CV_Error( cv::Error::StsBadArg, "The model has not been trained yet" );
 
     write_params( fs );
     cvWriteReal( fs, "base_value", base_value);
@@ -1170,13 +1170,13 @@ void CvGBTrees::read( CvFileStorage* fs, CvFileNode* node )
 
         trees_fnode = cvGetFileNodeByName( fs, node, s.c_str() );
         if( !trees_fnode || !CV_NODE_IS_SEQ(trees_fnode->tag) )
-            CV_ERROR( CV_StsParseError, "<trees_x> tag is missing" );
+            CV_Error( cv::Error::StsParseError, "<trees_x> tag is missing" );
 
         cvStartReadSeq( trees_fnode->data.seq, &reader );
         ntrees = trees_fnode->data.seq->total;
 
         if( ntrees != params.weak_count )
-            CV_ERROR( CV_StsUnmatchedSizes,
+            CV_Error( cv::Error::StsUnmatchedSizes,
             "The number of trees stored does not match <ntrees> tag value" );
 
         CV_CALL( storage = cvCreateMemStorage() );

modules/ml/src/inner_functions.cpp

@@ -63,7 +63,7 @@ bool StatModel::train(const Ptr<TrainData>& trainData, int )
 {
     CV_TRACE_FUNCTION();
     CV_Assert(!trainData.empty());
-    CV_Error(CV_StsNotImplemented, "");
+    CV_Error(cv::Error::StsNotImplemented, "");
     return false;
 }