Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add stateful kernel to python G-API

Browse Source
pull/22037/head
xiong-jie-y 3 years ago
parent 8d0fbc6a1e
commit a3d6994afa
3 changed files with 148 additions and 13 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 14
      modules/gapi/include/opencv2/gapi/python/python.hpp
  2. 106
      modules/gapi/misc/python/pyopencv_gapi.hpp
  3. 41
      modules/gapi/src/backends/python/gpythonbackend.cpp

14
modules/gapi/include/opencv2/gapi/python/python.hpp
Unescape View File

@ -31,17 +31,26 @@ struct GPythonContext
const cv::GArgs &ins;
const cv::GMetaArgs &in_metas;
const cv::GTypesInfo &out_info;
bool m_isStateful;
GArg m_state;
};
using Impl = std::function<cv::GRunArgs(const GPythonContext&)>;
using Setup = std::function<cv::GArg(const GMetaArgs&, const GArgs&)>;
class GAPI_EXPORTS GPythonKernel
{
public:
GPythonKernel() = default;
GPythonKernel(Impl run);
GPythonKernel(Impl run, Setup setup);
cv::GRunArgs operator()(const GPythonContext& ctx);
bool m_isStateful = false;
Setup m_setup = nullptr;
private:
Impl m_run;
};
@ -51,7 +60,8 @@ class GAPI_EXPORTS GPythonFunctor : public cv::gapi::GFunctor
public:
using Meta = cv::GKernel::M;
GPythonFunctor(const char* id, const Meta &meta, const Impl& impl);
GPythonFunctor(const char* id, const Meta& meta, const Impl& impl,
const Setup& setup = nullptr);
GKernelImpl impl() const override;
gapi::GBackend backend() const override;

106
modules/gapi/misc/python/pyopencv_gapi.hpp
Unescape View File

@ -660,7 +660,7 @@ static cv::GRunArgs run_py_kernel(cv::detail::PyObjectHolder kernel,
// 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);
cv::detail::PyObjectHolder args(PyTuple_New(ctx.m_isStateful ? ins.size() + 1: 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.
@ -690,6 +690,12 @@ static cv::GRunArgs run_py_kernel(cv::detail::PyObjectHolder kernel,
}
++in_idx;
}
if (ctx.m_isStateful)
{
PyTuple_SetItem(args.get(), ins.size(), pyopencv_from(ctx.m_state));
}
// NB: Doesn't increase reference counter (false).
// In case PyObject_CallObject return NULL, do nothing in destructor.
cv::detail::PyObjectHolder result(
@ -736,6 +742,80 @@ static cv::GRunArgs run_py_kernel(cv::detail::PyObjectHolder kernel,
return outs;
}
static cv::GArg setup_py(cv::detail::PyObjectHolder out_meta, const cv::GMetaArgs& meta,
const cv::GArgs& gargs)
{
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
cv::GArg out;
try
{
// 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.get(), idx, pyopencv_from(cv::util::get<cv::GMatDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::GScalarDesc>():
PyTuple_SetItem(args.get(), idx,
pyopencv_from(cv::util::get<cv::GScalarDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::GArrayDesc>():
PyTuple_SetItem(args.get(), idx,
pyopencv_from(cv::util::get<cv::GArrayDesc>(m)));
break;
case cv::GMetaArg::index_of<cv::GOpaqueDesc>():
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.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"));
break;
}
++idx;
}
// PyTuple_SetItem(args.get(), idx, pyopencv_from(gmarg));
// 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 kernel failed with error!");
}
// NB: In fact it's impossible situation, because errors were handled above.
GAPI_Assert(result.get() && "Python kernel returned NULL!");
if (!pyopencv_to(result.get(), out, ArgInfo("arg", false)))
{
util::throw_error(std::logic_error("Unsupported output meta type"));
}
}
catch (...)
{
PyGILState_Release(gstate);
throw;
}
PyGILState_Release(gstate);
return out;
}
static GMetaArg get_meta_arg(PyObject* obj)
{
cv::GMetaArg arg;
@ -860,6 +940,10 @@ static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObjec
"Python kernel should contain run, please use cv.gapi.kernel to define kernel");
return NULL;
}
PyObject* setup = nullptr;
if (PyObject_HasAttrString(user_kernel, "setup")) {
setup = PyObject_GetAttrString(user_kernel, "setup");
}
std::string id;
if (!pyopencv_to(id_obj, id, ArgInfo("id", false)))
@ -869,10 +953,22 @@ static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObjec
}
using namespace std::placeholders;
gapi::python::GPythonFunctor f(id.c_str(),
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);
if (setup)
{
gapi::python::GPythonFunctor f(
id.c_str(), std::bind(run_py_meta, cv::detail::PyObjectHolder{out_meta}, _1, _2),
std::bind(run_py_kernel, cv::detail::PyObjectHolder{run}, _1),
std::bind(setup_py, cv::detail::PyObjectHolder{setup}, _1, _2));
pkg.include(f);
}
else
{
gapi::python::GPythonFunctor f(
id.c_str(), 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);
}

