Merge pull request #3854 from asmorkalov:as/fastcv_bindings_fix

Fixed Java and Python bindings generation

modules/fastcv/include/opencv2/fastcv/hough.hpp

@@ -25,27 +25,6 @@ namespace fastcv {
  */
 CV_EXPORTS_W void houghLines(InputArray src, OutputArray lines, double threshold = 0.25);
 
-
-/**
- * @brief Finds circles in a grayscale image using Hough transform.
- *        The radius of circle varies from 0 to max(srcWidth, srcHeight).
- *
- * @param src Input 8-bit image containing binary contour. Step should be divisible by 8, data start should be 128-bit aligned
- * @param circles Output array containing detected circles in a form (x, y, r) where all numbers are 32-bit integers
- * @param minDist Minimum distance between the centers of the detected circles
- * @param cannyThreshold The higher threshold of the two passed to the Canny() edge detector
- *                       (the lower one is twice smaller). Default is 100.
- * @param accThreshold The accumulator threshold for the circle centers at the detection
- *                     stage. The smaller it is, the more false circles may be detected.
- *                     Circles, corresponding to the larger accumulator values, will be
- *                     returned first. Default is 100.
- * @param minRadius Minimum circle radius, default is 0
- * @param maxRadius Maximum circle radius, default is 0
- */
-CV_EXPORTS_W void houghCircles(InputArray src, OutputArray circles, uint32_t minDist,
-                               uint32_t cannyThreshold = 100, uint32_t accThreshold = 100,
-                               uint32_t minRadius = 0, uint32_t maxRadius = 0);
-
 //! @}
 
 } // fastcv::

modules/fastcv/include/opencv2/fastcv/mser.hpp

@@ -52,11 +52,11 @@ public:
                            Typical value range [0.1 1.0], typical value 0.2
      * @return Feature detector object ready for detection
      */
-    CV_WRAP static Ptr<FCVMSER> create( cv::Size     imgSize,
-                                        uint32_t numNeighbors = 4,
-                                        uint32_t delta = 2,
-                                        uint32_t minArea = 30,
-                                        uint32_t maxArea = 14400,
+    CV_WRAP static Ptr<FCVMSER> create( const cv::Size& imgSize,
+                                        int numNeighbors = 4,
+                                        int delta = 2,
+                                        int minArea = 30,
+                                        int maxArea = 14400,
                                         float maxVariation = 0.15f,
                                         float minDiversity = 0.2f);
 
@@ -98,10 +98,10 @@ public:
                         std::vector<ContourData>& contourData) = 0;
 
     CV_WRAP virtual cv::Size getImgSize() = 0;
-    CV_WRAP virtual uint32_t getNumNeighbors() = 0;
-    CV_WRAP virtual uint32_t getDelta()        = 0;
-    CV_WRAP virtual uint32_t getMinArea()      = 0;
-    CV_WRAP virtual uint32_t getMaxArea()      = 0;
+    CV_WRAP virtual int getNumNeighbors() = 0;
+    CV_WRAP virtual int getDelta()        = 0;
+    CV_WRAP virtual int getMinArea()      = 0;
+    CV_WRAP virtual int getMaxArea()      = 0;
     CV_WRAP virtual float getMaxVariation() = 0;
     CV_WRAP virtual float getMinDiversity() = 0;
 

modules/fastcv/include/opencv2/fastcv/thresh.hpp

