From 973e1acb67fd2aeb198c3ddc674cf32376609c62 Mon Sep 17 00:00:00 2001 From: Maksim Shabunin Date: Sun, 5 Dec 2021 15:49:36 +0300 Subject: [PATCH] Merge pull request #21182 from mshabunin:split-cv2cpp Split cv2.cpp * split cv2.cpp: util, numpy * split cv2.cpp: convert * split cv2.cpp: highgui, more utils * split cv2.cpp: fix numpy import --- modules/python/common.cmake | 12 +- modules/python/src2/cv2.cpp | 2150 +---------------------------------- modules/python/src2/cv2.hpp | 55 + modules/python/src2/cv2_convert.cpp | 1052 +++++++++++++++++ modules/python/src2/cv2_convert.hpp | 529 +++++++++ modules/python/src2/cv2_highgui.cpp | 184 +++ modules/python/src2/cv2_highgui.hpp | 14 + modules/python/src2/cv2_numpy.cpp | 73 ++ modules/python/src2/cv2_numpy.hpp | 217 ++++ modules/python/src2/cv2_util.cpp | 178 +++ modules/python/src2/cv2_util.hpp | 134 +++ modules/python/src2/pycompat.hpp | 2 + 12 files changed, 2458 insertions(+), 2142 deletions(-) create mode 100644 modules/python/src2/cv2.hpp create mode 100644 modules/python/src2/cv2_convert.cpp create mode 100644 modules/python/src2/cv2_convert.hpp create mode 100644 modules/python/src2/cv2_highgui.cpp create mode 100644 modules/python/src2/cv2_highgui.hpp create mode 100644 modules/python/src2/cv2_numpy.cpp create mode 100644 modules/python/src2/cv2_numpy.hpp create mode 100644 modules/python/src2/cv2_util.cpp create mode 100644 modules/python/src2/cv2_util.hpp diff --git a/modules/python/common.cmake b/modules/python/common.cmake index ebbb2e2..264714f 100644 --- a/modules/python/common.cmake +++ b/modules/python/common.cmake @@ -19,7 +19,17 @@ if(NOT WIN32 AND NOT APPLE AND NOT OPENCV_PYTHON_SKIP_LINKER_EXCLUDE_LIBS) set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--exclude-libs=ALL") endif() -ocv_add_library(${the_module} MODULE ${PYTHON_SOURCE_DIR}/src2/cv2.cpp ${cv2_generated_hdrs} ${opencv_userdef_hdrs} ${cv2_custom_hdr}) +ocv_add_library(${the_module} MODULE + ${PYTHON_SOURCE_DIR}/src2/cv2.cpp + ${PYTHON_SOURCE_DIR}/src2/cv2_util.cpp + ${PYTHON_SOURCE_DIR}/src2/cv2_numpy.cpp + ${PYTHON_SOURCE_DIR}/src2/cv2_convert.cpp + ${PYTHON_SOURCE_DIR}/src2/cv2_highgui.cpp + ${cv2_generated_hdrs} + ${opencv_userdef_hdrs} + ${cv2_custom_hdr} +) + if(TARGET gen_opencv_python_source) add_dependencies(${the_module} gen_opencv_python_source) endif() diff --git a/modules/python/src2/cv2.cpp b/modules/python/src2/cv2.cpp index 58b1357..b39db34 100644 --- a/modules/python/src2/cv2.cpp +++ b/modules/python/src2/cv2.cpp @@ -1,530 +1,24 @@ -//warning number '5033' not a valid compiler warning in vc12 -#if defined(_MSC_VER) && (_MSC_VER > 1800) -// eliminating duplicated round() declaration -#define HAVE_ROUND 1 -#pragma warning(push) -#pragma warning(disable:5033) // 'register' is no longer a supported storage class -#endif - -// #define CVPY_DYNAMIC_INIT -// #define Py_DEBUG - -#if defined(CVPY_DYNAMIC_INIT) && !defined(Py_DEBUG) -# define Py_LIMITED_API 0x03030000 -#endif - -#include -#include -#include - -#if PY_MAJOR_VERSION < 3 -#undef CVPY_DYNAMIC_INIT -#else -#define CV_PYTHON_3 1 -#endif +// must be defined before importing numpy headers +// https://numpy.org/doc/1.17/reference/c-api.array.html#importing-the-api +#define PY_ARRAY_UNIQUE_SYMBOL opencv_ARRAY_API -#if defined(_MSC_VER) && (_MSC_VER > 1800) -#pragma warning(pop) -#endif - -#define MODULESTR "cv2" -#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION - -#include +#include "cv2.hpp" #include "opencv2/opencv_modules.hpp" #include "opencv2/core.hpp" -#include "opencv2/core/utils/configuration.private.hpp" #include "opencv2/core/utils/logger.hpp" -#include "opencv2/core/utils/tls.hpp" #include "pyopencv_generated_include.h" #include "opencv2/core/types_c.h" -#include "pycompat.hpp" -#include - -#include // std::enable_if - -#define CV_HAS_CONVERSION_ERROR(x) (((x) == -1) && PyErr_Occurred()) - -static PyObject* opencv_error = NULL; - -static PyTypeObject* pyopencv_Mat_TypePtr = nullptr; - -class ArgInfo -{ -public: - const char* name; - bool outputarg; - // more fields may be added if necessary - - ArgInfo(const char* name_, bool outputarg_) : name(name_), outputarg(outputarg_) {} - -private: - ArgInfo(const ArgInfo&) = delete; - ArgInfo& operator=(const ArgInfo&) = delete; -}; - -template // TEnable is used for SFINAE checks -struct PyOpenCV_Converter -{ - //static inline bool to(PyObject* obj, T& p, const ArgInfo& info); - //static inline PyObject* from(const T& src); -}; - -// exception-safe pyopencv_to -template static -bool pyopencv_to_safe(PyObject* obj, _Tp& value, const ArgInfo& info) -{ - try - { - return pyopencv_to(obj, value, info); - } - catch (const std::exception &e) - { - PyErr_SetString(opencv_error, cv::format("Conversion error: %s, what: %s", info.name, e.what()).c_str()); - return false; - } - catch (...) - { - PyErr_SetString(opencv_error, cv::format("Conversion error: %s", info.name).c_str()); - return false; - } -} - -template static -bool pyopencv_to(PyObject* obj, T& p, const ArgInfo& info) { return PyOpenCV_Converter::to(obj, p, info); } - -template static -PyObject* pyopencv_from(const T& src) { return PyOpenCV_Converter::from(src); } - -static bool isPythonBindingsDebugEnabled() -{ - static bool param_debug = cv::utils::getConfigurationParameterBool("OPENCV_PYTHON_DEBUG", false); - return param_debug; -} - -static void emit_failmsg(PyObject * exc, const char *msg) -{ - static bool param_debug = isPythonBindingsDebugEnabled(); - if (param_debug) - { - CV_LOG_WARNING(NULL, "Bindings conversion failed: " << msg); - } - PyErr_SetString(exc, msg); -} - -static int failmsg(const char *fmt, ...) -{ - char str[1000]; - - va_list ap; - va_start(ap, fmt); - vsnprintf(str, sizeof(str), fmt, ap); - va_end(ap); - - emit_failmsg(PyExc_TypeError, str); - return 0; -} - -static PyObject* failmsgp(const char *fmt, ...) -{ - char str[1000]; - - va_list ap; - va_start(ap, fmt); - vsnprintf(str, sizeof(str), fmt, ap); - va_end(ap); - - emit_failmsg(PyExc_TypeError, str); - return 0; -} - -class PyAllowThreads -{ -public: - PyAllowThreads() : _state(PyEval_SaveThread()) {} - ~PyAllowThreads() - { - PyEval_RestoreThread(_state); - } -private: - PyThreadState* _state; -}; - -class PyEnsureGIL -{ -public: - PyEnsureGIL() : _state(PyGILState_Ensure()) {} - ~PyEnsureGIL() - { - PyGILState_Release(_state); - } -private: - PyGILState_STATE _state; -}; - -/** - * Light weight RAII wrapper for `PyObject*` owning references. - * In comparisson to C++11 `std::unique_ptr` with custom deleter, it provides - * implicit conversion functions that might be useful to initialize it with - * Python functions those returns owning references through the `PyObject**` - * e.g. `PyErr_Fetch` or directly pass it to functions those want to borrow - * reference to object (doesn't extend object lifetime) e.g. `PyObject_Str`. - */ -class PySafeObject -{ -public: - PySafeObject() : obj_(NULL) {} - explicit PySafeObject(PyObject* obj) : obj_(obj) {} - ~PySafeObject() - { - Py_CLEAR(obj_); - } - - operator PyObject*() - { - return obj_; - } - - operator PyObject**() - { - return &obj_; - } - - PyObject* release() - { - PyObject* obj = obj_; - obj_ = NULL; - return obj; - } - -private: - PyObject* obj_; - - // Explicitly disable copy operations - PySafeObject(const PySafeObject*); // = delete - PySafeObject& operator=(const PySafeObject&); // = delete -}; - -static void pyRaiseCVException(const cv::Exception &e) -{ - PyObject_SetAttrString(opencv_error, "file", PyString_FromString(e.file.c_str())); - PyObject_SetAttrString(opencv_error, "func", PyString_FromString(e.func.c_str())); - PyObject_SetAttrString(opencv_error, "line", PyInt_FromLong(e.line)); - PyObject_SetAttrString(opencv_error, "code", PyInt_FromLong(e.code)); - PyObject_SetAttrString(opencv_error, "msg", PyString_FromString(e.msg.c_str())); - PyObject_SetAttrString(opencv_error, "err", PyString_FromString(e.err.c_str())); - PyErr_SetString(opencv_error, e.what()); -} - -#define ERRWRAP2(expr) \ -try \ -{ \ - PyAllowThreads allowThreads; \ - expr; \ -} \ -catch (const cv::Exception &e) \ -{ \ - pyRaiseCVException(e); \ - return 0; \ -} \ -catch (const std::exception &e) \ -{ \ - PyErr_SetString(opencv_error, e.what()); \ - return 0; \ -} \ -catch (...) \ -{ \ - PyErr_SetString(opencv_error, "Unknown C++ exception from OpenCV code"); \ - return 0; \ -} +#include "cv2_util.hpp" +#include "cv2_numpy.hpp" +#include "cv2_convert.hpp" +#include "cv2_highgui.hpp" using namespace cv; - -namespace { -template -NPY_TYPES asNumpyType() -{ - return NPY_OBJECT; -} - -template<> -NPY_TYPES asNumpyType() -{ - return NPY_BOOL; -} - -#define CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(src, dst) \ - template<> \ - NPY_TYPES asNumpyType() \ - { \ - return NPY_##dst; \ - } \ - template<> \ - NPY_TYPES asNumpyType() \ - { \ - return NPY_U##dst; \ - } - -CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int8_t, INT8); - -CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int16_t, INT16); - -CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int32_t, INT32); - -CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int64_t, INT64); - -#undef CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION - -template<> -NPY_TYPES asNumpyType() -{ - return NPY_FLOAT; -} - -template<> -NPY_TYPES asNumpyType() -{ - return NPY_DOUBLE; -} - -template -PyArray_Descr* getNumpyTypeDescriptor() -{ - return PyArray_DescrFromType(asNumpyType()); -} - -template <> -PyArray_Descr* getNumpyTypeDescriptor() -{ -#if SIZE_MAX == ULONG_MAX - return PyArray_DescrFromType(NPY_ULONG); -#elif SIZE_MAX == ULLONG_MAX - return PyArray_DescrFromType(NPY_ULONGLONG); -#else - return PyArray_DescrFromType(NPY_UINT); -#endif -} - -template -bool isRepresentable(U value) { - return (std::numeric_limits::min() <= value) && (value <= std::numeric_limits::max()); -} - -template -bool canBeSafelyCasted(PyObject* obj, PyArray_Descr* to) -{ - return PyArray_CanCastTo(PyArray_DescrFromScalar(obj), to) != 0; -} - - -template<> -bool canBeSafelyCasted(PyObject* obj, PyArray_Descr* to) -{ - PyArray_Descr* from = PyArray_DescrFromScalar(obj); - if (PyArray_CanCastTo(from, to)) - { - return true; - } - else - { - // False negative scenarios: - // - Signed input is positive so it can be safely cast to unsigned output - // - Input has wider limits but value is representable within output limits - // - All the above - if (PyDataType_ISSIGNED(from)) - { - int64_t input = 0; - PyArray_CastScalarToCtype(obj, &input, getNumpyTypeDescriptor()); - return (input >= 0) && isRepresentable(static_cast(input)); - } - else - { - uint64_t input = 0; - PyArray_CastScalarToCtype(obj, &input, getNumpyTypeDescriptor()); - return isRepresentable(input); - } - return false; - } -} - - -template -bool parseNumpyScalar(PyObject* obj, T& value) -{ - if (PyArray_CheckScalar(obj)) - { - // According to the numpy documentation: - // There are 21 statically-defined PyArray_Descr objects for the built-in data-types - // So descriptor pointer is not owning. - PyArray_Descr* to = getNumpyTypeDescriptor(); - if (canBeSafelyCasted(obj, to)) - { - PyArray_CastScalarToCtype(obj, &value, to); - return true; - } - } - return false; -} - -TLSData > conversionErrorsTLS; - -inline void pyPrepareArgumentConversionErrorsStorage(std::size_t size) -{ - std::vector& conversionErrors = conversionErrorsTLS.getRef(); - conversionErrors.clear(); - conversionErrors.reserve(size); -} - -void pyRaiseCVOverloadException(const std::string& functionName) -{ - const std::vector& conversionErrors = conversionErrorsTLS.getRef(); - const std::size_t conversionErrorsCount = conversionErrors.size(); - if (conversionErrorsCount > 0) - { - // In modern std libraries small string optimization is used = no dynamic memory allocations, - // but it can be applied only for string with length < 18 symbols (in GCC) - const std::string bullet = "\n - "; - - // Estimate required buffer size - save dynamic memory allocations = faster - std::size_t requiredBufferSize = bullet.size() * conversionErrorsCount; - for (std::size_t i = 0; i < conversionErrorsCount; ++i) - { - requiredBufferSize += conversionErrors[i].size(); - } - - // Only string concatenation is required so std::string is way faster than - // std::ostringstream - std::string errorMessage("Overload resolution failed:"); - errorMessage.reserve(errorMessage.size() + requiredBufferSize); - for (std::size_t i = 0; i < conversionErrorsCount; ++i) - { - errorMessage += bullet; - errorMessage += conversionErrors[i]; - } - cv::Exception exception(CV_StsBadArg, errorMessage, functionName, "", -1); - pyRaiseCVException(exception); - } - else - { - cv::Exception exception(CV_StsInternal, "Overload resolution failed, but no errors reported", - functionName, "", -1); - pyRaiseCVException(exception); - } -} - -void pyPopulateArgumentConversionErrors() -{ - if (PyErr_Occurred()) - { - PySafeObject exception_type; - PySafeObject exception_value; - PySafeObject exception_traceback; - PyErr_Fetch(exception_type, exception_value, exception_traceback); - PyErr_NormalizeException(exception_type, exception_value, - exception_traceback); - - PySafeObject exception_message(PyObject_Str(exception_value)); - std::string message; - getUnicodeString(exception_message, message); -#ifdef CV_CXX11 - conversionErrorsTLS.getRef().push_back(std::move(message)); -#else - conversionErrorsTLS.getRef().push_back(message); -#endif - } -} - -struct SafeSeqItem -{ - PyObject * item; - SafeSeqItem(PyObject *obj, size_t idx) { item = PySequence_GetItem(obj, idx); } - ~SafeSeqItem() { Py_XDECREF(item); } - -private: - SafeSeqItem(const SafeSeqItem&); // = delete - SafeSeqItem& operator=(const SafeSeqItem&); // = delete -}; - -template -class RefWrapper -{ -public: - RefWrapper(T& item) : item_(item) {} - - T& get() CV_NOEXCEPT { return item_; } - -private: - T& item_; -}; - -// In order to support this conversion on 3.x branch - use custom reference_wrapper -// and C-style array instead of std::array -template -bool parseSequence(PyObject* obj, RefWrapper (&value)[N], const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (!PySequence_Check(obj)) - { - failmsg("Can't parse '%s'. Input argument doesn't provide sequence " - "protocol", info.name); - return false; - } - const std::size_t sequenceSize = PySequence_Size(obj); - if (sequenceSize != N) - { - failmsg("Can't parse '%s'. Expected sequence length %lu, got %lu", - info.name, N, sequenceSize); - return false; - } - for (std::size_t i = 0; i < N; ++i) - { - SafeSeqItem seqItem(obj, i); - if (!pyopencv_to(seqItem.item, value[i].get(), info)) - { - failmsg("Can't parse '%s'. Sequence item with index %lu has a " - "wrong type", info.name, i); - return false; - } - } - return true; -} -} // namespace - -namespace traits { -template -struct BooleanConstant -{ - static const bool value = Value; - typedef BooleanConstant type; -}; - -typedef BooleanConstant TrueType; -typedef BooleanConstant FalseType; - -template -struct VoidType { - typedef void type; -}; - -template -struct IsRepresentableAsMatDataType : FalseType -{ -}; - -template -struct IsRepresentableAsMatDataType::channel_type>::type> : TrueType -{ -}; -} // namespace traits - typedef std::vector vector_uchar; typedef std::vector vector_char; typedef std::vector vector_int; @@ -559,1634 +53,8 @@ typedef std::vector > vector_vector_Point3f; typedef std::vector > vector_vector_DMatch; typedef std::vector > vector_vector_KeyPoint; -class NumpyAllocator : public MatAllocator -{ -public: - NumpyAllocator() { stdAllocator = Mat::getStdAllocator(); } - ~NumpyAllocator() {} - - UMatData* allocate(PyObject* o, int dims, const int* sizes, int type, size_t* step) const - { - UMatData* u = new UMatData(this); - u->data = u->origdata = (uchar*)PyArray_DATA((PyArrayObject*) o); - npy_intp* _strides = PyArray_STRIDES((PyArrayObject*) o); - for( int i = 0; i < dims - 1; i++ ) - step[i] = (size_t)_strides[i]; - step[dims-1] = CV_ELEM_SIZE(type); - u->size = sizes[0]*step[0]; - u->userdata = o; - return u; - } - - UMatData* allocate(int dims0, const int* sizes, int type, void* data, size_t* step, AccessFlag flags, UMatUsageFlags usageFlags) const CV_OVERRIDE - { - if( data != 0 ) - { - // issue #6969: CV_Error(Error::StsAssert, "The data should normally be NULL!"); - // probably this is safe to do in such extreme case - return stdAllocator->allocate(dims0, sizes, type, data, step, flags, usageFlags); - } - PyEnsureGIL gil; - - int depth = CV_MAT_DEPTH(type); - int cn = CV_MAT_CN(type); - const int f = (int)(sizeof(size_t)/8); - int typenum = depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE : - depth == CV_16U ? NPY_USHORT : depth == CV_16S ? NPY_SHORT : - depth == CV_32S ? NPY_INT : depth == CV_32F ? NPY_FLOAT : - depth == CV_64F ? NPY_DOUBLE : f*NPY_ULONGLONG + (f^1)*NPY_UINT; - int i, dims = dims0; - cv::AutoBuffer _sizes(dims + 1); - for( i = 0; i < dims; i++ ) - _sizes[i] = sizes[i]; - if( cn > 1 ) - _sizes[dims++] = cn; - PyObject* o = PyArray_SimpleNew(dims, _sizes.data(), typenum); - if(!o) - CV_Error_(Error::StsError, ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims)); - return allocate(o, dims0, sizes, type, step); - } - - bool allocate(UMatData* u, AccessFlag accessFlags, UMatUsageFlags usageFlags) const CV_OVERRIDE - { - return stdAllocator->allocate(u, accessFlags, usageFlags); - } - - void deallocate(UMatData* u) const CV_OVERRIDE - { - if(!u) - return; - PyEnsureGIL gil; - CV_Assert(u->urefcount >= 0); - CV_Assert(u->refcount >= 0); - if(u->refcount == 0) - { - PyObject* o = (PyObject*)u->userdata; - Py_XDECREF(o); - delete u; - } - } - - const MatAllocator* stdAllocator; -}; - -NumpyAllocator g_numpyAllocator; - - -enum { ARG_NONE = 0, ARG_MAT = 1, ARG_SCALAR = 2 }; - -static bool isBool(PyObject* obj) CV_NOEXCEPT -{ - return PyArray_IsScalar(obj, Bool) || PyBool_Check(obj); -} - -template -static std::string pycv_dumpArray(const T* arr, int n) -{ - std::ostringstream out; - out << "["; - for (int i = 0; i < n; ++i) - out << " " << arr[i]; - out << " ]"; - return out.str(); -} - -// special case, when the converter needs full ArgInfo structure -static bool pyopencv_to(PyObject* o, Mat& m, const ArgInfo& info) -{ - if(!o || o == Py_None) - { - if( !m.data ) - m.allocator = &g_numpyAllocator; - return true; - } - - if( PyInt_Check(o) ) - { - double v[] = {static_cast(PyInt_AsLong((PyObject*)o)), 0., 0., 0.}; - m = Mat(4, 1, CV_64F, v).clone(); - return true; - } - if( PyFloat_Check(o) ) - { - double v[] = {PyFloat_AsDouble((PyObject*)o), 0., 0., 0.}; - m = Mat(4, 1, CV_64F, v).clone(); - return true; - } - if( PyTuple_Check(o) ) - { - int i, sz = (int)PyTuple_Size((PyObject*)o); - m = Mat(sz, 1, CV_64F); - for( i = 0; i < sz; i++ ) - { - PyObject* oi = PyTuple_GetItem(o, i); - if( PyInt_Check(oi) ) - m.at(i) = (double)PyInt_AsLong(oi); - else if( PyFloat_Check(oi) ) - m.at(i) = (double)PyFloat_AsDouble(oi); - else - { - failmsg("%s is not a numerical tuple", info.name); - m.release(); - return false; - } - } - return true; - } - - if( !PyArray_Check(o) ) - { - failmsg("%s is not a numpy array, neither a scalar", info.name); - return false; - } - - PyArrayObject* oarr = (PyArrayObject*) o; +// enum { ARG_NONE = 0, ARG_MAT = 1, ARG_SCALAR = 2 }; - bool needcopy = false, needcast = false; - int typenum = PyArray_TYPE(oarr), new_typenum = typenum; - int type = typenum == NPY_UBYTE ? CV_8U : - typenum == NPY_BYTE ? CV_8S : - typenum == NPY_USHORT ? CV_16U : - typenum == NPY_SHORT ? CV_16S : - typenum == NPY_INT ? CV_32S : - typenum == NPY_INT32 ? CV_32S : - typenum == NPY_FLOAT ? CV_32F : - typenum == NPY_DOUBLE ? CV_64F : -1; - - if( type < 0 ) - { - if( typenum == NPY_INT64 || typenum == NPY_UINT64 || typenum == NPY_LONG ) - { - needcopy = needcast = true; - new_typenum = NPY_INT; - type = CV_32S; - } - else - { - failmsg("%s data type = %d is not supported", info.name, typenum); - return false; - } - } - -#ifndef CV_MAX_DIM - const int CV_MAX_DIM = 32; -#endif - - int ndims = PyArray_NDIM(oarr); - if(ndims >= CV_MAX_DIM) - { - failmsg("%s dimensionality (=%d) is too high", info.name, ndims); - return false; - } - - size_t elemsize = CV_ELEM_SIZE1(type); - const npy_intp* _sizes = PyArray_DIMS(oarr); - const npy_intp* _strides = PyArray_STRIDES(oarr); - - CV_LOG_DEBUG(NULL, "Incoming ndarray '" << info.name << "': ndims=" << ndims << " _sizes=" << pycv_dumpArray(_sizes, ndims) << " _strides=" << pycv_dumpArray(_strides, ndims)); - - bool ismultichannel = ndims == 3 && _sizes[2] <= CV_CN_MAX; - if (pyopencv_Mat_TypePtr && PyObject_TypeCheck(o, pyopencv_Mat_TypePtr)) - { - bool wrapChannels = false; - PyObject* pyobj_wrap_channels = PyObject_GetAttrString(o, "wrap_channels"); - if (pyobj_wrap_channels) - { - if (!pyopencv_to_safe(pyobj_wrap_channels, wrapChannels, ArgInfo("cv.Mat.wrap_channels", 0))) - { - // TODO extra message - Py_DECREF(pyobj_wrap_channels); - return false; - } - Py_DECREF(pyobj_wrap_channels); - } - ismultichannel = wrapChannels && ndims >= 1; - } - - for( int i = ndims-1; i >= 0 && !needcopy; i-- ) - { - // these checks handle cases of - // a) multi-dimensional (ndims > 2) arrays, as well as simpler 1- and 2-dimensional cases - // b) transposed arrays, where _strides[] elements go in non-descending order - // c) flipped arrays, where some of _strides[] elements are negative - // the _sizes[i] > 1 is needed to avoid spurious copies when NPY_RELAXED_STRIDES is set - if( (i == ndims-1 && _sizes[i] > 1 && (size_t)_strides[i] != elemsize) || - (i < ndims-1 && _sizes[i] > 1 && _strides[i] < _strides[i+1]) ) - needcopy = true; - } - - if (ismultichannel) - { - int channels = ndims >= 1 ? (int)_sizes[ndims - 1] : 1; - if (channels > CV_CN_MAX) - { - failmsg("%s unable to wrap channels, too high (%d > CV_CN_MAX=%d)", info.name, (int)channels, (int)CV_CN_MAX); - return false; - } - ndims--; - type |= CV_MAKETYPE(0, channels); - - if (ndims >= 1 && _strides[ndims - 1] != (npy_intp)elemsize*_sizes[ndims]) - needcopy = true; - - elemsize = CV_ELEM_SIZE(type); - } - - if (needcopy) - { - if (info.outputarg) - { - failmsg("Layout of the output array %s is incompatible with cv::Mat", info.name); - return false; - } - - if( needcast ) { - o = PyArray_Cast(oarr, new_typenum); - oarr = (PyArrayObject*) o; - } - else { - oarr = PyArray_GETCONTIGUOUS(oarr); - o = (PyObject*) oarr; - } - - _strides = PyArray_STRIDES(oarr); - } - - int size[CV_MAX_DIM+1] = {}; - size_t step[CV_MAX_DIM+1] = {}; - - // Normalize strides in case NPY_RELAXED_STRIDES is set - size_t default_step = elemsize; - for ( int i = ndims - 1; i >= 0; --i ) - { - size[i] = (int)_sizes[i]; - if ( size[i] > 1 ) - { - step[i] = (size_t)_strides[i]; - default_step = step[i] * size[i]; - } - else - { - step[i] = default_step; - default_step *= size[i]; - } - } - - // handle degenerate case - // FIXIT: Don't force 1D for Scalars - if( ndims == 0) { - size[ndims] = 1; - step[ndims] = elemsize; - ndims++; - } - -#if 1 - CV_LOG_DEBUG(NULL, "Construct Mat: ndims=" << ndims << " size=" << pycv_dumpArray(size, ndims) << " step=" << pycv_dumpArray(step, ndims) << " type=" << cv::typeToString(type)); -#endif - - m = Mat(ndims, size, type, PyArray_DATA(oarr), step); - m.u = g_numpyAllocator.allocate(o, ndims, size, type, step); - m.addref(); - - if( !needcopy ) - { - Py_INCREF(o); - } - m.allocator = &g_numpyAllocator; - - return true; -} - -template -bool pyopencv_to(PyObject* o, Matx<_Tp, m, n>& mx, const ArgInfo& info) -{ - Mat tmp; - if (!pyopencv_to(o, tmp, info)) { - return false; - } - - tmp.copyTo(mx); - return true; -} - -template -bool pyopencv_to(PyObject* o, Vec<_Tp, cn>& vec, const ArgInfo& info) -{ - return pyopencv_to(o, (Matx<_Tp, cn, 1>&)vec, info); -} - -template<> -PyObject* pyopencv_from(const Mat& m) -{ - if( !m.data ) - Py_RETURN_NONE; - Mat temp, *p = (Mat*)&m; - if(!p->u || p->allocator != &g_numpyAllocator) - { - temp.allocator = &g_numpyAllocator; - ERRWRAP2(m.copyTo(temp)); - p = &temp; - } - PyObject* o = (PyObject*)p->u->userdata; - Py_INCREF(o); - return o; -} - -template -PyObject* pyopencv_from(const Matx<_Tp, m, n>& matx) -{ - return pyopencv_from(Mat(matx)); -} - -template -struct PyOpenCV_Converter< cv::Ptr > -{ - static PyObject* from(const cv::Ptr& p) - { - if (!p) - Py_RETURN_NONE; - return pyopencv_from(*p); - } - static bool to(PyObject *o, Ptr& p, const ArgInfo& info) - { - if (!o || o == Py_None) - return true; - p = makePtr(); - return pyopencv_to(o, *p, info); - } -}; - -template<> -bool pyopencv_to(PyObject* obj, void*& ptr, const ArgInfo& info) -{ - CV_UNUSED(info); - if (!obj || obj == Py_None) - return true; - - if (!PyLong_Check(obj)) - return false; - ptr = PyLong_AsVoidPtr(obj); - return ptr != NULL && !PyErr_Occurred(); -} - -static PyObject* pyopencv_from(void*& ptr) -{ - return PyLong_FromVoidPtr(ptr); -} - -static bool pyopencv_to(PyObject *o, Scalar& s, const ArgInfo& info) -{ - if(!o || o == Py_None) - return true; - if (PySequence_Check(o)) { - if (4 < PySequence_Size(o)) - { - failmsg("Scalar value for argument '%s' is longer than 4", info.name); - return false; - } - for (Py_ssize_t i = 0; i < PySequence_Size(o); i++) { - SafeSeqItem item_wrap(o, i); - PyObject *item = item_wrap.item; - if (PyFloat_Check(item) || PyInt_Check(item)) { - s[(int)i] = PyFloat_AsDouble(item); - } else { - failmsg("Scalar value for argument '%s' is not numeric", info.name); - return false; - } - } - } else { - if (PyFloat_Check(o) || PyInt_Check(o)) { - s[0] = PyFloat_AsDouble(o); - } else { - failmsg("Scalar value for argument '%s' is not numeric", info.name); - return false; - } - } - return true; -} - -template<> -PyObject* pyopencv_from(const Scalar& src) -{ - return Py_BuildValue("(dddd)", src[0], src[1], src[2], src[3]); -} - -template<> -PyObject* pyopencv_from(const bool& value) -{ - return PyBool_FromLong(value); -} - -template<> -bool pyopencv_to(PyObject* obj, bool& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (isBool(obj) || PyArray_IsIntegerScalar(obj)) - { - npy_bool npy_value = NPY_FALSE; - const int ret_code = PyArray_BoolConverter(obj, &npy_value); - if (ret_code >= 0) - { - value = (npy_value == NPY_TRUE); - return true; - } - } - failmsg("Argument '%s' is not convertable to bool", info.name); - return false; -} - -template<> -PyObject* pyopencv_from(const size_t& value) -{ - return PyLong_FromSize_t(value); -} - -template<> -bool pyopencv_to(PyObject* obj, size_t& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (isBool(obj)) - { - failmsg("Argument '%s' must be integer type, not bool", info.name); - return false; - } - if (PyArray_IsIntegerScalar(obj)) - { - if (PyLong_Check(obj)) - { -#if defined(CV_PYTHON_3) - value = PyLong_AsSize_t(obj); -#else - #if ULONG_MAX == SIZE_MAX - value = PyLong_AsUnsignedLong(obj); - #else - value = PyLong_AsUnsignedLongLong(obj); - #endif -#endif - } -#if !defined(CV_PYTHON_3) - // Python 2.x has PyIntObject which is not a subtype of PyLongObject - // Overflow check here is unnecessary because object will be converted to long on the - // interpreter side - else if (PyInt_Check(obj)) - { - const long res = PyInt_AsLong(obj); - if (res < 0) { - failmsg("Argument '%s' can not be safely parsed to 'size_t'", info.name); - return false; - } - #if ULONG_MAX == SIZE_MAX - value = PyInt_AsUnsignedLongMask(obj); - #else - value = PyInt_AsUnsignedLongLongMask(obj); - #endif - } -#endif - else - { - const bool isParsed = parseNumpyScalar(obj, value); - if (!isParsed) { - failmsg("Argument '%s' can not be safely parsed to 'size_t'", info.name); - return false; - } - } - } - else - { - failmsg("Argument '%s' is required to be an integer", info.name); - return false; - } - return !PyErr_Occurred(); -} - -template<> -PyObject* pyopencv_from(const int& value) -{ - return PyInt_FromLong(value); -} - -template<> -bool pyopencv_to(PyObject* obj, int& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (isBool(obj)) - { - failmsg("Argument '%s' must be integer, not bool", info.name); - return false; - } - if (PyArray_IsIntegerScalar(obj)) - { - value = PyArray_PyIntAsInt(obj); - } - else - { - failmsg("Argument '%s' is required to be an integer", info.name); - return false; - } - return !CV_HAS_CONVERSION_ERROR(value); -} - -// There is conflict between "size_t" and "unsigned int". -// They are the same type on some 32-bit platforms. -template -struct PyOpenCV_Converter - < T, typename std::enable_if< std::is_same::value && !std::is_same::value >::type > -{ - static inline PyObject* from(const unsigned int& value) - { - return PyLong_FromUnsignedLong(value); - } - - static inline bool to(PyObject* obj, unsigned int& value, const ArgInfo& info) - { - CV_UNUSED(info); - if(!obj || obj == Py_None) - return true; - if(PyInt_Check(obj)) - value = (unsigned int)PyInt_AsLong(obj); - else if(PyLong_Check(obj)) - value = (unsigned int)PyLong_AsLong(obj); - else - return false; - return value != (unsigned int)-1 || !PyErr_Occurred(); - } -}; - -template<> -PyObject* pyopencv_from(const uchar& value) -{ - return PyInt_FromLong(value); -} - -template<> -bool pyopencv_to(PyObject* obj, uchar& value, const ArgInfo& info) -{ - CV_UNUSED(info); - if(!obj || obj == Py_None) - return true; - int ivalue = (int)PyInt_AsLong(obj); - value = cv::saturate_cast(ivalue); - return ivalue != -1 || !PyErr_Occurred(); -} - -template<> -bool pyopencv_to(PyObject* obj, char& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (isBool(obj)) - { - failmsg("Argument '%s' must be an integer, not bool", info.name); - return false; - } - if (PyArray_IsIntegerScalar(obj)) - { - value = saturate_cast(PyArray_PyIntAsInt(obj)); - } - else - { - failmsg("Argument '%s' is required to be an integer", info.name); - return false; - } - return !CV_HAS_CONVERSION_ERROR(value); -} - -template<> -PyObject* pyopencv_from(const double& value) -{ - return PyFloat_FromDouble(value); -} - -template<> -bool pyopencv_to(PyObject* obj, double& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (isBool(obj)) - { - failmsg("Argument '%s' must be double, not bool", info.name); - return false; - } - if (PyArray_IsPythonNumber(obj)) - { - if (PyLong_Check(obj)) - { - value = PyLong_AsDouble(obj); - } - else - { - value = PyFloat_AsDouble(obj); - } - } - else if (PyArray_CheckScalar(obj)) - { - const bool isParsed = parseNumpyScalar(obj, value); - if (!isParsed) { - failmsg("Argument '%s' can not be safely parsed to 'double'", info.name); - return false; - } - } - else - { - failmsg("Argument '%s' can not be treated as a double", info.name); - return false; - } - return !PyErr_Occurred(); -} - -template<> -PyObject* pyopencv_from(const float& value) -{ - return PyFloat_FromDouble(value); -} - -template<> -bool pyopencv_to(PyObject* obj, float& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (isBool(obj)) - { - failmsg("Argument '%s' must be float, not bool", info.name); - return false; - } - if (PyArray_IsPythonNumber(obj)) - { - if (PyLong_Check(obj)) - { - double res = PyLong_AsDouble(obj); - value = static_cast(res); - } - else - { - double res = PyFloat_AsDouble(obj); - value = static_cast(res); - } - } - else if (PyArray_CheckScalar(obj)) - { - const bool isParsed = parseNumpyScalar(obj, value); - if (!isParsed) { - failmsg("Argument '%s' can not be safely parsed to 'float'", info.name); - return false; - } - } - else - { - failmsg("Argument '%s' can't be treated as a float", info.name); - return false; - } - return !PyErr_Occurred(); -} - -template<> -PyObject* pyopencv_from(const int64& value) -{ - return PyLong_FromLongLong(value); -} - -template<> -PyObject* pyopencv_from(const String& value) -{ - return PyString_FromString(value.empty() ? "" : value.c_str()); -} - -#if CV_VERSION_MAJOR == 3 -template<> -PyObject* pyopencv_from(const std::string& value) -{ - return PyString_FromString(value.empty() ? "" : value.c_str()); -} -#endif - -template<> -bool pyopencv_to(PyObject* obj, String &value, const ArgInfo& info) -{ - if(!obj || obj == Py_None) - { - return true; - } - std::string str; - if (getUnicodeString(obj, str)) - { - value = str; - return true; - } - else - { - // If error hasn't been already set by Python conversion functions - if (!PyErr_Occurred()) - { - // Direct access to underlying slots of PyObjectType is not allowed - // when limited API is enabled -#ifdef Py_LIMITED_API - failmsg("Can't convert object to 'str' for '%s'", info.name); -#else - failmsg("Can't convert object of type '%s' to 'str' for '%s'", - obj->ob_type->tp_name, info.name); -#endif - } - } - return false; -} - -template<> -bool pyopencv_to(PyObject* obj, Size& sz, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(sz.width), - RefWrapper(sz.height)}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Size& sz) -{ - return Py_BuildValue("(ii)", sz.width, sz.height); -} - -template<> -bool pyopencv_to(PyObject* obj, Size_& sz, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(sz.width), - RefWrapper(sz.height)}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Size_& sz) -{ - return Py_BuildValue("(ff)", sz.width, sz.height); -} - -template<> -bool pyopencv_to(PyObject* obj, Rect& r, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(r.x), RefWrapper(r.y), - RefWrapper(r.width), - RefWrapper(r.height)}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Rect& r) -{ - return Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height); -} - -template<> -bool pyopencv_to(PyObject* obj, Rect2d& r, const ArgInfo& info) -{ - RefWrapper values[] = { - RefWrapper(r.x), RefWrapper(r.y), - RefWrapper(r.width), RefWrapper(r.height)}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Rect2d& r) -{ - return Py_BuildValue("(dddd)", r.x, r.y, r.width, r.height); -} - -template<> -bool pyopencv_to(PyObject* obj, Range& r, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (PyObject_Size(obj) == 0) - { - r = Range::all(); - return true; - } - RefWrapper values[] = {RefWrapper(r.start), RefWrapper(r.end)}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Range& r) -{ - return Py_BuildValue("(ii)", r.start, r.end); -} - -template<> -bool pyopencv_to(PyObject* obj, Point& p, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(p.x), RefWrapper(p.y)}; - return parseSequence(obj, values, info); -} - -template <> -bool pyopencv_to(PyObject* obj, Point2f& p, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(p.x), - RefWrapper(p.y)}; - return parseSequence(obj, values, info); -} - -template<> -bool pyopencv_to(PyObject* obj, Point2d& p, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(p.x), - RefWrapper(p.y)}; - return parseSequence(obj, values, info); -} - -template<> -bool pyopencv_to(PyObject* obj, Point3f& p, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(p.x), - RefWrapper(p.y), - RefWrapper(p.z)}; - return parseSequence(obj, values, info); -} - -template<> -bool pyopencv_to(PyObject* obj, Point3d& p, const ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(p.x), - RefWrapper(p.y), - RefWrapper(p.z)}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Point& p) -{ - return Py_BuildValue("(ii)", p.x, p.y); -} - -template<> -PyObject* pyopencv_from(const Point2f& p) -{ - return Py_BuildValue("(dd)", p.x, p.y); -} - -template<> -PyObject* pyopencv_from(const Point3f& p) -{ - return Py_BuildValue("(ddd)", p.x, p.y, p.z); -} - -static bool pyopencv_to(PyObject* obj, Vec4d& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), - RefWrapper(v[2]), RefWrapper(v[3])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec4f& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), - RefWrapper(v[2]), RefWrapper(v[3])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec4i& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), - RefWrapper(v[2]), RefWrapper(v[3])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec3d& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), - RefWrapper(v[1]), - RefWrapper(v[2])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec3f& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), - RefWrapper(v[1]), - RefWrapper(v[2])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec3i& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), - RefWrapper(v[2])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec2d& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), - RefWrapper(v[1])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec2f& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), - RefWrapper(v[1])}; - return parseSequence(obj, values, info); -} - -static bool pyopencv_to(PyObject* obj, Vec2i& v, ArgInfo& info) -{ - RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1])}; - return parseSequence(obj, values, info); -} - -template<> -PyObject* pyopencv_from(const Vec4d& v) -{ - return Py_BuildValue("(dddd)", v[0], v[1], v[2], v[3]); -} - -template<> -PyObject* pyopencv_from(const Vec4f& v) -{ - return Py_BuildValue("(ffff)", v[0], v[1], v[2], v[3]); -} - -template<> -PyObject* pyopencv_from(const Vec4i& v) -{ - return Py_BuildValue("(iiii)", v[0], v[1], v[2], v[3]); -} - -template<> -PyObject* pyopencv_from(const Vec3d& v) -{ - return Py_BuildValue("(ddd)", v[0], v[1], v[2]); -} - -template<> -PyObject* pyopencv_from(const Vec3f& v) -{ - return Py_BuildValue("(fff)", v[0], v[1], v[2]); -} - -template<> -PyObject* pyopencv_from(const Vec3i& v) -{ - return Py_BuildValue("(iii)", v[0], v[1], v[2]); -} - -template<> -PyObject* pyopencv_from(const Vec2d& v) -{ - return Py_BuildValue("(dd)", v[0], v[1]); -} - -template<> -PyObject* pyopencv_from(const Vec2f& v) -{ - return Py_BuildValue("(ff)", v[0], v[1]); -} - -template<> -PyObject* pyopencv_from(const Vec2i& v) -{ - return Py_BuildValue("(ii)", v[0], v[1]); -} - -template<> -PyObject* pyopencv_from(const Point2d& p) -{ - return Py_BuildValue("(dd)", p.x, p.y); -} - -template<> -PyObject* pyopencv_from(const Point3d& p) -{ - return Py_BuildValue("(ddd)", p.x, p.y, p.z); -} - -template<> -PyObject* pyopencv_from(const std::pair& src) -{ - return Py_BuildValue("(id)", src.first, src.second); -} - -template<> -bool pyopencv_to(PyObject* obj, TermCriteria& dst, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (!PySequence_Check(obj)) - { - failmsg("Can't parse '%s' as TermCriteria." - "Input argument doesn't provide sequence protocol", - info.name); - return false; - } - const std::size_t sequenceSize = PySequence_Size(obj); - if (sequenceSize != 3) { - failmsg("Can't parse '%s' as TermCriteria. Expected sequence length 3, " - "got %lu", - info.name, sequenceSize); - return false; - } - { - const String typeItemName = format("'%s' criteria type", info.name); - const ArgInfo typeItemInfo(typeItemName.c_str(), false); - SafeSeqItem typeItem(obj, 0); - if (!pyopencv_to(typeItem.item, dst.type, typeItemInfo)) - { - return false; - } - } - { - const String maxCountItemName = format("'%s' max count", info.name); - const ArgInfo maxCountItemInfo(maxCountItemName.c_str(), false); - SafeSeqItem maxCountItem(obj, 1); - if (!pyopencv_to(maxCountItem.item, dst.maxCount, maxCountItemInfo)) - { - return false; - } - } - { - const String epsilonItemName = format("'%s' epsilon", info.name); - const ArgInfo epsilonItemInfo(epsilonItemName.c_str(), false); - SafeSeqItem epsilonItem(obj, 2); - if (!pyopencv_to(epsilonItem.item, dst.epsilon, epsilonItemInfo)) - { - return false; - } - } - return true; -} - -template<> -PyObject* pyopencv_from(const TermCriteria& src) -{ - return Py_BuildValue("(iid)", src.type, src.maxCount, src.epsilon); -} - -template<> -bool pyopencv_to(PyObject* obj, RotatedRect& dst, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (!PySequence_Check(obj)) - { - failmsg("Can't parse '%s' as RotatedRect." - "Input argument doesn't provide sequence protocol", - info.name); - return false; - } - const std::size_t sequenceSize = PySequence_Size(obj); - if (sequenceSize != 3) - { - failmsg("Can't parse '%s' as RotatedRect. Expected sequence length 3, got %lu", - info.name, sequenceSize); - return false; - } - { - const String centerItemName = format("'%s' center point", info.name); - const ArgInfo centerItemInfo(centerItemName.c_str(), false); - SafeSeqItem centerItem(obj, 0); - if (!pyopencv_to(centerItem.item, dst.center, centerItemInfo)) - { - return false; - } - } - { - const String sizeItemName = format("'%s' size", info.name); - const ArgInfo sizeItemInfo(sizeItemName.c_str(), false); - SafeSeqItem sizeItem(obj, 1); - if (!pyopencv_to(sizeItem.item, dst.size, sizeItemInfo)) - { - return false; - } - } - { - const String angleItemName = format("'%s' angle", info.name); - const ArgInfo angleItemInfo(angleItemName.c_str(), false); - SafeSeqItem angleItem(obj, 2); - if (!pyopencv_to(angleItem.item, dst.angle, angleItemInfo)) - { - return false; - } - } - return true; -} - -template<> -PyObject* pyopencv_from(const RotatedRect& src) -{ - return Py_BuildValue("((ff)(ff)f)", src.center.x, src.center.y, src.size.width, src.size.height, src.angle); -} - -template<> -PyObject* pyopencv_from(const Moments& m) -{ - return Py_BuildValue("{s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d}", - "m00", m.m00, "m10", m.m10, "m01", m.m01, - "m20", m.m20, "m11", m.m11, "m02", m.m02, - "m30", m.m30, "m21", m.m21, "m12", m.m12, "m03", m.m03, - "mu20", m.mu20, "mu11", m.mu11, "mu02", m.mu02, - "mu30", m.mu30, "mu21", m.mu21, "mu12", m.mu12, "mu03", m.mu03, - "nu20", m.nu20, "nu11", m.nu11, "nu02", m.nu02, - "nu30", m.nu30, "nu21", m.nu21, "nu12", m.nu12, "nu03", m.nu03); -} - -template -struct pyopencvVecConverter; - -template -bool pyopencv_to(PyObject* obj, std::vector& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - return pyopencvVecConverter::to(obj, value, info); -} - -template -PyObject* pyopencv_from(const std::vector& value) -{ - return pyopencvVecConverter::from(value); -} - -template -static bool pyopencv_to_generic_vec(PyObject* obj, std::vector& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (!PySequence_Check(obj)) - { - failmsg("Can't parse '%s'. Input argument doesn't provide sequence protocol", info.name); - return false; - } - const size_t n = static_cast(PySequence_Size(obj)); - value.resize(n); - for (size_t i = 0; i < n; i++) - { - SafeSeqItem item_wrap(obj, i); - if (!pyopencv_to(item_wrap.item, value[i], info)) - { - failmsg("Can't parse '%s'. Sequence item with index %lu has a wrong type", info.name, i); - return false; - } - } - return true; -} - -template<> inline bool pyopencv_to_generic_vec(PyObject* obj, std::vector& value, const ArgInfo& info) -{ - if (!obj || obj == Py_None) - { - return true; - } - if (!PySequence_Check(obj)) - { - failmsg("Can't parse '%s'. Input argument doesn't provide sequence protocol", info.name); - return false; - } - const size_t n = static_cast(PySequence_Size(obj)); - value.resize(n); - for (size_t i = 0; i < n; i++) - { - SafeSeqItem item_wrap(obj, i); - bool elem{}; - if (!pyopencv_to(item_wrap.item, elem, info)) - { - failmsg("Can't parse '%s'. Sequence item with index %lu has a wrong type", info.name, i); - return false; - } - value[i] = elem; - } - return true; -} - - -template -static PyObject* pyopencv_from_generic_vec(const std::vector& value) -{ - Py_ssize_t n = static_cast(value.size()); - PySafeObject seq(PyTuple_New(n)); - for (Py_ssize_t i = 0; i < n; i++) - { - PyObject* item = pyopencv_from(value[i]); - // If item can't be assigned - PyTuple_SetItem raises exception and returns -1. - if (!item || PyTuple_SetItem(seq, i, item) == -1) - { - return NULL; - } - } - return seq.release(); -} - -template<> inline PyObject* pyopencv_from_generic_vec(const std::vector& value) -{ - Py_ssize_t n = static_cast(value.size()); - PySafeObject seq(PyTuple_New(n)); - for (Py_ssize_t i = 0; i < n; i++) - { - bool elem = value[i]; - PyObject* item = pyopencv_from(elem); - // If item can't be assigned - PyTuple_SetItem raises exception and returns -1. - if (!item || PyTuple_SetItem(seq, i, item) == -1) - { - return NULL; - } - } - return seq.release(); -} - - -template -inline typename std::enable_if::type -convert_to_python_tuple(const std::tuple&, PyObject*) { } - -template -inline typename std::enable_if::type -convert_to_python_tuple(const std::tuple& cpp_tuple, PyObject* py_tuple) -{ - PyObject* item = pyopencv_from(std::get(cpp_tuple)); - - if (!item) - return; - - PyTuple_SetItem(py_tuple, I, item); - convert_to_python_tuple(cpp_tuple, py_tuple); -} - - -template -PyObject* pyopencv_from(const std::tuple& cpp_tuple) -{ - size_t size = sizeof...(Ts); - PyObject* py_tuple = PyTuple_New(size); - convert_to_python_tuple(cpp_tuple, py_tuple); - size_t actual_size = PyTuple_Size(py_tuple); - - if (actual_size < size) - { - Py_DECREF(py_tuple); - return NULL; - } - - return py_tuple; -} - -template -struct pyopencvVecConverter -{ - typedef typename std::vector::iterator VecIt; - - static bool to(PyObject* obj, std::vector& value, const ArgInfo& info) - { - if (!PyArray_Check(obj)) - { - return pyopencv_to_generic_vec(obj, value, info); - } - // If user passed an array it is possible to make faster conversions in several cases - PyArrayObject* array_obj = reinterpret_cast(obj); - const NPY_TYPES target_type = asNumpyType(); - const NPY_TYPES source_type = static_cast(PyArray_TYPE(array_obj)); - if (target_type == NPY_OBJECT) - { - // Non-planar arrays representing objects (e.g. array of N Rect is an array of shape Nx4) have NPY_OBJECT - // as their target type. - return pyopencv_to_generic_vec(obj, value, info); - } - if (PyArray_NDIM(array_obj) > 1) - { - failmsg("Can't parse %dD array as '%s' vector argument", PyArray_NDIM(array_obj), info.name); - return false; - } - if (target_type != source_type) - { - // Source type requires conversion - // Allowed conversions for target type is handled in the corresponding pyopencv_to function - return pyopencv_to_generic_vec(obj, value, info); - } - // For all other cases, all array data can be directly copied to std::vector data - // Simple `memcpy` is not possible because NumPy array can reference a slice of the bigger array: - // ``` - // arr = np.ones((8, 4, 5), dtype=np.int32) - // convertible_to_vector_of_int = arr[:, 0, 1] - // ``` - value.resize(static_cast(PyArray_SIZE(array_obj))); - const npy_intp item_step = PyArray_STRIDE(array_obj, 0) / PyArray_ITEMSIZE(array_obj); - const Tp* data_ptr = static_cast(PyArray_DATA(array_obj)); - for (VecIt it = value.begin(); it != value.end(); ++it, data_ptr += item_step) { - *it = *data_ptr; - } - return true; - } - - static PyObject* from(const std::vector& value) - { - if (value.empty()) - { - return PyTuple_New(0); - } - return from(value, ::traits::IsRepresentableAsMatDataType()); - } - -private: - static PyObject* from(const std::vector& value, ::traits::FalseType) - { - // Underlying type is not representable as Mat Data Type - return pyopencv_from_generic_vec(value); - } - - static PyObject* from(const std::vector& value, ::traits::TrueType) - { - // Underlying type is representable as Mat Data Type, so faster return type is available - typedef DataType DType; - typedef typename DType::channel_type UnderlyingArrayType; - - // If Mat is always exposed as NumPy array this code path can be reduced to the following snipped: - // Mat src(value); - // PyObject* array = pyopencv_from(src); - // return PyArray_Squeeze(reinterpret_cast(array)); - // This puts unnecessary restrictions on Mat object those might be avoided without losing the performance. - // Moreover, this version is a bit faster, because it doesn't create temporary objects with reference counting. - - const NPY_TYPES target_type = asNumpyType(); - const int cols = DType::channels; - PyObject* array = NULL; - if (cols == 1) - { - npy_intp dims = static_cast(value.size()); - array = PyArray_SimpleNew(1, &dims, target_type); - } - else - { - npy_intp dims[2] = {static_cast(value.size()), cols}; - array = PyArray_SimpleNew(2, dims, target_type); - } - if(!array) - { - // NumPy arrays with shape (N, 1) and (N) are not equal, so correct error message should distinguish - // them too. - String shape; - if (cols > 1) - { - shape = format("(%d x %d)", static_cast(value.size()), cols); - } - else - { - shape = format("(%d)", static_cast(value.size())); - } - const String error_message = format("Can't allocate NumPy array for vector with dtype=%d and shape=%s", - static_cast(target_type), shape.c_str()); - emit_failmsg(PyExc_MemoryError, error_message.c_str()); - return array; - } - // Fill the array - PyArrayObject* array_obj = reinterpret_cast(array); - UnderlyingArrayType* array_data = static_cast(PyArray_DATA(array_obj)); - // if Tp is representable as Mat DataType, so the following cast is pretty safe... - const UnderlyingArrayType* value_data = reinterpret_cast(value.data()); - memcpy(array_data, value_data, sizeof(UnderlyingArrayType) * value.size() * static_cast(cols)); - return array; - } -}; - -static int OnError(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata) -{ - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - PyObject *on_error = (PyObject*)userdata; - PyObject *args = Py_BuildValue("isssi", status, func_name, err_msg, file_name, line); - - PyObject *r = PyObject_Call(on_error, args, NULL); - if (r == NULL) { - PyErr_Print(); - } else { - Py_DECREF(r); - } - - Py_DECREF(args); - PyGILState_Release(gstate); - - return 0; // The return value isn't used -} - -static PyObject *pycvRedirectError(PyObject*, PyObject *args, PyObject *kw) -{ - const char *keywords[] = { "on_error", NULL }; - PyObject *on_error; - - if (!PyArg_ParseTupleAndKeywords(args, kw, "O", (char**)keywords, &on_error)) - return NULL; - - if ((on_error != Py_None) && !PyCallable_Check(on_error)) { - PyErr_SetString(PyExc_TypeError, "on_error must be callable"); - return NULL; - } - - // Keep track of the previous handler parameter, so we can decref it when no longer used - static PyObject* last_on_error = NULL; - if (last_on_error) { - Py_DECREF(last_on_error); - last_on_error = NULL; - } - - if (on_error == Py_None) { - ERRWRAP2(redirectError(NULL)); - } else { - last_on_error = on_error; - Py_INCREF(last_on_error); - ERRWRAP2(redirectError(OnError, last_on_error)); - } - Py_RETURN_NONE; -} - -static void OnMouse(int event, int x, int y, int flags, void* param) -{ - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - PyObject *o = (PyObject*)param; - PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1)); - - PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); - if (r == NULL) - PyErr_Print(); - else - Py_DECREF(r); - Py_DECREF(args); - PyGILState_Release(gstate); -} - -#ifdef HAVE_OPENCV_HIGHGUI -static PyObject *pycvSetMouseCallback(PyObject*, PyObject *args, PyObject *kw) -{ - const char *keywords[] = { "window_name", "on_mouse", "param", NULL }; - char* name; - PyObject *on_mouse; - PyObject *param = NULL; - - if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, ¶m)) - return NULL; - if (!PyCallable_Check(on_mouse)) { - PyErr_SetString(PyExc_TypeError, "on_mouse must be callable"); - return NULL; - } - if (param == NULL) { - param = Py_None; - } - PyObject* py_callback_info = Py_BuildValue("OO", on_mouse, param); - static std::map registered_callbacks; - std::map::iterator i = registered_callbacks.find(name); - if (i != registered_callbacks.end()) - { - Py_DECREF(i->second); - i->second = py_callback_info; - } - else - { - registered_callbacks.insert(std::pair(std::string(name), py_callback_info)); - } - ERRWRAP2(setMouseCallback(name, OnMouse, py_callback_info)); - Py_RETURN_NONE; -} -#endif - -static void OnChange(int pos, void *param) -{ - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - PyObject *o = (PyObject*)param; - PyObject *args = Py_BuildValue("(i)", pos); - PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); - if (r == NULL) - PyErr_Print(); - else - Py_DECREF(r); - Py_DECREF(args); - PyGILState_Release(gstate); -} - -#ifdef HAVE_OPENCV_HIGHGUI -// workaround for #20408, use nullptr, set value later -static int _createTrackbar(const String &trackbar_name, const String &window_name, int value, int count, - TrackbarCallback onChange, PyObject* py_callback_info) -{ - int n = createTrackbar(trackbar_name, window_name, NULL, count, onChange, py_callback_info); - setTrackbarPos(trackbar_name, window_name, value); - return n; -} -static PyObject *pycvCreateTrackbar(PyObject*, PyObject *args) -{ - PyObject *on_change; - char* trackbar_name; - char* window_name; - int value; - int count; - - if (!PyArg_ParseTuple(args, "ssiiO", &trackbar_name, &window_name, &value, &count, &on_change)) - return NULL; - if (!PyCallable_Check(on_change)) { - PyErr_SetString(PyExc_TypeError, "on_change must be callable"); - return NULL; - } - PyObject* py_callback_info = Py_BuildValue("OO", on_change, Py_None); - std::string name = std::string(window_name) + ":" + std::string(trackbar_name); - static std::map registered_callbacks; - std::map::iterator i = registered_callbacks.find(name); - if (i != registered_callbacks.end()) - { - Py_DECREF(i->second); - i->second = py_callback_info; - } - else - { - registered_callbacks.insert(std::pair(name, py_callback_info)); - } - ERRWRAP2(_createTrackbar(trackbar_name, window_name, value, count, OnChange, py_callback_info)); - Py_RETURN_NONE; -} - -static void OnButtonChange(int state, void *param) -{ - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - PyObject *o = (PyObject*)param; - PyObject *args; - if(PyTuple_GetItem(o, 1) != NULL) - { - args = Py_BuildValue("(iO)", state, PyTuple_GetItem(o,1)); - } - else - { - args = Py_BuildValue("(i)", state); - } - - PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); - if (r == NULL) - PyErr_Print(); - else - Py_DECREF(r); - Py_DECREF(args); - PyGILState_Release(gstate); -} - -static PyObject *pycvCreateButton(PyObject*, PyObject *args, PyObject *kw) -{ - const char* keywords[] = {"buttonName", "onChange", "userData", "buttonType", "initialButtonState", NULL}; - PyObject *on_change; - PyObject *userdata = NULL; - char* button_name; - int button_type = 0; - int initial_button_state = 0; - - if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|Oii", (char**)keywords, &button_name, &on_change, &userdata, &button_type, &initial_button_state)) - return NULL; - if (!PyCallable_Check(on_change)) { - PyErr_SetString(PyExc_TypeError, "onChange must be callable"); - return NULL; - } - if (userdata == NULL) { - userdata = Py_None; - } - - PyObject* py_callback_info = Py_BuildValue("OO", on_change, userdata); - std::string name(button_name); - - static std::map registered_callbacks; - std::map::iterator i = registered_callbacks.find(name); - if (i != registered_callbacks.end()) - { - Py_DECREF(i->second); - i->second = py_callback_info; - } - else - { - registered_callbacks.insert(std::pair(name, py_callback_info)); - } - ERRWRAP2(createButton(button_name, OnButtonChange, py_callback_info, button_type, initial_button_state != 0)); - Py_RETURN_NONE; -} -#endif /////////////////////////////////////////////////////////////////////////////////////// diff --git a/modules/python/src2/cv2.hpp b/modules/python/src2/cv2.hpp new file mode 100644 index 0000000..9293a59 --- /dev/null +++ b/modules/python/src2/cv2.hpp @@ -0,0 +1,55 @@ +#ifndef CV2_HPP +#define CV2_HPP + +//warning number '5033' not a valid compiler warning in vc12 +#if defined(_MSC_VER) && (_MSC_VER > 1800) +// eliminating duplicated round() declaration +#define HAVE_ROUND 1 +#pragma warning(push) +#pragma warning(disable:5033) // 'register' is no longer a supported storage class +#endif + +// #define CVPY_DYNAMIC_INIT +// #define Py_DEBUG + +#if defined(CVPY_DYNAMIC_INIT) && !defined(Py_DEBUG) +# define Py_LIMITED_API 0x03030000 +#endif + +#include +#include +#include + +#if PY_MAJOR_VERSION < 3 +#undef CVPY_DYNAMIC_INIT +#else +#define CV_PYTHON_3 1 +#endif + +#if defined(_MSC_VER) && (_MSC_VER > 1800) +#pragma warning(pop) +#endif + +#define MODULESTR "cv2" +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION + +#include + +#include "pycompat.hpp" + +class ArgInfo +{ +public: + const char* name; + bool outputarg; + // more fields may be added if necessary + + ArgInfo(const char* name_, bool outputarg_) : name(name_), outputarg(outputarg_) {} + +private: + ArgInfo(const ArgInfo&) = delete; + ArgInfo& operator=(const ArgInfo&) = delete; +}; + + +#endif // CV2_HPP diff --git a/modules/python/src2/cv2_convert.cpp b/modules/python/src2/cv2_convert.cpp new file mode 100644 index 0000000..eb800b6 --- /dev/null +++ b/modules/python/src2/cv2_convert.cpp @@ -0,0 +1,1052 @@ +// must be defined before importing numpy headers +// https://numpy.org/doc/1.17/reference/c-api.array.html#importing-the-api +#define NO_IMPORT_ARRAY +#define PY_ARRAY_UNIQUE_SYMBOL opencv_ARRAY_API + +#include "cv2_convert.hpp" +#include "cv2_numpy.hpp" +#include "opencv2/core/utils/logger.hpp" + +PyTypeObject* pyopencv_Mat_TypePtr = nullptr; + +//====================================================================================================================== + +using namespace cv; + +template +static std::string pycv_dumpArray(const T* arr, int n) +{ + std::ostringstream out; + out << "["; + for (int i = 0; i < n; ++i) + out << " " << arr[i]; + out << " ]"; + return out.str(); +} + +//====================================================================================================================== + +// --- Mat + +// special case, when the converter needs full ArgInfo structure +template<> +bool pyopencv_to(PyObject* o, Mat& m, const ArgInfo& info) +{ + if(!o || o == Py_None) + { + if( !m.data ) + m.allocator = &g_numpyAllocator; + return true; + } + + if( PyInt_Check(o) ) + { + double v[] = {static_cast(PyInt_AsLong((PyObject*)o)), 0., 0., 0.}; + m = Mat(4, 1, CV_64F, v).clone(); + return true; + } + if( PyFloat_Check(o) ) + { + double v[] = {PyFloat_AsDouble((PyObject*)o), 0., 0., 0.}; + m = Mat(4, 1, CV_64F, v).clone(); + return true; + } + if( PyTuple_Check(o) ) + { + int i, sz = (int)PyTuple_Size((PyObject*)o); + m = Mat(sz, 1, CV_64F); + for( i = 0; i < sz; i++ ) + { + PyObject* oi = PyTuple_GetItem(o, i); + if( PyInt_Check(oi) ) + m.at(i) = (double)PyInt_AsLong(oi); + else if( PyFloat_Check(oi) ) + m.at(i) = (double)PyFloat_AsDouble(oi); + else + { + failmsg("%s is not a numerical tuple", info.name); + m.release(); + return false; + } + } + return true; + } + + if( !PyArray_Check(o) ) + { + failmsg("%s is not a numpy array, neither a scalar", info.name); + return false; + } + + PyArrayObject* oarr = (PyArrayObject*) o; + + bool needcopy = false, needcast = false; + int typenum = PyArray_TYPE(oarr), new_typenum = typenum; + int type = typenum == NPY_UBYTE ? CV_8U : + typenum == NPY_BYTE ? CV_8S : + typenum == NPY_USHORT ? CV_16U : + typenum == NPY_SHORT ? CV_16S : + typenum == NPY_INT ? CV_32S : + typenum == NPY_INT32 ? CV_32S : + typenum == NPY_FLOAT ? CV_32F : + typenum == NPY_DOUBLE ? CV_64F : -1; + + if( type < 0 ) + { + if( typenum == NPY_INT64 || typenum == NPY_UINT64 || typenum == NPY_LONG ) + { + needcopy = needcast = true; + new_typenum = NPY_INT; + type = CV_32S; + } + else + { + failmsg("%s data type = %d is not supported", info.name, typenum); + return false; + } + } + +#ifndef CV_MAX_DIM + const int CV_MAX_DIM = 32; +#endif + + int ndims = PyArray_NDIM(oarr); + if(ndims >= CV_MAX_DIM) + { + failmsg("%s dimensionality (=%d) is too high", info.name, ndims); + return false; + } + + size_t elemsize = CV_ELEM_SIZE1(type); + const npy_intp* _sizes = PyArray_DIMS(oarr); + const npy_intp* _strides = PyArray_STRIDES(oarr); + + CV_LOG_DEBUG(NULL, "Incoming ndarray '" << info.name << "': ndims=" << ndims << " _sizes=" << pycv_dumpArray(_sizes, ndims) << " _strides=" << pycv_dumpArray(_strides, ndims)); + + bool ismultichannel = ndims == 3 && _sizes[2] <= CV_CN_MAX; + if (pyopencv_Mat_TypePtr && PyObject_TypeCheck(o, pyopencv_Mat_TypePtr)) + { + bool wrapChannels = false; + PyObject* pyobj_wrap_channels = PyObject_GetAttrString(o, "wrap_channels"); + if (pyobj_wrap_channels) + { + if (!pyopencv_to_safe(pyobj_wrap_channels, wrapChannels, ArgInfo("cv.Mat.wrap_channels", 0))) + { + // TODO extra message + Py_DECREF(pyobj_wrap_channels); + return false; + } + Py_DECREF(pyobj_wrap_channels); + } + ismultichannel = wrapChannels && ndims >= 1; + } + + for( int i = ndims-1; i >= 0 && !needcopy; i-- ) + { + // these checks handle cases of + // a) multi-dimensional (ndims > 2) arrays, as well as simpler 1- and 2-dimensional cases + // b) transposed arrays, where _strides[] elements go in non-descending order + // c) flipped arrays, where some of _strides[] elements are negative + // the _sizes[i] > 1 is needed to avoid spurious copies when NPY_RELAXED_STRIDES is set + if( (i == ndims-1 && _sizes[i] > 1 && (size_t)_strides[i] != elemsize) || + (i < ndims-1 && _sizes[i] > 1 && _strides[i] < _strides[i+1]) ) + needcopy = true; + } + + if (ismultichannel) + { + int channels = ndims >= 1 ? (int)_sizes[ndims - 1] : 1; + if (channels > CV_CN_MAX) + { + failmsg("%s unable to wrap channels, too high (%d > CV_CN_MAX=%d)", info.name, (int)channels, (int)CV_CN_MAX); + return false; + } + ndims--; + type |= CV_MAKETYPE(0, channels); + + if (ndims >= 1 && _strides[ndims - 1] != (npy_intp)elemsize*_sizes[ndims]) + needcopy = true; + + elemsize = CV_ELEM_SIZE(type); + } + + if (needcopy) + { + if (info.outputarg) + { + failmsg("Layout of the output array %s is incompatible with cv::Mat", info.name); + return false; + } + + if( needcast ) { + o = PyArray_Cast(oarr, new_typenum); + oarr = (PyArrayObject*) o; + } + else { + oarr = PyArray_GETCONTIGUOUS(oarr); + o = (PyObject*) oarr; + } + + _strides = PyArray_STRIDES(oarr); + } + + int size[CV_MAX_DIM+1] = {}; + size_t step[CV_MAX_DIM+1] = {}; + + // Normalize strides in case NPY_RELAXED_STRIDES is set + size_t default_step = elemsize; + for ( int i = ndims - 1; i >= 0; --i ) + { + size[i] = (int)_sizes[i]; + if ( size[i] > 1 ) + { + step[i] = (size_t)_strides[i]; + default_step = step[i] * size[i]; + } + else + { + step[i] = default_step; + default_step *= size[i]; + } + } + + // handle degenerate case + // FIXIT: Don't force 1D for Scalars + if( ndims == 0) { + size[ndims] = 1; + step[ndims] = elemsize; + ndims++; + } + +#if 1 + CV_LOG_DEBUG(NULL, "Construct Mat: ndims=" << ndims << " size=" << pycv_dumpArray(size, ndims) << " step=" << pycv_dumpArray(step, ndims) << " type=" << cv::typeToString(type)); +#endif + + m = Mat(ndims, size, type, PyArray_DATA(oarr), step); + m.u = g_numpyAllocator.allocate(o, ndims, size, type, step); + m.addref(); + + if( !needcopy ) + { + Py_INCREF(o); + } + m.allocator = &g_numpyAllocator; + + return true; +} + +template<> +PyObject* pyopencv_from(const cv::Mat& m) +{ + if( !m.data ) + Py_RETURN_NONE; + cv::Mat temp, *p = (cv::Mat*)&m; + if(!p->u || p->allocator != &g_numpyAllocator) + { + temp.allocator = &g_numpyAllocator; + ERRWRAP2(m.copyTo(temp)); + p = &temp; + } + PyObject* o = (PyObject*)p->u->userdata; + Py_INCREF(o); + return o; +} + +// --- bool + +template<> +bool pyopencv_to(PyObject* obj, bool& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (isBool(obj) || PyArray_IsIntegerScalar(obj)) + { + npy_bool npy_value = NPY_FALSE; + const int ret_code = PyArray_BoolConverter(obj, &npy_value); + if (ret_code >= 0) + { + value = (npy_value == NPY_TRUE); + return true; + } + } + failmsg("Argument '%s' is not convertable to bool", info.name); + return false; +} + +template<> +PyObject* pyopencv_from(const bool& value) +{ + return PyBool_FromLong(value); +} + +// --- ptr + +template<> +bool pyopencv_to(PyObject* obj, void*& ptr, const ArgInfo& info) +{ + CV_UNUSED(info); + if (!obj || obj == Py_None) + return true; + + if (!PyLong_Check(obj)) + return false; + ptr = PyLong_AsVoidPtr(obj); + return ptr != NULL && !PyErr_Occurred(); +} + +PyObject* pyopencv_from(void*& ptr) +{ + return PyLong_FromVoidPtr(ptr); +} + +// -- Scalar + +template<> +bool pyopencv_to(PyObject *o, Scalar& s, const ArgInfo& info) +{ + if(!o || o == Py_None) + return true; + if (PySequence_Check(o)) { + if (4 < PySequence_Size(o)) + { + failmsg("Scalar value for argument '%s' is longer than 4", info.name); + return false; + } + for (Py_ssize_t i = 0; i < PySequence_Size(o); i++) { + SafeSeqItem item_wrap(o, i); + PyObject *item = item_wrap.item; + if (PyFloat_Check(item) || PyInt_Check(item)) { + s[(int)i] = PyFloat_AsDouble(item); + } else { + failmsg("Scalar value for argument '%s' is not numeric", info.name); + return false; + } + } + } else { + if (PyFloat_Check(o) || PyInt_Check(o)) { + s[0] = PyFloat_AsDouble(o); + } else { + failmsg("Scalar value for argument '%s' is not numeric", info.name); + return false; + } + } + return true; +} + +template<> +PyObject* pyopencv_from(const Scalar& src) +{ + return Py_BuildValue("(dddd)", src[0], src[1], src[2], src[3]); +} + +// --- size_t + +template<> +bool pyopencv_to(PyObject* obj, size_t& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (isBool(obj)) + { + failmsg("Argument '%s' must be integer type, not bool", info.name); + return false; + } + if (PyArray_IsIntegerScalar(obj)) + { + if (PyLong_Check(obj)) + { +#if defined(CV_PYTHON_3) + value = PyLong_AsSize_t(obj); +#else + #if ULONG_MAX == SIZE_MAX + value = PyLong_AsUnsignedLong(obj); + #else + value = PyLong_AsUnsignedLongLong(obj); + #endif +#endif + } +#if !defined(CV_PYTHON_3) + // Python 2.x has PyIntObject which is not a subtype of PyLongObject + // Overflow check here is unnecessary because object will be converted to long on the + // interpreter side + else if (PyInt_Check(obj)) + { + const long res = PyInt_AsLong(obj); + if (res < 0) { + failmsg("Argument '%s' can not be safely parsed to 'size_t'", info.name); + return false; + } + #if ULONG_MAX == SIZE_MAX + value = PyInt_AsUnsignedLongMask(obj); + #else + value = PyInt_AsUnsignedLongLongMask(obj); + #endif + } +#endif + else + { + const bool isParsed = parseNumpyScalar(obj, value); + if (!isParsed) { + failmsg("Argument '%s' can not be safely parsed to 'size_t'", info.name); + return false; + } + } + } + else + { + failmsg("Argument '%s' is required to be an integer", info.name); + return false; + } + return !PyErr_Occurred(); +} + +template<> +PyObject* pyopencv_from(const size_t& value) +{ + return PyLong_FromSize_t(value); +} + +// --- int + +template<> +bool pyopencv_to(PyObject* obj, int& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (isBool(obj)) + { + failmsg("Argument '%s' must be integer, not bool", info.name); + return false; + } + if (PyArray_IsIntegerScalar(obj)) + { + value = PyArray_PyIntAsInt(obj); + } + else + { + failmsg("Argument '%s' is required to be an integer", info.name); + return false; + } + return !CV_HAS_CONVERSION_ERROR(value); +} + +template<> +PyObject* pyopencv_from(const int& value) +{ + return PyInt_FromLong(value); +} + +// --- int64 + +template<> +PyObject* pyopencv_from(const int64& value) +{ + return PyLong_FromLongLong(value); +} + + +// --- uchar + +template<> +bool pyopencv_to(PyObject* obj, uchar& value, const ArgInfo& info) +{ + CV_UNUSED(info); + if(!obj || obj == Py_None) + return true; + int ivalue = (int)PyInt_AsLong(obj); + value = cv::saturate_cast(ivalue); + return ivalue != -1 || !PyErr_Occurred(); +} + +template<> +PyObject* pyopencv_from(const uchar& value) +{ + return PyInt_FromLong(value); +} + +// --- char + +template<> +bool pyopencv_to(PyObject* obj, char& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (isBool(obj)) + { + failmsg("Argument '%s' must be an integer, not bool", info.name); + return false; + } + if (PyArray_IsIntegerScalar(obj)) + { + value = saturate_cast(PyArray_PyIntAsInt(obj)); + } + else + { + failmsg("Argument '%s' is required to be an integer", info.name); + return false; + } + return !CV_HAS_CONVERSION_ERROR(value); +} + +// --- double + +template<> +bool pyopencv_to(PyObject* obj, double& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (isBool(obj)) + { + failmsg("Argument '%s' must be double, not bool", info.name); + return false; + } + if (PyArray_IsPythonNumber(obj)) + { + if (PyLong_Check(obj)) + { + value = PyLong_AsDouble(obj); + } + else + { + value = PyFloat_AsDouble(obj); + } + } + else if (PyArray_CheckScalar(obj)) + { + const bool isParsed = parseNumpyScalar(obj, value); + if (!isParsed) { + failmsg("Argument '%s' can not be safely parsed to 'double'", info.name); + return false; + } + } + else + { + failmsg("Argument '%s' can not be treated as a double", info.name); + return false; + } + return !PyErr_Occurred(); +} + +template<> +PyObject* pyopencv_from(const double& value) +{ + return PyFloat_FromDouble(value); +} + +// --- float + +template<> +bool pyopencv_to(PyObject* obj, float& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (isBool(obj)) + { + failmsg("Argument '%s' must be float, not bool", info.name); + return false; + } + if (PyArray_IsPythonNumber(obj)) + { + if (PyLong_Check(obj)) + { + double res = PyLong_AsDouble(obj); + value = static_cast(res); + } + else + { + double res = PyFloat_AsDouble(obj); + value = static_cast(res); + } + } + else if (PyArray_CheckScalar(obj)) + { + const bool isParsed = parseNumpyScalar(obj, value); + if (!isParsed) { + failmsg("Argument '%s' can not be safely parsed to 'float'", info.name); + return false; + } + } + else + { + failmsg("Argument '%s' can't be treated as a float", info.name); + return false; + } + return !PyErr_Occurred(); +} + +template<> +PyObject* pyopencv_from(const float& value) +{ + return PyFloat_FromDouble(value); +} + +// --- string + +template<> +bool pyopencv_to(PyObject* obj, String &value, const ArgInfo& info) +{ + if(!obj || obj == Py_None) + { + return true; + } + std::string str; + if (getUnicodeString(obj, str)) + { + value = str; + return true; + } + else + { + // If error hasn't been already set by Python conversion functions + if (!PyErr_Occurred()) + { + // Direct access to underlying slots of PyObjectType is not allowed + // when limited API is enabled +#ifdef Py_LIMITED_API + failmsg("Can't convert object to 'str' for '%s'", info.name); +#else + failmsg("Can't convert object of type '%s' to 'str' for '%s'", + obj->ob_type->tp_name, info.name); +#endif + } + } + return false; +} + +template<> +PyObject* pyopencv_from(const String& value) +{ + return PyString_FromString(value.empty() ? "" : value.c_str()); +} + +#if CV_VERSION_MAJOR == 3 +template<> +PyObject* pyopencv_from(const std::string& value) +{ + return PyString_FromString(value.empty() ? "" : value.c_str()); +} +#endif + +// --- Size + +template<> +bool pyopencv_to(PyObject* obj, Size& sz, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(sz.width), + RefWrapper(sz.height)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Size& sz) +{ + return Py_BuildValue("(ii)", sz.width, sz.height); +} + +template<> +bool pyopencv_to(PyObject* obj, Size_& sz, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(sz.width), + RefWrapper(sz.height)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Size_& sz) +{ + return Py_BuildValue("(ff)", sz.width, sz.height); +} + +// --- Rect + +template<> +bool pyopencv_to(PyObject* obj, Rect& r, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(r.x), RefWrapper(r.y), + RefWrapper(r.width), + RefWrapper(r.height)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Rect& r) +{ + return Py_BuildValue("(iiii)", r.x, r.y, r.width, r.height); +} + +template<> +bool pyopencv_to(PyObject* obj, Rect2d& r, const ArgInfo& info) +{ + RefWrapper values[] = { + RefWrapper(r.x), RefWrapper(r.y), + RefWrapper(r.width), RefWrapper(r.height)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Rect2d& r) +{ + return Py_BuildValue("(dddd)", r.x, r.y, r.width, r.height); +} + +// --- RotatedRect + +template<> +bool pyopencv_to(PyObject* obj, RotatedRect& dst, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (!PySequence_Check(obj)) + { + failmsg("Can't parse '%s' as RotatedRect." + "Input argument doesn't provide sequence protocol", + info.name); + return false; + } + const std::size_t sequenceSize = PySequence_Size(obj); + if (sequenceSize != 3) + { + failmsg("Can't parse '%s' as RotatedRect. Expected sequence length 3, got %lu", + info.name, sequenceSize); + return false; + } + { + const String centerItemName = format("'%s' center point", info.name); + const ArgInfo centerItemInfo(centerItemName.c_str(), false); + SafeSeqItem centerItem(obj, 0); + if (!pyopencv_to(centerItem.item, dst.center, centerItemInfo)) + { + return false; + } + } + { + const String sizeItemName = format("'%s' size", info.name); + const ArgInfo sizeItemInfo(sizeItemName.c_str(), false); + SafeSeqItem sizeItem(obj, 1); + if (!pyopencv_to(sizeItem.item, dst.size, sizeItemInfo)) + { + return false; + } + } + { + const String angleItemName = format("'%s' angle", info.name); + const ArgInfo angleItemInfo(angleItemName.c_str(), false); + SafeSeqItem angleItem(obj, 2); + if (!pyopencv_to(angleItem.item, dst.angle, angleItemInfo)) + { + return false; + } + } + return true; +} + +template<> +PyObject* pyopencv_from(const RotatedRect& src) +{ + return Py_BuildValue("((ff)(ff)f)", src.center.x, src.center.y, src.size.width, src.size.height, src.angle); +} + +// --- Range + +template<> +bool pyopencv_to(PyObject* obj, Range& r, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (PyObject_Size(obj) == 0) + { + r = Range::all(); + return true; + } + RefWrapper values[] = {RefWrapper(r.start), RefWrapper(r.end)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Range& r) +{ + return Py_BuildValue("(ii)", r.start, r.end); +} + +// --- Point + +template<> +bool pyopencv_to(PyObject* obj, Point& p, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(p.x), RefWrapper(p.y)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Point& p) +{ + return Py_BuildValue("(ii)", p.x, p.y); +} + +template <> +bool pyopencv_to(PyObject* obj, Point2f& p, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(p.x), + RefWrapper(p.y)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Point2f& p) +{ + return Py_BuildValue("(dd)", p.x, p.y); +} + +template<> +bool pyopencv_to(PyObject* obj, Point2d& p, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(p.x), + RefWrapper(p.y)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Point2d& p) +{ + return Py_BuildValue("(dd)", p.x, p.y); +} + +template<> +bool pyopencv_to(PyObject* obj, Point3f& p, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(p.x), + RefWrapper(p.y), + RefWrapper(p.z)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Point3f& p) +{ + return Py_BuildValue("(ddd)", p.x, p.y, p.z); +} + +template<> +bool pyopencv_to(PyObject* obj, Point3d& p, const ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(p.x), + RefWrapper(p.y), + RefWrapper(p.z)}; + return parseSequence(obj, values, info); +} + +template<> +PyObject* pyopencv_from(const Point3d& p) +{ + return Py_BuildValue("(ddd)", p.x, p.y, p.z); +} + +// --- Vec + +bool pyopencv_to(PyObject* obj, Vec4d& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), + RefWrapper(v[2]), RefWrapper(v[3])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec4d& v) +{ + return Py_BuildValue("(dddd)", v[0], v[1], v[2], v[3]); +} + +bool pyopencv_to(PyObject* obj, Vec4f& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), + RefWrapper(v[2]), RefWrapper(v[3])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec4f& v) +{ + return Py_BuildValue("(ffff)", v[0], v[1], v[2], v[3]); +} + +bool pyopencv_to(PyObject* obj, Vec4i& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), + RefWrapper(v[2]), RefWrapper(v[3])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec4i& v) +{ + return Py_BuildValue("(iiii)", v[0], v[1], v[2], v[3]); +} + +bool pyopencv_to(PyObject* obj, Vec3d& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), + RefWrapper(v[1]), + RefWrapper(v[2])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec3d& v) +{ + return Py_BuildValue("(ddd)", v[0], v[1], v[2]); +} + +bool pyopencv_to(PyObject* obj, Vec3f& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), + RefWrapper(v[1]), + RefWrapper(v[2])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec3f& v) +{ + return Py_BuildValue("(fff)", v[0], v[1], v[2]); +} + +bool pyopencv_to(PyObject* obj, Vec3i& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1]), + RefWrapper(v[2])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec3i& v) +{ + return Py_BuildValue("(iii)", v[0], v[1], v[2]); +} + +bool pyopencv_to(PyObject* obj, Vec2d& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), + RefWrapper(v[1])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec2d& v) +{ + return Py_BuildValue("(dd)", v[0], v[1]); +} + +bool pyopencv_to(PyObject* obj, Vec2f& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), + RefWrapper(v[1])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec2f& v) +{ + return Py_BuildValue("(ff)", v[0], v[1]); +} + +bool pyopencv_to(PyObject* obj, Vec2i& v, ArgInfo& info) +{ + RefWrapper values[] = {RefWrapper(v[0]), RefWrapper(v[1])}; + return parseSequence(obj, values, info); +} + +PyObject* pyopencv_from(const Vec2i& v) +{ + return Py_BuildValue("(ii)", v[0], v[1]); +} + + +// --- TermCriteria + +template<> +bool pyopencv_to(PyObject* obj, TermCriteria& dst, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (!PySequence_Check(obj)) + { + failmsg("Can't parse '%s' as TermCriteria." + "Input argument doesn't provide sequence protocol", + info.name); + return false; + } + const std::size_t sequenceSize = PySequence_Size(obj); + if (sequenceSize != 3) { + failmsg("Can't parse '%s' as TermCriteria. Expected sequence length 3, " + "got %lu", + info.name, sequenceSize); + return false; + } + { + const String typeItemName = format("'%s' criteria type", info.name); + const ArgInfo typeItemInfo(typeItemName.c_str(), false); + SafeSeqItem typeItem(obj, 0); + if (!pyopencv_to(typeItem.item, dst.type, typeItemInfo)) + { + return false; + } + } + { + const String maxCountItemName = format("'%s' max count", info.name); + const ArgInfo maxCountItemInfo(maxCountItemName.c_str(), false); + SafeSeqItem maxCountItem(obj, 1); + if (!pyopencv_to(maxCountItem.item, dst.maxCount, maxCountItemInfo)) + { + return false; + } + } + { + const String epsilonItemName = format("'%s' epsilon", info.name); + const ArgInfo epsilonItemInfo(epsilonItemName.c_str(), false); + SafeSeqItem epsilonItem(obj, 2); + if (!pyopencv_to(epsilonItem.item, dst.epsilon, epsilonItemInfo)) + { + return false; + } + } + return true; +} + +template<> +PyObject* pyopencv_from(const TermCriteria& src) +{ + return Py_BuildValue("(iid)", src.type, src.maxCount, src.epsilon); +} + +// --- Moments + +template<> +PyObject* pyopencv_from(const Moments& m) +{ + return Py_BuildValue("{s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d,s:d}", + "m00", m.m00, "m10", m.m10, "m01", m.m01, + "m20", m.m20, "m11", m.m11, "m02", m.m02, + "m30", m.m30, "m21", m.m21, "m12", m.m12, "m03", m.m03, + "mu20", m.mu20, "mu11", m.mu11, "mu02", m.mu02, + "mu30", m.mu30, "mu21", m.mu21, "mu12", m.mu12, "mu03", m.mu03, + "nu20", m.nu20, "nu11", m.nu11, "nu02", m.nu02, + "nu30", m.nu30, "nu21", m.nu21, "nu12", m.nu12, "nu03", m.nu03); +} + +// --- pair + +template<> +PyObject* pyopencv_from(const std::pair& src) +{ + return Py_BuildValue("(id)", src.first, src.second); +} diff --git a/modules/python/src2/cv2_convert.hpp b/modules/python/src2/cv2_convert.hpp new file mode 100644 index 0000000..e9ed712 --- /dev/null +++ b/modules/python/src2/cv2_convert.hpp @@ -0,0 +1,529 @@ +#ifndef CV2_CONVERT_HPP +#define CV2_CONVERT_HPP + +#include "cv2.hpp" +#include "cv2_util.hpp" +#include "cv2_numpy.hpp" +#include +#include +#include // std::enable_if + +extern PyTypeObject* pyopencv_Mat_TypePtr; + +#define CV_HAS_CONVERSION_ERROR(x) (((x) == -1) && PyErr_Occurred()) + +inline bool isBool(PyObject* obj) CV_NOEXCEPT +{ + return PyArray_IsScalar(obj, Bool) || PyBool_Check(obj); +} + +//====================================================================================================================== + + +// exception-safe pyopencv_to +template static +bool pyopencv_to_safe(PyObject* obj, _Tp& value, const ArgInfo& info) +{ + try + { + return pyopencv_to(obj, value, info); + } + catch (const std::exception &e) + { + PyErr_SetString(opencv_error, cv::format("Conversion error: %s, what: %s", info.name, e.what()).c_str()); + return false; + } + catch (...) + { + PyErr_SetString(opencv_error, cv::format("Conversion error: %s", info.name).c_str()); + return false; + } +} + +//====================================================================================================================== + +template // TEnable is used for SFINAE checks +struct PyOpenCV_Converter +{ + //static inline bool to(PyObject* obj, T& p, const ArgInfo& info); + //static inline PyObject* from(const T& src); +}; + +// --- Generic + +template +bool pyopencv_to(PyObject* obj, T& p, const ArgInfo& info) { return PyOpenCV_Converter::to(obj, p, info); } + +template +PyObject* pyopencv_from(const T& src) { return PyOpenCV_Converter::from(src); } + +// --- Matx + +template +bool pyopencv_to(PyObject* o, cv::Matx<_Tp, m, n>& mx, const ArgInfo& info) +{ + cv::Mat tmp; + if (!pyopencv_to(o, tmp, info)) { + return false; + } + + tmp.copyTo(mx); + return true; +} + +template +PyObject* pyopencv_from(const cv::Matx<_Tp, m, n>& matx) +{ + return pyopencv_from(cv::Mat(matx)); +} + +// --- bool +template<> bool pyopencv_to(PyObject* obj, bool& value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const bool& value); + +// --- Mat +template<> bool pyopencv_to(PyObject* o, cv::Mat& m, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Mat& m); + +// --- Ptr +template +struct PyOpenCV_Converter< cv::Ptr > +{ + static PyObject* from(const cv::Ptr& p) + { + if (!p) + Py_RETURN_NONE; + return pyopencv_from(*p); + } + static bool to(PyObject *o, cv::Ptr& p, const ArgInfo& info) + { + if (!o || o == Py_None) + return true; + p = cv::makePtr(); + return pyopencv_to(o, *p, info); + } +}; + +// --- ptr +template<> bool pyopencv_to(PyObject* obj, void*& ptr, const ArgInfo& info); +PyObject* pyopencv_from(void*& ptr); + +// --- Scalar +template<> bool pyopencv_to(PyObject *o, cv::Scalar& s, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Scalar& src); + +// --- size_t +template<> bool pyopencv_to(PyObject* obj, size_t& value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const size_t& value); + +// --- int +template<> bool pyopencv_to(PyObject* obj, int& value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const int& value); + +// --- int64 +template<> PyObject* pyopencv_from(const int64& value); + +// There is conflict between "size_t" and "unsigned int". +// They are the same type on some 32-bit platforms. +template +struct PyOpenCV_Converter + < T, typename std::enable_if< std::is_same::value && !std::is_same::value >::type > +{ + static inline PyObject* from(const unsigned int& value) + { + return PyLong_FromUnsignedLong(value); + } + + static inline bool to(PyObject* obj, unsigned int& value, const ArgInfo& info) + { + CV_UNUSED(info); + if(!obj || obj == Py_None) + return true; + if(PyInt_Check(obj)) + value = (unsigned int)PyInt_AsLong(obj); + else if(PyLong_Check(obj)) + value = (unsigned int)PyLong_AsLong(obj); + else + return false; + return value != (unsigned int)-1 || !PyErr_Occurred(); + } +}; + +// --- uchar +template<> bool pyopencv_to(PyObject* obj, uchar& value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const uchar& value); + +// --- char +template<> bool pyopencv_to(PyObject* obj, char& value, const ArgInfo& info); + +// --- double +template<> bool pyopencv_to(PyObject* obj, double& value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const double& value); + +// --- float +template<> bool pyopencv_to(PyObject* obj, float& value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const float& value); + +// --- string +template<> bool pyopencv_to(PyObject* obj, cv::String &value, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::String& value); +#if CV_VERSION_MAJOR == 3 +template<> PyObject* pyopencv_from(const std::string& value); +#endif + +// --- Size +template<> bool pyopencv_to(PyObject* obj, cv::Size& sz, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Size& sz); +template<> bool pyopencv_to(PyObject* obj, cv::Size_& sz, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Size_& sz); + +// --- Rect +template<> bool pyopencv_to(PyObject* obj, cv::Rect& r, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Rect& r); +template<> bool pyopencv_to(PyObject* obj, cv::Rect2d& r, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Rect2d& r); + +// --- RotatedRect +template<> bool pyopencv_to(PyObject* obj, cv::RotatedRect& dst, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::RotatedRect& src); + +// --- Range +template<> bool pyopencv_to(PyObject* obj, cv::Range& r, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Range& r); + +// --- Point +template<> bool pyopencv_to(PyObject* obj, cv::Point& p, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Point& p); +template<> bool pyopencv_to(PyObject* obj, cv::Point2f& p, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Point2f& p); +template<> bool pyopencv_to(PyObject* obj, cv::Point2d& p, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Point2d& p); +template<> bool pyopencv_to(PyObject* obj, cv::Point3f& p, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Point3f& p); +template<> bool pyopencv_to(PyObject* obj, cv::Point3d& p, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::Point3d& p); + +// --- Vec +template +bool pyopencv_to(PyObject* o, cv::Vec<_Tp, cn>& vec, const ArgInfo& info) +{ + return pyopencv_to(o, (cv::Matx<_Tp, cn, 1>&)vec, info); +} +bool pyopencv_to(PyObject* obj, cv::Vec4d& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec4d& v); +bool pyopencv_to(PyObject* obj, cv::Vec4f& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec4f& v); +bool pyopencv_to(PyObject* obj, cv::Vec4i& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec4i& v); +bool pyopencv_to(PyObject* obj, cv::Vec3d& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec3d& v); +bool pyopencv_to(PyObject* obj, cv::Vec3f& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec3f& v); +bool pyopencv_to(PyObject* obj, cv::Vec3i& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec3i& v); +bool pyopencv_to(PyObject* obj, cv::Vec2d& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec2d& v); +bool pyopencv_to(PyObject* obj, cv::Vec2f& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec2f& v); +bool pyopencv_to(PyObject* obj, cv::Vec2i& v, ArgInfo& info); +PyObject* pyopencv_from(const cv::Vec2i& v); + +// --- TermCriteria +template<> bool pyopencv_to(PyObject* obj, cv::TermCriteria& dst, const ArgInfo& info); +template<> PyObject* pyopencv_from(const cv::TermCriteria& src); + +// --- Moments +template<> PyObject* pyopencv_from(const cv::Moments& m); + +// --- pair +template<> PyObject* pyopencv_from(const std::pair& src); + +// --- vector +template +struct pyopencvVecConverter; + +template +bool pyopencv_to(PyObject* obj, std::vector& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + return pyopencvVecConverter::to(obj, value, info); +} + +template +PyObject* pyopencv_from(const std::vector& value) +{ + return pyopencvVecConverter::from(value); +} + +template +static bool pyopencv_to_generic_vec(PyObject* obj, std::vector& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (!PySequence_Check(obj)) + { + failmsg("Can't parse '%s'. Input argument doesn't provide sequence protocol", info.name); + return false; + } + const size_t n = static_cast(PySequence_Size(obj)); + value.resize(n); + for (size_t i = 0; i < n; i++) + { + SafeSeqItem item_wrap(obj, i); + if (!pyopencv_to(item_wrap.item, value[i], info)) + { + failmsg("Can't parse '%s'. Sequence item with index %lu has a wrong type", info.name, i); + return false; + } + } + return true; +} + +template<> inline bool pyopencv_to_generic_vec(PyObject* obj, std::vector& value, const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (!PySequence_Check(obj)) + { + failmsg("Can't parse '%s'. Input argument doesn't provide sequence protocol", info.name); + return false; + } + const size_t n = static_cast(PySequence_Size(obj)); + value.resize(n); + for (size_t i = 0; i < n; i++) + { + SafeSeqItem item_wrap(obj, i); + bool elem{}; + if (!pyopencv_to(item_wrap.item, elem, info)) + { + failmsg("Can't parse '%s'. Sequence item with index %lu has a wrong type", info.name, i); + return false; + } + value[i] = elem; + } + return true; +} + +template +static PyObject* pyopencv_from_generic_vec(const std::vector& value) +{ + Py_ssize_t n = static_cast(value.size()); + PySafeObject seq(PyTuple_New(n)); + for (Py_ssize_t i = 0; i < n; i++) + { + PyObject* item = pyopencv_from(value[i]); + // If item can't be assigned - PyTuple_SetItem raises exception and returns -1. + if (!item || PyTuple_SetItem(seq, i, item) == -1) + { + return NULL; + } + } + return seq.release(); +} + +template<> inline PyObject* pyopencv_from_generic_vec(const std::vector& value) +{ + Py_ssize_t n = static_cast(value.size()); + PySafeObject seq(PyTuple_New(n)); + for (Py_ssize_t i = 0; i < n; i++) + { + bool elem = value[i]; + PyObject* item = pyopencv_from(elem); + // If item can't be assigned - PyTuple_SetItem raises exception and returns -1. + if (!item || PyTuple_SetItem(seq, i, item) == -1) + { + return NULL; + } + } + return seq.release(); +} + +namespace traits { + +template +struct BooleanConstant +{ + static const bool value = Value; + typedef BooleanConstant type; +}; + +typedef BooleanConstant TrueType; +typedef BooleanConstant FalseType; + +template +struct VoidType { + typedef void type; +}; + +template +struct IsRepresentableAsMatDataType : FalseType +{ +}; + +template +struct IsRepresentableAsMatDataType::channel_type>::type> : TrueType +{ +}; + +} // namespace traits + +template +struct pyopencvVecConverter +{ + typedef typename std::vector::iterator VecIt; + + static bool to(PyObject* obj, std::vector& value, const ArgInfo& info) + { + if (!PyArray_Check(obj)) + { + return pyopencv_to_generic_vec(obj, value, info); + } + // If user passed an array it is possible to make faster conversions in several cases + PyArrayObject* array_obj = reinterpret_cast(obj); + const NPY_TYPES target_type = asNumpyType(); + const NPY_TYPES source_type = static_cast(PyArray_TYPE(array_obj)); + if (target_type == NPY_OBJECT) + { + // Non-planar arrays representing objects (e.g. array of N Rect is an array of shape Nx4) have NPY_OBJECT + // as their target type. + return pyopencv_to_generic_vec(obj, value, info); + } + if (PyArray_NDIM(array_obj) > 1) + { + failmsg("Can't parse %dD array as '%s' vector argument", PyArray_NDIM(array_obj), info.name); + return false; + } + if (target_type != source_type) + { + // Source type requires conversion + // Allowed conversions for target type is handled in the corresponding pyopencv_to function + return pyopencv_to_generic_vec(obj, value, info); + } + // For all other cases, all array data can be directly copied to std::vector data + // Simple `memcpy` is not possible because NumPy array can reference a slice of the bigger array: + // ``` + // arr = np.ones((8, 4, 5), dtype=np.int32) + // convertible_to_vector_of_int = arr[:, 0, 1] + // ``` + value.resize(static_cast(PyArray_SIZE(array_obj))); + const npy_intp item_step = PyArray_STRIDE(array_obj, 0) / PyArray_ITEMSIZE(array_obj); + const Tp* data_ptr = static_cast(PyArray_DATA(array_obj)); + for (VecIt it = value.begin(); it != value.end(); ++it, data_ptr += item_step) { + *it = *data_ptr; + } + return true; + } + + static PyObject* from(const std::vector& value) + { + if (value.empty()) + { + return PyTuple_New(0); + } + return from(value, ::traits::IsRepresentableAsMatDataType()); + } + +private: + static PyObject* from(const std::vector& value, ::traits::FalseType) + { + // Underlying type is not representable as Mat Data Type + return pyopencv_from_generic_vec(value); + } + + static PyObject* from(const std::vector& value, ::traits::TrueType) + { + // Underlying type is representable as Mat Data Type, so faster return type is available + typedef cv::DataType DType; + typedef typename DType::channel_type UnderlyingArrayType; + + // If Mat is always exposed as NumPy array this code path can be reduced to the following snipped: + // Mat src(value); + // PyObject* array = pyopencv_from(src); + // return PyArray_Squeeze(reinterpret_cast(array)); + // This puts unnecessary restrictions on Mat object those might be avoided without losing the performance. + // Moreover, this version is a bit faster, because it doesn't create temporary objects with reference counting. + + const NPY_TYPES target_type = asNumpyType(); + const int cols = DType::channels; + PyObject* array = NULL; + if (cols == 1) + { + npy_intp dims = static_cast(value.size()); + array = PyArray_SimpleNew(1, &dims, target_type); + } + else + { + npy_intp dims[2] = {static_cast(value.size()), cols}; + array = PyArray_SimpleNew(2, dims, target_type); + } + if(!array) + { + // NumPy arrays with shape (N, 1) and (N) are not equal, so correct error message should distinguish + // them too. + cv::String shape; + if (cols > 1) + { + shape = cv::format("(%d x %d)", static_cast(value.size()), cols); + } + else + { + shape = cv::format("(%d)", static_cast(value.size())); + } + const cv::String error_message = cv::format("Can't allocate NumPy array for vector with dtype=%d and shape=%s", + static_cast(target_type), shape.c_str()); + emit_failmsg(PyExc_MemoryError, error_message.c_str()); + return array; + } + // Fill the array + PyArrayObject* array_obj = reinterpret_cast(array); + UnderlyingArrayType* array_data = static_cast(PyArray_DATA(array_obj)); + // if Tp is representable as Mat DataType, so the following cast is pretty safe... + const UnderlyingArrayType* value_data = reinterpret_cast(value.data()); + memcpy(array_data, value_data, sizeof(UnderlyingArrayType) * value.size() * static_cast(cols)); + return array; + } +}; + +// --- tuple +template +inline typename std::enable_if::type +convert_to_python_tuple(const std::tuple&, PyObject*) { } + +template +inline typename std::enable_if::type +convert_to_python_tuple(const std::tuple& cpp_tuple, PyObject* py_tuple) +{ + PyObject* item = pyopencv_from(std::get(cpp_tuple)); + + if (!item) + return; + + PyTuple_SetItem(py_tuple, I, item); + convert_to_python_tuple(cpp_tuple, py_tuple); +} + +template +PyObject* pyopencv_from(const std::tuple& cpp_tuple) +{ + size_t size = sizeof...(Ts); + PyObject* py_tuple = PyTuple_New(size); + convert_to_python_tuple(cpp_tuple, py_tuple); + size_t actual_size = PyTuple_Size(py_tuple); + + if (actual_size < size) + { + Py_DECREF(py_tuple); + return NULL; + } + + return py_tuple; +} + +#endif // CV2_CONVERT_HPP diff --git a/modules/python/src2/cv2_highgui.cpp b/modules/python/src2/cv2_highgui.cpp new file mode 100644 index 0000000..4262043 --- /dev/null +++ b/modules/python/src2/cv2_highgui.cpp @@ -0,0 +1,184 @@ +#include "cv2_highgui.hpp" + +#ifdef HAVE_OPENCV_HIGHGUI + +#include "cv2_util.hpp" +#include "opencv2/highgui.hpp" +#include + +using namespace cv; + +//====================================================================================================================== + +static void OnMouse(int event, int x, int y, int flags, void* param) +{ + PyGILState_STATE gstate; + gstate = PyGILState_Ensure(); + + PyObject *o = (PyObject*)param; + PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1)); + + PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); + if (r == NULL) + PyErr_Print(); + else + Py_DECREF(r); + Py_DECREF(args); + PyGILState_Release(gstate); +} + +PyObject *pycvSetMouseCallback(PyObject*, PyObject *args, PyObject *kw) +{ + const char *keywords[] = { "window_name", "on_mouse", "param", NULL }; + char* name; + PyObject *on_mouse; + PyObject *param = NULL; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, ¶m)) + return NULL; + if (!PyCallable_Check(on_mouse)) { + PyErr_SetString(PyExc_TypeError, "on_mouse must be callable"); + return NULL; + } + if (param == NULL) { + param = Py_None; + } + PyObject* py_callback_info = Py_BuildValue("OO", on_mouse, param); + static std::map registered_callbacks; + std::map::iterator i = registered_callbacks.find(name); + if (i != registered_callbacks.end()) + { + Py_DECREF(i->second); + i->second = py_callback_info; + } + else + { + registered_callbacks.insert(std::pair(std::string(name), py_callback_info)); + } + ERRWRAP2(setMouseCallback(name, OnMouse, py_callback_info)); + Py_RETURN_NONE; +} + +//====================================================================================================================== + +static void OnChange(int pos, void *param) +{ + PyGILState_STATE gstate; + gstate = PyGILState_Ensure(); + + PyObject *o = (PyObject*)param; + PyObject *args = Py_BuildValue("(i)", pos); + PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); + if (r == NULL) + PyErr_Print(); + else + Py_DECREF(r); + Py_DECREF(args); + PyGILState_Release(gstate); +} + +// workaround for #20408, use nullptr, set value later +static int _createTrackbar(const String &trackbar_name, const String &window_name, int value, int count, + TrackbarCallback onChange, PyObject* py_callback_info) +{ + int n = createTrackbar(trackbar_name, window_name, NULL, count, onChange, py_callback_info); + setTrackbarPos(trackbar_name, window_name, value); + return n; +} + +PyObject *pycvCreateTrackbar(PyObject*, PyObject *args) +{ + PyObject *on_change; + char* trackbar_name; + char* window_name; + int value; + int count; + + if (!PyArg_ParseTuple(args, "ssiiO", &trackbar_name, &window_name, &value, &count, &on_change)) + return NULL; + if (!PyCallable_Check(on_change)) { + PyErr_SetString(PyExc_TypeError, "on_change must be callable"); + return NULL; + } + PyObject* py_callback_info = Py_BuildValue("OO", on_change, Py_None); + std::string name = std::string(window_name) + ":" + std::string(trackbar_name); + static std::map registered_callbacks; + std::map::iterator i = registered_callbacks.find(name); + if (i != registered_callbacks.end()) + { + Py_DECREF(i->second); + i->second = py_callback_info; + } + else + { + registered_callbacks.insert(std::pair(name, py_callback_info)); + } + ERRWRAP2(_createTrackbar(trackbar_name, window_name, value, count, OnChange, py_callback_info)); + Py_RETURN_NONE; +} + +//====================================================================================================================== + +static void OnButtonChange(int state, void *param) +{ + PyGILState_STATE gstate; + gstate = PyGILState_Ensure(); + + PyObject *o = (PyObject*)param; + PyObject *args; + if(PyTuple_GetItem(o, 1) != NULL) + { + args = Py_BuildValue("(iO)", state, PyTuple_GetItem(o,1)); + } + else + { + args = Py_BuildValue("(i)", state); + } + + PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); + if (r == NULL) + PyErr_Print(); + else + Py_DECREF(r); + Py_DECREF(args); + PyGILState_Release(gstate); +} + +PyObject *pycvCreateButton(PyObject*, PyObject *args, PyObject *kw) +{ + const char* keywords[] = {"buttonName", "onChange", "userData", "buttonType", "initialButtonState", NULL}; + PyObject *on_change; + PyObject *userdata = NULL; + char* button_name; + int button_type = 0; + int initial_button_state = 0; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|Oii", (char**)keywords, &button_name, &on_change, &userdata, &button_type, &initial_button_state)) + return NULL; + if (!PyCallable_Check(on_change)) { + PyErr_SetString(PyExc_TypeError, "onChange must be callable"); + return NULL; + } + if (userdata == NULL) { + userdata = Py_None; + } + + PyObject* py_callback_info = Py_BuildValue("OO", on_change, userdata); + std::string name(button_name); + + static std::map registered_callbacks; + std::map::iterator i = registered_callbacks.find(name); + if (i != registered_callbacks.end()) + { + Py_DECREF(i->second); + i->second = py_callback_info; + } + else + { + registered_callbacks.insert(std::pair(name, py_callback_info)); + } + ERRWRAP2(createButton(button_name, OnButtonChange, py_callback_info, button_type, initial_button_state != 0)); + Py_RETURN_NONE; +} + +#endif // HAVE_OPENCV_HIGHGUI diff --git a/modules/python/src2/cv2_highgui.hpp b/modules/python/src2/cv2_highgui.hpp new file mode 100644 index 0000000..97e0837 --- /dev/null +++ b/modules/python/src2/cv2_highgui.hpp @@ -0,0 +1,14 @@ +#ifndef CV2_HIGHGUI_HPP +#define CV2_HIGHGUI_HPP + +#include "cv2.hpp" +#include "opencv2/opencv_modules.hpp" + +#ifdef HAVE_OPENCV_HIGHGUI +PyObject *pycvSetMouseCallback(PyObject*, PyObject *args, PyObject *kw); +// workaround for #20408, use nullptr, set value later +PyObject *pycvCreateTrackbar(PyObject*, PyObject *args); +PyObject *pycvCreateButton(PyObject*, PyObject *args, PyObject *kw); +#endif + +#endif // CV2_HIGHGUI_HPP diff --git a/modules/python/src2/cv2_numpy.cpp b/modules/python/src2/cv2_numpy.cpp new file mode 100644 index 0000000..98938db --- /dev/null +++ b/modules/python/src2/cv2_numpy.cpp @@ -0,0 +1,73 @@ +// must be defined before importing numpy headers +// https://numpy.org/doc/1.17/reference/c-api.array.html#importing-the-api +#define NO_IMPORT_ARRAY +#define PY_ARRAY_UNIQUE_SYMBOL opencv_ARRAY_API + +#include "cv2_numpy.hpp" +#include "cv2_util.hpp" + +NumpyAllocator g_numpyAllocator; + +using namespace cv; + +UMatData* NumpyAllocator::allocate(PyObject* o, int dims, const int* sizes, int type, size_t* step) const +{ + UMatData* u = new UMatData(this); + u->data = u->origdata = (uchar*)PyArray_DATA((PyArrayObject*) o); + npy_intp* _strides = PyArray_STRIDES((PyArrayObject*) o); + for( int i = 0; i < dims - 1; i++ ) + step[i] = (size_t)_strides[i]; + step[dims-1] = CV_ELEM_SIZE(type); + u->size = sizes[0]*step[0]; + u->userdata = o; + return u; +} + +UMatData* NumpyAllocator::allocate(int dims0, const int* sizes, int type, void* data, size_t* step, AccessFlag flags, UMatUsageFlags usageFlags) const +{ + if( data != 0 ) + { + // issue #6969: CV_Error(Error::StsAssert, "The data should normally be NULL!"); + // probably this is safe to do in such extreme case + return stdAllocator->allocate(dims0, sizes, type, data, step, flags, usageFlags); + } + PyEnsureGIL gil; + + int depth = CV_MAT_DEPTH(type); + int cn = CV_MAT_CN(type); + const int f = (int)(sizeof(size_t)/8); + int typenum = depth == CV_8U ? NPY_UBYTE : depth == CV_8S ? NPY_BYTE : + depth == CV_16U ? NPY_USHORT : depth == CV_16S ? NPY_SHORT : + depth == CV_32S ? NPY_INT : depth == CV_32F ? NPY_FLOAT : + depth == CV_64F ? NPY_DOUBLE : f*NPY_ULONGLONG + (f^1)*NPY_UINT; + int i, dims = dims0; + cv::AutoBuffer _sizes(dims + 1); + for( i = 0; i < dims; i++ ) + _sizes[i] = sizes[i]; + if( cn > 1 ) + _sizes[dims++] = cn; + PyObject* o = PyArray_SimpleNew(dims, _sizes.data(), typenum); + if(!o) + CV_Error_(Error::StsError, ("The numpy array of typenum=%d, ndims=%d can not be created", typenum, dims)); + return allocate(o, dims0, sizes, type, step); +} + +bool NumpyAllocator::allocate(UMatData* u, AccessFlag accessFlags, UMatUsageFlags usageFlags) const +{ + return stdAllocator->allocate(u, accessFlags, usageFlags); +} + +void NumpyAllocator::deallocate(UMatData* u) const +{ + if(!u) + return; + PyEnsureGIL gil; + CV_Assert(u->urefcount >= 0); + CV_Assert(u->refcount >= 0); + if(u->refcount == 0) + { + PyObject* o = (PyObject*)u->userdata; + Py_XDECREF(o); + delete u; + } +} diff --git a/modules/python/src2/cv2_numpy.hpp b/modules/python/src2/cv2_numpy.hpp new file mode 100644 index 0000000..7c386c7 --- /dev/null +++ b/modules/python/src2/cv2_numpy.hpp @@ -0,0 +1,217 @@ +#ifndef CV2_NUMPY_HPP +#define CV2_NUMPY_HPP + +#include "cv2.hpp" +#include "opencv2/core.hpp" + +class NumpyAllocator : public cv::MatAllocator +{ +public: + NumpyAllocator() { stdAllocator = cv::Mat::getStdAllocator(); } + ~NumpyAllocator() {} + + cv::UMatData* allocate(PyObject* o, int dims, const int* sizes, int type, size_t* step) const; + cv::UMatData* allocate(int dims0, const int* sizes, int type, void* data, size_t* step, cv::AccessFlag flags, cv::UMatUsageFlags usageFlags) const CV_OVERRIDE; + bool allocate(cv::UMatData* u, cv::AccessFlag accessFlags, cv::UMatUsageFlags usageFlags) const CV_OVERRIDE; + void deallocate(cv::UMatData* u) const CV_OVERRIDE; + + const cv::MatAllocator* stdAllocator; +}; + +extern NumpyAllocator g_numpyAllocator; + +//====================================================================================================================== + +// HACK(?): function from cv2_util.hpp +extern int failmsg(const char *fmt, ...); + +namespace { + +template +NPY_TYPES asNumpyType() +{ + return NPY_OBJECT; +} + +template<> +NPY_TYPES asNumpyType() +{ + return NPY_BOOL; +} + +#define CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(src, dst) \ + template<> \ + NPY_TYPES asNumpyType() \ + { \ + return NPY_##dst; \ + } \ + template<> \ + NPY_TYPES asNumpyType() \ + { \ + return NPY_U##dst; \ + } + +CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int8_t, INT8); + +CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int16_t, INT16); + +CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int32_t, INT32); + +CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION(int64_t, INT64); + +#undef CV_GENERATE_INTEGRAL_TYPE_NPY_CONVERSION + +template<> +NPY_TYPES asNumpyType() +{ + return NPY_FLOAT; +} + +template<> +NPY_TYPES asNumpyType() +{ + return NPY_DOUBLE; +} + +template +PyArray_Descr* getNumpyTypeDescriptor() +{ + return PyArray_DescrFromType(asNumpyType()); +} + +template <> +PyArray_Descr* getNumpyTypeDescriptor() +{ +#if SIZE_MAX == ULONG_MAX + return PyArray_DescrFromType(NPY_ULONG); +#elif SIZE_MAX == ULLONG_MAX + return PyArray_DescrFromType(NPY_ULONGLONG); +#else + return PyArray_DescrFromType(NPY_UINT); +#endif +} + +template +bool isRepresentable(U value) { + return (std::numeric_limits::min() <= value) && (value <= std::numeric_limits::max()); +} + +template +bool canBeSafelyCasted(PyObject* obj, PyArray_Descr* to) +{ + return PyArray_CanCastTo(PyArray_DescrFromScalar(obj), to) != 0; +} + + +template<> +bool canBeSafelyCasted(PyObject* obj, PyArray_Descr* to) +{ + PyArray_Descr* from = PyArray_DescrFromScalar(obj); + if (PyArray_CanCastTo(from, to)) + { + return true; + } + else + { + // False negative scenarios: + // - Signed input is positive so it can be safely cast to unsigned output + // - Input has wider limits but value is representable within output limits + // - All the above + if (PyDataType_ISSIGNED(from)) + { + int64_t input = 0; + PyArray_CastScalarToCtype(obj, &input, getNumpyTypeDescriptor()); + return (input >= 0) && isRepresentable(static_cast(input)); + } + else + { + uint64_t input = 0; + PyArray_CastScalarToCtype(obj, &input, getNumpyTypeDescriptor()); + return isRepresentable(input); + } + return false; + } +} + + +template +bool parseNumpyScalar(PyObject* obj, T& value) +{ + if (PyArray_CheckScalar(obj)) + { + // According to the numpy documentation: + // There are 21 statically-defined PyArray_Descr objects for the built-in data-types + // So descriptor pointer is not owning. + PyArray_Descr* to = getNumpyTypeDescriptor(); + if (canBeSafelyCasted(obj, to)) + { + PyArray_CastScalarToCtype(obj, &value, to); + return true; + } + } + return false; +} + + +struct SafeSeqItem +{ + PyObject * item; + SafeSeqItem(PyObject *obj, size_t idx) { item = PySequence_GetItem(obj, idx); } + ~SafeSeqItem() { Py_XDECREF(item); } + +private: + SafeSeqItem(const SafeSeqItem&); // = delete + SafeSeqItem& operator=(const SafeSeqItem&); // = delete +}; + +template +class RefWrapper +{ +public: + RefWrapper(T& item) : item_(item) {} + + T& get() CV_NOEXCEPT { return item_; } + +private: + T& item_; +}; + +// In order to support this conversion on 3.x branch - use custom reference_wrapper +// and C-style array instead of std::array +template +bool parseSequence(PyObject* obj, RefWrapper (&value)[N], const ArgInfo& info) +{ + if (!obj || obj == Py_None) + { + return true; + } + if (!PySequence_Check(obj)) + { + failmsg("Can't parse '%s'. Input argument doesn't provide sequence " + "protocol", info.name); + return false; + } + const std::size_t sequenceSize = PySequence_Size(obj); + if (sequenceSize != N) + { + failmsg("Can't parse '%s'. Expected sequence length %lu, got %lu", + info.name, N, sequenceSize); + return false; + } + for (std::size_t i = 0; i < N; ++i) + { + SafeSeqItem seqItem(obj, i); + if (!pyopencv_to(seqItem.item, value[i].get(), info)) + { + failmsg("Can't parse '%s'. Sequence item with index %lu has a " + "wrong type", info.name, i); + return false; + } + } + return true; +} + +} // namespace + + +#endif // CV2_NUMPY_HPP diff --git a/modules/python/src2/cv2_util.cpp b/modules/python/src2/cv2_util.cpp new file mode 100644 index 0000000..aca65ea --- /dev/null +++ b/modules/python/src2/cv2_util.cpp @@ -0,0 +1,178 @@ +#include "cv2_util.hpp" +#include "opencv2/core.hpp" +#include "opencv2/core/utils/configuration.private.hpp" +#include "opencv2/core/utils/logger.hpp" + +PyObject* opencv_error = NULL; +cv::TLSData > conversionErrorsTLS; + +using namespace cv; + +//====================================================================================================================== + +bool isPythonBindingsDebugEnabled() +{ + static bool param_debug = cv::utils::getConfigurationParameterBool("OPENCV_PYTHON_DEBUG", false); + return param_debug; +} + +void emit_failmsg(PyObject * exc, const char *msg) +{ + static bool param_debug = isPythonBindingsDebugEnabled(); + if (param_debug) + { + CV_LOG_WARNING(NULL, "Bindings conversion failed: " << msg); + } + PyErr_SetString(exc, msg); +} + +int failmsg(const char *fmt, ...) +{ + char str[1000]; + + va_list ap; + va_start(ap, fmt); + vsnprintf(str, sizeof(str), fmt, ap); + va_end(ap); + + emit_failmsg(PyExc_TypeError, str); + return 0; +} + +PyObject* failmsgp(const char *fmt, ...) +{ + char str[1000]; + + va_list ap; + va_start(ap, fmt); + vsnprintf(str, sizeof(str), fmt, ap); + va_end(ap); + + emit_failmsg(PyExc_TypeError, str); + return 0; +} + +void pyRaiseCVException(const cv::Exception &e) +{ + PyObject_SetAttrString(opencv_error, "file", PyString_FromString(e.file.c_str())); + PyObject_SetAttrString(opencv_error, "func", PyString_FromString(e.func.c_str())); + PyObject_SetAttrString(opencv_error, "line", PyInt_FromLong(e.line)); + PyObject_SetAttrString(opencv_error, "code", PyInt_FromLong(e.code)); + PyObject_SetAttrString(opencv_error, "msg", PyString_FromString(e.msg.c_str())); + PyObject_SetAttrString(opencv_error, "err", PyString_FromString(e.err.c_str())); + PyErr_SetString(opencv_error, e.what()); +} + +//====================================================================================================================== + +void pyRaiseCVOverloadException(const std::string& functionName) +{ + const std::vector& conversionErrors = conversionErrorsTLS.getRef(); + const std::size_t conversionErrorsCount = conversionErrors.size(); + if (conversionErrorsCount > 0) + { + // In modern std libraries small string optimization is used = no dynamic memory allocations, + // but it can be applied only for string with length < 18 symbols (in GCC) + const std::string bullet = "\n - "; + + // Estimate required buffer size - save dynamic memory allocations = faster + std::size_t requiredBufferSize = bullet.size() * conversionErrorsCount; + for (std::size_t i = 0; i < conversionErrorsCount; ++i) + { + requiredBufferSize += conversionErrors[i].size(); + } + + // Only string concatenation is required so std::string is way faster than + // std::ostringstream + std::string errorMessage("Overload resolution failed:"); + errorMessage.reserve(errorMessage.size() + requiredBufferSize); + for (std::size_t i = 0; i < conversionErrorsCount; ++i) + { + errorMessage += bullet; + errorMessage += conversionErrors[i]; + } + cv::Exception exception(Error::StsBadArg, errorMessage, functionName, "", -1); + pyRaiseCVException(exception); + } + else + { + cv::Exception exception(Error::StsInternal, "Overload resolution failed, but no errors reported", + functionName, "", -1); + pyRaiseCVException(exception); + } +} + +void pyPopulateArgumentConversionErrors() +{ + if (PyErr_Occurred()) + { + PySafeObject exception_type; + PySafeObject exception_value; + PySafeObject exception_traceback; + PyErr_Fetch(exception_type, exception_value, exception_traceback); + PyErr_NormalizeException(exception_type, exception_value, + exception_traceback); + + PySafeObject exception_message(PyObject_Str(exception_value)); + std::string message; + getUnicodeString(exception_message, message); +#ifdef CV_CXX11 + conversionErrorsTLS.getRef().push_back(std::move(message)); +#else + conversionErrorsTLS.getRef().push_back(message); +#endif + } +} + +//====================================================================================================================== + +static int OnError(int status, const char *func_name, const char *err_msg, const char *file_name, int line, void *userdata) +{ + PyGILState_STATE gstate; + gstate = PyGILState_Ensure(); + + PyObject *on_error = (PyObject*)userdata; + PyObject *args = Py_BuildValue("isssi", status, func_name, err_msg, file_name, line); + + PyObject *r = PyObject_Call(on_error, args, NULL); + if (r == NULL) { + PyErr_Print(); + } else { + Py_DECREF(r); + } + + Py_DECREF(args); + PyGILState_Release(gstate); + + return 0; // The return value isn't used +} + +PyObject *pycvRedirectError(PyObject*, PyObject *args, PyObject *kw) +{ + const char *keywords[] = { "on_error", NULL }; + PyObject *on_error; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "O", (char**)keywords, &on_error)) + return NULL; + + if ((on_error != Py_None) && !PyCallable_Check(on_error)) { + PyErr_SetString(PyExc_TypeError, "on_error must be callable"); + return NULL; + } + + // Keep track of the previous handler parameter, so we can decref it when no longer used + static PyObject* last_on_error = NULL; + if (last_on_error) { + Py_DECREF(last_on_error); + last_on_error = NULL; + } + + if (on_error == Py_None) { + ERRWRAP2(redirectError(NULL)); + } else { + last_on_error = on_error; + Py_INCREF(last_on_error); + ERRWRAP2(redirectError(OnError, last_on_error)); + } + Py_RETURN_NONE; +} diff --git a/modules/python/src2/cv2_util.hpp b/modules/python/src2/cv2_util.hpp new file mode 100644 index 0000000..3662ffc --- /dev/null +++ b/modules/python/src2/cv2_util.hpp @@ -0,0 +1,134 @@ +#ifndef CV2_UTIL_HPP +#define CV2_UTIL_HPP + +#include "cv2.hpp" +#include "opencv2/core.hpp" +#include "opencv2/core/utils/tls.hpp" +#include +#include + +//====================================================================================================================== + +bool isPythonBindingsDebugEnabled(); +void emit_failmsg(PyObject * exc, const char *msg); +int failmsg(const char *fmt, ...); +PyObject* failmsgp(const char *fmt, ...);; + +//====================================================================================================================== + +class PyAllowThreads +{ +public: + PyAllowThreads() : _state(PyEval_SaveThread()) {} + ~PyAllowThreads() + { + PyEval_RestoreThread(_state); + } +private: + PyThreadState* _state; +}; + +class PyEnsureGIL +{ +public: + PyEnsureGIL() : _state(PyGILState_Ensure()) {} + ~PyEnsureGIL() + { + PyGILState_Release(_state); + } +private: + PyGILState_STATE _state; +}; + +/** + * Light weight RAII wrapper for `PyObject*` owning references. + * In comparisson to C++11 `std::unique_ptr` with custom deleter, it provides + * implicit conversion functions that might be useful to initialize it with + * Python functions those returns owning references through the `PyObject**` + * e.g. `PyErr_Fetch` or directly pass it to functions those want to borrow + * reference to object (doesn't extend object lifetime) e.g. `PyObject_Str`. + */ +class PySafeObject +{ +public: + PySafeObject() : obj_(NULL) {} + + explicit PySafeObject(PyObject* obj) : obj_(obj) {} + + ~PySafeObject() + { + Py_CLEAR(obj_); + } + + operator PyObject*() + { + return obj_; + } + + operator PyObject**() + { + return &obj_; + } + + PyObject* release() + { + PyObject* obj = obj_; + obj_ = NULL; + return obj; + } + +private: + PyObject* obj_; + + // Explicitly disable copy operations + PySafeObject(const PySafeObject*); // = delete + PySafeObject& operator=(const PySafeObject&); // = delete +}; + +//====================================================================================================================== + +extern PyObject* opencv_error; + +void pyRaiseCVException(const cv::Exception &e); + +#define ERRWRAP2(expr) \ +try \ +{ \ + PyAllowThreads allowThreads; \ + expr; \ +} \ +catch (const cv::Exception &e) \ +{ \ + pyRaiseCVException(e); \ + return 0; \ +} \ +catch (const std::exception &e) \ +{ \ + PyErr_SetString(opencv_error, e.what()); \ + return 0; \ +} \ +catch (...) \ +{ \ + PyErr_SetString(opencv_error, "Unknown C++ exception from OpenCV code"); \ + return 0; \ +} + +//====================================================================================================================== + +extern cv::TLSData > conversionErrorsTLS; + +inline void pyPrepareArgumentConversionErrorsStorage(std::size_t size) +{ + std::vector& conversionErrors = conversionErrorsTLS.getRef(); + conversionErrors.clear(); + conversionErrors.reserve(size); +} + +void pyRaiseCVOverloadException(const std::string& functionName); +void pyPopulateArgumentConversionErrors(); + +//====================================================================================================================== + +PyObject *pycvRedirectError(PyObject*, PyObject *args, PyObject *kw); + +#endif // CV2_UTIL_HPP diff --git a/modules/python/src2/pycompat.hpp b/modules/python/src2/pycompat.hpp index 2650554..03379ec 100644 --- a/modules/python/src2/pycompat.hpp +++ b/modules/python/src2/pycompat.hpp @@ -44,6 +44,8 @@ #ifndef __PYCOMPAT_HPP__ #define __PYCOMPAT_HPP__ +#include + #if PY_MAJOR_VERSION >= 3 // Python3 treats all ints as longs, PyInt_X functions have been removed. -- 2.7.4