41
modules/gapi/src/backends/python/gpythonbackend.cpp
Unescape View File

@ -6,15 +6,19 @@
#include <ade/util/zip_range.hpp> // zip_range, indexed
#include "compiler/gmodel.hpp"
#include <opencv2/gapi/garg.hpp>
#include <opencv2/gapi/util/throw.hpp> // throw_error
#include <opencv2/gapi/python/python.hpp>
#include "api/gbackend_priv.hpp"
#include "backends/common/gbackend.hpp"
cv::gapi::python::GPythonKernel::GPythonKernel(cv::gapi::python::Impl run)
: m_run(run)
cv::gapi::python::GPythonKernel::GPythonKernel(cv::gapi::python::Impl run,
cv::gapi::python::Setup setup)
: m_run(run), m_setup(setup)
{
m_isStateful = (setup != nullptr);
}
cv::GRunArgs cv::gapi::python::GPythonKernel::operator()(const cv::gapi::python::GPythonContext& ctx)
@ -23,9 +27,10 @@ cv::GRunArgs cv::gapi::python::GPythonKernel::operator()(const cv::gapi::python:
}
cv::gapi::python::GPythonFunctor::GPythonFunctor(const char* id,
const cv::gapi::python::GPythonFunctor::Meta &meta,
const cv::gapi::python::Impl& impl)
: gapi::GFunctor(id), impl_{GPythonKernel{impl}, meta}
const cv::gapi::python::GPythonFunctor::Meta& meta,
const cv::gapi::python::Impl& impl,
const cv::gapi::python::Setup& setup)
: gapi::GFunctor(id), impl_{GPythonKernel{impl, setup}, meta}
{
}
@ -68,6 +73,7 @@ class GPythonExecutable final: public cv::gimpl::GIslandExecutable
virtual cv::RMat allocate(const cv::GMatDesc&) const override { return {}; }
virtual bool canReshape() const override { return true; }
virtual void handleNewStream() override;
virtual void reshape(ade::Graph&, const cv::GCompileArgs&) override {
// Do nothing here
}
@ -80,6 +86,7 @@ public:
cv::gimpl::GModel::ConstGraph m_gm;
cv::gapi::python::GPythonKernel m_kernel;
ade::NodeHandle m_op;
cv::GArg m_node_state;
cv::GTypesInfo m_out_info;
cv::GMetaArgs m_in_metas;
@ -153,6 +160,15 @@ static void writeBack(cv::GRunArg& arg, cv::GRunArgP& out)
}
}
void GPythonExecutable::handleNewStream()
{
if (!m_kernel.m_isStateful)
return;
m_node_state = m_kernel.m_setup(cv::gimpl::GModel::collectInputMeta(m_gm, m_op),
m_gm.metadata(m_op).get<cv::gimpl::Op>().args);
}
void GPythonExecutable::run(std::vector<InObj> &&input_objs,
std::vector<OutObj> &&output_objs)
{
@ -165,8 +181,15 @@ void GPythonExecutable::run(std::vector<InObj> &&input_objs,
std::back_inserter(inputs),
std::bind(&packArg, std::ref(m_res), _1));
cv::gapi::python::GPythonContext ctx{inputs, m_in_metas, m_out_info, false};
// For stateful kernel add state to its execution context
if (m_kernel.m_isStateful)
{
ctx.m_state = m_node_state;
ctx.m_isStateful = true;
}
cv::gapi::python::GPythonContext ctx{inputs, m_in_metas, m_out_info};
auto outs = m_kernel(ctx);
for (auto&& it : ade::util::zip(outs, output_objs))
@ -225,6 +248,12 @@ GPythonExecutable::GPythonExecutable(const ade::Graph& g,
m_op = *it;
m_kernel = cag.metadata(m_op).get<PythonUnit>().kernel;
// If kernel is stateful then prepare storage for its state.
if (m_kernel.m_isStateful)
{
m_node_state = cv::GArg{ };
}
// Ensure this the only op in the graph
if (std::any_of(it+1, nodes.end(), is_op))
{

Write Preview
Loading…
Cancel
Save