@@ -27,7 +27,7 @@ namespace fastcv {
  * @param falseValue The value assigned to the destination pixel if the source is out of the range inclusively defined by the
  *                   pair of threshold values
  */
-CV_EXPORTS_W void thresholdRange(InputArray src, OutputArray dst, uint8_t lowThresh, uint8_t highThresh, uint8_t trueValue, uint8_t falseValue);
+CV_EXPORTS_W void thresholdRange(InputArray src, OutputArray dst, int lowThresh, int highThresh, int trueValue, int falseValue);
 
 //! @}
 

modules/fastcv/src/mser.cpp

@@ -12,20 +12,20 @@ class MSER_Impl CV_FINAL : public cv::fastcv::FCVMSER
 {
 public:
     explicit MSER_Impl(cv::Size     imgSize,
-                       uint32_t numNeighbors,
-                       uint32_t delta,
-                       uint32_t minArea,
-                       uint32_t maxArea,
+                       int numNeighbors,
+                       int delta,
+                       int minArea,
+                       int maxArea,
                        float maxVariation,
                        float minDiversity);
 
     ~MSER_Impl() CV_OVERRIDE;
 
     cv::Size getImgSize()      CV_OVERRIDE { return imgSize;      };
-    uint32_t getNumNeighbors() CV_OVERRIDE { return numNeighbors; };
-    uint32_t getDelta()        CV_OVERRIDE { return delta;        };
-    uint32_t getMinArea()      CV_OVERRIDE { return minArea;      };
-    uint32_t getMaxArea()      CV_OVERRIDE { return maxArea;      };
+    int getNumNeighbors() CV_OVERRIDE { return numNeighbors; };
+    int getDelta()        CV_OVERRIDE { return delta;        };
+    int getMinArea()      CV_OVERRIDE { return minArea;      };
+    int getMaxArea()      CV_OVERRIDE { return maxArea;      };
     float getMaxVariation() CV_OVERRIDE { return maxVariation; };
     float getMinDiversity() CV_OVERRIDE { return minDiversity; };
 
@@ -42,10 +42,10 @@ public:
                        bool useContourData = true);
 
     cv::Size imgSize;
-    uint32_t numNeighbors;
-    uint32_t delta;
-    uint32_t minArea;
-    uint32_t maxArea;
+    int numNeighbors;
+    int delta;
+    int minArea;
+    int maxArea;
     float maxVariation;
     float minDiversity;
 
@@ -54,10 +54,10 @@ public:
 
 
 MSER_Impl::MSER_Impl(cv::Size _imgSize,
-                     uint32_t _numNeighbors,
-                     uint32_t _delta,
-                     uint32_t _minArea,
-                     uint32_t _maxArea,
+                     int _numNeighbors,
+                     int _delta,
+                     int _minArea,
+                     int _maxArea,
                      float _maxVariation,
                      float _minDiversity)
 {
@@ -244,14 +244,15 @@ void MSER_Impl::detect(InputArray src, std::vector<std::vector<Point>>& contours
     this->detectRegions(src, contours, boundingBoxes, contourData, /*useBoundingBoxes*/ true, /*useContourData*/ true);
 }
 
-Ptr<FCVMSER> FCVMSER::create(cv::Size     imgSize,
-                             uint32_t numNeighbors,
-                             uint32_t delta,
-                             uint32_t minArea,
-                             uint32_t maxArea,
+Ptr<FCVMSER> FCVMSER::create(const cv::Size& imgSize,
+                             int numNeighbors,
+                             int delta,
+                             int minArea,
+                             int maxArea,
                              float maxVariation,
                              float minDiversity)
 {
+    CV_Assert(numNeighbors > 0 && delta >= 0 && minArea >= 0 && maxArea >= 0);
     return makePtr<MSER_Impl>(imgSize, numNeighbors, delta, minArea, maxArea, maxVariation, minDiversity);
 }
 

modules/fastcv/src/thresh.cpp

@@ -8,10 +8,15 @@
 namespace cv {
 namespace fastcv {
 
-void thresholdRange(InputArray _src, OutputArray _dst, uint8_t lowThresh, uint8_t highThresh, uint8_t trueValue, uint8_t falseValue)
+void thresholdRange(InputArray _src, OutputArray _dst, int lowThresh, int highThresh, int trueValue, int falseValue)
 {
     INITIALIZATION_CHECK;
 
+    CV_Assert(lowThresh >= 0 && lowThresh < 256);
+    CV_Assert(highThresh >= 0 && highThresh < 256);
+    CV_Assert(falseValue >= 0 && falseValue < 256);
+    CV_Assert(trueValue >= 0 && trueValue < 256);
+
     CV_Assert(lowThresh <= highThresh);
 
     CV_Assert(!_src.empty() && _src.type() == CV_8UC1);