bindings: backport generator from OpenCV 4.x

- better handling of enum arguments
- less merge conflicts

modules/core/misc/python/pyopencv_umat.hpp

+#ifdef HAVE_OPENCV_CORE
+
+#include "opencv2/core/mat.hpp"
+
+typedef std::vector<Range> vector_Range;
+
+CV_PY_TO_CLASS(UMat);
+CV_PY_FROM_CLASS(UMat);
+
+static bool cv_mappable_to(const Ptr<Mat>& src, Ptr<UMat>& dst)
+{
+    //dst.reset(new UMat(src->getUMat(ACCESS_RW)));
+    dst.reset(new UMat());
+    src->copyTo(*dst);
+    return true;
+}
+
+static void* cv_UMat_queue()
+{
+    return cv::ocl::Queue::getDefault().ptr();
+}
+
+static void* cv_UMat_context()
+{
+    return cv::ocl::Context::getDefault().ptr();
+}
+
+static Mat cv_UMat_get(const UMat* _self)
+{
+    Mat m;
+    m.allocator = &g_numpyAllocator;
+    _self->copyTo(m);
+    return m;
+}
+
+#endif

modules/core/misc/python/shadow_umat.hpp

+#error This is a shadow header file, which is not intended for processing by any compiler. \
+       Only bindings parser should handle this file.
+
+namespace cv
+{
+
+class CV_EXPORTS_W UMat
+{
+public:
+    //! default constructor
+    CV_WRAP UMat(UMatUsageFlags usageFlags = USAGE_DEFAULT);
+    //! constructs 2D matrix of the specified size and type
+    // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
+    CV_WRAP UMat(int rows, int cols, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
+    CV_WRAP UMat(Size size, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
+    //! constucts 2D matrix and fills it with the specified value _s.
+    CV_WRAP UMat(int rows, int cols, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
+    CV_WRAP UMat(Size size, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
+
+    //! Mat is mappable to UMat
+    CV_WRAP_MAPPABLE(Ptr<Mat>);
+
+    //! returns the OpenCL queue used by OpenCV UMat
+    CV_WRAP_PHANTOM(static void* queue());
+
+    //! returns the OpenCL context used by OpenCV UMat
+    CV_WRAP_PHANTOM(static void* context());
+
+    //! copy constructor
+    CV_WRAP UMat(const UMat& m);
+
+    //! creates a matrix header for a part of the bigger matrix
+    CV_WRAP UMat(const UMat& m, const Range& rowRange, const Range& colRange = Range::all());
+    CV_WRAP UMat(const UMat& m, const Rect& roi);
+    CV_WRAP UMat(const UMat& m, const std::vector<Range>& ranges);
+
+    //CV_WRAP_AS(get) Mat getMat(int flags CV_WRAP_DEFAULT(ACCESS_RW)) const;
+    //! returns a numpy matrix
+    CV_WRAP_PHANTOM(Mat get() const);
+
+    //! returns true iff the matrix data is continuous
+    // (i.e. when there are no gaps between successive rows).
+    // similar to CV_IS_MAT_CONT(cvmat->type)
+    CV_WRAP bool isContinuous() const;
+
+    //! returns true if the matrix is a submatrix of another matrix
+    CV_WRAP bool isSubmatrix() const;
+
+    /*! Returns the OpenCL buffer handle on which UMat operates on.
+    The UMat instance should be kept alive during the use of the handle to prevent the buffer to be
+    returned to the OpenCV buffer pool.
+    */
+    CV_WRAP void* handle(int/*AccessFlag*/ accessFlags) const;
+
+    // offset of the submatrix (or 0)
+    CV_PROP_RW size_t offset;
+};
+
+} // namespace cv

modules/python/bindings/CMakeLists.txt

@@ -26,15 +26,15 @@ foreach(m ${OPENCV_PYTHON_MODULES})
       list(APPEND opencv_hdrs "${hdr}")
     endif()
   endforeach()
+  file(GLOB hdr ${OPENCV_MODULE_${m}_LOCATION}/misc/python/shadow*.hpp)
+  list(APPEND opencv_hdrs ${hdr})
   file(GLOB userdef_hdrs ${OPENCV_MODULE_${m}_LOCATION}/misc/python/pyopencv*.hpp)
   list(APPEND opencv_userdef_hdrs ${userdef_hdrs})
 endforeach(m)
 
 # header blacklist
 ocv_list_filterout(opencv_hdrs "modules/.*\\\\.h$")
-ocv_list_filterout(opencv_hdrs "modules/core/.*/cuda")
-ocv_list_filterout(opencv_hdrs "modules/cuda.*")
-ocv_list_filterout(opencv_hdrs "modules/cudev")
+ocv_list_filterout(opencv_hdrs "modules/core/.*/cuda/")
 ocv_list_filterout(opencv_hdrs "modules/core/.*/hal/")
 ocv_list_filterout(opencv_hdrs "modules/core/.*/opencl/")
 ocv_list_filterout(opencv_hdrs "modules/.+/utils/.*")
@@ -43,7 +43,12 @@ ocv_list_filterout(opencv_hdrs "modules/.*_inl\\\\.h*")
 ocv_list_filterout(opencv_hdrs "modules/.*\\\\.details\\\\.h*")
 ocv_list_filterout(opencv_hdrs "modules/.*\\\\.private\\\\.h*")
 ocv_list_filterout(opencv_hdrs "modules/.*/private\\\\.h*")
+ocv_list_filterout(opencv_hdrs "modules/.*/legacy/.*")
 ocv_list_filterout(opencv_hdrs "modules/.*/detection_based_tracker\\\\.hpp") # Conditional compilation
+if(NOT HAVE_CUDA)
+  ocv_list_filterout(opencv_hdrs "modules/cuda.*")
+  ocv_list_filterout(opencv_hdrs "modules/cudev")
+endif()
 
 set(cv2_generated_files
     "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_include.h"

modules/stitching/misc/python/pyopencv_stitching.hpp

 #ifdef HAVE_OPENCV_STITCHING
 typedef Stitcher::Status Status;
-
-template<>
-PyObject* pyopencv_from(const Status& value)
-{
-    return PyInt_FromLong(value);
-}
 #endif

modules/videoio/misc/python/pyopencv_videoio.hpp

 #ifdef HAVE_OPENCV_VIDEOIO
 typedef std::vector<VideoCaptureAPIs> vector_VideoCaptureAPIs;
 
-template<>
-bool pyopencv_to(PyObject *o, cv::VideoCaptureAPIs &v, const char *name)
-{
-    (void)name;
-    v = CAP_ANY;
-    if (!o || o == Py_None)
-        return false;
-    else if (PyLong_Check(o))
-    {
-        v = VideoCaptureAPIs((int64)PyLong_AsLongLong(o));
-        return true;
-    }
-    else if (PyInt_Check(o))
-    {
-        v = VideoCaptureAPIs((int64)PyInt_AS_LONG(o));
-        return true;
-    }
-    else
-        return false;
-}
-
-template<>
-PyObject* pyopencv_from(const cv::VideoCaptureAPIs &v)
-{
-    return pyopencv_from((int)(v));
-}
-
 template<> struct pyopencvVecConverter<cv::VideoCaptureAPIs>
 {
     static bool to(PyObject* obj, std::vector<cv::VideoCaptureAPIs>& value, const ArgInfo info)