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