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

Implement python backend

Browse Source
This commit is contained in:
Anatoliy Talamanov
2021-03-26 14:16:26 +03:00
parent ad2f5ccc66
commit 79d4a38d87
9 changed files with 697 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/gapi/misc/python/pyopencv_gapi.hpp
+142 -13
View File
@@ -3,10 +3,13 @@
#ifdef HAVE_OPENCV_GAPI
#include <opencv2/gapi/cpu/gcpukernel.hpp>
#include <opencv2/gapi/python/python.hpp>
// NB: Python wrapper replaces :: with _ for classes
using gapi_GKernelPackage = cv::gapi::GKernelPackage;
using gapi_GNetPackage = cv::gapi::GNetPackage;
using gapi_ie_PyParams = cv::gapi::ie::PyParams;
using gapi_GKernelPackage = cv::gapi::GKernelPackage;
using gapi_GNetPackage = cv::gapi::GNetPackage;
using gapi_ie_PyParams = cv::gapi::ie::PyParams;
using gapi_wip_IStreamSource_Ptr = cv::Ptr<cv::gapi::wip::IStreamSource>;
using detail_ExtractArgsCallback = cv::detail::ExtractArgsCallback;
using detail_ExtractMetaCallback = cv::detail::ExtractMetaCallback;
@@ -18,7 +21,7 @@ using GOpaque_int = cv::GOpaque<int>;
using GOpaque_double = cv::GOpaque<double>;
using GOpaque_float = cv::GOpaque<double>;
using GOpaque_string = cv::GOpaque<std::string>;
using GOpaque_Point = cv::GOpaque<cv::Point>;
using GOpaque_Point2i = cv::GOpaque<cv::Point>;
using GOpaque_Point2f = cv::GOpaque<cv::Point2f>;
using GOpaque_Size = cv::GOpaque<cv::Size>;
using GOpaque_Rect = cv::GOpaque<cv::Rect>;
@@ -28,7 +31,7 @@ using GArray_int = cv::GArray<int>;
using GArray_double = cv::GArray<double>;
using GArray_float = cv::GArray<double>;
using GArray_string = cv::GArray<std::string>;
using GArray_Point = cv::GArray<cv::Point>;
using GArray_Point2i = cv::GArray<cv::Point>;
using GArray_Point2f = cv::GArray<cv::Point2f>;
using GArray_Size = cv::GArray<cv::Size>;
using GArray_Rect = cv::GArray<cv::Rect>;
@@ -41,19 +44,19 @@ using GArray_GMat = cv::GArray<cv::GMat>;
// WA: Create using
using std::string;
template<>
template <>
bool pyopencv_to(PyObject* obj, std::vector<GCompileArg>& value, const ArgInfo& info)
{
return pyopencv_to_generic_vec(obj, value, info);
}
template<>
template <>
PyObject* pyopencv_from(const std::vector<GCompileArg>& value)
{
return pyopencv_from_generic_vec(value);
}
template<>
template <>
bool pyopencv_to(PyObject* obj, GRunArgs& value, const ArgInfo& info)
{
return pyopencv_to_generic_vec(obj, value, info);
@@ -267,10 +270,9 @@ static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::Opaq
UNSUPPORTED(SCALAR);
UNSUPPORTED(MAT);
UNSUPPORTED(DRAW_PRIM);
}
#undef HANDLE_CASE
#undef UNSUPPORTED
}
util::throw_error(std::logic_error("Unsupported type for GOpaqueT"));
}
@@ -302,8 +304,7 @@ static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::Opaq
#undef HANDLE_CASE
#undef UNSUPPORTED
}
util::throw_error(std::logic_error("Unsupported type for GOpaqueT"));
util::throw_error(std::logic_error("Unsupported type for GArrayT"));
}
static cv::GRunArg extract_run_arg(const cv::GTypeInfo& info, PyObject* item)
@@ -340,6 +341,7 @@ static cv::GRunArg extract_run_arg(const cv::GTypeInfo& info, PyObject* item)
}
case cv::GShape::GFRAME:
{
// NB: Isn't supported yet.
break;
}
}
@@ -391,7 +393,6 @@ static cv::GMetaArg extract_meta_arg(const cv::GTypeInfo& info, PyObject* item)
break;
}
}
util::throw_error(std::logic_error("Unsupported output shape"));
}
@@ -409,6 +410,134 @@ 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,
const cv::gapi::python::GPythonContext &ctx)
{
const auto& ins = ctx.ins;
const auto& in_metas = ctx.in_metas;
const auto& out_info = ctx.out_info;
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
cv::GRunArgs outs;
try
{
int in_idx = 0;
PyObject* args = PyTuple_New(ins.size());
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.
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*>());
continue;
}
switch (in_metas[i].index())
{
case cv::GMetaArg::index_of<cv::GMatDesc>():
PyTuple_SetItem(args, 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>()));
break;
case cv::GMetaArg::index_of<cv::GOpaqueDesc>():
PyTuple_SetItem(args, 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>()));
break;
case cv::GMetaArg::index_of<cv::GFrameDesc>():
util::throw_error(std::logic_error("GFrame isn't supported for custom operation"));
break;
}
++in_idx;
}
PyObject* result = PyObject_CallObject(kernel, args);
outs = out_info.size() == 1 ? cv::GRunArgs{extract_run_arg(out_info[0], result)}
: extract_run_args(out_info, result);
}
catch (...)
{
PyGILState_Release(gstate);
throw;
}
PyGILState_Release(gstate);
return outs;
}
// FIXME: Now it's impossible to obtain meta function from operation,
// because kernel connects to operation only by id (string).
static GMetaArgs empty_meta(const cv::GMetaArgs &, const cv::GArgs &) {
return {};
}
static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObject*)
{
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);
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");
return NULL;
}
Py_INCREF(kernel);
gapi::python::GPythonFunctor f(id.c_str(),
empty_meta,
std::bind(run_py_kernel,
kernel,
std::placeholders::_1));
pkg.include(f);
}
return pyopencv_from(pkg);
}
static PyObject* pyopencv_cv_gin(PyObject*, PyObject* py_args, PyObject*)
{
Py_INCREF(py_args);
modules/gapi/misc/python/test/test_gapi_sample_pipelines.py
+230
View File
@@ -15,6 +15,59 @@ pkgs = [
# ('plaidml', cv.gapi.core.plaidml.kernels())
]
# Test output GMat.
def custom_add(img1, img2, dtype):
return cv.add(img1, img2)
# Test output GScalar.
def custom_mean(img):
return cv.mean(img)
# Test output tuple of GMat's.
def custom_split3(img):
# NB: cv.split return list but g-api requires tuple in multiple output case
return tuple(cv.split(img))
# Test output GOpaque.
def custom_size(img):
# NB: Take only H, W, because the operation should return cv::Size which is 2D.
return img.shape[:2]
# Test output GArray.
def custom_goodFeaturesToTrack(img, max_corners, quality_lvl,
min_distance, mask, block_sz,
use_harris_detector, k):
features = cv.goodFeaturesToTrack(img, max_corners, quality_lvl,
min_distance, mask=mask,
blockSize=block_sz,
useHarrisDetector=use_harris_detector, k=k)
# NB: The operation output is cv::GArray<cv::Pointf>, so it should be mapped
# to python paramaters like this: [(1.2, 3.4), (5.2, 3.2)], because the cv::Point2f
# according to opencv rules mapped to the tuple and cv::GArray<> mapped to the list.
# OpenCV returns np.array with shape (n_features, 1, 2), so let's to convert it to list
# tuples with size - n_features.
features = list(map(tuple, features.reshape(features.shape[0], -1)))
return features
# Test input scalar.
def custom_addC(img, sc, dtype):
# NB: dtype is just ignored in this implementation.
# More over from G-API kernel got scalar as tuples with 4 elements
# where the last element is equal to zero, just cut him for broadcasting.
return img + np.array(sc, dtype=np.uint8)[:-1]
# Test input opaque.
def custom_sizeR(rect):
# NB: rect - is tuple (x, y, h, w)
return (rect[2], rect[3])
# Test input array.
def custom_boundingRect(array):
# NB: OpenCV - numpy array (n_points x 2).
# G-API - array of tuples (n_points).
return cv.boundingRect(np.array(array))
class gapi_sample_pipelines(NewOpenCVTests):
@@ -40,5 +93,182 @@ class gapi_sample_pipelines(NewOpenCVTests):
'Failed on ' + pkg_name + ' backend')
def test_custom_mean(self):
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in_mat = cv.imread(img_path)
# OpenCV
expected = cv.mean(in_mat)
# G-API
g_in = cv.GMat()
g_out = cv.gapi.mean(g_in)
comp = cv.GComputation(g_in, g_out)
pkg = cv.gapi_wip_kernels((custom_mean, 'org.opencv.core.math.mean'))
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
# Comparison
self.assertEqual(expected, actual)
def test_custom_add(self):
sz = (3, 3)
in_mat1 = np.full(sz, 45, dtype=np.uint8)
in_mat2 = np.full(sz, 50 , dtype=np.uint8)
# OpenCV
expected = cv.add(in_mat1, in_mat2)
# G-API
g_in1 = cv.GMat()
g_in2 = cv.GMat()
g_out = cv.gapi.add(g_in1, g_in2)
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_out))
pkg = cv.gapi_wip_kernels((custom_add, 'org.opencv.core.math.add'))
actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
def test_custom_size(self):
sz = (100, 150, 3)
in_mat = np.full(sz, 45, dtype=np.uint8)
# OpenCV
expected = (100, 150)
# G-API
g_in = cv.GMat()
g_sz = cv.gapi.streaming.size(g_in)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_sz))
pkg = cv.gapi_wip_kernels((custom_size, 'org.opencv.streaming.size'))
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
def test_custom_goodFeaturesToTrack(self):
# G-API
img_path = self.find_file('cv/face/david2.jpg', [os.environ.get('OPENCV_TEST_DATA_PATH')])
in_mat = cv.cvtColor(cv.imread(img_path), cv.COLOR_RGB2GRAY)
# NB: goodFeaturesToTrack configuration
max_corners = 50
quality_lvl = 0.01
min_distance = 10
block_sz = 3
use_harris_detector = True
k = 0.04
mask = None
# OpenCV
expected = cv.goodFeaturesToTrack(in_mat, max_corners, quality_lvl,
min_distance, mask=mask,
blockSize=block_sz, useHarrisDetector=use_harris_detector, k=k)
# G-API
g_in = cv.GMat()
g_out = cv.gapi.goodFeaturesToTrack(g_in, max_corners, quality_lvl,
min_distance, mask, block_sz, use_harris_detector, k)
comp = cv.GComputation(cv.GIn(g_in), cv.GOut(g_out))
pkg = cv.gapi_wip_kernels((custom_goodFeaturesToTrack, 'org.opencv.imgproc.feature.goodFeaturesToTrack'))
actual = comp.apply(cv.gin(in_mat), args=cv.compile_args(pkg))
# NB: OpenCV & G-API have different output types.
# OpenCV - numpy array with shape (num_points, 1, 2)
# G-API - list of tuples with size - num_points
# Comparison
self.assertEqual(0.0, cv.norm(expected.flatten(),
np.array(actual, dtype=np.float32).flatten(), cv.NORM_INF))
def test_custom_addC(self):
sz = (3, 3, 3)
in_mat = np.full(sz, 45, dtype=np.uint8)
sc = (50, 10, 20)
# Numpy reference, make array from sc to keep uint8 dtype.
expected = in_mat + np.array(sc, dtype=np.uint8)
# G-API
g_in = cv.GMat()
g_sc = cv.GScalar()
g_out = cv.gapi.addC(g_in, g_sc)
comp = cv.GComputation(cv.GIn(g_in, g_sc), cv.GOut(g_out))
pkg = cv.gapi_wip_kernels((custom_addC, 'org.opencv.core.math.addC'))
actual = comp.apply(cv.gin(in_mat, sc), args=cv.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
def test_custom_sizeR(self):
# x, y, h, w
roi = (10, 15, 100, 150)
expected = (100, 150)
# G-API
g_r = cv.GOpaqueT(cv.gapi.CV_RECT)
g_sz = cv.gapi.streaming.size(g_r)
comp = cv.GComputation(cv.GIn(g_r), cv.GOut(g_sz))
pkg = cv.gapi_wip_kernels((custom_sizeR, 'org.opencv.streaming.sizeR'))
actual = comp.apply(cv.gin(roi), args=cv.compile_args(pkg))
# cv.norm works with tuples ?
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
def test_custom_boundingRect(self):
points = [(0,0), (0,1), (1,0), (1,1)]
# OpenCV
expected = cv.boundingRect(np.array(points))
# G-API
g_pts = cv.GArrayT(cv.gapi.CV_POINT)
g_br = cv.gapi.boundingRect(g_pts)
comp = cv.GComputation(cv.GIn(g_pts), cv.GOut(g_br))
pkg = cv.gapi_wip_kernels((custom_boundingRect, 'org.opencv.imgproc.shape.boundingRectVector32S'))
actual = comp.apply(cv.gin(points), args=cv.compile_args(pkg))
# cv.norm works with tuples ?
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
def test_multiple_custom_kernels(self):
sz = (3, 3, 3)
in_mat1 = np.full(sz, 45, dtype=np.uint8)
in_mat2 = np.full(sz, 50 , dtype=np.uint8)
# OpenCV
expected = cv.mean(cv.split(cv.add(in_mat1, in_mat2))[1])
# G-API
g_in1 = cv.GMat()
g_in2 = cv.GMat()
g_sum = cv.gapi.add(g_in1, g_in2)
g_b, g_r, g_g = cv.gapi.split3(g_sum)
g_mean = cv.gapi.mean(g_b)
comp = cv.GComputation(cv.GIn(g_in1, g_in2), cv.GOut(g_mean))
pkg = cv.gapi_wip_kernels((custom_add , 'org.opencv.core.math.add'),
(custom_mean , 'org.opencv.core.math.mean'),
(custom_split3, 'org.opencv.core.transform.split3'))
actual = comp.apply(cv.gin(in_mat1, in_mat2), args=cv.compile_args(pkg))
self.assertEqual(0.0, cv.norm(expected, actual, cv.NORM_INF))
if __name__ == '__main__':
NewOpenCVTests.bootstrap()
modules/gapi/misc/python/test/test_gapi_streaming.py
-1
View File
@@ -199,6 +199,5 @@ class test_gapi_streaming(NewOpenCVTests):
if proc_num_frames == max_num_frames:
break;
if __name__ == '__main__':
NewOpenCVTests.bootstrap()