third_party/opencv
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #19982 from TolyaTalamanov:at/new-python-operation-api

Browse Source 
G-API: New python operations API

* Reimplement test using decorators

* Custom python operation API

* Remove wip status

* python: support Python code in bindings (through loader only)

* cleanup, skip tests for Python 2.x (not supported)

* python 2.x can't skip unittest modules

* Clean up

* Clean up

* Fix segfault python3.9

Co-authored-by: Alexander Alekhin <alexander.a.alekhin@gmail.com>
This commit is contained in:
Anatoliy Talamanov
2021-05-20 21:59:53 +03:00
committed by GitHub
parent 0f11b1fc0d
commit c4df8989e9
11 changed files with 1122 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/misc/python/pyopencv_gapi.hpp
+209 -88
View File
@@ -5,7 +5,6 @@
#ifdef _MSC_VER
#pragma warning(disable: 4503) // "decorated name length exceeded"
// on empty_meta(const cv::GMetaArgs&, const cv::GArgs&)
#endif
#include <opencv2/gapi/cpu/gcpukernel.hpp>
@@ -49,6 +48,121 @@ using GArray_GMat = cv::GArray<cv::GMat>;
// WA: Create using
using std::string;
namespace cv
{
namespace detail
{
class PyObjectHolder
{
public:
PyObjectHolder(PyObject* o, bool owner = true);
PyObject* get() const;
private:
class Impl;
std::shared_ptr<Impl> m_impl;
};
} // namespace detail
} // namespace cv
class cv::detail::PyObjectHolder::Impl
{
public:
Impl(PyObject* object, bool owner);
PyObject* get() const;
~Impl();
private:
PyObject* m_object;
};
cv::detail::PyObjectHolder::Impl::Impl(PyObject* object, bool owner)
: m_object(object)
{
// NB: Become an owner of that PyObject.
// Need to store this and get access
// after the caller which provide the object is out of range.
if (owner)
{
// NB: Impossible take ownership if object is NULL.
GAPI_Assert(object);
Py_INCREF(m_object);
}
}
cv::detail::PyObjectHolder::Impl::~Impl()
{
// NB: If NULL was set, don't decrease counter.
if (m_object)
{
Py_DECREF(m_object);
}
}
PyObject* cv::detail::PyObjectHolder::Impl::get() const
{
return m_object;
}
cv::detail::PyObjectHolder::PyObjectHolder(PyObject* object, bool owner)
: m_impl(new cv::detail::PyObjectHolder::Impl{object, owner})
{
}
PyObject* cv::detail::PyObjectHolder::get() const
{
return m_impl->get();
}
template<>
PyObject* pyopencv_from(const cv::detail::PyObjectHolder& v)
{
PyObject* o = cv::util::any_cast<cv::detail::PyObjectHolder>(v).get();
Py_INCREF(o);
return o;
}
template<>
PyObject* pyopencv_from(const cv::GArg& value)
{
GAPI_Assert(value.kind != cv::detail::ArgKind::GOBJREF);
#define HANDLE_CASE(T, O) case cv::detail::OpaqueKind::CV_##T: \
{ \
return pyopencv_from(value.get<O>()); \
}
#define UNSUPPORTED(T) case cv::detail::OpaqueKind::CV_##T: break
switch (value.opaque_kind)
{
HANDLE_CASE(BOOL, bool);
HANDLE_CASE(INT, int);
HANDLE_CASE(DOUBLE, double);
HANDLE_CASE(FLOAT, float);
HANDLE_CASE(STRING, std::string);
HANDLE_CASE(POINT, cv::Point);
HANDLE_CASE(POINT2F, cv::Point2f);
HANDLE_CASE(SIZE, cv::Size);
HANDLE_CASE(RECT, cv::Rect);
HANDLE_CASE(SCALAR, cv::Scalar);
HANDLE_CASE(MAT, cv::Mat);
HANDLE_CASE(UNKNOWN, cv::detail::PyObjectHolder);
UNSUPPORTED(UINT64);
UNSUPPORTED(DRAW_PRIM);
#undef HANDLE_CASE
#undef UNSUPPORTED
}
util::throw_error(std::logic_error("Unsupported kernel input type"));
}
template<>
bool pyopencv_to(PyObject* obj, cv::GArg& value, const ArgInfo& info)
{
value = cv::GArg(cv::detail::PyObjectHolder(obj));
return true;
}
template <>
bool pyopencv_to(PyObject* obj, std::vector<GCompileArg>& value, const ArgInfo& info)
{
@@ -81,7 +195,7 @@ PyObject* pyopencv_from(const cv::detail::OpaqueRef& o)
case cv::detail::OpaqueKind::CV_POINT2F : return pyopencv_from(o.rref<cv::Point2f>());
case cv::detail::OpaqueKind::CV_SIZE : return pyopencv_from(o.rref<cv::Size>());
case cv::detail::OpaqueKind::CV_RECT : return pyopencv_from(o.rref<cv::Rect>());
case cv::detail::OpaqueKind::CV_UNKNOWN : break;
case cv::detail::OpaqueKind::CV_UNKNOWN : return pyopencv_from(o.rref<cv::GArg>());
case cv::detail::OpaqueKind::CV_UINT64 : break;
case cv::detail::OpaqueKind::CV_SCALAR : break;
case cv::detail::OpaqueKind::CV_MAT : break;
@@ -108,7 +222,7 @@ PyObject* pyopencv_from(const cv::detail::VectorRef& v)
case cv::detail::OpaqueKind::CV_RECT : return pyopencv_from_generic_vec(v.rref<cv::Rect>());
case cv::detail::OpaqueKind::CV_SCALAR : return pyopencv_from_generic_vec(v.rref<cv::Scalar>());
case cv::detail::OpaqueKind::CV_MAT : return pyopencv_from_generic_vec(v.rref<cv::Mat>());
case cv::detail::OpaqueKind::CV_UNKNOWN : break;
case cv::detail::OpaqueKind::CV_UNKNOWN : return pyopencv_from_generic_vec(v.rref<cv::GArg>());
case cv::detail::OpaqueKind::CV_UINT64 : break;
case cv::detail::OpaqueKind::CV_DRAW_PRIM : break;
}
@@ -270,7 +384,7 @@ static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::Opaq
HANDLE_CASE(POINT2F, cv::Point2f);
HANDLE_CASE(SIZE, cv::Size);
HANDLE_CASE(RECT, cv::Rect);
UNSUPPORTED(UNKNOWN);
HANDLE_CASE(UNKNOWN, cv::GArg);
UNSUPPORTED(UINT64);
UNSUPPORTED(SCALAR);
UNSUPPORTED(MAT);
@@ -303,7 +417,7 @@ static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::Opaq
HANDLE_CASE(RECT, cv::Rect);
HANDLE_CASE(SCALAR, cv::Scalar);
HANDLE_CASE(MAT, cv::Mat);
UNSUPPORTED(UNKNOWN);
HANDLE_CASE(UNKNOWN, cv::GArg);
UNSUPPORTED(UINT64);
UNSUPPORTED(DRAW_PRIM);
#undef HANDLE_CASE
@@ -415,38 +529,7 @@ static cv::GMetaArgs extract_meta_args(const cv::GTypesInfo& info, PyObject* py_
return metas;
}
inline PyObject* extract_opaque_value(const cv::GArg& value)
{
GAPI_Assert(value.kind != cv::detail::ArgKind::GOBJREF);
#define HANDLE_CASE(T, O) case cv::detail::OpaqueKind::CV_##T: \
{ \
return pyopencv_from(value.get<O>()); \
}
#define UNSUPPORTED(T) case cv::detail::OpaqueKind::CV_##T: break
switch (value.opaque_kind)
{
HANDLE_CASE(BOOL, bool);
HANDLE_CASE(INT, int);
HANDLE_CASE(DOUBLE, double);
HANDLE_CASE(FLOAT, float);
HANDLE_CASE(STRING, std::string);
HANDLE_CASE(POINT, cv::Point);
HANDLE_CASE(POINT2F, cv::Point2f);
HANDLE_CASE(SIZE, cv::Size);
HANDLE_CASE(RECT, cv::Rect);
HANDLE_CASE(SCALAR, cv::Scalar);
HANDLE_CASE(MAT, cv::Mat);
UNSUPPORTED(UNKNOWN);
UNSUPPORTED(UINT64);
UNSUPPORTED(DRAW_PRIM);
#undef HANDLE_CASE
#undef UNSUPPORTED
}
util::throw_error(std::logic_error("Unsupported kernel input type"));
}
static cv::GRunArgs run_py_kernel(PyObject* kernel,
static cv::GRunArgs run_py_kernel(cv::detail::PyObjectHolder kernel,
const cv::gapi::python::GPythonContext &ctx)
{
const auto& ins = ctx.ins;
@@ -460,33 +543,32 @@ static cv::GRunArgs run_py_kernel(PyObject* kernel,
try
{
int in_idx = 0;
PyObject* args = PyTuple_New(ins.size());
// NB: Doesn't increase reference counter (false),
// because PyObject already have ownership.
// In case exception decrement reference counter.
cv::detail::PyObjectHolder args(PyTuple_New(ins.size()), false);
for (size_t i = 0; i < ins.size(); ++i)
{
// NB: If meta is monostate then object isn't associated with G-TYPE, so in case it
// kind matches with supported types do conversion from c++ to python, if not (CV_UNKNOWN)
// obtain PyObject* and pass as-is.
// NB: If meta is monostate then object isn't associated with G-TYPE.
if (cv::util::holds_alternative<cv::util::monostate>(in_metas[i]))
{
PyTuple_SetItem(args, i,
ins[i].opaque_kind != cv::detail::OpaqueKind::CV_UNKNOWN ? extract_opaque_value(ins[i])
: ins[i].get<PyObject*>());
PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i]));
continue;
}
switch (in_metas[i].index())
{
case cv::GMetaArg::index_of<cv::GMatDesc>():
PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::Mat>()));
PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get<cv::Mat>()));
break;
case cv::GMetaArg::index_of<cv::GScalarDesc>():
PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::Scalar>()));
PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get<cv::Scalar>()));
break;
case cv::GMetaArg::index_of<cv::GOpaqueDesc>():
PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::detail::OpaqueRef>()));
PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get<cv::detail::OpaqueRef>()));
break;
case cv::GMetaArg::index_of<cv::GArrayDesc>():
PyTuple_SetItem(args, i, pyopencv_from(ins[i].get<cv::detail::VectorRef>()));
PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get<cv::detail::VectorRef>()));
break;
case cv::GMetaArg::index_of<cv::GFrameDesc>():
util::throw_error(std::logic_error("GFrame isn't supported for custom operation"));
@@ -494,11 +576,21 @@ static cv::GRunArgs run_py_kernel(PyObject* kernel,
}
++in_idx;
}
// NB: Doesn't increase reference counter (false).
// In case PyObject_CallObject return NULL, do nothing in destructor.
cv::detail::PyObjectHolder result(
PyObject_CallObject(kernel.get(), args.get()), false);
PyObject* result = PyObject_CallObject(kernel, args);
if (PyErr_Occurred()) {
PyErr_PrintEx(0);
PyErr_Clear();
throw std::logic_error("Python kernel failed with error!");
}
// NB: In fact it's impossible situation, becase errors were handled above.
GAPI_Assert(result.get() && "Python kernel returned NULL!");
outs = out_info.size() == 1 ? cv::GRunArgs{extract_run_arg(out_info[0], result)}
: extract_run_args(out_info, result);
outs = out_info.size() == 1 ? cv::GRunArgs{extract_run_arg(out_info[0], result.get())}
: extract_run_args(out_info, result.get());
}
catch (...)
{
@@ -510,12 +602,6 @@ static cv::GRunArgs run_py_kernel(PyObject* kernel,
return outs;
}
// FIXME: Now it's impossible to obtain meta function from operation,
// because kernel connects to operation only by id (string).
static cv::GMetaArgs empty_meta(const cv::GMetaArgs &, const cv::GArgs &) {
return {};
}
static GMetaArg get_meta_arg(PyObject* obj)
{
if (PyObject_TypeCheck(obj,
@@ -558,33 +644,38 @@ static cv::GMetaArgs get_meta_args(PyObject* tuple)
return metas;
}
static GMetaArgs python_meta(PyObject* outMeta, const cv::GMetaArgs &meta, const cv::GArgs &gargs) {
static GMetaArgs run_py_meta(cv::detail::PyObjectHolder out_meta,
const cv::GMetaArgs &meta,
const cv::GArgs &gargs) {
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
cv::GMetaArgs out_metas;
try
{
PyObject* args = PyTuple_New(meta.size());
// NB: Doesn't increase reference counter (false),
// because PyObject already have ownership.
// In case exception decrement reference counter.
cv::detail::PyObjectHolder args(PyTuple_New(meta.size()), false);
size_t idx = 0;
for (auto&& m : meta)
{
switch (m.index())
{
case cv::GMetaArg::index_of<cv::GMatDesc>():
PyTuple_SetItem(args, idx, pyopencv_from(cv::util::get<cv::GMatDesc>(m)));
PyTuple_SetItem(args.get(), idx, pyopencv_from(cv::util::get<cv::GMatDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::GScalarDesc>():
PyTuple_SetItem(args, idx, pyopencv_from(cv::util::get<cv::GScalarDesc>(m)));
PyTuple_SetItem(args.get(), idx, pyopencv_from(cv::util::get<cv::GScalarDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::GArrayDesc>():
PyTuple_SetItem(args, idx, pyopencv_from(cv::util::get<cv::GArrayDesc>(m)));
PyTuple_SetItem(args.get(), idx, pyopencv_from(cv::util::get<cv::GArrayDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::GOpaqueDesc>():
PyTuple_SetItem(args, idx, pyopencv_from(cv::util::get<cv::GOpaqueDesc>(m)));
PyTuple_SetItem(args.get(), idx, pyopencv_from(cv::util::get<cv::GOpaqueDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::util::monostate>():
PyTuple_SetItem(args, idx, gargs[idx].get<PyObject*>());
PyTuple_SetItem(args.get(), idx, pyopencv_from(gargs[idx]));
break;
case cv::GMetaArg::index_of<cv::GFrameDesc>():
util::throw_error(std::logic_error("GFrame isn't supported for custom operation"));
@@ -592,9 +683,21 @@ static GMetaArgs python_meta(PyObject* outMeta, const cv::GMetaArgs &meta, const
}
++idx;
}
PyObject* result = PyObject_CallObject(outMeta, args);
out_metas = PyTuple_Check(result) ? get_meta_args(result)
: cv::GMetaArgs{get_meta_arg(result)};
// NB: Doesn't increase reference counter (false).
// In case PyObject_CallObject return NULL, do nothing in destructor.
cv::detail::PyObjectHolder result(
PyObject_CallObject(out_meta.get(), args.get()), false);
if (PyErr_Occurred()) {
PyErr_PrintEx(0);
PyErr_Clear();
throw std::logic_error("Python outMeta failed with error!");
}
// NB: In fact it's impossible situation, becase errors were handled above.
GAPI_Assert(result.get() && "Python outMeta returned NULL!");
out_metas = PyTuple_Check(result.get()) ? get_meta_args(result.get())
: cv::GMetaArgs{get_meta_arg(result.get())};
}
catch (...)
{
@@ -611,23 +714,43 @@ static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObjec
using namespace cv;
gapi::GKernelPackage pkg;
Py_ssize_t size = PyTuple_Size(py_args);
for (int i = 0; i < size; ++i)
{
PyObject* pair = PyTuple_GetItem(py_args, i);
PyObject* kernel = PyTuple_GetItem(pair, 0);
PyObject* user_kernel = PyTuple_GetItem(py_args, i);
std::string id;
if (!pyopencv_to(PyTuple_GetItem(pair, 1), id, ArgInfo("id", false)))
{
PyErr_SetString(PyExc_TypeError, "Failed to obtain: kernel id must be a string");
PyObject* id_obj = PyObject_GetAttrString(user_kernel, "id");
if (!id_obj) {
PyErr_SetString(PyExc_TypeError,
"Python kernel should contain id, please use cv.gapi.kernel to define kernel");
return NULL;
}
Py_INCREF(kernel);
PyObject* out_meta = PyObject_GetAttrString(user_kernel, "outMeta");
if (!out_meta) {
PyErr_SetString(PyExc_TypeError,
"Python kernel should contain outMeta, please use cv.gapi.kernel to define kernel");
return NULL;
}
PyObject* run = PyObject_GetAttrString(user_kernel, "run");
if (!run) {
PyErr_SetString(PyExc_TypeError,
"Python kernel should contain run, please use cv.gapi.kernel to define kernel");
return NULL;
}
std::string id;
if (!pyopencv_to(id_obj, id, ArgInfo("id", false)))
{
PyErr_SetString(PyExc_TypeError, "Failed to obtain string");
return NULL;
}
using namespace std::placeholders;
gapi::python::GPythonFunctor f(id.c_str(),
empty_meta,
std::bind(run_py_kernel,
kernel,
std::placeholders::_1));
std::bind(run_py_meta , cv::detail::PyObjectHolder{out_meta}, _1, _2),
std::bind(run_py_kernel, cv::detail::PyObjectHolder{run} , _1));
pkg.include(f);
}
return pyopencv_from(pkg);
@@ -644,7 +767,6 @@ static PyObject* pyopencv_cv_gapi_op(PyObject* , PyObject* py_args, PyObject*)
return NULL;
}
PyObject* outMeta = PyTuple_GetItem(py_args, 1);
Py_INCREF(outMeta);
cv::GArgs args;
for (int i = 2; i < size; i++)
@@ -684,13 +806,12 @@ static PyObject* pyopencv_cv_gapi_op(PyObject* , PyObject* py_args, PyObject*)
}
else
{
Py_INCREF(item);
args.emplace_back(cv::GArg(item));
args.emplace_back(cv::GArg(cv::detail::PyObjectHolder{item}));
}
}
cv::GKernel::M outMetaWrapper = std::bind(python_meta,
outMeta,
cv::GKernel::M outMetaWrapper = std::bind(run_py_meta,
cv::detail::PyObjectHolder{outMeta},
std::placeholders::_1,
std::placeholders::_2);
return pyopencv_from(cv::gapi::wip::op(id, outMetaWrapper, std::move(args)));
@@ -698,7 +819,7 @@ static PyObject* pyopencv_cv_gapi_op(PyObject* , PyObject* py_args, PyObject*)
static PyObject* pyopencv_cv_gin(PyObject*, PyObject* py_args, PyObject*)
{
Py_INCREF(py_args);
cv::detail::PyObjectHolder holder{py_args};
auto callback = cv::detail::ExtractArgsCallback{[=](const cv::GTypesInfo& info)
{
PyGILState_STATE gstate;
@@ -707,7 +828,7 @@ static PyObject* pyopencv_cv_gin(PyObject*, PyObject* py_args, PyObject*)
cv::GRunArgs args;
try
{
args = extract_run_args(info, py_args);
args = extract_run_args(info, holder.get());
}
catch (...)
{
@@ -792,10 +913,10 @@ struct PyOpenCV_Converter<cv::GOpaque<T>>
};
// extend cv.gapi.wip. methods
#define PYOPENCV_EXTRA_METHODS_GAPI_WIP \
// extend cv.gapi methods
#define PYOPENCV_EXTRA_METHODS_GAPI \
{"kernels", CV_PY_FN_WITH_KW(pyopencv_cv_gapi_kernels), "kernels(...) -> GKernelPackage"}, \
{"op", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_op, 0), "kernels(...) -> retval\n"}, \
{"__op", CV_PY_FN_WITH_KW(pyopencv_cv_gapi_op), "__op(...) -> retval\n"},
#endif // HAVE_OPENCV_GAPI