diff --git a/cmake/OpenCVPackaging.cmake b/cmake/OpenCVPackaging.cmake index 96aaacc5d9..e90aabb893 100644 --- a/cmake/OpenCVPackaging.cmake +++ b/cmake/OpenCVPackaging.cmake @@ -123,7 +123,7 @@ endif() set(STD_OPENCV_LIBS opencv-data) set(STD_OPENCV_DEV libopencv-dev) -foreach(module 3d calib core dnn features flann gapi highgui +foreach(module 3d calib core dnn features flann highgui imgcodecs imgproc ml objdetect photo stereo stitching ts video videoio) if(HAVE_opencv_${module}) diff --git a/cmake/vars/OPENCV_DISABLE_THREAD_SUPPORT.cmake b/cmake/vars/OPENCV_DISABLE_THREAD_SUPPORT.cmake index 8f3a4c0048..7608375d61 100644 --- a/cmake/vars/OPENCV_DISABLE_THREAD_SUPPORT.cmake +++ b/cmake/vars/OPENCV_DISABLE_THREAD_SUPPORT.cmake @@ -21,7 +21,6 @@ ocv_update(BUILD_opencv_java OFF) # <[thread|mutex|condition_variable|future]>` and linkage into # `libpthread` to work. ocv_update(BUILD_opencv_objdetect OFF) -ocv_update(BUILD_opencv_gapi OFF) ocv_update(BUILD_opencv_dnn OFF) set(OPJ_USE_THREAD "OFF" CACHE INTERNAL "") diff --git a/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_gapi.png b/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_gapi.png deleted file mode 100644 index f378ea870e..0000000000 Binary files a/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_gapi.png and /dev/null differ diff --git a/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_gapi_fluid.png b/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_gapi_fluid.png deleted file mode 100644 index 11bb83bf4c..0000000000 Binary files a/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_gapi_fluid.png and /dev/null differ diff --git a/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_ocv.png b/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_ocv.png deleted file mode 100644 index 60b5492da8..0000000000 Binary files a/doc/tutorials/gapi/anisotropic_segmentation/pics/massif_export_ocv.png and /dev/null differ diff --git a/doc/tutorials/gapi/anisotropic_segmentation/pics/result.jpg b/doc/tutorials/gapi/anisotropic_segmentation/pics/result.jpg deleted file mode 100644 index e69cd690aa..0000000000 Binary files a/doc/tutorials/gapi/anisotropic_segmentation/pics/result.jpg and /dev/null differ diff --git a/doc/tutorials/gapi/anisotropic_segmentation/pics/segm.gif b/doc/tutorials/gapi/anisotropic_segmentation/pics/segm.gif deleted file mode 100644 index a984d9da36..0000000000 Binary files a/doc/tutorials/gapi/anisotropic_segmentation/pics/segm.gif and /dev/null differ diff --git a/doc/tutorials/gapi/anisotropic_segmentation/pics/segm_fluid.gif b/doc/tutorials/gapi/anisotropic_segmentation/pics/segm_fluid.gif deleted file mode 100644 index 2180b434d4..0000000000 Binary files a/doc/tutorials/gapi/anisotropic_segmentation/pics/segm_fluid.gif and /dev/null differ diff --git a/doc/tutorials/gapi/anisotropic_segmentation/porting_anisotropic_segmentation.markdown b/doc/tutorials/gapi/anisotropic_segmentation/porting_anisotropic_segmentation.markdown deleted file mode 100644 index 64b68e644c..0000000000 --- a/doc/tutorials/gapi/anisotropic_segmentation/porting_anisotropic_segmentation.markdown +++ /dev/null @@ -1,404 +0,0 @@ -# Porting anisotropic image segmentation on G-API {#tutorial_gapi_anisotropic_segmentation} - -@prev_tutorial{tutorial_gapi_interactive_face_detection} -@next_tutorial{tutorial_gapi_face_beautification} - -[TOC] - -# Introduction {#gapi_anisotropic_intro} - -In this tutorial you will learn: -* How an existing algorithm can be transformed into a G-API - computation (graph); -* How to inspect and profile G-API graphs; -* How to customize graph execution without changing its code. - -This tutorial is based on @ref -tutorial_anisotropic_image_segmentation_by_a_gst. - -# Quick start: using OpenCV backend {#gapi_anisotropic_start} - -Before we start, let's review the original algorithm implementation: - -@include cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp - -## Examining calcGST() {#gapi_anisotropic_calcgst} - -The function calcGST() is clearly an image processing pipeline: -* It is just a sequence of operations over a number of cv::Mat; -* No logic (conditionals) and loops involved in the code; -* All functions operate on 2D images (like cv::Sobel, cv::multiply, -cv::boxFilter, cv::sqrt, etc). - -Considering the above, calcGST() is a great candidate to start -with. In the original code, its prototype is defined like this: - -@snippet cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp calcGST_proto - -With G-API, we can define it as follows: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp calcGST_proto - -It is important to understand that the new G-API based version of -calcGST() will just produce a compute graph, in contrast to its -original version, which actually calculates the values. This is a -principal difference -- G-API based functions like this are used to -construct graphs, not to process the actual data. - -Let's start implementing calcGST() with calculation of \f$J\f$ -matrix. This is how the original code looks like: - -@snippet cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp calcJ_header - -Here we need to declare output objects for every new operation (see -img as a result for cv::Mat::convertTo, imgDiffX and others as results for -cv::Sobel and cv::multiply). - -The G-API analogue is listed below: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp calcGST_header - -This snippet demonstrates the following syntactic difference between -G-API and traditional OpenCV: -* All standard G-API functions are by default placed in "cv::gapi" -namespace; -* G-API operations _return_ its results -- there's no need to pass -extra "output" parameters to the functions. - -Note -- this code is also using `auto` -- types of intermediate objects -like `img`, `imgDiffX`, and so on are inferred automatically by the -C++ compiler. In this example, the types are determined by G-API -operation return values which all are cv::GMat. - -G-API standard kernels are trying to follow OpenCV API conventions -whenever possible -- so cv::gapi::sobel takes the same arguments as -cv::Sobel, cv::gapi::mul follows cv::multiply, and so on (except -having a return value). - -The rest of calcGST() function can be implemented the same -way trivially. Below is its full source code: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp calcGST - -## Running G-API graph {#gapi_anisotropic_running} - -After calcGST() is defined in G-API language, we can construct a graph -based on it and finally run it -- pass input image and obtain -result. Before we do it, let's have a look how original code looked -like: - -@snippet cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp main_extra - -G-API-based functions like calcGST() can't be applied to input data -directly, since it is a _construction_ code, not the _processing_ code. -In order to _run_ computations, a special object of class -cv::GComputation needs to be created. This object wraps our G-API code -(which is a composition of G-API data and operations) into a callable -object, similar to C++11 -[std::function<>](https://en.cppreference.com/w/cpp/utility/functional/function). - -cv::GComputation class has a number of constructors which can be used -to define a graph. Generally, user needs to pass graph boundaries --- _input_ and _output_ objects, on which a GComputation is -defined. Then G-API analyzes the call flow from _outputs_ to _inputs_ -and reconstructs the graph with operations in-between the specified -boundaries. This may sound complex, however in fact the code looks -like this: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp main - -Note that this code slightly changes from the original one: forming up -the resulting image is also a part of the pipeline (done with -cv::gapi::addWeighted). - -Result of this G-API pipeline bit-exact matches the original one -(given the same input image): - -![Segmentation result with G-API](pics/result.jpg) - -## G-API initial version: full listing {#gapi_anisotropic_ocv} - -Below is the full listing of the initial anisotropic image -segmentation port on G-API: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi.cpp full_sample - -# Inspecting the initial version {#gapi_anisotropic_inspect} - -After we have got the initial working version of our algorithm working -with G-API, we can use it to inspect and learn how G-API works. This -chapter covers two aspects: understanding the graph structure, and -memory profiling. - -## Understanding the graph structure {#gapi_anisotropic_inspect_graph} - -G-API stands for "Graph API", but did you mention any graphs in the -above example? It was one of the initial design goals -- G-API was -designed with expressions in mind to make adoption and porting process -more straightforward. People _usually_ don't think in terms of -_Nodes_ and _Edges_ when writing ordinary code, and so G-API, while -being a Graph API, doesn't force its users to do that. - -However, a graph is still built implicitly when a cv::GComputation -object is defined. It may be useful to inspect how the resulting graph -looks like to check if it is generated correctly and if it really -represents our algorithm. It is also useful to learn the structure of -the graph to see if it has any redundancies. - -G-API allows to dump generated graphs to `.dot` files which then -could be visualized with [Graphviz](https://www.graphviz.org/), a -popular open graph visualization software. - - - -In order to dump our graph to a `.dot` file, set `GRAPH_DUMP_PATH` to a -file name before running the application, e.g.: - - $ GRAPH_DUMP_PATH=segm.dot ./bin/example_tutorial_porting_anisotropic_image_segmentation_gapi - -Now this file can be visualized with a `dot` command like this: - - $ dot segm.dot -Tpng -o segm.png - -or viewed interactively with `xdot` (please refer to your -distribution/operating system documentation on how to install these -packages). - -![Anisotropic image segmentation graph](pics/segm.gif) - -The above diagram demonstrates a number of interesting aspects of -G-API's internal algorithm representation: -1. G-API underlying graph is a bipartite graph: it consists of - _Operation_ and _Data_ nodes such that a _Data_ node can only be - connected to an _Operation_ node, _Operation_ node can only be - connected to a _Data_ node, and nodes of a single kind are never - connected directly. -2. Graph is directed - every edge in the graph has a direction. -3. Graph "begins" and "ends" with a _Data_ kind of nodes. -4. A _Data_ node can have only a single writer and multiple readers. -5. An _Operation_ node may have multiple inputs, though every input - must have an unique _port number_ (among inputs). -6. An _Operation_ node may have multiple outputs, and every output - must have an unique _port number_ (among outputs). - -## Measuring memory footprint {#gapi_anisotropic_memory_ocv} - -Let's measure and compare memory footprint of the algorithm in its two -versions: G-API-based and OpenCV-based. At the moment, G-API version -is also OpenCV-based since it fallbacks to OpenCV functions inside. - -On GNU/Linux, application memory footprint can be profiled with -[Valgrind](http://valgrind.org/). On Debian/Ubuntu systems it can be -installed like this (assuming you have administrator privileges): - - $ sudo apt-get install valgrind massif-visualizer - -Once installed, we can collect memory profiles easily for our two -algorithm versions: - - $ valgrind --tool=massif --massif-out-file=ocv.out ./bin/example_tutorial_anisotropic_image_segmentation - ==6101== Massif, a heap profiler - ==6101== Copyright (C) 2003-2015, and GNU GPL'd, by Nicholas Nethercote - ==6101== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info - ==6101== Command: ./bin/example_tutorial_anisotropic_image_segmentation - ==6101== - ==6101== - $ valgrind --tool=massif --massif-out-file=gapi.out ./bin/example_tutorial_porting_anisotropic_image_segmentation_gapi - ==6117== Massif, a heap profiler - ==6117== Copyright (C) 2003-2015, and GNU GPL'd, by Nicholas Nethercote - ==6117== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info - ==6117== Command: ./bin/example_tutorial_porting_anisotropic_image_segmentation_gapi - ==6117== - ==6117== - -Once done, we can inspect the collected profiles with -[Massif Visualizer](https://github.com/KDE/massif-visualizer) -(installed in the above step). - -Below is the visualized memory profile of the original OpenCV version -of the algorithm: - -![Memory profile: original Anisotropic Image Segmentation sample](pics/massif_export_ocv.png) - -We see that memory is allocated as the application -executes, reaching its peak in the calcGST() function; then the -footprint drops as calcGST() completes its execution and all temporary -buffers are freed. Massif reports us peak memory consumption of 7.6 MiB. - -Now let's have a look on the profile of G-API version: - -![Memory profile: G-API port of Anisotropic Image Segmentation sample](pics/massif_export_gapi.png) - -Once G-API computation is created and its execution starts, G-API -allocates all required memory at once and then the memory profile -remains flat until the termination of the program. Massif reports us -peak memory consumption of 11.4 MiB. - -A reader may ask a right question at this point -- is G-API that bad? -What is the reason in using it than? - -Hopefully, it is not. The reason why we see here an increased memory -consumption is because the default naive OpenCV-based backend is used to -execute this graph. This backend serves mostly for quick prototyping -and debugging algorithms before offload/further optimization. - -This backend doesn't utilize any complex memory management strategies yet -since it is not its point at the moment. In the following chapter, -we'll learn about Fluid backend and see how the same G-API code can -run in a completely different model (and the footprint shrunk to a -number of kilobytes). - -# Backends and kernels {#gapi_anisotropic_backends} - -This chapter covers how a G-API computation can be executed in a -special way -- e.g. offloaded to another device, or scheduled with a -special intelligence. G-API is designed to make its graphs portable -- -it means that once a graph is defined in G-API terms, no changes -should be required in it if we want to run it on CPU or on GPU or on -both devices at once. [G-API High-level overview](@ref gapi_hld) and -[G-API Kernel API](@ref gapi_kernel_api) shed more light on technical -details which make it possible. In this chapter, we will utilize G-API -Fluid backend to make our graph cache-efficient on CPU. - -G-API defines _backend_ as the lower-level entity which knows how to -run kernels. Backends may have (and, in fact, do have) different -_Kernel APIs_ which are used to program and integrate kernels for that -backends. In this context, _kernel_ is an implementation of an -_operation_, which is defined on the top API level (see -G_TYPED_KERNEL() macro). - -Backend is a thing which is aware of device & platform specifics, and -which executes its kernels with keeping that specifics in mind. For -example, there may be [Halide](http://halide-lang.org/) backend which -allows to write (implement) G-API operations in Halide language and -then generate functional Halide code for portions of G-API graph which -map well there. - -## Running a graph with a Fluid backend {#gapi_anisotropic_fluid} - -OpenCV 4.0 is bundled with two G-API backends -- the default "OpenCV" -which we just used, and a special "Fluid" backend. - -Fluid backend reorganizes the execution to save memory and to achieve -near-perfect cache locality, implementing so-called "streaming" model -of execution. - -In order to start using Fluid kernels, we need first to include -appropriate header files (which are not included by default): - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp fluid_includes - -Once these headers are included, we can form up a new _kernel package_ -and specify it to G-API: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp kernel_pkg - -In G-API, kernels (or operation implementations) are objects. Kernels are -organized into collections, or _kernel packages_, represented by class -cv::GKernelPackage. The main purpose of a kernel package is to -capture which kernels we would like to use in our graph, and pass it -as a _graph compilation option_: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp kernel_pkg_use - -Traditional OpenCV is logically divided into modules, with every -module providing a set of functions. In G-API, there are also -"modules" which are represented as kernel packages provided by a -particular backend. In this example, we pass Fluid kernel packages to -G-API to utilize appropriate Fluid functions in our graph. - -Kernel packages are combinable -- in the above example, we take "Core" -and "ImgProc" Fluid kernel packages and combine it into a single -one. See documentation reference on cv::gapi::combine. - -If no kernel packages are specified in options, G-API is using -_default_ package which consists of default OpenCV implementations and -thus G-API graphs are executed via OpenCV functions by default. OpenCV -backend provides broader functional coverage than any other -backend. If a kernel package is specified, like in this example, then -it is being combined with the _default_. -It means that user-specified implementations will replace default implementations in case of -conflict. - - - - -## Troubleshooting and customization {#gapi_anisotropic_trouble} - -After the above modifications, (in OpenCV 4.0) the app should crash -with a message like this: - -``` -$ ./bin/example_tutorial_porting_anisotropic_image_segmentation_gapi_fluid -terminate called after throwing an instance of 'std::logic_error' - what(): .../modules/gapi/src/backends/fluid/gfluidimgproc.cpp:436: Assertion kernelSize.width == 3 && kernelSize.height == 3 in function run failed - -Aborted (core dumped) -``` - -Fluid backend has a number of limitations in OpenCV 4.0 (see this -[wiki page](https://github.com/opencv/opencv/wiki/Graph-API) for a -more up-to-date status). In particular, the Box filter used in this -sample supports only static 3x3 kernel size. - -We can overcome this problem easily by avoiding G-API using Fluid -version of Box filter kernel in this sample. It can be done by -removing the appropriate kernel from the kernel package we've just -created: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp kernel_hotfix - -Now this kernel package doesn't have _any_ implementation of Box -filter kernel interface (specified as a template parameter). As -described above, G-API will fall-back to OpenCV to run this kernel -now. The resulting code with this change now looks like: - -@snippet cpp/tutorial_code/gapi/porting_anisotropic_image_segmentation/porting_anisotropic_image_segmentation_gapi_fluid.cpp kernel_pkg_proper - -Let's examine the memory profile for this sample after we switched to -Fluid backend. Now it looks like this: - -![Memory profile: G-API/Fluid port of Anisotropic Image Segmentation sample](pics/massif_export_gapi_fluid.png) - -Now the tool reports 4.7MiB -- and we just changed a few lines in our -code, without modifying the graph itself! It is a ~2.4X improvement of -the previous G-API result, and ~1.6X improvement of the original OpenCV -version. - -Let's also examine how the internal representation of the graph now -looks like. Dumping the graph into `.dot` would result into a -visualization like this: - -![Anisotropic image segmentation graph with OpenCV & Fluid kernels](pics/segm_fluid.gif) - -This graph doesn't differ structurally from its previous version (in -terms of operations and data objects), though a changed layout (on the -left side of the dump) is easily noticeable. - -The visualization reflects how G-API deals with mixed graphs, also -called _heterogeneous_ graphs. The majority of operations in this -graph are implemented with Fluid backend, but Box filters are executed -by the OpenCV backend. One can easily see that the graph is partitioned -(with rectangles). G-API groups connected operations based on their -affinity, forming _subgraphs_ (or _islands_ in G-API terminology), and -our top-level graph becomes a composition of multiple smaller -subgraphs. Every backend determines how its subgraph (island) is -executed, so Fluid backend optimizes out memory where possible, and -six intermediate buffers accessed by OpenCV Box filters are allocated -fully and can't be optimized out. - - - - - -# Conclusion {#gapi_tutor_conclusion} - -This tutorial demonstrates what G-API is and what its key design -concepts are, how an algorithm can be ported to G-API, and -how to utilize graph model benefits after that. - -In OpenCV 4.0, G-API is still in its inception stage -- it is more a -foundation for all future work, though ready for use even now. - -Further, this tutorial will be extended with new chapters on custom -kernels programming, parallelism, and more. diff --git a/doc/tutorials/gapi/face_beautification/face_beautification.markdown b/doc/tutorials/gapi/face_beautification/face_beautification.markdown deleted file mode 100644 index 1ceb416c99..0000000000 --- a/doc/tutorials/gapi/face_beautification/face_beautification.markdown +++ /dev/null @@ -1,442 +0,0 @@ -# Implementing a face beautification algorithm with G-API {#tutorial_gapi_face_beautification} - -@prev_tutorial{tutorial_gapi_anisotropic_segmentation} - -[TOC] - -# Introduction {#gapi_fb_intro} - -In this tutorial you will learn: -* Basics of a sample face beautification algorithm; -* How to infer different networks inside a pipeline with G-API; -* How to run a G-API pipeline on a video stream. - -## Prerequisites {#gapi_fb_prerec} - -This sample requires: -- PC with GNU/Linux or Microsoft Windows (Apple macOS is supported but - was not tested); -- OpenCV 4.2 or later built with Intel® Distribution of [OpenVINO™ - Toolkit](https://docs.openvinotoolkit.org/) (building with [Intel® - TBB](https://www.threadingbuildingblocks.org/intel-tbb-tutorial) is - a plus); -- The following topologies from OpenVINO™ Toolkit [Open Model - Zoo](https://github.com/opencv/open_model_zoo): - - `face-detection-adas-0001`; - - `facial-landmarks-35-adas-0002`. - -## Face beautification algorithm {#gapi_fb_algorithm} - -We will implement a simple face beautification algorithm using a -combination of modern Deep Learning techniques and traditional -Computer Vision. The general idea behind the algorithm is to make -face skin smoother while preserving face features like eyes or a -mouth contrast. The algorithm identifies parts of the face using a DNN -inference, applies different filters to the parts found, and then -combines it into the final result using basic image arithmetics: - -\dot -strict digraph Pipeline { - node [shape=record fontname=Helvetica fontsize=10 style=filled color="#4c7aa4" fillcolor="#5b9bd5" fontcolor="white"]; - edge [color="#62a8e7"]; - ordering="out"; - splines=ortho; - rankdir=LR; - - input [label="Input"]; - fd [label="Face\ndetector"]; - bgMask [label="Generate\nBG mask"]; - unshMask [label="Unsharp\nmask"]; - bilFil [label="Bilateral\nfilter"]; - shMask [label="Generate\nsharp mask"]; - blMask [label="Generate\nblur mask"]; - mul_1 [label="*" fontsize=24 shape=circle labelloc=b]; - mul_2 [label="*" fontsize=24 shape=circle labelloc=b]; - mul_3 [label="*" fontsize=24 shape=circle labelloc=b]; - - subgraph cluster_0 { - style=dashed - fontsize=10 - ld [label="Landmarks\ndetector"]; - label="for each face" - } - - sum_1 [label="+" fontsize=24 shape=circle]; - out [label="Output"]; - - temp_1 [style=invis shape=point width=0]; - temp_2 [style=invis shape=point width=0]; - temp_3 [style=invis shape=point width=0]; - temp_4 [style=invis shape=point width=0]; - temp_5 [style=invis shape=point width=0]; - temp_6 [style=invis shape=point width=0]; - temp_7 [style=invis shape=point width=0]; - temp_8 [style=invis shape=point width=0]; - temp_9 [style=invis shape=point width=0]; - - input -> temp_1 [arrowhead=none] - temp_1 -> fd -> ld - ld -> temp_4 [arrowhead=none] - temp_4 -> bgMask - bgMask -> mul_1 -> sum_1 -> out - - temp_4 -> temp_5 -> temp_6 [arrowhead=none constraint=none] - ld -> temp_2 -> temp_3 [style=invis constraint=none] - - temp_1 -> {unshMask, bilFil} - fd -> unshMask [style=invis constraint=none] - unshMask -> bilFil [style=invis constraint=none] - - bgMask -> shMask [style=invis constraint=none] - shMask -> blMask [style=invis constraint=none] - mul_1 -> mul_2 [style=invis constraint=none] - temp_5 -> shMask -> mul_2 - temp_6 -> blMask -> mul_3 - - unshMask -> temp_2 -> temp_5 [style=invis] - bilFil -> temp_3 -> temp_6 [style=invis] - - mul_2 -> temp_7 [arrowhead=none] - mul_3 -> temp_8 [arrowhead=none] - - temp_8 -> temp_7 [arrowhead=none constraint=none] - temp_7 -> sum_1 [constraint=none] - - unshMask -> mul_2 [constraint=none] - bilFil -> mul_3 [constraint=none] - temp_1 -> mul_1 [constraint=none] -} -\enddot - -Briefly the algorithm is described as follows: -- Input image \f$I\f$ is passed to unsharp mask and bilateral filters - (\f$U\f$ and \f$L\f$ respectively); -- Input image \f$I\f$ is passed to an SSD-based face detector; -- SSD result (a \f$[1 \times 1 \times 200 \times 7]\f$ blob) is parsed - and converted to an array of faces; -- Every face is passed to a landmarks detector; -- Based on landmarks found for every face, three image masks are - generated: - - A background mask \f$b\f$ -- indicating which areas from the - original image to keep as-is; - - A face part mask \f$p\f$ -- identifying regions to preserve - (sharpen). - - A face skin mask \f$s\f$ -- identifying regions to blur; -- The final result \f$O\f$ is a composition of features above - calculated as \f$O = b*I + p*U + s*L\f$. - -Generating face element masks based on a limited set of features (just -35 per face, including all its parts) is not very trivial and is -described in the sections below. - -# Constructing a G-API pipeline {#gapi_fb_pipeline} - -## Declaring Deep Learning topologies {#gapi_fb_decl_nets} - -This sample is using two DNN detectors. Every network takes one input -and produces one output. In G-API, networks are defined with macro -G_API_NET(): - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp net_decl - -To get more information, see -[Declaring Deep Learning topologies](@ref gapi_ifd_declaring_nets) -described in the "Face Analytics pipeline" tutorial. - -## Describing the processing graph {#gapi_fb_ppline} - -The code below generates a graph for the algorithm above: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp ppl - -The resulting graph is a mixture of G-API's standard operations, -user-defined operations (namespace `custom::`), and DNN inference. -The generic function `cv::gapi::infer<>()` allows to trigger inference -within the pipeline; networks to infer are specified as template -parameters. The sample code is using two versions of `cv::gapi::infer<>()`: -- A frame-oriented one is used to detect faces on the input frame. -- An ROI-list oriented one is used to run landmarks inference on a - list of faces -- this version produces an array of landmarks per - every face. - -More on this in "Face Analytics pipeline" -([Building a GComputation](@ref gapi_ifd_gcomputation) section). - -## Unsharp mask in G-API {#gapi_fb_unsh} - -The unsharp mask \f$U\f$ for image \f$I\f$ is defined as: - -\f[U = I - s * L(M(I)),\f] - -where \f$M()\f$ is a median filter, \f$L()\f$ is the Laplace operator, -and \f$s\f$ is a strength coefficient. While G-API doesn't provide -this function out-of-the-box, it is expressed naturally with the -existing G-API operations: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp unsh - -Note that the code snipped above is a regular C++ function defined -with G-API types. Users can write functions like this to simplify -graph construction; when called, this function just puts the relevant -nodes to the pipeline it is used in. - -# Custom operations {#gapi_fb_proc} - -The face beautification graph is using custom operations -extensively. This chapter focuses on the most interesting kernels, -refer to [G-API Kernel API](@ref gapi_kernel_api) for general -information on defining operations and implementing kernels in G-API. - -## Face detector post-processing {#gapi_fb_face_detect} - -A face detector output is converted to an array of faces with the -following kernel: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp vec_ROI -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp fd_pp - -## Facial landmarks post-processing {#gapi_fb_landm_detect} - -The algorithm infers locations of face elements (like the eyes, the mouth -and the head contour itself) using a generic facial landmarks detector -(details) -from OpenVINO™ Open Model Zoo. However, the detected landmarks as-is are not -enough to generate masks --- this operation requires regions of interest on -the face represented by closed contours, so some interpolation is applied to -get them. This landmarks -processing and interpolation is performed by the following kernel: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp ld_pp_cnts - -The kernel takes two arrays of denormalized landmarks coordinates and -returns an array of elements' closed contours and an array of faces' -closed contours; in other words, outputs are, the first, an array of -contours of image areas to be sharpened and, the second, another one -to be smoothed. - -Here and below `Contour` is a vector of points. - -### Getting an eye contour {#gapi_fb_ld_eye} - -Eye contours are estimated with the following function: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp ld_pp_incl -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp ld_pp_eye - -Briefly, this function restores the bottom side of an eye by a -half-ellipse based on two points in left and right eye -corners. In fact, `cv::ellipse2Poly()` is used to approximate the eye region, and -the function only defines ellipse parameters based on just two points: -- The ellipse center and the \f$X\f$ half-axis calculated by two eye Points; -- The \f$Y\f$ half-axis calculated according to the assumption that an average -eye width is \f$1/3\f$ of its length; -- The start and the end angles which are 0 and 180 (refer to - `cv::ellipse()` documentation); -- The angle delta: how much points to produce in the contour; -- The inclination angle of the axes. - -The use of the `atan2()` instead of just `atan()` in function -`custom::getLineInclinationAngleDegrees()` is essential as it allows to -return a negative value depending on the `x` and the `y` signs so we -can get the right angle even in case of upside-down face arrangement -(if we put the points in the right order, of course). - -### Getting a forehead contour {#gapi_fb_ld_fhd} - -The function approximates the forehead contour: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp ld_pp_fhd - -As we have only jaw points in our detected landmarks, we have to get a -half-ellipse based on three points of a jaw: the leftmost, the -rightmost and the lowest one. The jaw width is assumed to be equal to the -forehead width and the latter is calculated using the left and the -right points. Speaking of the \f$Y\f$ axis, we have no points to get -it directly, and instead assume that the forehead height is about \f$2/3\f$ -of the jaw height, which can be figured out from the face center (the -middle between the left and right points) and the lowest jaw point. - -## Drawing masks {#gapi_fb_masks_drw} - -When we have all the contours needed, we are able to draw masks: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp msk_ppline - -The steps to get the masks are: -* the "sharp" mask calculation: - * fill the contours that should be sharpened; - * blur that to get the "sharp" mask (`mskSharpG`); -* the "bilateral" mask calculation: - * fill all the face contours fully; - * blur that; - * subtract areas which intersect with the "sharp" mask --- and get the - "bilateral" mask (`mskBlurFinal`); -* the background mask calculation: - * add two previous masks - * set all non-zero pixels of the result as 255 (by `cv::gapi::threshold()`) - * revert the output (by `cv::gapi::bitwise_not`) to get the background - mask (`mskNoFaces`). - -# Configuring and running the pipeline {#gapi_fb_comp_args} - -Once the graph is fully expressed, we can finally compile it and run -on real data. G-API graph compilation is the stage where the G-API -framework actually understands which kernels and networks to use. This -configuration happens via G-API compilation arguments. - -## DNN parameters {#gapi_fb_comp_args_net} - -This sample is using OpenVINO™ Toolkit Inference Engine backend for DL -inference, which is configured the following way: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp net_param - -Every `cv::gapi::ie::Params<>` object is related to the network -specified in its template argument. We should pass there the network -type we have defined in `G_API_NET()` in the early beginning of the -tutorial. - -Network parameters are then wrapped in `cv::gapi::NetworkPackage`: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp netw - -More details in "Face Analytics Pipeline" -([Configuring the pipeline](@ref gapi_ifd_configuration) section). - -## Kernel packages {#gapi_fb_comp_args_kernels} - -In this example we use a lot of custom kernels, in addition to that we -use Fluid backend to optimize out memory for G-API's standard kernels -where applicable. The resulting kernel package is formed like this: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp kern_pass_1 - -## Compiling the streaming pipeline {#gapi_fb_compiling} - -G-API optimizes execution for video streams when compiled in the -"Streaming" mode. - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp str_comp - -More on this in "Face Analytics Pipeline" -([Configuring the pipeline](@ref gapi_ifd_configuration) section). - -## Running the streaming pipeline {#gapi_fb_running} - -In order to run the G-API streaming pipeline, all we need is to -specify the input video source, call -`cv::GStreamingCompiled::start()`, and then fetch the pipeline -processing results: - -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp str_src -@snippet cpp/tutorial_code/gapi/face_beautification/face_beautification.cpp str_loop - -Once results are ready and can be pulled from the pipeline we display -it on the screen and handle GUI events. - -See [Running the pipeline](@ref gapi_ifd_running) section -in the "Face Analytics Pipeline" tutorial for more details. - -# Conclusion {#gapi_fb_cncl} - -The tutorial has two goals: to show the use of brand new features of -G-API introduced in OpenCV 4.2, and give a basic understanding on a -sample face beautification algorithm. - -The result of the algorithm application: - -![Face Beautification example](pics/example.jpg) - -On the test machine (Intel® Core™ i7-8700) the G-API-optimized video -pipeline outperforms its serial (non-pipelined) version by a factor of -**2.7** -- meaning that for such a non-trivial graph, the proper -pipelining can bring almost 3x increase in performance. - - diff --git a/doc/tutorials/gapi/face_beautification/pics/example.jpg b/doc/tutorials/gapi/face_beautification/pics/example.jpg deleted file mode 100644 index 99a538f78c..0000000000 Binary files a/doc/tutorials/gapi/face_beautification/pics/example.jpg and /dev/null differ diff --git a/doc/tutorials/gapi/interactive_face_detection/interactive_face_detection.markdown b/doc/tutorials/gapi/interactive_face_detection/interactive_face_detection.markdown deleted file mode 100644 index 27916b4176..0000000000 --- a/doc/tutorials/gapi/interactive_face_detection/interactive_face_detection.markdown +++ /dev/null @@ -1,355 +0,0 @@ -# Face analytics pipeline with G-API {#tutorial_gapi_interactive_face_detection} - -@next_tutorial{tutorial_gapi_anisotropic_segmentation} - -[TOC] - -# Overview {#gapi_ifd_intro} - -In this tutorial you will learn: -* How to integrate Deep Learning inference in a G-API graph; -* How to run a G-API graph on a video stream and obtain data from it. - -# Prerequisites {#gapi_ifd_prereq} - -This sample requires: -- PC with GNU/Linux or Microsoft Windows (Apple macOS is supported but - was not tested); -- OpenCV 4.2 or later built with Intel® Distribution of [OpenVINO™ - Toolkit](https://docs.openvinotoolkit.org/) (building with [Intel® - TBB](https://www.threadingbuildingblocks.org/intel-tbb-tutorial) is - a plus); -- The following topologies from OpenVINO™ Toolkit [Open Model - Zoo](https://github.com/opencv/open_model_zoo): - - `face-detection-adas-0001`; - - `age-gender-recognition-retail-0013`; - - `emotions-recognition-retail-0003`. - -# Introduction: why G-API {#gapi_ifd_why} - -Many computer vision algorithms run on a video stream rather than on -individual images. Stream processing usually consists of multiple -steps -- like decode, preprocessing, detection, tracking, -classification (on detected objects), and visualization -- forming a -*video processing pipeline*. Moreover, many these steps of such -pipeline can run in parallel -- modern platforms have different -hardware blocks on the same chip like decoders and GPUs, and extra -accelerators can be plugged in as extensions, like Intel® Movidius™ -Neural Compute Stick for deep learning offload. - -Given all this manifold of options and a variety in video analytics -algorithms, managing such pipelines effectively quickly becomes a -problem. For sure it can be done manually, but this approach doesn't -scale: if a change is required in the algorithm (e.g. a new pipeline -step is added), or if it is ported on a new platform with different -capabilities, the whole pipeline needs to be re-optimized. - -Starting with version 4.2, OpenCV offers a solution to this -problem. OpenCV G-API now can manage Deep Learning inference (a -cornerstone of any modern analytics pipeline) with a traditional -Computer Vision as well as video capturing/decoding, all in a single -pipeline. G-API takes care of pipelining itself -- so if the algorithm -or platform changes, the execution model adapts to it automatically. - -# Pipeline overview {#gapi_ifd_overview} - -Our sample application is based on ["Interactive Face Detection"] demo -from OpenVINO™ Toolkit Open Model Zoo. A simplified pipeline consists -of the following steps: -1. Image acquisition and decode; -2. Detection with preprocessing; -3. Classification with preprocessing for every detected object with - two networks; -4. Visualization. - -\dot -digraph pipeline { - node [shape=record fontname=Helvetica fontsize=10 style=filled color="#4c7aa4" fillcolor="#5b9bd5" fontcolor="white"]; - edge [color="#62a8e7"]; - splines=ortho; - - rankdir = LR; - subgraph cluster_0 { - color=invis; - capture [label="Capture\nDecode"]; - resize [label="Resize\nConvert"]; - detect [label="Detect faces"]; - capture -> resize -> detect - } - - subgraph cluster_1 { - graph[style=dashed]; - - subgraph cluster_2 { - color=invis; - temp_4 [style=invis shape=point width=0]; - postproc_1 [label="Crop\nResize\nConvert"]; - age_gender [label="Classify\nAge/gender"]; - postproc_1 -> age_gender [constraint=true] - temp_4 -> postproc_1 [constraint=none] - } - - subgraph cluster_3 { - color=invis; - postproc_2 [label="Crop\nResize\nConvert"]; - emo [label="Classify\nEmotions"]; - postproc_2 -> emo [constraint=true] - } - label="(for each face)"; - } - - temp_1 [style=invis shape=point width=0]; - temp_2 [style=invis shape=point width=0]; - detect -> temp_1 [arrowhead=none] - temp_1 -> postproc_1 - - capture -> {temp_4, temp_2} [arrowhead=none constraint=false] - temp_2 -> postproc_2 - - temp_1 -> temp_2 [arrowhead=none constraint=false] - - temp_3 [style=invis shape=point width=0]; - show [label="Visualize\nDisplay"]; - - {age_gender, emo} -> temp_3 [arrowhead=none] - temp_3 -> show -} -\enddot - -# Constructing a pipeline {#gapi_ifd_constructing} - -Constructing a G-API graph for a video streaming case does not differ -much from a [regular usage](@ref gapi_example) of G-API -- it is still -about defining graph *data* (with cv::GMat, cv::GScalar, and -cv::GArray) and *operations* over it. Inference also becomes an -operation in the graph, but is defined in a little bit different way. - -## Declaring Deep Learning topologies {#gapi_ifd_declaring_nets} - -In contrast with traditional CV functions (see [core] and [imgproc]) -where G-API declares distinct operations for every function, inference -in G-API is a single generic operation cv::gapi::infer<>. As usual, it -is just an interface and it can be implemented in a number of ways under -the hood. In OpenCV 4.2, only OpenVINO™ Inference Engine-based backend -is available, and OpenCV's own DNN module-based backend is to come. - -cv::gapi::infer<> is _parametrized_ by the details of a topology we are -going to execute. Like operations, topologies in G-API are strongly -typed and are defined with a special macro G_API_NET(): - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp G_API_NET - -Similar to how operations are defined with G_API_OP(), network -description requires three parameters: -1. A type name. Every defined topology is declared as a distinct C++ - type which is used further in the program -- see below; -2. A `std::function<>`-like API signature. G-API traits networks as - regular "functions" which take and return data. Here network - `Faces` (a detector) takes a cv::GMat and returns a cv::GMat, while - network `AgeGender` is known to provide two outputs (age and gender - blobs, respectively) -- so its has a `std::tuple<>` as a return - type. -3. A topology name -- can be any non-empty string, G-API is using - these names to distinguish networks inside. Names should be unique - in the scope of a single graph. - -## Building a GComputation {#gapi_ifd_gcomputation} - -Now the above pipeline is expressed in G-API like this: - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp GComputation - -Every pipeline starts with declaring empty data objects -- which act -as inputs to the pipeline. Then we call a generic cv::gapi::infer<> -specialized to `Faces` detection network. cv::gapi::infer<> inherits its -signature from its template parameter -- and in this case it expects -one input cv::GMat and produces one output cv::GMat. - -In this sample we use a pre-trained SSD-based network and its output -needs to be parsed to an array of detections (object regions of -interest, ROIs). It is done by a custom operation `custom::PostProc`, -which returns an array of rectangles (of type `cv::GArray`) -back to the pipeline. This operation also filters out results by a -confidence threshold -- and these details are hidden in the kernel -itself. Still, at the moment of graph construction we operate with -interfaces only and don't need actual kernels to express the pipeline --- so the implementation of this post-processing will be listed later. - -After detection result output is parsed to an array of objects, we can run -classification on any of those. G-API doesn't support syntax for -in-graph loops like `for_each()` yet, but instead cv::gapi::infer<> -comes with a special list-oriented overload. - -User can call cv::gapi::infer<> with a cv::GArray as the first -argument, so then G-API assumes it needs to run the associated network -on every rectangle from the given list of the given frame (second -argument). Result of such operation is also a list -- a cv::GArray of -cv::GMat. - -Since `AgeGender` network itself produces two outputs, it's output -type for a list-based version of cv::gapi::infer is a tuple of -arrays. We use `std::tie()` to decompose this input into two distinct -objects. - -`Emotions` network produces a single output so its list-based -inference's return type is `cv::GArray`. - -# Configuring the pipeline {#gapi_ifd_configuration} - -G-API strictly separates construction from configuration -- with the -idea to keep algorithm code itself platform-neutral. In the above -listings we only declared our operations and expressed the overall -data flow, but didn't even mention that we use OpenVINO™. We only -described *what* we do, but not *how* we do it. Keeping these two -aspects clearly separated is the design goal for G-API. - -Platform-specific details arise when the pipeline is *compiled* -- -i.e. is turned from a declarative to an executable form. The way *how* -to run stuff is specified via compilation arguments, and new -inference/streaming features are no exception from this rule. - -G-API is built on backends which implement interfaces (see -[Architecture] and [Kernels] for details) -- thus cv::gapi::infer<> is -a function which can be implemented by different backends. In OpenCV -4.2, only OpenVINO™ Inference Engine backend for inference is -available. Every inference backend in G-API has to provide a special -parameterizable structure to express *backend-specific* neural network -parameters -- and in this case, it is cv::gapi::ie::Params: - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp Param_Cfg - -Here we define three parameter objects: `det_net`, `age_net`, and -`emo_net`. Every object is a cv::gapi::ie::Params structure -parametrization for each particular network we use. On a compilation -stage, G-API automatically matches network parameters with their -cv::gapi::infer<> calls in graph using this information. - -Regardless of the topology, every parameter structure is constructed -with three string arguments -- specific to the OpenVINO™ Inference -Engine: -1. Path to the topology's intermediate representation (.xml file); -2. Path to the topology's model weights (.bin file); -3. Device where to run -- "CPU", "GPU", and others -- based on your -OpenVINO™ Toolkit installation. -These arguments are taken from the command-line parser. - -Once networks are defined and custom kernels are implemented, the -pipeline is compiled for streaming: - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp Compile - -cv::GComputation::compileStreaming() triggers a special video-oriented -form of graph compilation where G-API is trying to optimize -throughput. Result of this compilation is an object of special type -cv::GStreamingCompiled -- in contrast to a traditional callable -cv::GCompiled, these objects are closer to media players in their -semantics. - -@note There is no need to pass metadata arguments describing the -format of the input video stream in -cv::GComputation::compileStreaming() -- G-API figures automatically -what are the formats of the input vector and adjusts the pipeline to -these formats on-the-fly. User still can pass metadata there as with -regular cv::GComputation::compile() in order to fix the pipeline to -the specific input format. - -# Running the pipeline {#gapi_ifd_running} - -Pipelining optimization is based on processing multiple input video -frames simultaneously, running different steps of the pipeline in -parallel. This is why it works best when the framework takes full -control over the video stream. - -The idea behind streaming API is that user specifies an *input source* -to the pipeline and then G-API manages its execution automatically -until the source ends or user interrupts the execution. G-API pulls -new image data from the source and passes it to the pipeline for -processing. - -Streaming sources are represented by the interface -cv::gapi::wip::IStreamSource. Objects implementing this interface may -be passed to `GStreamingCompiled` as regular inputs via `cv::gin()` -helper function. In OpenCV 4.2, only one streaming source is allowed -per pipeline -- this requirement will be relaxed in the future. - -OpenCV comes with a great class cv::VideoCapture and by default G-API -ships with a stream source class based on it -- -cv::gapi::wip::GCaptureSource. Users can implement their own -streaming sources e.g. using [VAAPI] or other Media or Networking -APIs. - -Sample application specifies the input source as follows: - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp Source - -Please note that a GComputation may still have multiple inputs like -cv::GMat, cv::GScalar, or cv::GArray objects. User can pass their -respective host-side types (cv::Mat, cv::Scalar, std::vector<>) in the -input vector as well, but in Streaming mode these objects will create -"endless" constant streams. Mixing a real video source stream and a -const data stream is allowed. - -Running a pipeline is easy -- just call -cv::GStreamingCompiled::start() and fetch your data with blocking -cv::GStreamingCompiled::pull() or non-blocking -cv::GStreamingCompiled::try_pull(); repeat until the stream ends: - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp Run - -The above code may look complex but in fact it handles two modes -- -with and without graphical user interface (GUI): -- When a sample is running in a "headless" mode (`--pure` option is - set), this code simply pulls data from the pipeline with the - blocking `pull()` until it ends. This is the most performant mode of - execution. -- When results are also displayed on the screen, the Window System - needs to take some time to refresh the window contents and handle - GUI events. In this case, the demo pulls data with a non-blocking - `try_pull()` until there is no more data available (but it does not - mark end of the stream -- just means new data is not ready yet), and - only then displays the latest obtained result and refreshes the - screen. Reducing the time spent in GUI with this trick increases the - overall performance a little bit. - -# Comparison with serial mode {#gapi_ifd_comparison} - -The sample can also run in a serial mode for a reference and -benchmarking purposes. In this case, a regular -cv::GComputation::compile() is used and a regular single-frame -cv::GCompiled object is produced; the pipelining optimization is not -applied within G-API; it is the user responsibility to acquire image -frames from cv::VideoCapture object and pass those to G-API. - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp Run_Serial - -On a test machine (Intel® Core™ i5-6600), with OpenCV built with -[Intel® TBB] -support, detector network assigned to CPU, and classifiers to iGPU, -the pipelined sample outperformes the serial one by the factor of -1.36x (thus adding +36% in overall throughput). - -# Conclusion {#gapi_ifd_conclusion} - -G-API introduces a technological way to build and optimize hybrid -pipelines. Switching to a new execution model does not require changes -in the algorithm code expressed with G-API -- only the way how graph -is triggered differs. - -# Listing: post-processing kernel {#gapi_ifd_pp} - -G-API gives an easy way to plug custom code into the pipeline even if -it is running in a streaming mode and processing tensor -data. Inference results are represented by multi-dimensional cv::Mat -objects so accessing those is as easy as with a regular DNN module. - -The OpenCV-based SSD post-processing kernel is defined and implemented in this -sample as follows: - -@snippet cpp/tutorial_code/gapi/age_gender_emotion_recognition/age_gender_emotion_recognition.cpp Postproc - -["Interactive Face Detection"]: https://github.com/opencv/open_model_zoo/tree/master/demos/interactive_face_detection_demo -[core]: @ref gapi_core -[imgproc]: @ref gapi_imgproc -[Architecture]: @ref gapi_hld -[Kernels]: @ref gapi_kernel_api -[VAAPI]: https://01.org/vaapi diff --git a/doc/tutorials/gapi/oak_devices/oak_devices.markdown b/doc/tutorials/gapi/oak_devices/oak_devices.markdown deleted file mode 100644 index 6046cdef25..0000000000 --- a/doc/tutorials/gapi/oak_devices/oak_devices.markdown +++ /dev/null @@ -1,26 +0,0 @@ -Using DepthAI Hardware / OAK depth sensors {#tutorial_gapi_oak_devices} -======================================================================= - -@tableofcontents - -@prev_tutorial{tutorial_gapi_face_beautification} - -![Oak-D and Oak-D-Light cameras](pics/oak.jpg) - -Depth sensors compatible with Luxonis DepthAI library are supported through OpenCV Graph API (or G-API) module. RGB image and some other formats of output can be retrieved by using familiar interface of G-API module. - -In order to use DepthAI sensor with OpenCV you should do the following preliminary steps: --# Install Luxonis DepthAI library [depthai-core](https://github.com/luxonis/depthai-core). - --# Configure OpenCV with DepthAI library support by setting `WITH_OAK` flag in CMake. If DepthAI library is found in install folders OpenCV will be built with depthai-core (see a status `WITH_OAK` in CMake log). - --# Build OpenCV. - -Source code ------------ - -You can find source code how to process heterogeneous graphs in the `modules/gapi/samples/oak_basic_infer.cpp` of the OpenCV source code library. - -@add_toggle_cpp - @include modules/gapi/samples/oak_basic_infer.cpp -@end_toggle diff --git a/doc/tutorials/gapi/oak_devices/pics/oak.jpg b/doc/tutorials/gapi/oak_devices/pics/oak.jpg deleted file mode 100644 index 9ad30ce1e9..0000000000 Binary files a/doc/tutorials/gapi/oak_devices/pics/oak.jpg and /dev/null differ diff --git a/doc/tutorials/gapi/table_of_content_gapi.markdown b/doc/tutorials/gapi/table_of_content_gapi.markdown deleted file mode 100644 index 1b33172b9e..0000000000 --- a/doc/tutorials/gapi/table_of_content_gapi.markdown +++ /dev/null @@ -1,53 +0,0 @@ -# Graph API (gapi module) {#tutorial_table_of_content_gapi} - -In this section you will learn about graph-based image processing and -how G-API module can be used for that. - -- @subpage tutorial_gapi_interactive_face_detection - - *Languages:* C++ - - *Compatibility:* \> OpenCV 4.2 - - *Author:* Dmitry Matveev - - This tutorial illustrates how to build a hybrid video processing - pipeline with G-API where Deep Learning and image processing are - combined effectively to maximize the overall throughput. This - sample requires Intel® distribution of OpenVINO™ Toolkit version - 2019R2 or later. - -- @subpage tutorial_gapi_anisotropic_segmentation - - *Languages:* C++ - - *Compatibility:* \> OpenCV 4.0 - - *Author:* Dmitry Matveev - - This is an end-to-end tutorial where an existing sample algorithm - is ported on G-API, covering the basic intuition behind this - transition process, and examining benefits which a graph model - brings there. - -- @subpage tutorial_gapi_face_beautification - - *Languages:* C++ - - *Compatibility:* \> OpenCV 4.2 - - *Author:* Orest Chura - - In this tutorial we build a complex hybrid Computer Vision/Deep - Learning video processing pipeline with G-API. - - -- @subpage tutorial_gapi_oak_devices - - *Languages:* C++ - - *Compatibility:* \> OpenCV 4.6 - - *Author:* Alessandro de Oliveira Faria (A.K.A. CABELO) - - In this tutorial we showed how to use the Luxonis DepthAI library with G-API. diff --git a/doc/tutorials/introduction/env_reference/env_reference.markdown b/doc/tutorials/introduction/env_reference/env_reference.markdown index ee725f8542..c902a95c46 100644 --- a/doc/tutorials/introduction/env_reference/env_reference.markdown +++ b/doc/tutorials/introduction/env_reference/env_reference.markdown @@ -301,26 +301,6 @@ Some external dependencies can be detached into a dynamic library, which will be | OPENCV_TEST_CAMERA_%d_FPS | num | | fps to set for N-th camera (0-based index) (waitAny_V4L test) | -## gapi -| name | type | default | description | -|------|------|---------|-------------| -| ⭐ GRAPH_DUMP_PATH | file path | | dump graph (dot format) | -| PIPELINE_MODELS_PATH | dir path | | pipeline_modeling_tool sample application uses this var | -| OPENCV_GAPI_INFERENCE_ENGINE_CORE_LIFETIME_WORKAROUND | bool | true (Windows, Apple), false (others) | similar to OPENCV_DNN_INFERENCE_ENGINE_CORE_LIFETIME_WORKAROUND | - -### gapi tests/samples -| name | type | default | description | -|------|------|---------|-------------| -| PLAIDML_DEVICE | string | | specific to PlaidML backend test | -| PLAIDML_TARGET | string | | specific to PlaidML backend test | -| OPENCV_GAPI_ONNX_MODEL_PATH | dir path | | search location for ONNX models test | -| OPENCV_TEST_FREETYPE_FONT_PATH | file path | | location of TrueType font for one of tests | - -### Links: -* https://github.com/opencv/opencv/wiki/Using-G-API-with-OpenVINO-Toolkit -* https://github.com/opencv/opencv/wiki/Using-G-API-with-MS-ONNX-Runtime - - ## highgui | name | type | default | description | diff --git a/doc/tutorials/tutorials.markdown b/doc/tutorials/tutorials.markdown index ffa5d5d3c6..48f1292971 100644 --- a/doc/tutorials/tutorials.markdown +++ b/doc/tutorials/tutorials.markdown @@ -9,7 +9,6 @@ OpenCV Tutorials {#tutorial_root} - @subpage tutorial_table_of_content_objdetect - INSERT OBJDETECT MODULE INFO - @subpage tutorial_table_of_content_features - feature detectors, descriptors and matching framework - @subpage tutorial_table_of_content_dnn - infer neural networks using built-in _dnn_ module -- @subpage tutorial_table_of_content_gapi - graph-based approach to computer vision algorithms building - @subpage tutorial_table_of_content_other - other modules (stitching, video, photo) - @subpage tutorial_table_of_content_ios - running OpenCV on an iDevice - @subpage tutorial_table_of_content_3d - 3d objects processing and visualisation diff --git a/modules/gapi/CMakeLists.txt b/modules/gapi/CMakeLists.txt deleted file mode 100644 index 6757c853bd..0000000000 --- a/modules/gapi/CMakeLists.txt +++ /dev/null @@ -1,440 +0,0 @@ -# FIXME: Rework standalone build in more generic maner -# (Restructure directories, add common pass, etc) -if(NOT DEFINED OPENCV_INITIAL_PASS) - cmake_minimum_required(VERSION 3.13) - project(gapi_standalone) - include("cmake/standalone.cmake") - return() -endif() - -if(NOT TARGET ade) - # can't build G-API because of the above reasons - ocv_module_disable(gapi) - return() -endif() - -if(TARGET ocv.3rdparty.openvino) - # TODO: remove OPENCV_GAPI_INF_ENGINE option - set(initial_value ON) - if(DEFINED OPENCV_GAPI_INF_ENGINE) - set(initial_value ${OPENCV_GAPI_INF_ENGINE}) - message(WARNING "OPENCV_GAPI_INF_ENGINE option is deprecated. Use OPENCV_GAPI_WITH_OPENVINO option instead.") - endif() - ocv_option(OPENCV_GAPI_WITH_OPENVINO "G-API: Enable OpenVINO Toolkit support" ${initial_value}) -endif() - -set(the_description "OpenCV G-API Core Module") - -ocv_add_module(gapi - REQUIRED - opencv_imgproc - OPTIONAL - opencv_video opencv_stereo - WRAP - python -) - -if(MSVC) - if(MSVC_VERSION LESS 1910) - # Disable obsolete warning C4503 popping up on MSVC << 15 2017 - # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4503?view=vs-2019 - # and IE deprecated code warning C4996 - ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4503 /wd4996) - endif() - if((MSVC_VERSION LESS 1920) OR ARM OR AARCH64) # MSVS 2015/2017 on x86 and ARM - ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4702) # 'unreachable code' - endif() -endif() - -file(GLOB gapi_ext_hdrs - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.h" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/cpu/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/fluid/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/gpu/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/infer/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/oak/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/ocl/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/own/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/plaidml/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/python/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/render/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/s11n/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/gstreamer/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/onevpl/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/plaidml/*.hpp" - "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/util/*.hpp" - ) - -set(gapi_srcs - # Front-end part - src/api/grunarg.cpp - src/api/gorigin.cpp - src/api/gmat.cpp - src/api/garray.cpp - src/api/gopaque.cpp - src/api/gscalar.cpp - src/api/gframe.cpp - src/api/gkernel.cpp - src/api/gbackend.cpp - src/api/gcommon.cpp - src/api/gproto.cpp - src/api/gnode.cpp - src/api/gcall.cpp - src/api/gcomputation.cpp - src/api/operators.cpp - src/api/kernels_core.cpp - src/api/kernels_imgproc.cpp - src/api/kernels_video.cpp - src/api/kernels_nnparsers.cpp - src/api/kernels_ot.cpp - src/api/kernels_streaming.cpp - src/api/kernels_stereo.cpp - src/api/render.cpp - src/api/render_ocv.cpp - src/api/ginfer.cpp - src/api/media.cpp - src/api/rmat.cpp - - # Compiler part - src/compiler/gmodel.cpp - src/compiler/gmodelbuilder.cpp - src/compiler/gislandmodel.cpp - src/compiler/gcompiler.cpp - src/compiler/gcompiled.cpp - src/compiler/gstreaming.cpp - src/compiler/passes/helpers.cpp - src/compiler/passes/dump_dot.cpp - src/compiler/passes/islands.cpp - src/compiler/passes/meta.cpp - src/compiler/passes/kernels.cpp - src/compiler/passes/exec.cpp - src/compiler/passes/transformations.cpp - src/compiler/passes/pattern_matching.cpp - src/compiler/passes/perform_substitution.cpp - src/compiler/passes/streaming.cpp - src/compiler/passes/intrin.cpp - - # Executor - src/executor/gabstractexecutor.cpp - src/executor/gabstractstreamingexecutor.cpp - src/executor/gexecutor.cpp - src/executor/gtbbexecutor.cpp - src/executor/gthreadedexecutor.cpp - src/executor/gstreamingexecutor.cpp - src/executor/gasync.cpp - src/executor/thread_pool.cpp - - # CPU Backend (currently built-in) - src/backends/cpu/gcpubackend.cpp - src/backends/cpu/gcpukernel.cpp - src/backends/cpu/gcpuimgproc.cpp - src/backends/cpu/gcpustereo.cpp - src/backends/cpu/gcpuvideo.cpp - src/backends/cpu/gcpucore.cpp - src/backends/cpu/gcpuot.cpp - src/backends/cpu/gnnparsers.cpp - - # Fluid Backend (also built-in, FIXME:move away) - src/backends/fluid/gfluidbuffer.cpp - src/backends/fluid/gfluidbackend.cpp - src/backends/fluid/gfluidimgproc.cpp - src/backends/fluid/gfluidimgproc_func.dispatch.cpp - src/backends/fluid/gfluidcore.cpp - src/backends/fluid/gfluidcore_func.dispatch.cpp - - # OAK Backend (optional) - src/backends/oak/goak.cpp - src/backends/oak/goakbackend.cpp - src/backends/oak/goak_memory_adapters.cpp - - # OCL Backend (currently built-in) - src/backends/ocl/goclbackend.cpp - src/backends/ocl/goclkernel.cpp - src/backends/ocl/goclimgproc.cpp - src/backends/ocl/goclcore.cpp - - # IE Backend. FIXME: should be included by CMake - # if and only if IE support is enabled - src/backends/ie/giebackend.cpp - src/backends/ie/giebackend/giewrapper.cpp - - # OV Backend. FIXME: should be included by CMake - # if and only if OV support is enabled - src/backends/ov/govbackend.cpp - - # ONNX backend - src/backends/onnx/gonnxbackend.cpp - src/backends/onnx/dml_ep.cpp - src/backends/onnx/coreml_ep.cpp - - # Render backend - src/backends/render/grenderocv.cpp - src/backends/render/ft_render.cpp - - # PlaidML Backend - src/backends/plaidml/gplaidmlcore.cpp - src/backends/plaidml/gplaidmlbackend.cpp - - # Common backend code - src/backends/common/gmetabackend.cpp - src/backends/common/gcompoundbackend.cpp - src/backends/common/gcompoundkernel.cpp - - # Serialization API and routines - src/api/s11n.cpp - src/backends/common/serialization.cpp - - # Streaming backend - src/backends/streaming/gstreamingbackend.cpp - - # Python bridge - src/backends/ie/bindings_ie.cpp - src/backends/onnx/bindings_onnx.cpp - src/backends/ov/bindings_ov.cpp - src/backends/python/gpythonbackend.cpp - - # Queue Streaming source - src/streaming/queue_source.cpp - - # OpenVPL Streaming source - src/streaming/onevpl/source.cpp - src/streaming/onevpl/source_priv.cpp - src/streaming/onevpl/file_data_provider.cpp - src/streaming/onevpl/cfg_params.cpp - src/streaming/onevpl/cfg_params_parser.cpp - src/streaming/onevpl/utils.cpp - src/streaming/onevpl/default.cpp - src/streaming/onevpl/data_provider_interface_exception.cpp - src/streaming/onevpl/accelerators/surface/base_frame_adapter.cpp - src/streaming/onevpl/accelerators/surface/cpu_frame_adapter.cpp - src/streaming/onevpl/accelerators/surface/dx11_frame_adapter.cpp - src/streaming/onevpl/accelerators/surface/surface.cpp - src/streaming/onevpl/accelerators/surface/surface_pool.cpp - src/streaming/onevpl/accelerators/utils/shared_lock.cpp - src/streaming/onevpl/accelerators/accel_policy_cpu.cpp - src/streaming/onevpl/accelerators/accel_policy_dx11.cpp - src/streaming/onevpl/accelerators/accel_policy_va_api.cpp - src/streaming/onevpl/accelerators/dx11_alloc_resource.cpp - src/streaming/onevpl/engine/engine_session.cpp - src/streaming/onevpl/engine/processing_engine_base.cpp - src/streaming/onevpl/engine/decode/decode_engine_legacy.cpp - src/streaming/onevpl/engine/decode/decode_session.cpp - src/streaming/onevpl/engine/transcode/transcode_engine_legacy.cpp - src/streaming/onevpl/engine/transcode/transcode_session.cpp - src/streaming/onevpl/engine/preproc/preproc_engine.cpp - src/streaming/onevpl/engine/preproc/preproc_session.cpp - src/streaming/onevpl/engine/preproc/preproc_dispatcher.cpp - src/streaming/onevpl/engine/preproc_engine_interface.cpp - src/streaming/onevpl/demux/async_mfp_demux_data_provider.cpp - src/streaming/onevpl/data_provider_dispatcher.cpp - - src/streaming/onevpl/cfg_param_device_selector.cpp - src/streaming/onevpl/device_selector_interface.cpp - - # GStreamer Streaming source - src/streaming/gstreamer/gstreamer_pipeline_facade.cpp - src/streaming/gstreamer/gstreamerpipeline.cpp - src/streaming/gstreamer/gstreamersource.cpp - src/streaming/gstreamer/gstreamer_buffer_utils.cpp - src/streaming/gstreamer/gstreamer_media_adapter.cpp - src/streaming/gstreamer/gstreamerenv.cpp - - # Utils (ITT tracing) - src/utils/itt.cpp - ) - -file(GLOB_RECURSE gapi_3rdparty_srcs - "${CMAKE_CURRENT_LIST_DIR}/src/3rdparty/vasot/src/*.cpp" -) - -ocv_add_dispatched_file(backends/fluid/gfluidimgproc_func SSE4_1 AVX2) -ocv_add_dispatched_file(backends/fluid/gfluidcore_func SSE4_1 AVX2) - -ocv_list_add_prefix(gapi_srcs "${CMAKE_CURRENT_LIST_DIR}/") - -# For IDE users -ocv_source_group("Src" FILES ${gapi_srcs} ${gapi_3rdparty_srcs}) -ocv_source_group("Include" FILES ${gapi_ext_hdrs}) - -ocv_set_module_sources(HEADERS ${gapi_ext_hdrs} SOURCES ${gapi_srcs} ${gapi_3rdparty_srcs}) -ocv_module_include_directories("${CMAKE_CURRENT_LIST_DIR}/src") - -# VAS Object Tracking includes -ocv_module_include_directories(${CMAKE_CURRENT_LIST_DIR}/src/3rdparty/vasot/include) - -ocv_create_module() - -ocv_target_link_libraries(${the_module} PRIVATE ade) - -if(TARGET ocv.3rdparty.openvino AND OPENCV_GAPI_WITH_OPENVINO) - ocv_target_link_libraries(${the_module} PRIVATE ocv.3rdparty.openvino) - ocv_install_used_external_targets(ocv.3rdparty.openvino) -endif() - -if(HAVE_TBB) - ocv_target_link_libraries(${the_module} PRIVATE tbb) -endif() - -# TODO: Consider support of ITT in G-API standalone mode. -if(CV_TRACE AND HAVE_ITT) - ocv_target_compile_definitions(${the_module} PRIVATE -DOPENCV_WITH_ITT=1) - ocv_module_include_directories(${ITT_INCLUDE_DIRS}) - ocv_target_link_libraries(${the_module} PRIVATE ${ITT_LIBRARIES}) -endif() - -set(__test_extra_deps "") -if(TARGET ocv.3rdparty.openvino AND OPENCV_GAPI_WITH_OPENVINO) - list(APPEND __test_extra_deps ocv.3rdparty.openvino) -endif() -ocv_add_accuracy_tests(${__test_extra_deps}) - -# FIXME: test binary is linked with ADE directly since ADE symbols -# are not exported from libopencv_gapi.so in any form - thus -# there're two copies of ADE code in memory when tests run (!) -# src/ is specified to include dirs for INTERNAL tests only. -if(TARGET opencv_test_gapi) - target_include_directories(opencv_test_gapi PRIVATE "${CMAKE_CURRENT_LIST_DIR}/src") - target_link_libraries(opencv_test_gapi PRIVATE ade) -endif() - -if(HAVE_TBB AND TARGET opencv_test_gapi) - ocv_target_link_libraries(opencv_test_gapi PRIVATE tbb) -endif() - -if(HAVE_FREETYPE) - ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_FREETYPE) - if(TARGET opencv_test_gapi) - ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_FREETYPE) - endif() - ocv_target_link_libraries(${the_module} PRIVATE ${FREETYPE_LIBRARIES}) - ocv_target_include_directories(${the_module} PRIVATE ${FREETYPE_INCLUDE_DIRS}) -endif() - -if(HAVE_OAK) - ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_OAK) - if(TARGET opencv_test_gapi) - ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_OAK) - endif() - ocv_target_link_libraries(${the_module} PRIVATE depthai::core) -endif() - -if(HAVE_PLAIDML) - ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_PLAIDML) - if(TARGET opencv_test_gapi) - ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_PLAIDML) - endif() - ocv_target_link_libraries(${the_module} PRIVATE ${PLAIDML_LIBRARIES}) - ocv_target_include_directories(${the_module} SYSTEM PRIVATE ${PLAIDML_INCLUDE_DIRS}) -endif() - -if(HAVE_GAPI_ONEVPL) - if(TARGET opencv_test_gapi) - ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_ONEVPL) - ocv_target_link_libraries(opencv_test_gapi PRIVATE ${VPL_IMPORTED_TARGETS}) - if(MSVC) - target_compile_options(opencv_test_gapi PUBLIC "/wd4201") - endif() - if(HAVE_D3D11 AND HAVE_OPENCL) - ocv_target_include_directories(opencv_test_gapi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS}) - endif() - endif() - - ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_ONEVPL) - ocv_target_link_libraries(${the_module} PRIVATE ${VPL_IMPORTED_TARGETS}) - - if(HAVE_DIRECTX AND HAVE_D3D11) - ocv_target_link_libraries(${the_module} PRIVATE d3d11 dxgi) - endif() - if(WIN32) - ocv_target_link_libraries(${the_module} PRIVATE mf mfuuid mfplat shlwapi mfreadwrite) - endif() - if(HAVE_D3D11 AND HAVE_OPENCL) - ocv_target_include_directories(${the_module} SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS}) - endif() - - if(UNIX AND HAVE_VA) - ocv_target_include_directories(${the_module} SYSTEM PRIVATE ${VA_INCLUDE_DIR}) - ocv_target_link_libraries(${the_module} PRIVATE ${VA_LIBRARIES}) - if(TARGET opencv_test_gapi) - ocv_target_include_directories(opencv_test_gapi SYSTEM PRIVATE ${VA_INCLUDE_DIR}) - ocv_target_link_libraries(opencv_test_gapi PRIVATE ${VA_LIBRARIES}) - endif() - endif() -endif() - -ocv_option(OPENCV_GAPI_GSTREAMER "Build G-API with GStreamer support" HAVE_GSTREAMER) -if(HAVE_GSTREAMER AND OPENCV_GAPI_GSTREAMER) - if(TARGET opencv_test_gapi) - ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_GSTREAMER) - ocv_target_link_libraries(opencv_test_gapi PRIVATE ocv.3rdparty.gstreamer) - endif() - ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_GSTREAMER) - ocv_target_link_libraries(${the_module} PRIVATE ocv.3rdparty.gstreamer) -endif() - -if(WIN32) - # Required for htonl/ntohl on Windows - ocv_target_link_libraries(${the_module} PRIVATE wsock32 ws2_32) -endif() - -if(HAVE_DIRECTML) - ocv_target_compile_definitions(${the_module} PRIVATE HAVE_DIRECTML=1) -endif() - -if(HAVE_ONNX) - ocv_target_link_libraries(${the_module} PRIVATE ${ONNX_LIBRARY}) - ocv_target_compile_definitions(${the_module} PRIVATE HAVE_ONNX=1) - if(HAVE_ONNX_DML) - ocv_target_compile_definitions(${the_module} PRIVATE HAVE_ONNX_DML=1) - endif() - if(TARGET opencv_test_gapi) - ocv_target_compile_definitions(opencv_test_gapi PRIVATE HAVE_ONNX=1) - ocv_target_link_libraries(opencv_test_gapi PRIVATE ${ONNX_LIBRARY}) - endif() -endif() - -ocv_install_3rdparty_licenses(vasot "${CMAKE_CURRENT_SOURCE_DIR}/src/3rdparty/vasot/LICENSE.txt") - -ocv_add_perf_tests() -ocv_add_samples() - -# Required for sample with inference on host -if(TARGET example_gapi_onevpl_infer_with_advanced_device_selection) - if(TARGET ocv.3rdparty.openvino AND OPENCV_GAPI_WITH_OPENVINO) - ocv_target_link_libraries(example_gapi_onevpl_infer_with_advanced_device_selection PRIVATE ocv.3rdparty.openvino) - endif() - if(HAVE_DIRECTX AND HAVE_D3D11) - ocv_target_link_libraries(example_gapi_onevpl_infer_with_advanced_device_selection PRIVATE d3d11 dxgi) - endif() - if(HAVE_D3D11 AND HAVE_OPENCL) - ocv_target_include_directories(example_gapi_onevpl_infer_with_advanced_device_selection SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS}) - endif() - if(UNIX AND HAVE_VA) - message(STATUS "GAPI VPL samples with VAAPI") - ocv_target_include_directories(example_gapi_onevpl_infer_with_advanced_device_selection SYSTEM PRIVATE ${VA_INCLUDE_DIR}) - ocv_target_link_libraries(example_gapi_onevpl_infer_with_advanced_device_selection PRIVATE ${VA_LIBRARIES}) - endif() -endif() - -if(TARGET example_gapi_pipeline_modeling_tool) - if(WIN32) - ocv_target_link_libraries(example_gapi_pipeline_modeling_tool winmm.lib) - endif() -endif() - -# perf test dependencies postprocessing -if(HAVE_GAPI_ONEVPL) - # NB: TARGET opencv_perf_gapi doesn't exist before `ocv_add_perf_tests` - # src/ is specified to include dirs for INTERNAL tests only. - if(TARGET opencv_perf_gapi) - target_include_directories(opencv_perf_gapi PRIVATE "${CMAKE_CURRENT_LIST_DIR}/src") - ocv_target_compile_definitions(opencv_perf_gapi PRIVATE -DHAVE_ONEVPL) - ocv_target_link_libraries(opencv_perf_gapi PRIVATE ${VPL_IMPORTED_TARGETS}) - if(HAVE_D3D11 AND HAVE_OPENCL) - ocv_target_include_directories(opencv_perf_gapi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS}) - endif() - endif() -endif() diff --git a/modules/gapi/cmake/DownloadADE.cmake b/modules/gapi/cmake/DownloadADE.cmake deleted file mode 100644 index 8ddaadb511..0000000000 --- a/modules/gapi/cmake/DownloadADE.cmake +++ /dev/null @@ -1,51 +0,0 @@ -set(ade_src_dir "${OpenCV_BINARY_DIR}/3rdparty/ade") -set(ade_filename "v0.1.2e.zip") -set(ade_subdir "ade-0.1.2e") -set(ade_md5 "962ce79e0b95591f226431f7b5f152cd") -ocv_download(FILENAME ${ade_filename} - HASH ${ade_md5} - URL - "${OPENCV_ADE_URL}" - "$ENV{OPENCV_ADE_URL}" - "https://github.com/opencv/ade/archive/" - DESTINATION_DIR ${ade_src_dir} - ID ADE - STATUS res - UNPACK RELATIVE_URL) - -if (NOT res) - return() -endif() - -set(ADE_root "${ade_src_dir}/${ade_subdir}/sources/ade") -file(GLOB_RECURSE ADE_sources "${ADE_root}/source/*.cpp") -file(GLOB_RECURSE ADE_include "${ADE_root}/include/ade/*.hpp") -add_library(ade STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} - ${ADE_include} - ${ADE_sources} -) - -# https://github.com/opencv/ade/issues/32 -if(CV_CLANG AND CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.1) - ocv_warnings_disable(CMAKE_CXX_FLAGS -Wdeprecated-copy) -endif() - -target_include_directories(ade PUBLIC $) -set_target_properties(ade PROPERTIES - POSITION_INDEPENDENT_CODE True - OUTPUT_NAME ade - DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}" - COMPILE_PDB_NAME ade - COMPILE_PDB_NAME_DEBUG "ade${OPENCV_DEBUG_POSTFIX}" - ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH} -) - -if(ENABLE_SOLUTION_FOLDERS) - set_target_properties(ade PROPERTIES FOLDER "3rdparty") -endif() - -if(NOT BUILD_SHARED_LIBS) - ocv_install_target(ade EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL) -endif() - -ocv_install_3rdparty_licenses(ade "${ade_src_dir}/${ade_subdir}/LICENSE") diff --git a/modules/gapi/cmake/init.cmake b/modules/gapi/cmake/init.cmake deleted file mode 100644 index dd4b0bccfa..0000000000 --- a/modules/gapi/cmake/init.cmake +++ /dev/null @@ -1,49 +0,0 @@ -OCV_OPTION(WITH_ADE "Enable ADE framework (required for Graph API module)" ON) - -OCV_OPTION(WITH_FREETYPE "Enable FreeType framework" OFF) -OCV_OPTION(WITH_PLAIDML "Include PlaidML2 support" OFF) -OCV_OPTION(WITH_OAK "Include OpenCV AI Kit support" OFF) - -if(NOT WITH_ADE) - return() -endif() - -if(ade_DIR) - # if ade_DIR is set, use ADE-supplied CMake script - # to set up variables to the prebuilt ADE - find_package(ade 0.1.0) -endif() - -if(NOT TARGET ade) - # if ade_DIR is not set, try to use automatically - # downloaded one (if there any) - include("${CMAKE_CURRENT_LIST_DIR}/DownloadADE.cmake") -endif() - -if(WITH_FREETYPE) - ocv_check_modules(FREETYPE freetype2) - if (FREETYPE_FOUND) - set(HAVE_FREETYPE TRUE) - endif() -endif() - -if(WITH_PLAIDML) - find_package(PlaidML2 CONFIG QUIET) - if (PLAIDML_FOUND) - set(HAVE_PLAIDML TRUE) - endif() -endif() - -if(WITH_GAPI_ONEVPL) - find_package(VPL) - if(VPL_FOUND) - set(HAVE_GAPI_ONEVPL TRUE) - endif() -endif() - -if(WITH_OAK) - find_package(depthai QUIET) - if(depthai_FOUND) - set(HAVE_OAK TRUE) - endif() -endif() diff --git a/modules/gapi/cmake/standalone.cmake b/modules/gapi/cmake/standalone.cmake deleted file mode 100644 index f81c1c8a85..0000000000 --- a/modules/gapi/cmake/standalone.cmake +++ /dev/null @@ -1,62 +0,0 @@ -if("${CMAKE_BUILD_TYPE}" STREQUAL "") - set(CMAKE_BUILD_TYPE "Release") -endif() - -if (NOT TARGET ade ) - find_package(ade 0.1.0 REQUIRED) -endif() - -if (WITH_GAPI_ONEVPL) - find_package(VPL) - if(VPL_FOUND) - set(HAVE_GAPI_ONEVPL TRUE) - endif() -endif() - -set(FLUID_TARGET fluid) -set(FLUID_ROOT "${CMAKE_CURRENT_LIST_DIR}/../") - -file(GLOB FLUID_includes "${FLUID_ROOT}/include/opencv2/*.hpp" - "${FLUID_ROOT}/include/opencv2/gapi/g*.hpp" - "${FLUID_ROOT}/include/opencv2/gapi/util/*.hpp" - "${FLUID_ROOT}/include/opencv2/gapi/own/*.hpp" - "${FLUID_ROOT}/include/opencv2/gapi/fluid/*.hpp") -file(GLOB FLUID_sources "${FLUID_ROOT}/src/api/g*.cpp" - "${FLUID_ROOT}/src/api/rmat.cpp" - "${FLUID_ROOT}/src/api/media.cpp" - "${FLUID_ROOT}/src/compiler/*.cpp" - "${FLUID_ROOT}/src/compiler/passes/*.cpp" - "${FLUID_ROOT}/src/executor/*.cpp" - "${FLUID_ROOT}/src/backends/fluid/*.cpp" - "${FLUID_ROOT}/src/backends/streaming/*.cpp" - "${FLUID_ROOT}/src/backends/common/*.cpp") - -add_library(${FLUID_TARGET} STATIC ${FLUID_includes} ${FLUID_sources}) - -target_include_directories(${FLUID_TARGET} - PUBLIC $ - PRIVATE ${FLUID_ROOT}/src) - -target_compile_definitions(${FLUID_TARGET} PUBLIC GAPI_STANDALONE -# This preprocessor definition resolves symbol clash when -# standalone fluid meets gapi ocv module in one application - PUBLIC cv=fluidcv) - -set_target_properties(${FLUID_TARGET} PROPERTIES POSITION_INDEPENDENT_CODE True) -set_property(TARGET ${FLUID_TARGET} PROPERTY CXX_STANDARD 11) - -if(MSVC) - target_compile_options(${FLUID_TARGET} PUBLIC "/wd4251") - target_compile_options(${FLUID_TARGET} PUBLIC "/wd4275") - target_compile_definitions(${FLUID_TARGET} PRIVATE _CRT_SECURE_NO_DEPRECATE) - # Disable obsollete warning C4503 popping up on MSVC <<2017 - # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4503?view=vs-2019 - set_target_properties(${FLUID_TARGET} PROPERTIES COMPILE_FLAGS "/wd4503") -endif() - -target_link_libraries(${FLUID_TARGET} PRIVATE ade) - -if(WIN32) - # Required for htonl/ntohl on Windows - target_link_libraries(${FLUID_TARGET} PRIVATE wsock32 ws2_32) -endif() diff --git a/modules/gapi/doc/00-root.markdown b/modules/gapi/doc/00-root.markdown deleted file mode 100644 index cb99495c1b..0000000000 --- a/modules/gapi/doc/00-root.markdown +++ /dev/null @@ -1,125 +0,0 @@ -# Graph API {#gapi} - -# Introduction {#gapi_root_intro} - -OpenCV Graph API (or G-API) is a new OpenCV module targeted to make -regular image processing fast and portable. These two goals are -achieved by introducing a new graph-based model of execution. - -G-API is a special module in OpenCV -- in contrast with the majority -of other main modules, this one acts as a framework rather than some -specific CV algorithm. G-API provides means to define CV operations, -construct graphs (in form of expressions) using it, and finally -implement and run the operations for a particular backend. - -@note G-API is a new module and now is in active development. It's API -is volatile at the moment and there may be minor but -compatibility-breaking changes in the future. - -# Contents - -G-API documentation is organized into the following chapters: - -- @subpage gapi_purposes - - The motivation behind G-API and its goals. - -- @subpage gapi_hld - - General overview of G-API architecture and its major internal - components. - -- @subpage gapi_kernel_api - - Learn how to introduce new operations in G-API and implement it for - various backends. - -- @subpage gapi_impl - - Low-level implementation details of G-API, for those who want to - contribute. - -- API Reference: functions and classes - - - @subpage gapi_ref - - Core G-API classes, data types, backends, etc. - - - @subpage gapi_core - - Core G-API operations - arithmetic, boolean, and other matrix - operations; - - - @subpage gapi_imgproc - - Image processing functions: color space conversions, various - filters, etc. - - - @subpage gapi_video - - Video processing functionality. - - - @subpage gapi_draw - - Drawing and composition functionality - -# API Example {#gapi_example} - -A very basic example of G-API pipeline is shown below: - -@include modules/gapi/samples/api_example.cpp - - - -G-API is a separate OpenCV module so its header files have to be -included explicitly. The first four lines of `main()` create and -initialize OpenCV's standard video capture object, which fetches -video frames from either an attached camera or a specified file. - -G-API pipeline is constructed next. In fact, it is a series of G-API -operation calls on cv::GMat data. The important aspect of G-API is -that this code block is just a declaration of actions, but not the -actions themselves. No processing happens at this point, G-API only -tracks which operations form pipeline and how it is connected. G-API -_Data objects_ (here it is cv::GMat) are used to connect operations -each other. `in` is an _empty_ cv::GMat signalling that it is a -beginning of computation. - -After G-API code is written, it is captured into a call graph with -instantiation of cv::GComputation object. This object takes -input/output data references (in this example, `in` and `out` -cv::GMat objects, respectively) as parameters and reconstructs the -call graph based on all the data flow between `in` and `out`. - -cv::GComputation is a thin object in sense that it just captures which -operations form up a computation. However, it can be used to execute -computations -- in the following processing loop, every captured frame (a -cv::Mat `input_frame`) is passed to cv::GComputation::apply(). - -![Example pipeline running on sample video 'vtest.avi'](pics/demo.jpg) - -cv::GComputation::apply() is a polimorphic method which accepts a -variadic number of arguments. Since this computation is defined on one -input, one output, a special overload of cv::GComputation::apply() is -used to pass input data and get output data. - -Internally, cv::GComputation::apply() compiles the captured graph for -the given input parameters and executes the compiled graph on data -immediately. - -There is a number important concepts can be outlines with this example: -* Graph declaration and graph execution are distinct steps; -* Graph is built implicitly from a sequence of G-API expressions; -* G-API supports function-like calls -- e.g. cv::gapi::resize(), and - operators, e.g operator|() which is used to compute bitwise OR; -* G-API syntax aims to look pure: every operation call within a graph - yields a new result, thus forming a directed acyclic graph (DAG); -* Graph declaration is not bound to any data -- real data objects - (cv::Mat) come into picture after the graph is already declared. - - - -See [tutorials and porting examples](@ref tutorial_table_of_content_gapi) -to learn more on various G-API features and concepts. - - diff --git a/modules/gapi/doc/01-background.markdown b/modules/gapi/doc/01-background.markdown deleted file mode 100644 index 08014d1f67..0000000000 --- a/modules/gapi/doc/01-background.markdown +++ /dev/null @@ -1,76 +0,0 @@ -# Why Graph API? {#gapi_purposes} - -# Motivation behind G-API {#gapi_intro_why} - -G-API module brings graph-based model of execution to OpenCV. This -chapter briefly describes how this new model can help software -developers in two aspects: optimizing and porting image processing -algorithms. - -## Optimizing with Graph API {#gapi_intro_opt} - -Traditionally OpenCV provided a lot of stand-alone image processing -functions (see modules `core` and `imgproc`). Many of that functions -are well-optimized (e.g. vectorized for specific CPUs, parallel, etc) -but still the out-of-box optimization scope has been limited to a -single function only -- optimizing the whole algorithm built atop of that -functions was a responsibility of a programmer. - -OpenCV 3.0 introduced _Transparent API_ (or _T-API_) which allowed to -offload OpenCV function calls transparently to OpenCL devices and save -on Host/Device data transfers with cv::UMat -- and it was a great step -forward. However, T-API is a dynamic API -- user code still remains -unconstrained and OpenCL kernels are enqueued in arbitrary order, thus -eliminating further pipeline-level optimization potential. - -G-API brings implicit graph model to OpenCV 4.0. Graph model captures -all operations and its data dependencies in a pipeline and so provides -G-API framework with extra information to do pipeline-level -optimizations. - -The cornerstone of graph-based optimizations is _Tiling_. Tiling -allows to break the processing into smaller parts and reorganize -operations to enable data parallelism, improve data locality, and save -memory footprint. Data locality is an especially important aspect of -software optimization due to diffent costs of memory access on modern -computer architectures -- the more data is reused in the first level -cache, the more efficient pipeline is. - -Definitely the aforementioned techniques can be applied manually -- -but it requires extra skills and knowledge of the target platform and -the algorithm implementation changes irrevocably -- becoming more -specific, less flexible, and harder to extend and maintain. - -G-API takes this responsibility and complexity from user and does the -majority of the work by itself, keeping the algorithm code clean from -device or optimization details. This approach has its own limitations, -though, as graph model is a _constrained_ model and not every -algorithm can be represented as a graph, so the G-API scope is limited -only to regular image processing -- various filters, arithmetic, -binary operations, and well-defined geometrical transformations. - -## Porting with Graph API {#gapi_intro_port} - -The essence of G-API is declaring a sequence of operations to run, and -then executing that sequence. G-API is a constrained API, so it puts a -number of limitations on which operations can form a pipeline and -which data these operations may exchange each other. - -This formalization in fact helps to make an algorithm portable. G-API -clearly separates operation _interfaces_ from its _implementations_. - -One operation (_kernel_) may have multiple implementations even for a -single device (e.g., OpenCV-based "reference" implementation and a -tiled optimized implementation, both running on CPU). Graphs (or -_Computations_ in G-API terms) are built only using operation -interfaces, not implementations -- thus the same graph can be executed -on different devices (and, of course, using different optimization -techniques) with little-to-no changes in the graph itself. - -G-API supports plugins (_Backends_) which aggregate logic and -intelligence on what is the best way to execute on a particular -platform. Once a pipeline is built with G-API, it can be parametrized -to use either of the backends (or a combination of it) and so a graph -can be ported easily to a new platform. - -@sa @ref gapi_hld diff --git a/modules/gapi/doc/10-hld-overview.md b/modules/gapi/doc/10-hld-overview.md deleted file mode 100644 index 6de6efa921..0000000000 --- a/modules/gapi/doc/10-hld-overview.md +++ /dev/null @@ -1,160 +0,0 @@ -# High-level design overview {#gapi_hld} - -[TOC] - -# G-API High-level design overview - -G-API is a heterogeneous framework and provides an unified API to -program image processing pipelines with a number of supported -backends. - -The key design idea is to keep pipeline code itself platform-neutral -while specifying which kernels to use and which devices to utilize -using extra parameters at graph compile (configuration) time. This -requirement has led to the following architecture: - - - -![G-API framework architecture](pics/gapi_scheme.png) - -There are three layers in this architecture: -* **API Layer** -- this is the top layer, which implements G-API - public interface, its building blocks and semantics. - When user constructs a pipeline with G-API, he interacts with this - layer directly, and the entities the user operates on (like cv::GMat - or cv::GComputation) are provided by this layer. -* **Graph Compiler Layer** -- this is the intermediate layer which - unrolls user computation into a graph and then applies a number of - transformations to it (e.g. optimizations). This layer is built atop - of [ADE Framework](@ref gapi_detail_ade). -* **Backends Layer** -- this is the lowest level layer, which lists a - number of _Backends_. In contrast with the above two layers, - backends are highly coupled with low-level platform details, with - every backend standing for every platform. A backend operates on a - processed graph (coming from the graph compiler) and executes this - graph optimally for a specific platform or device. - -# API layer {#gapi_api_layer} - -API layer is what user interacts with when defining and using a -pipeline (a Computation in G-API terms). API layer defines a set of -G-API _dynamic_ objects which can be used as inputs, outputs, and -intermediate data objects within a graph: -* cv::GMat -* cv::GScalar -* cv::GArray (template class) - -API layer specifies a list of Operations which are defined on these -data objects -- so called kernels. See G-API [core](@ref gapi_core) -and [imgproc](@ref gapi_imgproc) namespaces for details on which -operations G-API provides by default. - -G-API is not limited to these operations only -- users can define -their own kernels easily using a special macro G_TYPED_KERNEL(). - -API layer is also responsible for marshalling and storing operation -parameters on pipeline creation. In addition to the aforementioned -G-API dynamic objects, operations may also accept arbitrary -parameters (more on this [here](@ref gapi_detail_params)), so API -layer captures its values and stores internally upon the moment of -execution. - -Finally, cv::GComputation and cv::GCompiled are the remaining -important components of API layer. The former wraps a series of G-API -expressions into an object (graph), and the latter is a product of -graph _compilation_ (see [this chapter](@ref gapi_detail_compiler) for -details). - -# Graph compiler layer {#gapi_compiler} - -Every G-API computation is compiled before it executes. Compilation -process is triggered in two ways: -* _implicitly_, when cv::GComputation::apply() is used. In this case, - graph compilation is then immediately followed by execution. -* _explicitly_, when cv::GComputation::compile() is used. In this case, - a cv::GCompiled object is returned which then can be invoked as a - C++ functor. - -The first way is recommended for cases when input data format is not -known in advance -- e.g. when it comes from an arbitrary input file. -The second way is recommended for deployment (production) scenarios -where input data characteristics are usually predefined. - -Graph compilation process is built atop of ADE Framework. Initially, a -bipartite graph is generated from expressions captured by API layer. -This graph contains nodes of two types: _Data_ and _Operations_. Graph -always starts and ends with a Data node(s), with Operations nodes -in-between. Every Operation node has inputs and outputs, both are Data -nodes. - -After the initial graph is generated, it is actually processed by a -number of graph transformations, called _passes_. ADE Framework acts -as a compiler pass management engine, and passes are written -specifically for G-API. - -There are different passes which check graph validity, refine details -on operations and data, organize nodes into clusters ("Islands") based -on affinity or user-specified regioning[TBD], and more. Backends also -are able to inject backend-specific passes into the compilation -process, see more on this in the [dedicated chapter](@ref gapi_detail_meta). - -Result of graph compilation is a compiled object, represented by class -cv::GCompiled. A new cv::GCompiled object is always created regardless -if there was an explicit or implicit compilation request (see -above). Actual graph execution happens within cv::GCompiled and is -determined by backends which participated in the graph compilation. - -@sa cv::GComputation::apply(), cv::GComputation::compile(), cv::GCompiled - -# Backends layer {#gapi_backends} - -The above diagram lists two backends, _OpenCV_ and _Fluid_. _OpenCV_ -is so-called "reference backend", which implements G-API operations -using plain old OpenCV functions. This backend is useful for -prototyping on a familiar development system. _Fluid_ is a plugin for -cache-efficient execution on CPU -- it implements a different -execution policy and operates with its own, special kernels. Fluid -backend allows to achieve less memory footprint and better memory -locality when running on CPU. - -There may be more backends available, e.g. Halide, OpenCL, etc. -- -G-API provides an uniform internal API to develop backends so any -enthusiast or a company are free to scale G-API on a new platform or -accelerator. In terms of OpenCV infrastructure, every new backend is a -new distinct OpenCV module, which extends G-API when build as a part -of OpenCV. - -# Graph execution {#gapi_compiled} - -The way graph executed is defined by backends selected for -compilation. In fact, every backend builds its own execution script as -the final stage of graph compilation process, when an executable -(compiled) object is being generated. For example, in OpenCV backend, -this script is just a topologically-sorted sequence of OpenCV -functions to call; for Fluid backend, it is a similar thing -- a -topologically sorted list of _Agents_ processing lines of input on -every iteration. - -Graph execution is triggered in two ways: -* via cv::GComputation::apply(), with graph compiled in-place exactly - for the given input data; -* via cv::GCompiled::operator()(), when the graph has been precompiled. - -Both methods are polimorphic and take a variadic number of arguments, -with validity checks performed in runtime. If a number, shapes, and -formats of passed data objects differ from expected, a runtime -exception is thrown. G-API also provides _typed_ wrappers to move -these checks to the compile time -- see `cv::GComputationT<>`. - -G-API graph execution is declared stateless -- it means that a -compiled functor (cv::GCompiled) acts like a pure C++ function and -provides the same result for the same set of input arguments. - -Both execution methods take \f$N+M\f$ parameters, where \f$N\f$ is a -number of inputs, and \f$M\f$ is a number of outputs on which a -cv::GComputation is defined. Note that while G-API types (cv::GMat, -etc) are used in definition, the execution methods accept OpenCV's -traditional data types (like cv::Mat) which hold actual data -- see -table in [parameter marshalling](@ref gapi_detail_params). - -@sa @ref gapi_impl, @ref gapi_kernel_api diff --git a/modules/gapi/doc/20-kernel-api.markdown b/modules/gapi/doc/20-kernel-api.markdown deleted file mode 100644 index 9a7cf39f67..0000000000 --- a/modules/gapi/doc/20-kernel-api.markdown +++ /dev/null @@ -1,188 +0,0 @@ -# Kernel API {#gapi_kernel_api} - -[TOC] - -# G-API Kernel API - -The core idea behind G-API is portability -- a pipeline built with -G-API must be portable (or at least able to be portable). It means -that either it works out-of-the box when compiled for new platform, -_or_ G-API provides necessary tools to make it running there, with -little-to-no changes in the algorithm itself. - -This idea can be achieved by separating kernel interface from its -implementation. Once a pipeline is built using kernel interfaces, it -becomes implementation-neutral -- the implementation details -(i.e. which kernels to use) are passed on a separate stage (graph -compilation). - -Kernel-implementation hierarchy may look like: - -@dot Kernel API/implementation hierarchy example -digraph { - rankdir=BT; - node [shape=record]; - - ki_a [label="{ interface\nA}"]; - ki_b [label="{ interface\nB}"]; - - {rank=same; ki_a ki_b}; - - "CPU::A" -> ki_a [dir="forward"]; - "OpenCL::A" -> ki_a [dir="forward"]; - "Halide::A" -> ki_a [dir="forward"]; - - "CPU::B" -> ki_b [dir="forward"]; - "OpenCL::B" -> ki_b [dir="forward"]; - "Halide::B" -> ki_b [dir="forward"]; -} -@enddot - -A pipeline itself then can be expressed only in terms of `A`, `B`, and -so on, and choosing which implementation to use in execution becomes -an external parameter. - -# Defining a kernel {#gapi_defining_kernel} - -G-API provides a macro to define a new kernel interface -- -G_TYPED_KERNEL(): - -@snippet samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp filter2d_api - -This macro is a shortcut to a new type definition. It takes three -arguments to register a new type, and requires type body to be present -(see [below](@ref gapi_kernel_supp_info)). The macro arguments are: -1. Kernel interface name -- also serves as a name of new type defined - with this macro; -2. Kernel signature -- an `std::function<>`-like signature which defines - API of the kernel; -3. Kernel's unique name -- used to identify kernel when its type - informattion is stripped within the system. - -Kernel declaration may be seen as function declaration -- in both cases -a new entity must be used then according to the way it was defined. - -Kernel signature defines kernel's usage syntax -- which parameters -it takes during graph construction. Implementations can also use this -signature to derive it into backend-specific callback signatures (see -next chapter). - -Kernel may accept values of any type, and G-API _dynamic_ types are -handled in a special way. All other types are opaque to G-API and -passed to kernel in `outMeta()` or in execution callbacks as-is. - -Kernel's return value can _only_ be of G-API dynamic type -- cv::GMat, -cv::GScalar, or `cv::GArray`. If an operation has more than one -output, it should be wrapped into an `std::tuple<>` (which can contain -only mentioned G-API types). Arbitrary-output-number operations are -not supported. - -Once a kernel is defined, it can be used in pipelines with special, -G-API-supplied method "::on()". This method has the same signature as -defined in kernel, so this code: - -@snippet samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp filter2d_on - -is a perfectly legal construction. This example has some verbosity, -though, so usually a kernel declaration comes with a C++ function -wrapper ("factory method") which enables optional parameters, more -compact syntax, Doxygen comments, etc: - -@snippet samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp filter2d_wrap - -so now it can be used like: - -@snippet samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp filter2d_wrap_call - -# Extra information {#gapi_kernel_supp_info} - -In the current version, kernel declaration body (everything within the -curly braces) must contain a static function `outMeta()`. This function -establishes a functional dependency between operation's input and -output metadata. - -_Metadata_ is an information about data kernel operates on. Since -non-G-API types are opaque to G-API, G-API cares only about `G*` data -descriptors (i.e. dimensions and format of cv::GMat, etc). - -`outMeta()` is also an example of how kernel's signature can be -transformed into a derived callback -- note that in this example, -`outMeta()` signature exactly follows the kernel signature (defined -within the macro) but is different -- where kernel expects cv::GMat, -`outMeta()` takes and returns cv::GMatDesc (a G-API structure metadata -for cv::GMat). - -The point of `outMeta()` is to propagate metadata information within -computation from inputs to outputs and infer metadata of internal -(intermediate, temporary) data objects. This information is required -for further pipeline optimizations, memory allocation, and other -operations done by G-API framework during graph compilation. - - - -# Implementing a kernel {#gapi_kernel_implementing} - -Once a kernel is declared, its interface can be used to implement -versions of this kernel in different backends. This concept is -naturally projected from object-oriented programming -"Interface/Implementation" idiom: an interface can be implemented -multiple times, and different implementations of a kernel should be -substitutable with each other without breaking the algorithm -(pipeline) logic (Liskov Substitution Principle). - -Every backend defines its own way to implement a kernel interface. -This way is regular, though -- whatever plugin is, its kernel -implementation must be "derived" from a kernel interface type. - -Kernel implementation are then organized into _kernel -packages_. Kernel packages are passed to cv::GComputation::compile() -as compile arguments, with some hints to G-API on how to select proper -kernels (see more on this in "Heterogeneity"[TBD]). - -For example, the aforementioned `Filter2D` is implemented in -"reference" CPU (OpenCV) plugin this way (*NOTE* -- this is a -simplified form with improper border handling): - -@snippet samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp filter2d_ocv - -Note how CPU (OpenCV) plugin has transformed the original kernel -signature: -- Input cv::GMat has been substituted with cv::Mat, holding actual input - data for the underlying OpenCV function call; -- Output cv::GMat has been transformed into extra output parameter, thus - `GCPUFilter2D::run()` takes one argument more than the original - kernel signature. - -The basic intuition for kernel developer here is _not to care_ where -that cv::Mat objects come from instead of the original cv::GMat -- and -just follow the signature conventions defined by the plugin. G-API -will call this method during execution and supply all the necessary -information (and forward the original opaque data as-is). - -# Compound kernels {#gapi_kernel_compound} - -Sometimes kernel is a single thing only on API level. It is convenient -for users, but on a particular implementation side it would be better to -have multiple kernels (a subgraph) doing the thing instead. An example -is goodFeaturesToTrack() -- while in OpenCV backend it may remain a -single kernel, with Fluid it becomes compound -- Fluid can handle Harris -response calculation but can't do sparse non-maxima suppression and -point extraction to an STL vector: - - - -A compound kernel _implementation_ can be defined using a generic -macro GAPI_COMPOUND_KERNEL(): - -@snippet samples/cpp/tutorial_code/gapi/doc_snippets/kernel_api_snippets.cpp compound - - - - -It is important to distinguish a compound kernel from G-API high-order -function, i.e. a C++ function which looks like a kernel but in fact -generates a subgraph. The core difference is that a compound kernel is -an _implementation detail_ and a kernel implementation may be either -compound or not (depending on backend capabilities), while a -high-order function is a "macro" in terms of G-API and so cannot act as -an interface which then needs to be implemented by a backend. diff --git a/modules/gapi/doc/30-implementation.markdown b/modules/gapi/doc/30-implementation.markdown deleted file mode 100644 index cdb5df413b..0000000000 --- a/modules/gapi/doc/30-implementation.markdown +++ /dev/null @@ -1,29 +0,0 @@ -# Implementation details {#gapi_impl} - -[TOC] - -# G-API Implementation details - -@note this section is still in progress. - -# API layer {#gapi_detail_api} - -## Expression unrolling {#gapi_detail_expr} - -## Parameter marshalling {#gapi_detail_params} - -## Operations representation {#gapi_detail_operations} - -# Graph compiler {#gapi_detail_compiler} - -## ADE basics {#gapi_detail_ade} - -## Graph model representation {#gapi_detail_gmodel} - -## G-API metadata and passes {#gapi_detail_meta} - -# Backends {#gapi_detail_backends} - -## Backend scope of work {#gapi_backend_scope} - -## Graph transformation {#gapi_backend_pass} diff --git a/modules/gapi/doc/pics/demo.jpg b/modules/gapi/doc/pics/demo.jpg deleted file mode 100644 index 742d135f7a..0000000000 Binary files a/modules/gapi/doc/pics/demo.jpg and /dev/null differ diff --git a/modules/gapi/doc/pics/gapi_scheme.png b/modules/gapi/doc/pics/gapi_scheme.png deleted file mode 100644 index 24271e3224..0000000000 Binary files a/modules/gapi/doc/pics/gapi_scheme.png and /dev/null differ diff --git a/modules/gapi/doc/pics/render_example.png b/modules/gapi/doc/pics/render_example.png deleted file mode 100644 index b2675988b3..0000000000 Binary files a/modules/gapi/doc/pics/render_example.png and /dev/null differ diff --git a/modules/gapi/doc/slides/.gitignore b/modules/gapi/doc/slides/.gitignore deleted file mode 100644 index 309f68f98d..0000000000 --- a/modules/gapi/doc/slides/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -*.bbl -*.blg -*.sty -*.tex -*-converted-to.pdf -mtheme.sty/ diff --git a/modules/gapi/doc/slides/README.md b/modules/gapi/doc/slides/README.md deleted file mode 100644 index 3c81e24fa6..0000000000 --- a/modules/gapi/doc/slides/README.md +++ /dev/null @@ -1,27 +0,0 @@ -# G-API Overview - -This is the latest overview slide deck on G-API. - -## Prerequisites - -- [Emacs] v24 or higher; -- [Org]-mode 8.2.10; -- `pdflatex`; -- `texlive-latex-recommended` ([Beamer] package); -- `texlive-font-utils` (`epstopdf`); -- `wget` (for `get_sty.sh`). - -## Building - -1. Download and build the [Metropolis] theme with the script: - -``` -$ ./get_sty.sh -``` - -2. Now open `gapi_overview.org` with Emacs and press `C-c C-e l P`. - -[Emacs]: https://www.gnu.org/software/emacs/ -[Org]: https://orgmode.org/ -[Beamer]: https://ctan.org/pkg/beamer -[Metropolis]: https://github.com/matze/mtheme diff --git a/modules/gapi/doc/slides/gapi_overview.org b/modules/gapi/doc/slides/gapi_overview.org deleted file mode 100644 index 7ed85baeca..0000000000 --- a/modules/gapi/doc/slides/gapi_overview.org +++ /dev/null @@ -1,961 +0,0 @@ -#+TITLE: OpenCV 4.4 Graph API -#+AUTHOR: Dmitry Matveev\newline Intel Corporation -#+OPTIONS: H:2 toc:t num:t -#+LATEX_CLASS: beamer -#+LATEX_CLASS_OPTIONS: [presentation] -#+LATEX_HEADER: \usepackage{transparent} \usepackage{listings} \usepackage{pgfplots} \usepackage{mtheme.sty/beamerthememetropolis} -#+LATEX_HEADER: \setbeamertemplate{frame footer}{OpenCV 4.4 G-API: Overview and programming by example} -#+BEAMER_HEADER: \subtitle{Overview and programming by example} -#+BEAMER_HEADER: \titlegraphic{ \vspace*{3cm}\hspace*{5cm} {\transparent{0.2}\includegraphics[height=\textheight]{ocv_logo.eps}}} -#+COLUMNS: %45ITEM %10BEAMER_ENV(Env) %10BEAMER_ACT(Act) %4BEAMER_COL(Col) %8BEAMER_OPT(Opt) - -* G-API: What is, why, what's for? - -** OpenCV evolution in one slide - -*** Version 1.x -- Library inception - -- Just a set of CV functions + helpers around (visualization, IO); - -*** Version 2.x -- Library rewrite - -- OpenCV meets C++, ~cv::Mat~ replaces ~IplImage*~; - -*** Version 3.0 -- Welcome Transparent API (T-API) - -- ~cv::UMat~ is introduced as a /transparent/ addition to - ~cv::Mat~; -- With ~cv::UMat~, an OpenCL kernel can be enqeueud instead of - immediately running C code; -- ~cv::UMat~ data is kept on a /device/ until explicitly queried. - -** OpenCV evolution in one slide (cont'd) -# FIXME: Learn proper page-breaking! - -*** Version 4.0 -- Welcome Graph API (G-API) - -- A new separate module (not a full library rewrite); -- A framework (or even a /meta/-framework); -- Usage model: - - /Express/ an image/vision processing graph and then /execute/ it; - - Fine-tune execution without changes in the graph; -- Similar to Halide -- separates logic from - platform details. -- More than Halide: - - Kernels can be written in unconstrained platform-native code; - - Halide can serve as a backend (one of many). - -** OpenCV evolution in one slide (cont'd) -# FIXME: Learn proper page-breaking! - -*** Version 4.2 -- New horizons - -- Introduced in-graph inference via OpenVINO™ Toolkit; -- Introduced video-oriented Streaming execution mode; -- Extended focus from individual image processing to the full - application pipeline optimization. - -*** Version 4.4 -- More on video - -- Introduced a notion of stateful kernels; - - The road to object tracking, background subtraction, etc. in the - graph; -- Added more video-oriented operations (feature detection, Optical - flow). - -** Why G-API? - -*** Why introduce a new execution model? - -- Ultimately it is all about optimizations; - - or at least about a /possibility/ to optimize; -- A CV algorithm is usually not a single function call, but a - composition of functions; -- Different models operate at different levels of knowledge on the - algorithm (problem) we run. - -** Why G-API? (cont'd) -# FIXME: Learn proper page-breaking! - -*** Why introduce a new execution model? - -- *Traditional* -- every function can be optimized (e.g. vectorized) - and parallelized, the rest is up to programmer to care about. -- *Queue-based* -- kernels are enqueued dynamically with no guarantee - where the end is or what is called next; -- *Graph-based* -- nearly all information is there, some compiler - magic can be done! - -** What is G-API for? - -*** Bring the value of graph model with OpenCV where it makes sense: - -- *Memory consumption* can be reduced dramatically; -- *Memory access* can be optimized to maximize cache reuse; -- *Parallelism* can be applied automatically where it is hard to do - it manually; - - It also becomes more efficient when working with graphs; -- *Heterogeneity* gets extra benefits like: - - Avoiding unnecessary data transfers; - - Shadowing transfer costs with parallel host co-execution; - - Improving system throughput with frame-level pipelining. - -* Programming with G-API - -** G-API Basics - -*** G-API Concepts - -- *Graphs* are built by applying /operations/ to /data objects/; - - API itself has no "graphs", it is expression-based instead; -- *Data objects* do not hold actual data, only capture /dependencies/; -- *Operations* consume and produce data objects. -- A graph is defined by specifying its /boundaries/ with data objects: - - What data objects are /inputs/ to the graph? - - What are its /outputs/? - -** The code is worth a thousand words - :PROPERTIES: - :BEAMER_opt: shrink=42 - :END: - -#+BEGIN_SRC C++ -#include // G-API framework header -#include // cv::gapi::blur() -#include // cv::imread/imwrite - -int main(int argc, char *argv[]) { - if (argc < 3) return 1; - - cv::GMat in; // Express the graph: - cv::GMat out = cv::gapi::blur(in, cv::Size(3,3)); // `out` is a result of `blur` of `in` - - cv::Mat in_mat = cv::imread(argv[1]); // Get the real data - cv::Mat out_mat; // Output buffer (may be empty) - - cv::GComputation(cv::GIn(in), cv::GOut(out)) // Declare a graph from `in` to `out` - .apply(cv::gin(in_mat), cv::gout(out_mat)); // ...and run it immediately - - cv::imwrite(argv[2], out_mat); // Save the result - return 0; -} -#+END_SRC - -** The code is worth a thousand words - :PROPERTIES: - :BEAMER_opt: shrink=42 - :END: - -*** Traditional OpenCV :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.45 - :END: -#+BEGIN_SRC C++ -#include -#include - -#include - -int main(int argc, char *argv[]) { - using namespace cv; - if (argc != 3) return 1; - - Mat in_mat = imread(argv[1]); - Mat gx, gy; - - Sobel(in_mat, gx, CV_32F, 1, 0); - Sobel(in_mat, gy, CV_32F, 0, 1); - - Mat mag, out_mat; - sqrt(gx.mul(gx) + gy.mul(gy), mag); - mag.convertTo(out_mat, CV_8U); - - imwrite(argv[2], out_mat); - return 0; -} -#+END_SRC - -*** OpenCV G-API :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.5 - :END: -#+BEGIN_SRC C++ -#include -#include -#include -#include - -int main(int argc, char *argv[]) { - using namespace cv; - if (argc != 3) return 1; - - GMat in; - GMat gx = gapi::Sobel(in, CV_32F, 1, 0); - GMat gy = gapi::Sobel(in, CV_32F, 0, 1); - GMat mag = gapi::sqrt( gapi::mul(gx, gx) - + gapi::mul(gy, gy)); - GMat out = gapi::convertTo(mag, CV_8U); - GComputation sobel(GIn(in), GOut(out)); - - Mat in_mat = imread(argv[1]), out_mat; - sobel.apply(in_mat, out_mat); - imwrite(argv[2], out_mat); - return 0; -} -#+END_SRC - -** The code is worth a thousand words (cont'd) -# FIXME: sections!!! - -*** What we have just learned? - -- G-API functions mimic their traditional OpenCV ancestors; -- No real data is required to construct a graph; -- Graph construction and graph execution are separate steps. - -*** What else? - -- Graph is first /expressed/ and then /captured/ in an object; -- Graph constructor defines /protocol/; user can pass vectors of - inputs/outputs like - #+BEGIN_SRC C++ -cv::GComputation(cv::GIn(...), cv::GOut(...)) - #+END_SRC -- Calls to ~.apply()~ must conform to graph's protocol - -** On data objects - -Graph *protocol* defines what arguments a computation was defined on -(both inputs and outputs), and what are the *shapes* (or types) of -those arguments: - - | *Shape* | *Argument* | Size | - |--------------+------------------+-----------------------------| - | ~GMat~ | ~Mat~ | Static; defined during | - | | | graph compilation | - |--------------+------------------+-----------------------------| - | ~GScalar~ | ~Scalar~ | 4 x ~double~ | - |--------------+------------------+-----------------------------| - | ~GArray~ | ~std::vector~ | Dynamic; defined in runtime | - |--------------+------------------+-----------------------------| - | ~GOpaque~ | ~T~ | Static, ~sizeof(T)~ | - -~GScalar~ may be value-initialized at construction time to allow - expressions like ~GMat a = 2*(b + 1)~. - -** On operations and kernels - :PROPERTIES: - :BEAMER_opt: shrink=22 - :END: - -*** :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.45 - :END: - -- Graphs are built with *Operations* over virtual *Data*; -- *Operations* define interfaces (literally); -- *Kernels* are implementations to *Operations* (like in OOP); -- An *Operation* is platform-agnostic, a *kernel* is not; -- *Kernels* are implemented for *Backends*, the latter provide - APIs to write kernels; -- Users can /add/ their *own* operations and kernels, - and also /redefine/ "standard" kernels their *own* way. - -*** :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.45 - :END: - -#+BEGIN_SRC dot :file "000-ops-kernels.eps" :cmdline "-Kdot -Teps" -digraph G { -node [shape=box]; -rankdir=BT; - -Gr [label="Graph"]; -Op [label="Operation\nA"]; -{rank=same -Impl1 [label="Kernel\nA:2"]; -Impl2 [label="Kernel\nA:1"]; -} - -Op -> Gr [dir=back, label="'consists of'"]; -Impl1 -> Op []; -Impl2 -> Op [label="'is implemented by'"]; - -node [shape=note,style=dashed]; -{rank=same -Op; -CommentOp [label="Abstract:\ndeclared via\nG_API_OP()"]; -} -{rank=same -Comment1 [label="Platform:\ndefined with\nOpenCL backend"]; -Comment2 [label="Platform:\ndefined with\nOpenCV backend"]; -} - -CommentOp -> Op [constraint=false, style=dashed, arrowhead=none]; -Comment1 -> Impl1 [style=dashed, arrowhead=none]; -Comment2 -> Impl2 [style=dashed, arrowhead=none]; -} -#+END_SRC - -** On operations and kernels (cont'd) - -*** Defining an operation - -- A type name (every operation is a C++ type); -- Operation signature (similar to ~std::function<>~); -- Operation identifier (a string); -- Metadata callback -- describe what is the output value format(s), - given the input and arguments. -- Use ~OpType::on(...)~ to use a new kernel ~OpType~ to construct graphs. - -#+LaTeX: {\footnotesize -#+BEGIN_SRC C++ -G_API_OP(GSqrt,,"org.opencv.core.math.sqrt") { - static GMatDesc outMeta(GMatDesc in) { return in; } -}; -#+END_SRC -#+LaTeX: } - -** On operations and kernels (cont'd) - -*** ~GSqrt~ vs. ~cv::gapi::sqrt()~ - -- How a *type* relates to a *functions* from the example? -- These functions are just wrappers over ~::on~: - #+LaTeX: {\scriptsize - #+BEGIN_SRC C++ - G_API_OP(GSqrt,,"org.opencv.core.math.sqrt") { - static GMatDesc outMeta(GMatDesc in) { return in; } - }; - GMat gapi::sqrt(const GMat& src) { return GSqrt::on(src); } - #+END_SRC - #+LaTeX: } -- Why -- Doxygen, default parameters, 1:n mapping: - #+LaTeX: {\scriptsize - #+BEGIN_SRC C++ - cv::GMat custom::unsharpMask(const cv::GMat &src, - const int sigma, - const float strength) { - cv::GMat blurred = cv::gapi::medianBlur(src, sigma); - cv::GMat laplacian = cv::gapi::Laplacian(blurred, CV_8U); - return (src - (laplacian * strength)); - } - #+END_SRC - #+LaTeX: } - -** On operations and kernels (cont'd) - -*** Implementing an operation - -- Depends on the backend and its API; -- Common part for all backends: refer to operation being implemented - using its /type/. - -*** OpenCV backend -- OpenCV backend is the default one: OpenCV kernel is a wrapped OpenCV - function: - #+LaTeX: {\footnotesize - #+BEGIN_SRC C++ - GAPI_OCV_KERNEL(GCPUSqrt, cv::gapi::core::GSqrt) { - static void run(const cv::Mat& in, cv::Mat &out) { - cv::sqrt(in, out); - } - }; - #+END_SRC - #+LaTeX: } - -** Operations and Kernels (cont'd) -# FIXME!!! - -*** Fluid backend - -- Fluid backend operates with row-by-row kernels and schedules its - execution to optimize data locality: - #+LaTeX: {\footnotesize - #+BEGIN_SRC C++ - GAPI_FLUID_KERNEL(GFluidSqrt, cv::gapi::core::GSqrt, false) { - static const int Window = 1; - static void run(const View &in, Buffer &out) { - hal::sqrt32f(in .InLine (0) - out.OutLine(0), - out.length()); - } - }; - #+END_SRC - #+LaTeX: } -- Note ~run~ changes signature but still is derived from the operation - signature. - -** Operations and Kernels (cont'd) - -*** Specifying which kernels to use - -- Graph execution model is defined by kernels which are available/used; -- Kernels can be specified via the graph compilation arguments: - #+LaTeX: {\footnotesize - #+BEGIN_SRC C++ - #include - #include - ... - auto pkg = cv::gapi::combine(cv::gapi::core::fluid::kernels(), - cv::gapi::imgproc::fluid::kernels()); - sobel.apply(in_mat, out_mat, cv::compile_args(pkg)); - #+END_SRC - #+LaTeX: } -- Users can combine kernels of different backends and G-API will partition - the execution among those automatically. - -** Heterogeneity in G-API - :PROPERTIES: - :BEAMER_opt: shrink=35 - :END: -*** Automatic subgraph partitioning in G-API -*** :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.18 - :END: - -#+BEGIN_SRC dot :file "010-hetero-init.eps" :cmdline "-Kdot -Teps" -digraph G { -rankdir=TB; -ranksep=0.3; - -node [shape=box margin=0 height=0.25]; -A; B; C; - -node [shape=ellipse]; -GMat0; -GMat1; -GMat2; -GMat3; - -GMat0 -> A -> GMat1 -> B -> GMat2; -GMat2 -> C; -GMat0 -> C -> GMat3 - -subgraph cluster {style=invis; A; GMat1; B; GMat2; C}; -} -#+END_SRC - -The initial graph: operations are not resolved yet. - -*** :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.18 - :END: - -#+BEGIN_SRC dot :file "011-hetero-homo.eps" :cmdline "-Kdot -Teps" -digraph G { -rankdir=TB; -ranksep=0.3; - -node [shape=box margin=0 height=0.25]; -A; B; C; - -node [shape=ellipse]; -GMat0; -GMat1; -GMat2; -GMat3; - -GMat0 -> A -> GMat1 -> B -> GMat2; -GMat2 -> C; -GMat0 -> C -> GMat3 - -subgraph cluster {style=filled;color=azure2; A; GMat1; B; GMat2; C}; -} -#+END_SRC - -All operations are handled by the same backend. - -*** :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.18 - :END: - -#+BEGIN_SRC dot :file "012-hetero-a.eps" :cmdline "-Kdot -Teps" -digraph G { -rankdir=TB; -ranksep=0.3; - -node [shape=box margin=0 height=0.25]; -A; B; C; - -node [shape=ellipse]; -GMat0; -GMat1; -GMat2; -GMat3; - -GMat0 -> A -> GMat1 -> B -> GMat2; -GMat2 -> C; -GMat0 -> C -> GMat3 - -subgraph cluster_1 {style=filled;color=azure2; A; GMat1; B; } -subgraph cluster_2 {style=filled;color=ivory2; C}; -} -#+END_SRC - -~A~ & ~B~ are of backend ~1~, ~C~ is of backend ~2~. - -*** :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.18 - :END: - -#+BEGIN_SRC dot :file "013-hetero-b.eps" :cmdline "-Kdot -Teps" -digraph G { -rankdir=TB; -ranksep=0.3; - -node [shape=box margin=0 height=0.25]; -A; B; C; - -node [shape=ellipse]; -GMat0; -GMat1; -GMat2; -GMat3; - -GMat0 -> A -> GMat1 -> B -> GMat2; -GMat2 -> C; -GMat0 -> C -> GMat3 - -subgraph cluster_1 {style=filled;color=azure2; A}; -subgraph cluster_2 {style=filled;color=ivory2; B}; -subgraph cluster_3 {style=filled;color=azure2; C}; -} -#+END_SRC - -~A~ & ~C~ are of backend ~1~, ~B~ is of backend ~2~. - -** Heterogeneity in G-API - -*** Heterogeneity summary - -- G-API automatically partitions its graph in subgraphs (called "islands") - based on the available kernels; -- Adjacent kernels taken from the same backend are "fused" into the same - "island"; -- G-API implements a two-level execution model: - - Islands are executed at the top level by a G-API's *Executor*; - - Island internals are run at the bottom level by its *Backend*; -- G-API fully delegates the low-level execution and memory management to backends. - -* Inference and Streaming - -** Inference with G-API - -*** In-graph inference example - -- Starting with OpencV 4.2 (2019), G-API allows to integrate ~infer~ - operations into the graph: - #+LaTeX: {\scriptsize - #+BEGIN_SRC C++ - G_API_NET(ObjDetect, , "pdf.example.od"); - - cv::GMat in; - cv::GMat blob = cv::gapi::infer(bgr); - cv::GOpaque size = cv::gapi::streaming::size(bgr); - cv::GArray objs = cv::gapi::streaming::parseSSD(blob, size); - cv::GComputation pipelne(cv::GIn(in), cv::GOut(objs)); - #+END_SRC - #+LaTeX: } -- Starting with OpenCV 4.5 (2020), G-API will provide more streaming- - and NN-oriented operations out of the box. - -** Inference with G-API - -*** What is the difference? - -- ~ObjDetect~ is not an operation, ~cv::gapi::infer~ is; -- ~cv::gapi::infer~ is a *generic* operation, where ~T=ObjDetect~ describes - the calling convention: - - How many inputs the network consumes, - - How many outputs the network produces. -- Inference data types are ~GMat~ only: - - Representing an image, then preprocessed automatically; - - Representing a blob (n-dimensional ~Mat~), then passed as-is. -- Inference *backends* only need to implement a single generic operation ~infer~. - -** Inference with G-API - -*** But how does it run? - -- Since ~infer~ is an *Operation*, backends may provide *Kernels* implementing it; -- The only publicly available inference backend now is *OpenVINO™*: - - Brings its ~infer~ kernel atop of the Inference Engine; -- NN model data is passed through G-API compile arguments (like kernels); -- Every NN backend provides its own structure to configure the network (like - a kernel API). - -** Inference with G-API - -*** Passing OpenVINO™ parameters to G-API - -- ~ObjDetect~ example: - #+LaTeX: {\footnotesize - #+BEGIN_SRC C++ - auto face_net = cv::gapi::ie::Params { - face_xml_path, // path to the topology IR - face_bin_path, // path to the topology weights - face_device_string, // OpenVINO plugin (device) string - }; - auto networks = cv::gapi::networks(face_net); - pipeline.compile(.., cv::compile_args(..., networks)); - #+END_SRC - #+LaTeX: } -- ~AgeGender~ requires binding Op's outputs to NN layers: - #+LaTeX: {\footnotesize - #+BEGIN_SRC C++ - auto age_net = cv::gapi::ie::Params { - ... - }.cfgOutputLayers({"age_conv3", "prob"}); // array ! - #+END_SRC - #+LaTeX: } - -** Streaming with G-API - -#+BEGIN_SRC dot :file 020-fd-demo.eps :cmdline "-Kdot -Teps" -digraph { - rankdir=LR; - node [shape=box]; - - cap [label=Capture]; - dec [label=Decode]; - res [label=Resize]; - cnn [label=Infer]; - vis [label=Visualize]; - - cap -> dec; - dec -> res; - res -> cnn; - cnn -> vis; -} -#+END_SRC -Anatomy of a regular video analytics application - -** Streaming with G-API - -#+BEGIN_SRC dot :file 021-fd-serial.eps :cmdline "-Kdot -Teps" -digraph { - node [shape=box margin=0 width=0.3 height=0.4] - nodesep=0.2; - rankdir=LR; - - subgraph cluster0 { - colorscheme=blues9 - pp [label="..." shape=plaintext]; - v0 [label=V]; - label="Frame N-1"; - color=7; - } - - subgraph cluster1 { - colorscheme=blues9 - c1 [label=C]; - d1 [label=D]; - r1 [label=R]; - i1 [label=I]; - v1 [label=V]; - label="Frame N"; - color=6; - } - - subgraph cluster2 { - colorscheme=blues9 - c2 [label=C]; - nn [label="..." shape=plaintext]; - label="Frame N+1"; - color=5; - } - - c1 -> d1 -> r1 -> i1 -> v1; - - pp-> v0; - v0 -> c1 [style=invis]; - v1 -> c2 [style=invis]; - c2 -> nn; -} -#+END_SRC -Serial execution of the sample video analytics application - -** Streaming with G-API - :PROPERTIES: - :BEAMER_opt: shrink - :END: - -#+BEGIN_SRC dot :file 022-fd-pipelined.eps :cmdline "-Kdot -Teps" -digraph { - nodesep=0.2; - ranksep=0.2; - node [margin=0 width=0.4 height=0.2]; - node [shape=plaintext] - Camera [label="Camera:"]; - GPU [label="GPU:"]; - FPGA [label="FPGA:"]; - CPU [label="CPU:"]; - Time [label="Time:"]; - t6 [label="T6"]; - t7 [label="T7"]; - t8 [label="T8"]; - t9 [label="T9"]; - t10 [label="T10"]; - tnn [label="..."]; - - node [shape=box margin=0 width=0.4 height=0.4 colorscheme=blues9] - node [color=9] V3; - node [color=8] F4; V4; - node [color=7] DR5; F5; V5; - node [color=6] C6; DR6; F6; V6; - node [color=5] C7; DR7; F7; V7; - node [color=4] C8; DR8; F8; - node [color=3] C9; DR9; - node [color=2] C10; - - {rank=same; rankdir=LR; Camera C6 C7 C8 C9 C10} - Camera -> C6 -> C7 -> C8 -> C9 -> C10 [style=invis]; - - {rank=same; rankdir=LR; GPU DR5 DR6 DR7 DR8 DR9} - GPU -> DR5 -> DR6 -> DR7 -> DR8 -> DR9 [style=invis]; - - C6 -> DR5 [style=invis]; - C6 -> DR6 [constraint=false]; - C7 -> DR7 [constraint=false]; - C8 -> DR8 [constraint=false]; - C9 -> DR9 [constraint=false]; - - {rank=same; rankdir=LR; FPGA F4 F5 F6 F7 F8} - FPGA -> F4 -> F5 -> F6 -> F7 -> F8 [style=invis]; - - DR5 -> F4 [style=invis]; - DR5 -> F5 [constraint=false]; - DR6 -> F6 [constraint=false]; - DR7 -> F7 [constraint=false]; - DR8 -> F8 [constraint=false]; - - {rank=same; rankdir=LR; CPU V3 V4 V5 V6 V7} - CPU -> V3 -> V4 -> V5 -> V6 -> V7 [style=invis]; - - F4 -> V3 [style=invis]; - F4 -> V4 [constraint=false]; - F5 -> V5 [constraint=false]; - F6 -> V6 [constraint=false]; - F7 -> V7 [constraint=false]; - - {rank=same; rankdir=LR; Time t6 t7 t8 t9 t10 tnn} - Time -> t6 -> t7 -> t8 -> t9 -> t10 -> tnn [style=invis]; - - CPU -> Time [style=invis]; - V3 -> t6 [style=invis]; - V4 -> t7 [style=invis]; - V5 -> t8 [style=invis]; - V6 -> t9 [style=invis]; - V7 -> t10 [style=invis]; -} -#+END_SRC -Pipelined execution for the video analytics application - -** Streaming with G-API: Example - -**** Serial mode (4.0) :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.45 - :END: -#+LaTeX: {\tiny -#+BEGIN_SRC C++ -pipeline = cv::GComputation(...); - -cv::VideoCapture cap(input); -cv::Mat in_frame; -std::vector out_faces; - -while (cap.read(in_frame)) { - pipeline.apply(cv::gin(in_frame), - cv::gout(out_faces), - cv::compile_args(kernels, - networks)); - // Process results - ... -} -#+END_SRC -#+LaTeX: } - -**** Streaming mode (since 4.2) :B_block:BMCOL: - :PROPERTIES: - :BEAMER_env: block - :BEAMER_col: 0.45 - :END: -#+LaTeX: {\tiny -#+BEGIN_SRC C++ -pipeline = cv::GComputation(...); - -auto in_src = cv::gapi::wip::make_src - (input) -auto cc = pipeline.compileStreaming - (cv::compile_args(kernels, networks)) -cc.setSource(cv::gin(in_src)); -cc.start(); - -std::vector out_faces; -while (cc.pull(cv::gout(out_faces))) { - // Process results - ... -} -#+END_SRC -#+LaTeX: } - -**** More information - -#+LaTeX: {\footnotesize -https://opencv.org/hybrid-cv-dl-pipelines-with-opencv-4-4-g-api/ -#+LaTeX: } - -* Latest features -** Latest features -*** Python API - -- Initial Python3 binding is available now in ~master~ (future 4.5); -- Only basic CV functionality is supported (~core~ & ~imgproc~ namespaces, - selecting backends); -- Adding more programmability, inference, and streaming is next. - -** Latest features -*** Python API - -#+LaTeX: {\footnotesize -#+BEGIN_SRC Python -import numpy as np -import cv2 as cv - -sz = (1280, 720) -in1 = np.random.randint(0, 100, sz).astype(np.uint8) -in2 = np.random.randint(0, 100, sz).astype(np.uint8) - -g_in1 = cv.GMat() -g_in2 = cv.GMat() -g_out = cv.gapi.add(g_in1, g_in2) -gr = cv.GComputation(g_in1, g_in2, g_out) - -pkg = cv.gapi.core.fluid.kernels() -out = gr.apply(in1, in2, args=cv.compile_args(pkg)) -#+END_SRC -#+LaTeX: } - -* Understanding the "G-Effect" - -** Understanding the "G-Effect" - -*** What is "G-Effect"? - -- G-API is not only an API, but also an /implementation/; - - i.e. it does some work already! -- We call "G-Effect" any measurable improvement which G-API demonstrates - against traditional methods; -- So far the list is: - - Memory consumption; - - Performance; - - Programmer efforts. - -Note: in the following slides, all measurements are taken on -Intel\textregistered{} Core\texttrademark-i5 6600 CPU. - -** Understanding the "G-Effect" -# FIXME - -*** Memory consumption: Sobel Edge Detector - -- G-API/Fluid backend is designed to minimize footprint: -#+LaTeX: {\footnotesize -| Input | OpenCV | G-API/Fluid | Factor | -| | MiB | MiB | Times | -|-------------+--------+-------------+--------| -| 512 x 512 | 17.33 | 0.59 | 28.9x | -| 640 x 480 | 20.29 | 0.62 | 32.8x | -| 1280 x 720 | 60.73 | 0.72 | 83.9x | -| 1920 x 1080 | 136.53 | 0.83 | 164.7x | -| 3840 x 2160 | 545.88 | 1.22 | 447.4x | -#+LaTeX: } -- The detector itself can be written manually in two ~for~ - loops, but G-API covers cases more complex than that; -- OpenCV code requires changes to shrink footprint. - -** Understanding the "G-Effect" - -*** Performance: Sobel Edge Detector - -- G-API/Fluid backend also optimizes cache reuse: - -#+LaTeX: {\footnotesize -| Input | OpenCV | G-API/Fluid | Factor | -| | ms | ms | Times | -|-------------+--------+-------------+--------| -| 320 x 240 | 1.16 | 0.53 | 2.17x | -| 640 x 480 | 5.66 | 1.89 | 2.99x | -| 1280 x 720 | 17.24 | 5.26 | 3.28x | -| 1920 x 1080 | 39.04 | 12.29 | 3.18x | -| 3840 x 2160 | 219.57 | 51.22 | 4.29x | -#+LaTeX: } - -- The more data is processed, the bigger "G-Effect" is. - -** Understanding the "G-Effect" - -*** Relative speed-up based on cache efficiency - -#+BEGIN_LATEX -\begin{figure} - \begin{tikzpicture} - \begin{axis}[ - xlabel={Image size}, - ylabel={Relative speed-up}, - nodes near coords, - width=0.8\textwidth, - xtick=data, - xticklabels={QVGA, VGA, HD, FHD, UHD}, - height=4.5cm, - ] - - \addplot plot coordinates {(1, 1.0) (2, 1.38) (3, 1.51) (4, 1.46) (5, 1.97)}; - - \end{axis} - \end{tikzpicture} -\end{figure} -#+END_LATEX - -The higher resolution is, the higher relative speed-up is (with -speed-up on QVGA taken as 1.0). - -* Resources on G-API - -** Resources on G-API - :PROPERTIES: - :BEAMER_opt: shrink - :END: -*** Repository - -- https://github.com/opencv/opencv (see ~modules/gapi~) - -*** Article - -- https://opencv.org/hybrid-cv-dl-pipelines-with-opencv-4-4-g-api/ - -*** Documentation - -- https://docs.opencv.org/4.4.0/d0/d1e/gapi.html - -*** Tutorials -- https://docs.opencv.org/4.4.0/df/d7e/tutorial_table_of_content_gapi.html - -* Thank you! diff --git a/modules/gapi/doc/slides/get_sty.sh b/modules/gapi/doc/slides/get_sty.sh deleted file mode 100755 index 0b97cf3ece..0000000000 --- a/modules/gapi/doc/slides/get_sty.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env bash - -set -e - -MTHEME_VER=2fa6084b9d34fec9d2d5470eb9a17d0bf712b6c8 -MTHEME_DIR=mtheme.sty - -function make_sty { - if [ -d "$MTHEME_DIR" ]; then rm -rf "$MTHEME_DIR"; fi - mkdir "$MTHEME_DIR" - - # Download template from Github - tmp_dir=$(mktemp -d) - wget -P "$tmp_dir" -c https://github.com/matze/mtheme/archive/${MTHEME_VER}.tar.gz - pushd "$tmp_dir" - tar -xzvf "$MTHEME_VER.tar.gz" - popd - make -C "$tmp_dir"/mtheme-"$MTHEME_VER" - cp -v "$tmp_dir"/mtheme-"$MTHEME_VER"/*.sty "$MTHEME_DIR" - rm -r "$tmp_dir" - # Put our own .gitignore to ignore this directory completely - echo "*" > "$MTHEME_DIR/.gitignore" -} - -make_sty diff --git a/modules/gapi/doc/slides/ocv_logo.eps b/modules/gapi/doc/slides/ocv_logo.eps deleted file mode 100644 index 67005bd3d0..0000000000 --- a/modules/gapi/doc/slides/ocv_logo.eps +++ /dev/null @@ -1,181 +0,0 @@ -%!PS-Adobe-3.0 EPSF-3.0 -%%Creator: cairo 1.14.6 (http://cairographics.org) -%%CreationDate: Wed Dec 12 17:03:17 2018 -%%Pages: 1 -%%DocumentData: Clean7Bit -%%LanguageLevel: 2 -%%BoundingBox: 0 -1 598 739 -%%EndComments -%%BeginProlog -save -50 dict begin -/q { gsave } bind def -/Q { grestore } bind def -/cm { 6 array astore concat } bind def -/w { setlinewidth } bind def -/J { setlinecap } bind def -/j { setlinejoin } bind def -/M { setmiterlimit } bind def -/d { setdash } bind def -/m { moveto } bind def -/l { lineto } bind def -/c { curveto } bind def -/h { closepath } bind def -/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto - 0 exch rlineto 0 rlineto closepath } bind def -/S { stroke } bind def -/f { fill } bind def -/f* { eofill } bind def -/n { newpath } bind def -/W { clip } bind def -/W* { eoclip } bind def -/BT { } bind def -/ET { } bind def -/pdfmark where { pop globaldict /?pdfmark /exec load put } - { globaldict begin /?pdfmark /pop load def /pdfmark - /cleartomark load def end } ifelse -/BDC { mark 3 1 roll /BDC pdfmark } bind def -/EMC { mark /EMC pdfmark } bind def -/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def -/Tj { show currentpoint cairo_store_point } bind def -/TJ { - { - dup - type /stringtype eq - { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse - } forall - currentpoint cairo_store_point -} bind def -/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore - cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def -/Tf { pop /cairo_font exch def /cairo_font_matrix where - { pop cairo_selectfont } if } bind def -/Td { matrix translate cairo_font_matrix matrix concatmatrix dup - /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point - /cairo_font where { pop cairo_selectfont } if } bind def -/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def - cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def -/g { setgray } bind def -/rg { setrgbcolor } bind def -/d1 { setcachedevice } bind def -%%EndProlog -%%BeginSetup -%%EndSetup -%%Page: 1 1 -%%BeginPageSetup -%%PageBoundingBox: 0 -1 598 739 -%%EndPageSetup -q 0 -1 598 740 rectclip q -1 0.00392157 0.00392157 rg -225.648 478.363 m 171.051 509.887 144.43 574.156 160.746 635.051 c 177.066 - 695.945 232.254 738.277 295.301 738.277 c 358.348 738.277 413.535 695.945 - 429.855 635.051 c 446.172 574.156 419.551 509.887 364.949 478.363 c 323.008 - 551.008 l 344.73 563.547 355.324 589.117 348.832 613.34 c 342.34 637.566 - 320.383 654.41 295.301 654.41 c 270.219 654.41 248.262 637.566 241.77 613.34 - c 235.277 589.117 245.871 563.547 267.59 551.008 c h -225.648 478.363 m f -0.00392157 0.00392157 1 rg -523.949 444.637 m 578.551 413.113 605.172 348.844 588.855 287.949 c 572.535 - 227.055 517.348 184.723 454.301 184.723 c 391.254 184.723 336.066 227.055 - 319.746 287.949 c 303.43 348.844 330.051 413.113 384.648 444.637 c 426.59 - 371.992 l 404.871 359.453 394.277 333.883 400.77 309.66 c 407.262 285.434 - 429.219 268.59 454.301 268.59 c 479.383 268.59 501.34 285.434 507.832 309.66 - c 514.324 333.883 503.73 359.453 482.008 371.992 c h -523.949 444.637 m f -0.00392157 1 0.00392157 rg -278.602 324 m 278.602 260.953 236.254 205.762 175.359 189.449 c 114.461 - 173.133 50.207 199.762 18.684 254.363 c -12.84 308.961 -3.773 377.922 40.805 - 422.504 c 85.383 467.082 154.352 476.164 208.949 444.637 c 167.008 371.992 - l 145.289 384.535 117.852 380.922 100.117 363.188 c 82.383 345.453 78.773 - 318.016 91.316 296.297 c 103.855 274.574 129.418 263.98 153.645 270.473 - c 177.871 276.961 194.719 298.918 194.719 324 c h -278.602 324 m f -0.0196078 g -39.781 151.301 m 51.57 152.359 63.492 152.352 75.223 150.672 c 82.449 149.391 - 90.121 147.52 95.551 142.25 c 101.242 135.898 102.641 127.078 103.891 118.949 - c 105.941 102.078 105.699 84.969 103.891 68.09 c 102.68 59.852 101.492 -50.949 96.09 44.25 c 90.199 38.27 81.5 36.57 73.52 35.309 c 61.742 33.84 - 49.789 33.5 37.961 34.68 c 29.949 35.5 21.59 36.91 14.77 41.48 c 10.359 - 44.281 7.992 49.219 6.379 54.012 c 3.152 63.988 2.742 74.59 2.301 84.988 - c 2.25 98.73 2.512 112.609 5.191 126.129 c 6.641 132.441 8.402 139.379 -13.73 143.59 c 21.242 149.039 30.789 150.359 39.781 151.301 c h -41.73 132.469 m 51.723 133.27 61.922 133.512 71.801 131.57 c 75.629 130.801 - 80.152 128.941 80.871 124.578 c 83.871 112.309 83.172 99.531 83.289 86.988 - c 82.922 78.07 83.129 68.852 80.141 60.309 c 77.531 54.699 70.422 54.238 - 65.062 53.422 c 54.312 52.809 43.152 52.27 32.723 55.461 c 27.91 56.73 -26.391 61.891 25.652 66.219 c 23.652 79.051 24.301 92.102 24.551 105.031 - c 25.082 112.281 24.992 119.801 27.602 126.691 c 30.59 131.309 36.77 131.719 - 41.73 132.469 c h -41.73 132.469 m f* -147.07 112.219 m 154.23 116.77 163.121 117.512 171.379 116.762 c 179.09 - 116.102 187.652 113.48 191.781 106.379 c 196.711 97.469 196.992 86.941 -197.332 77 c 197.109 66.781 196.922 56.109 192.699 46.609 c 190.289 40.84 - 184.75 37.059 178.82 35.57 c 169.742 33.34 159.762 33.102 151.012 36.719 - c 146.281 38.57 143.012 42.59 140.301 46.711 c 140.301 0 l 120.301 0 l -120.312 38.66 120.281 77.328 120.312 115.988 c 126.781 116.02 133.25 116.02 - 139.711 115.988 c 139.492 112.012 139.27 108.039 139.16 104.051 c 141.562 - 106.98 143.789 110.199 147.07 112.219 c h -153.582 101.781 m 159.18 102.211 165.102 102.328 170.34 100.02 c 173.66 - 98.59 175.41 95.078 176 91.68 c 177.742 82.91 177.52 73.852 176.902 64.969 - c 176.281 59.609 175.422 52.672 169.52 50.59 c 162.699 48.359 154.922 48.219 - 148.18 50.828 c 141.91 53.469 141.18 61.059 140.562 66.949 c 140.191 75.988 - 139.742 85.289 142.289 94.07 c 143.641 99.051 148.82 101.41 153.582 101.781 - c h -153.582 101.781 m f* -221.262 112.07 m 231.09 117.121 242.602 117.301 253.391 116.789 c 262.371 - 116.039 273.27 114.539 278.223 105.949 c 283.801 95.578 282.891 83.379 -283.672 72 c 228.961 72 l 229.602 66.129 228.84 59.801 231.801 54.422 c -234.332 50.172 239.699 49.301 244.242 49.051 c 249.852 49.012 255.891 48.551 - 261.062 51.16 c 264.02 53.48 264.039 57.602 264.422 61 c 270.82 61.012 -277.223 61.012 283.621 61 c 283.379 54.32 282.52 46.84 277.16 42.141 c 269.109 - 34.922 257.59 34.172 247.289 33.969 c 238.199 34.238 228.602 34.699 220.461 - 39.18 c 213.871 43.07 211.77 51.059 210.609 58.102 c 209.141 68.559 208.77 - 79.219 210.02 89.719 c 211.039 98.012 213.27 107.762 221.262 112.07 c h -232.949 99.34 m 238.41 102.66 245.172 101.988 251.301 101.898 c 255.102 - 101.488 259.73 101.27 262.199 97.91 c 264.723 93.762 264.27 88.68 264.289 - 84.02 c 252.52 84 240.762 83.969 229 84.031 c 229.18 89.211 228.77 95.531 - 232.949 99.34 c h -232.949 99.34 m f* -326.262 112.121 m 333.18 116.922 342.121 117.59 350.262 116.648 c 357.191 - 115.922 364.531 113.281 368.621 107.301 c 372.25 102.34 373.262 96.02 373.312 - 90.012 c 373.281 71.672 373.32 53.34 373.301 35 c 366.961 34.988 360.629 - 34.988 354.312 35 c 354.281 52.352 354.332 69.691 354.281 87.031 c 354.09 - 90.82 354.242 95.199 351.391 98.121 c 348.352 101.41 343.582 102.051 339.332 - 102.02 c 334.191 102.051 328.629 101.172 324.672 97.621 c 320.801 94.32 - 319.332 89 319.312 84.078 c 319.281 67.719 319.32 51.359 319.289 35.012 - c 312.961 34.988 306.629 34.988 300.312 35 c 300.301 62 300.301 89 300.312 - 116 c 306.531 116.02 312.762 116.012 318.98 116 c 318.949 111.262 318.48 - 106.551 318.34 101.809 c 320.379 105.641 322.52 109.68 326.262 112.121 -c h -326.262 112.121 m f* -407.691 147.602 m 418.172 151.121 429.34 151.621 440.301 152.012 c 450.922 - 151.961 462.02 151.859 471.941 147.578 c 476.98 145.48 480.473 140.879 -482.172 135.801 c 484.941 128.211 485.02 119.988 485.082 112 c 477.77 112 - 470.461 111.98 463.16 112.012 c 463.039 117.629 463.473 123.93 459.992 -128.711 c 456.473 132.309 450.973 132.301 446.301 132.852 c 436.801 133.031 - 426.91 133.641 417.812 130.359 c 414.531 129.32 412.832 126.039 412.172 - 122.879 c 410.301 114.398 410.289 105.648 410.301 97 c 410.41 85.441 410.23 - 73.711 412.699 62.34 c 413.352 58.18 417.18 55.621 421.02 54.699 c 429.902 - 52.488 439.172 52.809 448.242 53.352 c 452.973 53.969 458.73 54.281 461.699 - 58.621 c 464.871 63.801 464.34 70.172 464.172 75.988 c 471.551 76.02 478.922 - 76.012 486.301 75.988 c 486.211 66.801 486.051 57.309 482.711 48.609 c -480.992 44.059 477.441 40.199 472.84 38.461 c 463.812 34.84 453.91 34.609 - 444.332 34.031 c 433.223 33.84 421.973 34.109 411.109 36.699 c 404.742 -38.359 397.781 41.281 394.832 47.609 c 391.062 55.98 390.371 65.289 389.402 - 74.301 c 388.59 86.199 388.07 98.121 388.359 110.039 c 388.93 119.691 389.812 - 129.859 395.02 138.27 c 397.789 142.949 402.652 145.879 407.691 147.602 - c h -407.691 147.602 m f* -489.902 150.969 m 497.52 150.961 505.141 151.18 512.75 150.859 c 520.16 - 127.352 528.301 104.078 535.781 80.602 c 538.691 71.578 540.75 62.301 543.762 - 53.309 c 547.129 63.012 549.289 73.09 552.59 82.809 c 559.902 105.52 567.41 - 128.16 574.711 150.871 c 582.23 151.191 589.77 150.91 597.301 151.012 c - 597.301 148.52 l 584.922 110.789 572.832 72.961 560.699 35.141 c 549.379 - 34.91 538.039 34.879 526.723 35.16 c 514.66 73.828 502.02 112.32 489.902 - 150.969 c h -489.902 150.969 m f* -Q Q -showpage -%%Trailer -end restore -%%EOF diff --git a/modules/gapi/include/opencv2/gapi.hpp b/modules/gapi/include/opencv2/gapi.hpp deleted file mode 100644 index 2087641023..0000000000 --- a/modules/gapi/include/opencv2/gapi.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2021 Intel Corporation - - -#ifndef OPENCV_GAPI_HPP -#define OPENCV_GAPI_HPP - -#include - -/** \defgroup gapi_ref G-API framework -@{ - @defgroup gapi_main_classes G-API Main Classes - @defgroup gapi_data_objects G-API Data Types - @{ - @defgroup gapi_meta_args G-API Metadata Descriptors - @} - @defgroup gapi_std_backends G-API Standard Backends - @defgroup gapi_compile_args G-API Graph Compilation Arguments - @defgroup gapi_serialization G-API Serialization functionality -@} - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -// Include these files here to avoid cyclic dependency between -// Desync & GKernel & GComputation & GStreamingCompiled. -#include -#include - -#endif // OPENCV_GAPI_HPP diff --git a/modules/gapi/include/opencv2/gapi/core.hpp b/modules/gapi/include/opencv2/gapi/core.hpp deleted file mode 100644 index 60bb2c5074..0000000000 --- a/modules/gapi/include/opencv2/gapi/core.hpp +++ /dev/null @@ -1,1911 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_CORE_HPP -#define OPENCV_GAPI_CORE_HPP - -#include -#include // std::tuple - -#include -#include - -#include -#include -#include -#include - -/** \defgroup gapi_core G-API Core functionality -@{ - @defgroup gapi_math Graph API: Math operations - @defgroup gapi_pixelwise Graph API: Pixelwise operations - @defgroup gapi_matrixop Graph API: Operations on matrices - @defgroup gapi_transform Graph API: Image and channel composition functions -@} - */ - -namespace cv { namespace gapi { -/** - * @brief This namespace contains G-API Operation Types for OpenCV - * Core module functionality. - */ -namespace core { - using GResize = cv::gapi::imgproc::GResize; - using GResizeP = cv::gapi::imgproc::GResizeP; - - using GMat2 = std::tuple; - using GMat3 = std::tuple; // FIXME: how to avoid this? - using GMat4 = std::tuple; - using GMatScalar = std::tuple; - - G_TYPED_KERNEL(GAdd, , "org.opencv.core.math.add") { - static GMatDesc outMeta(GMatDesc a, GMatDesc b, int ddepth) { - if (ddepth == -1) - { - // OpenCV: When the input arrays in add/subtract/multiply/divide - // functions have different depths, the output array depth must be - // explicitly specified! - // See artim_op() @ arithm.cpp - GAPI_Assert(a.chan == b.chan); - GAPI_Assert(a.depth == b.depth); - return a; - } - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GAddC, , "org.opencv.core.math.addC") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc, int ddepth) { - GAPI_Assert(a.chan <= 4); - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GSub, , "org.opencv.core.math.sub") { - static GMatDesc outMeta(GMatDesc a, GMatDesc b, int ddepth) { - if (ddepth == -1) - { - // This macro should select a larger data depth from a and b - // considering the number of channels in the same - // FIXME!!! Clarify if it is valid for sub() - GAPI_Assert(a.chan == b.chan); - ddepth = std::max(a.depth, b.depth); - } - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GSubC, , "org.opencv.core.math.subC") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc, int ddepth) { - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GSubRC,, "org.opencv.core.math.subRC") { - static GMatDesc outMeta(GScalarDesc, GMatDesc b, int ddepth) { - return b.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GMul, , "org.opencv.core.math.mul") { - static GMatDesc outMeta(GMatDesc a, GMatDesc, double, int ddepth) { - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GMulCOld, , "org.opencv.core.math.mulCOld") { - static GMatDesc outMeta(GMatDesc a, double, int ddepth) { - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GMulC, , "org.opencv.core.math.mulC") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc, int ddepth) { - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GMulS, , "org.opencv.core.math.muls") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a; - } - }; // FIXME: Merge with MulC - - G_TYPED_KERNEL(GDiv, , "org.opencv.core.math.div") { - static GMatDesc outMeta(GMatDesc a, GMatDesc b, double, int ddepth) { - if (ddepth == -1) - { - GAPI_Assert(a.depth == b.depth); - return b; - } - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GDivC, , "org.opencv.core.math.divC") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc, double, int ddepth) { - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GDivRC, , "org.opencv.core.math.divRC") { - static GMatDesc outMeta(GScalarDesc, GMatDesc b, double, int ddepth) { - return b.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GMean, , "org.opencv.core.math.mean") { - static GScalarDesc outMeta(GMatDesc) { - return empty_scalar_desc(); - } - }; - - G_TYPED_KERNEL_M(GPolarToCart, , "org.opencv.core.math.polarToCart") { - static std::tuple outMeta(GMatDesc, GMatDesc a, bool) { - return std::make_tuple(a, a); - } - }; - - G_TYPED_KERNEL_M(GCartToPolar, , "org.opencv.core.math.cartToPolar") { - static std::tuple outMeta(GMatDesc x, GMatDesc, bool) { - return std::make_tuple(x, x); - } - }; - - G_TYPED_KERNEL(GPhase, , "org.opencv.core.math.phase") { - static GMatDesc outMeta(const GMatDesc &inx, const GMatDesc &, bool) { - return inx; - } - }; - - G_TYPED_KERNEL(GMask, , "org.opencv.core.pixelwise.mask") { - static GMatDesc outMeta(GMatDesc in, GMatDesc) { - return in; - } - }; - - G_TYPED_KERNEL(GCmpGT, , "org.opencv.core.pixelwise.compare.cmpGT") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpGE, , "org.opencv.core.pixelwise.compare.cmpGE") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpLE, , "org.opencv.core.pixelwise.compare.cmpLE") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpLT, , "org.opencv.core.pixelwise.compare.cmpLT") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpEQ, , "org.opencv.core.pixelwise.compare.cmpEQ") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpNE, , "org.opencv.core.pixelwise.compare.cmpNE") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpGTScalar, , "org.opencv.core.pixelwise.compare.cmpGTScalar") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpGEScalar, , "org.opencv.core.pixelwise.compare.cmpGEScalar") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpLEScalar, , "org.opencv.core.pixelwise.compare.cmpLEScalar") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpLTScalar, , "org.opencv.core.pixelwise.compare.cmpLTScalar") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpEQScalar, , "org.opencv.core.pixelwise.compare.cmpEQScalar") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GCmpNEScalar, , "org.opencv.core.pixelwise.compare.cmpNEScalar") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a.withDepth(CV_8U); - } - }; - - G_TYPED_KERNEL(GAnd, , "org.opencv.core.pixelwise.bitwise_and") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GAndS, , "org.opencv.core.pixelwise.bitwise_andS") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GOr, , "org.opencv.core.pixelwise.bitwise_or") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GOrS, , "org.opencv.core.pixelwise.bitwise_orS") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GXor, , "org.opencv.core.pixelwise.bitwise_xor") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GXorS, , "org.opencv.core.pixelwise.bitwise_xorS") { - static GMatDesc outMeta(GMatDesc a, GScalarDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GNot, , "org.opencv.core.pixelwise.bitwise_not") { - static GMatDesc outMeta(GMatDesc a) { - return a; - } - }; - - G_TYPED_KERNEL(GSelect, , "org.opencv.core.pixelwise.select") { - static GMatDesc outMeta(GMatDesc a, GMatDesc, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GMin, , "org.opencv.core.matrixop.min") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GMax, , "org.opencv.core.matrixop.max") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GAbsDiff, , "org.opencv.core.matrixop.absdiff") { - static GMatDesc outMeta(GMatDesc a, GMatDesc) { - return a; - } - }; - - G_TYPED_KERNEL(GAbsDiffC, , "org.opencv.core.matrixop.absdiffC") { - static GMatDesc outMeta(const GMatDesc& a, const GScalarDesc&) { - return a; - } - }; - - G_TYPED_KERNEL(GSum, , "org.opencv.core.matrixop.sum") { - static GScalarDesc outMeta(GMatDesc) { - return empty_scalar_desc(); - } - }; - - G_TYPED_KERNEL(GCountNonZero, (GMat)>, "org.opencv.core.matrixop.countNonZero") { - static GOpaqueDesc outMeta(GMatDesc in) { - GAPI_Assert(in.chan == 1); - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GAddW, , "org.opencv.core.matrixop.addweighted") { - static GMatDesc outMeta(GMatDesc a, double, GMatDesc b, double, double, int ddepth) { - if (ddepth == -1) - { - // OpenCV: When the input arrays in add/subtract/multiply/divide - // functions have different depths, the output array depth must be - // explicitly specified! - // See artim_op() @ arithm.cpp - GAPI_Assert(a.chan == b.chan); - GAPI_Assert(a.depth == b.depth); - return a; - } - return a.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GNormL1, , "org.opencv.core.matrixop.norml1") { - static GScalarDesc outMeta(GMatDesc) { - return empty_scalar_desc(); - } - }; - - G_TYPED_KERNEL(GNormL2, , "org.opencv.core.matrixop.norml2") { - static GScalarDesc outMeta(GMatDesc) { - return empty_scalar_desc(); - } - }; - - G_TYPED_KERNEL(GNormInf, , "org.opencv.core.matrixop.norminf") { - static GScalarDesc outMeta(GMatDesc) { - return empty_scalar_desc(); - } - }; - - G_TYPED_KERNEL_M(GIntegral, , "org.opencv.core.matrixop.integral") { - static std::tuple outMeta(GMatDesc in, int sd, int sqd) { - return std::make_tuple(in.withSizeDelta(1,1).withDepth(sd), - in.withSizeDelta(1,1).withDepth(sqd)); - } - }; - - G_TYPED_KERNEL(GThreshold, , "org.opencv.core.matrixop.threshold") { - static GMatDesc outMeta(GMatDesc in, GScalarDesc, GScalarDesc, int) { - return in; - } - }; - - - G_TYPED_KERNEL_M(GThresholdOT, , "org.opencv.core.matrixop.thresholdOT") { - static std::tuple outMeta(GMatDesc in, GScalarDesc, int) { - return std::make_tuple(in, empty_scalar_desc()); - } - }; - - G_TYPED_KERNEL(GInRange, , "org.opencv.core.matrixop.inrange") { - static GMatDesc outMeta(GMatDesc in, GScalarDesc, GScalarDesc) { - return in.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL_M(GSplit3, , "org.opencv.core.transform.split3") { - static std::tuple outMeta(GMatDesc in) { - const auto out_depth = in.depth; - const auto out_desc = in.withType(out_depth, 1); - return std::make_tuple(out_desc, out_desc, out_desc); - } - }; - - G_TYPED_KERNEL_M(GSplit4, ,"org.opencv.core.transform.split4") { - static std::tuple outMeta(GMatDesc in) { - const auto out_depth = in.depth; - const auto out_desc = in.withType(out_depth, 1); - return std::make_tuple(out_desc, out_desc, out_desc, out_desc); - } - }; - - G_TYPED_KERNEL(GMerge3, , "org.opencv.core.transform.merge3") { - static GMatDesc outMeta(GMatDesc in, GMatDesc, GMatDesc) { - // Preserve depth and add channel component - return in.withType(in.depth, 3); - } - }; - - G_TYPED_KERNEL(GMerge4, , "org.opencv.core.transform.merge4") { - static GMatDesc outMeta(GMatDesc in, GMatDesc, GMatDesc, GMatDesc) { - // Preserve depth and add channel component - return in.withType(in.depth, 4); - } - }; - - G_TYPED_KERNEL(GRemap, , "org.opencv.core.transform.remap") { - static GMatDesc outMeta(GMatDesc in, Mat m1, Mat, int, int, Scalar) { - return in.withSize(m1.size()); - } - }; - - G_TYPED_KERNEL(GFlip, , "org.opencv.core.transform.flip") { - static GMatDesc outMeta(GMatDesc in, int) { - return in; - } - }; - - // TODO: eliminate the need in this kernel (streaming) - G_TYPED_KERNEL(GCrop, , "org.opencv.core.transform.crop") { - static GMatDesc outMeta(GMatDesc in, Rect rc) { - return in.withSize(Size(rc.width, rc.height)); - } - }; - - G_TYPED_KERNEL(GConcatHor, , "org.opencv.imgproc.transform.concatHor") { - static GMatDesc outMeta(GMatDesc l, GMatDesc r) { - return l.withSizeDelta(+r.size.width, 0); - } - }; - - G_TYPED_KERNEL(GConcatVert, , "org.opencv.imgproc.transform.concatVert") { - static GMatDesc outMeta(GMatDesc t, GMatDesc b) { - return t.withSizeDelta(0, +b.size.height); - } - }; - - G_TYPED_KERNEL(GLUT, , "org.opencv.core.transform.LUT") { - static GMatDesc outMeta(GMatDesc in, Mat) { - return in; - } - }; - - G_TYPED_KERNEL(GConvertTo, , "org.opencv.core.transform.convertTo") { - static GMatDesc outMeta(GMatDesc in, int rdepth, double, double) { - return rdepth < 0 ? in : in.withDepth(rdepth); - } - }; - - G_TYPED_KERNEL(GSqrt, , "org.opencv.core.math.sqrt") { - static GMatDesc outMeta(GMatDesc in) { - return in; - } - }; - - G_TYPED_KERNEL(GNormalize, , "org.opencv.core.normalize") { - static GMatDesc outMeta(GMatDesc in, double, double, int, int ddepth) { - // unlike opencv doesn't have a mask as a parameter - return (ddepth < 0 ? in : in.withDepth(ddepth)); - } - }; - - G_TYPED_KERNEL(GWarpPerspective, , "org.opencv.core.warpPerspective") { - static GMatDesc outMeta(GMatDesc in, const Mat&, Size dsize, int, int borderMode, const cv::Scalar&) { - GAPI_Assert((borderMode == cv::BORDER_CONSTANT || borderMode == cv::BORDER_REPLICATE) && - "cv::gapi::warpPerspective supports only cv::BORDER_CONSTANT and cv::BORDER_REPLICATE border modes"); - return in.withType(in.depth, in.chan).withSize(dsize); - } - }; - - G_TYPED_KERNEL(GWarpAffine, , "org.opencv.core.warpAffine") { - static GMatDesc outMeta(GMatDesc in, const Mat&, Size dsize, int, int border_mode, const cv::Scalar&) { - GAPI_Assert(border_mode != cv::BORDER_TRANSPARENT && - "cv::BORDER_TRANSPARENT mode is not supported in cv::gapi::warpAffine"); - return in.withType(in.depth, in.chan).withSize(dsize); - } - }; - - G_TYPED_KERNEL( - GKMeansND, - ,GMat,GMat>(GMat,int,GMat,TermCriteria,int,KmeansFlags)>, - "org.opencv.core.kmeansND") { - - static std::tuple - outMeta(const GMatDesc& in, int K, const GMatDesc& bestLabels, const TermCriteria&, int, - KmeansFlags flags) { - GAPI_Assert(in.depth == CV_32F); - std::vector amount_n_dim = detail::checkVector(in); - int amount = amount_n_dim[0], dim = amount_n_dim[1]; - if (amount == -1) // Mat with height != 1, width != 1, channels != 1 given - { // which means that kmeans will consider the following: - amount = in.size.height; - dim = in.size.width * in.chan; - } - // kmeans sets these labels' sizes when no bestLabels given: - GMatDesc out_labels(CV_32S, 1, Size{1, amount}); - // kmeans always sets these centers' sizes: - GMatDesc centers (CV_32F, 1, Size{dim, K}); - if (flags & KMEANS_USE_INITIAL_LABELS) - { - GAPI_Assert(bestLabels.depth == CV_32S); - int labels_amount = detail::checkVector(bestLabels, 1u); - GAPI_Assert(labels_amount == amount); - out_labels = bestLabels; // kmeans preserves bestLabels' sizes if given - } - return std::make_tuple(empty_gopaque_desc(), out_labels, centers); - } - }; - - G_TYPED_KERNEL( - GKMeansNDNoInit, - ,GMat,GMat>(GMat,int,TermCriteria,int,KmeansFlags)>, - "org.opencv.core.kmeansNDNoInit") { - - static std::tuple - outMeta(const GMatDesc& in, int K, const TermCriteria&, int, KmeansFlags flags) { - GAPI_Assert( !(flags & KMEANS_USE_INITIAL_LABELS) ); - GAPI_Assert(in.depth == CV_32F); - std::vector amount_n_dim = detail::checkVector(in); - int amount = amount_n_dim[0], dim = amount_n_dim[1]; - if (amount == -1) // Mat with height != 1, width != 1, channels != 1 given - { // which means that kmeans will consider the following: - amount = in.size.height; - dim = in.size.width * in.chan; - } - GMatDesc out_labels(CV_32S, 1, Size{1, amount}); - GMatDesc centers (CV_32F, 1, Size{dim, K}); - return std::make_tuple(empty_gopaque_desc(), out_labels, centers); - } - }; - - G_TYPED_KERNEL(GKMeans2D, ,GArray,GArray> - (GArray,int,GArray,TermCriteria,int,KmeansFlags)>, - "org.opencv.core.kmeans2D") { - static std::tuple - outMeta(const GArrayDesc&,int,const GArrayDesc&,const TermCriteria&,int,KmeansFlags) { - return std::make_tuple(empty_gopaque_desc(), empty_array_desc(), empty_array_desc()); - } - }; - - G_TYPED_KERNEL(GKMeans3D, ,GArray,GArray> - (GArray,int,GArray,TermCriteria,int,KmeansFlags)>, - "org.opencv.core.kmeans3D") { - static std::tuple - outMeta(const GArrayDesc&,int,const GArrayDesc&,const TermCriteria&,int,KmeansFlags) { - return std::make_tuple(empty_gopaque_desc(), empty_array_desc(), empty_array_desc()); - } - }; - - G_TYPED_KERNEL(GTranspose, , "org.opencv.core.transpose") { - static GMatDesc outMeta(GMatDesc in) { - return in.withSize({in.size.height, in.size.width}); - } - }; -} // namespace core - -namespace streaming { - -// Operations for Streaming (declared in this header for convenience) -G_TYPED_KERNEL(GSize, (GMat)>, "org.opencv.streaming.size") { - static GOpaqueDesc outMeta(const GMatDesc&) { - return empty_gopaque_desc(); - } -}; - -G_TYPED_KERNEL(GSizeR, (GOpaque)>, "org.opencv.streaming.sizeR") { - static GOpaqueDesc outMeta(const GOpaqueDesc&) { - return empty_gopaque_desc(); - } -}; - -G_TYPED_KERNEL(GSizeMF, (GFrame)>, "org.opencv.streaming.sizeMF") { - static GOpaqueDesc outMeta(const GFrameDesc&) { - return empty_gopaque_desc(); - } -}; -} // namespace streaming - -//! @addtogroup gapi_math -//! @{ - -/** @brief Calculates the per-element sum of two matrices. - -The function add calculates sum of two matrices of the same size and the same number of channels: -\f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] - -The function can be replaced with matrix expressions: - \f[\texttt{dst} = \texttt{src1} + \texttt{src2}\f] - -The input matrices and the output matrix can all have the same or different depths. For example, you -can add a 16-bit unsigned matrix to a 8-bit signed matrix and store the sum as a 32-bit -floating-point matrix. Depth of the output matrix is determined by the ddepth parameter. -If src1.depth() == src2.depth(), ddepth can be set to the default -1. In this case, the output matrix will have -the same depth as the input matrices. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.add" -@param src1 first input matrix. -@param src2 second input matrix. -@param ddepth optional depth of the output matrix. -@sa sub, addWeighted -*/ -GAPI_EXPORTS_W GMat add(const GMat& src1, const GMat& src2, int ddepth = -1); - -/** @brief Calculates the per-element sum of matrix and given scalar. - -The function addC adds a given scalar value to each element of given matrix. -The function can be replaced with matrix expressions: - - \f[\texttt{dst} = \texttt{src1} + \texttt{c}\f] - -Depth of the output matrix is determined by the ddepth parameter. -If ddepth is set to default -1, the depth of output matrix will be the same as the depth of input matrix. -The matrices can be single or multi channel. Output matrix must have the same size and number of channels as the input matrix. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.addC" -@param src1 first input matrix. -@param c scalar value to be added. -@param ddepth optional depth of the output matrix. -@sa sub, addWeighted -*/ -GAPI_EXPORTS_W GMat addC(const GMat& src1, const GScalar& c, int ddepth = -1); -//! @overload -GAPI_EXPORTS_W GMat addC(const GScalar& c, const GMat& src1, int ddepth = -1); - -/** @brief Calculates the per-element difference between two matrices. - -The function sub calculates difference between two matrices, when both matrices have the same size and the same number of -channels: - \f[\texttt{dst}(I) = \texttt{src1}(I) - \texttt{src2}(I)\f] - -The function can be replaced with matrix expressions: -\f[\texttt{dst} = \texttt{src1} - \texttt{src2}\f] - -The input matrices and the output matrix can all have the same or different depths. For example, you -can subtract two 8-bit unsigned matrices store the result as a 16-bit signed matrix. -Depth of the output matrix is determined by the ddepth parameter. -If src1.depth() == src2.depth(), ddepth can be set to the default -1. In this case, the output matrix will have -the same depth as the input matrices. The matrices can be single or multi channel. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.sub" -@param src1 first input matrix. -@param src2 second input matrix. -@param ddepth optional depth of the output matrix. -@sa add, addC - */ -GAPI_EXPORTS_W GMat sub(const GMat& src1, const GMat& src2, int ddepth = -1); - -/** @brief Calculates the per-element difference between matrix and given scalar. - -The function can be replaced with matrix expressions: - \f[\texttt{dst} = \texttt{src} - \texttt{c}\f] - -Depth of the output matrix is determined by the ddepth parameter. -If ddepth is set to default -1, the depth of output matrix will be the same as the depth of input matrix. -The matrices can be single or multi channel. Output matrix must have the same size as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.subC" -@param src first input matrix. -@param c scalar value to subtracted. -@param ddepth optional depth of the output matrix. -@sa add, addC, subRC - */ -GAPI_EXPORTS_W GMat subC(const GMat& src, const GScalar& c, int ddepth = -1); - -/** @brief Calculates the per-element difference between given scalar and the matrix. - -The function can be replaced with matrix expressions: - \f[\texttt{dst} = \texttt{c} - \texttt{src}\f] - -Depth of the output matrix is determined by the ddepth parameter. -If ddepth is set to default -1, the depth of output matrix will be the same as the depth of input matrix. -The matrices can be single or multi channel. Output matrix must have the same size as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.subRC" -@param c scalar value to subtract from. -@param src input matrix to be subtracted. -@param ddepth optional depth of the output matrix. -@sa add, addC, subC - */ -GAPI_EXPORTS_W GMat subRC(const GScalar& c, const GMat& src, int ddepth = -1); - -/** @brief Calculates the per-element scaled product of two matrices. - -The function mul calculates the per-element product of two matrices: - -\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\f] - -If src1.depth() == src2.depth(), ddepth can be set to the default -1. In this case, the output matrix will have -the same depth as the input matrices. The matrices can be single or multi channel. -Output matrix must have the same size as input matrices. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.mul" -@param src1 first input matrix. -@param src2 second input matrix of the same size and the same depth as src1. -@param scale optional scale factor. -@param ddepth optional depth of the output matrix. -@sa add, sub, div, addWeighted -*/ -GAPI_EXPORTS_W GMat mul(const GMat& src1, const GMat& src2, double scale = 1.0, int ddepth = -1); - -/** @brief Multiplies matrix by scalar. - -The function mulC multiplies each element of matrix src by given scalar value: - -\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I) \cdot \texttt{multiplier} )\f] - -The matrices can be single or multi channel. Output matrix must have the same size as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.mulC" -@param src input matrix. -@param multiplier factor to be multiplied. -@param ddepth optional depth of the output matrix. If -1, the depth of output matrix will be the same as input matrix depth. -@sa add, sub, div, addWeighted -*/ -GAPI_EXPORTS_W GMat mulC(const GMat& src, double multiplier, int ddepth = -1); -//! @overload -GAPI_EXPORTS_W GMat mulC(const GMat& src, const GScalar& multiplier, int ddepth = -1); // FIXME: merge with mulc -//! @overload -GAPI_EXPORTS_W GMat mulC(const GScalar& multiplier, const GMat& src, int ddepth = -1); // FIXME: merge with mulc - -/** @brief Performs per-element division of two matrices. - -The function divides one matrix by another: -\f[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\f] - -For integer types when src2(I) is zero, dst(I) will also be zero. -Floating point case returns Inf/NaN (according to IEEE). - -Different channels of -multi-channel matrices are processed independently. -The matrices can be single or multi channel. Output matrix must have the same size and depth as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.div" -@param src1 first input matrix. -@param src2 second input matrix of the same size and depth as src1. -@param scale scalar factor. -@param ddepth optional depth of the output matrix; you can only pass -1 when src1.depth() == src2.depth(). -@sa mul, add, sub -*/ -GAPI_EXPORTS_W GMat div(const GMat& src1, const GMat& src2, double scale, int ddepth = -1); - -/** @brief Divides matrix by scalar. - -The function divC divides each element of matrix src by given scalar value: - -\f[\texttt{dst(I) = saturate(src(I)*scale/divisor)}\f] - -When divisor is zero, dst(I) will also be zero. Different channels of -multi-channel matrices are processed independently. -The matrices can be single or multi channel. Output matrix must have the same size and depth as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.divC" -@param src input matrix. -@param divisor number to be divided by. -@param ddepth optional depth of the output matrix. If -1, the depth of output matrix will be the same as input matrix depth. -@param scale scale factor. -@sa add, sub, div, addWeighted -*/ -GAPI_EXPORTS_W GMat divC(const GMat& src, const GScalar& divisor, double scale, int ddepth = -1); - -/** @brief Divides scalar by matrix. - -The function divRC divides given scalar by each element of matrix src and keep the division result in new matrix of the same size and type as src: - -\f[\texttt{dst(I) = saturate(divident*scale/src(I))}\f] - -When src(I) is zero, dst(I) will also be zero. Different channels of -multi-channel matrices are processed independently. -The matrices can be single or multi channel. Output matrix must have the same size and depth as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.divRC" -@param src input matrix. -@param divident number to be divided. -@param ddepth optional depth of the output matrix. If -1, the depth of output matrix will be the same as input matrix depth. -@param scale scale factor -@sa add, sub, div, addWeighted -*/ -GAPI_EXPORTS_W GMat divRC(const GScalar& divident, const GMat& src, double scale, int ddepth = -1); - -/** @brief Applies a mask to a matrix. - -The function mask set value from given matrix if the corresponding pixel value in mask matrix set to true, -and set the matrix value to 0 otherwise. - -Supported src matrix data types are @ref CV_8UC1, @ref CV_16SC1, @ref CV_16UC1. Supported mask data type is @ref CV_8UC1. - -@note Function textual ID is "org.opencv.core.math.mask" -@param src input matrix. -@param mask input mask matrix. -*/ -GAPI_EXPORTS_W GMat mask(const GMat& src, const GMat& mask); - -/** @brief Calculates an average (mean) of matrix elements. - -The function mean calculates the mean value M of matrix elements, -independently for each channel, and return it. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.math.mean" -@param src input matrix. -@sa countNonZero, min, max -*/ -GAPI_EXPORTS_W GScalar mean(const GMat& src); - -/** @brief Calculates x and y coordinates of 2D vectors from their magnitude and angle. - -The function polarToCart calculates the Cartesian coordinates of each 2D -vector represented by the corresponding elements of magnitude and angle: -\f[\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\f] - -The relative accuracy of the estimated coordinates is about 1e-6. - -First output is a matrix of x-coordinates of 2D vectors. -Second output is a matrix of y-coordinates of 2D vectors. -Both output must have the same size and depth as input matrices. - -@note Function textual ID is "org.opencv.core.math.polarToCart" - -@param magnitude input floating-point @ref CV_32FC1 matrix (1xN) of magnitudes of 2D vectors; -@param angle input floating-point @ref CV_32FC1 matrix (1xN) of angles of 2D vectors. -@param angleInDegrees when true, the input angles are measured in -degrees, otherwise, they are measured in radians. -@sa cartToPolar, exp, log, pow, sqrt -*/ -GAPI_EXPORTS_W std::tuple polarToCart(const GMat& magnitude, const GMat& angle, - bool angleInDegrees = false); - -/** @brief Calculates the magnitude and angle of 2D vectors. - -The function cartToPolar calculates either the magnitude, angle, or both -for every 2D vector (x(I),y(I)): -\f[\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\f] - -The angles are calculated with accuracy about 0.3 degrees. For the point -(0,0), the angle is set to 0. - -First output is a matrix of magnitudes of the same size and depth as input x. -Second output is a matrix of angles that has the same size and depth as -x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360 degrees). - -@note Function textual ID is "org.opencv.core.math.cartToPolar" - -@param x matrix of @ref CV_32FC1 x-coordinates. -@param y array of @ref CV_32FC1 y-coordinates. -@param angleInDegrees a flag, indicating whether the angles are measured -in radians (which is by default), or in degrees. -@sa polarToCart -*/ -GAPI_EXPORTS_W std::tuple cartToPolar(const GMat& x, const GMat& y, - bool angleInDegrees = false); - -/** @brief Calculates the rotation angle of 2D vectors. - -The function cv::phase calculates the rotation angle of each 2D vector that -is formed from the corresponding elements of x and y : -\f[\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\f] - -The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , -the corresponding angle(I) is set to 0. -@param x input floating-point array of x-coordinates of 2D vectors. -@param y input array of y-coordinates of 2D vectors; it must have the -same size and the same type as x. -@param angleInDegrees when true, the function calculates the angle in -degrees, otherwise, they are measured in radians. -@return array of vector angles; it has the same size and same type as x. -*/ -GAPI_EXPORTS_W GMat phase(const GMat& x, const GMat &y, bool angleInDegrees = false); - -/** @brief Calculates a square root of array elements. - -The function cv::gapi::sqrt calculates a square root of each input array element. -In case of multi-channel arrays, each channel is processed -independently. The accuracy is approximately the same as of the built-in -std::sqrt . -@param src input floating-point array. -@return output array of the same size and type as src. -*/ -GAPI_EXPORTS_W GMat sqrt(const GMat &src); - -//! @} gapi_math -//! -//! @addtogroup gapi_pixelwise -//! @{ - -/** @brief Performs the per-element comparison of two matrices checking if elements from first matrix are greater compare to elements in second. - -The function compares elements of two matrices src1 and src2 of the same size: - \f[\texttt{dst} (I) = \texttt{src1} (I) > \texttt{src2} (I)\f] - -When the comparison result is true, the corresponding element of output -array is set to 255. The comparison operations can be replaced with the -equivalent matrix expressions: -\f[\texttt{dst} = \texttt{src1} > \texttt{src2}\f] - -Output matrix of depth @ref CV_8U must have the same size and the same number of channels as - the input matrices/matrix. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpGT" -@param src1 first input matrix. -@param src2 second input matrix/scalar of the same depth as first input matrix. -@sa min, max, threshold, cmpLE, cmpGE, cmpLT -*/ -GAPI_EXPORTS_W GMat cmpGT(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpGTScalar" -*/ -GAPI_EXPORTS_W GMat cmpGT(const GMat& src1, const GScalar& src2); - -/** @brief Performs the per-element comparison of two matrices checking if elements from first matrix are less than elements in second. - -The function compares elements of two matrices src1 and src2 of the same size: - \f[\texttt{dst} (I) = \texttt{src1} (I) < \texttt{src2} (I)\f] - -When the comparison result is true, the corresponding element of output -array is set to 255. The comparison operations can be replaced with the -equivalent matrix expressions: - \f[\texttt{dst} = \texttt{src1} < \texttt{src2}\f] - -Output matrix of depth @ref CV_8U must have the same size and the same number of channels as - the input matrices/matrix. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpLT" -@param src1 first input matrix. -@param src2 second input matrix/scalar of the same depth as first input matrix. -@sa min, max, threshold, cmpLE, cmpGE, cmpGT -*/ -GAPI_EXPORTS_W GMat cmpLT(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpLTScalar" -*/ -GAPI_EXPORTS_W GMat cmpLT(const GMat& src1, const GScalar& src2); - -/** @brief Performs the per-element comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second. - -The function compares elements of two matrices src1 and src2 of the same size: - \f[\texttt{dst} (I) = \texttt{src1} (I) >= \texttt{src2} (I)\f] - -When the comparison result is true, the corresponding element of output -array is set to 255. The comparison operations can be replaced with the -equivalent matrix expressions: - \f[\texttt{dst} = \texttt{src1} >= \texttt{src2}\f] - -Output matrix of depth @ref CV_8U must have the same size and the same number of channels as - the input matrices. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpGE" -@param src1 first input matrix. -@param src2 second input matrix/scalar of the same depth as first input matrix. -@sa min, max, threshold, cmpLE, cmpGT, cmpLT -*/ -GAPI_EXPORTS_W GMat cmpGE(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpLGEcalar" -*/ -GAPI_EXPORTS_W GMat cmpGE(const GMat& src1, const GScalar& src2); - -/** @brief Performs the per-element comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second. - -The function compares elements of two matrices src1 and src2 of the same size: - \f[\texttt{dst} (I) = \texttt{src1} (I) <= \texttt{src2} (I)\f] - -When the comparison result is true, the corresponding element of output -array is set to 255. The comparison operations can be replaced with the -equivalent matrix expressions: - \f[\texttt{dst} = \texttt{src1} <= \texttt{src2}\f] - -Output matrix of depth @ref CV_8U must have the same size and the same number of channels as - the input matrices. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpLE" -@param src1 first input matrix. -@param src2 second input matrix/scalar of the same depth as first input matrix. -@sa min, max, threshold, cmpGT, cmpGE, cmpLT -*/ -GAPI_EXPORTS_W GMat cmpLE(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpLEScalar" -*/ -GAPI_EXPORTS_W GMat cmpLE(const GMat& src1, const GScalar& src2); - -/** @brief Performs the per-element comparison of two matrices checking if elements from first matrix are equal to elements in second. - -The function compares elements of two matrices src1 and src2 of the same size: - \f[\texttt{dst} (I) = \texttt{src1} (I) == \texttt{src2} (I)\f] - -When the comparison result is true, the corresponding element of output -array is set to 255. The comparison operations can be replaced with the -equivalent matrix expressions: - \f[\texttt{dst} = \texttt{src1} == \texttt{src2}\f] - -Output matrix of depth @ref CV_8U must have the same size and the same number of channels as - the input matrices. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpEQ" -@param src1 first input matrix. -@param src2 second input matrix/scalar of the same depth as first input matrix. -@sa min, max, threshold, cmpNE -*/ -GAPI_EXPORTS_W GMat cmpEQ(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpEQScalar" -*/ -GAPI_EXPORTS_W GMat cmpEQ(const GMat& src1, const GScalar& src2); - -/** @brief Performs the per-element comparison of two matrices checking if elements from first matrix are not equal to elements in second. - -The function compares elements of two matrices src1 and src2 of the same size: - \f[\texttt{dst} (I) = \texttt{src1} (I) != \texttt{src2} (I)\f] - -When the comparison result is true, the corresponding element of output -array is set to 255. The comparison operations can be replaced with the -equivalent matrix expressions: - \f[\texttt{dst} = \texttt{src1} != \texttt{src2}\f] - -Output matrix of depth @ref CV_8U must have the same size and the same number of channels as - the input matrices. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpNE" -@param src1 first input matrix. -@param src2 second input matrix/scalar of the same depth as first input matrix. -@sa min, max, threshold, cmpEQ -*/ -GAPI_EXPORTS_W GMat cmpNE(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.compare.cmpNEScalar" -*/ -GAPI_EXPORTS_W GMat cmpNE(const GMat& src1, const GScalar& src2); - -/** @brief computes bitwise conjunction of the two matrixes (src1 & src2) -Calculates the per-element bit-wise logical conjunction of two matrices of the same size. - -In case of floating-point matrices, their machine-specific bit -representations (usually IEEE754-compliant) are used for the operation. -In case of multi-channel matrices, each channel is processed -independently. Output matrix must have the same size and depth as the input -matrices. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_and" - -@param src1 first input matrix. -@param src2 second input matrix. -*/ -GAPI_EXPORTS_W GMat bitwise_and(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_andS" -@param src1 first input matrix. -@param src2 scalar, which will be per-lemenetly conjuncted with elements of src1. -*/ -GAPI_EXPORTS_W GMat bitwise_and(const GMat& src1, const GScalar& src2); - -/** @brief computes bitwise disjunction of the two matrixes (src1 | src2) -Calculates the per-element bit-wise logical disjunction of two matrices of the same size. - -In case of floating-point matrices, their machine-specific bit -representations (usually IEEE754-compliant) are used for the operation. -In case of multi-channel matrices, each channel is processed -independently. Output matrix must have the same size and depth as the input -matrices. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_or" - -@param src1 first input matrix. -@param src2 second input matrix. -*/ -GAPI_EXPORTS_W GMat bitwise_or(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_orS" -@param src1 first input matrix. -@param src2 scalar, which will be per-lemenetly disjuncted with elements of src1. -*/ -GAPI_EXPORTS_W GMat bitwise_or(const GMat& src1, const GScalar& src2); - - -/** @brief computes bitwise logical "exclusive or" of the two matrixes (src1 ^ src2) -Calculates the per-element bit-wise logical "exclusive or" of two matrices of the same size. - -In case of floating-point matrices, their machine-specific bit -representations (usually IEEE754-compliant) are used for the operation. -In case of multi-channel matrices, each channel is processed -independently. Output matrix must have the same size and depth as the input -matrices. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_xor" - -@param src1 first input matrix. -@param src2 second input matrix. -*/ -GAPI_EXPORTS_W GMat bitwise_xor(const GMat& src1, const GMat& src2); -/** @overload -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_xorS" -@param src1 first input matrix. -@param src2 scalar, for which per-lemenet "logical or" operation on elements of src1 will be performed. -*/ -GAPI_EXPORTS_W GMat bitwise_xor(const GMat& src1, const GScalar& src2); - - -/** @brief Inverts every bit of an array. - -The function bitwise_not calculates per-element bit-wise inversion of the input -matrix: -\f[\texttt{dst} (I) = \neg \texttt{src} (I)\f] - -In case of floating-point matrices, their machine-specific bit -representations (usually IEEE754-compliant) are used for the operation. -In case of multi-channel matrices, each channel is processed -independently. Output matrix must have the same size and depth as the input -matrix. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.bitwise_not" - -@param src input matrix. -*/ -GAPI_EXPORTS_W GMat bitwise_not(const GMat& src); - -/** @brief Select values from either first or second of input matrices by given mask. -The function set to the output matrix either the value from the first input matrix if corresponding value of mask matrix is 255, - or value from the second input matrix (if value of mask matrix set to 0). - -Input mask matrix must be of @ref CV_8UC1 type, two other inout matrices and output matrix should be of the same type. The size should -be the same for all input and output matrices. -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.pixelwise.select" - -@param src1 first input matrix. -@param src2 second input matrix. -@param mask mask input matrix. -*/ -GAPI_EXPORTS_W GMat select(const GMat& src1, const GMat& src2, const GMat& mask); - -//! @} gapi_pixelwise - - -//! @addtogroup gapi_matrixop -//! @{ -/** @brief Calculates per-element minimum of two matrices. - -The function min calculates the per-element minimum of two matrices of the same size, number of channels and depth: -\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\f] - where I is a multi-dimensional index of matrix elements. In case of - multi-channel matrices, each channel is processed independently. -Output matrix must be of the same size and depth as src1. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.min" -@param src1 first input matrix. -@param src2 second input matrix of the same size and depth as src1. -@sa max, cmpEQ, cmpLT, cmpLE -*/ -GAPI_EXPORTS_W GMat min(const GMat& src1, const GMat& src2); - -/** @brief Calculates per-element maximum of two matrices. - -The function max calculates the per-element maximum of two matrices of the same size, number of channels and depth: -\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\f] - where I is a multi-dimensional index of matrix elements. In case of - multi-channel matrices, each channel is processed independently. -Output matrix must be of the same size and depth as src1. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.max" -@param src1 first input matrix. -@param src2 second input matrix of the same size and depth as src1. -@sa min, compare, cmpEQ, cmpGT, cmpGE -*/ -GAPI_EXPORTS_W GMat max(const GMat& src1, const GMat& src2); - -/** @brief Calculates the per-element absolute difference between two matrices. - -The function absDiff calculates absolute difference between two matrices of the same size and depth: - \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\f] - where I is a multi-dimensional index of matrix elements. In case of - multi-channel matrices, each channel is processed independently. -Output matrix must have the same size and depth as input matrices. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.absdiff" -@param src1 first input matrix. -@param src2 second input matrix. -@sa abs -*/ -GAPI_EXPORTS_W GMat absDiff(const GMat& src1, const GMat& src2); - -/** @brief Calculates absolute value of matrix elements. - -The function abs calculates absolute difference between matrix elements and given scalar value: - \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{matC}(I)|)\f] - where matC is constructed from given scalar c and has the same sizes and depth as input matrix src. - -Output matrix must be of the same size and depth as src. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.absdiffC" -@param src input matrix. -@param c scalar to be subtracted. -@sa min, max -*/ -GAPI_EXPORTS_W GMat absDiffC(const GMat& src, const GScalar& c); - -/** @brief Calculates sum of all matrix elements. - -The function sum calculates sum of all matrix elements, independently for each channel. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.sum" -@param src input matrix. -@sa countNonZero, mean, min, max -*/ -GAPI_EXPORTS_W GScalar sum(const GMat& src); - -/** @brief Counts non-zero array elements. - -The function returns the number of non-zero elements in src : -\f[\sum _{I: \; \texttt{src} (I) \ne0 } 1\f] - -Supported matrix data types are @ref CV_8UC1, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.countNonZero" -@param src input single-channel matrix. -@sa mean, min, max -*/ -GAPI_EXPORTS_W GOpaque countNonZero(const GMat& src); - -/** @brief Calculates the weighted sum of two matrices. - -The function addWeighted calculates the weighted sum of two matrices as follows: -\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f] -where I is a multi-dimensional index of array elements. In case of multi-channel matrices, each -channel is processed independently. - -The function can be replaced with a matrix expression: - \f[\texttt{dst}(I) = \texttt{alpha} * \texttt{src1}(I) - \texttt{beta} * \texttt{src2}(I) + \texttt{gamma} \f] - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.addweighted" -@param src1 first input matrix. -@param alpha weight of the first matrix elements. -@param src2 second input matrix of the same size and channel number as src1. -@param beta weight of the second matrix elements. -@param gamma scalar added to each sum. -@param ddepth optional depth of the output matrix. -@sa add, sub -*/ -GAPI_EXPORTS_W GMat addWeighted(const GMat& src1, double alpha, const GMat& src2, double beta, double gamma, int ddepth = -1); - -/** @brief Calculates the absolute L1 norm of a matrix. - -This version of normL1 calculates the absolute L1 norm of src. - -As example for one array consider the function \f$r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\f$. -The \f$ L_{1} \f$ norm for the sample value \f$r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\f$ -is calculated as follows -\f{align*} - \| r(-1) \|_{L_1} &= |-1| + |2| = 3 \\ -\f} -and for \f$r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\f$ the calculation is -\f{align*} - \| r(0.5) \|_{L_1} &= |0.5| + |0.5| = 1 \\ -\f} - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.norml1" -@param src input matrix. -@sa normL2, normInf -*/ -GAPI_EXPORTS_W GScalar normL1(const GMat& src); - -/** @brief Calculates the absolute L2 norm of a matrix. - -This version of normL2 calculates the absolute L2 norm of src. - -As example for one array consider the function \f$r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\f$. -The \f$ L_{2} \f$ norm for the sample value \f$r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\f$ -is calculated as follows -\f{align*} - \| r(-1) \|_{L_2} &= \sqrt{(-1)^{2} + (2)^{2}} = \sqrt{5} \\ -\f} -and for \f$r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\f$ the calculation is -\f{align*} - \| r(0.5) \|_{L_2} &= \sqrt{(0.5)^{2} + (0.5)^{2}} = \sqrt{0.5} \\ -\f} - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. -@note Function textual ID is "org.opencv.core.matrixop.norml2" -@param src input matrix. -@sa normL1, normInf -*/ -GAPI_EXPORTS_W GScalar normL2(const GMat& src); - -/** @brief Calculates the absolute infinite norm of a matrix. - -This version of normInf calculates the absolute infinite norm of src. - -As example for one array consider the function \f$r(x)= \begin{pmatrix} x \\ 1-x \end{pmatrix}, x \in [-1;1]\f$. -The \f$ L_{\infty} \f$ norm for the sample value \f$r(-1) = \begin{pmatrix} -1 \\ 2 \end{pmatrix}\f$ -is calculated as follows -\f{align*} - \| r(-1) \|_{L_\infty} &= \max(|-1|,|2|) = 2 -\f} -and for \f$r(0.5) = \begin{pmatrix} 0.5 \\ 0.5 \end{pmatrix}\f$ the calculation is -\f{align*} - \| r(0.5) \|_{L_\infty} &= \max(|0.5|,|0.5|) = 0.5. -\f} - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.core.matrixop.norminf" -@param src input matrix. -@sa normL1, normL2 -*/ -GAPI_EXPORTS_W GScalar normInf(const GMat& src); - -/** @brief Calculates the integral of an image. - -The function calculates one or more integral images for the source image as follows: - -\f[\texttt{sum} (X,Y) = \sum _{x integral(const GMat& src, int sdepth = -1, int sqdepth = -1); - -/** @brief Applies a fixed-level threshold to each matrix element. - -The function applies fixed-level thresholding to a single- or multiple-channel matrix. -The function is typically used to get a bi-level (binary) image out of a grayscale image ( cmp functions could be also used for -this purpose) or for removing a noise, that is, filtering out pixels with too small or too large -values. There are several types of thresholding supported by the function. They are determined by -type parameter. - -Also, the special values cv::THRESH_OTSU or cv::THRESH_TRIANGLE may be combined with one of the -above values. In these cases, the function determines the optimal threshold value using the Otsu's -or Triangle algorithm and uses it instead of the specified thresh . The function returns the -computed threshold value in addititon to thresholded matrix. -The Otsu's and Triangle methods are implemented only for 8-bit matrices. - -Input image should be single channel only in case of cv::THRESH_OTSU or cv::THRESH_TRIANGLE flags. -Output matrix must be of the same size and depth as src. - -@note Function textual ID is "org.opencv.core.matrixop.threshold" - -@param src input matrix (@ref CV_8UC1, @ref CV_8UC3, or @ref CV_32FC1). -@param thresh threshold value. -@param maxval maximum value to use with the cv::THRESH_BINARY and cv::THRESH_BINARY_INV thresholding -types. -@param type thresholding type (see the cv::ThresholdTypes). - -@sa min, max, cmpGT, cmpLE, cmpGE, cmpLT - */ -GAPI_EXPORTS_W GMat threshold(const GMat& src, const GScalar& thresh, const GScalar& maxval, int type); -/** @overload -This function applicable for all threshold types except cv::THRESH_OTSU and cv::THRESH_TRIANGLE -@note Function textual ID is "org.opencv.core.matrixop.thresholdOT" -*/ -GAPI_EXPORTS_W std::tuple threshold(const GMat& src, const GScalar& maxval, int type); - -/** @brief Applies a range-level threshold to each matrix element. - -The function applies range-level thresholding to a single- or multiple-channel matrix. -It sets output pixel value to OxFF if the corresponding pixel value of input matrix is in specified range,or 0 otherwise. - -Input and output matrices must be CV_8UC1. - -@note Function textual ID is "org.opencv.core.matrixop.inRange" - -@param src input matrix (CV_8UC1). -@param threshLow lower boundary value. -@param threshUp upper boundary value. - -@sa threshold - */ -GAPI_EXPORTS_W GMat inRange(const GMat& src, const GScalar& threshLow, const GScalar& threshUp); - -//! @} gapi_matrixop - -//! @addtogroup gapi_transform -//! @{ -/** @brief Creates one 4-channel matrix out of 4 single-channel ones. - -The function merges several matrices to make a single multi-channel matrix. That is, each -element of the output matrix will be a concatenation of the elements of the input matrices, where -elements of i-th input matrix are treated as mv[i].channels()-element vectors. -Output matrix must be of @ref CV_8UC4 type. - -The function split4 does the reverse operation. - -@note - - Function textual ID is "org.opencv.core.transform.merge4" - -@param src1 first input @ref CV_8UC1 matrix to be merged. -@param src2 second input @ref CV_8UC1 matrix to be merged. -@param src3 third input @ref CV_8UC1 matrix to be merged. -@param src4 fourth input @ref CV_8UC1 matrix to be merged. -@sa merge3, split4, split3 -*/ -GAPI_EXPORTS_W GMat merge4(const GMat& src1, const GMat& src2, const GMat& src3, const GMat& src4); - -/** @brief Creates one 3-channel matrix out of 3 single-channel ones. - -The function merges several matrices to make a single multi-channel matrix. That is, each -element of the output matrix will be a concatenation of the elements of the input matrices, where -elements of i-th input matrix are treated as mv[i].channels()-element vectors. -Output matrix must be of @ref CV_8UC3 type. - -The function split3 does the reverse operation. - -@note - - Function textual ID is "org.opencv.core.transform.merge3" - -@param src1 first input @ref CV_8UC1 matrix to be merged. -@param src2 second input @ref CV_8UC1 matrix to be merged. -@param src3 third input @ref CV_8UC1 matrix to be merged. -@sa merge4, split4, split3 -*/ -GAPI_EXPORTS_W GMat merge3(const GMat& src1, const GMat& src2, const GMat& src3); - -/** @brief Divides a 4-channel matrix into 4 single-channel matrices. - -The function splits a 4-channel matrix into 4 single-channel matrices: -\f[\texttt{mv} [c](I) = \texttt{src} (I)_c\f] - -All output matrices must be of @ref CV_8UC1 type. - -The function merge4 does the reverse operation. - -@note - - Function textual ID is "org.opencv.core.transform.split4" - -@param src input @ref CV_8UC4 matrix. -@sa split3, merge3, merge4 -*/ -GAPI_EXPORTS_W std::tuple split4(const GMat& src); - -/** @brief Divides a 3-channel matrix into 3 single-channel matrices. - -The function splits a 3-channel matrix into 3 single-channel matrices: -\f[\texttt{mv} [c](I) = \texttt{src} (I)_c\f] - -All output matrices must be of @ref CV_8UC1 type. - -The function merge3 does the reverse operation. - -@note - - Function textual ID is "org.opencv.core.transform.split3" - -@param src input @ref CV_8UC3 matrix. -@sa split4, merge3, merge4 -*/ -GAPI_EXPORTS_W std::tuple split3(const GMat& src); - -/** @brief Applies a generic geometrical transformation to an image. - -The function remap transforms the source image using the specified map: - -\f[\texttt{dst} (x,y) = \texttt{src} (map_x(x,y),map_y(x,y))\f] - -where values of pixels with non-integer coordinates are computed using one of available -interpolation methods. \f$map_x\f$ and \f$map_y\f$ can be encoded as separate floating-point maps -in \f$map_1\f$ and \f$map_2\f$ respectively, or interleaved floating-point maps of \f$(x,y)\f$ in -\f$map_1\f$, or fixed-point maps created by using convertMaps. The reason you might want to -convert from floating to fixed-point representations of a map is that they can yield much faster -(\~2x) remapping operations. In the converted case, \f$map_1\f$ contains pairs (cvFloor(x), -cvFloor(y)) and \f$map_2\f$ contains indices in a table of interpolation coefficients. -Output image must be of the same size and depth as input one. - -@note - - Function textual ID is "org.opencv.core.transform.remap" - - Due to current implementation limitations the size of an input and output images should be less than 32767x32767. - -@param src Source image. -@param map1 The first map of either (x,y) points or just x values having the type CV_16SC2, -CV_32FC1, or CV_32FC2. -@param map2 The second map of y values having the type CV_16UC1, CV_32FC1, or none (empty map -if map1 is (x,y) points), respectively. -@param interpolation Interpolation method (see cv::InterpolationFlags). The methods #INTER_AREA -and #INTER_LINEAR_EXACT are not supported by this function. -@param borderMode Pixel extrapolation method (see cv::BorderTypes). When -borderMode=BORDER_TRANSPARENT, it means that the pixels in the destination image that -corresponds to the "outliers" in the source image are not modified by the function. -@param borderValue Value used in case of a constant border. By default, it is 0. - */ -GAPI_EXPORTS_W GMat remap(const GMat& src, const Mat& map1, const Mat& map2, - int interpolation, int borderMode = BORDER_CONSTANT, - const Scalar& borderValue = Scalar()); - -/** @brief Flips a 2D matrix around vertical, horizontal, or both axes. - -The function flips the matrix in one of three different ways (row -and column indices are 0-based): -\f[\texttt{dst} _{ij} = -\left\{ -\begin{array}{l l} -\texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ -\texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ -\texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ -\end{array} -\right.\f] -The example scenarios of using the function are the following: -* Vertical flipping of the image (flipCode == 0) to switch between - top-left and bottom-left image origin. This is a typical operation - in video processing on Microsoft Windows\* OS. -* Horizontal flipping of the image with the subsequent horizontal - shift and absolute difference calculation to check for a - vertical-axis symmetry (flipCode \> 0). -* Simultaneous horizontal and vertical flipping of the image with - the subsequent shift and absolute difference calculation to check - for a central symmetry (flipCode \< 0). -* Reversing the order of point arrays (flipCode \> 0 or - flipCode == 0). -Output image must be of the same depth as input one, size should be correct for given flipCode. - -@note Function textual ID is "org.opencv.core.transform.flip" - -@param src input matrix. -@param flipCode a flag to specify how to flip the array; 0 means -flipping around the x-axis and positive value (for example, 1) means -flipping around y-axis. Negative value (for example, -1) means flipping -around both axes. -@sa remap -*/ -GAPI_EXPORTS_W GMat flip(const GMat& src, int flipCode); - -/** @brief Crops a 2D matrix. - -The function crops the matrix by given cv::Rect. - -Output matrix must be of the same depth as input one, size is specified by given rect size. - -@note Function textual ID is "org.opencv.core.transform.crop" - -@param src input matrix. -@param rect a rect to crop a matrix to -@sa resize -*/ -GAPI_EXPORTS_W GMat crop(const GMat& src, const Rect& rect); - -/** @brief Applies horizontal concatenation to given matrices. - -The function horizontally concatenates two GMat matrices (with the same number of rows). -@code{.cpp} - GMat A = { 1, 4, - 2, 5, - 3, 6 }; - GMat B = { 7, 10, - 8, 11, - 9, 12 }; - - GMat C = gapi::concatHor(A, B); - //C: - //[1, 4, 7, 10; - // 2, 5, 8, 11; - // 3, 6, 9, 12] -@endcode -Output matrix must the same number of rows and depth as the src1 and src2, and the sum of cols of the src1 and src2. -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.imgproc.transform.concatHor" - -@param src1 first input matrix to be considered for horizontal concatenation. -@param src2 second input matrix to be considered for horizontal concatenation. -@sa concatVert -*/ -GAPI_EXPORTS_W GMat concatHor(const GMat& src1, const GMat& src2); - -/** @overload -The function horizontally concatenates given number of GMat matrices (with the same number of columns). -Output matrix must the same number of columns and depth as the input matrices, and the sum of rows of input matrices. - -@param v vector of input matrices to be concatenated horizontally. -*/ -GAPI_EXPORTS_W GMat concatHor(const std::vector &v); - -/** @brief Applies vertical concatenation to given matrices. - -The function vertically concatenates two GMat matrices (with the same number of cols). - @code{.cpp} - GMat A = { 1, 7, - 2, 8, - 3, 9 }; - GMat B = { 4, 10, - 5, 11, - 6, 12 }; - - GMat C = gapi::concatVert(A, B); - //C: - //[1, 7; - // 2, 8; - // 3, 9; - // 4, 10; - // 5, 11; - // 6, 12] - @endcode - -Output matrix must the same number of cols and depth as the src1 and src2, and the sum of rows of the src1 and src2. -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. - -@note Function textual ID is "org.opencv.imgproc.transform.concatVert" - -@param src1 first input matrix to be considered for vertical concatenation. -@param src2 second input matrix to be considered for vertical concatenation. -@sa concatHor -*/ -GAPI_EXPORTS_W GMat concatVert(const GMat& src1, const GMat& src2); - -/** @overload -The function vertically concatenates given number of GMat matrices (with the same number of columns). -Output matrix must the same number of columns and depth as the input matrices, and the sum of rows of input matrices. - -@param v vector of input matrices to be concatenated vertically. -*/ -GAPI_EXPORTS_W GMat concatVert(const std::vector &v); - - -/** @brief Performs a look-up table transform of a matrix. - -The function LUT fills the output matrix with values from the look-up table. Indices of the entries -are taken from the input matrix. That is, the function processes each element of src as follows: -\f[\texttt{dst} (I) \leftarrow \texttt{lut(src(I))}\f] - -Supported matrix data types are @ref CV_8UC1. -Output is a matrix of the same size and number of channels as src, and the same depth as lut. - -@note Function textual ID is "org.opencv.core.transform.LUT" - -@param src input matrix of 8-bit elements. -@param lut look-up table of 256 elements; in case of multi-channel input array, the table should -either have a single channel (in this case the same table is used for all channels) or the same -number of channels as in the input matrix. -*/ -GAPI_EXPORTS_W GMat LUT(const GMat& src, const Mat& lut); - -/** @brief Converts a matrix to another data depth with optional scaling. - -The method converts source pixel values to the target data depth. saturate_cast\<\> is applied at -the end to avoid possible overflows: - -\f[m(x,y) = saturate \_ cast( \alpha (*this)(x,y) + \beta )\f] -Output matrix must be of the same size as input one. - -@note Function textual ID is "org.opencv.core.transform.convertTo" -@param src input matrix to be converted from. -@param rdepth desired output matrix depth or, rather, the depth since the number of channels are the -same as the input has; if rdepth is negative, the output matrix will have the same depth as the input. -@param alpha optional scale factor. -@param beta optional delta added to the scaled values. - */ -GAPI_EXPORTS_W GMat convertTo(const GMat& src, int rdepth, double alpha=1, double beta=0); - -/** @brief Normalizes the norm or value range of an array. - -The function normalizes scale and shift the input array elements so that -\f[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\f] -(where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that -\f[\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\f] -when normType=NORM_MINMAX (for dense arrays only). - -@note Function textual ID is "org.opencv.core.normalize" - -@param src input array. -@param alpha norm value to normalize to or the lower range boundary in case of the range -normalization. -@param beta upper range boundary in case of the range normalization; it is not used for the norm -normalization. -@param norm_type normalization type (see cv::NormTypes). -@param ddepth when negative, the output array has the same type as src; otherwise, it has the same -number of channels as src and the depth =ddepth. -@sa norm, Mat::convertTo -*/ -GAPI_EXPORTS_W GMat normalize(const GMat& src, double alpha, double beta, - int norm_type, int ddepth = -1); - -/** @brief Applies a perspective transformation to an image. - -The function warpPerspective transforms the source image using the specified matrix: - -\f[\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} , - \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right )\f] - -when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted with invert -and then put in the formula above instead of M. The function cannot operate in-place. - -@param src input image. -@param M \f$3\times 3\f$ transformation matrix. -@param dsize size of the output image. -@param flags combination of interpolation methods (#INTER_LINEAR or #INTER_NEAREST) and the -optional flag #WARP_INVERSE_MAP, that sets M as the inverse transformation ( -\f$\texttt{dst}\rightarrow\texttt{src}\f$ ). -@param borderMode pixel extrapolation method (#BORDER_CONSTANT or #BORDER_REPLICATE). -@param borderValue value used in case of a constant border; by default, it equals 0. - -@sa warpAffine, resize, remap, getRectSubPix, perspectiveTransform - */ -GAPI_EXPORTS_W GMat warpPerspective(const GMat& src, const Mat& M, const Size& dsize, int flags = cv::INTER_LINEAR, - int borderMode = cv::BORDER_CONSTANT, const Scalar& borderValue = Scalar()); - -/** @brief Applies an affine transformation to an image. - -The function warpAffine transforms the source image using the specified matrix: - -\f[\texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23})\f] - -when the flag #WARP_INVERSE_MAP is set. Otherwise, the transformation is first inverted -with #invertAffineTransform and then put in the formula above instead of M. The function cannot -operate in-place. - -@param src input image. -@param M \f$2\times 3\f$ transformation matrix. -@param dsize size of the output image. -@param flags combination of interpolation methods (see #InterpolationFlags) and the optional -flag #WARP_INVERSE_MAP that means that M is the inverse transformation ( -\f$\texttt{dst}\rightarrow\texttt{src}\f$ ). -@param borderMode pixel extrapolation method (see #BorderTypes); -borderMode=#BORDER_TRANSPARENT isn't supported -@param borderValue value used in case of a constant border; by default, it is 0. - -@sa warpPerspective, resize, remap, getRectSubPix, transform - */ -GAPI_EXPORTS_W GMat warpAffine(const GMat& src, const Mat& M, const Size& dsize, int flags = cv::INTER_LINEAR, - int borderMode = cv::BORDER_CONSTANT, const Scalar& borderValue = Scalar()); -//! @} gapi_transform - -/** @brief Finds centers of clusters and groups input samples around the clusters. - -The function kmeans implements a k-means algorithm that finds the centers of K clusters -and groups the input samples around the clusters. As an output, \f$\texttt{bestLabels}_i\f$ -contains a 0-based cluster index for the \f$i^{th}\f$ sample. - -@note - - Function textual ID is "org.opencv.core.kmeansND" - - In case of an N-dimentional points' set given, input GMat can have the following traits: -2 dimensions, a single row or column if there are N channels, -or N columns if there is a single channel. Mat should have @ref CV_32F depth. - - Although, if GMat with height != 1, width != 1, channels != 1 given as data, n-dimensional -samples are considered given in amount of A, where A = height, n = width * channels. - - In case of GMat given as data: - - the output labels are returned as 1-channel GMat with sizes -width = 1, height = A, where A is samples amount, or width = bestLabels.width, -height = bestLabels.height if bestLabels given; - - the cluster centers are returned as 1-channel GMat with sizes -width = n, height = K, where n is samples' dimentionality and K is clusters' amount. - - As one of possible usages, if you want to control the initial labels for each attempt -by yourself, you can utilize just the core of the function. To do that, set the number -of attempts to 1, initialize labels each time using a custom algorithm, pass them with the -( flags = #KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best (most-compact) clustering. - -@param data Data for clustering. An array of N-Dimensional points with float coordinates is needed. -Function can take GArray, GArray for 2D and 3D cases or GMat for any -dimentionality and channels. -@param K Number of clusters to split the set by. -@param bestLabels Optional input integer array that can store the supposed initial cluster indices -for every sample. Used when ( flags = #KMEANS_USE_INITIAL_LABELS ) flag is set. -@param criteria The algorithm termination criteria, that is, the maximum number of iterations -and/or the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of -the cluster centers moves by less than criteria.epsilon on some iteration, the algorithm stops. -@param attempts Flag to specify the number of times the algorithm is executed using different -initial labellings. The algorithm returns the labels that yield the best compactness (see the first -function return value). -@param flags Flag that can take values of cv::KmeansFlags . - -@return - - Compactness measure that is computed as -\f[\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\f] -after every attempt. The best (minimum) value is chosen and the corresponding labels and the -compactness value are returned by the function. - - Integer array that stores the cluster indices for every sample. - - Array of the cluster centers. -*/ -GAPI_EXPORTS_W std::tuple,GMat,GMat> -kmeans(const GMat& data, const int K, const GMat& bestLabels, - const TermCriteria& criteria, const int attempts, const KmeansFlags flags); - -/** @overload -@note - - Function textual ID is "org.opencv.core.kmeansNDNoInit" - - #KMEANS_USE_INITIAL_LABELS flag must not be set while using this overload. - */ -GAPI_EXPORTS_W std::tuple,GMat,GMat> -kmeans(const GMat& data, const int K, const TermCriteria& criteria, const int attempts, - const KmeansFlags flags); - -/** @overload -@note Function textual ID is "org.opencv.core.kmeans2D" - */ -GAPI_EXPORTS_W std::tuple,GArray,GArray> -kmeans(const GArray& data, const int K, const GArray& bestLabels, - const TermCriteria& criteria, const int attempts, const KmeansFlags flags); - -/** @overload -@note Function textual ID is "org.opencv.core.kmeans3D" - */ -GAPI_EXPORTS_W std::tuple,GArray,GArray> -kmeans(const GArray& data, const int K, const GArray& bestLabels, - const TermCriteria& criteria, const int attempts, const KmeansFlags flags); - - -/** @brief Transposes a matrix. - -The function transposes the matrix: -\f[\texttt{dst} (i,j) = \texttt{src} (j,i)\f] - -@note - - Function textual ID is "org.opencv.core.transpose" - - No complex conjugation is done in case of a complex matrix. It should be done separately if needed. - -@param src input array. -*/ -GAPI_EXPORTS_W GMat transpose(const GMat& src); - - -namespace streaming { -/** @brief Gets dimensions from Mat. - -@note Function textual ID is "org.opencv.streaming.size" - -@param src Input tensor -@return Size (tensor dimensions). -*/ -GAPI_EXPORTS_W GOpaque size(const GMat& src); - -/** @overload -Gets dimensions from rectangle. - -@note Function textual ID is "org.opencv.streaming.sizeR" - -@param r Input rectangle. -@return Size (rectangle dimensions). -*/ -GAPI_EXPORTS_W GOpaque size(const GOpaque& r); - -/** @brief Gets dimensions from MediaFrame. - -@note Function textual ID is "org.opencv.streaming.sizeMF" - -@param src Input frame -@return Size (frame dimensions). -*/ -GAPI_EXPORTS_W GOpaque size(const GFrame& src); -} //namespace streaming -} //namespace gapi -} //namespace cv - -#endif //OPENCV_GAPI_CORE_HPP diff --git a/modules/gapi/include/opencv2/gapi/cpu/core.hpp b/modules/gapi/include/opencv2/gapi/cpu/core.hpp deleted file mode 100644 index ee86fb72c2..0000000000 --- a/modules/gapi/include/opencv2/gapi/cpu/core.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_CPU_CORE_API_HPP -#define OPENCV_GAPI_CPU_CORE_API_HPP - -#include // GKernelPackage -#include // GAPI_EXPORTS - -namespace cv { -namespace gapi { -namespace core { -namespace cpu { - -GAPI_EXPORTS_W cv::GKernelPackage kernels(); - -} // namespace cpu -} // namespace core -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_CPU_CORE_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp b/modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp deleted file mode 100644 index eb5f784747..0000000000 --- a/modules/gapi/include/opencv2/gapi/cpu/gcpukernel.hpp +++ /dev/null @@ -1,542 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2022 Intel Corporation - - -#ifndef OPENCV_GAPI_GCPUKERNEL_HPP -#define OPENCV_GAPI_GCPUKERNEL_HPP - -#if defined _MSC_VER -#pragma warning(push) -#pragma warning(disable: 4702) // "Unreachable code" on postprocess(...) call inside OCVCallHelper -#endif - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include //suppress_unused_warning -#include - -// FIXME: namespace scheme for backends? -namespace cv { - -namespace gimpl -{ - // Forward-declare an internal class - class GCPUExecutable; -} // namespace gimpl - -namespace gapi -{ -/** - * @brief This namespace contains G-API CPU backend functions, - * structures, and symbols. - */ -namespace cpu -{ - /** - * \addtogroup gapi_std_backends - * @{ - * - * @brief G-API backends available in this OpenCV version - * - * G-API backends play a corner stone role in G-API execution - * stack. Every backend is hardware-oriented and thus can run its - * kernels efficiently on the target platform. - * - * Backends are usually "black boxes" for G-API users -- on the API - * side, all backends are represented as different objects of the - * same class cv::gapi::GBackend. - * User can manipulate with backends by specifying which kernels to use. - * - * @sa @ref gapi_hld - */ - - /** - * @brief Get a reference to CPU (OpenCV) backend. - * - * This is the default backend in G-API at the moment, providing - * broader functional coverage but losing some graph model - * advantages. Provided mostly for reference and prototyping - * purposes. - * - * @sa gapi_std_backends - */ - GAPI_EXPORTS cv::gapi::GBackend backend(); - /** @} */ - - class GOCVFunctor; - - //! @cond IGNORED - template - GOCVFunctor ocv_kernel(const Callable& c); - - template - GOCVFunctor ocv_kernel(Callable& c); - //! @endcond - -} // namespace cpu -} // namespace gapi - -// Represents arguments which are passed to a wrapped CPU function -// FIXME: put into detail? -class GAPI_EXPORTS GCPUContext -{ -public: - // Generic accessor API - template - const T& inArg(int input) { return m_args.at(input).get(); } - - // Syntax sugar - const cv::Mat& inMat(int input); - cv::Mat& outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR() - - const cv::Scalar& inVal(int input); - cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR() - cv::MediaFrame& outFrame(int output); - template std::vector& outVecR(int output) // FIXME: the same issue - { - return outVecRef(output).wref(); - } - template T& outOpaqueR(int output) // FIXME: the same issue - { - return outOpaqueRef(output).wref(); - } - - GArg state() - { - return m_state; - } - -protected: - detail::VectorRef& outVecRef(int output); - detail::OpaqueRef& outOpaqueRef(int output); - - std::vector m_args; - GArg m_state; - - //FIXME: avoid conversion of arguments from internal representation to OpenCV one on each call - //to OCV kernel. (This can be achieved by a two single time conversions in GCPUExecutable::run, - //once on enter for input and output arguments, and once before return for output arguments only - std::unordered_map m_results; - - friend class gimpl::GCPUExecutable; -}; - -class GAPI_EXPORTS GCPUKernel -{ -public: - // This function is a kernel's execution entry point (does the processing work) - using RunF = std::function; - // This function is a stateful kernel's setup routine (configures state) - using SetupF = std::function; - - GCPUKernel(); - GCPUKernel(const RunF& runF, const SetupF& setupF = nullptr); - - RunF m_runF = nullptr; - SetupF m_setupF = nullptr; - - bool m_isStateful = false; -}; - -// FIXME: This is an ugly ad-hoc implementation. TODO: refactor - -namespace detail -{ -template struct get_in; -template<> struct get_in -{ - static cv::Mat get(GCPUContext &ctx, int idx) { return ctx.inMat(idx); } -}; -template<> struct get_in -{ - static cv::Mat get(GCPUContext &ctx, int idx) { return get_in::get(ctx, idx); } -}; -template<> struct get_in -{ - static cv::MediaFrame get(GCPUContext &ctx, int idx) { return ctx.inArg(idx); } -}; -template<> struct get_in -{ - static cv::Scalar get(GCPUContext &ctx, int idx) { return ctx.inVal(idx); } -}; -template struct get_in > -{ - static const std::vector& get(GCPUContext &ctx, int idx) { return ctx.inArg(idx).rref(); } -}; -template struct get_in > -{ - static const U& get(GCPUContext &ctx, int idx) { return ctx.inArg(idx).rref(); } -}; - -//FIXME(dm): GArray/GArray conversion should be done more gracefully in the system -template<> struct get_in >: public get_in > -{ -}; - -//FIXME(dm): GArray/GArray conversion should be done more gracefully in the system -template<> struct get_in >: public get_in > -{ -}; - -// FIXME(dm): GArray>/GArray> conversion should be done more gracefully in the system -template struct get_in> >: public get_in> > -{ -}; - -//FIXME(dm): GOpaque/GOpaque conversion should be done more gracefully in the system -template<> struct get_in >: public get_in > -{ -}; - -//FIXME(dm): GOpaque/GOpaque conversion should be done more gracefully in the system -template<> struct get_in >: public get_in > -{ -}; - -template struct get_in -{ - static T get(GCPUContext &ctx, int idx) { return ctx.inArg(idx); } -}; - -struct tracked_cv_mat{ - tracked_cv_mat(cv::Mat& m) : r{m}, original_data{m.data} {} - cv::Mat r; - uchar* original_data; - - operator cv::Mat& (){ return r;} - void validate() const{ - if (r.data != original_data) - { - util::throw_error - (std::logic_error - ("OpenCV kernel output parameter was reallocated. \n" - "Incorrect meta data was provided ?")); - } - } -}; - -template -void postprocess(Outputs&... outs) -{ - struct - { - void operator()(tracked_cv_mat* bm) { bm->validate(); } - void operator()(...) { } - - } validate; - //dummy array to unfold parameter pack - int dummy[] = { 0, (validate(&outs), 0)... }; - cv::util::suppress_unused_warning(dummy); -} - -template struct get_out; -template<> struct get_out -{ - static tracked_cv_mat get(GCPUContext &ctx, int idx) - { - auto& r = ctx.outMatR(idx); - return {r}; - } -}; -template<> struct get_out -{ - static tracked_cv_mat get(GCPUContext &ctx, int idx) - { - return get_out::get(ctx, idx); - } -}; -template<> struct get_out -{ - static cv::Scalar& get(GCPUContext &ctx, int idx) - { - return ctx.outValR(idx); - } -}; -template<> struct get_out -{ - static cv::MediaFrame& get(GCPUContext &ctx, int idx) - { - return ctx.outFrame(idx); - } -}; -template struct get_out> -{ - static std::vector& get(GCPUContext &ctx, int idx) - { - return ctx.outVecR(idx); - } -}; - -//FIXME(dm): GArray/GArray conversion should be done more gracefully in the system -template<> struct get_out >: public get_out > -{ -}; - -// FIXME(dm): GArray>/GArray> conversion should be done more gracefully in the system -template struct get_out> >: public get_out> > -{ -}; - -template struct get_out> -{ - static U& get(GCPUContext &ctx, int idx) - { - return ctx.outOpaqueR(idx); - } -}; - -template -struct OCVSetupHelper; - -template -struct OCVSetupHelper> -{ - // Using 'auto' return type and 'decltype' specifier in both 'setup_impl' versions - // to check existence of required 'Impl::setup' functions. - // While 'decltype' specifier accepts expression we pass expression with 'comma-operator' - // where first operand of comma-operator is call attempt to desired 'Impl::setup' and - // the second operand is 'void()' expression. - // - // SFINAE for 'Impl::setup' which accepts compile arguments. - template - static auto setup_impl(const GMetaArgs &metaArgs, const GArgs &args, - GArg &state, const GCompileArgs &compileArgs, - detail::Seq) -> - decltype(Impl::setup(detail::get_in_meta(metaArgs, args, IIs)..., - std::declval - >::type - >(), - compileArgs) - , void()) - { - // TODO: unique_ptr <-> shared_ptr conversion ? - // To check: Conversion is possible only if the state which should be passed to - // 'setup' user callback isn't required to have previous value - std::shared_ptr stPtr; - Impl::setup(detail::get_in_meta(metaArgs, args, IIs)..., stPtr, compileArgs); - state = GArg(stPtr); - } - - // SFINAE for 'Impl::setup' which doesn't accept compile arguments. - template - static auto setup_impl(const GMetaArgs &metaArgs, const GArgs &args, - GArg &state, const GCompileArgs &/* compileArgs */, - detail::Seq) -> - decltype(Impl::setup(detail::get_in_meta(metaArgs, args, IIs)..., - std::declval - >::type - >() - ) - , void()) - { - // The same comment as in 'setup' above. - std::shared_ptr stPtr; - Impl::setup(detail::get_in_meta(metaArgs, args, IIs)..., stPtr); - state = GArg(stPtr); - } - - static void setup(const GMetaArgs &metaArgs, const GArgs &args, - GArg& state, const GCompileArgs &compileArgs) - { - setup_impl(metaArgs, args, state, compileArgs, - typename detail::MkSeq::type()); - } -}; - -// OCVCallHelper is a helper class to call stateless OCV kernels and OCV kernel functors. -template -struct OCVCallHelper; - -// FIXME: probably can be simplified with std::apply or analogue. -template -struct OCVCallHelper, std::tuple> -{ - template - struct call_and_postprocess - { - template - static void call(Inputs&&... ins, Outputs&&... outs) - { - //not using a std::forward on outs is deliberate in order to - //cause compilation error, by trying to bind rvalue references to lvalue references - Impl::run(std::forward(ins)..., outs...); - postprocess(outs...); - } - - template - static void call(Impl& impl, Inputs&&... ins, Outputs&&... outs) - { - impl(std::forward(ins)..., outs...); - } - }; - - template - static void call_impl(GCPUContext &ctx, detail::Seq, detail::Seq) - { - //Make sure that OpenCV kernels do not reallocate memory for output parameters - //by comparing it's state (data ptr) before and after the call. - //This is done by converting each output Mat into tracked_cv_mat object, and binding - //them to parameters of ad-hoc function - call_and_postprocess::get(ctx, IIs))...> - ::call(get_in::get(ctx, IIs)..., get_out::get(ctx, OIs)...); - } - - template - static void call_impl(cv::GCPUContext &ctx, Impl& impl, - detail::Seq, detail::Seq) - { - call_and_postprocess::get(ctx, IIs))...> - ::call(impl, get_in::get(ctx, IIs)..., get_out::get(ctx, OIs)...); - } - - static void call(GCPUContext &ctx) - { - call_impl(ctx, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } - - // NB: Same as call but calling the object - // This necessary for kernel implementations that have a state - // and are represented as an object - static void callFunctor(cv::GCPUContext &ctx, Impl& impl) - { - call_impl(ctx, impl, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } -}; - -// OCVStCallHelper is a helper class to call stateful OCV kernels. -template -struct OCVStCallHelper; - -template -struct OCVStCallHelper, std::tuple> : - OCVCallHelper, std::tuple> -{ - template - struct call_and_postprocess - { - template - static void call(typename Impl::State& st, Inputs&&... ins, Outputs&&... outs) - { - Impl::run(std::forward(ins)..., outs..., st); - postprocess(outs...); - } - }; - - template - static void call_impl(GCPUContext &ctx, detail::Seq, detail::Seq) - { - auto& st = *ctx.state().get>(); - call_and_postprocess::get(ctx, IIs))...> - ::call(st, get_in::get(ctx, IIs)..., get_out::get(ctx, OIs)...); - } - - static void call(GCPUContext &ctx) - { - call_impl(ctx, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } -}; - -} // namespace detail - -template -class GCPUKernelImpl: public cv::detail::KernelTag -{ - using CallHelper = cv::detail::OCVCallHelper; - -public: - using API = K; - - static cv::gapi::GBackend backend() { return cv::gapi::cpu::backend(); } - static cv::GCPUKernel kernel() { return GCPUKernel(&CallHelper::call); } -}; - -template -class GCPUStKernelImpl: public cv::detail::KernelTag -{ - using StSetupHelper = detail::OCVSetupHelper; - using StCallHelper = detail::OCVStCallHelper; - -public: - using API = K; - using State = S; - - static cv::gapi::GBackend backend() { return cv::gapi::cpu::backend(); } - static cv::GCPUKernel kernel() { return GCPUKernel(&StCallHelper::call, - &StSetupHelper::setup); } -}; - -#define GAPI_OCV_KERNEL(Name, API) struct Name: public cv::GCPUKernelImpl - -// TODO: Reuse Anatoliy's logic for support of types with commas in macro. -// Retrieve the common part from Anatoliy's logic to the separate place. -#define GAPI_OCV_KERNEL_ST(Name, API, State) \ - struct Name: public cv::GCPUStKernelImpl \ - -/// @private -class gapi::cpu::GOCVFunctor : public gapi::GFunctor -{ -public: - using Impl = std::function; - using Meta = cv::GKernel::M; - - GOCVFunctor(const char* id, const Meta &meta, const Impl& impl) - : gapi::GFunctor(id), impl_{GCPUKernel(impl), meta} - { - } - - GKernelImpl impl() const override { return impl_; } - gapi::GBackend backend() const override { return gapi::cpu::backend(); } - -private: - GKernelImpl impl_; -}; - -//! @cond IGNORED -template -gapi::cpu::GOCVFunctor gapi::cpu::ocv_kernel(Callable& c) -{ - using P = cv::detail::OCVCallHelper; - return GOCVFunctor{ K::id() - , &K::getOutMeta - , std::bind(&P::callFunctor, std::placeholders::_1, std::ref(c)) - }; -} - -template -gapi::cpu::GOCVFunctor gapi::cpu::ocv_kernel(const Callable& c) -{ - using P = cv::detail::OCVCallHelper; - return GOCVFunctor{ K::id() - , &K::getOutMeta - , std::bind(&P::callFunctor, std::placeholders::_1, c) - }; -} -//! @endcond - -} // namespace cv - -#if defined _MSC_VER -#pragma warning(pop) -#endif - -#endif // OPENCV_GAPI_GCPUKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/cpu/imgproc.hpp b/modules/gapi/include/opencv2/gapi/cpu/imgproc.hpp deleted file mode 100644 index 0b96db08ae..0000000000 --- a/modules/gapi/include/opencv2/gapi/cpu/imgproc.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_CPU_IMGPROC_API_HPP -#define OPENCV_GAPI_CPU_IMGPROC_API_HPP - -#include // GAPI_EXPORTS -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace imgproc { -namespace cpu { - -GAPI_EXPORTS GKernelPackage kernels(); - -} // namespace cpu -} // namespace imgproc -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_CPU_IMGPROC_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/cpu/ot.hpp b/modules/gapi/include/opencv2/gapi/cpu/ot.hpp deleted file mode 100644 index 03dbe904cc..0000000000 --- a/modules/gapi/include/opencv2/gapi/cpu/ot.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_CPU_OT_API_HPP -#define OPENCV_GAPI_CPU_OT_API_HPP - -#include // GAPI_EXPORTS -#include // GKernelPackage - -namespace cv { -namespace gapi { -/** - * @brief This namespace contains G-API Operation Types for - * VAS Object Tracking module functionality. - */ -namespace ot { -namespace cpu { -GAPI_EXPORTS_W GKernelPackage kernels(); -} // namespace cpu -} // namespace ot -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_CPU_OT_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp b/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp deleted file mode 100644 index e2a2242bd0..0000000000 --- a/modules/gapi/include/opencv2/gapi/cpu/stereo.hpp +++ /dev/null @@ -1,48 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_CPU_STEREO_API_HPP -#define OPENCV_GAPI_CPU_STEREO_API_HPP - -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace calib3d { -namespace cpu { - -GAPI_EXPORTS GKernelPackage kernels(); - -/** @brief Structure for the Stereo operation initialization parameters.*/ -struct GAPI_EXPORTS StereoInitParam { - StereoInitParam(int nD, int bS, double bL, double f): - numDisparities(nD), blockSize(bS), baseline(bL), focus(f) {} - - StereoInitParam() = default; - - int numDisparities = 0; - int blockSize = 21; - double baseline = 63.5; - double focus = 3.6; -}; - -} // namespace cpu -} // namespace calib3d -} // namespace gapi - -namespace detail { - - template<> struct CompileArgTag { - static const char* tag() { - return "org.opencv.stereoInit"; - } -}; - -} // namespace detail -} // namespace cv - - -#endif // OPENCV_GAPI_CPU_STEREO_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/cpu/video.hpp b/modules/gapi/include/opencv2/gapi/cpu/video.hpp deleted file mode 100644 index d3c1f2e670..0000000000 --- a/modules/gapi/include/opencv2/gapi/cpu/video.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_CPU_VIDEO_API_HPP -#define OPENCV_GAPI_CPU_VIDEO_API_HPP - -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace video { -namespace cpu { - -GAPI_EXPORTS GKernelPackage kernels(); - -} // namespace cpu -} // namespace video -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_CPU_VIDEO_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/fluid/core.hpp b/modules/gapi/include/opencv2/gapi/fluid/core.hpp deleted file mode 100644 index a4329d6f50..0000000000 --- a/modules/gapi/include/opencv2/gapi/fluid/core.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_FLUID_CORE_HPP -#define OPENCV_GAPI_FLUID_CORE_HPP - -#include // GKernelPackage -#include // GAPI_EXPORTS - -namespace cv { namespace gapi { namespace core { namespace fluid { - -GAPI_EXPORTS_W cv::GKernelPackage kernels(); - -}}}} - -#endif // OPENCV_GAPI_FLUID_CORE_HPP diff --git a/modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp b/modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp deleted file mode 100644 index 551f0a398f..0000000000 --- a/modules/gapi/include/opencv2/gapi/fluid/gfluidbuffer.hpp +++ /dev/null @@ -1,154 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_FLUID_BUFFER_HPP -#define OPENCV_GAPI_FLUID_BUFFER_HPP - -#include -#include // accumulate -#include // ostream -#include // uint8_t - -#include -#include - -#include - -namespace cv { -namespace gapi { -namespace fluid { - -struct Border -{ - // This constructor is required to support existing kernels which are part of G-API - Border(int _type, cv::Scalar _val) : type(_type), value(_val) {} - - int type; - cv::Scalar value; -}; - -using BorderOpt = util::optional; - -bool operator == (const Border& b1, const Border& b2); - -class GAPI_EXPORTS Buffer; - -class GAPI_EXPORTS View -{ -public: - struct Cache - { - std::vector m_linePtrs; - GMatDesc m_desc; - int m_border_size = 0; - - inline const uint8_t* linePtr(int index) const - { - // "out_of_window" check: - // user must not request the lines which are outside of specified kernel window - GAPI_DbgAssert(index >= -m_border_size - && index < -m_border_size + static_cast(m_linePtrs.size())); - return m_linePtrs[index + m_border_size]; - } - }; - - const inline uint8_t* InLineB(int index) const // -(w-1)/2...0...+(w-1)/2 for Filters - { - return m_cache->linePtr(index); - } - - template const inline T* InLine(int i) const - { - const uint8_t* ptr = this->InLineB(i); - return reinterpret_cast(ptr); - } - - inline operator bool() const { return m_priv != nullptr; } - bool ready() const; - inline int length() const { return m_cache->m_desc.size.width; } - int y() const; - - inline const GMatDesc& meta() const { return m_cache->m_desc; } - - class GAPI_EXPORTS Priv; // internal use only - Priv& priv(); // internal use only - const Priv& priv() const; // internal use only - - View(); - View(std::unique_ptr&& p); - View(View&& v); - View& operator=(View&& v); - ~View(); - -private: - std::unique_ptr m_priv; - const Cache* m_cache = nullptr; -}; - -class GAPI_EXPORTS Buffer -{ -public: - struct Cache - { - std::vector m_linePtrs; - GMatDesc m_desc; - }; - - // Default constructor (executable creation stage, - // all following initialization performed in Priv::init()) - Buffer(); - // Scratch constructor (user kernels) - Buffer(const cv::GMatDesc &desc); - - // Constructor for intermediate buffers (for tests) - Buffer(const cv::GMatDesc &desc, - int max_line_consumption, int border_size, - int skew, - int wlpi, - BorderOpt border); - // Constructor for in/out buffers (for tests) - Buffer(const cv::Mat &data, bool is_input); - ~Buffer(); - Buffer& operator=(Buffer&&); - - inline uint8_t* OutLineB(int index = 0) - { - return m_cache->m_linePtrs[index]; - } - - template inline T* OutLine(int index = 0) - { - uint8_t* ptr = this->OutLineB(index); - return reinterpret_cast(ptr); - } - - int y() const; - - int linesReady() const; - void debug(std::ostream &os) const; - inline int length() const { return m_cache->m_desc.size.width; } - int lpi() const; // LPI for WRITER - - inline const GMatDesc& meta() const { return m_cache->m_desc; } - - View mkView(int borderSize, bool ownStorage); - void addView(const View* v); - - class GAPI_EXPORTS Priv; // internal use only - Priv& priv(); // internal use only - const Priv& priv() const; // internal use only - -private: - std::unique_ptr m_priv; - const Cache* m_cache; -}; - -} // namespace cv::gapi::fluid -} // namespace cv::gapi -} // namespace cv - -#endif // OPENCV_GAPI_FLUID_BUFFER_HPP diff --git a/modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp b/modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp deleted file mode 100644 index c3ae9dfdd6..0000000000 --- a/modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp +++ /dev/null @@ -1,442 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2019 Intel Corporation - - -#ifndef OPENCV_GAPI_FLUID_KERNEL_HPP -#define OPENCV_GAPI_FLUID_KERNEL_HPP - -#include -#include -#include -#include - -#include -#include -#include -#include - -#include - -// FIXME: namespace scheme for backends? -namespace cv { - -namespace gapi -{ -/** - * @brief This namespace contains G-API Fluid backend functions, structures, and symbols. - */ -namespace fluid -{ - /** - * \addtogroup gapi_std_backends G-API Standard Backends - * @{ - */ - /** - * @brief Get a reference to Fluid backend. - * - * @sa gapi_std_backends - */ - GAPI_EXPORTS cv::gapi::GBackend backend(); - /** @} */ -} // namespace fluid -} // namespace gapi - - -class GAPI_EXPORTS GFluidKernel -{ -public: - enum class Kind - { - Filter, - Resize, - YUV420toRGB //Color conversion of 4:2:0 chroma sub-sampling formats (NV12, I420 ..etc) to RGB - }; - - // This function is a generic "doWork" callback - using F = std::function &)>; - - // This function is a generic "initScratch" callback - using IS = std::function; - - // This function is a generic "resetScratch" callback - using RS = std::function; - - // This function describes kernel metadata inference rule. - using M = std::function; - - // This function is a generic "getBorder" callback (extracts border-related data from kernel's input parameters) - using B = std::function; - - // This function is a generic "getWindow" callback (extracts window-related data from kernel's input parameters) - using GW = std::function; - - // FIXME: move implementations out of header file - GFluidKernel() {} - GFluidKernel(Kind k, int l, bool scratch, const F& f, const IS &is, const RS &rs, const B& b, const GW& win) - : m_kind(k) - , m_lpi(l) - , m_scratch(scratch) - , m_f(f) - , m_is(is) - , m_rs(rs) - , m_b(b) - , m_gw(win) {} - - Kind m_kind; - const int m_lpi = -1; - const bool m_scratch = false; - - const F m_f; - const IS m_is; - const RS m_rs; - const B m_b; - const GW m_gw; -}; - -// FIXME!!! -// This is the temporary and experimental API -// which should be replaced by runtime roi-based scheduling -/** \addtogroup gapi_compile_args - * @{ - */ -/** - * @brief This structure allows to control the output image region - * which Fluid backend will produce in the graph. - * - * This feature is useful for external tiling and parallelism, but - * will be deprecated in the future releases. - */ -struct GFluidOutputRois -{ - std::vector rois; -}; - -/** - * @brief This structure forces Fluid backend to generate multiple - * parallel output regions in the graph. These regions execute in parallel. - * - * This feature may be deprecated in the future releases. - */ -struct GFluidParallelOutputRois -{ - std::vector parallel_rois; -}; - -/** - * @brief This structure allows to customize the way how Fluid executes - * parallel regions. - * - * For example, user can utilize his own threading runtime via this parameter. - * The `parallel_for` member functor is called by the Fluid runtime with the - * following arguments: - * - * @param size Size of the parallel range to process - * @param f A function which should be called for every integer index - * in this range by the specified parallel_for implementation. - * - * This feature may be deprecated in the future releases. - */ -struct GFluidParallelFor -{ - //this function accepts: - // - size of the "parallel" range as the first argument - // - and a function to be called on the range items, designated by item index - std::function)> parallel_for; -}; -/** @} gapi_compile_args */ - -namespace detail -{ -template<> struct CompileArgTag -{ - static const char* tag() { return "gapi.fluid.outputRois"; } -}; - -template<> struct CompileArgTag -{ - static const char* tag() { return "gapi.fluid.parallelFor"; } -}; - -template<> struct CompileArgTag -{ - static const char* tag() { return "gapi.fluid.parallelOutputRois"; } -}; - -} // namespace detail - -namespace detail -{ -template struct fluid_get_in; -template<> struct fluid_get_in -{ - static const cv::gapi::fluid::View& get(const cv::GArgs &in_args, int idx) - { - return *in_args[idx].unsafe_get(); - } -}; - -template<> struct fluid_get_in -{ - // FIXME: change to return by reference when moved to own::Scalar - static cv::Scalar get(const cv::GArgs &in_args, int idx) - { - return in_args[idx].unsafe_get(); - } -}; - -template struct fluid_get_in> -{ - static const std::vector& get(const cv::GArgs &in_args, int idx) - { - return in_args.at(idx).unsafe_get().rref(); - } -}; - -template struct fluid_get_in> -{ - static const U& get(const cv::GArgs &in_args, int idx) - { - return in_args.at(idx).unsafe_get().rref(); - } -}; - -template struct fluid_get_in -{ - static const T& get(const cv::GArgs &in_args, int idx) - { - return in_args[idx].unsafe_get(); - } -}; - -template -struct scratch_helper; - -template -struct scratch_helper -{ - // Init - template - static void help_init_impl(const cv::GMetaArgs &metas, - const cv::GArgs &in_args, - gapi::fluid::Buffer &scratch_buf, - detail::Seq) - { - Impl::initScratch(get_in_meta(metas, in_args, IIs)..., scratch_buf); - } - - static void help_init(const cv::GMetaArgs &metas, - const cv::GArgs &in_args, - gapi::fluid::Buffer &b) - { - help_init_impl(metas, in_args, b, typename detail::MkSeq::type()); - } - - // Reset - static void help_reset(gapi::fluid::Buffer &b) - { - Impl::resetScratch(b); - } -}; - -template -struct scratch_helper -{ - static void help_init(const cv::GMetaArgs &, - const cv::GArgs &, - gapi::fluid::Buffer &) - { - GAPI_Error("InternalError"); - } - static void help_reset(gapi::fluid::Buffer &) - { - GAPI_Error("InternalError"); - } -}; - -template struct is_gmat_type -{ - static const constexpr bool value = std::is_same::value; -}; - -template -struct get_border_helper; - -template -struct get_border_helper -{ - template - static gapi::fluid::BorderOpt get_border_impl(const GMetaArgs &metas, - const cv::GArgs &in_args, - cv::detail::Seq) - { - return util::make_optional(Impl::getBorder(cv::detail::get_in_meta(metas, in_args, IIs)...)); - } - - static gapi::fluid::BorderOpt help(const GMetaArgs &metas, - const cv::GArgs &in_args) - { - return get_border_impl(metas, in_args, typename detail::MkSeq::type()); - } -}; - -template -struct get_border_helper -{ - static gapi::fluid::BorderOpt help(const cv::GMetaArgs &, - const cv::GArgs &) - { - return {}; - } -}; - -template -struct get_window_helper; - -template -struct get_window_helper -{ - template - static int get_window_impl(const GMetaArgs &metas, - const cv::GArgs &in_args, - cv::detail::Seq) - { - return Impl::getWindow(cv::detail::get_in_meta(metas, in_args, IIs)...); - } - - static int help(const GMetaArgs &metas, const cv::GArgs &in_args) - { - return get_window_impl(metas, in_args, typename detail::MkSeq::type()); - } -}; - -template -struct get_window_helper -{ - static int help(const cv::GMetaArgs &, - const cv::GArgs &) - { - return Impl::Window; - } -}; - -template -struct has_Window -{ -private: - template - static constexpr auto Check(U*) -> typename std::is_same::type; - - template - static constexpr std::false_type Check(...); - - typedef decltype(Check(0)) Result; - -public: - static constexpr bool value = Result::value; -}; - -template -struct callCustomGetBorder; - -template -struct callCustomGetBorder -{ - static constexpr bool value = (Impl::Window != 1); -}; - -template -struct callCustomGetBorder -{ - static constexpr bool value = true; -}; - -template -struct FluidCallHelper; - -template -struct FluidCallHelper, std::tuple, UseScratch> -{ - static_assert(all_satisfy::value, "return type must be GMat"); - static_assert(contains::value, "input must contain at least one GMat"); - - // Execution dispatcher //////////////////////////////////////////////////// - template - static void call_impl(const cv::GArgs &in_args, - const std::vector &out_bufs, - detail::Seq, - detail::Seq) - { - Impl::run(fluid_get_in::get(in_args, IIs)..., *out_bufs[OIs]...); - } - - static void call(const cv::GArgs &in_args, - const std::vector &out_bufs) - { - constexpr int numOuts = (sizeof...(Outs)) + (UseScratch ? 1 : 0); - call_impl(in_args, out_bufs, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } - - // Scratch buffer initialization dispatcher //////////////////////////////// - static void init_scratch(const GMetaArgs &metas, - const cv::GArgs &in_args, - gapi::fluid::Buffer &b) - { - scratch_helper::help_init(metas, in_args, b); - } - - // Scratch buffer reset dispatcher ///////////////////////////////////////// - static void reset_scratch(gapi::fluid::Buffer &scratch_buf) - { - scratch_helper::help_reset(scratch_buf); - } - - static gapi::fluid::BorderOpt getBorder(const GMetaArgs &metas, const cv::GArgs &in_args) - { - constexpr bool hasWindow = has_Window::value; - - // User must provide "init" callback if Window != 1 - // TODO: move to constexpr if when we enable C++17 - return get_border_helper::value, Impl, Ins...>::help(metas, in_args); - } - - static int getWindow(const GMetaArgs &metas, const cv::GArgs &in_args) - { - constexpr bool callCustomGetWindow = !(has_Window::value); - return get_window_helper::help(metas, in_args); - } -}; -} // namespace detail - - -template -class GFluidKernelImpl : public cv::detail::KernelTag -{ - static const int LPI = 1; - static const auto Kind = GFluidKernel::Kind::Filter; - using P = detail::FluidCallHelper; - -public: - using API = K; - - static GFluidKernel kernel() - { - // FIXME: call() and getOutMeta() needs to be renamed so it is clear these - // functions are internal wrappers, not user API - return GFluidKernel(Impl::Kind, Impl::LPI, - UseScratch, - &P::call, &P::init_scratch, &P::reset_scratch, &P::getBorder, &P::getWindow); - } - - static cv::gapi::GBackend backend() { return cv::gapi::fluid::backend(); } -}; - -#define GAPI_FLUID_KERNEL(Name, API, Scratch) struct Name: public cv::GFluidKernelImpl - -} // namespace cv - -#endif // OPENCV_GAPI_GCPUKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/fluid/imgproc.hpp b/modules/gapi/include/opencv2/gapi/fluid/imgproc.hpp deleted file mode 100644 index a4e8ac0f99..0000000000 --- a/modules/gapi/include/opencv2/gapi/fluid/imgproc.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_FLUID_IMGPROC_HPP -#define OPENCV_GAPI_FLUID_IMGPROC_HPP - -#include // GKernelPackage -#include // GAPI_EXPORTS - -namespace cv { namespace gapi { namespace imgproc { namespace fluid { - -GAPI_EXPORTS_W GKernelPackage kernels(); - -}}}} - -#endif // OPENCV_GAPI_FLUID_IMGPROC_HPP diff --git a/modules/gapi/include/opencv2/gapi/garg.hpp b/modules/gapi/include/opencv2/gapi/garg.hpp deleted file mode 100644 index 2a8315f9d8..0000000000 --- a/modules/gapi/include/opencv2/gapi/garg.hpp +++ /dev/null @@ -1,311 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2021 Intel Corporation - - -#ifndef OPENCV_GAPI_GARG_HPP -#define OPENCV_GAPI_GARG_HPP - -#include -#include -#include - -#include -#include -#include - -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace cv { - -class GArg; - -namespace detail { - template - using is_garg = std::is_same::type>; -} - -// Parameter holder class for a node -// Depending on platform capabilities, can either support arbitrary types -// (as `boost::any`) or a limited number of types (as `boot::variant`). -// FIXME: put into "details" as a user shouldn't use it in his code -class GAPI_EXPORTS GArg -{ -public: - GArg() {} - - template::value, int>::type = 0> - explicit GArg(const T &t) - : kind(detail::GTypeTraits::kind) - , opaque_kind(detail::GOpaqueTraits::kind) - , value(detail::wrap_gapi_helper::wrap(t)) - { - } - - template::value, int>::type = 0> - explicit GArg(T &&t) - : kind(detail::GTypeTraits::type>::kind) - , opaque_kind(detail::GOpaqueTraits::type>::kind) - , value(detail::wrap_gapi_helper::wrap(t)) - { - } - - template inline T& get() - { - return util::any_cast::type>(value); - } - - template inline const T& get() const - { - return util::any_cast::type>(value); - } - - template inline T& unsafe_get() - { - return util::unsafe_any_cast::type>(value); - } - - template inline const T& unsafe_get() const - { - return util::unsafe_any_cast::type>(value); - } - - detail::ArgKind kind = detail::ArgKind::OPAQUE_VAL; - detail::OpaqueKind opaque_kind = detail::OpaqueKind::CV_UNKNOWN; - -protected: - util::any value; -}; - -using GArgs = std::vector; - -// FIXME: Express as M::type -// FIXME: Move to a separate file! -using GRunArgBase = util::variant< -#if !defined(GAPI_STANDALONE) - cv::UMat, -#endif // !defined(GAPI_STANDALONE) - cv::RMat, - cv::gapi::wip::IStreamSource::Ptr, - cv::Mat, - cv::Scalar, - cv::detail::VectorRef, - cv::detail::OpaqueRef, - cv::MediaFrame - >; - -namespace detail { -template -struct in_variant; - -template -struct in_variant > - : std::integral_constant::value > { -}; -} // namespace detail - -struct GAPI_EXPORTS GRunArg: public GRunArgBase -{ - // Metadata information here - using Meta = std::unordered_map; - Meta meta; - - // Mimic the old GRunArg semantics here, old of the times when - // GRunArg was an alias to variant<> - GRunArg(); - GRunArg(const cv::GRunArg &arg); - GRunArg(cv::GRunArg &&arg); - - GRunArg& operator= (const GRunArg &arg); - GRunArg& operator= (GRunArg &&arg); - - template - GRunArg(const T &t, - const Meta &m = Meta{}, - typename std::enable_if< detail::in_variant::value, int>::type = 0) - : GRunArgBase(t) - , meta(m) - { - } - template - GRunArg(T &&t, - const Meta &m = Meta{}, - typename std::enable_if< detail::in_variant::value, int>::type = 0) - : GRunArgBase(std::move(t)) - , meta(m) - { - } - template auto operator= (const T &t) - -> typename std::enable_if< detail::in_variant::value, cv::GRunArg>::type& - { - GRunArgBase::operator=(t); - return *this; - } - template auto operator= (T&& t) - -> typename std::enable_if< detail::in_variant::value, cv::GRunArg>::type& - { - GRunArgBase::operator=(std::move(t)); - return *this; - } -}; -using GRunArgs = std::vector; - -// TODO: Think about the addition operator -/** - * @brief This operator allows to complement the input vector at runtime. - * - * It's an ordinary overload of addition assignment operator. - * - * Example of usage: - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/dynamic_graph_snippets.cpp GRunArgs usage - * - */ -inline GRunArgs& operator += (GRunArgs &lhs, const GRunArgs &rhs) -{ - lhs.reserve(lhs.size() + rhs.size()); - lhs.insert(lhs.end(), rhs.begin(), rhs.end()); - return lhs; -} - -namespace gapi -{ -namespace wip -{ -/** - * @brief This aggregate type represents all types which G-API can - * handle (via variant). - * - * It only exists to overcome C++ language limitations (where a - * `using`-defined class can't be forward-declared). - */ -struct GAPI_EXPORTS Data: public GRunArg -{ - using GRunArg::GRunArg; - template - Data& operator= (const T& t) { GRunArg::operator=(t); return *this; } - template - Data& operator= (T&& t) { GRunArg::operator=(std::move(t)); return *this; } -}; -} // namespace wip -} // namespace gapi - -using GRunArgP = util::variant< -#if !defined(GAPI_STANDALONE) - cv::UMat*, -#endif // !defined(GAPI_STANDALONE) - cv::Mat*, - cv::RMat*, - cv::Scalar*, - cv::MediaFrame*, - cv::detail::VectorRef, - cv::detail::OpaqueRef - >; -using GRunArgsP = std::vector; - -// TODO: Think about the addition operator -/** - * @brief This operator allows to complement the output vector at runtime. - * - * It's an ordinary overload of addition assignment operator. - * - * Example of usage: - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/dynamic_graph_snippets.cpp GRunArgsP usage - * - */ -inline GRunArgsP& operator += (GRunArgsP &lhs, const GRunArgsP &rhs) -{ - lhs.reserve(lhs.size() + rhs.size()); - lhs.insert(lhs.end(), rhs.begin(), rhs.end()); - return lhs; -} - -namespace gapi -{ -/** - * \addtogroup gapi_serialization - * @{ - * - * @brief G-API functions and classes for serialization and deserialization. - */ - -/** @brief Wraps deserialized output GRunArgs to GRunArgsP which can be used by GCompiled. - * - * Since it's impossible to get modifiable output arguments from deserialization - * it needs to be wrapped by this function. - * - * Example of usage: - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp bind after deserialization - * - * @param out_args deserialized GRunArgs. - * @return the same GRunArgs wrapped in GRunArgsP. - * @see deserialize - */ -GAPI_EXPORTS cv::GRunArgsP bind(cv::GRunArgs &out_args); - -/** @brief Wraps output GRunArgsP available during graph execution to GRunArgs which can be serialized. - * - * GRunArgsP is pointer-to-value, so to be serialized they need to be binded to real values - * which this function does. - * - * Example of usage: - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp bind before serialization - * - * @param out output GRunArgsP available during graph execution. - * @return the same GRunArgsP wrapped in serializable GRunArgs. - * @see serialize - */ -GAPI_EXPORTS cv::GRunArg bind(cv::GRunArgP &out); // FIXME: think more about it -/** @} */ -} - -template inline GRunArgs gin(const Ts&... args) -{ - return GRunArgs{ GRunArg(detail::wrap_host_helper::wrap_in(args))... }; -} - -template inline GRunArgsP gout(Ts&... args) -{ - return GRunArgsP{ GRunArgP(detail::wrap_host_helper::wrap_out(args))... }; -} - -struct GTypeInfo; -using GTypesInfo = std::vector; - -// FIXME: Needed for python bridge, must be moved to more appropriate header -namespace detail { -struct ExtractArgsCallback -{ - cv::GRunArgs operator()(const cv::GTypesInfo& info) const { return c(info); } - using CallBackT = std::function; - CallBackT c; -}; - -struct ExtractMetaCallback -{ - cv::GMetaArgs operator()(const cv::GTypesInfo& info) const { return c(info); } - using CallBackT = std::function; - CallBackT c; -}; - -void constructGraphOutputs(const cv::GTypesInfo &out_info, - cv::GRunArgs &args, - cv::GRunArgsP &outs); -} // namespace detail - -} // namespace cv - -#endif // OPENCV_GAPI_GARG_HPP diff --git a/modules/gapi/include/opencv2/gapi/garray.hpp b/modules/gapi/include/opencv2/gapi/garray.hpp deleted file mode 100644 index a2951993f2..0000000000 --- a/modules/gapi/include/opencv2/gapi/garray.hpp +++ /dev/null @@ -1,440 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GARRAY_HPP -#define OPENCV_GAPI_GARRAY_HPP - -#include -#include -#include -#include - -#include -#include - -#include -#include -#include - -#include // flatten_g only! -#include // flatten_g only! - -namespace cv -{ -// Forward declaration; GNode and GOrigin are an internal -// (user-inaccessible) classes. -class GNode; -struct GOrigin; -template class GArray; - -/** - * \addtogroup gapi_meta_args - * @{ - */ -struct GAPI_EXPORTS_W_SIMPLE GArrayDesc -{ - // FIXME: Body - // FIXME: Also implement proper operator== then - bool operator== (const GArrayDesc&) const { return true; } -}; -template GArrayDesc descr_of(const std::vector &) { return {};} -GAPI_EXPORTS_W inline GArrayDesc empty_array_desc() {return {}; } -/** @} */ - -std::ostream& operator<<(std::ostream& os, const cv::GArrayDesc &desc); - -namespace detail -{ - // ConstructVec is a callback which stores information about T and is used by - // G-API runtime to construct arrays in host memory (T remains opaque for G-API). - // ConstructVec is carried into G-API internals by GArrayU. - // Currently it is suitable for Host (CPU) plugins only, real offload may require - // more information for manual memory allocation on-device. - class VectorRef; - using ConstructVec = std::function; - - // This is the base struct for GArrayU type holder - struct TypeHintBase{virtual ~TypeHintBase() = default;}; - - // This class holds type of initial GArray to be checked from GArrayU - template - struct TypeHint final : public TypeHintBase{}; - - // This class strips type information from GArray and makes it usable - // in the G-API graph compiler (expression unrolling, graph generation, etc). - // Part of GProtoArg. - class GAPI_EXPORTS GArrayU - { - public: - GArrayU(const GNode &n, std::size_t out); // Operation result constructor - - template - bool holds() const; // Check if was created from GArray - - GOrigin& priv(); // Internal use only - const GOrigin& priv() const; // Internal use only - - protected: - GArrayU(); // Default constructor - GArrayU(const detail::VectorRef& vref); // Constant value constructor - template friend class cv::GArray; // (available to GArray only) - - void setConstructFcn(ConstructVec &&cv); // Store T-aware constructor - - template - void specifyType(); // Store type of initial GArray - - template - void storeKind(); - - void setKind(cv::detail::OpaqueKind); - - std::shared_ptr m_priv; - std::shared_ptr m_hint; - }; - - template - bool GArrayU::holds() const{ - GAPI_Assert(m_hint != nullptr); - using U = typename std::decay::type; - return dynamic_cast*>(m_hint.get()) != nullptr; - } - - template - void GArrayU::specifyType(){ - m_hint.reset(new TypeHint::type>); - } - - template - void GArrayU::storeKind(){ - setKind(cv::detail::GOpaqueTraits::kind); - } - - // This class represents a typed STL vector reference. - // Depending on origins, this reference may be either "just a" reference to - // an object created externally, OR actually own the underlying object - // (be value holder). - class BasicVectorRef - { - public: - // These fields are set by the derived class(es) - std::size_t m_elemSize = 0ul; - cv::GArrayDesc m_desc; - virtual ~BasicVectorRef() {} - - virtual void mov(BasicVectorRef &ref) = 0; - virtual const void* ptr() const = 0; - virtual std::size_t size() const = 0; - }; - - template class VectorRefT final: public BasicVectorRef - { - using empty_t = util::monostate; - using ro_ext_t = const std::vector *; - using rw_ext_t = std::vector *; - using rw_own_t = std::vector ; - util::variant m_ref; - - inline bool isEmpty() const { return util::holds_alternative(m_ref); } - inline bool isROExt() const { return util::holds_alternative(m_ref); } - inline bool isRWExt() const { return util::holds_alternative(m_ref); } - inline bool isRWOwn() const { return util::holds_alternative(m_ref); } - - void init(const std::vector* vec = nullptr) - { - m_elemSize = sizeof(T); - if (vec) m_desc = cv::descr_of(*vec); - } - - public: - VectorRefT() { init(); } - virtual ~VectorRefT() {} - - explicit VectorRefT(const std::vector& vec) : m_ref(&vec) { init(&vec); } - explicit VectorRefT(std::vector& vec) : m_ref(&vec) { init(&vec); } - explicit VectorRefT(std::vector&& vec) : m_ref(std::move(vec)) { init(&vec); } - - // Reset a VectorRefT. Called only for objects instantiated - // internally in G-API (e.g. temporary GArray's within a - // computation). Reset here means both initialization - // (creating an object) and reset (discarding its existing - // content before the next execution). Must never be called - // for external VectorRefTs. - void reset() - { - if (isEmpty()) - { - std::vector empty_vector; - m_desc = cv::descr_of(empty_vector); - m_ref = std::move(empty_vector); - GAPI_Assert(isRWOwn()); - } - else if (isRWOwn()) - { - util::get(m_ref).clear(); - } - else GAPI_Error("InternalError"); // shouldn't be called in *EXT modes - } - - // Obtain a WRITE reference to underlying object - // Used by CPU kernel API wrappers when a kernel execution frame - // is created - std::vector& wref() - { - GAPI_Assert(isRWExt() || isRWOwn()); - if (isRWExt()) return *util::get(m_ref); - if (isRWOwn()) return util::get(m_ref); - util::throw_error(std::logic_error("Impossible happened")); - } - - // Obtain a READ reference to underlying object - // Used by CPU kernel API wrappers when a kernel execution frame - // is created - const std::vector& rref() const - { - // ANY vector can be accessed for reading, even if it declared for - // output. Example -- a GComputation from [in] to [out1,out2] - // where [out2] is a result of operation applied to [out1]: - // - // GComputation boundary - // . . . . . . . - // . . - // [in] ----> foo() ----> [out1] - // . . : - // . . . .:. . . - // . V . - // . bar() ---> [out2] - // . . . . . . . . . . . . - // - if (isROExt()) return *util::get(m_ref); - if (isRWExt()) return *util::get(m_ref); - if (isRWOwn()) return util::get(m_ref); - util::throw_error(std::logic_error("Impossible happened")); - } - - virtual void mov(BasicVectorRef &v) override { - VectorRefT *tv = dynamic_cast*>(&v); - GAPI_Assert(tv != nullptr); - wref() = std::move(tv->wref()); - } - - virtual const void* ptr() const override { return &rref(); } - virtual std::size_t size() const override { return rref().size(); } - }; - - // This class strips type information from VectorRefT<> and makes it usable - // in the G-API executables (carrying run-time data/information to kernels). - // Part of GRunArg. - // Its methods are typed proxies to VectorRefT. - // VectorRef maintains "reference" semantics so two copies of VectoRef refer - // to the same underlying object. - // FIXME: Put a good explanation on why cv::OutputArray doesn't fit this role - class VectorRef - { - std::shared_ptr m_ref; - cv::detail::OpaqueKind m_kind = cv::detail::OpaqueKind::CV_UNKNOWN; - - template inline void check() const - { - GAPI_DbgAssert(dynamic_cast*>(m_ref.get()) != nullptr); - GAPI_Assert(sizeof(T) == m_ref->m_elemSize); - } - - public: - VectorRef() = default; - template explicit VectorRef(const std::vector& vec) - : m_ref(new VectorRefT(vec)) - , m_kind(GOpaqueTraits::kind) - {} - template explicit VectorRef(std::vector& vec) - : m_ref(new VectorRefT(vec)) - , m_kind(GOpaqueTraits::kind) - {} - template explicit VectorRef(std::vector&& vec) - : m_ref(new VectorRefT(std::move(vec))) - , m_kind(GOpaqueTraits::kind) - {} - - cv::detail::OpaqueKind getKind() const - { - return m_kind; - } - - template void reset() - { - if (!m_ref) m_ref.reset(new VectorRefT()); - check(); - storeKind(); - static_cast&>(*m_ref).reset(); - } - - template - void storeKind() - { - m_kind = cv::detail::GOpaqueTraits::kind; - } - - template std::vector& wref() - { - check(); - return static_cast&>(*m_ref).wref(); - } - - template const std::vector& rref() const - { - check(); - return static_cast&>(*m_ref).rref(); - } - - // Check if was created for/from std::vector - template bool holds() const - { - if (!m_ref) return false; - using U = typename std::decay::type; - return dynamic_cast*>(m_ref.get()) != nullptr; - } - - void mov(VectorRef &v) - { - m_ref->mov(*v.m_ref); - } - - cv::GArrayDesc descr_of() const - { - return m_ref->m_desc; - } - - std::size_t size() const - { - return m_ref->size(); - } - - // May be used to uniquely identify this object internally - const void *ptr() const { return m_ref->ptr(); } - }; - - // Helper (FIXME: work-around?) - // stripping G types to their host types - // like cv::GArray would still map to std::vector - // but not to std::vector -#if defined(GAPI_STANDALONE) -# define FLATTEN_NS cv::gapi::own -#else -# define FLATTEN_NS cv -#endif - template struct flatten_g; - template<> struct flatten_g { using type = FLATTEN_NS::Mat; }; - template<> struct flatten_g { using type = FLATTEN_NS::Scalar; }; - template struct flatten_g> { using type = std::vector; }; - template struct flatten_g { using type = T; }; -#undef FLATTEN_NS - // FIXME: the above mainly duplicates "ProtoToParam" thing from gtyped.hpp - // but I decided not to include gtyped here - probably worth moving that stuff - // to some common place? (DM) -} // namespace detail - -/** \addtogroup gapi_data_objects - * @{ - */ -/** - * @brief `cv::GArray` template class represents a list of objects - * of class `T` in the graph. - * - * `cv::GArray` describes a functional relationship between - * operations consuming and producing arrays of objects of class - * `T`. The primary purpose of `cv::GArray` is to represent a - * dynamic list of objects -- where the size of the list is not known - * at the graph construction or compile time. Examples include: corner - * and feature detectors (`cv::GArray`), object detection - * and tracking results (`cv::GArray`). Programmers can use - * their own types with `cv::GArray` in the custom operations. - * - * Similar to `cv::GScalar`, `cv::GArray` may be value-initialized - * -- in this case a graph-constant value is associated with the object. - * - * `GArray` is a virtual counterpart of `std::vector`, which is - * usually used to represent the `GArray` data in G-API during the - * execution. - * - * @sa `cv::GOpaque` - */ -template class GArray -{ -public: - // Host type (or Flat type) - the type this GArray is actually - // specified to. - /// @private - using HT = typename detail::flatten_g::type>::type; - - /** - * @brief Constructs a value-initialized `cv::GArray` - * - * `cv::GArray` objects may have their values - * be associated at graph construction time. It is useful when - * some operation has a `cv::GArray` input which doesn't change during - * the program execution, and is set only once. In this case, - * there is no need to declare such `cv::GArray` as a graph input. - * - * @note The value of `cv::GArray` may be overwritten by assigning some - * other `cv::GArray` to the object using `operator=` -- on the - * assignment, the old association or value is discarded. - * - * @param v a std::vector to associate with this - * `cv::GArray` object. Vector data is copied into the - * `cv::GArray` (no reference to the passed data is held). - */ - explicit GArray(const std::vector& v) // Constant value constructor - : m_ref(detail::GArrayU(detail::VectorRef(v))) { putDetails(); } - - /** - * @overload - * @brief Constructs a value-initialized `cv::GArray` - * - * @param v a std::vector to associate with this - * `cv::GArray` object. Vector data is moved into the `cv::GArray`. - */ - explicit GArray(std::vector&& v) // Move-constructor - : m_ref(detail::GArrayU(detail::VectorRef(std::move(v)))) { putDetails(); } - - /** - * @brief Constructs an empty `cv::GArray` - * - * Normally, empty G-API data objects denote a starting point of - * the graph. When an empty `cv::GArray` is assigned to a result - * of some operation, it obtains a functional link to this - * operation (and is not empty anymore). - */ - GArray() { putDetails(); } // Empty constructor - - /// @private - explicit GArray(detail::GArrayU &&ref) // GArrayU-based constructor - : m_ref(ref) { putDetails(); } // (used by GCall, not for users) - - /// @private - detail::GArrayU strip() const { - return m_ref; - } - /// @private - static void VCtor(detail::VectorRef& vref) { - vref.reset(); - } - -private: - void putDetails() { - m_ref.setConstructFcn(&VCtor); - m_ref.specifyType(); // FIXME: to unify those 2 to avoid excessive dynamic_cast - m_ref.storeKind(); // - } - - detail::GArrayU m_ref; -}; - -/** @} */ - -} // namespace cv - -#endif // OPENCV_GAPI_GARRAY_HPP diff --git a/modules/gapi/include/opencv2/gapi/gasync_context.hpp b/modules/gapi/include/opencv2/gapi/gasync_context.hpp deleted file mode 100644 index f49b59822d..0000000000 --- a/modules/gapi/include/opencv2/gapi/gasync_context.hpp +++ /dev/null @@ -1,63 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - -#ifndef OPENCV_GAPI_GASYNC_CONTEXT_HPP -#define OPENCV_GAPI_GASYNC_CONTEXT_HPP - -#if !defined(GAPI_STANDALONE) -# include -#else // Without OpenCV -# include -#endif // !defined(GAPI_STANDALONE) - -#include - -namespace cv { -namespace gapi{ - -/** - * @brief This namespace contains experimental G-API functionality, - * functions or structures in this namespace are subjects to change or - * removal in the future releases. This namespace also contains - * functions which API is not stabilized yet. - */ -namespace wip { - -/** - * @brief A class to group async requests to cancel them in a single shot. - * - * GAsyncContext is passed as an argument to async() and async_apply() functions - */ - -class GAPI_EXPORTS GAsyncContext{ - std::atomic cancelation_requested = {false}; -public: - /** - * @brief Start cancellation process for an associated request. - * - * User still has to wait for each individual request (either via callback or according std::future object) to make sure it actually canceled. - * - * @return true if it was a first request to cancel the context - */ - bool cancel(); - - /** - * @brief Returns true if cancellation was requested for this context. - * - * @return true if cancellation was requested for this context - */ - bool isCanceled() const; -}; - -class GAPI_EXPORTS GAsyncCanceled : public std::exception { -public: - virtual const char* what() const noexcept CV_OVERRIDE; -}; -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif //OPENCV_GAPI_GASYNC_CONTEXT_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcall.hpp b/modules/gapi/include/opencv2/gapi/gcall.hpp deleted file mode 100644 index 8d1b8d6010..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcall.hpp +++ /dev/null @@ -1,78 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GCALL_HPP -#define OPENCV_GAPI_GCALL_HPP - -#include // GArg -#include // GMat -#include // GScalar -#include // GFrame -#include // GArray -#include // GOpaque - -namespace cv { - -struct GKernel; - -// The whole idea of this class is to represent an operation -// which is applied to arguments. This is part of public API, -// since it is what users should use to define kernel interfaces. - -class GAPI_EXPORTS GCall final -{ -public: - class Priv; - - explicit GCall(const GKernel &k); - ~GCall(); - - template - GCall& pass(Ts&&... args) - { - setArgs({cv::GArg(std::move(args))...}); - return *this; - } - - // A generic yield method - obtain a link to operator's particular GMat output - GMat yield (int output = 0); - GMatP yieldP (int output = 0); - GScalar yieldScalar(int output = 0); - GFrame yieldFrame (int output = 0); - - template GArray yieldArray(int output = 0) - { - return GArray(yieldArray(output)); - } - - template GOpaque yieldOpaque(int output = 0) - { - return GOpaque(yieldOpaque(output)); - } - - // Internal use only - Priv& priv(); - const Priv& priv() const; - - // GKernel and params can be modified, it's needed for infer, - // because information about output shapes doesn't exist in compile time - GKernel& kernel(); - cv::util::any& params(); - - void setArgs(std::vector &&args); - -protected: - std::shared_ptr m_priv; - - // Public versions return a typed array or opaque, those are implementation details - detail::GArrayU yieldArray(int output = 0); - detail::GOpaqueU yieldOpaque(int output = 0); -}; - -} // namespace cv - -#endif // OPENCV_GAPI_GCALL_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcommon.hpp b/modules/gapi/include/opencv2/gapi/gcommon.hpp deleted file mode 100644 index c61110e4d5..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcommon.hpp +++ /dev/null @@ -1,309 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GCOMMON_HPP -#define OPENCV_GAPI_GCOMMON_HPP - -#include // std::hash -#include // std::vector -#include // decay - -#include - -#include -#include -#include -#include -#include -#include - -namespace cv { - -class GMat; // FIXME: forward declaration for GOpaqueTraits - -namespace detail -{ - // This is a trait-like structure to mark backend-specific compile arguments - // with tags - template struct CompileArgTag; - - // These structures are tags which separate kernels and transformations - struct KernelTag - {}; - struct TransformTag - {}; - - // This enum is utilized mostly by GArray and GOpaque to store and recognize their internal data - // types (aka Host type). Also it is widely used during serialization routine. - enum class OpaqueKind: int - { - CV_UNKNOWN, // Unknown, generic, opaque-to-GAPI data type unsupported in graph seriallization - CV_BOOL, // bool user G-API data - CV_INT, // int user G-API data - CV_INT64, // int64_t user G-API data - CV_DOUBLE, // double user G-API data - CV_FLOAT, // float user G-API data - CV_UINT64, // uint64_t user G-API data - CV_STRING, // std::string user G-API data - CV_POINT, // cv::Point user G-API data - CV_POINT2F, // cv::Point2f user G-API data - CV_POINT3F, // cv::Point3f user G-API data - CV_SIZE, // cv::Size user G-API data - CV_RECT, // cv::Rect user G-API data - CV_SCALAR, // cv::Scalar user G-API data - CV_MAT, // cv::Mat user G-API data - CV_DRAW_PRIM, // cv::gapi::wip::draw::Prim user G-API data - }; - - // Type traits helper which simplifies the extraction of kind from type - template struct GOpaqueTraits; - template struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_UNKNOWN; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_INT; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_INT64; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_DOUBLE; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_FLOAT; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_UINT64; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_BOOL; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_STRING; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_SIZE; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_SCALAR; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_POINT; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_POINT2F; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_POINT3F; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_MAT; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_RECT; }; - template<> struct GOpaqueTraits { static constexpr const OpaqueKind kind = OpaqueKind::CV_MAT; }; - template<> struct GOpaqueTraits - { static constexpr const OpaqueKind kind = OpaqueKind::CV_DRAW_PRIM; }; - using GOpaqueTraitsArrayTypes = std::tuple; - // GOpaque is not supporting cv::Mat and cv::Scalar since there are GScalar and GMat types - using GOpaqueTraitsOpaqueTypes = std::tuple; -} // namespace detail - -// This definition is here because it is reused by both public(?) and internal -// modules. Keeping it here wouldn't expose public details (e.g., API-level) -// to components which are internal and operate on a lower-level entities -// (e.g., compiler, backends). -// FIXME: merge with ArgKind? -// FIXME: replace with variant[format desc]? -enum class GShape: int -{ - GMAT, - GSCALAR, - GARRAY, - GOPAQUE, - GFRAME, -}; - -namespace gapi { -namespace s11n { -namespace detail { -template struct wrap_serialize; -} // namespace detail -} // namespace s11n -} // namespace gapi - - -struct GCompileArg; - -namespace detail { - template - using is_compile_arg = std::is_same::type>; -} // namespace detail - -// CompileArg is an unified interface over backend-specific compilation -// information -// FIXME: Move to a separate file? -/** \addtogroup gapi_compile_args - * @{ - * - * @brief Compilation arguments: data structures controlling the - * compilation process - * - * G-API comes with a number of graph compilation options which can be - * passed to cv::GComputation::apply() or - * cv::GComputation::compile(). Known compilation options are listed - * in this page, while extra backends may introduce their own - * compilation options (G-API transparently accepts _everything_ which - * can be passed to cv::compile_args(), it depends on underlying - * backends if an option would be interpreted or not). - * - * For example, if an example computation is executed like this: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp graph_decl_apply - * - * Extra parameter specifying which kernels to compile with can be - * passed like this: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp apply_with_param - */ - -/** - * @brief Represents an arbitrary compilation argument. - * - * Any value can be wrapped into cv::GCompileArg, but only known ones - * (to G-API or its backends) can be interpreted correctly. - * - * Normally objects of this class shouldn't be created manually, use - * cv::compile_args() function which automatically wraps everything - * passed in (a variadic template parameter pack) into a vector of - * cv::GCompileArg objects. - */ -struct GCompileArg -{ -public: - // NB: Required for pythnon bindings - GCompileArg() = default; - - std::string tag; - - // FIXME: use decay in GArg/other trait-based wrapper before leg is shot! - template::value, int>::type = 0> - explicit GCompileArg(T &&t) - : tag(detail::CompileArgTag::type>::tag()) - , serializeF(cv::gapi::s11n::detail::has_S11N_spec::value ? - &cv::gapi::s11n::detail::wrap_serialize::serialize : - nullptr) - , arg(t) - { - } - - template T& get() - { - return util::any_cast(arg); - } - - template const T& get() const - { - return util::any_cast(arg); - } - - void serialize(cv::gapi::s11n::IOStream& os) const - { - if (serializeF) - { - serializeF(os, *this); - } - } - -private: - std::function serializeF; - util::any arg; -}; - -using GCompileArgs = std::vector; - -inline cv::GCompileArgs& operator += ( cv::GCompileArgs &lhs, - const cv::GCompileArgs &rhs) -{ - lhs.reserve(lhs.size() + rhs.size()); - lhs.insert(lhs.end(), rhs.begin(), rhs.end()); - return lhs; -} - -/** - * @brief Wraps a list of arguments (a parameter pack) into a vector of - * compilation arguments (cv::GCompileArg). - */ -template GCompileArgs compile_args(Ts&&... args) -{ - return GCompileArgs{ GCompileArg(args)... }; -} - -namespace gapi -{ -/** - * @brief Retrieves particular compilation argument by its type from - * cv::GCompileArgs - */ -template -inline cv::util::optional getCompileArg(const cv::GCompileArgs &args) -{ - for (auto &compile_arg : args) - { - if (compile_arg.tag == cv::detail::CompileArgTag::tag()) - { - return cv::util::optional(compile_arg.get()); - } - } - return cv::util::optional(); -} - -namespace s11n { -namespace detail { -template struct wrap_serialize -{ - static void serialize(IOStream& os, const GCompileArg& arg) - { - using DT = typename std::decay::type; - S11N
::serialize(os, arg.get
()); - } -}; -} // namespace detail -} // namespace s11n -} // namespace gapi - -/** @} gapi_compile_args */ - -/** - * @brief Ask G-API to dump compiled graph in Graphviz format under - * the given file name. - * - * Specifies a graph dump path (path to .dot file to be generated). - * G-API will dump a .dot file under specified path during a - * compilation process if this flag is passed. - */ -struct graph_dump_path -{ - std::string m_dump_path; -}; - -/** - * @brief Ask G-API to use threaded executor when cv::GComputation - * is compiled via cv::GComputation::compile method. - * - * Specifies a number of threads that should be used by executor. - */ -struct GAPI_EXPORTS use_threaded_executor -{ - use_threaded_executor(); - explicit use_threaded_executor(const uint32_t nthreads); - - uint32_t num_threads; -}; - -namespace detail -{ - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.graph_dump_path"; } - }; - - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.threaded_executor"; } - }; -} - -} // namespace cv - -// std::hash overload for GShape -namespace std -{ -template<> struct hash -{ - size_t operator() (cv::GShape sh) const - { - return std::hash()(static_cast(sh)); - } -}; -} // namespace std - - -#endif // OPENCV_GAPI_GCOMMON_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcompiled.hpp b/modules/gapi/include/opencv2/gapi/gcompiled.hpp deleted file mode 100644 index ac36783d62..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcompiled.hpp +++ /dev/null @@ -1,232 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GCOMPILED_HPP -#define OPENCV_GAPI_GCOMPILED_HPP - -#include - -#include -#include -#include - -namespace cv { - -// This class represents a compiled computation. -// In theory (and ideally), it can be used w/o the rest of APIs. -// In theory (and ideally), it can be serialized/deserialized. -// It can enable scenarious like deployment to an autonomous devince, FuSa, etc. -// -// Currently GCompiled assumes all GMats you used to pass data to G-API -// are valid and not destroyed while you use a GCompiled object. -// -// FIXME: In future, there should be a way to name I/O objects and specify it -// to GCompiled externally (for example, when it is loaded on the target system). - -/** - * \addtogroup gapi_main_classes - * @{ - */ -/** - * @brief Represents a compiled computation (graph). Can only be used - * with image / data formats & resolutions it was compiled for, with - * some exceptions. - * - * This class represents a product of graph compilation (calling - * cv::GComputation::compile()). Objects of this class actually do - * data processing, and graph execution is incapsulated into objects - * of this class. Execution model itself depends on kernels and - * backends which were using during the compilation, see @ref - * gapi_compile_args for details. - * - * In a general case, GCompiled objects can be applied to data only in - * that formats/resolutions they were compiled for (see @ref - * gapi_meta_args). However, if the underlying backends allow, a - * compiled object can be _reshaped_ to handle data (images) of - * different resolution, though formats and types must remain the same. - * - * GCompiled is very similar to `std::function<>` in its semantics -- - * running it looks like a function call in the user code. - * - * At the moment, GCompiled objects are not reentrant -- generally, - * the objects are stateful since graph execution itself is a stateful - * process and this state is now maintained in GCompiled's own memory - * (not on the process stack). - * - * At the same time, two different GCompiled objects produced from the - * single cv::GComputation are completely independent and can be used - * concurrently. - * - * @sa GStreamingCompiled - */ -class GAPI_EXPORTS GCompiled -{ -public: - /// @private - class GAPI_EXPORTS Priv; - - /** - * @brief Constructs an empty object - */ - GCompiled(); - - /** - * @brief Run the compiled computation, a generic version. - * - * @param ins vector of inputs to process. - * @param outs vector of outputs to produce. - * - * Input/output vectors must have the same number of elements as - * defined in the cv::GComputation protocol (at the moment of its - * construction). Shapes of elements also must conform to protocol - * (e.g. cv::Mat needs to be passed where cv::GMat has been - * declared as input, and so on). Run-time exception is generated - * otherwise. - * - * Objects in output vector may remain empty (like cv::Mat) -- - * G-API will automatically initialize output objects to proper formats. - * - * @note Don't construct GRunArgs/GRunArgsP objects manually, use - * cv::gin()/cv::gout() wrappers instead. - */ - void operator() (GRunArgs &&ins, GRunArgsP &&outs); // Generic arg-to-arg -#if !defined(GAPI_STANDALONE) - - /** - * @brief Execute an unary computation - * - * @overload - * @param in input cv::Mat for unary computation - * @param out output cv::Mat for unary computation - * process. - */ - void operator() (cv::Mat in, cv::Mat &out); // Unary overload - - /** - * @brief Execute an unary computation - * - * @overload - * @param in input cv::Mat for unary computation - * @param out output cv::Scalar for unary computation - * process. - */ - void operator() (cv::Mat in, cv::Scalar &out); // Unary overload (scalar) - - /** - * @brief Execute a binary computation - * - * @overload - * @param in1 first input cv::Mat for binary computation - * @param in2 second input cv::Mat for binary computation - * @param out output cv::Mat for binary computation - * process. - */ - void operator() (cv::Mat in1, cv::Mat in2, cv::Mat &out); // Binary overload - - /** - * @brief Execute an binary computation - * - * @overload - * @param in1 first input cv::Mat for binary computation - * @param in2 second input cv::Mat for binary computation - * @param out output cv::Scalar for binary computation - * process. - */ - void operator() (cv::Mat in1, cv::Mat in2, cv::Scalar &out); // Binary overload (scalar) - - /** - * @brief Execute a computation with arbitrary number of - * inputs/outputs. - * - * @overload - * @param ins vector of input cv::Mat objects to process by the - * computation. - * @param outs vector of output cv::Mat objects to produce by the - * computation. - * - * Numbers of elements in ins/outs vectors must match numbers of - * inputs/outputs which were used to define the source GComputation. - */ - void operator() (const std::vector &ins, // Compatibility overload - const std::vector &outs); -#endif // !defined(GAPI_STANDALONE) - /// @private - Priv& priv(); - - /** - * @brief Check if compiled object is valid (non-empty) - * - * @return true if the object is runnable (valid), false otherwise - */ - explicit operator bool () const; - - /** - * @brief Vector of metadata this graph was compiled for. - * - * @return Unless _reshape_ is not supported, return value is the - * same vector which was passed to cv::GComputation::compile() to - * produce this compiled object. Otherwise, it is the latest - * metadata vector passed to reshape() (if that call was - * successful). - */ - const GMetaArgs& metas() const; // Meta passed to compile() - - /** - * @brief Vector of metadata descriptions of graph outputs - * - * @return vector with formats/resolutions of graph's output - * objects, auto-inferred from input metadata vector by - * operations which form this computation. - * - * @note GCompiled objects produced from the same - * cv::GComputiation graph with different input metas may return - * different values in this vector. - */ - const GMetaArgs& outMetas() const; - - /** - * @brief Check if the underlying backends support reshape or not. - * - * @return true if supported, false otherwise. - */ - bool canReshape() const; - - /** - * @brief Reshape a compiled graph to support new image - * resolutions. - * - * Throws an exception if an error occurs. - * - * @param inMetas new metadata to reshape on. Vector size and - * metadata shapes must match the computation's protocol. - * @param args compilation arguments to use. - */ - // FIXME: Why it requires compile args? - void reshape(const GMetaArgs& inMetas, const GCompileArgs& args); - - /** - * @brief Prepare inner kernels states for a new video-stream. - * - * GCompiled objects may be used to process video streams frame by frame. - * In this case, a GCompiled is called on every image frame individually. - * Starting OpenCV 4.4, some kernels in the graph may have their internal - * states (see GAPI_OCV_KERNEL_ST for the OpenCV backend). - * In this case, if user starts processing another video stream with - * this GCompiled, this method needs to be called to let kernels re-initialize - * their internal states to a new video stream. - */ - void prepareForNewStream(); - -protected: - /// @private - std::shared_ptr m_priv; -}; -/** @} */ - -} - -#endif // OPENCV_GAPI_GCOMPILED_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcompiled_async.hpp b/modules/gapi/include/opencv2/gapi/gcompiled_async.hpp deleted file mode 100644 index a0c2917d6a..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcompiled_async.hpp +++ /dev/null @@ -1,73 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - - -#ifndef OPENCV_GAPI_GCOMPILED_ASYNC_HPP -#define OPENCV_GAPI_GCOMPILED_ASYNC_HPP - -#include //for std::future -#include //for std::exception_ptr -#include //for std::function -#include -#include - -namespace cv { - //fwd declaration - class GCompiled; - -namespace gapi{ -namespace wip { - class GAsyncContext; - /** - These functions asynchronously (i.e. probably on a separate thread of execution) call GCompiled::operator() member function of their first argument with copies of rest of arguments (except callback) passed in. - The difference between the function is the way to get the completion notification (via callback or a waiting on std::future object) - If exception is occurred during execution of apply it is transferred to the callback (via function parameter) or passed to future (and will be thrown on call to std::future::get) - - N.B. : - Input arguments are copied on call to async function (actually on call to cv::gin) and thus do not have to outlive the actual completion of asynchronous activity. - While output arguments are "captured" by reference(pointer) and therefore _must_ outlive the asynchronous activity - (i.e. live at least until callback is called or future is unblocked) - - @param gcmpld Compiled computation (graph) to start asynchronously - @param callback Callback to be called when execution of gcmpld is done - @param ins Input parameters for gcmpld - @param outs Output parameters for gcmpld - */ - GAPI_EXPORTS void async(GCompiled& gcmpld, std::function&& callback, GRunArgs &&ins, GRunArgsP &&outs); - - /** @overload - @param gcmpld Compiled computation (graph) to run asynchronously - @param callback Callback to be called when execution of gcmpld is done - @param ins Input parameters for gcmpld - @param outs Output parameters for gcmpld - @param ctx Context this request belongs to - @see async GAsyncContext - */ - GAPI_EXPORTS void async(GCompiled& gcmpld, std::function&& callback, GRunArgs &&ins, GRunArgsP &&outs, GAsyncContext& ctx); - - /** @overload - @param gcmpld Compiled computation (graph) to run asynchronously - @param ins Input parameters for gcmpld - @param outs Output parameters for gcmpld - @return std::future object to wait for completion of async operation - @see async - */ - GAPI_EXPORTS std::future async(GCompiled& gcmpld, GRunArgs &&ins, GRunArgsP &&outs); - - /** - @param gcmpld Compiled computation (graph) to run asynchronously - @param ins Input parameters for gcmpld - @param outs Output parameters for gcmpld - @param ctx Context this request belongs to - @return std::future object to wait for completion of async operation - @see async GAsyncContext - */ - GAPI_EXPORTS std::future async(GCompiled& gcmpld, GRunArgs &&ins, GRunArgsP &&outs, GAsyncContext& ctx); -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_GCOMPILED_ASYNC_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcompoundkernel.hpp b/modules/gapi/include/opencv2/gapi/gcompoundkernel.hpp deleted file mode 100644 index df0ce34045..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcompoundkernel.hpp +++ /dev/null @@ -1,139 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2019 Intel Corporation - - -#ifndef OPENCV_GAPI_GCOMPOUNDKERNEL_HPP -#define OPENCV_GAPI_GCOMPOUNDKERNEL_HPP - -#include -#include -#include -#include - -namespace cv { -namespace gapi -{ -namespace compound -{ - // FIXME User does not need to know about this function - // Needs that user may define compound kernels(as cpu kernels) - GAPI_EXPORTS cv::gapi::GBackend backend(); -} // namespace compound -} // namespace gapi - -namespace detail -{ - -struct GCompoundContext -{ - explicit GCompoundContext(const GArgs& in_args); - template - const T& inArg(int input) { return m_args.at(input).get(); } - - GArgs m_args; - GArgs m_results; -}; - -class GAPI_EXPORTS GCompoundKernel -{ -// Compound kernel must use all of it's inputs -public: - using F = std::function; - - explicit GCompoundKernel(const F& f); - void apply(GCompoundContext& ctx); - -protected: - F m_f; -}; - -template struct get_compound_in -{ - static T get(GCompoundContext &ctx, int idx) { return ctx.inArg(idx); } -}; - -template struct get_compound_in> -{ - static cv::GArray get(GCompoundContext &ctx, int idx) - { - auto array = cv::GArray(); - ctx.m_args[idx] = GArg(array); - return array; - } -}; - -template struct get_compound_in> -{ - static cv::GOpaque get(GCompoundContext &ctx, int idx) - { - auto opaq = cv::GOpaque(); - ctx.m_args[idx] = GArg(opaq); - return opaq; - } -}; - -template<> struct get_compound_in -{ - static cv::GMatP get(GCompoundContext &ctx, int idx) - { - auto mat = cv::GMatP(); - ctx.m_args[idx] = GArg(mat); - return mat; - } -}; - -template -struct GCompoundCallHelper; - -template -struct GCompoundCallHelper, std::tuple > -{ - template - static void expand_impl(GCompoundContext &ctx, detail::Seq, detail::Seq) - { - auto result = Impl::expand(get_compound_in::get(ctx, IIs)...); - auto tuple_return = tuple_wrap_helper::get(std::move(result)); - ctx.m_results = { cv::GArg(std::get(tuple_return))... }; - } - - static void expand(GCompoundContext &ctx) - { - expand_impl(ctx, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } -}; - -template -class GCompoundKernelImpl: public cv::detail::GCompoundCallHelper, - public cv::detail::KernelTag -{ - using P = cv::detail::GCompoundCallHelper; - -public: - using API = K; - - static cv::gapi::GBackend backend() { return cv::gapi::compound::backend(); } - static GCompoundKernel kernel() { return GCompoundKernel(&P::expand); } -}; - -} // namespace detail - - -/** - * Declares a new compound kernel. See this - * [documentation chapter](@ref gapi_kernel_compound) - * on compound kernels for more details. - * - * @param Name type name for new kernel - * @param API the interface this kernel implements - */ -#define GAPI_COMPOUND_KERNEL(Name, API) \ - struct Name: public cv::detail::GCompoundKernelImpl - -} // namespace cv - -#endif // OPENCV_GAPI_GCOMPOUNDKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcomputation.hpp b/modules/gapi/include/opencv2/gapi/gcomputation.hpp deleted file mode 100644 index 196eb37c6b..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcomputation.hpp +++ /dev/null @@ -1,581 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GCOMPUTATION_HPP -#define OPENCV_GAPI_GCOMPUTATION_HPP - -#include - -#include -#include -#include -#include -#include -#include - -namespace cv { - -namespace detail -{ - // FIXME: move to algorithm, cover with separate tests - // FIXME: replace with O(1) version (both memory and compilation time) - template - struct last_type; - - template - struct last_type { using type = T;}; - - template - struct last_type { using type = typename last_type::type; }; - - template - using last_type_t = typename last_type::type; -} - -// Forward-declare the serialization objects -namespace gapi { -namespace s11n { - struct IIStream; - struct IOStream; -} // namespace s11n -} // namespace gapi - -/** - * \addtogroup gapi_main_classes - * @{ - * - * @brief G-API classes for constructed and compiled graphs. - */ - -/** - * @brief GComputation class represents a captured computation - * graph. GComputation objects form boundaries for expression code - * user writes with G-API, allowing to compile and execute it. - * - * G-API computations are defined with input/output data - * objects. G-API will track automatically which operations connect - * specified outputs to the inputs, forming up a call graph to be - * executed. The below example expresses calculation of Sobel operator - * for edge detection (\f$G = \sqrt{G_x^2 + G_y^2}\f$): - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp graph_def - * - * Full pipeline can be now captured with this object declaration: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp graph_cap_full - * - * Input/output data objects on which a call graph should be - * reconstructed are passed using special wrappers cv::GIn and - * cv::GOut. G-API will track automatically which operations form a - * path from inputs to outputs and build the execution graph appropriately. - * - * Note that cv::GComputation doesn't take ownership on data objects - * it is defined. Moreover, multiple GComputation objects may be - * defined on the same expressions, e.g. a smaller pipeline which - * expects that image gradients are already pre-calculated may be - * defined like this: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp graph_cap_sub - * - * The resulting graph would expect two inputs and produce one - * output. In this case, it doesn't matter if gx/gy data objects are - * results of cv::gapi::Sobel operators -- G-API will stop unrolling - * expressions and building the underlying graph one reaching this - * data objects. - * - * The way how GComputation is defined is important as its definition - * specifies graph _protocol_ -- the way how the graph should be - * used. Protocol is defined by number of inputs, number of outputs, - * and shapes of inputs and outputs. - * - * In the above example, sobelEdge expects one Mat on input and - * produces one Mat; while sobelEdgeSub expects two Mats on input and - * produces one Mat. GComputation's protocol defines how other - * computation methods should be used -- cv::GComputation::compile() and - * cv::GComputation::apply(). For example, if a graph is defined on - * two GMat inputs, two cv::Mat objects have to be passed to apply() - * for execution. GComputation checks protocol correctness in runtime - * so passing a different number of objects in apply() or passing - * cv::Scalar instead of cv::Mat there would compile well as a C++ - * source but raise an exception in run-time. G-API also comes with a - * typed wrapper cv::GComputationT<> which introduces this type-checking in - * compile-time. - * - * cv::GComputation itself is a thin object which just captures what - * the graph is. The compiled graph (which actually process data) is - * represented by class GCompiled. Use compile() method to generate a - * compiled graph with given compile options. cv::GComputation can - * also be used to process data with implicit graph compilation - * on-the-fly, see apply() for details. - * - * GComputation is a reference-counted object -- once defined, all its - * copies will refer to the same instance. - * - * @sa GCompiled - */ -class GAPI_EXPORTS_W GComputation -{ -public: - class Priv; - typedef std::function Generator; - - // Various constructors enable different ways to define a computation: ///// - // 1. Generic constructors - /** - * @brief Define a computation using a generator function. - * - * Graph can be defined in-place directly at the moment of its - * construction with a lambda: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp graph_gen - * - * This may be useful since all temporary objects (cv::GMats) and - * namespaces can be localized to scope of lambda, without - * contaminating the parent scope with probably unnecessary objects - * and information. - * - * @param gen generator function which returns a cv::GComputation, - * see Generator. - */ - GComputation(const Generator& gen); // Generator - // overload - - /** - * @brief Generic GComputation constructor. - * - * Constructs a new graph with a given protocol, specified as a - * flow of operations connecting input/output objects. Throws if - * the passed boundaries are invalid, e.g. if there's no - * functional dependency (path) between given outputs and inputs. - * - * @param ins Input data vector. - * @param outs Output data vector. - * - * @note Don't construct GProtoInputArgs/GProtoOutputArgs objects - * directly, use cv::GIn()/cv::GOut() wrapper functions instead. - * - * @sa @ref gapi_data_objects - */ - GAPI_WRAP GComputation(GProtoInputArgs &&ins, - GProtoOutputArgs &&outs); // Arg-to-arg overload - - // 2. Syntax sugar and compatibility overloads - /** - * @brief Defines an unary (one input -- one output) computation - * - * @overload - * @param in input GMat of the defined unary computation - * @param out output GMat of the defined unary computation - */ - GAPI_WRAP GComputation(GMat in, GMat out); // Unary overload - - /** - * @brief Defines an unary (one input -- one output) computation - * - * @overload - * @param in input GMat of the defined unary computation - * @param out output GScalar of the defined unary computation - */ - GAPI_WRAP GComputation(GMat in, GScalar out); // Unary overload (scalar) - - /** - * @brief Defines a binary (two inputs -- one output) computation - * - * @overload - * @param in1 first input GMat of the defined binary computation - * @param in2 second input GMat of the defined binary computation - * @param out output GMat of the defined binary computation - */ - GAPI_WRAP GComputation(GMat in1, GMat in2, GMat out); // Binary overload - - /** - * @brief Defines a binary (two inputs -- one output) computation - * - * @overload - * @param in1 first input GMat of the defined binary computation - * @param in2 second input GMat of the defined binary computation - * @param out output GScalar of the defined binary computation - */ - GComputation(GMat in1, GMat in2, GScalar out); // Binary - // overload - // (scalar) - - /** - * @brief Defines a computation with arbitrary input/output number. - * - * @overload - * @param ins vector of inputs GMats for this computation - * @param outs vector of outputs GMats for this computation - * - * Use this overload for cases when number of computation - * inputs/outputs is not known in compile-time -- e.g. when graph - * is programmatically generated to build an image pyramid with - * the given number of levels, etc. - */ - GComputation(const std::vector &ins, // Compatibility overload - const std::vector &outs); - - // Various versions of apply(): //////////////////////////////////////////// - // 1. Generic apply() - /** - * @brief Compile graph on-the-fly and immediately execute it on - * the inputs data vectors. - * - * Number of input/output data objects must match GComputation's - * protocol, also types of host data objects (cv::Mat, cv::Scalar) - * must match the shapes of data objects from protocol (cv::GMat, - * cv::GScalar). If there's a mismatch, a run-time exception will - * be generated. - * - * Internally, a cv::GCompiled object is created for the given - * input format configuration, which then is executed on the input - * data immediately. cv::GComputation caches compiled objects - * produced within apply() -- if this method would be called next - * time with the same input parameters (image formats, image - * resolution, etc), the underlying compiled graph will be reused - * without recompilation. If new metadata doesn't match the cached - * one, the underlying compiled graph is regenerated. - * - * @note compile() always triggers a compilation process and - * produces a new GCompiled object regardless if a similar one has - * been cached via apply() or not. - * - * @param ins vector of input data to process. Don't create - * GRunArgs object manually, use cv::gin() wrapper instead. - * @param outs vector of output data to fill results in. cv::Mat - * objects may be empty in this vector, G-API will automatically - * initialize it with the required format & dimensions. Don't - * create GRunArgsP object manually, use cv::gout() wrapper instead. - * @param args a list of compilation arguments to pass to the - * underlying compilation process. Don't create GCompileArgs - * object manually, use cv::compile_args() wrapper instead. - * - * @sa @ref gapi_data_objects, @ref gapi_compile_args - */ - void apply(GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {}); // Arg-to-arg overload - - /// @private -- Exclude this function from OpenCV documentation - GAPI_WRAP GRunArgs apply(const cv::detail::ExtractArgsCallback &callback, - GCompileArgs &&args = {}); - - /// @private -- Exclude this function from OpenCV documentation - void apply(const std::vector& ins, // Compatibility overload - const std::vector& outs, - GCompileArgs &&args = {}); - - // 2. Syntax sugar and compatibility overloads -#if !defined(GAPI_STANDALONE) - /** - * @brief Execute an unary computation (with compilation on the fly) - * - * @overload - * @param in input cv::Mat for unary computation - * @param out output cv::Mat for unary computation - * @param args compilation arguments for underlying compilation - * process. - */ - void apply(cv::Mat in, cv::Mat &out, GCompileArgs &&args = {}); // Unary overload - - /** - * @brief Execute an unary computation (with compilation on the fly) - * - * @overload - * @param in input cv::Mat for unary computation - * @param out output cv::Scalar for unary computation - * @param args compilation arguments for underlying compilation - * process. - */ - void apply(cv::Mat in, cv::Scalar &out, GCompileArgs &&args = {}); // Unary overload (scalar) - - /** - * @brief Execute a binary computation (with compilation on the fly) - * - * @overload - * @param in1 first input cv::Mat for binary computation - * @param in2 second input cv::Mat for binary computation - * @param out output cv::Mat for binary computation - * @param args compilation arguments for underlying compilation - * process. - */ - void apply(cv::Mat in1, cv::Mat in2, cv::Mat &out, GCompileArgs &&args = {}); // Binary overload - - /** - * @brief Execute an binary computation (with compilation on the fly) - * - * @overload - * @param in1 first input cv::Mat for binary computation - * @param in2 second input cv::Mat for binary computation - * @param out output cv::Scalar for binary computation - * @param args compilation arguments for underlying compilation - * process. - */ - void apply(cv::Mat in1, cv::Mat in2, cv::Scalar &out, GCompileArgs &&args = {}); // Binary overload (scalar) - - /** - * @brief Execute a computation with arbitrary number of - * inputs/outputs (with compilation on-the-fly). - * - * @overload - * @param ins vector of input cv::Mat objects to process by the - * computation. - * @param outs vector of output cv::Mat objects to produce by the - * computation. - * @param args compilation arguments for underlying compilation - * process. - * - * Numbers of elements in ins/outs vectors must match numbers of - * inputs/outputs which were used to define this GComputation. - */ - void apply(const std::vector& ins, // Compatibility overload - std::vector& outs, - GCompileArgs &&args = {}); -#endif // !defined(GAPI_STANDALONE) - // Various versions of compile(): ////////////////////////////////////////// - // 1. Generic compile() - requires metas to be passed as vector - /** - * @brief Compile the computation for specific input format(s). - * - * This method triggers compilation process and produces a new - * GCompiled object which then can process data of the given - * format. Passing data with different format to the compiled - * computation will generate a run-time exception. - * - * @param in_metas vector of input metadata configuration. Grab - * metadata from real data objects (like cv::Mat or cv::Scalar) - * using cv::descr_of(), or create it on your own. - * @param args compilation arguments for this compilation - * process. Compilation arguments directly affect what kind of - * executable object would be produced, e.g. which kernels (and - * thus, devices) would be used to execute computation. - * - * @return GCompiled, an executable computation compiled - * specifically for the given input parameters. - * - * @sa @ref gapi_compile_args - */ - GCompiled compile(GMetaArgs &&in_metas, GCompileArgs &&args = {}); - - // 2. Syntax sugar - variadic list of metas, no extra compile args - // FIXME: SFINAE looks ugly in the generated documentation - /** - * @overload - * - * Takes a variadic parameter pack with metadata - * descriptors for which a compiled object needs to be produced. - * - * @return GCompiled, an executable computation compiled - * specifically for the given input parameters. - */ - template - auto compile(const Ts&... metas) -> - typename std::enable_if::value, GCompiled>::type - { - return compile(GMetaArgs{GMetaArg(metas)...}, GCompileArgs()); - } - - // 3. Syntax sugar - variadic list of metas, extra compile args - // (seems optional parameters don't work well when there's an variadic template - // comes first) - // - // Ideally it should look like: - // - // template - // GCompiled compile(const Ts&... metas, GCompileArgs &&args) - // - // But not all compilers can handle this (and seems they shouldn't be able to). - // FIXME: SFINAE looks ugly in the generated documentation - /** - * @overload - * - * Takes a variadic parameter pack with metadata - * descriptors for which a compiled object needs to be produced, - * followed by GCompileArgs object representing compilation - * arguments for this process. - * - * @return GCompiled, an executable computation compiled - * specifically for the given input parameters. - */ - template - auto compile(const Ts&... meta_and_compile_args) -> - typename std::enable_if::value - && std::is_same >::value, - GCompiled>::type - { - //FIXME: wrapping meta_and_compile_args into a tuple to unwrap them inside a helper function is the overkill - return compile(std::make_tuple(meta_and_compile_args...), - typename detail::MkSeq::type()); - } - - - // FIXME: Document properly in the Doxygen format - // Video-oriented pipeline compilation: - // 1. A generic version - /** - * @brief Compile the computation for streaming mode. - * - * This method triggers compilation process and produces a new - * GStreamingCompiled object which then can process video stream - * data of the given format. Passing a stream in a different - * format to the compiled computation will generate a run-time - * exception. - * - * @param in_metas vector of input metadata configuration. Grab - * metadata from real data objects (like cv::Mat or cv::Scalar) - * using cv::descr_of(), or create it on your own. - * - * @param args compilation arguments for this compilation - * process. Compilation arguments directly affect what kind of - * executable object would be produced, e.g. which kernels (and - * thus, devices) would be used to execute computation. - * - * @return GStreamingCompiled, a streaming-oriented executable - * computation compiled specifically for the given input - * parameters. - * - * @sa @ref gapi_compile_args - */ - GAPI_WRAP GStreamingCompiled compileStreaming(GMetaArgs &&in_metas, GCompileArgs &&args = {}); - - /** - * @brief Compile the computation for streaming mode. - * - * This method triggers compilation process and produces a new - * GStreamingCompiled object which then can process video stream - * data in any format. Underlying mechanisms will be adjusted to - * every new input video stream automatically, but please note that - * _not all_ existing backends support this (see reshape()). - * - * @param args compilation arguments for this compilation - * process. Compilation arguments directly affect what kind of - * executable object would be produced, e.g. which kernels (and - * thus, devices) would be used to execute computation. - * - * @return GStreamingCompiled, a streaming-oriented executable - * computation compiled for any input image format. - * - * @sa @ref gapi_compile_args - */ - GAPI_WRAP GStreamingCompiled compileStreaming(GCompileArgs &&args = {}); - - /// @private -- Exclude this function from OpenCV documentation - GAPI_WRAP GStreamingCompiled compileStreaming(const cv::detail::ExtractMetaCallback &callback, - GCompileArgs &&args = {}); - - // 2. Direct metadata version - /** - * @overload - * - * Takes a variadic parameter pack with metadata - * descriptors for which a compiled object needs to be produced. - * - * @return GStreamingCompiled, a streaming-oriented executable - * computation compiled specifically for the given input - * parameters. - */ - template - auto compileStreaming(const Ts&... metas) -> - typename std::enable_if::value, GStreamingCompiled>::type - { - return compileStreaming(GMetaArgs{GMetaArg(metas)...}, GCompileArgs()); - } - - // 2. Direct metadata + compile arguments version - /** - * @overload - * - * Takes a variadic parameter pack with metadata - * descriptors for which a compiled object needs to be produced, - * followed by GCompileArgs object representing compilation - * arguments for this process. - * - * @return GStreamingCompiled, a streaming-oriented executable - * computation compiled specifically for the given input - * parameters. - */ - template - auto compileStreaming(const Ts&... meta_and_compile_args) -> - typename std::enable_if::value - && std::is_same >::value, - GStreamingCompiled>::type - { - //FIXME: wrapping meta_and_compile_args into a tuple to unwrap them inside a helper function is the overkill - return compileStreaming(std::make_tuple(meta_and_compile_args...), - typename detail::MkSeq::type()); - } - - // Internal use only - /// @private - Priv& priv(); - /// @private - const Priv& priv() const; - /// @private - explicit GComputation(cv::gapi::s11n::IIStream &); - /// @private - void serialize(cv::gapi::s11n::IOStream &) const; - -protected: - - // 4. Helper methods for (3) - /// @private - template - GCompiled compile(const std::tuple &meta_and_compile_args, detail::Seq) - { - GMetaArgs meta_args = {GMetaArg(std::get(meta_and_compile_args))...}; - GCompileArgs comp_args = std::get(meta_and_compile_args); - return compile(std::move(meta_args), std::move(comp_args)); - } - template - GStreamingCompiled compileStreaming(const std::tuple &meta_and_compile_args, detail::Seq) - { - GMetaArgs meta_args = {GMetaArg(std::get(meta_and_compile_args))...}; - GCompileArgs comp_args = std::get(meta_and_compile_args); - return compileStreaming(std::move(meta_args), std::move(comp_args)); - } - void recompile(GMetaArgs&& in_metas, GCompileArgs &&args); - /// @private - std::shared_ptr m_priv; -}; -/** @} */ - -namespace gapi -{ - // FIXME: all these standalone functions need to be added to some - // common documentation section - /** - * @brief Define an tagged island (subgraph) within a computation. - * - * Declare an Island tagged with `name` and defined from `ins` to `outs` - * (exclusively, as ins/outs are data objects, and regioning is done on - * operations level). - * Throws if any operation between `ins` and `outs` are already assigned - * to another island. - * - * Islands allow to partition graph into subgraphs, fine-tuning - * the way it is scheduled by the underlying executor. - * - * @param name name of the Island to create - * @param ins vector of input data objects where the subgraph - * begins - * @param outs vector of output data objects where the subgraph - * ends. - * - * The way how an island is defined is similar to how - * cv::GComputation is defined on input/output data objects. - * Same rules apply here as well -- if there's no functional - * dependency between inputs and outputs or there's not enough - * input data objects were specified to properly calculate all - * outputs, an exception is thrown. - * - * Use cv::GIn() / cv::GOut() to specify input/output vectors. - */ - void GAPI_EXPORTS island(const std::string &name, - GProtoInputArgs &&ins, - GProtoOutputArgs &&outs); -} // namespace gapi - -} // namespace cv -#endif // OPENCV_GAPI_GCOMPUTATION_HPP diff --git a/modules/gapi/include/opencv2/gapi/gcomputation_async.hpp b/modules/gapi/include/opencv2/gapi/gcomputation_async.hpp deleted file mode 100644 index 8af603efea..0000000000 --- a/modules/gapi/include/opencv2/gapi/gcomputation_async.hpp +++ /dev/null @@ -1,69 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - -#ifndef OPENCV_GAPI_GCOMPUTATION_ASYNC_HPP -#define OPENCV_GAPI_GCOMPUTATION_ASYNC_HPP - - -#include //for std::future -#include //for std::exception_ptr -#include //for std::function -#include //for GRunArgs, GRunArgsP -#include //for GCompileArgs -#include - - -namespace cv { - //fwd declaration - class GComputation; -namespace gapi { -namespace wip { - class GAsyncContext; - /** In contrast to async() functions, these do call GComputation::apply() member function of the GComputation passed in. - - @param gcomp Computation (graph) to run asynchronously - @param callback Callback to be called when execution of gcomp is done - @param ins Input parameters for gcomp - @param outs Output parameters for gcomp - @param args Compile arguments to pass to GComputation::apply() - @see async - */ - GAPI_EXPORTS void async_apply(GComputation& gcomp, std::function&& callback, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {}); - /** @overload - @param gcomp Computation (graph) to run asynchronously - @param callback Callback to be called when execution of gcomp is done - @param ins Input parameters for gcomp - @param outs Output parameters for gcomp - @param args Compile arguments to pass to GComputation::apply() - @param ctx Context this request belongs to - @see async_apply async GAsyncContext - */ - GAPI_EXPORTS void async_apply(GComputation& gcomp, std::function&& callback, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args, GAsyncContext& ctx); - /** @overload - @param gcomp Computation (graph) to run asynchronously - @param ins Input parameters for gcomp - @param outs Output parameters for gcomp - @param args Compile arguments to pass to GComputation::apply() - @return std::future object to wait for completion of async operation - @see async_apply async - */ - GAPI_EXPORTS std::future async_apply(GComputation& gcomp, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args = {}); - /** @overload - @param gcomp Computation (graph) to run asynchronously - @param ins Input parameters for gcomp - @param outs Output parameters for gcomp - @param args Compile arguments to pass to GComputation::apply() - @param ctx Context this request belongs to - @return std::future object to wait for completion of async operation - @see async_apply async GAsyncContext - */ - GAPI_EXPORTS std::future async_apply(GComputation& gcomp, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args, GAsyncContext& ctx); -} // namespace wip -} // namespace gapi -} // namespace cv - - -#endif //OPENCV_GAPI_GCOMPUTATION_ASYNC_HPP diff --git a/modules/gapi/include/opencv2/gapi/gframe.hpp b/modules/gapi/include/opencv2/gapi/gframe.hpp deleted file mode 100644 index 54fb30789e..0000000000 --- a/modules/gapi/include/opencv2/gapi/gframe.hpp +++ /dev/null @@ -1,113 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GFRAME_HPP -#define OPENCV_GAPI_GFRAME_HPP - -#include -#include // std::shared_ptr - -#include -#include // GShape - -#include -#include - -// TODO GAPI_EXPORTS or so -namespace cv -{ -// Forward declaration; GNode and GOrigin are an internal -// (user-inaccessible) classes. -class GNode; -struct GOrigin; - -/** \addtogroup gapi_data_objects - * @{ - */ -/** - * @brief GFrame class represents an image or media frame in the graph. - * - * GFrame doesn't store any data itself, instead it describes a - * functional relationship between operations consuming and producing - * GFrame objects. - * - * GFrame is introduced to handle various media formats (e.g., NV12 or - * I420) under the same type. Various image formats may differ in the - * number of planes (e.g. two for NV12, three for I420) and the pixel - * layout inside. GFrame type allows to handle these media formats in - * the graph uniformly -- the graph structure will not change if the - * media format changes, e.g. a different camera or decoder is used - * with the same graph. G-API provides a number of operations which - * operate directly on GFrame, like `infer<>()` or - * renderFrame(); these operations are expected to handle different - * media formats inside. There is also a number of accessor - * operations like BGR(), Y(), UV() -- these operations provide - * access to frame's data in the familiar cv::GMat form, which can be - * used with the majority of the existing G-API operations. These - * accessor functions may perform color space conversion on the fly if - * the image format of the GFrame they are applied to differs from the - * operation's semantic (e.g. the BGR() accessor is called on an NV12 - * image frame). - * - * GFrame is a virtual counterpart of cv::MediaFrame. - * - * @sa cv::MediaFrame, cv::GFrameDesc, BGR(), Y(), UV(), infer<>(). - */ -class GAPI_EXPORTS_W_SIMPLE GFrame -{ -public: - /** - * @brief Constructs an empty GFrame - * - * Normally, empty G-API data objects denote a starting point of - * the graph. When an empty GFrame is assigned to a result of some - * operation, it obtains a functional link to this operation (and - * is not empty anymore). - */ - GAPI_WRAP GFrame(); // Empty constructor - - /// @private - GFrame(const GNode &n, std::size_t out); // Operation result constructor - /// @private - GOrigin& priv(); // Internal use only - /// @private - const GOrigin& priv() const; // Internal use only - -private: - std::shared_ptr m_priv; -}; -/** @} */ - -enum class MediaFormat: int -{ - BGR = 0, - NV12, - GRAY, -}; - -/** - * \addtogroup gapi_meta_args - * @{ - */ -struct GAPI_EXPORTS GFrameDesc -{ - MediaFormat fmt; - cv::Size size; - - bool operator== (const GFrameDesc &) const; -}; -static inline GFrameDesc empty_gframe_desc() { return GFrameDesc{}; } -/** @} */ - -class MediaFrame; -GAPI_EXPORTS GFrameDesc descr_of(const MediaFrame &frame); - -GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const cv::GFrameDesc &desc); - -} // namespace cv - -#endif // OPENCV_GAPI_GFRAME_HPP diff --git a/modules/gapi/include/opencv2/gapi/gkernel.hpp b/modules/gapi/include/opencv2/gapi/gkernel.hpp deleted file mode 100644 index 6ec6bf573d..0000000000 --- a/modules/gapi/include/opencv2/gapi/gkernel.hpp +++ /dev/null @@ -1,757 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2021 Intel Corporation - - -#ifndef OPENCV_GAPI_GKERNEL_HPP -#define OPENCV_GAPI_GKERNEL_HPP - -#include -#include -#include // string -#include // false_type, true_type -#include // map (for GKernelPackage) -#include // tuple - -#include // CompileArgTag -#include // Seq -#include -#include // GArg -#include // GMetaArg -#include // GTypeTraits -#include //suppress_unused_warning -#include - -namespace cv { - -struct GTypeInfo -{ - GShape shape; - cv::detail::OpaqueKind kind; - detail::HostCtor ctor; -}; - -using GShapes = std::vector; -using GKinds = std::vector; -using GCtors = std::vector; -using GTypesInfo = std::vector; - -// GKernel describes kernel API to the system -// FIXME: add attributes of a kernel, (e.g. number and types -// of inputs, etc) -struct GAPI_EXPORTS GKernel -{ - using M = std::function; - - std::string name; // kernel ID, defined by its API (signature) - std::string tag; // some (implementation-specific) tag - M outMeta; // generic adaptor to API::outMeta(...) - GShapes outShapes; // types (shapes) kernel's outputs - GKinds inKinds; // kinds of kernel's inputs (fixme: below) - GCtors outCtors; // captured constructors for template output types - GKinds outKinds; // kinds of kernel's outputs (fixme: below) -}; -// TODO: It's questionable if inKinds should really be here. Instead, -// this information could come from meta. - -// GKernelImpl describes particular kernel implementation to the system -struct GAPI_EXPORTS GKernelImpl -{ - util::any opaque; // backend-specific opaque info - GKernel::M outMeta; // for deserialized graphs, the outMeta is taken here -}; - -template class GKernelTypeM; - -namespace detail -{ - //////////////////////////////////////////////////////////////////////////// - // yield() is used in graph construction time as a generic method to obtain - // lazy "return value" of G-API operations - // - template struct Yield; - template<> struct Yield - { - static inline cv::GMat yield(cv::GCall &call, int i) { return call.yield(i); } - }; - template<> struct Yield - { - static inline cv::GMatP yield(cv::GCall &call, int i) { return call.yieldP(i); } - }; - template<> struct Yield - { - static inline cv::GScalar yield(cv::GCall &call, int i) { return call.yieldScalar(i); } - }; - template struct Yield > - { - static inline cv::GArray yield(cv::GCall &call, int i) { return call.yieldArray(i); } - }; - template struct Yield > - { - static inline cv::GOpaque yield(cv::GCall &call, int i) { return call.yieldOpaque(i); } - }; - template<> struct Yield - { - static inline cv::GFrame yield(cv::GCall &call, int i) { return call.yieldFrame(i); } - }; - - //////////////////////////////////////////////////////////////////////////// - // Helper classes which brings outputMeta() marshalling to kernel - // implementations - // - // 1. MetaType establishes G#Type -> G#Meta mapping between G-API dynamic - // types and its metadata descriptor types. - // This mapping is used to transform types to call outMeta() callback. - template struct MetaType; - template<> struct MetaType { using type = GMatDesc; }; - template<> struct MetaType { using type = GMatDesc; }; - template<> struct MetaType { using type = GFrameDesc; }; - template<> struct MetaType { using type = GScalarDesc; }; - template struct MetaType > { using type = GArrayDesc; }; - template struct MetaType > { using type = GOpaqueDesc; }; - template struct MetaType { using type = T; }; // opaque args passed as-is - // FIXME: Move it to type traits? - - // 2. Hacky test based on MetaType to check if we operate on G-* type or not - template using is_nongapi_type = std::is_same::type>; - - // 3. Two ways to transform input arguments to its meta - for G-* and non-G* types: - template - typename std::enable_if::value, typename MetaType::type> - ::type get_in_meta(const GMetaArgs &in_meta, const GArgs &, int idx) - { - return util::get::type>(in_meta.at(idx)); - } - - template - typename std::enable_if::value, T> - ::type get_in_meta(const GMetaArgs &, const GArgs &in_args, int idx) - { - return in_args.at(idx).template get(); - } - - // 4. The MetaHelper itself: an entity which generates outMeta() call - // based on kernel signature, with arguments properly substituted. - // 4.1 - case for multiple return values - // FIXME: probably can be simplified with std::apply or analogue. - template - struct MetaHelper; - - template - struct MetaHelper, std::tuple > - { - template - static GMetaArgs getOutMeta_impl(const GMetaArgs &in_meta, - const GArgs &in_args, - detail::Seq, - detail::Seq) - { - // FIXME: decay? - using R = std::tuple::type...>; - const R r = K::outMeta( get_in_meta(in_meta, in_args, IIs)... ); - return GMetaArgs{ GMetaArg(std::get(r))... }; - } - // FIXME: help users identify how outMeta must look like (via default impl w/static_assert?) - - static GMetaArgs getOutMeta(const GMetaArgs &in_meta, - const GArgs &in_args) - { - return getOutMeta_impl(in_meta, - in_args, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } - }; - - // 4.1 - case for a single return value - // FIXME: How to avoid duplication here? - template - struct MetaHelper, Out > - { - template - static GMetaArgs getOutMeta_impl(const GMetaArgs &in_meta, - const GArgs &in_args, - detail::Seq) - { - // FIXME: decay? - using R = typename MetaType::type; - const R r = K::outMeta( get_in_meta(in_meta, in_args, IIs)... ); - return GMetaArgs{ GMetaArg(r) }; - } - // FIXME: help users identify how outMeta must look like (via default impl w/static_assert?) - - static GMetaArgs getOutMeta(const GMetaArgs &in_meta, - const GArgs &in_args) - { - return getOutMeta_impl(in_meta, - in_args, - typename detail::MkSeq::type()); - } - }; - - //////////////////////////////////////////////////////////////////////////// - // Helper class to introduce tags to calls. By default there's no tag - struct NoTag { - static constexpr const char *tag() { return ""; } - }; - -} // namespace detail - -// GKernelType and GKernelTypeM are base classes which implement typed ::on() -// method based on kernel signature. GKernelTypeM stands for multiple-return-value kernels -// -// G_TYPED_KERNEL and G_TYPED_KERNEL_M macros inherit user classes from GKernelType and -// GKernelTypeM respectively. - -template -class GKernelTypeM(Args...)> > - : public detail::MetaHelper, std::tuple> - , public detail::NoTag -{ - template - static std::tuple yield(cv::GCall &call, detail::Seq) - { - return std::make_tuple(detail::Yield::yield(call, IIs)...); - } - -public: - using InArgs = std::tuple; - using OutArgs = std::tuple; - - // TODO: Args&&... here? - static std::tuple on(Args... args) - { - cv::GCall call(GKernel{ K::id() - , K::tag() - , &K::getOutMeta - , {detail::GTypeTraits::shape...} - , {detail::GTypeTraits::op_kind...} - , {detail::GObtainCtor::get()...} - , {detail::GTypeTraits::op_kind...}}); - call.pass(args...); // TODO: std::forward() here? - return yield(call, typename detail::MkSeq::type()); - } -}; - -template class GKernelType; - -template -class GKernelType > - : public detail::MetaHelper, R> - , public detail::NoTag -{ -public: - using InArgs = std::tuple; - using OutArgs = std::tuple; - - static R on(Args... args) - { - cv::GCall call(GKernel{ K::id() - , K::tag() - , &K::getOutMeta - , {detail::GTypeTraits::shape} - , {detail::GTypeTraits::op_kind...} - , {detail::GObtainCtor::get()} - , {detail::GTypeTraits::op_kind}}); - call.pass(args...); - return detail::Yield::yield(call, 0); - } -}; - -namespace detail { -// This tiny class eliminates the semantic difference between -// GKernelType and GKernelTypeM. -template class KernelTypeMedium; - -template -class KernelTypeMedium(Args...)>> : - public cv::GKernelTypeM(Args...)>> {}; - -template -class KernelTypeMedium> : - public cv::GKernelType> {}; -} // namespace detail - -} // namespace cv - - -// FIXME: I don't know a better way so far. Feel free to suggest one -// The problem is that every typed kernel should have ::id() but body -// of the class is defined by user (with outMeta, other stuff) - -//! @cond IGNORED -#define G_ID_HELPER_CLASS(Class) Class##IdHelper - -#define G_ID_HELPER_BODY(Class, Id) \ - struct G_ID_HELPER_CLASS(Class) \ - { \ - static constexpr const char * id() {return Id;} \ - }; \ -//! @endcond - -#define GET_G_TYPED_KERNEL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, NAME, ...) NAME -#define COMBINE_SIGNATURE(...) __VA_ARGS__ -// Ensure correct __VA_ARGS__ expansion on Windows -#define __WRAP_VAARGS(x) x - -/** - * Helper for G_TYPED_KERNEL declares a new G-API Operation. See [Kernel API](@ref gapi_kernel_api) - * for more details. - * - * @param Class type name for this operation. - * @param API an `std::function<>`-like signature for the operation; - * return type is a single value or a tuple of multiple values. - * @param Id string identifier for the operation. Must be unique. - */ -#define G_TYPED_KERNEL_HELPER(Class, API, Id) \ - G_ID_HELPER_BODY(Class, Id) \ - struct Class final: public cv::detail::KernelTypeMedium, \ - public G_ID_HELPER_CLASS(Class) -// {body} is to be defined by user - -#define G_TYPED_KERNEL_HELPER_2(Class, _1, _2, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2), Id) - -#define G_TYPED_KERNEL_HELPER_3(Class, _1, _2, _3, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3), Id) - -#define G_TYPED_KERNEL_HELPER_4(Class, _1, _2, _3, _4, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4), Id) - -#define G_TYPED_KERNEL_HELPER_5(Class, _1, _2, _3, _4, _5, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5), Id) - -#define G_TYPED_KERNEL_HELPER_6(Class, _1, _2, _3, _4, _5, _6, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6), Id) - -#define G_TYPED_KERNEL_HELPER_7(Class, _1, _2, _3, _4, _5, _6, _7, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7), Id) - -#define G_TYPED_KERNEL_HELPER_8(Class, _1, _2, _3, _4, _5, _6, _7, _8, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7, _8), Id) - -#define G_TYPED_KERNEL_HELPER_9(Class, _1, _2, _3, _4, _5, _6, _7, _8, _9, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7, _8, _9), Id) - -#define G_TYPED_KERNEL_HELPER_10(Class, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, Id) \ -G_TYPED_KERNEL_HELPER(Class, COMBINE_SIGNATURE(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10), Id) - -/** - * Declares a new G-API Operation. See [Kernel API](@ref gapi_kernel_api) - * for more details. - * - * @param Class type name for this operation. - */ -#define G_TYPED_KERNEL(Class, ...) __WRAP_VAARGS(GET_G_TYPED_KERNEL(__VA_ARGS__, \ - G_TYPED_KERNEL_HELPER_10, \ - G_TYPED_KERNEL_HELPER_9, \ - G_TYPED_KERNEL_HELPER_8, \ - G_TYPED_KERNEL_HELPER_7, \ - G_TYPED_KERNEL_HELPER_6, \ - G_TYPED_KERNEL_HELPER_5, \ - G_TYPED_KERNEL_HELPER_4, \ - G_TYPED_KERNEL_HELPER_3, \ - G_TYPED_KERNEL_HELPER_2, \ - G_TYPED_KERNEL_HELPER)(Class, __VA_ARGS__)) \ - -/** - * Declares a new G-API Operation. See [Kernel API](@ref gapi_kernel_api) for more details. - * - * @deprecated This macro is deprecated in favor of `G_TYPED_KERNEL` that is used for declaring any - * G-API Operation. - * - * @param Class type name for this operation. - */ -#define G_TYPED_KERNEL_M G_TYPED_KERNEL - -#define G_API_OP G_TYPED_KERNEL -#define G_API_OP_M G_API_OP - -namespace cv -{ -namespace gapi -{ - // Prework: model "Device" API before it gets to G-API headers. - // FIXME: Don't mix with internal Backends class! - /// @private - class GAPI_EXPORTS GBackend - { - public: - class Priv; - - // TODO: make it template (call `new` within??) - GBackend(); - explicit GBackend(std::shared_ptr &&p); - - Priv& priv(); - const Priv& priv() const; - std::size_t hash() const; - - bool operator== (const GBackend &rhs) const; - - private: - std::shared_ptr m_priv; - }; - - inline bool operator != (const GBackend &lhs, const GBackend &rhs) - { - return !(lhs == rhs); - } -} // namespace gapi -} // namespace cv - -namespace std -{ - template<> struct hash - { - std::size_t operator() (const cv::gapi::GBackend &b) const - { - return b.hash(); - } - }; -} // namespace std - -namespace cv { - class GAPI_EXPORTS_W_SIMPLE GKernelPackage; - -namespace gapi { - GAPI_EXPORTS_W cv::GKernelPackage combine(const cv::GKernelPackage &lhs, - const cv::GKernelPackage &rhs); - - /// @private - class GFunctor - { - public: - virtual cv::GKernelImpl impl() const = 0; - virtual cv::gapi::GBackend backend() const = 0; - const char* id() const { return m_id; } - - virtual ~GFunctor() = default; - protected: - GFunctor(const char* id) : m_id(id) { } - private: - const char* m_id; - }; -} // namespace gapi - - /** \addtogroup gapi_compile_args - * @{ - */ - - // FIXME: Hide implementation - /** - * @brief A container class for heterogeneous kernel - * implementation collections and graph transformations. - * - * GKernelPackage is a special container class which stores kernel - * _implementations_ and graph _transformations_. Objects of this class - * are created and passed to cv::GComputation::compile() to specify - * which kernels to use and which transformations to apply in the - * compiled graph. GKernelPackage may contain kernels of - * different backends, e.g. be heterogeneous. - * - * The most easy way to create a kernel package is to use function - * cv::gapi::kernels(). This template functions takes kernel - * implementations in form of type list (variadic template) and - * generates a kernel package atop of that. - * - * Kernel packages can be also generated programmatically, starting - * with an empty package (created with the default constructor) - * and then by populating it with kernels via call to - * GKernelPackage::include(). Note this method is also a template - * one since G-API kernel and transformation implementations are _types_, - * not objects. - * - * Finally, two kernel packages can be combined into a new one - * with function cv::gapi::combine(). - */ - class GAPI_EXPORTS_W_SIMPLE GKernelPackage - { - - /// @private - using M = std::unordered_map>; - - /// @private - M m_id_kernels; - - /// @private - std::vector m_transformations; - - protected: - /// @private - // Remove ALL implementations of the given API (identified by ID) - void removeAPI(const std::string &id); - - /// @private - // Partial include() specialization for kernels - template - typename std::enable_if<(std::is_base_of::value), void>::type - includeHelper() - { - auto backend = KImpl::backend(); - auto kernel_id = KImpl::API::id(); - auto kernel_impl = GKernelImpl{KImpl::kernel(), &KImpl::API::getOutMeta}; - removeAPI(kernel_id); - - m_id_kernels[kernel_id] = std::make_pair(backend, kernel_impl); - } - - /// @private - // Partial include() specialization for transformations - template - typename std::enable_if<(std::is_base_of::value), void>::type - includeHelper() - { - m_transformations.emplace_back(TImpl::transformation()); - } - - public: - void include(const cv::gapi::GFunctor& functor); - - /** - * @brief Returns total number of kernels - * in the package (across all backends included) - * - * @return a number of kernels in the package - */ - GAPI_WRAP std::size_t size() const; - - /** - * @brief Returns vector of transformations included in the package - * - * @return vector of transformations included in the package - */ - const std::vector& get_transformations() const; - - /** - * @brief Returns vector of kernel ids included in the package - * - * @return vector of kernel ids included in the package - */ - std::vector get_kernel_ids() const; - - /** - * @brief Test if a particular kernel _implementation_ KImpl is - * included in this kernel package. - * - * @sa includesAPI() - * - * @note cannot be applied to transformations - * - * @return true if there is such kernel, false otherwise. - */ - template - bool includes() const - { - static_assert(std::is_base_of::value, - "includes() can be applied to kernels only"); - - auto kernel_it = m_id_kernels.find(KImpl::API::id()); - return kernel_it != m_id_kernels.end() && - kernel_it->second.first == KImpl::backend(); - } - - /** - * @brief Remove all kernels associated with the given backend - * from the package. - * - * Does nothing if there's no kernels of this backend in the package. - * - * @param backend backend which kernels to remove - */ - void remove(const cv::gapi::GBackend& backend); - - /** - * @brief Remove all kernels implementing the given API from - * the package. - * - * Does nothing if there's no kernels implementing the given interface. - */ - template - void remove() - { - removeAPI(KAPI::id()); - } - - // FIXME: Rename to includes() and distinguish API/impl case by - // statically? - /** - * Check if package contains ANY implementation of a kernel API - * by API type. - */ - template - bool includesAPI() const - { - return includesAPI(KAPI::id()); - } - - /// @private - bool includesAPI(const std::string &id) const; - - // FIXME: The below comment is wrong, and who needs this function? - /** - * @brief Find a kernel (by its API) - * - * Returns implementation corresponding id. - * Throws if nothing found. - * - * @return Backend which hosts matching kernel implementation. - * - */ - template - cv::gapi::GBackend lookup() const - { - return lookup(KAPI::id()).first; - } - - /// @private - std::pair - lookup(const std::string &id) const; - - // FIXME: No overwrites allowed? - /** - * @brief Put a new kernel implementation or a new transformation - * KImpl into the package. - */ - template - void include() - { - includeHelper(); - } - - /** - * @brief Adds a new kernel based on it's backend and id into the kernel package - * - * @param backend backend associated with the kernel - * @param kernel_id a name/id of the kernel - */ - void include(const cv::gapi::GBackend& backend, const std::string& kernel_id); - - /** - * @brief Lists all backends which are included into package - * - * @return vector of backends - */ - std::vector backends() const; - - // TODO: Doxygen bug -- it wants me to place this comment - // here, not below. - /** - * @brief Create a new package based on `lhs` and `rhs`. - * - * @param lhs "Left-hand-side" package in the process - * @param rhs "Right-hand-side" package in the process - * @return a new kernel package. - */ - friend GAPI_EXPORTS GKernelPackage cv::gapi::combine(const GKernelPackage &lhs, - const GKernelPackage &rhs); - }; - /** @} */ - -namespace gapi { - using GKernelPackage = cv::GKernelPackage; // Keep backward compatibility - - /** \addtogroup gapi_compile_args - * @{ - */ - - /** - * @brief Create a kernel package object containing kernels - * and transformations specified in variadic template argument. - * - * In G-API, kernel implementations and transformations are _types_. - * Every backend has its own kernel API (like GAPI_OCV_KERNEL() and - * GAPI_FLUID_KERNEL()) but all of that APIs define a new type for - * each kernel implementation. - * - * Use this function to pass kernel implementations (defined in - * either way) and transformations to the system. Example: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp kernels_snippet - * - * Note that kernels() itself is a function returning object, not - * a type, so having `()` at the end is important -- it must be a - * function call. - */ - template GKernelPackage kernels() - { - // FIXME: currently there is no check that transformations' signatures are unique - // and won't be any intersection in graph compilation stage - static_assert(cv::detail::all_unique::value, "Kernels API must be unique"); - - GKernelPackage pkg; - - // For those who wonder - below is a trick to call a number of - // methods based on parameter pack (zeroes just help hiding these - // calls into a sequence which helps to expand this parameter pack). - // Just note that `f(),a` always equals to `a` (with f() called!) - // and parentheses are used to hide function call in the expanded sequence. - // Leading 0 helps to handle case when KK is an empty list (kernels<>()). - int unused[] = { 0, (pkg.include(), 0)... }; - cv::util::suppress_unused_warning(unused); - return pkg; - } - - template - GKernelPackage kernels(FF&... functors) - { - GKernelPackage pkg; - int unused[] = { 0, (pkg.include(functors), 0)... }; - cv::util::suppress_unused_warning(unused); - return pkg; - } - - /** @} */ - - /** - * @brief Combines multiple G-API kernel packages into one - * - * @overload - * - * This function successively combines the passed kernel packages using a right fold. - * Calling `combine(a, b, c)` is equal to `combine(a, combine(b, c))`. - * - * @return The resulting kernel package - */ - template - cv::GKernelPackage combine(const cv::GKernelPackage &a, const cv::GKernelPackage &b, Ps&&... rest) - { - return combine(a, combine(b, rest...)); - } - // NB(DM): Variadic-arg version in Python may require the same - // approach as used in GComputation::compile/apply. - - /** \addtogroup gapi_compile_args - * @{ - */ - /** - * @brief cv::gapi::use_only() is a special combinator which hints G-API to use only - * kernels specified in cv::GComputation::compile() (and not to extend kernels available by - * default with that package). - */ - struct GAPI_EXPORTS use_only - { - GKernelPackage pkg; - }; - /** @} */ - -} // namespace gapi - -namespace detail -{ - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.kernel_package"; } - }; - - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.use_only"; } - }; -} // namespace detail - -} // namespace cv - -#endif // OPENCV_GAPI_GKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/gmat.hpp b/modules/gapi/include/opencv2/gapi/gmat.hpp deleted file mode 100644 index 6d6f74ff7f..0000000000 --- a/modules/gapi/include/opencv2/gapi/gmat.hpp +++ /dev/null @@ -1,292 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GMAT_HPP -#define OPENCV_GAPI_GMAT_HPP - -#include -#include // std::shared_ptr - -#include -#include // GShape - -#include - -// TODO GAPI_EXPORTS or so -namespace cv -{ -// Forward declaration; GNode and GOrigin are an internal -// (user-inaccessible) classes. -class GNode; -struct GOrigin; - -/** \addtogroup gapi_data_objects - * @{ - * - * @brief G-API data objects used to build G-API expressions. - * - * These objects do not own any particular data (except compile-time - * associated values like with cv::GScalar or `cv::GArray`) and are - * used only to construct graphs. - * - * Every graph in G-API starts and ends with data objects. - * - * Once constructed and compiled, G-API operates with regular host-side - * data instead. Refer to the below table to find the mapping between - * G-API and regular data types when passing input and output data - * structures to G-API: - * - * G-API data type | I/O data type - * ------------------ | ------------- - * cv::GMat | cv::Mat, cv::UMat, cv::RMat - * cv::GScalar | cv::Scalar - * `cv::GArray` | std::vector - * `cv::GOpaque` | T - * cv::GFrame | cv::MediaFrame - */ - -/** - * @brief GMat class represents image or tensor data in the - * graph. - * - * GMat doesn't store any data itself, instead it describes a - * functional relationship between operations consuming and producing - * GMat objects. - * - * GMat is a virtual counterpart of Mat and UMat, but it - * doesn't mean G-API use Mat or UMat objects internally to represent - * GMat objects -- the internal data representation may be - * backend-specific or optimized out at all. - * - * @sa Mat, GMatDesc - */ -class GAPI_EXPORTS_W_SIMPLE GMat -{ -public: - /** - * @brief Constructs an empty GMat - * - * Normally, empty G-API data objects denote a starting point of - * the graph. When an empty GMat is assigned to a result of some - * operation, it obtains a functional link to this operation (and - * is not empty anymore). - */ - GAPI_WRAP GMat(); // Empty constructor - - /** - * @brief Constructs a value-initialized GMat - * - * GMat may be associated with a buffer at graph construction time. - * It is useful when some operation has a Mat input which doesn't - * change during the program execution, and is set only once. - * In this case, there's no need to declare such GMat as graph input. - * - * @param m a cv::Mat buffer to associate with this GMat object. - */ - GAPI_WRAP explicit GMat(cv::Mat m); // Value-initialization constructor - - /// @private - GMat(const GNode &n, std::size_t out); // Operation result constructor - /// @private - GOrigin& priv(); // Internal use only - /// @private - const GOrigin& priv() const; // Internal use only - -private: - std::shared_ptr m_priv; -}; - -class GAPI_EXPORTS GMatP : public GMat -{ -public: - using GMat::GMat; -}; - -class RMat; - -/** @} */ - -/** - * \addtogroup gapi_meta_args - * @{ - */ -struct GAPI_EXPORTS_W_SIMPLE GMatDesc -{ - // FIXME: Default initializers in C++14 - GAPI_PROP int depth; - GAPI_PROP int chan; - GAPI_PROP cv::Size size; // NB.: no multi-dimensional cases covered yet - GAPI_PROP bool planar; - GAPI_PROP std::vector dims; // FIXME: Maybe it's real questionable to have it here - - GAPI_WRAP GMatDesc(int d, int c, cv::Size s, bool p = false) - : depth(d), chan(c), size(s), planar(p) {} - - GAPI_WRAP GMatDesc(int d, const std::vector &dd) - : depth(d), chan(-1), size{-1,-1}, planar(false), dims(dd) {} - - GAPI_WRAP GMatDesc(int d, std::vector &&dd) - : depth(d), chan(-1), size{-1,-1}, planar(false), dims(std::move(dd)) {} - - GAPI_WRAP GMatDesc() : GMatDesc(-1, -1, {-1,-1}) {} - - inline bool operator== (const GMatDesc &rhs) const - { - return depth == rhs.depth - && chan == rhs.chan - && size == rhs.size - && planar == rhs.planar - && dims == rhs.dims; - } - - inline bool operator!= (const GMatDesc &rhs) const - { - return !(*this == rhs); - } - - bool isND() const { return !dims.empty(); } - - // Checks if the passed mat can be described by this descriptor - // (it handles the case when - // 1-channel mat can be reinterpreted as is (1-channel mat) - // and as a 3-channel planar mat with height divided by 3) - bool canDescribe(const cv::Mat& mat) const; - - bool canDescribe(const cv::RMat& mat) const; - - // Meta combinator: return a new GMatDesc which differs in size by delta - // (all other fields are taken unchanged from this GMatDesc) - // FIXME: a better name? - GAPI_WRAP GMatDesc withSizeDelta(cv::Size delta) const - { - GMatDesc desc(*this); - desc.size += delta; - return desc; - } - // Meta combinator: return a new GMatDesc which differs in size by delta - // (all other fields are taken unchanged from this GMatDesc) - // - // This is an overload. - GAPI_WRAP GMatDesc withSizeDelta(int dx, int dy) const - { - return withSizeDelta(cv::Size{dx,dy}); - } - - GAPI_WRAP GMatDesc withSize(cv::Size sz) const - { - GMatDesc desc(*this); - desc.size = sz; - return desc; - } - - // Meta combinator: return a new GMatDesc with specified data depth. - // (all other fields are taken unchanged from this GMatDesc) - GAPI_WRAP GMatDesc withDepth(int ddepth) const - { - GAPI_Assert(CV_MAT_CN(ddepth) == 1 || ddepth == -1); - GMatDesc desc(*this); - if (ddepth != -1) desc.depth = ddepth; - return desc; - } - - // Meta combinator: return a new GMatDesc with specified data depth - // and number of channels. - // (all other fields are taken unchanged from this GMatDesc) - GAPI_WRAP GMatDesc withType(int ddepth, int dchan) const - { - GAPI_Assert(CV_MAT_CN(ddepth) == 1 || ddepth == -1); - GMatDesc desc = withDepth(ddepth); - desc.chan = dchan; - return desc; - } - - // Meta combinator: return a new GMatDesc with planar flag set - // (no size changes are performed, only channel interpretation is changed - // (interleaved -> planar) - GAPI_WRAP GMatDesc asPlanar() const - { - GAPI_Assert(planar == false); - GMatDesc desc(*this); - desc.planar = true; - return desc; - } - - // Meta combinator: return a new GMatDesc - // reinterpreting 1-channel input as planar image - // (size height is divided by plane number) - GAPI_WRAP GMatDesc asPlanar(int planes) const - { - GAPI_Assert(planar == false); - GAPI_Assert(chan == 1); - GAPI_Assert(planes > 1); - GAPI_Assert(size.height % planes == 0); - GMatDesc desc(*this); - desc.size.height /= planes; - desc.chan = planes; - return desc.asPlanar(); - } - - // Meta combinator: return a new GMatDesc with planar flag set to false - // (no size changes are performed, only channel interpretation is changed - // (planar -> interleaved) - GAPI_WRAP GMatDesc asInterleaved() const - { - GAPI_Assert(planar == true); - GMatDesc desc(*this); - desc.planar = false; - return desc; - } -}; - -static inline GMatDesc empty_gmat_desc() { return GMatDesc{-1,-1,{-1,-1}}; } - -namespace gapi { namespace detail { -/** Checks GMatDesc fields if the passed matrix is a set of n-dimentional points. -@param in GMatDesc to check. -@param n expected dimensionality. -@return the amount of points. In case input matrix can't be described as vector of points -of expected dimensionality, returns -1. - */ -int checkVector(const GMatDesc& in, const size_t n); - -/** @overload - -Checks GMatDesc fields if the passed matrix can be described as a set of points of any -dimensionality. - -@return array of two elements in form of std::vector: the amount of points -and their calculated dimensionality. In case input matrix can't be described as vector of points, -returns {-1, -1}. - */ -std::vector checkVector(const GMatDesc& in); -}} // namespace gapi::detail - -#if !defined(GAPI_STANDALONE) -GAPI_EXPORTS GMatDesc descr_of(const cv::UMat &mat); -#endif // !defined(GAPI_STANDALONE) - -//Fwd declarations -namespace gapi { namespace own { - class Mat; - GAPI_EXPORTS GMatDesc descr_of(const Mat &mat); -}}//gapi::own - -GAPI_EXPORTS GMatDesc descr_of(const RMat &mat); - -#if !defined(GAPI_STANDALONE) -GAPI_EXPORTS GMatDesc descr_of(const cv::Mat &mat); -#else -using gapi::own::descr_of; -#endif - -/** @} */ - -GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const cv::GMatDesc &desc); - -} // namespace cv - -#endif // OPENCV_GAPI_GMAT_HPP diff --git a/modules/gapi/include/opencv2/gapi/gmetaarg.hpp b/modules/gapi/include/opencv2/gapi/gmetaarg.hpp deleted file mode 100644 index f21182c19f..0000000000 --- a/modules/gapi/include/opencv2/gapi/gmetaarg.hpp +++ /dev/null @@ -1,80 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GMETAARG_HPP -#define OPENCV_GAPI_GMETAARG_HPP - -#include -#include - -#include -#include - -#include -#include -#include -#include -#include - -namespace cv -{ -// FIXME: Rename to GMeta? -// FIXME: user shouldn't deal with it - put to detail? -// GMetaArg is an union type over descriptions of G-types which can serve as -// GComputation's in/output slots. -// -// GMetaArg objects are passed as arguments to GComputation::compile() -// to specify which data a compiled computation should be specialized on. -// For manual compile(), user must supply this metadata, in case of apply() -// this metadata is taken from arguments computation should operate on. -// -// The first type (monostate) is equal to "uninitialized"/"unresolved" meta. -using GMetaArg = util::variant - < util::monostate - , GMatDesc - , GScalarDesc - , GArrayDesc - , GOpaqueDesc - , GFrameDesc - >; -GAPI_EXPORTS std::ostream& operator<<(std::ostream& os, const GMetaArg &); - -using GMetaArgs = std::vector; - -namespace detail -{ - // These traits are used by GComputation::compile() - - // FIXME: is_constructible doesn't work as variant doesn't do any SFINAE - // in its current template constructor - - template struct is_meta_descr : std::false_type {}; - template<> struct is_meta_descr : std::true_type {}; - template<> struct is_meta_descr : std::true_type {}; - template<> struct is_meta_descr : std::true_type {}; - template<> struct is_meta_descr : std::true_type {}; - - template - using are_meta_descrs = all_satisfy; - - template - using are_meta_descrs_but_last = all_satisfy::type>; - -} // namespace detail - -// Note: descr_of(std::vector<..>) returns a GArrayDesc, while -// descrs_of(std::vector<..>) returns an array of Meta args! -class UMat; -GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector &vec); -GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector &vec); -namespace gapi { namespace own { - GAPI_EXPORTS cv::GMetaArgs descrs_of(const std::vector &vec); -}} // namespace gapi::own - -} // namespace cv - -#endif // OPENCV_GAPI_GMETAARG_HPP diff --git a/modules/gapi/include/opencv2/gapi/gopaque.hpp b/modules/gapi/include/opencv2/gapi/gopaque.hpp deleted file mode 100644 index a3f98a9867..0000000000 --- a/modules/gapi/include/opencv2/gapi/gopaque.hpp +++ /dev/null @@ -1,369 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GOPAQUE_HPP -#define OPENCV_GAPI_GOPAQUE_HPP - -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include - -#include // OpaqueKind -#include // TypeHintBase - -namespace cv -{ -// Forward declaration; GNode and GOrigin are an internal -// (user-inaccessible) classes. -class GNode; -struct GOrigin; -template class GOpaque; - -/** - * \addtogroup gapi_meta_args - * @{ - */ -struct GAPI_EXPORTS_W_SIMPLE GOpaqueDesc -{ - // FIXME: Body - // FIXME: Also implement proper operator== then - bool operator== (const GOpaqueDesc&) const { return true; } -}; -template GOpaqueDesc descr_of(const U &) { return {};} -GAPI_EXPORTS_W inline GOpaqueDesc empty_gopaque_desc() {return {}; } -/** @} */ - -std::ostream& operator<<(std::ostream& os, const cv::GOpaqueDesc &desc); - -namespace detail -{ - // ConstructOpaque is a callback which stores information about T and is used by - // G-API runtime to construct an object in host memory (T remains opaque for G-API). - // ConstructOpaque is carried into G-API internals by GOpaqueU. - // Currently it is suitable for Host (CPU) plugins only, real offload may require - // more information for manual memory allocation on-device. - class OpaqueRef; - using ConstructOpaque = std::function; - - // FIXME: garray.hpp already contains hint classes (for actual T type verification), - // need to think where it can be moved (currently opaque uses it from garray) - - // This class strips type information from GOpaque and makes it usable - // in the G-API graph compiler (expression unrolling, graph generation, etc). - // Part of GProtoArg. - class GAPI_EXPORTS GOpaqueU - { - public: - GOpaqueU(const GNode &n, std::size_t out); // Operation result constructor - - template - bool holds() const; // Check if was created from GOpaque - - GOrigin& priv(); // Internal use only - const GOrigin& priv() const; // Internal use only - - protected: - GOpaqueU(); // Default constructor - template friend class cv::GOpaque; // (available for GOpaque only) - - void setConstructFcn(ConstructOpaque &&cv); // Store T-aware constructor - - template - void specifyType(); // Store type of initial GOpaque - - template - void storeKind(); - - void setKind(cv::detail::OpaqueKind); - - std::shared_ptr m_priv; - std::shared_ptr m_hint; - }; - - template - bool GOpaqueU::holds() const{ - GAPI_Assert(m_hint != nullptr); - using U = util::decay_t; - return dynamic_cast*>(m_hint.get()) != nullptr; - } - - template - void GOpaqueU::specifyType(){ - m_hint.reset(new TypeHint>); - } - - template - void GOpaqueU::storeKind(){ - // FIXME: Add assert here on cv::Mat and cv::Scalar? - setKind(cv::detail::GOpaqueTraits::kind); - } - - // This class represents a typed object reference. - // Depending on origins, this reference may be either "just a" reference to - // an object created externally, OR actually own the underlying object - // (be value holder). - class BasicOpaqueRef - { - public: - cv::GOpaqueDesc m_desc; - virtual ~BasicOpaqueRef() {} - - virtual void mov(BasicOpaqueRef &ref) = 0; - virtual const void* ptr() const = 0; - virtual void set(const cv::util::any &a) = 0; - }; - - template class OpaqueRefT final: public BasicOpaqueRef - { - using empty_t = util::monostate; - using ro_ext_t = const T *; - using rw_ext_t = T *; - using rw_own_t = T ; - util::variant m_ref; - - inline bool isEmpty() const { return util::holds_alternative(m_ref); } - inline bool isROExt() const { return util::holds_alternative(m_ref); } - inline bool isRWExt() const { return util::holds_alternative(m_ref); } - inline bool isRWOwn() const { return util::holds_alternative(m_ref); } - - void init(const T* obj = nullptr) - { - if (obj) m_desc = cv::descr_of(*obj); - } - - public: - OpaqueRefT() { init(); } - virtual ~OpaqueRefT() {} - - explicit OpaqueRefT(const T& obj) : m_ref(&obj) { init(&obj); } - explicit OpaqueRefT( T& obj) : m_ref(&obj) { init(&obj); } - explicit OpaqueRefT( T&& obj) : m_ref(std::move(obj)) { init(&obj); } - - // Reset a OpaqueRefT. Called only for objects instantiated - // internally in G-API (e.g. temporary GOpaque's within a - // computation). Reset here means both initialization - // (creating an object) and reset (discarding its existing - // content before the next execution). Must never be called - // for external OpaqueRefTs. - void reset() - { - if (isEmpty()) - { - T empty_obj{}; - m_desc = cv::descr_of(empty_obj); - m_ref = std::move(empty_obj); - GAPI_Assert(isRWOwn()); - } - else if (isRWOwn()) - { - util::get(m_ref) = {}; - } - else GAPI_Error("InternalError"); // shouldn't be called in *EXT modes - } - - // Obtain a WRITE reference to underlying object - // Used by CPU kernel API wrappers when a kernel execution frame - // is created - T& wref() - { - GAPI_Assert(isRWExt() || isRWOwn()); - if (isRWExt()) return *util::get(m_ref); - if (isRWOwn()) return util::get(m_ref); - util::throw_error(std::logic_error("Impossible happened")); - } - - // Obtain a READ reference to underlying object - // Used by CPU kernel API wrappers when a kernel execution frame - // is created - const T& rref() const - { - // ANY object can be accessed for reading, even if it declared for - // output. Example -- a GComputation from [in] to [out1,out2] - // where [out2] is a result of operation applied to [out1]: - // - // GComputation boundary - // . . . . . . . - // . . - // [in] ----> foo() ----> [out1] - // . . : - // . . . .:. . . - // . V . - // . bar() ---> [out2] - // . . . . . . . . . . . . - // - if (isROExt()) return *util::get(m_ref); - if (isRWExt()) return *util::get(m_ref); - if (isRWOwn()) return util::get(m_ref); - util::throw_error(std::logic_error("Impossible happened")); - } - - virtual void mov(BasicOpaqueRef &v) override { - OpaqueRefT *tv = dynamic_cast*>(&v); - GAPI_Assert(tv != nullptr); - wref() = std::move(tv->wref()); - } - - virtual const void* ptr() const override { return &rref(); } - - virtual void set(const cv::util::any &a) override { - wref() = util::any_cast(a); - } - }; - - // This class strips type information from OpaqueRefT<> and makes it usable - // in the G-API executables (carrying run-time data/information to kernels). - // Part of GRunArg. - // Its methods are typed proxies to OpaqueRefT. - // OpaqueRef maintains "reference" semantics so two copies of OpaqueRef refer - // to the same underlying object. - class OpaqueRef - { - std::shared_ptr m_ref; - cv::detail::OpaqueKind m_kind = cv::detail::OpaqueKind::CV_UNKNOWN; - - template inline void check() const - { - GAPI_DbgAssert(dynamic_cast*>(m_ref.get()) != nullptr); - } - - public: - OpaqueRef() = default; - - template< - typename T, - typename = util::are_different_t - > - // FIXME: probably won't work with const object - explicit OpaqueRef(T&& obj) : - m_ref(new OpaqueRefT>(std::forward(obj))), - m_kind(GOpaqueTraits>::kind) {} - - cv::detail::OpaqueKind getKind() const - { - return m_kind; - } - - template void reset() - { - if (!m_ref) m_ref.reset(new OpaqueRefT()); - check(); - storeKind(); - static_cast&>(*m_ref).reset(); - } - - template - void storeKind() - { - m_kind = cv::detail::GOpaqueTraits::kind; - } - - template T& wref() - { - check(); - return static_cast&>(*m_ref).wref(); - } - - template const T& rref() const - { - check(); - return static_cast&>(*m_ref).rref(); - } - - void mov(OpaqueRef &v) - { - m_ref->mov(*v.m_ref); - } - - cv::GOpaqueDesc descr_of() const - { - return m_ref->m_desc; - } - - // May be used to uniquely identify this object internally - const void *ptr() const { return m_ref->ptr(); } - - // Introduced for in-graph meta handling - OpaqueRef& operator= (const cv::util::any &a) - { - m_ref->set(a); - return *this; - } - }; -} // namespace detail - -/** \addtogroup gapi_data_objects - * @{ - */ -/** - * @brief `cv::GOpaque` template class represents an object of - * class `T` in the graph. - * - * `cv::GOpaque` describes a functional relationship between operations - * consuming and producing object of class `T`. `cv::GOpaque` is - * designed to extend G-API with user-defined data types, which are - * often required with user-defined operations. G-API can't apply any - * optimizations to user-defined types since these types are opaque to - * the framework. However, there is a number of G-API operations - * declared with `cv::GOpaque` as a return type, - * e.g. cv::gapi::streaming::timestamp() or cv::gapi::streaming::size(). - * - * @sa `cv::GArray` - */ -template class GOpaque -{ -public: - // Host type (or Flat type) - the type this GOpaque is actually - // specified to. - /// @private - using HT = typename detail::flatten_g>::type; - - /** - * @brief Constructs an empty `cv::GOpaque` - * - * Normally, empty G-API data objects denote a starting point of - * the graph. When an empty `cv::GOpaque` is assigned to a result - * of some operation, it obtains a functional link to this - * operation (and is not empty anymore). - */ - GOpaque() { putDetails(); } // Empty constructor - - /// @private - explicit GOpaque(detail::GOpaqueU &&ref) // GOpaqueU-based constructor - : m_ref(ref) { putDetails(); } // (used by GCall, not for users) - - /// @private - detail::GOpaqueU strip() const { - return m_ref; - } - /// @private - static void Ctor(detail::OpaqueRef& ref) { - ref.reset(); - } -private: - void putDetails() { - m_ref.setConstructFcn(&Ctor); - m_ref.specifyType(); - m_ref.storeKind(); - } - - detail::GOpaqueU m_ref; -}; - -/** @} */ - -} // namespace cv - -#endif // OPENCV_GAPI_GOPAQUE_HPP diff --git a/modules/gapi/include/opencv2/gapi/gproto.hpp b/modules/gapi/include/opencv2/gapi/gproto.hpp deleted file mode 100644 index a2b5d83bc1..0000000000 --- a/modules/gapi/include/opencv2/gapi/gproto.hpp +++ /dev/null @@ -1,159 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GPROTO_HPP -#define OPENCV_GAPI_GPROTO_HPP - -#include -#include -#include - -#include - -#include -#include -#include -#include -#include -#include - -namespace cv { - -// FIXME: user shouldn't deal with it - put to detail? -// GProtoArg is an union type over G-types which can serve as -// GComputation's in/output slots. In other words, GProtoArg -// wraps any type which can serve as G-API exchange type. -// -// In Runtime, GProtoArgs are substituted with appropriate GRunArgs. -// -// GProtoArg objects are constructed in-place when user describes -// (captures) computations, user doesn't interact with these types -// directly. -using GProtoArg = util::variant - < GMat - , GMatP - , GFrame - , GScalar - , detail::GArrayU // instead of GArray - , detail::GOpaqueU // instead of GOpaque - >; - -using GProtoArgs = std::vector; - -namespace detail -{ -template inline GProtoArgs packArgs(Ts... args) -{ - return GProtoArgs{ GProtoArg(wrap_gapi_helper::wrap(args))... }; -} - -} - -template -struct GIOProtoArgs -{ -public: - // NB: Used by python wrapper - GIOProtoArgs() = default; - explicit GIOProtoArgs(const GProtoArgs& args) : m_args(args) {} - explicit GIOProtoArgs(GProtoArgs &&args) : m_args(std::move(args)) {} - - GProtoArgs m_args; - - // TODO: Think about the addition operator - /** - * @brief This operator allows to complement the proto vectors at runtime. - * - * It's an ordinary overload of addition assignment operator. - * - * Example of usage: - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/dynamic_graph_snippets.cpp GIOProtoArgs usage - * - */ - template - friend GIOProtoArgs& operator += (GIOProtoArgs &lhs, const GIOProtoArgs &rhs); -}; - -template -cv::GIOProtoArgs& operator += (cv::GIOProtoArgs &lhs, const cv::GIOProtoArgs &rhs) -{ - lhs.m_args.reserve(lhs.m_args.size() + rhs.m_args.size()); - lhs.m_args.insert(lhs.m_args.end(), rhs.m_args.begin(), rhs.m_args.end()); - return lhs; -} - -struct In_Tag{}; -struct Out_Tag{}; - -using GProtoInputArgs = GIOProtoArgs; -using GProtoOutputArgs = GIOProtoArgs; - -// Perfect forwarding -template inline GProtoInputArgs GIn(Ts&&... ts) -{ - return GProtoInputArgs(detail::packArgs(std::forward(ts)...)); -} - -template inline GProtoOutputArgs GOut(Ts&&... ts) -{ - return GProtoOutputArgs(detail::packArgs(std::forward(ts)...)); -} - -namespace detail -{ - // Extract elements form tuple - // FIXME: Someday utilize a generic tuple_to_vec<> routine - template - static GProtoOutputArgs getGOut_impl(const std::tuple& ts, detail::Seq) - { - return GProtoOutputArgs{ detail::packArgs(std::get(ts)...)}; - } -} - -template inline GProtoOutputArgs GOut(const std::tuple& ts) -{ - // TODO: think of std::forward(ts) - return detail::getGOut_impl(ts, typename detail::MkSeq::type()); -} - -// Takes rvalue as input arg -template inline GProtoOutputArgs GOut(std::tuple&& ts) -{ - // TODO: think of std::forward(ts) - return detail::getGOut_impl(ts, typename detail::MkSeq::type()); -} - -// Extract run-time arguments from node origin -// Can be used to extract constant values associated with G-objects -// (like GScalar) at graph construction time -GRunArg value_of(const GOrigin &origin); - -// Transform run-time computation arguments into a collection of metadata -// extracted from that arguments -GMetaArg GAPI_EXPORTS descr_of(const GRunArg &arg ); -GMetaArgs GAPI_EXPORTS descr_of(const GRunArgs &args); - -// Transform run-time operation result argument into metadata extracted from that argument -// Used to compare the metadata, which generated at compile time with the metadata result operation in run time -GMetaArg GAPI_EXPORTS descr_of(const GRunArgP& argp); - -// Checks if run-time computation argument can be described by metadata -bool GAPI_EXPORTS can_describe(const GMetaArg& meta, const GRunArg& arg); -bool GAPI_EXPORTS can_describe(const GMetaArgs& metas, const GRunArgs& args); - -// Checks if run-time computation result argument can be described by metadata. -// Used to check if the metadata generated at compile time -// coincides with output arguments passed to computation in cpu and ocl backends -bool GAPI_EXPORTS can_describe(const GMetaArg& meta, const GRunArgP& argp); - -// Validates input arguments -void GAPI_EXPORTS validate_input_arg(const GRunArg& arg); -void GAPI_EXPORTS validate_input_args(const GRunArgs& args); - -} // namespace cv - -#endif // OPENCV_GAPI_GPROTO_HPP diff --git a/modules/gapi/include/opencv2/gapi/gpu/core.hpp b/modules/gapi/include/opencv2/gapi/gpu/core.hpp deleted file mode 100644 index a7ee59577c..0000000000 --- a/modules/gapi/include/opencv2/gapi/gpu/core.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GPU_CORE_API_HPP -#define OPENCV_GAPI_GPU_CORE_API_HPP -/** @file -* @deprecated Use instead. -*/ - -#include - -namespace cv { -namespace gapi { -namespace core { -namespace gpu { - using namespace ocl; -} // namespace gpu -} // namespace core -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_GPU_CORE_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp b/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp deleted file mode 100644 index b52c21de6b..0000000000 --- a/modules/gapi/include/opencv2/gapi/gpu/ggpukernel.hpp +++ /dev/null @@ -1,18 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GGPUKERNEL_HPP -#define OPENCV_GAPI_GGPUKERNEL_HPP -/** @file -* @deprecated Use instead. -*/ - -#include -#define GAPI_GPU_KERNEL GAPI_OCL_KERNEL - - -#endif // OPENCV_GAPI_GGPUKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp b/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp deleted file mode 100644 index b0df7ae331..0000000000 --- a/modules/gapi/include/opencv2/gapi/gpu/imgproc.hpp +++ /dev/null @@ -1,28 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GPU_IMGPROC_API_HPP -#define OPENCV_GAPI_GPU_IMGPROC_API_HPP -/** @file -* @deprecated Use instead. -*/ - -#include - - -namespace cv { -namespace gapi { -namespace imgproc { -namespace gpu { - using namespace ocl; -} // namespace gpu -} // namespace imgproc -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_GPU_IMGPROC_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/gscalar.hpp b/modules/gapi/include/opencv2/gapi/gscalar.hpp deleted file mode 100644 index de0dfe1383..0000000000 --- a/modules/gapi/include/opencv2/gapi/gscalar.hpp +++ /dev/null @@ -1,140 +0,0 @@ -// This file is part of OpenCV project. - -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GSCALAR_HPP -#define OPENCV_GAPI_GSCALAR_HPP - -#include - -#include -#include // GShape -#include - -namespace cv -{ -// Forward declaration; GNode and GOrigin are an internal -// (user-inaccessible) classes. -class GNode; -struct GOrigin; - -/** \addtogroup gapi_data_objects - * @{ - */ -/** - * @brief GScalar class represents cv::Scalar data in the graph. - * - * GScalar may be associated with a cv::Scalar value, which becomes - * its constant value bound in graph compile time. cv::GScalar describes a - * functional relationship between operations consuming and producing - * GScalar objects. - * - * GScalar is a virtual counterpart of cv::Scalar, which is usually used - * to represent the GScalar data in G-API during the execution. - * - * @sa Scalar - */ -class GAPI_EXPORTS_W_SIMPLE GScalar -{ -public: - /** - * @brief Constructs an empty GScalar - * - * Normally, empty G-API data objects denote a starting point of - * the graph. When an empty GScalar is assigned to a result of some - * operation, it obtains a functional link to this operation (and - * is not empty anymore). - */ - GAPI_WRAP GScalar(); - - /** - * @brief Constructs a value-initialized GScalar - * - * GScalars may have their values be associated at graph - * construction time. It is useful when some operation has a - * GScalar input which doesn't change during the program - * execution, and is set only once. In this case, there is no need - * to declare such GScalar as a graph input. - * - * @note The value of GScalar may be overwritten by assigning some - * other GScalar to the object using `operator=` -- on the - * assignment, the old GScalar value is discarded. - * - * @param s a cv::Scalar value to associate with this GScalar object. - */ - GAPI_WRAP - explicit GScalar(const cv::Scalar& s); - - /** - * @overload - * @brief Constructs a value-initialized GScalar - * - * @param s a cv::Scalar value to associate with this GScalar object. - */ - explicit GScalar(cv::Scalar&& s); // Constant value move-constructor from cv::Scalar - - /** - * @overload - * @brief Constructs a value-initialized GScalar - * - * @param v0 A `double` value to associate with this GScalar. Note - * that only the first component of a four-component cv::Scalar is - * set to this value, with others remain zeros. - * - * This constructor overload is not marked `explicit` and can be - * used in G-API expression code like this: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp gscalar_implicit - * - * Here operator+(GMat,GScalar) is used to wrap cv::gapi::addC() - * and a value-initialized GScalar is created on the fly. - * - * @overload - */ - GScalar(double v0); // Constant value constructor from double - - /// @private - GScalar(const GNode &n, std::size_t out); // Operation result constructor - /// @private - GOrigin& priv(); // Internal use only - /// @private - const GOrigin& priv() const; // Internal use only - -private: - std::shared_ptr m_priv; -}; - -/** @} */ - -/** - * \addtogroup gapi_meta_args - * @{ - */ -struct GAPI_EXPORTS_W_SIMPLE GScalarDesc -{ - // NB.: right now it is empty - - inline bool operator== (const GScalarDesc &) const - { - return true; // NB: implement this method if GScalar meta appears - } - - inline bool operator!= (const GScalarDesc &rhs) const - { - return !(*this == rhs); - } -}; - -GAPI_EXPORTS_W inline GScalarDesc empty_scalar_desc() { return GScalarDesc(); } - -GAPI_EXPORTS GScalarDesc descr_of(const cv::Scalar &scalar); - -std::ostream& operator<<(std::ostream& os, const cv::GScalarDesc &desc); - -} // namespace cv - -#endif // OPENCV_GAPI_GSCALAR_HPP diff --git a/modules/gapi/include/opencv2/gapi/gstreaming.hpp b/modules/gapi/include/opencv2/gapi/gstreaming.hpp deleted file mode 100644 index d413195b81..0000000000 --- a/modules/gapi/include/opencv2/gapi/gstreaming.hpp +++ /dev/null @@ -1,430 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2021 Intel Corporation - - -#ifndef OPENCV_GAPI_GSTREAMING_COMPILED_HPP -#define OPENCV_GAPI_GSTREAMING_COMPILED_HPP - -#include -#include - -#include -#include -#include -#include -#include - -namespace cv { - -template using optional = cv::util::optional; - -namespace detail { -template struct wref_spec { - using type = T; -}; -template struct wref_spec > { - using type = T; -}; - -template -struct OptRef { - struct OptHolder { - virtual void mov(RefHolder &h) = 0; - virtual void reset() = 0; - virtual ~OptHolder() = default; - using Ptr = std::shared_ptr; - }; - template struct Holder final: OptHolder { - std::reference_wrapper > m_opt_ref; - - explicit Holder(cv::optional& opt) : m_opt_ref(std::ref(opt)) { - } - virtual void mov(RefHolder &h) override { - using U = typename wref_spec::type; - m_opt_ref.get() = cv::util::make_optional(std::move(h.template wref())); - } - virtual void reset() override { - m_opt_ref.get().reset(); - } - }; - template - explicit OptRef(cv::optional& t) : m_opt{new Holder(t)} {} - void mov(RefHolder &h) { m_opt->mov(h); } - void reset() { m_opt->reset();} -private: - typename OptHolder::Ptr m_opt; -}; -using OptionalVectorRef = OptRef; -using OptionalOpaqueRef = OptRef; -} // namespace detail - -// TODO: Keep it in sync with GRunArgP (derive the type automatically?) -using GOptRunArgP = util::variant< - optional*, - optional*, - optional*, - optional*, - cv::detail::OptionalVectorRef, - cv::detail::OptionalOpaqueRef ->; -using GOptRunArgsP = std::vector; - -using GOptRunArg = util::variant< - optional, - optional, - optional, - optional, - optional, - optional ->; -using GOptRunArgs = std::vector; - -namespace detail { - -template inline GOptRunArgP wrap_opt_arg(optional& arg) { - // By default, T goes to an OpaqueRef. All other types are specialized - return GOptRunArgP{OptionalOpaqueRef(arg)}; -} - -template inline GOptRunArgP wrap_opt_arg(optional >& arg) { - return GOptRunArgP{OptionalVectorRef(arg)}; -} - -template<> inline GOptRunArgP wrap_opt_arg(optional &m) { - return GOptRunArgP{&m}; -} - -template<> inline GOptRunArgP wrap_opt_arg(optional &m) { - return GOptRunArgP{&m}; -} - -template<> inline GOptRunArgP wrap_opt_arg(optional &f) { - return GOptRunArgP{&f}; -} - -template<> inline GOptRunArgP wrap_opt_arg(optional &s) { - return GOptRunArgP{&s}; -} - -} // namespace detail - -// Now cv::gout() may produce an empty vector (see "dynamic graphs"), so -// there may be a conflict between these two. State here that Opt version -// _must_ have at least one input for this overload -template -inline GOptRunArgsP gout(optional&arg, optional&... args) -{ - return GOptRunArgsP{ detail::wrap_opt_arg(arg), detail::wrap_opt_arg(args)... }; -} - -/** - * \addtogroup gapi_main_classes - * @{ - */ -/** - * @brief Represents a computation (graph) compiled for streaming. - * - * This class represents a product of graph compilation (calling - * cv::GComputation::compileStreaming()). Objects of this class - * actually do stream processing, and the whole pipeline execution - * complexity is incapsulated into objects of this class. Execution - * model has two levels: at the very top, the execution of a - * heterogeneous graph is aggressively pipelined; at the very bottom - * the execution of every internal block is determined by its - * associated backend. Backends are selected based on kernel packages - * passed via compilation arguments ( see @ref gapi_compile_args, - * GNetworkPackage, GKernelPackage for details). - * - * GStreamingCompiled objects have a "player" semantics -- there are - * methods like start() and stop(). GStreamingCompiled has a full - * control over a videostream and so is stateful. You need to specify the - * input stream data using setSource() and then call start() to - * actually start processing. After that, use pull() or try_pull() to - * obtain next processed data frame from the graph in a blocking or - * non-blocking way, respectively. - * - * Currently a single GStreamingCompiled can process only one video - * streat at time. Produce multiple GStreamingCompiled objects to run the - * same graph on multiple video streams. - * - * @sa GCompiled - */ -class GAPI_EXPORTS_W_SIMPLE GStreamingCompiled -{ -public: - class GAPI_EXPORTS Priv; - GAPI_WRAP GStreamingCompiled(); - - // FIXME: More overloads? - /** - * @brief Specify the input data to GStreamingCompiled for - * processing, a generic version. - * - * Use gin() to create an input parameter vector. - * - * Input vectors must have the same number of elements as defined - * in the cv::GComputation protocol (at the moment of its - * construction). Shapes of elements also must conform to protocol - * (e.g. cv::Mat needs to be passed where cv::GMat has been - * declared as input, and so on). Run-time exception is generated - * on type mismatch. - * - * In contrast with regular GCompiled, user can also pass an - * object of type GVideoCapture for a GMat parameter of the parent - * GComputation. The compiled pipeline will start fetching data - * from that GVideoCapture and feeding it into the - * pipeline. Pipeline stops when a GVideoCapture marks end of the - * stream (or when stop() is called). - * - * Passing a regular Mat for a GMat parameter makes it "infinite" - * source -- pipeline may run forever feeding with this Mat until - * stopped explicitly. - * - * Currently only a single GVideoCapture is supported as input. If - * the parent GComputation is declared with multiple input GMat's, - * one of those can be specified as GVideoCapture but all others - * must be regular Mat objects. - * - * Throws if pipeline is already running. Use stop() and then - * setSource() to run the graph on a new video stream. - * - * @note This method is not thread-safe (with respect to the user - * side) at the moment. Protect the access if - * start()/stop()/setSource() may be called on the same object in - * multiple threads in your application. - * - * @param ins vector of inputs to process. - * @sa gin - */ - void setSource(GRunArgs &&ins); - - /// @private -- Exclude this function from OpenCV documentation - GAPI_WRAP void setSource(const cv::detail::ExtractArgsCallback& callback); - - /** - * @brief Specify an input video stream for a single-input - * computation pipeline. - * - * Throws if pipeline is already running. Use stop() and then - * setSource() to run the graph on a new video stream. - * - * @overload - * @param s a shared pointer to IStreamSource representing the - * input video stream. - */ - void setSource(const gapi::wip::IStreamSource::Ptr& s); - - /** - * @brief Constructs and specifies an input video stream for a - * single-input computation pipeline with the given parameters. - * - * Throws if pipeline is already running. Use stop() and then - * setSource() to run the graph on a new video stream. - * - * @overload - * @param args arguments used to construct and initialize a stream - * source. - */ - template - void setSource(Args&&... args) { - setSource(cv::gapi::wip::make_src(std::forward(args)...)); - } - - /** - * @brief Start the pipeline execution. - * - * Use pull()/try_pull() to obtain data. Throws an exception if - * a video source was not specified. - * - * setSource() must be called first, even if the pipeline has been - * working already and then stopped (explicitly via stop() or due - * stream completion) - * - * @note This method is not thread-safe (with respect to the user - * side) at the moment. Protect the access if - * start()/stop()/setSource() may be called on the same object in - * multiple threads in your application. - */ - GAPI_WRAP void start(); - - /** - * @brief Get the next processed frame from the pipeline. - * - * Use gout() to create an output parameter vector. - * - * Output vectors must have the same number of elements as defined - * in the cv::GComputation protocol (at the moment of its - * construction). Shapes of elements also must conform to protocol - * (e.g. cv::Mat needs to be passed where cv::GMat has been - * declared as output, and so on). Run-time exception is generated - * on type mismatch. - * - * This method writes new data into objects passed via output - * vector. If there is no data ready yet, this method blocks. Use - * try_pull() if you need a non-blocking version. - * - * @param outs vector of output parameters to obtain. - * @return true if next result has been obtained, - * false marks end of the stream. - */ - bool pull(cv::GRunArgsP &&outs); - - // NB: Used from python - /// @private -- Exclude this function from OpenCV documentation - GAPI_WRAP std::tuple> pull(); - - /** - * @brief Get some next available data from the pipeline. - * - * This method takes a vector of cv::optional object. An object is - * assigned to some value if this value is available (ready) at - * the time of the call, and resets the object to empty() if it is - * not. - * - * This is a blocking method which guarantees that some data has - * been written to the output vector on return. - * - * Using this method only makes sense if the graph has - * desynchronized parts (see cv::gapi::desync). If there is no - * desynchronized parts in the graph, the behavior of this - * method is identical to the regular pull() (all data objects are - * produced synchronously in the output vector). - * - * Use gout() to create an output parameter vector. - * - * Output vectors must have the same number of elements as defined - * in the cv::GComputation protocol (at the moment of its - * construction). Shapes of elements also must conform to protocol - * (e.g. cv::optional needs to be passed where cv::GMat - * has been declared as output, and so on). Run-time exception is - * generated on type mismatch. - * - * This method writes new data into objects passed via output - * vector. If there is no data ready yet, this method blocks. Use - * try_pull() if you need a non-blocking version. - * - * @param outs vector of output parameters to obtain. - * @return true if next result has been obtained, - * false marks end of the stream. - * - * @sa cv::gapi::desync - */ - bool pull(cv::GOptRunArgsP &&outs); - - /** - * @brief Try to get the next processed frame from the pipeline. - * - * Use gout() to create an output parameter vector. - * - * This method writes new data into objects passed via output - * vector. If there is no data ready yet, the output vector - * remains unchanged and false is returned. - * - * @return true if data has been obtained, and false if it was - * not. Note: false here doesn't mark the end of the stream. - */ - bool try_pull(cv::GRunArgsP &&outs); - - /** - * @brief Stop (abort) processing the pipeline. - * - * Note - it is not pause but a complete stop. Calling start() - * will cause G-API to start processing the stream from the early beginning. - * - * Throws if the pipeline is not running. - */ - GAPI_WRAP void stop(); - - /** - * @brief Test if the pipeline is running. - * - * @note This method is not thread-safe (with respect to the user - * side) at the moment. Protect the access if - * start()/stop()/setSource() may be called on the same object in - * multiple threads in your application. - * - * @return true if the current stream is not over yet. - */ - GAPI_WRAP bool running() const; - - /// @private - Priv& priv(); - - /** - * @brief Check if compiled object is valid (non-empty) - * - * @return true if the object is runnable (valid), false otherwise - */ - explicit operator bool () const; - - /** - * @brief Vector of metadata this graph was compiled for. - * - * @return Unless _reshape_ is not supported, return value is the - * same vector which was passed to cv::GComputation::compile() to - * produce this compiled object. Otherwise, it is the latest - * metadata vector passed to reshape() (if that call was - * successful). - */ - const GMetaArgs& metas() const; // Meta passed to compile() - - /** - * @brief Vector of metadata descriptions of graph outputs - * - * @return vector with formats/resolutions of graph's output - * objects, auto-inferred from input metadata vector by - * operations which form this computation. - * - * @note GCompiled objects produced from the same - * cv::GComputiation graph with different input metas may return - * different values in this vector. - */ - const GMetaArgs& outMetas() const; - -protected: - /// @private - std::shared_ptr m_priv; -}; - -namespace gapi { - -/** - * @brief This namespace contains G-API functions, structures, and - * symbols related to the Streaming execution mode. - * - * Some of the operations defined in this namespace (e.g. size(), - * BGR(), etc.) can be used in the traditional execution mode too. - */ -namespace streaming { -/** - * @brief Specify queue capacity for streaming execution. - * - * In the streaming mode the pipeline steps are connected with queues - * and this compile argument controls every queue's size. - */ -struct GAPI_EXPORTS_W_SIMPLE queue_capacity -{ - GAPI_WRAP - explicit queue_capacity(size_t cap = 1) : capacity(cap) { } - GAPI_PROP_RW - size_t capacity; -}; -} // namespace streaming -} // namespace gapi - -namespace detail -{ -template<> struct CompileArgTag -{ - static const char* tag() { return "gapi.queue_capacity"; } -}; -} - -/** @} gapi_main_classes */ - -} - -#endif // OPENCV_GAPI_GSTREAMING_COMPILED_HPP diff --git a/modules/gapi/include/opencv2/gapi/gtransform.hpp b/modules/gapi/include/opencv2/gapi/gtransform.hpp deleted file mode 100644 index ce88c894d7..0000000000 --- a/modules/gapi/include/opencv2/gapi/gtransform.hpp +++ /dev/null @@ -1,103 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - -#ifndef OPENCV_GAPI_GTRANSFORM_HPP -#define OPENCV_GAPI_GTRANSFORM_HPP - -#include -#include -#include - -#include -#include -#include -#include -#include -#include - -namespace cv -{ - -struct GAPI_EXPORTS GTransform -{ - // FIXME: consider another simplified - // class instead of GComputation - using F = std::function; - - std::string description; - F pattern; - F substitute; - - GTransform(const std::string& d, const F &p, const F &s) : description(d), pattern(p), substitute(s) {} -}; - -namespace detail -{ - -template -struct TransHelper; - -template -struct TransHelper, Out> -{ - template - static GComputation invoke(Callable f, Seq, Seq) - { - const std::tuple ins; - const auto r = tuple_wrap_helper::get(f(std::get(ins)...)); - return GComputation(cv::GIn(std::get(ins)...), - cv::GOut(std::get(r)...)); - } - - static GComputation get_pattern() - { - return invoke(K::pattern, typename MkSeq::type(), - typename MkSeq::type>::value>::type()); - } - static GComputation get_substitute() - { - return invoke(K::substitute, typename MkSeq::type(), - typename MkSeq::type>::value>::type()); - } -}; -} // namespace detail - -template -class GTransformImpl; - -template -class GTransformImpl> : public cv::detail::TransHelper, R>, - public cv::detail::TransformTag -{ -public: - // FIXME: currently there is no check that transformations' signatures are unique - // and won't be any intersection in graph compilation stage - using API = K; - - static GTransform transformation() - { - return GTransform(K::descr(), &K::get_pattern, &K::get_substitute); - } -}; -} // namespace cv - -#define G_DESCR_HELPER_CLASS(Class) Class##DescrHelper - -#define G_DESCR_HELPER_BODY(Class, Descr) \ - namespace detail \ - { \ - struct G_DESCR_HELPER_CLASS(Class) \ - { \ - static constexpr const char *descr() { return Descr; } \ - }; \ - } - -#define GAPI_TRANSFORM(Class, API, Descr) \ - G_DESCR_HELPER_BODY(Class, Descr) \ - struct Class final : public cv::GTransformImpl, \ - public detail::G_DESCR_HELPER_CLASS(Class) - -#endif // OPENCV_GAPI_GTRANSFORM_HPP diff --git a/modules/gapi/include/opencv2/gapi/gtype_traits.hpp b/modules/gapi/include/opencv2/gapi/gtype_traits.hpp deleted file mode 100644 index c42d64a761..0000000000 --- a/modules/gapi/include/opencv2/gapi/gtype_traits.hpp +++ /dev/null @@ -1,242 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GTYPE_TRAITS_HPP -#define OPENCV_GAPI_GTYPE_TRAITS_HPP - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace cv -{ -namespace detail -{ - template - struct contains_shape_field : std::false_type {}; - - template - struct contains_shape_field> : - std::is_same::type, GShape> - {}; - - template - struct has_gshape : contains_shape_field {}; - - // FIXME: These traits and enum and possible numerous switch(kind) - // block may be replaced with a special Handler object or with - // a double dispatch - enum class ArgKind: int - { - OPAQUE_VAL, // Unknown, generic, opaque-to-GAPI data type - STATIC - // Note: OPAQUE is sometimes defined in Win sys headers -#if !defined(OPAQUE) && !defined(CV_DOXYGEN) - OPAQUE = OPAQUE_VAL, // deprecated value used for compatibility, use OPAQUE_VAL instead -#endif - GOBJREF, // reference to object - GMAT, // a cv::GMat - GMATP, // a cv::GMatP - GFRAME, // a cv::GFrame - GSCALAR, // a cv::GScalar - GARRAY, // a cv::GArrayU (note - exactly GArrayU, not GArray!) - GOPAQUE, // a cv::GOpaqueU (note - exactly GOpaqueU, not GOpaque!) - }; - - // Describe G-API types (G-types) with traits. Mostly used by - // cv::GArg to store meta information about types passed into - // operation arguments. Please note that cv::GComputation is - // defined on GProtoArgs, not GArgs! - template struct GTypeTraits; - template struct GTypeTraits - { - static constexpr const ArgKind kind = ArgKind::OPAQUE_VAL; - static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN; - }; - template<> struct GTypeTraits - { - static constexpr const ArgKind kind = ArgKind::GMAT; - static constexpr const GShape shape = GShape::GMAT; - static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN; - }; - template<> struct GTypeTraits - { - static constexpr const ArgKind kind = ArgKind::GMATP; - static constexpr const GShape shape = GShape::GMAT; - static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN; - }; - template<> struct GTypeTraits - { - static constexpr const ArgKind kind = ArgKind::GFRAME; - static constexpr const GShape shape = GShape::GFRAME; - static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN; - }; - template<> struct GTypeTraits - { - static constexpr const ArgKind kind = ArgKind::GSCALAR; - static constexpr const GShape shape = GShape::GSCALAR; - static constexpr const OpaqueKind op_kind = OpaqueKind::CV_UNKNOWN; - }; - template struct GTypeTraits > - { - static constexpr const ArgKind kind = ArgKind::GARRAY; - static constexpr const GShape shape = GShape::GARRAY; - static constexpr const OpaqueKind op_kind = GOpaqueTraits::kind; - using host_type = std::vector; - using strip_type = cv::detail::VectorRef; - static cv::detail::GArrayU wrap_value(const cv::GArray &t) { return t.strip();} - static cv::detail::VectorRef wrap_in (const std::vector &t) { return detail::VectorRef(t); } - static cv::detail::VectorRef wrap_out ( std::vector &t) { return detail::VectorRef(t); } - }; - template struct GTypeTraits > - { - static constexpr const ArgKind kind = ArgKind::GOPAQUE; - static constexpr const GShape shape = GShape::GOPAQUE; - static constexpr const OpaqueKind op_kind = GOpaqueTraits::kind; - using host_type = T; - using strip_type = cv::detail::OpaqueRef; - static cv::detail::GOpaqueU wrap_value(const cv::GOpaque &t) { return t.strip();} - static cv::detail::OpaqueRef wrap_in (const T &t) { return detail::OpaqueRef(t); } - static cv::detail::OpaqueRef wrap_out ( T &t) { return detail::OpaqueRef(t); } - }; - - // Tests if Trait for type T requires extra marshalling ("custom wrap") or not. - // If Traits has wrap_value() defined, it does. - template struct has_custom_wrap - { - template class check; - template static std::true_type test(check::wrap_value)> *); - template static std::false_type test(...); - using type = decltype(test(nullptr)); - static const constexpr bool value = std::is_same(nullptr))>::value; - }; - - // Resolve a Host type back to its associated G-Type. - // FIXME: Probably it can be avoided - // FIXME: GMatP is not present here. - // (Actually these traits is used only to check - // if associated G-type has custom wrap functions - // and GMat behavior is correct for GMatP) - template struct GTypeOf; -#if !defined(GAPI_STANDALONE) - template<> struct GTypeOf { using type = cv::GMat; }; -#endif // !defined(GAPI_STANDALONE) - template<> struct GTypeOf { using type = cv::GMat; }; - template<> struct GTypeOf { using type = cv::GMat; }; - template<> struct GTypeOf { using type = cv::GScalar; }; - template struct GTypeOf > { using type = cv::GArray; }; - template struct GTypeOf { using type = cv::GOpaque;}; - template<> struct GTypeOf { using type = cv::GFrame; }; - - // FIXME: This is not quite correct since IStreamSource may - // produce not only Mat but also MediaFrame, Scalar and vector - // data. TODO: Extend the type dispatching on these types too. - template<> struct GTypeOf { using type = cv::GMat;}; - template using g_type_of_t = typename GTypeOf::type; - - // Marshalling helper for G-types and its Host types. Helps G-API - // to store G types in internal generic containers for further - // processing. Implements the following callbacks: - // - // * wrap() - converts user-facing G-type into an internal one - // for internal storage. - // Used when G-API operation is instantiated (G::on(), - // etc) during expressing a pipeline. Mostly returns input - // value "as is" except the case when G-type is a template. For - // template G-classes, calls custom wrap() from Traits. - // The value returned by wrap() is then wrapped into GArg() and - // stored in G-API metadata. - // - // Example: - // - cv::GMat arguments are passed as-is. - // - integers, pointers, STL containers, user types are passed as-is. - // - cv::GArray is converted to cv::GArrayU. - // - // * wrap_in() / wrap_out() - convert Host type associated with - // G-type to internal representation type. - // - // - For "simple" (non-template) G-types, returns value as-is. - // Example: cv::GMat has host type cv::Mat, when user passes a - // cv::Mat, system stores it internally as cv::Mat. - // - // - For "complex" (template) G-types, utilizes custom - // wrap_in()/wrap_out() as described in Traits. - // Example: cv::GArray has host type std::vector, when - // user passes a std::vector, system stores it - // internally as VectorRef (with stripped away). - template struct WrapValue - { - static auto wrap(const T& t) -> - typename std::remove_reference::type - { - return static_cast::type>(t); - } - - template static U wrap_in (const U &u) { return u; } - template static U* wrap_out(U &u) { return &u; } - }; - template struct WrapValue::value>::type> - { - static auto wrap(const T& t) -> decltype(GTypeTraits::wrap_value(t)) - { - return GTypeTraits::wrap_value(t); - } - template static auto wrap_in (const U &u) -> typename GTypeTraits::strip_type - { - static_assert(!(cv::detail::has_gshape>::value - || cv::detail::contains::type, GAPI_OWN_TYPES_LIST>::value), - "gin/gout must not be used with G* classes or cv::gapi::own::*"); - return GTypeTraits::wrap_in(u); - } - template static auto wrap_out(U &u) -> typename GTypeTraits::strip_type - { - static_assert(!(cv::detail::has_gshape>::value - || cv::detail::contains::type, GAPI_OWN_TYPES_LIST>::value), - "gin/gout must not be used with G* classes or cv::gapi::own::*"); - return GTypeTraits::wrap_out(u); - } - }; - - template using wrap_gapi_helper = WrapValue::type>; - template using wrap_host_helper = WrapValue >::type>; - -// Union type for various user-defined type constructors (GArray, -// GOpaque, etc) -// -// TODO: Replace construct-only API with a more generic one (probably -// with bits of introspection) -// -// Not required for non-user-defined types (GMat, GScalar, etc) -using HostCtor = util::variant - < util::monostate - , detail::ConstructVec - , detail::ConstructOpaque - >; - -template struct GObtainCtor { - static HostCtor get() { return HostCtor{}; } -}; -template struct GObtainCtor > { - static HostCtor get() { return HostCtor{ConstructVec{&GArray::VCtor}}; } -}; -template struct GObtainCtor > { - static HostCtor get() { return HostCtor{ConstructOpaque{&GOpaque::Ctor}}; } -}; -} // namespace detail -} // namespace cv - -#endif // OPENCV_GAPI_GTYPE_TRAITS_HPP diff --git a/modules/gapi/include/opencv2/gapi/gtyped.hpp b/modules/gapi/include/opencv2/gapi/gtyped.hpp deleted file mode 100644 index 2acc2f7ffb..0000000000 --- a/modules/gapi/include/opencv2/gapi/gtyped.hpp +++ /dev/null @@ -1,246 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GTYPED_HPP -#define OPENCV_GAPI_GTYPED_HPP -#if !defined(GAPI_STANDALONE) - -#include - -#include -#include -#include -#include - -namespace cv { - -namespace detail -{ - // FIXME: How to prevent coolhackers from extending it by their own types? - // FIXME: ...Should we care? - template struct ProtoToParam; - template<> struct ProtoToParam { using type = cv::Mat; }; - template<> struct ProtoToParam { using type = cv::Scalar; }; - template struct ProtoToParam > { using type = std::vector; }; - template<> struct ProtoToParam> { using type = std::vector; }; - template struct ProtoToParam > { using type = U; }; - template using ProtoToParamT = typename ProtoToParam::type; - - template struct ProtoToMeta; - template<> struct ProtoToMeta { using type = cv::GMatDesc; }; - template<> struct ProtoToMeta { using type = cv::GScalarDesc; }; - template struct ProtoToMeta > { using type = cv::GArrayDesc; }; - template struct ProtoToMeta > { using type = cv::GOpaqueDesc; }; - template using ProtoToMetaT = typename ProtoToMeta::type; - - //workaround for MSVC 19.0 bug - template - auto make_default()->decltype(T{}) {return {};} -} // detail - -/** - * @brief This class is a typed wrapper over a regular GComputation. - * - * `std::function<>`-like template parameter specifies the graph - * signature so methods so the object's constructor, methods like - * `apply()` and the derived `GCompiledT::operator()` also become - * typed. - * - * There is no need to use cv::gin() or cv::gout() modifiers with - * objects of this class. Instead, all input arguments are followed - * by all output arguments in the order from the template argument - * signature. - * - * Refer to the following example. Regular (untyped) code is written this way: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp Untyped_Example - * - * Here: - * - * - cv::GComputation object is created with a lambda constructor - * where it is defined as a two-input, one-output graph. - * - * - Its method `apply()` in fact takes arbitrary number of arguments - * (as vectors) so user can pass wrong number of inputs/outputs - * here. C++ compiler wouldn't notice that since the cv::GComputation - * API is polymorphic, and only a run-time error will be generated. - * - * Now the same code written with typed API: - * - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp Typed_Example - * - * The key difference is: - * - * - Now the constructor lambda *must take* parameters and *must - * return* values as defined in the `GComputationT<>` signature. - * - Its method `apply()` does not require any extra specifiers to - * separate input arguments from the output ones - * - A `GCompiledT` (compilation product) takes input/output - * arguments with no extra specifiers as well. - */ -template class GComputationT; - -// Single return value implementation -template class GComputationT -{ -public: - typedef std::function Gen; - - class GCompiledT - { - private: - friend class GComputationT; - - cv::GCompiled m_comp; - - explicit GCompiledT(const cv::GCompiled &comp) : m_comp(comp) {} - - public: - GCompiledT() {} - - void operator()(detail::ProtoToParamT... inArgs, - detail::ProtoToParamT &outArg) - { - m_comp(cv::gin(inArgs...), cv::gout(outArg)); - } - - explicit operator bool() const - { - return static_cast(m_comp); - } - }; - -private: - typedef std::pair Captured; - - Captured capture(const Gen& g, Args... args) - { - return Captured(g(args...), cv::GIn(args...)); - } - - Captured m_capture; - cv::GComputation m_comp; - -public: - GComputationT(const Gen &generator) - : m_capture(capture(generator, detail::make_default()...)) - , m_comp(cv::GProtoInputArgs(std::move(m_capture.second)), - cv::GOut(m_capture.first)) - { - } - - void apply(detail::ProtoToParamT... inArgs, - detail::ProtoToParamT &outArg, - GCompileArgs &&args) - { - m_comp.apply(cv::gin(inArgs...), cv::gout(outArg), std::move(args)); - } - - void apply(detail::ProtoToParamT... inArgs, - detail::ProtoToParamT &outArg) - { - apply(inArgs..., outArg, GCompileArgs()); - } - - - GCompiledT compile(detail::ProtoToMetaT... inDescs) - { - GMetaArgs inMetas = { GMetaArg(inDescs)... }; - return GCompiledT(m_comp.compile(std::move(inMetas), GCompileArgs())); - } - - GCompiledT compile(detail::ProtoToMetaT... inDescs, GCompileArgs &&args) - { - GMetaArgs inMetas = { GMetaArg(inDescs)... }; - return GCompiledT(m_comp.compile(std::move(inMetas), std::move(args))); - } -}; - -// Multiple (fixed) return value implementation. FIXME: How to avoid copy-paste? -template class GComputationT(Args...)> -{ -public: - typedef std::function(Args...)> Gen; - - class GCompiledT - { - private: - friend class GComputationT(Args...)>; - - cv::GCompiled m_comp; - explicit GCompiledT(const cv::GCompiled &comp) : m_comp(comp) {} - - public: - GCompiledT() {} - - void operator()(detail::ProtoToParamT... inArgs, - detail::ProtoToParamT&... outArgs) - { - m_comp(cv::gin(inArgs...), cv::gout(outArgs...)); - } - - explicit operator bool() const - { - return static_cast(m_comp); - } - }; - -private: - typedef std::pair Captured; - - template - Captured capture(GProtoArgs &&args, const std::tuple &rr, detail::Seq) - { - return Captured(cv::GOut(std::get(rr)...).m_args, args); - } - - Captured capture(const Gen& g, Args... args) - { - return capture(cv::GIn(args...).m_args, g(args...), typename detail::MkSeq::type()); - } - - Captured m_capture; - cv::GComputation m_comp; - -public: - GComputationT(const Gen &generator) - : m_capture(capture(generator, detail::make_default()...)) - , m_comp(cv::GProtoInputArgs(std::move(m_capture.second)), - cv::GProtoOutputArgs(std::move(m_capture.first))) - { - } - - void apply(detail::ProtoToParamT... inArgs, - detail::ProtoToParamT&... outArgs, - GCompileArgs &&args) - { - m_comp.apply(cv::gin(inArgs...), cv::gout(outArgs...), std::move(args)); - } - - void apply(detail::ProtoToParamT... inArgs, - detail::ProtoToParamT&... outArgs) - { - apply(inArgs..., outArgs..., GCompileArgs()); - } - - - GCompiledT compile(detail::ProtoToMetaT... inDescs) - { - GMetaArgs inMetas = { GMetaArg(inDescs)... }; - return GCompiledT(m_comp.compile(std::move(inMetas), GCompileArgs())); - } - - GCompiledT compile(detail::ProtoToMetaT... inDescs, GCompileArgs &&args) - { - GMetaArgs inMetas = { GMetaArg(inDescs)... }; - return GCompiledT(m_comp.compile(std::move(inMetas), std::move(args))); - } -}; - -} // namespace cv -#endif // !defined(GAPI_STANDALONE) -#endif // OPENCV_GAPI_GTYPED_HPP diff --git a/modules/gapi/include/opencv2/gapi/imgproc.hpp b/modules/gapi/include/opencv2/gapi/imgproc.hpp deleted file mode 100644 index 96aaa5a447..0000000000 --- a/modules/gapi/include/opencv2/gapi/imgproc.hpp +++ /dev/null @@ -1,1769 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_IMGPROC_HPP -#define OPENCV_GAPI_IMGPROC_HPP - -#include - -#include // std::tuple - -#include -#include -#include - - -/** \defgroup gapi_imgproc G-API Image processing functionality -@{ - @defgroup gapi_filters Graph API: Image filters - @defgroup gapi_colorconvert Graph API: Converting image from one color space to another - @defgroup gapi_feature Graph API: Image Feature Detection - @defgroup gapi_shape Graph API: Image Structural Analysis and Shape Descriptors - @defgroup gapi_transform Graph API: Image and channel composition functions -@} - */ - -namespace { -void validateFindingContoursMeta(const int depth, const int chan, const int mode) -{ - GAPI_Assert(chan == 1); - switch (mode) - { - case cv::RETR_CCOMP: - GAPI_Assert(depth == CV_8U || depth == CV_32S); - break; - case cv::RETR_FLOODFILL: - GAPI_Assert(depth == CV_32S); - break; - default: - GAPI_Assert(depth == CV_8U); - break; - } -} -} // anonymous namespace - -namespace cv { namespace gapi { - -/** - * @brief This namespace contains G-API Operation Types for OpenCV - * ImgProc module functionality. - */ -namespace imgproc { - using GMat2 = std::tuple; - using GMat3 = std::tuple; // FIXME: how to avoid this? - using GFindContoursOutput = std::tuple>,GArray>; - - G_TYPED_KERNEL(GFilter2D, , "org.opencv.imgproc.filters.filter2D") { - static GMatDesc outMeta(GMatDesc in, int ddepth, Mat, Point, Scalar, int, Scalar) { - return in.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GSepFilter, , "org.opencv.imgproc.filters.sepfilter") { - static GMatDesc outMeta(GMatDesc in, int ddepth, Mat, Mat, Point, Scalar, int, Scalar) { - return in.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GBoxFilter, , "org.opencv.imgproc.filters.boxfilter") { - static GMatDesc outMeta(GMatDesc in, int ddepth, Size, Point, bool, int, Scalar) { - return in.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GBlur, , "org.opencv.imgproc.filters.blur") { - static GMatDesc outMeta(GMatDesc in, Size, Point, int, Scalar) { - return in; - } - }; - - G_TYPED_KERNEL(GGaussBlur, , "org.opencv.imgproc.filters.gaussianBlur") { - static GMatDesc outMeta(GMatDesc in, Size, double, double, int, Scalar) { - return in; - } - }; - - G_TYPED_KERNEL(GMedianBlur, , "org.opencv.imgproc.filters.medianBlur") { - static GMatDesc outMeta(GMatDesc in, int) { - return in; - } - }; - - G_TYPED_KERNEL(GErode, , "org.opencv.imgproc.filters.erode") { - static GMatDesc outMeta(GMatDesc in, Mat, Point, int, int, Scalar) { - return in; - } - }; - - G_TYPED_KERNEL(GDilate, , "org.opencv.imgproc.filters.dilate") { - static GMatDesc outMeta(GMatDesc in, Mat, Point, int, int, Scalar) { - return in; - } - }; - - G_TYPED_KERNEL(GMorphologyEx, , - "org.opencv.imgproc.filters.morphologyEx") { - static GMatDesc outMeta(const GMatDesc &in, MorphTypes, Mat, Point, int, - BorderTypes, Scalar) { - return in; - } - }; - - G_TYPED_KERNEL(GSobel, , "org.opencv.imgproc.filters.sobel") { - static GMatDesc outMeta(GMatDesc in, int ddepth, int, int, int, double, double, int, Scalar) { - return in.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL_M(GSobelXY, , "org.opencv.imgproc.filters.sobelxy") { - static std::tuple outMeta(GMatDesc in, int ddepth, int, int, double, double, int, Scalar) { - return std::make_tuple(in.withDepth(ddepth), in.withDepth(ddepth)); - } - }; - - G_TYPED_KERNEL(GLaplacian, , - "org.opencv.imgproc.filters.laplacian") { - static GMatDesc outMeta(GMatDesc in, int ddepth, int, double, double, int) { - return in.withDepth(ddepth); - } - }; - - G_TYPED_KERNEL(GBilateralFilter, , - "org.opencv.imgproc.filters.bilateralfilter") { - static GMatDesc outMeta(GMatDesc in, int, double, double, int) { - return in; - } - }; - - G_TYPED_KERNEL(GEqHist, , "org.opencv.imgproc.equalizeHist") { - static GMatDesc outMeta(GMatDesc in) { - return in.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL(GCanny, , "org.opencv.imgproc.feature.canny") { - static GMatDesc outMeta(GMatDesc in, double, double, int, bool) { - return in.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL(GGoodFeatures, - (GMat,int,double,double,Mat,int,bool,double)>, - "org.opencv.imgproc.feature.goodFeaturesToTrack") { - static GArrayDesc outMeta(GMatDesc, int, double, double, const Mat&, int, bool, double) { - return empty_array_desc(); - } - }; - - using RetrMode = RetrievalModes; - using ContMethod = ContourApproximationModes; - G_TYPED_KERNEL(GFindContours, >(GMat,RetrMode,ContMethod,GOpaque)>, - "org.opencv.imgproc.shape.findContours") - { - static GArrayDesc outMeta(GMatDesc in, RetrMode mode, ContMethod, GOpaqueDesc) - { - validateFindingContoursMeta(in.depth, in.chan, mode); - return empty_array_desc(); - } - }; - - // FIXME oc: make default value offset = Point() - G_TYPED_KERNEL(GFindContoursNoOffset, >(GMat,RetrMode,ContMethod)>, - "org.opencv.imgproc.shape.findContoursNoOffset") - { - static GArrayDesc outMeta(GMatDesc in, RetrMode mode, ContMethod) - { - validateFindingContoursMeta(in.depth, in.chan, mode); - return empty_array_desc(); - } - }; - - G_TYPED_KERNEL(GFindContoursH,)>, - "org.opencv.imgproc.shape.findContoursH") - { - static std::tuple - outMeta(GMatDesc in, RetrMode mode, ContMethod, GOpaqueDesc) - { - validateFindingContoursMeta(in.depth, in.chan, mode); - return std::make_tuple(empty_array_desc(), empty_array_desc()); - } - }; - - // FIXME oc: make default value offset = Point() - G_TYPED_KERNEL(GFindContoursHNoOffset,, - "org.opencv.imgproc.shape.findContoursHNoOffset") - { - static std::tuple - outMeta(GMatDesc in, RetrMode mode, ContMethod) - { - validateFindingContoursMeta(in.depth, in.chan, mode); - return std::make_tuple(empty_array_desc(), empty_array_desc()); - } - }; - - G_TYPED_KERNEL(GBoundingRectMat, (GMat)>, - "org.opencv.imgproc.shape.boundingRectMat") { - static GOpaqueDesc outMeta(GMatDesc in) { - if (in.depth == CV_8U) - { - GAPI_Assert(in.chan == 1); - } - else - { - GAPI_Assert (in.depth == CV_32S || in.depth == CV_32F); - int amount = detail::checkVector(in, 2u); - GAPI_Assert(amount != -1 && - "Input Mat can't be described as vector of 2-dimentional points"); - } - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GBoundingRectVector32S, (GArray)>, - "org.opencv.imgproc.shape.boundingRectVector32S") { - static GOpaqueDesc outMeta(GArrayDesc) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GBoundingRectVector32F, (GArray)>, - "org.opencv.imgproc.shape.boundingRectVector32F") { - static GOpaqueDesc outMeta(GArrayDesc) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine2DMat, (GMat,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine2DMat") { - static GOpaqueDesc outMeta(GMatDesc in,DistanceTypes,double,double,double) { - int amount = detail::checkVector(in, 2u); - GAPI_Assert(amount != -1 && - "Input Mat can't be described as vector of 2-dimentional points"); - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine2DVector32S, - (GArray,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine2DVector32S") { - static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine2DVector32F, - (GArray,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine2DVector32F") { - static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine2DVector64F, - (GArray,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine2DVector64F") { - static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine3DMat, (GMat,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine3DMat") { - static GOpaqueDesc outMeta(GMatDesc in,int,double,double,double) { - int amount = detail::checkVector(in, 3u); - GAPI_Assert(amount != -1 && - "Input Mat can't be described as vector of 3-dimentional points"); - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine3DVector32S, - (GArray,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine3DVector32S") { - static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine3DVector32F, - (GArray,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine3DVector32F") { - static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GFitLine3DVector64F, - (GArray,DistanceTypes,double,double,double)>, - "org.opencv.imgproc.shape.fitLine3DVector64F") { - static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) { - return empty_gopaque_desc(); - } - }; - - G_TYPED_KERNEL(GBGR2RGB, , "org.opencv.imgproc.colorconvert.bgr2rgb") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GRGB2YUV, , "org.opencv.imgproc.colorconvert.rgb2yuv") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GYUV2RGB, , "org.opencv.imgproc.colorconvert.yuv2rgb") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GBGR2I420, , "org.opencv.imgproc.colorconvert.bgr2i420") { - static GMatDesc outMeta(GMatDesc in) { - GAPI_Assert(in.depth == CV_8U); - GAPI_Assert(in.chan == 3); - GAPI_Assert(in.size.height % 2 == 0); - return in.withType(in.depth, 1).withSize(Size(in.size.width, in.size.height * 3 / 2)); - } - }; - - G_TYPED_KERNEL(GRGB2I420, , "org.opencv.imgproc.colorconvert.rgb2i420") { - static GMatDesc outMeta(GMatDesc in) { - GAPI_Assert(in.depth == CV_8U); - GAPI_Assert(in.chan == 3); - GAPI_Assert(in.size.height % 2 == 0); - return in.withType(in.depth, 1).withSize(Size(in.size.width, in.size.height * 3 / 2)); - } - }; - - G_TYPED_KERNEL(GI4202BGR, , "org.opencv.imgproc.colorconvert.i4202bgr") { - static GMatDesc outMeta(GMatDesc in) { - GAPI_Assert(in.depth == CV_8U); - GAPI_Assert(in.chan == 1); - GAPI_Assert(in.size.height % 3 == 0); - return in.withType(in.depth, 3).withSize(Size(in.size.width, in.size.height * 2 / 3)); - } - }; - - G_TYPED_KERNEL(GI4202RGB, , "org.opencv.imgproc.colorconvert.i4202rgb") { - static GMatDesc outMeta(GMatDesc in) { - GAPI_Assert(in.depth == CV_8U); - GAPI_Assert(in.chan == 1); - GAPI_Assert(in.size.height % 3 == 0); - return in.withType(in.depth, 3).withSize(Size(in.size.width, in.size.height * 2 / 3)); - } - }; - - G_TYPED_KERNEL(GNV12toRGB, , "org.opencv.imgproc.colorconvert.nv12torgb") { - static GMatDesc outMeta(GMatDesc in_y, GMatDesc in_uv) { - GAPI_Assert(in_y.chan == 1); - GAPI_Assert(in_uv.chan == 2); - GAPI_Assert(in_y.depth == CV_8U); - GAPI_Assert(in_uv.depth == CV_8U); - // UV size should be aligned with Y - GAPI_Assert(in_y.size.width == 2 * in_uv.size.width); - GAPI_Assert(in_y.size.height == 2 * in_uv.size.height); - return in_y.withType(CV_8U, 3); // type will be CV_8UC3; - } - }; - - G_TYPED_KERNEL(GNV12toBGR, , "org.opencv.imgproc.colorconvert.nv12tobgr") { - static GMatDesc outMeta(GMatDesc in_y, GMatDesc in_uv) { - GAPI_Assert(in_y.chan == 1); - GAPI_Assert(in_uv.chan == 2); - GAPI_Assert(in_y.depth == CV_8U); - GAPI_Assert(in_uv.depth == CV_8U); - // UV size should be aligned with Y - GAPI_Assert(in_y.size.width == 2 * in_uv.size.width); - GAPI_Assert(in_y.size.height == 2 * in_uv.size.height); - return in_y.withType(CV_8U, 3); // type will be CV_8UC3; - } - }; - - G_TYPED_KERNEL(GRGB2Lab, , "org.opencv.imgproc.colorconvert.rgb2lab") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GBGR2LUV, , "org.opencv.imgproc.colorconvert.bgr2luv") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GLUV2BGR, , "org.opencv.imgproc.colorconvert.luv2bgr") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GYUV2BGR, , "org.opencv.imgproc.colorconvert.yuv2bgr") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GBGR2YUV, , "org.opencv.imgproc.colorconvert.bgr2yuv") { - static GMatDesc outMeta(GMatDesc in) { - return in; // type still remains CV_8UC3; - } - }; - - G_TYPED_KERNEL(GRGB2Gray, , "org.opencv.imgproc.colorconvert.rgb2gray") { - static GMatDesc outMeta(GMatDesc in) { - return in.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL(GRGB2GrayCustom, , "org.opencv.imgproc.colorconvert.rgb2graycustom") { - static GMatDesc outMeta(GMatDesc in, float, float, float) { - return in.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL(GBGR2Gray, , "org.opencv.imgproc.colorconvert.bgr2gray") { - static GMatDesc outMeta(GMatDesc in) { - return in.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL(GBayerGR2RGB, , "org.opencv.imgproc.colorconvert.bayergr2rgb") { - static cv::GMatDesc outMeta(cv::GMatDesc in) { - return in.withType(CV_8U, 3); - } - }; - - G_TYPED_KERNEL(GRGB2HSV, , "org.opencv.imgproc.colorconvert.rgb2hsv") { - static cv::GMatDesc outMeta(cv::GMatDesc in) { - return in; - } - }; - - G_TYPED_KERNEL(GRGB2YUV422, , "org.opencv.imgproc.colorconvert.rgb2yuv422") { - static cv::GMatDesc outMeta(cv::GMatDesc in) { - GAPI_Assert(in.depth == CV_8U); - GAPI_Assert(in.chan == 3); - return in.withType(in.depth, 2); - } - }; - - G_TYPED_KERNEL(GNV12toRGBp, , "org.opencv.imgproc.colorconvert.nv12torgbp") { - static GMatDesc outMeta(GMatDesc inY, GMatDesc inUV) { - GAPI_Assert(inY.depth == CV_8U); - GAPI_Assert(inUV.depth == CV_8U); - GAPI_Assert(inY.chan == 1); - GAPI_Assert(inY.planar == false); - GAPI_Assert(inUV.chan == 2); - GAPI_Assert(inUV.planar == false); - GAPI_Assert(inY.size.width == 2 * inUV.size.width); - GAPI_Assert(inY.size.height == 2 * inUV.size.height); - return inY.withType(CV_8U, 3).asPlanar(); - } - }; - - G_TYPED_KERNEL(GNV12toGray, , "org.opencv.imgproc.colorconvert.nv12togray") { - static GMatDesc outMeta(GMatDesc inY, GMatDesc inUV) { - GAPI_Assert(inY.depth == CV_8U); - GAPI_Assert(inUV.depth == CV_8U); - GAPI_Assert(inY.chan == 1); - GAPI_Assert(inY.planar == false); - GAPI_Assert(inUV.chan == 2); - GAPI_Assert(inUV.planar == false); - - GAPI_Assert(inY.size.width == 2 * inUV.size.width); - GAPI_Assert(inY.size.height == 2 * inUV.size.height); - return inY.withType(CV_8U, 1); - } - }; - - G_TYPED_KERNEL(GNV12toBGRp, , "org.opencv.imgproc.colorconvert.nv12tobgrp") { - static GMatDesc outMeta(GMatDesc inY, GMatDesc inUV) { - GAPI_Assert(inY.depth == CV_8U); - GAPI_Assert(inUV.depth == CV_8U); - GAPI_Assert(inY.chan == 1); - GAPI_Assert(inY.planar == false); - GAPI_Assert(inUV.chan == 2); - GAPI_Assert(inUV.planar == false); - GAPI_Assert(inY.size.width == 2 * inUV.size.width); - GAPI_Assert(inY.size.height == 2 * inUV.size.height); - return inY.withType(CV_8U, 3).asPlanar(); - } - }; - - G_TYPED_KERNEL(GResize, , "org.opencv.imgproc.transform.resize") { - static GMatDesc outMeta(GMatDesc in, Size sz, double fx, double fy, int /*interp*/) { - if (sz.width != 0 && sz.height != 0) - { - return in.withSize(sz); - } - else - { - int outSz_w = saturate_cast(in.size.width * fx); - int outSz_h = saturate_cast(in.size.height * fy); - GAPI_Assert(outSz_w > 0 && outSz_h > 0); - return in.withSize(Size(outSz_w, outSz_h)); - } - } - }; - - G_TYPED_KERNEL(GResizeP, , "org.opencv.imgproc.transform.resizeP") { - static GMatDesc outMeta(GMatDesc in, Size sz, int interp) { - GAPI_Assert(in.depth == CV_8U); - GAPI_Assert(in.chan == 3); - GAPI_Assert(in.planar); - GAPI_Assert(interp == cv::INTER_LINEAR); - return in.withSize(sz); - } - }; - -} //namespace imgproc - -//! @addtogroup gapi_filters -//! @{ -/** @brief Applies a separable linear filter to a matrix(image). - -The function applies a separable linear filter to the matrix. That is, first, every row of src is -filtered with the 1D kernel kernelX. Then, every column of the result is filtered with the 1D -kernel kernelY. The final result is returned. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - In case of floating-point computation, rounding to nearest even is procedeed -if hardware supports it (if not - to nearest value). - - Function textual ID is "org.opencv.imgproc.filters.sepfilter" -@param src Source image. -@param ddepth desired depth of the destination image (the following combinations of src.depth() and ddepth are supported: - - src.depth() = CV_8U, ddepth = -1/CV_16S/CV_32F/CV_64F - src.depth() = CV_16U/CV_16S, ddepth = -1/CV_32F/CV_64F - src.depth() = CV_32F, ddepth = -1/CV_32F/CV_64F - src.depth() = CV_64F, ddepth = -1/CV_64F - -when ddepth=-1, the output image will have the same depth as the source) -@param kernelX Coefficients for filtering each row. -@param kernelY Coefficients for filtering each column. -@param anchor Anchor position within the kernel. The default value \f$(-1,-1)\f$ means that the anchor -is at the kernel center. -@param delta Value added to the filtered results before storing them. -@param borderType Pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa boxFilter, gaussianBlur, medianBlur - */ -GAPI_EXPORTS_W GMat sepFilter(const GMat& src, int ddepth, const Mat& kernelX, const Mat& kernelY, const Point& anchor /*FIXME: = Point(-1,-1)*/, - const Scalar& delta /*FIXME = GScalar(0)*/, int borderType = BORDER_DEFAULT, - const Scalar& borderValue = Scalar(0)); - -/** @brief Convolves an image with the kernel. - -The function applies an arbitrary linear filter to an image. When -the aperture is partially outside the image, the function interpolates outlier pixel values -according to the specified border mode. - -The function does actually compute correlation, not the convolution: - -\f[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\f] - -That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip -the kernel using flip and set the new anchor to `(kernel.cols - anchor.x - 1, kernel.rows - -anchor.y - 1)`. - -Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. -Output image must have the same size and number of channels an input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.filter2D" - -@param src input image. -@param ddepth desired depth of the destination image -@param kernel convolution kernel (or rather a correlation kernel), a single-channel floating point -matrix; if you want to apply different kernels to different channels, split the image into -separate color planes using split and process them individually. -@param anchor anchor of the kernel that indicates the relative position of a filtered point within -the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor -is at the kernel center. -@param delta optional value added to the filtered pixels before storing them in dst. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa sepFilter - */ -GAPI_EXPORTS_W GMat filter2D(const GMat& src, int ddepth, const Mat& kernel, const Point& anchor = Point(-1,-1), const Scalar& delta = Scalar(0), - int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0)); - - -/** @brief Blurs an image using the box filter. - -The function smooths an image using the kernel: - -\f[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\f] - -where - -\f[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise} \end{cases}\f] - -Unnormalized box filter is useful for computing various integral characteristics over each pixel -neighborhood, such as covariance matrices of image derivatives (used in dense optical flow -algorithms, and so on). If you need to compute pixel sums over variable-size windows, use cv::integral. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.boxfilter" - -@param src Source image. -@param dtype the output image depth (-1 to set the input image data type). -@param ksize blurring kernel size. -@param anchor Anchor position within the kernel. The default value \f$(-1,-1)\f$ means that the anchor -is at the kernel center. -@param normalize flag, specifying whether the kernel is normalized by its area or not. -@param borderType Pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa sepFilter, gaussianBlur, medianBlur, integral - */ -GAPI_EXPORTS_W GMat boxFilter(const GMat& src, int dtype, const Size& ksize, const Point& anchor = Point(-1,-1), - bool normalize = true, int borderType = BORDER_DEFAULT, - const Scalar& borderValue = Scalar(0)); - -/** @brief Blurs an image using the normalized box filter. - -The function smooths an image using the kernel: - -\f[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\f] - -The call `blur(src, ksize, anchor, borderType)` is equivalent to `boxFilter(src, src.type(), ksize, anchor, -true, borderType)`. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.blur" - -@param src Source image. -@param ksize blurring kernel size. -@param anchor anchor point; default value Point(-1,-1) means that the anchor is at the kernel -center. -@param borderType border mode used to extrapolate pixels outside of the image, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa boxFilter, bilateralFilter, GaussianBlur, medianBlur - */ -GAPI_EXPORTS_W GMat blur(const GMat& src, const Size& ksize, const Point& anchor = Point(-1,-1), - int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0)); - - -//GAPI_EXPORTS_W void blur( InputArray src, OutputArray dst, - // Size ksize, Point anchor = Point(-1,-1), - // int borderType = BORDER_DEFAULT ); - - -/** @brief Blurs an image using a Gaussian filter. - -The function filter2Ds the source image with the specified Gaussian kernel. -Output image must have the same type and number of channels an input image. - -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.gaussianBlur" - -@param src input image; -@param ksize Gaussian kernel size. ksize.width and ksize.height can differ but they both must be -positive and odd. Or, they can be zero's and then they are computed from sigma. -@param sigmaX Gaussian kernel standard deviation in X direction. -@param sigmaY Gaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be -equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height, -respectively (see cv::getGaussianKernel for details); to fully control the result regardless of -possible future modifications of all this semantics, it is recommended to specify all of ksize, -sigmaX, and sigmaY. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa sepFilter, boxFilter, medianBlur - */ -GAPI_EXPORTS_W GMat gaussianBlur(const GMat& src, const Size& ksize, double sigmaX, double sigmaY = 0, - int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0)); - -/** @brief Blurs an image using the median filter. - -The function smoothes an image using the median filter with the \f$\texttt{ksize} \times -\texttt{ksize}\f$ aperture. Each channel of a multi-channel image is processed independently. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. -The median filter uses cv::BORDER_REPLICATE internally to cope with border pixels, see cv::BorderTypes - - Function textual ID is "org.opencv.imgproc.filters.medianBlur" - -@param src input matrix (image) -@param ksize aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ... -@sa boxFilter, gaussianBlur - */ -GAPI_EXPORTS_W GMat medianBlur(const GMat& src, int ksize); - -/** @brief Erodes an image by using a specific structuring element. - -The function erodes the source image using the specified structuring element that determines the -shape of a pixel neighborhood over which the minimum is taken: - -\f[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] - -Erosion can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.erode" - -@param src input image -@param kernel structuring element used for erosion; if `element=Mat()`, a `3 x 3` rectangular -structuring element is used. Kernel can be created using getStructuringElement. -@param anchor position of the anchor within the element; default value (-1, -1) means that the -anchor is at the element center. -@param iterations number of times erosion is applied. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of a constant border -@sa dilate, morphologyEx - */ -GAPI_EXPORTS_W GMat erode(const GMat& src, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1, - int borderType = BORDER_CONSTANT, - const Scalar& borderValue = morphologyDefaultBorderValue()); - -/** @brief Erodes an image by using 3 by 3 rectangular structuring element. - -The function erodes the source image using the rectangular structuring element with rectangle center as an anchor. -Erosion can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.erode" - -@param src input image -@param iterations number of times erosion is applied. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of a constant border -@sa erode, dilate3x3 - */ -GAPI_EXPORTS_W GMat erode3x3(const GMat& src, int iterations = 1, - int borderType = BORDER_CONSTANT, - const Scalar& borderValue = morphologyDefaultBorderValue()); - -/** @brief Dilates an image by using a specific structuring element. - -The function dilates the source image using the specified structuring element that determines the -shape of a pixel neighborhood over which the maximum is taken: -\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] - -Dilation can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.dilate" - -@param src input image. -@param kernel structuring element used for dilation; if elemenat=Mat(), a 3 x 3 rectangular -structuring element is used. Kernel can be created using getStructuringElement -@param anchor position of the anchor within the element; default value (-1, -1) means that the -anchor is at the element center. -@param iterations number of times dilation is applied. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of a constant border -@sa erode, morphologyEx, getStructuringElement - */ -GAPI_EXPORTS_W GMat dilate(const GMat& src, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1, - int borderType = BORDER_CONSTANT, - const Scalar& borderValue = morphologyDefaultBorderValue()); - -/** @brief Dilates an image by using 3 by 3 rectangular structuring element. - -The function dilates the source image using the specified structuring element that determines the -shape of a pixel neighborhood over which the maximum is taken: -\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] - -Dilation can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. -Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1. -Output image must have the same type, size, and number of channels as the input image. -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.dilate" - -@param src input image. -@param iterations number of times dilation is applied. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of a constant border -@sa dilate, erode3x3 - */ - -GAPI_EXPORTS_W GMat dilate3x3(const GMat& src, int iterations = 1, - int borderType = BORDER_CONSTANT, - const Scalar& borderValue = morphologyDefaultBorderValue()); - -/** @brief Performs advanced morphological transformations. - -The function can perform advanced morphological transformations using an erosion and dilation as -basic operations. - -Any of the operations can be done in-place. In case of multi-channel images, each channel is -processed independently. - -@note - - Function textual ID is "org.opencv.imgproc.filters.morphologyEx" - - The number of iterations is the number of times erosion or dilatation operation will be -applied. For instance, an opening operation (#MORPH_OPEN) with two iterations is equivalent to -apply successively: erode -> erode -> dilate -> dilate -(and not erode -> dilate -> erode -> dilate). - -@param src Input image. -@param op Type of a morphological operation, see #MorphTypes -@param kernel Structuring element. It can be created using #getStructuringElement. -@param anchor Anchor position within the element. Both negative values mean that the anchor is at -the kernel center. -@param iterations Number of times erosion and dilation are applied. -@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported. -@param borderValue Border value in case of a constant border. The default value has a special -meaning. -@sa dilate, erode, getStructuringElement - */ -GAPI_EXPORTS_W GMat morphologyEx(const GMat &src, const MorphTypes op, const Mat &kernel, - const Point &anchor = Point(-1,-1), - const int iterations = 1, - const BorderTypes borderType = BORDER_CONSTANT, - const Scalar &borderValue = morphologyDefaultBorderValue()); - -/** @brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. - -In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$ separable kernel is used to -calculate the derivative. When \f$\texttt{ksize = 1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$ -kernel is used (that is, no Gaussian smoothing is done). `ksize = 1` can only be used for the first -or the second x- or y- derivatives. - -There is also the special value `ksize = FILTER_SCHARR (-1)` that corresponds to the \f$3\times3\f$ Scharr -filter that may give more accurate results than the \f$3\times3\f$ Sobel. The Scharr aperture is - -\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f] - -for the x-derivative, or transposed for the y-derivative. - -The function calculates an image derivative by convolving the image with the appropriate kernel: - -\f[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\f] - -The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less -resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3) -or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first -case corresponds to a kernel of: - -\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f] - -The second case corresponds to a kernel of: - -\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f] - -@note - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.sobel" - -@param src input image. -@param ddepth output image depth, see @ref filter_depths "combinations"; in the case of - 8-bit input images it will result in truncated derivatives. -@param dx order of the derivative x. -@param dy order of the derivative y. -@param ksize size of the extended Sobel kernel; it must be odd. -@param scale optional scale factor for the computed derivative values; by default, no scaling is -applied (see cv::getDerivKernels for details). -@param delta optional delta value that is added to the results prior to storing them in dst. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa filter2D, gaussianBlur, cartToPolar - */ -GAPI_EXPORTS_W GMat Sobel(const GMat& src, int ddepth, int dx, int dy, int ksize = 3, - double scale = 1, double delta = 0, - int borderType = BORDER_DEFAULT, - const Scalar& borderValue = Scalar(0)); - -/** @brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. - -In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$ separable kernel is used to -calculate the derivative. When \f$\texttt{ksize = 1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$ -kernel is used (that is, no Gaussian smoothing is done). `ksize = 1` can only be used for the first -or the second x- or y- derivatives. - -There is also the special value `ksize = FILTER_SCHARR (-1)` that corresponds to the \f$3\times3\f$ Scharr -filter that may give more accurate results than the \f$3\times3\f$ Sobel. The Scharr aperture is - -\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f] - -for the x-derivative, or transposed for the y-derivative. - -The function calculates an image derivative by convolving the image with the appropriate kernel: - -\f[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\f] - -The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less -resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3) -or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first -case corresponds to a kernel of: - -\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f] - -The second case corresponds to a kernel of: - -\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f] - -@note - - First returned matrix correspons to dx derivative while the second one to dy. - - Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. - - Function textual ID is "org.opencv.imgproc.filters.sobelxy" - -@param src input image. -@param ddepth output image depth, see @ref filter_depths "combinations"; in the case of - 8-bit input images it will result in truncated derivatives. -@param order order of the derivatives. -@param ksize size of the extended Sobel kernel; it must be odd. -@param scale optional scale factor for the computed derivative values; by default, no scaling is -applied (see cv::getDerivKernels for details). -@param delta optional delta value that is added to the results prior to storing them in dst. -@param borderType pixel extrapolation method, see cv::BorderTypes -@param borderValue border value in case of constant border type -@sa filter2D, gaussianBlur, cartToPolar - */ -GAPI_EXPORTS_W std::tuple SobelXY(const GMat& src, int ddepth, int order, int ksize = 3, - double scale = 1, double delta = 0, - int borderType = BORDER_DEFAULT, - const Scalar& borderValue = Scalar(0)); - -/** @brief Calculates the Laplacian of an image. - -The function calculates the Laplacian of the source image by adding up the second x and y -derivatives calculated using the Sobel operator: - -\f[\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\f] - -This is done when `ksize > 1`. When `ksize == 1`, the Laplacian is computed by filtering the image -with the following \f$3 \times 3\f$ aperture: - -\f[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\f] - -@note Function textual ID is "org.opencv.imgproc.filters.laplacian" - -@param src Source image. -@param ddepth Desired depth of the destination image. -@param ksize Aperture size used to compute the second-derivative filters. See #getDerivKernels for -details. The size must be positive and odd. -@param scale Optional scale factor for the computed Laplacian values. By default, no scaling is -applied. See #getDerivKernels for details. -@param delta Optional delta value that is added to the results prior to storing them in dst . -@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported. -@return Destination image of the same size and the same number of channels as src. -@sa Sobel, Scharr - */ -GAPI_EXPORTS_W GMat Laplacian(const GMat& src, int ddepth, int ksize = 1, - double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT); - -/** @brief Applies the bilateral filter to an image. - -The function applies bilateral filtering to the input image, as described in -http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html -bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is -very slow compared to most filters. - -_Sigma values_: For simplicity, you can set the 2 sigma values to be the same. If they are small (\< -10), the filter will not have much effect, whereas if they are large (\> 150), they will have a very -strong effect, making the image look "cartoonish". - -_Filter size_: Large filters (d \> 5) are very slow, so it is recommended to use d=5 for real-time -applications, and perhaps d=9 for offline applications that need heavy noise filtering. - -This filter does not work inplace. - -@note Function textual ID is "org.opencv.imgproc.filters.bilateralfilter" - -@param src Source 8-bit or floating-point, 1-channel or 3-channel image. -@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, -it is computed from sigmaSpace. -@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that -farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting -in larger areas of semi-equal color. -@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that -farther pixels will influence each other as long as their colors are close enough (see sigmaColor -). When d\>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is -proportional to sigmaSpace. -@param borderType border mode used to extrapolate pixels outside of the image, see #BorderTypes -@return Destination image of the same size and type as src. - */ -GAPI_EXPORTS_W GMat bilateralFilter(const GMat& src, int d, double sigmaColor, double sigmaSpace, - int borderType = BORDER_DEFAULT); - -//! @} gapi_filters - -//! @addtogroup gapi_feature -//! @{ -/** @brief Finds edges in an image using the Canny algorithm. - -The function finds edges in the input image and marks them in the output map edges using the -Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The -largest value is used to find initial segments of strong edges. See - - -@note Function textual ID is "org.opencv.imgproc.feature.canny" - -@param image 8-bit input image. -@param threshold1 first threshold for the hysteresis procedure. -@param threshold2 second threshold for the hysteresis procedure. -@param apertureSize aperture size for the Sobel operator. -@param L2gradient a flag, indicating whether a more accurate \f$L_2\f$ norm -\f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image gradient magnitude ( -L2gradient=true ), or whether the default \f$L_1\f$ norm \f$=|dI/dx|+|dI/dy|\f$ is enough ( -L2gradient=false ). - */ -GAPI_EXPORTS_W GMat Canny(const GMat& image, double threshold1, double threshold2, - int apertureSize = 3, bool L2gradient = false); - -/** @brief Determines strong corners on an image. - -The function finds the most prominent corners in the image or in the specified image region, as -described in @cite Shi94 - -- Function calculates the corner quality measure at every source image pixel using the - #cornerMinEigenVal or #cornerHarris . -- Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are - retained). -- The corners with the minimal eigenvalue less than - \f$\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\f$ are rejected. -- The remaining corners are sorted by the quality measure in the descending order. -- Function throws away each corner for which there is a stronger corner at a distance less than - maxDistance. - -The function can be used to initialize a point-based tracker of an object. - -@note - - If the function is called with different values A and B of the parameter qualityLevel , and -A \> B, the vector of returned corners with qualityLevel=A will be the prefix of the output vector -with qualityLevel=B . - - Function textual ID is "org.opencv.imgproc.feature.goodFeaturesToTrack" - -@param image Input 8-bit or floating-point 32-bit, single-channel image. -@param maxCorners Maximum number of corners to return. If there are more corners than are found, -the strongest of them is returned. `maxCorners <= 0` implies that no limit on the maximum is set -and all detected corners are returned. -@param qualityLevel Parameter characterizing the minimal accepted quality of image corners. The -parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue -(see #cornerMinEigenVal ) or the Harris function response (see #cornerHarris ). The corners with the -quality measure less than the product are rejected. For example, if the best corner has the -quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure -less than 15 are rejected. -@param minDistance Minimum possible Euclidean distance between the returned corners. -@param mask Optional region of interest. If the image is not empty (it needs to have the type -CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected. -@param blockSize Size of an average block for computing a derivative covariation matrix over each -pixel neighborhood. See cornerEigenValsAndVecs . -@param useHarrisDetector Parameter indicating whether to use a Harris detector (see #cornerHarris) -or #cornerMinEigenVal. -@param k Free parameter of the Harris detector. - -@return vector of detected corners. - */ -GAPI_EXPORTS_W GArray goodFeaturesToTrack(const GMat &image, - int maxCorners, - double qualityLevel, - double minDistance, - const Mat &mask = Mat(), - int blockSize = 3, - bool useHarrisDetector = false, - double k = 0.04); - -/** @brief Equalizes the histogram of a grayscale image. - -//! @} gapi_feature - -The function equalizes the histogram of the input image using the following algorithm: - -- Calculate the histogram \f$H\f$ for src . -- Normalize the histogram so that the sum of histogram bins is 255. -- Compute the integral of the histogram: -\f[H'_i = \sum _{0 \le j < i} H(j)\f] -- Transform the image using \f$H'\f$ as a look-up table: \f$\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\f$ - -The algorithm normalizes the brightness and increases the contrast of the image. -@note - - The returned image is of the same size and type as input. - - Function textual ID is "org.opencv.imgproc.equalizeHist" - -@param src Source 8-bit single channel image. - */ -GAPI_EXPORTS_W GMat equalizeHist(const GMat& src); - -//! @addtogroup gapi_shape -//! @{ -/** @brief Finds contours in a binary image. - -The function retrieves contours from the binary image using the algorithm @cite Suzuki85 . -The contours are a useful tool for shape analysis and object detection and recognition. -See squares.cpp in the OpenCV sample directory. - -@note Function textual ID is "org.opencv.imgproc.shape.findContours" - -@param src Input gray-scale image @ref CV_8UC1. Non-zero pixels are treated as 1's. Zero -pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, #threshold , -#adaptiveThreshold, #Canny, and others to create a binary image out of a grayscale or color one. -If mode equals to #RETR_CCOMP, the input can also be a 32-bit integer -image of labels ( @ref CV_32SC1 ). If #RETR_FLOODFILL then @ref CV_32SC1 is supported only. -@param mode Contour retrieval mode, see #RetrievalModes -@param method Contour approximation method, see #ContourApproximationModes -@param offset Optional offset by which every contour point is shifted. This is useful if the -contours are extracted from the image ROI and then they should be analyzed in the whole image -context. - -@return GArray of detected contours. Each contour is stored as a GArray of points. - */ -GAPI_EXPORTS GArray> -findContours(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method, - const GOpaque &offset); - -// FIXME oc: make default value offset = Point() -/** @overload -@note Function textual ID is "org.opencv.imgproc.shape.findContoursNoOffset" - */ -GAPI_EXPORTS GArray> -findContours(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method); - -/** @brief Finds contours and their hierarchy in a binary image. - -The function retrieves contours from the binary image using the algorithm @cite Suzuki85 -and calculates their hierarchy. -The contours are a useful tool for shape analysis and object detection and recognition. -See squares.cpp in the OpenCV sample directory. - -@note Function textual ID is "org.opencv.imgproc.shape.findContoursH" - -@param src Input gray-scale image @ref CV_8UC1. Non-zero pixels are treated as 1's. Zero -pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, #threshold , -#adaptiveThreshold, #Canny, and others to create a binary image out of a grayscale or color one. -If mode equals to #RETR_CCOMP, the input can also be a 32-bit integer -image of labels ( @ref CV_32SC1 ). If #RETR_FLOODFILL -- @ref CV_32SC1 supports only. -@param mode Contour retrieval mode, see #RetrievalModes -@param method Contour approximation method, see #ContourApproximationModes -@param offset Optional offset by which every contour point is shifted. This is useful if the -contours are extracted from the image ROI and then they should be analyzed in the whole image -context. - -@return - - GArray of detected contours. Each contour is stored as a GArray of points. - - Optional output GArray of cv::Vec4i, containing information about the image topology. -It has as many elements as the number of contours. For each i-th contour contours[i], the elements -hierarchy[i][0] , hierarchy[i][1] , hierarchy[i][2] , and hierarchy[i][3] are set to 0-based -indices in contours of the next and previous contours at the same hierarchical level, the first -child contour and the parent contour, respectively. If for the contour i there are no next, -previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative. - */ -GAPI_EXPORTS std::tuple>,GArray> -findContoursH(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method, - const GOpaque &offset); - -// FIXME oc: make default value offset = Point() -/** @overload -@note Function textual ID is "org.opencv.imgproc.shape.findContoursHNoOffset" - */ -GAPI_EXPORTS std::tuple>,GArray> -findContoursH(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method); - -/** @brief Calculates the up-right bounding rectangle of a point set or non-zero pixels -of gray-scale image. - -The function calculates and returns the minimal up-right bounding rectangle for the specified -point set or non-zero pixels of gray-scale image. - -@note - - Function textual ID is "org.opencv.imgproc.shape.boundingRectMat" - - In case of a 2D points' set given, Mat should be 2-dimensional, have a single row or column -if there are 2 channels, or have 2 columns if there is a single channel. Mat should have either -@ref CV_32S or @ref CV_32F depth - -@param src Input gray-scale image @ref CV_8UC1; or input set of @ref CV_32S or @ref CV_32F -2D points stored in Mat. - */ -GAPI_EXPORTS_W GOpaque boundingRect(const GMat& src); - -/** @overload - -Calculates the up-right bounding rectangle of a point set. - -@note Function textual ID is "org.opencv.imgproc.shape.boundingRectVector32S" - -@param src Input 2D point set, stored in std::vector. - */ -GAPI_EXPORTS_W GOpaque boundingRect(const GArray& src); - -/** @overload - -Calculates the up-right bounding rectangle of a point set. - -@note Function textual ID is "org.opencv.imgproc.shape.boundingRectVector32F" - -@param src Input 2D point set, stored in std::vector. - */ -GAPI_EXPORTS_W GOpaque boundingRect(const GArray& src); - -/** @brief Fits a line to a 2D point set. - -The function fits a line to a 2D point set by minimizing \f$\sum_i \rho(r_i)\f$ where -\f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and \f$\rho(r)\f$ is a distance -function, one of the following: -- DIST_L2 -\f[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\f] -- DIST_L1 -\f[\rho (r) = r\f] -- DIST_L12 -\f[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f] -- DIST_FAIR -\f[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\f] -- DIST_WELSCH -\f[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\f] -- DIST_HUBER -\f[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\f] - -The algorithm is based on the M-estimator ( ) technique -that iteratively fits the line using the weighted least-squares algorithm. After each iteration the -weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ . - -@note - - Function textual ID is "org.opencv.imgproc.shape.fitLine2DMat" - - In case of an N-dimentional points' set given, Mat should be 2-dimensional, have a single row -or column if there are N channels, or have N columns if there is a single channel. - -@param src Input set of 2D points stored in one of possible containers: Mat, -std::vector, std::vector, std::vector. -@param distType Distance used by the M-estimator, see #DistanceTypes. @ref DIST_USER -and @ref DIST_C are not supported. -@param param Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value -is chosen. -@param reps Sufficient accuracy for the radius (distance between the coordinate origin and the -line). 1.0 would be a good default value for reps. If it is 0, a default value is chosen. -@param aeps Sufficient accuracy for the angle. 0.01 would be a good default value for aeps. -If it is 0, a default value is chosen. - -@return Output line parameters: a vector of 4 elements (like Vec4f) - (vx, vy, x0, y0), -where (vx, vy) is a normalized vector collinear to the line and (x0, y0) is a point on the line. - */ -GAPI_EXPORTS GOpaque fitLine2D(const GMat& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @overload - -@note Function textual ID is "org.opencv.imgproc.shape.fitLine2DVector32S" - - */ -GAPI_EXPORTS GOpaque fitLine2D(const GArray& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @overload - -@note Function textual ID is "org.opencv.imgproc.shape.fitLine2DVector32F" - - */ -GAPI_EXPORTS GOpaque fitLine2D(const GArray& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @overload - -@note Function textual ID is "org.opencv.imgproc.shape.fitLine2DVector64F" - - */ -GAPI_EXPORTS GOpaque fitLine2D(const GArray& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @brief Fits a line to a 3D point set. - -The function fits a line to a 3D point set by minimizing \f$\sum_i \rho(r_i)\f$ where -\f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and \f$\rho(r)\f$ is a distance -function, one of the following: -- DIST_L2 -\f[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\f] -- DIST_L1 -\f[\rho (r) = r\f] -- DIST_L12 -\f[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f] -- DIST_FAIR -\f[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\f] -- DIST_WELSCH -\f[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\f] -- DIST_HUBER -\f[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\f] - -The algorithm is based on the M-estimator ( ) technique -that iteratively fits the line using the weighted least-squares algorithm. After each iteration the -weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ . - -@note - - Function textual ID is "org.opencv.imgproc.shape.fitLine3DMat" - - In case of an N-dimentional points' set given, Mat should be 2-dimensional, have a single row -or column if there are N channels, or have N columns if there is a single channel. - -@param src Input set of 3D points stored in one of possible containers: Mat, -std::vector, std::vector, std::vector. -@param distType Distance used by the M-estimator, see #DistanceTypes. @ref DIST_USER -and @ref DIST_C are not supported. -@param param Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value -is chosen. -@param reps Sufficient accuracy for the radius (distance between the coordinate origin and the -line). 1.0 would be a good default value for reps. If it is 0, a default value is chosen. -@param aeps Sufficient accuracy for the angle. 0.01 would be a good default value for aeps. -If it is 0, a default value is chosen. - -@return Output line parameters: a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0, z0), -where (vx, vy, vz) is a normalized vector collinear to the line and (x0, y0, z0) is a point on -the line. - */ -GAPI_EXPORTS GOpaque fitLine3D(const GMat& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @overload - -@note Function textual ID is "org.opencv.imgproc.shape.fitLine3DVector32S" - - */ -GAPI_EXPORTS GOpaque fitLine3D(const GArray& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @overload - -@note Function textual ID is "org.opencv.imgproc.shape.fitLine3DVector32F" - - */ -GAPI_EXPORTS GOpaque fitLine3D(const GArray& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -/** @overload - -@note Function textual ID is "org.opencv.imgproc.shape.fitLine3DVector64F" - - */ -GAPI_EXPORTS GOpaque fitLine3D(const GArray& src, const DistanceTypes distType, - const double param = 0., const double reps = 0., - const double aeps = 0.); - -//! @} gapi_shape - -//! @addtogroup gapi_colorconvert -//! @{ -/** @brief Converts an image from BGR color space to RGB color space. - -The function converts an input image from BGR color space to RGB. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image is 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2rgb" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa RGB2BGR -*/ -GAPI_EXPORTS_W GMat BGR2RGB(const GMat& src); - -/** @brief Converts an image from RGB color space to gray-scaled. - -The conventional ranges for R, G, and B channel values are 0 to 255. -Resulting gray color value computed as -\f[\texttt{dst} (I)= \texttt{0.299} * \texttt{src}(I).R + \texttt{0.587} * \texttt{src}(I).G + \texttt{0.114} * \texttt{src}(I).B \f] - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2gray" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1. -@sa RGB2YUV - */ -GAPI_EXPORTS_W GMat RGB2Gray(const GMat& src); - -/** @overload -Resulting gray color value computed as -\f[\texttt{dst} (I)= \texttt{rY} * \texttt{src}(I).R + \texttt{gY} * \texttt{src}(I).G + \texttt{bY} * \texttt{src}(I).B \f] - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2graycustom" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1. -@param rY float multiplier for R channel. -@param gY float multiplier for G channel. -@param bY float multiplier for B channel. -@sa RGB2YUV - */ -GAPI_EXPORTS_W GMat RGB2Gray(const GMat& src, float rY, float gY, float bY); - -/** @brief Converts an image from BGR color space to gray-scaled. - -The conventional ranges for B, G, and R channel values are 0 to 255. -Resulting gray color value computed as -\f[\texttt{dst} (I)= \texttt{0.114} * \texttt{src}(I).B + \texttt{0.587} * \texttt{src}(I).G + \texttt{0.299} * \texttt{src}(I).R \f] - -@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2gray" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1. -@sa BGR2LUV - */ -GAPI_EXPORTS_W GMat BGR2Gray(const GMat& src); - -/** @brief Converts an image from RGB color space to YUV color space. - -The function converts an input image from RGB color space to YUV. -The conventional ranges for R, G, and B channel values are 0 to 255. - -In case of linear transformations, the range does not matter. But in case of a non-linear -transformation, an input RGB image should be normalized to the proper value range to get the correct -results, like here, at RGB \f$\rightarrow\f$ Y\*u\*v\* transformation. -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2yuv" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa YUV2RGB, RGB2Lab -*/ -GAPI_EXPORTS_W GMat RGB2YUV(const GMat& src); - -/** @brief Converts an image from BGR color space to I420 color space. - -The function converts an input image from BGR color space to I420. -The conventional ranges for R, G, and B channel values are 0 to 255. - -Output image must be 8-bit unsigned 1-channel image. @ref CV_8UC1. -Width of I420 output image must be the same as width of input image. -Height of I420 output image must be equal 3/2 from height of input image. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2i420" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa I4202BGR -*/ -GAPI_EXPORTS_W GMat BGR2I420(const GMat& src); - -/** @brief Converts an image from RGB color space to I420 color space. - -The function converts an input image from RGB color space to I420. -The conventional ranges for R, G, and B channel values are 0 to 255. - -Output image must be 8-bit unsigned 1-channel image. @ref CV_8UC1. -Width of I420 output image must be the same as width of input image. -Height of I420 output image must be equal 3/2 from height of input image. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2i420" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa I4202RGB -*/ -GAPI_EXPORTS_W GMat RGB2I420(const GMat& src); - -/** @brief Converts an image from I420 color space to BGR color space. - -The function converts an input image from I420 color space to BGR. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image. @ref CV_8UC3. -Width of BGR output image must be the same as width of input image. -Height of BGR output image must be equal 2/3 from height of input image. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.i4202bgr" - -@param src input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@sa BGR2I420 -*/ -GAPI_EXPORTS_W GMat I4202BGR(const GMat& src); - -/** @brief Converts an image from I420 color space to BGR color space. - -The function converts an input image from I420 color space to BGR. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image. @ref CV_8UC3. -Width of RGB output image must be the same as width of input image. -Height of RGB output image must be equal 2/3 from height of input image. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.i4202rgb" - -@param src input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@sa RGB2I420 -*/ -GAPI_EXPORTS_W GMat I4202RGB(const GMat& src); - -/** @brief Converts an image from BGR color space to LUV color space. - -The function converts an input image from BGR color space to LUV. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2luv" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa RGB2Lab, RGB2LUV -*/ -GAPI_EXPORTS_W GMat BGR2LUV(const GMat& src); - -/** @brief Converts an image from LUV color space to BGR color space. - -The function converts an input image from LUV color space to BGR. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.luv2bgr" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa BGR2LUV -*/ -GAPI_EXPORTS_W GMat LUV2BGR(const GMat& src); - -/** @brief Converts an image from YUV color space to BGR color space. - -The function converts an input image from YUV color space to BGR. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.yuv2bgr" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa BGR2YUV -*/ -GAPI_EXPORTS_W GMat YUV2BGR(const GMat& src); - -/** @brief Converts an image from BGR color space to YUV color space. - -The function converts an input image from BGR color space to YUV. -The conventional ranges for B, G, and R channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2yuv" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@sa YUV2BGR -*/ -GAPI_EXPORTS_W GMat BGR2YUV(const GMat& src); - -/** @brief Converts an image from RGB color space to Lab color space. - -The function converts an input image from BGR color space to Lab. -The conventional ranges for R, G, and B channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC1. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2lab" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1. -@sa RGB2YUV, RGB2LUV -*/ -GAPI_EXPORTS_W GMat RGB2Lab(const GMat& src); - -/** @brief Converts an image from YUV color space to RGB. -The function converts an input image from YUV color space to RGB. -The conventional ranges for Y, U, and V channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.yuv2rgb" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. - -@sa RGB2Lab, RGB2YUV -*/ -GAPI_EXPORTS_W GMat YUV2RGB(const GMat& src); - -/** @brief Converts an image from NV12 (YUV420p) color space to RGB. -The function converts an input image from NV12 color space to RGB. -The conventional ranges for Y, U, and V channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12torgb" - -@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2. - -@sa YUV2RGB, NV12toBGR -*/ -GAPI_EXPORTS_W GMat NV12toRGB(const GMat& src_y, const GMat& src_uv); - -/** @brief Converts an image from NV12 (YUV420p) color space to gray-scaled. -The function converts an input image from NV12 color space to gray-scaled. -The conventional ranges for Y, U, and V channel values are 0 to 255. - -Output image must be 8-bit unsigned 1-channel image @ref CV_8UC1. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12togray" - -@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2. - -@sa YUV2RGB, NV12toBGR -*/ -GAPI_EXPORTS_W GMat NV12toGray(const GMat& src_y, const GMat& src_uv); - -/** @brief Converts an image from NV12 (YUV420p) color space to BGR. -The function converts an input image from NV12 color space to RGB. -The conventional ranges for Y, U, and V channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12tobgr" - -@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2. - -@sa YUV2BGR, NV12toRGB -*/ -GAPI_EXPORTS_W GMat NV12toBGR(const GMat& src_y, const GMat& src_uv); - -/** @brief Converts an image from BayerGR color space to RGB. -The function converts an input image from BayerGR color space to RGB. -The conventional ranges for G, R, and B channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.bayergr2rgb" - -@param src_gr input image: 8-bit unsigned 1-channel image @ref CV_8UC1. - -@sa YUV2BGR, NV12toRGB -*/ -GAPI_EXPORTS_W GMat BayerGR2RGB(const GMat& src_gr); - -/** @brief Converts an image from RGB color space to HSV. -The function converts an input image from RGB color space to HSV. -The conventional ranges for R, G, and B channel values are 0 to 255. - -Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2hsv" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. - -@sa YUV2BGR, NV12toRGB -*/ -GAPI_EXPORTS_W GMat RGB2HSV(const GMat& src); - -/** @brief Converts an image from RGB color space to YUV422. -The function converts an input image from RGB color space to YUV422. -The conventional ranges for R, G, and B channel values are 0 to 255. - -Output image must be 8-bit unsigned 2-channel image @ref CV_8UC2. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2yuv422" - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3. - -@sa YUV2BGR, NV12toRGB -*/ -GAPI_EXPORTS_W GMat RGB2YUV422(const GMat& src); - -/** @brief Converts an image from NV12 (YUV420p) color space to RGB. -The function converts an input image from NV12 color space to RGB. -The conventional ranges for Y, U, and V channel values are 0 to 255. - -Output image must be 8-bit unsigned planar 3-channel image @ref CV_8UC1. -Planar image memory layout is three planes laying in the memory contiguously, -so the image height should be plane_height*plane_number, -image type is @ref CV_8UC1. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12torgbp" - -@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2. - -@sa YUV2RGB, NV12toBGRp, NV12toRGB -*/ -GAPI_EXPORTS GMatP NV12toRGBp(const GMat &src_y, const GMat &src_uv); - -/** @brief Converts an image from NV12 (YUV420p) color space to BGR. -The function converts an input image from NV12 color space to BGR. -The conventional ranges for Y, U, and V channel values are 0 to 255. - -Output image must be 8-bit unsigned planar 3-channel image @ref CV_8UC1. -Planar image memory layout is three planes laying in the memory contiguously, -so the image height should be plane_height*plane_number, -image type is @ref CV_8UC1. - -@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12torgbp" - -@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2. - -@sa YUV2RGB, NV12toRGBp, NV12toBGR -*/ -GAPI_EXPORTS GMatP NV12toBGRp(const GMat &src_y, const GMat &src_uv); - -//! @} gapi_colorconvert -//! @addtogroup gapi_transform -//! @{ -/** @brief Resizes an image. - -The function resizes the image src down to or up to the specified size. - -Output image size will have the size dsize (when dsize is non-zero) or the size computed from -src.size(), fx, and fy; the depth of output is the same as of src. - -If you want to resize src so that it fits the pre-created dst, -you may call the function as follows: -@code - // explicitly specify dsize=dst.size(); fx and fy will be computed from that. - resize(src, dst, dst.size(), 0, 0, interpolation); -@endcode -If you want to decimate the image by factor of 2 in each direction, you can call the function this -way: -@code - // specify fx and fy and let the function compute the destination image size. - resize(src, dst, Size(), 0.5, 0.5, interpolation); -@endcode -To shrink an image, it will generally look best with cv::INTER_AREA interpolation, whereas to -enlarge an image, it will generally look best with cv::INTER_CUBIC (slow) or cv::INTER_LINEAR -(faster but still looks OK). - -@note Function textual ID is "org.opencv.imgproc.transform.resize" - -@param src input image. -@param dsize output image size; if it equals zero, it is computed as: - \f[\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}\f] - Either dsize or both fx and fy must be non-zero. -@param fx scale factor along the horizontal axis; when it equals 0, it is computed as -\f[\texttt{(double)dsize.width/src.cols}\f] -@param fy scale factor along the vertical axis; when it equals 0, it is computed as -\f[\texttt{(double)dsize.height/src.rows}\f] -@param interpolation interpolation method, see cv::InterpolationFlags - -@sa warpAffine, warpPerspective, remap, resizeP - */ -GAPI_EXPORTS_W GMat resize(const GMat& src, const Size& dsize, double fx = 0, double fy = 0, int interpolation = INTER_LINEAR); - -/** @brief Resizes a planar image. - -The function resizes the image src down to or up to the specified size. -Planar image memory layout is three planes laying in the memory contiguously, -so the image height should be plane_height*plane_number, image type is @ref CV_8UC1. - -Output image size will have the size dsize, the depth of output is the same as of src. - -@note Function textual ID is "org.opencv.imgproc.transform.resizeP" - -@param src input image, must be of @ref CV_8UC1 type; -@param dsize output image size; -@param interpolation interpolation method, only cv::INTER_LINEAR is supported at the moment - -@sa warpAffine, warpPerspective, remap, resize - */ -GAPI_EXPORTS GMatP resizeP(const GMatP& src, const Size& dsize, int interpolation = cv::INTER_LINEAR); - -//! @} gapi_transform -} //namespace gapi -} //namespace cv - -#endif // OPENCV_GAPI_IMGPROC_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer.hpp b/modules/gapi/include/opencv2/gapi/infer.hpp deleted file mode 100644 index abbd32ba20..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer.hpp +++ /dev/null @@ -1,717 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019-2021 Intel Corporation - - -#ifndef OPENCV_GAPI_INFER_HPP -#define OPENCV_GAPI_INFER_HPP - -// FIXME: Inference API is currently only available in full mode -#if !defined(GAPI_STANDALONE) - -#include -#include // string -#include // tuple -#include // is_same, false_type - -#include // all_satisfy -#include // any<> -#include // GKernelType[M], GBackend -#include // GArg -#include // CompileArgTag -#include // GMetaArg - -namespace cv { - -template class GNetworkType; - -namespace detail { - -// Infer /////////////////////////////////////////////////////////////////////// -template -struct accepted_infer_types { - static constexpr const auto value = - std::is_same::type, cv::GMat>::value - || std::is_same::type, cv::GFrame>::value; -}; - -template -using valid_infer_types = all_satisfy; - -// Infer2 ////////////////////////////////////////////////////////////////////// - -template -struct valid_infer2_types; - -// Terminal case 1 (50/50 success) -template -struct valid_infer2_types< std::tuple, std::tuple > { - // By default, Nets are limited to GMat argument types only - // for infer2, every GMat argument may translate to either - // GArray or GArray. GArray<> part is stripped - // already at this point. - static constexpr const auto value = - std::is_same::type, cv::GMat>::value - || std::is_same::type, cv::Rect>::value; -}; - -// Terminal case 2 (100% failure) -template -struct valid_infer2_types< std::tuple<>, std::tuple > - : public std::false_type { -}; - -// Terminal case 3 (100% failure) -template -struct valid_infer2_types< std::tuple, std::tuple<> > - : public std::false_type { -}; - -// Recursion -- generic -template -struct valid_infer2_types< std::tuple, std::tuple > { - static constexpr const auto value = - valid_infer2_types< std::tuple, std::tuple >::value - && valid_infer2_types< std::tuple, std::tuple >::value; -}; - -// Struct stores network input/output names. -// Used by infer -struct InOutInfo -{ - std::vector in_names; - std::vector out_names; -}; - -template -class GInferOutputsTyped -{ -public: - GInferOutputsTyped() = default; - GInferOutputsTyped(std::shared_ptr call) - : m_priv(std::make_shared(std::move(call))) - { - } - - OutT at(const std::string& name) - { - auto it = m_priv->blobs.find(name); - if (it == m_priv->blobs.end()) { - // FIXME: Avoid modifying GKernel - auto shape = cv::detail::GTypeTraits::shape; - auto kind = cv::detail::GTypeTraits::op_kind; - m_priv->call->kernel().outShapes.push_back(shape); - m_priv->call->kernel().outCtors.emplace_back(cv::detail::GObtainCtor::get()); - m_priv->call->kernel().outKinds.emplace_back(kind); - auto out_idx = static_cast(m_priv->blobs.size()); - it = m_priv->blobs.emplace(name, - cv::detail::Yield::yield(*(m_priv->call), out_idx)).first; - m_priv->info->out_names.push_back(name); - } - return it->second; - } -private: - struct Priv - { - Priv(std::shared_ptr c) - : call(std::move(c)), info(cv::util::any_cast(&call->params())) - { - } - - std::shared_ptr call; - InOutInfo* info = nullptr; - std::unordered_map blobs; - }; - - std::shared_ptr m_priv; -}; - -template -class GInferInputsTyped -{ -public: - GInferInputsTyped() - : m_priv(std::make_shared()) - { - } - - template - GInferInputsTyped& setInput(const std::string& name, U in) - { - m_priv->blobs.emplace(std::piecewise_construct, - std::forward_as_tuple(name), - std::forward_as_tuple(in)); - return *this; - } - - using StorageT = cv::util::variant; - StorageT& operator[](const std::string& name) { - return m_priv->blobs[name]; - } - - using Map = std::unordered_map; - const Map& getBlobs() const { - return m_priv->blobs; - } - -private: - struct Priv - { - std::unordered_map blobs; - }; - - std::shared_ptr m_priv; -}; - -template -std::shared_ptr makeCall(const std::string &tag, - std::vector &&args, - std::vector &&names, - cv::GKinds &&kinds) { - auto call = std::make_shared(GKernel{ - InferT::id(), - tag, - InferT::getOutMeta, - {}, // outShape will be filled later - std::move(kinds), - {}, // outCtors will be filled later - {}, // outKinds will be filled later - }); - - call->setArgs(std::move(args)); - call->params() = cv::detail::InOutInfo{std::move(names), {}}; - - return call; -} - -} // namespace detail - -// TODO: maybe tuple_wrap_helper from util.hpp may help with this. -// Multiple-return-value network definition (specialized base class) -template -class GNetworkType(Args...)> > -{ -public: - using InArgs = std::tuple; - using OutArgs = std::tuple; - - using Result = OutArgs; - using API = std::function; - - using ResultL = std::tuple< cv::GArray... >; -}; - -// Single-return-value network definition (specialized base class) -template -class GNetworkType > -{ -public: - using InArgs = std::tuple; - using OutArgs = std::tuple; - - using Result = R; - using API = std::function; - - using ResultL = cv::GArray; -}; - -// InferAPI: Accepts either GMat or GFrame for very individual network's input -template -struct InferAPI { - using type = typename std::enable_if - < detail::valid_infer_types::value - && std::tuple_size::value == sizeof...(Ts) - , std::function - >::type; -}; - -// InferAPIRoi: Accepts a rectangle and either GMat or GFrame -template -struct InferAPIRoi { - using type = typename std::enable_if - < detail::valid_infer_types::value - && std::tuple_size::value == 1u - , std::function, T)> - >::type; -}; - -// InferAPIList: Accepts a list of rectangles and list of GMat/GFrames; -// crops every input. -template -struct InferAPIList { - using type = typename std::enable_if - < detail::valid_infer_types::value - && std::tuple_size::value == sizeof...(Ts) - , std::function, Ts...)> - >::type; -}; - -// APIList2 is also template to allow different calling options -// (GArray vs GArray per input) -template -struct InferAPIList2 { - using type = typename std::enable_if - < detail::valid_infer_types::value && - cv::detail::valid_infer2_types< typename Net::InArgs - , std::tuple >::value, - std::function...)> - >::type; -}; - -// Base "Infer" kernel. Note - for whatever network, kernel ID -// is always the same. Different inference calls are distinguished by -// network _tag_ (an extra field in GCall) -// -// getOutMeta is a stub callback collected by G-API kernel subsystem -// automatically. This is a rare case when this callback is defined by -// a particular backend, not by a network itself. -struct GInferBase { - static constexpr const char * id() { - return "org.opencv.dnn.infer"; // Universal stub - } - static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) { - return GMetaArgs{}; // One more universal stub - } -}; - -// Base "InferROI" kernel. -// All notes from "Infer" kernel apply here as well. -struct GInferROIBase { - static constexpr const char * id() { - return "org.opencv.dnn.infer-roi"; // Universal stub - } - static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) { - return GMetaArgs{}; // One more universal stub - } -}; - -// Base "Infer list" kernel. -// All notes from "Infer" kernel apply here as well. -struct GInferListBase { - static constexpr const char * id() { - return "org.opencv.dnn.infer-roi-list-1"; // Universal stub - } - static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) { - return GMetaArgs{}; // One more universal stub - } -}; - -// Base "Infer list 2" kernel. -// All notes from "Infer" kernel apply here as well. -struct GInferList2Base { - static constexpr const char * id() { - return "org.opencv.dnn.infer-roi-list-2"; // Universal stub - } - static GMetaArgs getOutMeta(const GMetaArgs &, const GArgs &) { - return GMetaArgs{}; // One more universal stub - } -}; - -// A generic inference kernel. API (::on()) is fully defined by the Net -// template parameter. -// Acts as a regular kernel in graph (via KernelTypeMedium). -template -struct GInfer final - : public GInferBase - , public detail::KernelTypeMedium< GInfer - , typename InferAPI::type > { - using GInferBase::getOutMeta; // FIXME: name lookup conflict workaround? - - static constexpr const char* tag() { return Net::tag(); } -}; - -// A specific roi-inference kernel. API (::on()) is fixed here and -// verified against Net. -template -struct GInferROI final - : public GInferROIBase - , public detail::KernelTypeMedium< GInferROI - , typename InferAPIRoi::type > { - using GInferROIBase::getOutMeta; // FIXME: name lookup conflict workaround? - - static constexpr const char* tag() { return Net::tag(); } -}; - - -// A generic roi-list inference kernel. API (::on()) is derived from -// the Net template parameter (see more in infer<> overload). -template -struct GInferList final - : public GInferListBase - , public detail::KernelTypeMedium< GInferList - , typename InferAPIList::type > { - using GInferListBase::getOutMeta; // FIXME: name lookup conflict workaround? - - static constexpr const char* tag() { return Net::tag(); } -}; - -// An even more generic roi-list inference kernel. API (::on()) is -// derived from the Net template parameter (see more in infer<> -// overload). -// Takes an extra variadic template list to reflect how this network -// was called (with Rects or GMats as array parameters) -template -struct GInferList2 final - : public GInferList2Base - , public detail::KernelTypeMedium< GInferList2 - , typename InferAPIList2::type > { - using GInferList2Base::getOutMeta; // FIXME: name lookup conflict workaround? - - static constexpr const char* tag() { return Net::tag(); } -}; - -/** - * @brief G-API object used to collect network inputs - */ -using GInferInputs = cv::detail::GInferInputsTyped; - -/** - * @brief G-API object used to collect the list of network inputs - */ -using GInferListInputs = cv::detail::GInferInputsTyped, cv::GArray>; - -/** - * @brief G-API object used to collect network outputs - */ -using GInferOutputs = cv::detail::GInferOutputsTyped; - -/** - * @brief G-API object used to collect the list of network outputs - */ -using GInferListOutputs = cv::detail::GInferOutputsTyped>; - -namespace detail { -void inline unpackBlobs(const cv::GInferInputs::Map& blobs, - std::vector& args, - std::vector& names, - cv::GKinds& kinds) -{ - for (auto&& p : blobs) { - names.emplace_back(p.first); - switch (p.second.index()) { - case cv::GInferInputs::StorageT::index_of(): - args.emplace_back(cv::util::get(p.second)); - kinds.emplace_back(cv::detail::OpaqueKind::CV_MAT); - break; - case cv::GInferInputs::StorageT::index_of(): - args.emplace_back(cv::util::get(p.second)); - kinds.emplace_back(cv::detail::OpaqueKind::CV_UNKNOWN); - break; - default: - GAPI_Error("InternalError"); - } - } -} - -template -struct InferROITraits; - -template <> -struct InferROITraits -{ - using outType = cv::GInferOutputs; - using inType = cv::GOpaque; -}; - -template <> -struct InferROITraits -{ - using outType = cv::GInferListOutputs; - using inType = cv::GArray; -}; - -template -typename InferROITraits::outType -inferGenericROI(const std::string& tag, - const typename InferROITraits::inType& in, - const cv::GInferInputs& inputs) -{ - std::vector args; - std::vector names; - cv::GKinds kinds; - - args.emplace_back(in); - kinds.emplace_back(cv::detail::OpaqueKind::CV_RECT); - - unpackBlobs(inputs.getBlobs(), args, names, kinds); - - auto call = cv::detail::makeCall(tag, - std::move(args), - std::move(names), - std::move(kinds)); - - return {std::move(call)}; -} - -} // namespace detail -} // namespace cv - -// FIXME: Probably the signature makes a function/tuple/function round-trip -#define G_API_NET(Class, API, Tag) \ - struct Class final: public cv::GNetworkType { \ - static constexpr const char * tag() { return Tag; } \ - } - -namespace cv { -namespace gapi { - -/** @brief Calculates response for the specified network (template - * parameter) for the specified region in the source image. - * Currently expects a single-input network only. - * - * @tparam A network type defined with G_API_NET() macro. - * @param in input image where to take ROI from. - * @param roi an object describing the region of interest - * in the source image. May be calculated in the same graph dynamically. - * @return an object of return type as defined in G_API_NET(). - * If a network has multiple return values (defined with a tuple), a tuple of - * objects of appropriate type is returned. - * @sa G_API_NET() - */ -template -typename Net::Result infer(cv::GOpaque roi, T in) { - return GInferROI::on(roi, in); -} - -/** @brief Calculates responses for the specified network (template - * parameter) for every region in the source image. - * - * @tparam A network type defined with G_API_NET() macro. - * @param roi a list of rectangles describing regions of interest - * in the source image. Usually an output of object detector or tracker. - * @param args network's input parameters as specified in G_API_NET() macro. - * NOTE: verified to work reliably with 1-input topologies only. - * @return a list of objects of return type as defined in G_API_NET(). - * If a network has multiple return values (defined with a tuple), a tuple of - * GArray<> objects is returned with the appropriate types inside. - * @sa G_API_NET() - */ -template -typename Net::ResultL infer(cv::GArray roi, Args&&... args) { - return GInferList::on(roi, std::forward(args)...); -} - -/** @brief Calculates responses for the specified network (template - * parameter) for every region in the source image, extended version. - * - * @tparam A network type defined with G_API_NET() macro. - * @param image A source image containing regions of interest - * @param args GArray<> objects of cv::Rect or cv::GMat, one per every - * network input: - * - If a cv::GArray is passed, the appropriate - * regions are taken from `image` and preprocessed to this particular - * network input; - * - If a cv::GArray is passed, the underlying data traited - * as tensor (no automatic preprocessing happen). - * @return a list of objects of return type as defined in G_API_NET(). - * If a network has multiple return values (defined with a tuple), a tuple of - * GArray<> objects is returned with the appropriate types inside. - * @sa G_API_NET() - */ - -template -typename Net::ResultL infer2(T image, cv::GArray... args) { - // FIXME: Declared as "2" because in the current form it steals - // overloads from the regular infer - return GInferList2::on(image, args...); -} - -/** - * @brief Calculates response for the specified network (template - * parameter) given the input data. - * - * @tparam A network type defined with G_API_NET() macro. - * @param args network's input parameters as specified in G_API_NET() macro. - * @return an object of return type as defined in G_API_NET(). - * If a network has multiple return values (defined with a tuple), a tuple of - * objects of appropriate type is returned. - * @sa G_API_NET() - */ -template -typename Net::Result infer(Args&&... args) { - return GInfer::on(std::forward(args)...); -} - -/** - * @brief Generic network type: input and output layers are configured dynamically at runtime - * - * Unlike the network types defined with G_API_NET macro, this one - * doesn't fix number of network inputs and outputs at the compilation stage - * thus providing user with an opportunity to program them in runtime. - */ -struct Generic { }; - -/** - * @brief Calculates response for generic network - * - * @param tag a network tag - * @param inputs networks's inputs - * @return a GInferOutputs - */ -template cv::GInferOutputs -infer(const std::string& tag, const cv::GInferInputs& inputs) -{ - std::vector args; - std::vector names; - cv::GKinds kinds; - - cv::detail::unpackBlobs(inputs.getBlobs(), args, names, kinds); - - auto call = cv::detail::makeCall(tag, - std::move(args), - std::move(names), - std::move(kinds)); - - return cv::GInferOutputs{std::move(call)}; -} - -/** @brief Calculates response for the generic network - * for the specified region in the source image. - * Currently expects a single-input network only. - * - * @param tag a network tag - * @param roi a an object describing the region of interest - * in the source image. May be calculated in the same graph dynamically. - * @param inputs networks's inputs - * @return a cv::GInferOutputs - */ -template cv::GInferOutputs -infer(const std::string& tag, const cv::GOpaque& roi, const cv::GInferInputs& inputs) -{ - return cv::detail::inferGenericROI(tag, roi, inputs); -} - -/** @brief Calculates responses for the specified network - * for every region in the source image. - * - * @param tag a network tag - * @param rois a list of rectangles describing regions of interest - * in the source image. Usually an output of object detector or tracker. - * @param inputs networks's inputs - * @return a cv::GInferListOutputs - */ -template cv::GInferListOutputs -infer(const std::string& tag, const cv::GArray& rois, const cv::GInferInputs& inputs) -{ - return cv::detail::inferGenericROI(tag, rois, inputs); -} - -/** @brief Calculates responses for the specified network - * for every region in the source image, extended version. - * - * @param tag a network tag - * @param in a source image containing regions of interest. - * @param inputs networks's inputs - * @return a cv::GInferListOutputs - */ -template -typename std::enable_if::value, cv::GInferListOutputs>::type -infer2(const std::string& tag, - const Input& in, - const cv::GInferListInputs& inputs) -{ - std::vector args; - std::vector names; - cv::GKinds kinds; - - args.emplace_back(in); - auto k = cv::detail::GOpaqueTraits::kind; - kinds.emplace_back(k); - - for (auto&& p : inputs.getBlobs()) { - names.emplace_back(p.first); - switch (p.second.index()) { - case cv::GInferListInputs::StorageT::index_of>(): - args.emplace_back(cv::util::get>(p.second)); - kinds.emplace_back(cv::detail::OpaqueKind::CV_MAT); - break; - case cv::GInferListInputs::StorageT::index_of>(): - args.emplace_back(cv::util::get>(p.second)); - kinds.emplace_back(cv::detail::OpaqueKind::CV_RECT); - break; - default: - GAPI_Error("InternalError"); - } - } - - auto call = cv::detail::makeCall(tag, - std::move(args), - std::move(names), - std::move(kinds)); - - return cv::GInferListOutputs{std::move(call)}; -} - -} // namespace gapi -} // namespace cv - -#endif // GAPI_STANDALONE - -namespace cv { -namespace gapi { - -// Note: the below code _is_ part of STANDALONE build, -// just to make our compiler code compileable. - -// A type-erased form of network parameters. -// Similar to how a type-erased GKernel is represented and used. -/// @private -struct GAPI_EXPORTS_W_SIMPLE GNetParam { - std::string tag; // FIXME: const? - GBackend backend; // Specifies the execution model - util::any params; // Backend-interpreted parameter structure -}; - -/** \addtogroup gapi_compile_args - * @{ - */ -/** - * @brief A container class for network configurations. Similar to - * GKernelPackage. Use cv::gapi::networks() to construct this object. - * - * @sa cv::gapi::networks - */ -struct GAPI_EXPORTS_W_SIMPLE GNetPackage { - GAPI_WRAP GNetPackage() = default; - GAPI_WRAP explicit GNetPackage(std::vector nets); - explicit GNetPackage(std::initializer_list ii); - std::vector backends() const; - std::vector networks; -}; -/** @} gapi_compile_args */ -} // namespace gapi - -namespace detail { -template -gapi::GNetParam strip(T&& t) { - return gapi::GNetParam { t.tag() - , t.backend() - , t.params() - }; -} - -template<> struct CompileArgTag { - static const char* tag() { return "gapi.net_package"; } -}; - -} // namespace cv::detail - -namespace gapi { -template -cv::gapi::GNetPackage networks(Args&&... args) { - return cv::gapi::GNetPackage({ cv::detail::strip(args)... }); -} - -inline cv::gapi::GNetPackage& operator += ( cv::gapi::GNetPackage& lhs, - const cv::gapi::GNetPackage& rhs) { - lhs.networks.reserve(lhs.networks.size() + rhs.networks.size()); - lhs.networks.insert(lhs.networks.end(), rhs.networks.begin(), rhs.networks.end()); - return lhs; -} - -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_INFER_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/bindings_ie.hpp b/modules/gapi/include/opencv2/gapi/infer/bindings_ie.hpp deleted file mode 100644 index 94272dea55..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/bindings_ie.hpp +++ /dev/null @@ -1,70 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_INFER_BINDINGS_IE_HPP -#define OPENCV_GAPI_INFER_BINDINGS_IE_HPP - -#include -#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS -#include // GKernelPackage -#include // Params - -#include - -namespace cv { -namespace gapi { -namespace ie { - -// NB: Used by python wrapper -// This class can be marked as SIMPLE, because it's implemented as pimpl -class GAPI_EXPORTS_W_SIMPLE PyParams { -public: - GAPI_WRAP - PyParams() = default; - - GAPI_WRAP - PyParams(const std::string &tag, - const std::string &model, - const std::string &weights, - const std::string &device); - - GAPI_WRAP - PyParams(const std::string &tag, - const std::string &model, - const std::string &device); - - GAPI_WRAP - PyParams& constInput(const std::string &layer_name, - const cv::Mat &data, - TraitAs hint = TraitAs::TENSOR); - - GAPI_WRAP - PyParams& cfgNumRequests(size_t nireq); - - GAPI_WRAP - PyParams& cfgBatchSize(const size_t size); - - GBackend backend() const; - std::string tag() const; - cv::util::any params() const; - -private: - std::shared_ptr> m_priv; -}; - -GAPI_EXPORTS_W PyParams params(const std::string &tag, - const std::string &model, - const std::string &weights, - const std::string &device); - -GAPI_EXPORTS_W PyParams params(const std::string &tag, - const std::string &model, - const std::string &device); -} // namespace ie -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_INFER_BINDINGS_IE_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/bindings_onnx.hpp b/modules/gapi/include/opencv2/gapi/infer/bindings_onnx.hpp deleted file mode 100644 index f7bb259924..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/bindings_onnx.hpp +++ /dev/null @@ -1,74 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level -// directory of this distribution and at http://opencv.org/license.html. - -#ifndef OPENCV_GAPI_INFER_BINDINGS_ONNX_HPP -#define OPENCV_GAPI_INFER_BINDINGS_ONNX_HPP - -#include // GKernelPackage -#include // Params -#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS -#include - -#include - -namespace cv { -namespace gapi { -namespace onnx { - -// NB: Used by python wrapper -// This class can be marked as SIMPLE, because it's implemented as pimpl -class GAPI_EXPORTS_W_SIMPLE PyParams { -public: - GAPI_WRAP - PyParams() = default; - - GAPI_WRAP - PyParams(const std::string& tag, const std::string& model_path); - - GAPI_WRAP - PyParams& cfgMeanStd(const std::string &layer_name, - const cv::Scalar &m, - const cv::Scalar &s); - GAPI_WRAP - PyParams& cfgNormalize(const std::string &layer_name, bool flag); - - GAPI_WRAP - PyParams& cfgAddExecutionProvider(ep::OpenVINO ep); - - GAPI_WRAP - PyParams& cfgAddExecutionProvider(ep::DirectML ep); - - GAPI_WRAP - PyParams& cfgAddExecutionProvider(ep::CoreML ep); - - GAPI_WRAP - PyParams& cfgAddExecutionProvider(ep::CUDA ep); - - GAPI_WRAP - PyParams& cfgAddExecutionProvider(ep::TensorRT ep); - - GAPI_WRAP - PyParams& cfgDisableMemPattern(); - - GAPI_WRAP - PyParams& cfgSessionOptions(const std::map& options); - - GAPI_WRAP - PyParams& cfgOptLevel(const int opt_level); - - GBackend backend() const; - std::string tag() const; - cv::util::any params() const; - -private: - std::shared_ptr> m_priv; -}; - -GAPI_EXPORTS_W PyParams params(const std::string& tag, const std::string& model_path); - -} // namespace onnx -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_INFER_BINDINGS_ONNX_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/bindings_ov.hpp b/modules/gapi/include/opencv2/gapi/infer/bindings_ov.hpp deleted file mode 100644 index 08f5c83a3f..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/bindings_ov.hpp +++ /dev/null @@ -1,128 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2023 Intel Corporation - -#ifndef OPENCV_GAPI_INFER_BINDINGS_OV_HPP -#define OPENCV_GAPI_INFER_BINDINGS_OV_HPP - -#include -#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS -#include // GKernelPackage -#include // Params - -#include - -namespace cv { -namespace gapi { -namespace ov { - -// NB: Used by python wrapper -// This class can be marked as SIMPLE, because it's implemented as pimpl -class GAPI_EXPORTS_W_SIMPLE PyParams { -public: - GAPI_WRAP - PyParams() = default; - - GAPI_WRAP - PyParams(const std::string &tag, - const std::string &model_path, - const std::string &bin_path, - const std::string &device); - - GAPI_WRAP - PyParams(const std::string &tag, - const std::string &blob_path, - const std::string &device); - - GAPI_WRAP - PyParams& cfgPluginConfig( - const std::map &config); - - GAPI_WRAP - PyParams& cfgInputTensorLayout(std::string tensor_layout); - - GAPI_WRAP - PyParams& cfgInputTensorLayout( - std::map layout_map); - - GAPI_WRAP - PyParams& cfgInputModelLayout(std::string tensor_layout); - - GAPI_WRAP - PyParams& cfgInputModelLayout( - std::map layout_map); - - GAPI_WRAP - PyParams& cfgOutputTensorLayout(std::string tensor_layout); - - GAPI_WRAP - PyParams& cfgOutputTensorLayout( - std::map layout_map); - - GAPI_WRAP - PyParams& cfgOutputModelLayout(std::string tensor_layout); - - GAPI_WRAP - PyParams& cfgOutputModelLayout( - std::map layout_map); - - GAPI_WRAP - PyParams& cfgOutputTensorPrecision(int precision); - - GAPI_WRAP - PyParams& cfgOutputTensorPrecision( - std::map precision_map); - - GAPI_WRAP - PyParams& cfgReshape(std::vector new_shape); - - GAPI_WRAP - PyParams& cfgReshape( - std::map> new_shape_map); - - GAPI_WRAP - PyParams& cfgNumRequests(const size_t nireq); - - GAPI_WRAP - PyParams& cfgMean(std::vector mean_values); - - GAPI_WRAP - PyParams& cfgMean( - std::map> mean_map); - - GAPI_WRAP - PyParams& cfgScale(std::vector scale_values); - - GAPI_WRAP - PyParams& cfgScale( - std::map> scale_map); - - GAPI_WRAP - PyParams& cfgResize(int interpolation); - - GAPI_WRAP - PyParams& cfgResize(std::map interpolation); - - GBackend backend() const; - std::string tag() const; - cv::util::any params() const; - -private: - std::shared_ptr> m_priv; -}; - -GAPI_EXPORTS_W PyParams params(const std::string &tag, - const std::string &model_path, - const std::string &weights, - const std::string &device); - -GAPI_EXPORTS_W PyParams params(const std::string &tag, - const std::string &bin_path, - const std::string &device); -} // namespace ov -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_INFER_BINDINGS_OV_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/ie.hpp b/modules/gapi/include/opencv2/gapi/infer/ie.hpp deleted file mode 100644 index 9f9518d0b8..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/ie.hpp +++ /dev/null @@ -1,711 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019-2023 Intel Corporation - -#ifndef OPENCV_GAPI_INFER_IE_HPP -#define OPENCV_GAPI_INFER_IE_HPP - -#include -#include -#include -#include -#include // tuple, tuple_size -#include - -#include -#include - -#include // GAPI_EXPORTS -#include // GKernelPackage -#include // Generic -#include // Preproc Dev & Ctx - -namespace cv { -namespace gapi { -// FIXME: introduce a new sub-namespace for NN? - -/** - * @brief This namespace contains G-API OpenVINO backend functions, - * structures, and symbols. - */ -namespace ie { - -GAPI_EXPORTS cv::gapi::GBackend backend(); - -/** - * Specifies how G-API and IE should trait input data - * - * In OpenCV, the same cv::Mat is used to represent both - * image and tensor data. Sometimes those are hardly distinguishable, - * so this extra parameter is used to give G-API a hint. - * - * This hint controls how G-API reinterprets the data when converting - * it to IE Blob format (and which layout/etc is assigned to this data). - */ -enum class TraitAs: int -{ - TENSOR, //!< G-API traits an associated cv::Mat as a raw tensor and passes dimensions as-is - IMAGE //!< G-API traits an associated cv::Mat as an image so creates an "image" blob (NCHW/NHWC, etc) -}; - -using IEConfig = std::map; - -enum InferMode {Sync, Async}; - -namespace detail { - -template -using AttrMap = std::map; -// NB: This type is used to hold in/out layers -// attributes such as precision, layout, shape etc. -// -// User can provide attributes either: -// 1. cv::util::monostate - No value specified explicitly. -// 2. Attr - value specified explicitly that should be broadcasted to all layers. -// 3. AttrMap[str->T] - map specifies value for particular layer. -template -using LayerVariantAttr = cv::util::variant< cv::util::monostate - , AttrMap - , Attr>; - -struct ParamDesc { - std::string model_path; - std::string weights_path; - std::string device_id; - - std::vector input_names; - std::vector output_names; - - using ConstInput = std::pair; - std::unordered_map const_inputs; - - std::size_t num_in; - std::size_t num_out; - - enum class Kind {Load, Import}; - Kind kind; - bool is_generic; - IEConfig config; - - std::map> reshape_table; - std::unordered_set layer_names_to_reshape; - - // NB: Number of asyncrhonious infer requests - size_t nireq; - - // NB: An optional config to setup RemoteContext for IE - cv::util::any context_config; - - // NB: batch_size can't be equal to 1 by default, because some of models - // have 2D (Layout::NC) input and if the first dimension not equal to 1 - // net.setBatchSize(1) will overwrite it. - cv::optional batch_size; - - cv::optional vpl_preproc_device; - cv::optional vpl_preproc_ctx; - - InferMode mode; - - using PrecisionT = int; - using PrecisionMapT = std::unordered_map; - // NB: This parameter can contain: - // 1. cv::util::monostate - Don't specify precision, but use default from IR/Blob. - // 2. PrecisionT (CV_8U, CV_32F, ...) - Specifies precision for all output layers. - // 3. PrecisionMapT ({{"layer0", CV_32F}, {"layer1", CV_16F}} - Specifies precision for certain output layer. - // cv::util::monostate is default value that means precision wasn't specified. - using PrecisionVariantT = cv::util::variant; - - PrecisionVariantT output_precision; - LayerVariantAttr input_layout; - LayerVariantAttr output_layout; - LayerVariantAttr interpolation; -}; -} // namespace detail - -// FIXME: this is probably a shared (reusable) thing -template -struct PortCfg { - using In = std::array - < std::string - , std::tuple_size::value >; - using Out = std::array - < std::string - , std::tuple_size::value >; -}; - -/** - * @brief This structure provides functions - * that fill inference parameters for "OpenVINO Toolkit" model. - */ -template class Params { -public: - /** @brief Class constructor. - - Constructs Params based on model information and specifies default values for other - inference description parameters. Model is loaded and compiled using "OpenVINO Toolkit". - - @param model Path to topology IR (.xml file). - @param weights Path to weights (.bin file). - @param device target device to use. - */ - Params(const std::string &model, - const std::string &weights, - const std::string &device) - : desc{ model, weights, device, {}, {}, {} - , std::tuple_size::value // num_in - , std::tuple_size::value // num_out - , detail::ParamDesc::Kind::Load - , false - , {} - , {} - , {} - , 1u - , {} - , {} - , {} - , {} - , InferMode::Async - , {} - , {} - , {} - , {} } { - } - - /** @overload - Use this constructor to work with pre-compiled network. - Model is imported from a pre-compiled blob. - - @param model Path to model. - @param device target device to use. - */ - Params(const std::string &model, - const std::string &device) - : desc{ model, {}, device, {}, {}, {} - , std::tuple_size::value // num_in - , std::tuple_size::value // num_out - , detail::ParamDesc::Kind::Import - , false - , {} - , {} - , {} - , 1u - , {} - , {} - , {} - , {} - , InferMode::Async - , {} - , {} - , {} - , {} } { - } - - /** @brief Specifies sequence of network input layers names for inference. - - The function is used to associate cv::gapi::infer<> inputs with the model inputs. - Number of names has to match the number of network inputs as defined in G_API_NET(). - In case a network has only single input layer, there is no need to specify name manually. - - @param layer_names std::array where N is the number of inputs - as defined in the @ref G_API_NET. Contains names of input layers. - @return reference to this parameter structure. - */ - Params& cfgInputLayers(const typename PortCfg::In &layer_names) { - desc.input_names.clear(); - desc.input_names.reserve(layer_names.size()); - std::copy(layer_names.begin(), layer_names.end(), - std::back_inserter(desc.input_names)); - return *this; - } - - /** @brief Specifies sequence of network output layers names for inference. - - The function is used to associate cv::gapi::infer<> outputs with the model outputs. - Number of names has to match the number of network outputs as defined in G_API_NET(). - In case a network has only single output layer, there is no need to specify name manually. - - @param layer_names std::array where N is the number of outputs - as defined in the @ref G_API_NET. Contains names of output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputLayers(const typename PortCfg::Out &layer_names) { - desc.output_names.clear(); - desc.output_names.reserve(layer_names.size()); - std::copy(layer_names.begin(), layer_names.end(), - std::back_inserter(desc.output_names)); - return *this; - } - - /** @brief Specifies a constant input. - - The function is used to set a constant input. This input has to be - a preprocessed tensor if its type is TENSOR. Need to provide name of the - network layer which will receive provided data. - - @param layer_name Name of network layer. - @param data cv::Mat that contains data which will be associated with network layer. - @param hint Input type @sa cv::gapi::ie::TraitAs. - @return reference to this parameter structure. - */ - Params& constInput(const std::string &layer_name, - const cv::Mat &data, - TraitAs hint = TraitAs::TENSOR) { - desc.const_inputs[layer_name] = {data, hint}; - return *this; - } - - /** @brief Specifies OpenVINO plugin configuration. - - The function is used to set configuration for OpenVINO plugin. Some parameters - can be different for each plugin. Please follow https://docs.openvinotoolkit.org/latest/index.html - to check information about specific plugin. - - @param cfg Map of pairs: (config parameter name, config parameter value). - @return reference to this parameter structure. - */ - Params& pluginConfig(const IEConfig& cfg) { - desc.config = cfg; - return *this; - } - - /** @overload - Function with a rvalue parameter. - - @param cfg rvalue map of pairs: (config parameter name, config parameter value). - @return reference to this parameter structure. - */ - Params& pluginConfig(IEConfig&& cfg) { - desc.config = std::move(cfg); - return *this; - } - - /** @brief Specifies configuration for RemoteContext in InferenceEngine. - - When RemoteContext is configured the backend imports the networks using the context. - It also expects cv::MediaFrames to be actually remote, to operate with blobs via the context. - - @param ctx_cfg cv::util::any value which holds InferenceEngine::ParamMap. - @return reference to this parameter structure. - */ - Params& cfgContextParams(const cv::util::any& ctx_cfg) { - desc.context_config = ctx_cfg; - return *this; - } - - /** @overload - Function with an rvalue parameter. - - @param ctx_cfg cv::util::any value which holds InferenceEngine::ParamMap. - @return reference to this parameter structure. - */ - Params& cfgContextParams(cv::util::any&& ctx_cfg) { - desc.context_config = std::move(ctx_cfg); - return *this; - } - - /** @brief Specifies number of asynchronous inference requests. - - @param nireq Number of inference asynchronous requests. - @return reference to this parameter structure. - */ - Params& cfgNumRequests(size_t nireq) { - GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!"); - desc.nireq = nireq; - return *this; - } - - /** @brief Specifies new input shapes for the network inputs. - - The function is used to specify new input shapes for the network inputs. - Follow https://docs.openvinotoolkit.org/latest/classInferenceEngine_1_1networkNetwork.html - for additional information. - - @param reshape_table Map of pairs: name of corresponding data and its dimension. - @return reference to this parameter structure. - */ - Params& cfgInputReshape(const std::map>& reshape_table) { - desc.reshape_table = reshape_table; - return *this; - } - - /** @overload */ - Params& cfgInputReshape(std::map>&& reshape_table) { - desc.reshape_table = std::move(reshape_table); - return *this; - } - - /** @overload - - @param layer_name Name of layer. - @param layer_dims New dimensions for this layer. - @return reference to this parameter structure. - */ - Params& cfgInputReshape(const std::string& layer_name, const std::vector& layer_dims) { - desc.reshape_table.emplace(layer_name, layer_dims); - return *this; - } - - /** @overload */ - Params& cfgInputReshape(std::string&& layer_name, std::vector&& layer_dims) { - desc.reshape_table.emplace(layer_name, layer_dims); - return *this; - } - - /** @overload - - @param layer_names set of names of network layers that will be used for network reshape. - @return reference to this parameter structure. - */ - Params& cfgInputReshape(const std::unordered_set& layer_names) { - desc.layer_names_to_reshape = layer_names; - return *this; - } - - /** @overload - - @param layer_names rvalue set of the selected layers will be reshaped automatically - its input image size. - @return reference to this parameter structure. - */ - Params& cfgInputReshape(std::unordered_set&& layer_names) { - desc.layer_names_to_reshape = std::move(layer_names); - return *this; - } - - /** @brief Specifies the inference batch size. - - The function is used to specify inference batch size. - Follow https://docs.openvinotoolkit.org/latest/classInferenceEngine_1_1CNNNetwork.html#a8e9d19270a48aab50cb5b1c43eecb8e9 for additional information - - @param size batch size which will be used. - @return reference to this parameter structure. - */ - Params& cfgBatchSize(const size_t size) { - desc.batch_size = cv::util::make_optional(size); - return *this; - } - - Params& cfgPreprocessingParams(const cv::gapi::wip::onevpl::Device &device, - const cv::gapi::wip::onevpl::Context &ctx) { - desc.vpl_preproc_device = cv::util::make_optional(device); - desc.vpl_preproc_ctx = cv::util::make_optional(ctx); - return *this; - } - - /** @brief Specifies which api will be used to run inference. - - The function is used to specify mode for OpenVINO inference. - OpenVINO has two options to run inference: - 1. Asynchronous (using StartAsync: https://docs.openvino.ai/latest/classInferenceEngine_1_1InferRequest.html#doxid-class-inference-engine-1-1-infer-request-1a405293e8423d82a5b45f642a3bef0d24) - 2. Synchronous (using Infer: https://docs.openvino.ai/latest/classInferenceEngine_1_1InferRequest.html#doxid-class-inference-engine-1-1-infer-request-1a3391ce30894abde730523e9ca9371ce8) - By default asynchronous mode is used. - - @param mode Inference mode which will be used. - @return reference to this parameter structure. - */ - Params& cfgInferMode(InferMode mode) { - desc.mode = mode; - return *this; - } - - /** @brief Specifies the output precision for model. - - The function is used to set an output precision for model. - - @param precision Precision in OpenCV format (CV_8U, CV_32F, ...) - will be applied to all output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputPrecision(detail::ParamDesc::PrecisionT precision) { - desc.output_precision = precision; - return *this; - } - - /** @overload - - @param precision_map Map of pairs: name of corresponding output layer - and its precision in OpenCV format (CV_8U, CV_32F, ...) - @return reference to this parameter structure. - */ - Params& - cfgOutputPrecision(detail::ParamDesc::PrecisionMapT precision_map) { - desc.output_precision = precision_map; - return *this; - } - - /** @brief Specifies the input layout for model. - - The function is used to set an input layout for model. - - @param layout Layout in string representation ("NCHW", "NHWC", etc) - will be applied to all input layers. - @return reference to this parameter structure. - */ - Params& cfgInputLayout(std::string layout) { - desc.input_layout = std::move(layout); - return *this; - } - - /** @overload - - @param layout_map Map of pairs: name of corresponding input layer - and its layout in string representation ("NCHW", "NHWC", etc) - @return reference to this parameter structure. - */ - Params& - cfgInputLayout(detail::AttrMap layout_map) { - desc.input_layout = std::move(layout_map); - return *this; - } - - /** @brief Specifies the output layout for model. - - The function is used to set an output layout for model. - - @param layout Layout in string representation ("NCHW", "NHWC", etc) - will be applied to all output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputLayout(std::string layout) { - desc.output_layout = std::move(layout); - return *this; - } - - /** @overload - - @param layout_map Map of pairs: name of corresponding output layer - and its layout in string representation ("NCHW", "NHWC", etc) - @return reference to this parameter structure. - */ - Params& - cfgOutputLayout(detail::AttrMap layout_map) { - desc.output_layout = std::move(layout_map); - return *this; - } - - /** @brief Specifies resize interpolation algorithm. - * - The function is used to configure resize preprocessing for input layer. - - @param interpolation Resize interpolation algorithm. - Supported algorithms: #INTER_LINEAR, #INTER_AREA. - @return reference to this parameter structure. - */ - Params& cfgResize(int interpolation) { - desc.interpolation = interpolation; - return *this; - } - - /** @overload - - @param interpolation Map of pairs: name of corresponding input layer - and its resize algorithm. - @return reference to this parameter structure. - */ - Params& cfgResize(detail::AttrMap interpolation) { - desc.interpolation = std::move(interpolation); - return *this; - } - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::ie::backend(); } - std::string tag() const { return Net::tag(); } - cv::util::any params() const { return { desc }; } - // END(G-API's network parametrization API) - -protected: - detail::ParamDesc desc; -}; - -/* -* @brief This structure provides functions for generic network type that -* fill inference parameters. -* @see struct Generic -*/ -template<> -class Params { -public: - /** @brief Class constructor. - - Constructs Params based on model information and sets default values for other - inference description parameters. Model is loaded and compiled using OpenVINO Toolkit. - - @param tag string tag of the network for which these parameters are intended. - @param model path to topology IR (.xml file). - @param weights path to weights (.bin file). - @param device target device to use. - */ - Params(const std::string &tag, - const std::string &model, - const std::string &weights, - const std::string &device) - : desc{ model, weights, device, {}, {}, {}, 0u, 0u, - detail::ParamDesc::Kind::Load, true, {}, {}, {}, 1u, - {}, {}, {}, {}, InferMode::Async, {}, {}, {}, {} }, - m_tag(tag) { - } - - /** @overload - - This constructor for pre-compiled networks. Model is imported from pre-compiled - blob. - - @param tag string tag of the network for which these parameters are intended. - @param model path to model. - @param device target device to use. - */ - Params(const std::string &tag, - const std::string &model, - const std::string &device) - : desc{ model, {}, device, {}, {}, {}, 0u, 0u, - detail::ParamDesc::Kind::Import, true, {}, {}, {}, 1u, - {}, {}, {}, {}, InferMode::Async, {}, {}, {}, {} }, - m_tag(tag) { - } - - /** @see ie::Params::pluginConfig. */ - Params& pluginConfig(const IEConfig& cfg) { - desc.config = cfg; - return *this; - } - - /** @overload */ - Params& pluginConfig(IEConfig&& cfg) { - desc.config = std::move(cfg); - return *this; - } - - /** @see ie::Params::constInput. */ - Params& constInput(const std::string &layer_name, - const cv::Mat &data, - TraitAs hint = TraitAs::TENSOR) { - desc.const_inputs[layer_name] = {data, hint}; - return *this; - } - - /** @see ie::Params::cfgNumRequests. */ - Params& cfgNumRequests(size_t nireq) { - GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!"); - desc.nireq = nireq; - return *this; - } - - /** @see ie::Params::cfgInputReshape */ - Params& cfgInputReshape(const std::map>&reshape_table) { - desc.reshape_table = reshape_table; - return *this; - } - - /** @overload */ - Params& cfgInputReshape(std::map> && reshape_table) { - desc.reshape_table = std::move(reshape_table); - return *this; - } - - /** @overload */ - Params& cfgInputReshape(std::string && layer_name, std::vector && layer_dims) { - desc.reshape_table.emplace(layer_name, layer_dims); - return *this; - } - - /** @overload */ - Params& cfgInputReshape(const std::string & layer_name, const std::vector&layer_dims) { - desc.reshape_table.emplace(layer_name, layer_dims); - return *this; - } - - /** @overload */ - Params& cfgInputReshape(std::unordered_set && layer_names) { - desc.layer_names_to_reshape = std::move(layer_names); - return *this; - } - - /** @overload */ - Params& cfgInputReshape(const std::unordered_set&layer_names) { - desc.layer_names_to_reshape = layer_names; - return *this; - } - - /** @see ie::Params::cfgBatchSize */ - Params& cfgBatchSize(const size_t size) { - desc.batch_size = cv::util::make_optional(size); - return *this; - } - - /** @see ie::Params::cfgInferAPI */ - Params& cfgInferMode(InferMode mode) { - desc.mode = mode; - return *this; - } - - /** @see ie::Params::cfgOutputPrecision */ - Params& cfgOutputPrecision(detail::ParamDesc::PrecisionT precision) { - desc.output_precision = precision; - return *this; - } - - /** @overload */ - Params& - cfgOutputPrecision(detail::ParamDesc::PrecisionMapT precision_map) { - desc.output_precision = precision_map; - return *this; - } - - /** @see ie::Params::cfgInputLayout */ - Params& cfgInputLayout(std::string layout) { - desc.input_layout = std::move(layout); - return *this; - } - - /** @overload */ - Params& - cfgInputLayout(detail::AttrMap layout_map) { - desc.input_layout = std::move(layout_map); - return *this; - } - - /** @see ie::Params::cfgOutputLayout */ - Params& cfgOutputLayout(std::string layout) { - desc.output_layout = std::move(layout); - return *this; - } - - /** @overload */ - Params& - cfgOutputLayout(detail::AttrMap layout_map) { - desc.output_layout = std::move(layout_map); - return *this; - } - - /** @see ie::Params::cfgResize */ - Params& cfgResize(int interpolation) { - desc.interpolation = interpolation; - return *this; - } - - /** @overload */ - Params& cfgResize(detail::AttrMap interpolation) { - desc.interpolation = std::move(interpolation); - return *this; - } - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::ie::backend(); } - std::string tag() const { return m_tag; } - cv::util::any params() const { return { desc }; } - // END(G-API's network parametrization API) - -protected: - detail::ParamDesc desc; - std::string m_tag; -}; - -} // namespace ie -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_INFER_IE_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/onnx.hpp b/modules/gapi/include/opencv2/gapi/infer/onnx.hpp deleted file mode 100644 index eb6316b446..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/onnx.hpp +++ /dev/null @@ -1,759 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020-2021 Intel Corporation - -#ifndef OPENCV_GAPI_INFER_ONNX_HPP -#define OPENCV_GAPI_INFER_ONNX_HPP - -#include -#include -#include -#include // tuple, tuple_size -#include - -#include -#include -#include - -#include // GAPI_EXPORTS -#include // GKernelPackage -#include // Generic - -namespace cv { -namespace gapi { - -/** - * @brief This namespace contains G-API ONNX Runtime backend functions, structures, and symbols. - */ -namespace onnx { - -/** - * @brief This namespace contains Execution Providers structures for G-API ONNX Runtime backend. - */ -namespace ep { - -/** - * @brief This structure provides functions - * that fill inference options for ONNX CoreML Execution Provider. - * Please follow https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml-execution-provider - */ -struct GAPI_EXPORTS_W_SIMPLE CoreML { - /** @brief Class constructor. - - Constructs CoreML parameters. - - */ - GAPI_WRAP - CoreML() = default; - - /** @brief Limit CoreML Execution Provider to run on CPU only. - - This function is used to limit CoreML to run on CPU only. - Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_use_cpu_only - - @return reference to this parameter structure. - */ - GAPI_WRAP - CoreML& cfgUseCPUOnly() { - use_cpu_only = true; - return *this; - } - - /** @brief Enable CoreML EP to run on a subgraph in the body of a control flow ONNX operator (i.e. a Loop, Scan or If operator). - - This function is used to enable CoreML EP to run on - a subgraph of a control flow of ONNX operation. - Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_enable_on_subgraph - - @return reference to this parameter structure. - */ - GAPI_WRAP - CoreML& cfgEnableOnSubgraph() { - enable_on_subgraph = true; - return *this; - } - - /** @brief Enable CoreML EP to run only on Apple Neural Engine. - - This function is used to enable CoreML EP to run only on Apple Neural Engine. - Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_only_enable_device_with_ane - - @return reference to this parameter structure. - */ - GAPI_WRAP - CoreML& cfgEnableOnlyNeuralEngine() { - enable_only_ane = true; - return *this; - } - - bool use_cpu_only = false; - bool enable_on_subgraph = false; - bool enable_only_ane = false; -}; - -/** - * @brief This structure provides functions - * that fill inference options for CUDA Execution Provider. - * Please follow https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html#cuda-execution-provider - */ -struct GAPI_EXPORTS_W_SIMPLE CUDA { - // NB: Used from python. - /// @private -- Exclude this constructor from OpenCV documentation - GAPI_WRAP - CUDA() = default; - - /** @brief Class constructor. - - Constructs CUDA parameters based on device type information. - - @param dev_id Target device id to use. - */ - GAPI_WRAP - explicit CUDA(const int dev_id) - : device_id(dev_id) { - } - - int device_id; -}; - -/** - * @brief This structure provides functions - * that fill inference options for TensorRT Execution Provider. - * Please follow https://onnxruntime.ai/docs/execution-providers/TensorRT-ExecutionProvider.html#tensorrt-execution-provider - */ -struct GAPI_EXPORTS_W_SIMPLE TensorRT { - // NB: Used from python. - /// @private -- Exclude this constructor from OpenCV documentation - GAPI_WRAP - TensorRT() = default; - - /** @brief Class constructor. - - Constructs TensorRT parameters based on device type information. - - @param dev_id Target device id to use. - */ - GAPI_WRAP - explicit TensorRT(const int dev_id) - : device_id(dev_id) { - } - - int device_id; -}; - -/** - * @brief This structure provides functions - * that fill inference options for ONNX OpenVINO Execution Provider. - * Please follow https://onnxruntime.ai/docs/execution-providers/OpenVINO-ExecutionProvider.html#summary-of-options - */ -struct GAPI_EXPORTS_W_SIMPLE OpenVINO { - // NB: Used from python. - /// @private -- Exclude this constructor from OpenCV documentation - GAPI_WRAP - OpenVINO() = default; - - /** @brief Class constructor. - - Constructs OpenVINO parameters based on device type information. - - @param dev_type Target device type to use. ("CPU", "GPU", "GPU.0" etc) - */ - GAPI_WRAP - explicit OpenVINO(const std::string &dev_type) - : device_type(dev_type) { - } - - /** @brief Class constructor. - - Constructs OpenVINO parameters based on map of options passed. - - * @param params A map of parameter names and their corresponding string values. - */ - GAPI_WRAP - explicit OpenVINO(const std::map& params) - : params_map(params) { - } - - /** @brief Specifies OpenVINO Execution Provider cache dir. - - This function is used to explicitly specify the path to save and load - the blobs enabling model caching feature. - - @param dir Path to the directory what will be used as cache. - @return reference to this parameter structure. - */ - GAPI_WRAP - OpenVINO& cfgCacheDir(const std::string &dir) { - if (!params_map.empty()) { - cv::util::throw_error(std::logic_error("ep::OpenVINO cannot be changed if" - "created from the parameters map.")); - } - cache_dir = dir; - return *this; - } - - /** @brief Specifies OpenVINO Execution Provider number of threads. - - This function is used to override the accelerator default value - of number of threads with this value at runtime. - - @param nthreads Number of threads. - @return reference to this parameter structure. - */ - GAPI_WRAP - OpenVINO& cfgNumThreads(size_t nthreads) { - if (!params_map.empty()) { - cv::util::throw_error(std::logic_error("ep::OpenVINO cannot be changed if" - "created from the parameters map.")); - } - num_of_threads = nthreads; - return *this; - } - - /** @brief Enables OpenVINO Execution Provider opencl throttling. - - This function is used to enable OpenCL queue throttling for GPU devices - (reduces CPU utilization when using GPU). - - @return reference to this parameter structure. - */ - GAPI_WRAP - OpenVINO& cfgEnableOpenCLThrottling() { - if (!params_map.empty()) { - cv::util::throw_error(std::logic_error("ep::OpenVINO cannot be changed if" - "created from the parameters map.")); - } - enable_opencl_throttling = true; - return *this; - } - - /** @brief Enables OpenVINO Execution Provider dynamic shapes. - - This function is used to enable OpenCL queue throttling for GPU devices - (reduces CPU utilization when using GPU). - This function is used to enable work with dynamic shaped models - whose shape will be set dynamically based on the infer input - image/data shape at run time in CPU. - - @return reference to this parameter structure. - */ - GAPI_WRAP - OpenVINO& cfgEnableDynamicShapes() { - if (!params_map.empty()) { - cv::util::throw_error(std::logic_error("ep::OpenVINO cannot be changed if" - "created from the parameters map.")); - } - enable_dynamic_shapes = true; - return *this; - } - - std::string device_type; - std::string cache_dir; - size_t num_of_threads = 0; - bool enable_opencl_throttling = false; - bool enable_dynamic_shapes = false; - std::map params_map; -}; - -/** - * @brief This structure provides functions - * that fill inference options for ONNX DirectML Execution Provider. - * Please follow https://onnxruntime.ai/docs/execution-providers/DirectML-ExecutionProvider.html#directml-execution-provider - */ -class GAPI_EXPORTS_W_SIMPLE DirectML { -public: - // NB: Used from python. - /// @private -- Exclude this constructor from OpenCV documentation - GAPI_WRAP - DirectML() = default; - - /** @brief Class constructor. - - Constructs DirectML parameters based on device id. - - @param device_id Target device id to use. ("0", "1", etc) - */ - GAPI_WRAP - explicit DirectML(const int device_id) : ddesc(device_id) { }; - - /** @brief Class constructor. - - Constructs DirectML parameters based on adapter name. - - @param adapter_name Target adapter_name to use. - */ - GAPI_WRAP - explicit DirectML(const std::string &adapter_name) : ddesc(adapter_name) { }; - - using DeviceDesc = cv::util::variant; - DeviceDesc ddesc; -}; - -using EP = cv::util::variant< cv::util::monostate - , OpenVINO - , DirectML - , CoreML - , CUDA - , TensorRT>; - -} // namespace ep - -GAPI_EXPORTS cv::gapi::GBackend backend(); - -enum class TraitAs: int { - TENSOR, //!< G-API traits an associated cv::Mat as a raw tensor - // and passes dimensions as-is - IMAGE //!< G-API traits an associated cv::Mat as an image so - // creates an "image" blob (NCHW/NHWC, etc) -}; - -using PostProc = std::function &, - std::unordered_map &)>; - -namespace detail { -/** -* @brief This structure contains description of inference parameters -* which is specific to ONNX models. -*/ -struct ParamDesc { - std::string model_path; //!< Path to model. - - // NB: nun_* may differ from topology's real input/output port numbers - // (e.g. topology's partial execution) - std::size_t num_in; //!< How many inputs are defined in the operation - std::size_t num_out; //!< How many outputs are defined in the operation - - // NB: Here order follows the `Net` API - std::vector input_names; //!< Names of input network layers. - std::vector output_names; //!< Names of output network layers. - - using ConstInput = std::pair; - std::unordered_map const_inputs; //!< Map with pair of name of network layer and ConstInput which will be associated with this. - - std::vector mean; //!< Mean values for preprocessing. - std::vector stdev; //!< Standard deviation values for preprocessing. - - std::vector out_metas; //!< Out meta information about your output (type, dimension). - PostProc custom_post_proc; //!< Post processing function. - - std::vector normalize; //!< Vector of bool values that enabled or disabled normalize of input data. - - std::vector names_to_remap; //!< Names of output layers that will be processed in PostProc function. - - bool is_generic; - - // TODO: Needs to modify the rest of ParamDesc accordingly to support - // both generic and non-generic options without duplication - // (as it was done for the OV IE backend) - // These values are pushed into the respective vector<> fields above - // when the generic infer parameters are unpacked (see GONNXBackendImpl::unpackKernel) - std::unordered_map > generic_mstd; - std::unordered_map generic_norm; - - std::map session_options; - std::vector execution_providers; - bool disable_mem_pattern; - cv::util::optional opt_level; -}; -} // namespace detail - -template -struct PortCfg { - using In = std::array - < std::string - , std::tuple_size::value >; - using Out = std::array - < std::string - , std::tuple_size::value >; - using NormCoefs = std::array - < cv::Scalar - , std::tuple_size::value >; - using Normalize = std::array - < bool - , std::tuple_size::value >; -}; - -/** - * Contains description of inference parameters and kit of functions that - * fill this parameters. - */ -template class Params { -public: - /** @brief Class constructor. - - Constructs Params based on model information and sets default values for other - inference description parameters. - - @param model Path to model (.onnx file). - */ - Params(const std::string &model) { - desc.model_path = model; - desc.num_in = std::tuple_size::value; - desc.num_out = std::tuple_size::value; - desc.is_generic = false; - desc.disable_mem_pattern = false; - } - - /** @brief Specifies sequence of network input layers names for inference. - - The function is used to associate data of graph inputs with input layers of - network topology. Number of names has to match the number of network inputs. If a network - has only one input layer, there is no need to call it as the layer is - associated with input automatically but this doesn't prevent you from - doing it yourself. Count of names has to match to number of network inputs. - - @param layer_names std::array where N is the number of inputs - as defined in the @ref G_API_NET. Contains names of input layers. - @return the reference on modified object. - */ - Params& cfgInputLayers(const typename PortCfg::In &layer_names) { - desc.input_names.assign(layer_names.begin(), layer_names.end()); - return *this; - } - - /** @brief Specifies sequence of output layers names for inference. - - The function is used to associate data of graph outputs with output layers of - network topology. If a network has only one output layer, there is no need to call it - as the layer is associated with output automatically but this doesn't prevent - you from doing it yourself. Count of names has to match to number of network - outputs or you can set your own output but for this case you have to - additionally use @ref cfgPostProc function. - - @param layer_names std::array where N is the number of outputs - as defined in the @ref G_API_NET. Contains names of output layers. - @return the reference on modified object. - */ - Params& cfgOutputLayers(const typename PortCfg::Out &layer_names) { - desc.output_names.assign(layer_names.begin(), layer_names.end()); - return *this; - } - - /** @brief Sets a constant input. - - The function is used to set constant input. This input has to be - a prepared tensor since preprocessing is disabled for this case. You should - provide name of network layer which will receive provided data. - - @param layer_name Name of network layer. - @param data cv::Mat that contains data which will be associated with network layer. - @param hint Type of input (TENSOR). - @return the reference on modified object. - */ - Params& constInput(const std::string &layer_name, - const cv::Mat &data, - TraitAs hint = TraitAs::TENSOR) { - desc.const_inputs[layer_name] = {data, hint}; - return *this; - } - - /** @brief Specifies mean value and standard deviation for preprocessing. - - The function is used to set mean value and standard deviation for preprocessing - of input data. - - @param m std::array where N is the number of inputs - as defined in the @ref G_API_NET. Contains mean values. - @param s std::array where N is the number of inputs - as defined in the @ref G_API_NET. Contains standard deviation values. - @return the reference on modified object. - */ - Params& cfgMeanStd(const typename PortCfg::NormCoefs &m, - const typename PortCfg::NormCoefs &s) { - desc.mean.assign(m.begin(), m.end()); - desc.stdev.assign(s.begin(), s.end()); - return *this; - } - - /** @brief Configures graph output and provides the post processing function from user. - - The function is used when you work with networks with dynamic outputs. - Since we can't know dimensions of inference result needs provide them for - construction of graph output. This dimensions can differ from inference result. - So you have to provide @ref PostProc function that gets information from inference - result and fill output which is constructed by dimensions from out_metas. - - @param out_metas Out meta information about your output (type, dimension). - @param remap_function Post processing function, which has two parameters. First is onnx - result, second is graph output. Both parameters is std::map that contain pair of - layer's name and cv::Mat. - @return the reference on modified object. - */ - Params& cfgPostProc(const std::vector &out_metas, - const PostProc &remap_function) { - desc.out_metas = out_metas; - desc.custom_post_proc = remap_function; - return *this; - } - - /** @overload - Function with a rvalue parameters. - - @param out_metas rvalue out meta information about your output (type, dimension). - @param remap_function rvalue post processing function, which has two parameters. First is onnx - result, second is graph output. Both parameters is std::map that contain pair of - layer's name and cv::Mat. - @return the reference on modified object. - */ - Params& cfgPostProc(std::vector &&out_metas, - PostProc &&remap_function) { - desc.out_metas = std::move(out_metas); - desc.custom_post_proc = std::move(remap_function); - return *this; - } - - /** @overload - The function has additional parameter names_to_remap. This parameter provides - information about output layers which will be used for inference and post - processing function. - - @param out_metas Out meta information. - @param remap_function Post processing function. - @param names_to_remap Names of output layers. network's inference will - be done on these layers. Inference's result will be processed in post processing - function using these names. - @return the reference on modified object. - */ - Params& cfgPostProc(const std::vector &out_metas, - const PostProc &remap_function, - const std::vector &names_to_remap) { - desc.out_metas = out_metas; - desc.custom_post_proc = remap_function; - desc.names_to_remap = names_to_remap; - return *this; - } - - /** @overload - Function with a rvalue parameters and additional parameter names_to_remap. - - @param out_metas rvalue out meta information. - @param remap_function rvalue post processing function. - @param names_to_remap rvalue names of output layers. network's inference will - be done on these layers. Inference's result will be processed in post processing - function using these names. - @return the reference on modified object. - */ - Params& cfgPostProc(std::vector &&out_metas, - PostProc &&remap_function, - std::vector &&names_to_remap) { - desc.out_metas = std::move(out_metas); - desc.custom_post_proc = std::move(remap_function); - desc.names_to_remap = std::move(names_to_remap); - return *this; - } - - /** @brief Specifies normalize parameter for preprocessing. - - The function is used to set normalize parameter for preprocessing of input data. - - @param normalizations std::array where N is the number of inputs - as defined in the @ref G_API_NET. Сontains bool values that enabled or disabled - normalize of input data. - @return the reference on modified object. - */ - Params& cfgNormalize(const typename PortCfg::Normalize &normalizations) { - desc.normalize.assign(normalizations.begin(), normalizations.end()); - return *this; - } - - /** @brief Adds execution provider for runtime. - - The function is used to add ONNX Runtime OpenVINO Execution Provider options. - - @param ep OpenVINO Execution Provider options. - @see cv::gapi::onnx::ep::OpenVINO. - - @return the reference on modified object. - */ - Params& cfgAddExecutionProvider(ep::OpenVINO&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - return *this; - } - - /** @brief Adds execution provider for runtime. - - The function is used to add ONNX Runtime DirectML Execution Provider options. - - @param ep DirectML Execution Provider options. - @see cv::gapi::onnx::ep::DirectML. - - @return the reference on modified object. - */ - Params& cfgAddExecutionProvider(ep::DirectML&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - return *this; - } - - /** @brief Adds execution provider for runtime. - - The function is used to add ONNX Runtime CoreML Execution Provider options. - - @param ep CoreML Execution Provider options. - @see cv::gapi::onnx::ep::CoreML. - - @return the reference on modified object. - */ - Params& cfgAddExecutionProvider(ep::CoreML&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - return *this; - } - - /** @brief Adds execution provider for runtime. - - The function is used to add ONNX Runtime CUDA Execution Provider options. - - @param ep CUDA Execution Provider options. - @see cv::gapi::onnx::ep::CUDA. - - @return the reference on modified object. - */ - Params& cfgAddExecutionProvider(ep::CUDA&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - return *this; - } - - /** @brief Adds execution provider for runtime. - - The function is used to add ONNX Runtime TensorRT Execution Provider options. - - @param ep TensorRT Execution Provider options. - @see cv::gapi::onnx::ep::TensorRT. - - @return the reference on modified object. - */ - Params& cfgAddExecutionProvider(ep::TensorRT&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - return *this; - } - - /** @brief Disables the memory pattern optimization. - - @return the reference on modified object. - */ - Params& cfgDisableMemPattern() { - desc.disable_mem_pattern = true; - return *this; - } - - /** @brief Configures session options for ONNX Runtime. - - This function is used to set various session options for the ONNX Runtime - session by accepting a map of key-value pairs. - - @param options A map of session option to be applied to the ONNX Runtime session. - @return the reference on modified object. - */ - Params& cfgSessionOptions(const std::map& options) { - desc.session_options.insert(options.begin(), options.end()); - return *this; - } - - /** @brief Configures optimization level for ONNX Runtime. - - @param opt_level [optimization level]: Valid values are 0 (disable), 1 (basic), 2 (extended), 99 (all). - Please see onnxruntime_c_api.h (enum GraphOptimizationLevel) for the full list of all optimization levels. - @return the reference on modified object. - */ - Params& cfgOptLevel(const int opt_level) { - desc.opt_level = cv::util::make_optional(opt_level); - return *this; - } - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::onnx::backend(); } - std::string tag() const { return Net::tag(); } - cv::util::any params() const { return { desc }; } - // END(G-API's network parametrization API) - -protected: - detail::ParamDesc desc; -}; - -/* -* @brief This structure provides functions for generic network type that -* fill inference parameters. -* @see struct Generic -*/ -template<> -class Params { -public: - /** @brief Class constructor. - - Constructs Params based on input information and sets default values for other - inference description parameters. - - @param tag string tag of the network for which these parameters are intended. - @param model_path path to model file (.onnx file). - */ - Params(const std::string& tag, const std::string& model_path) - : desc{ model_path, 0u, 0u, {}, {}, {}, {}, {}, {}, {}, {}, {}, true, {}, {}, {}, {}, false, {} }, m_tag(tag) {} - - /** @see onnx::Params::cfgMeanStdDev. */ - void cfgMeanStdDev(const std::string &layer, - const cv::Scalar &m, - const cv::Scalar &s) { - desc.generic_mstd[layer] = std::make_pair(m, s); - } - - /** @see onnx::Params::cfgNormalize. */ - void cfgNormalize(const std::string &layer, bool flag) { - desc.generic_norm[layer] = flag; - } - - /** @see onnx::Params::cfgAddExecutionProvider. */ - void cfgAddExecutionProvider(ep::OpenVINO&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - } - - /** @see onnx::Params::cfgAddExecutionProvider. */ - void cfgAddExecutionProvider(ep::DirectML&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - } - - /** @see onnx::Params::cfgAddExecutionProvider. */ - void cfgAddExecutionProvider(ep::CoreML&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - } - - /** @see onnx::Params::cfgAddExecutionProvider. */ - void cfgAddExecutionProvider(ep::CUDA&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - } - - /** @see onnx::Params::cfgAddExecutionProvider. */ - void cfgAddExecutionProvider(ep::TensorRT&& ep) { - desc.execution_providers.emplace_back(std::move(ep)); - } - - /** @see onnx::Params::cfgDisableMemPattern. */ - void cfgDisableMemPattern() { - desc.disable_mem_pattern = true; - } - - /** @see onnx::Params::cfgSessionOptions. */ - void cfgSessionOptions(const std::map& options) { - desc.session_options.insert(options.begin(), options.end()); - } - -/** @see onnx::Params::cfgOptLevel. */ - void cfgOptLevel(const int opt_level) { - desc.opt_level = cv::util::make_optional(opt_level); - } - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::onnx::backend(); } - std::string tag() const { return m_tag; } - cv::util::any params() const { return { desc }; } - // END(G-API's network parametrization API) -protected: - detail::ParamDesc desc; - std::string m_tag; -}; - -} // namespace onnx -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_INFER_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/ov.hpp b/modules/gapi/include/opencv2/gapi/infer/ov.hpp deleted file mode 100644 index 782792489b..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/ov.hpp +++ /dev/null @@ -1,709 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2023 Intel Corporation - -#ifndef OPENCV_GAPI_INFER_OV_HPP -#define OPENCV_GAPI_INFER_OV_HPP - -#include - -#include -#include // GAPI_EXPORTS -#include // GKernelType[M], GBackend -#include // Generic - -#include - -namespace cv { -namespace gapi { - -/** - * @brief This namespace contains G-API OpenVINO 2.0 backend functions, - * structures, and symbols. - */ -namespace ov { - -GAPI_EXPORTS cv::gapi::GBackend backend(); - -namespace detail { - -template -using AttrMap = std::map; -// NB: This type is supposed to be used to hold in/out layers -// attributes such as precision, layout, shape etc. -// -// User can provide attributes either: -// 1. cv::util::monostate - No value specified explicitly. -// 2. Attr - value specified explicitly that should be broadcasted to all layers. -// 3. AttrMap[str->T] - map specifies value for particular layer. -template -using LayerVariantAttr = cv::util::variant< cv::util::monostate - , AttrMap - , Attr>; - -struct ParamDesc { - struct Model { - - Model(const std::string &model_path_, - const std::string &bin_path_) - : model_path(model_path_), bin_path(bin_path_) { - } - - std::string model_path; - std::string bin_path; - - LayerVariantAttr input_tensor_layout; - LayerVariantAttr input_model_layout; - LayerVariantAttr output_tensor_layout; - LayerVariantAttr output_model_layout; - LayerVariantAttr output_tensor_precision; - - LayerVariantAttr> new_shapes; - - LayerVariantAttr> mean_values; - LayerVariantAttr> scale_values; - - LayerVariantAttr interpolation; - }; - - struct CompiledModel { - std::string blob_path; - }; - - using Kind = cv::util::variant; - - ParamDesc(Kind &&kind_, - const std::string &device_, - const bool is_generic_, - const size_t num_in_, - const size_t num_out_) - : kind(std::move(kind_)), device(device_), - is_generic(is_generic_), - num_in(num_in_), num_out(num_out_) { - } - - Kind kind; - - std::string device; - bool is_generic; - - std::size_t num_in; - std::size_t num_out; - - std::vector input_names; - std::vector output_names; - - using PluginConfigT = std::map; - PluginConfigT config; - - size_t nireq = 1; -}; - -// NB: Just helper to avoid code duplication. -static detail::ParamDesc::Model& -getModelToSetAttrOrThrow(detail::ParamDesc::Kind &kind, - const std::string &attr_name) { - if (cv::util::holds_alternative(kind)) { - cv::util::throw_error( - std::logic_error("Specifying " + attr_name + " isn't" - " possible for compiled model.")); - } - GAPI_Assert(cv::util::holds_alternative(kind)); - return cv::util::get(kind); -} - -} // namespace detail - -/** - * @brief This structure provides functions - * that fill inference parameters for "OpenVINO Toolkit" model. - */ -template struct Params { -public: - /** @brief Class constructor. - - Constructs Params based on model information and specifies default values for other - inference description parameters. Model is loaded and compiled using "OpenVINO Toolkit". - - @param model_path Path to a model. - @param bin_path Path to a data file. - For IR format (*.bin): - If path is empty, will try to read a bin file with the same name as xml. - If the bin file with the same name is not found, will load IR without weights. - For PDPD (*.pdmodel) and ONNX (*.onnx) formats bin_path isn't used. - @param device target device to use. - */ - Params(const std::string &model_path, - const std::string &bin_path, - const std::string &device) - : m_desc( detail::ParamDesc::Kind{detail::ParamDesc::Model{model_path, bin_path}} - , device - , false /* is generic */ - , std::tuple_size::value - , std::tuple_size::value) { - } - - /** @overload - Use this constructor to work with pre-compiled network. - Model is imported from a pre-compiled blob. - - @param blob_path path to the compiled model (*.blob). - @param device target device to use. - */ - Params(const std::string &blob_path, - const std::string &device) - : m_desc( detail::ParamDesc::Kind{detail::ParamDesc::CompiledModel{blob_path}} - , device - , false /* is generic */ - , std::tuple_size::value - , std::tuple_size::value) { - } - - /** @brief Specifies sequence of network input layers names for inference. - - The function is used to associate cv::gapi::infer<> inputs with the model inputs. - Number of names has to match the number of network inputs as defined in G_API_NET(). - In case a network has only single input layer, there is no need to specify name manually. - - @param layer_names std::array where N is the number of inputs - as defined in the @ref G_API_NET. Contains names of input layers. - @return reference to this parameter structure. - */ - Params& cfgInputLayers(const std::vector &layer_names) { - m_desc.input_names = layer_names; - return *this; - } - - /** @brief Specifies sequence of network output layers names for inference. - - The function is used to associate cv::gapi::infer<> outputs with the model outputs. - Number of names has to match the number of network outputs as defined in G_API_NET(). - In case a network has only single output layer, there is no need to specify name manually. - - @param layer_names std::array where N is the number of outputs - as defined in the @ref G_API_NET. Contains names of output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputLayers(const std::vector &layer_names) { - m_desc.output_names = layer_names; - return *this; - } - - /** @brief Specifies OpenVINO plugin configuration. - - The function is used to set configuration for OpenVINO plugin. Some parameters - can be different for each plugin. Please follow https://docs.openvinotoolkit.org/latest/index.html - to check information about specific plugin. - - @param config Map of pairs: (config parameter name, config parameter value). - @return reference to this parameter structure. - */ - Params& cfgPluginConfig(const detail::ParamDesc::PluginConfigT &config) { - m_desc.config = config; - return *this; - } - - /** @brief Specifies tensor layout for an input layer. - - The function is used to set tensor layout for an input layer. - - @param layout Tensor layout ("NCHW", "NWHC", etc) - will be applied to all input layers. - @return reference to this parameter structure. - */ - Params& cfgInputTensorLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout") - .input_tensor_layout = std::move(layout); - return *this; - } - - /** @overload - @param layout_map Map of pairs: name of corresponding input layer - and its tensor layout represented in std::string ("NCHW", "NHWC", etc) - @return reference to this parameter structure. - */ - Params& - cfgInputTensorLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout") - .input_tensor_layout = std::move(layout_map); - return *this; - } - - /** @brief Specifies model layout for an input layer. - - The function is used to set model layout for an input layer. - - @param layout Model layout ("NCHW", "NHWC", etc) - will be applied to all input layers. - @return reference to this parameter structure. - */ - Params& cfgInputModelLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout") - .input_model_layout = std::move(layout); - return *this; - } - - /** @overload - @param layout_map Map of pairs: name of corresponding input layer - and its model layout ("NCHW", "NHWC", etc) - @return reference to this parameter structure. - */ - Params& - cfgInputModelLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout") - .input_model_layout = std::move(layout_map); - return *this; - } - - /** @brief Specifies tensor layout for an output layer. - - The function is used to set tensor layout for an output layer. - - @param layout Tensor layout ("NCHW", "NWHC", etc) - will be applied to all output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputTensorLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout") - .output_tensor_layout = std::move(layout); - return *this; - } - - /** @overload - @param layout_map Map of pairs: name of corresponding output layer - and its tensor layout represented in std::string ("NCHW", "NHWC", etc) - @return reference to this parameter structure. - */ - Params& - cfgOutputTensorLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout") - .output_tensor_layout = std::move(layout_map); - return *this; - } - - /** @brief Specifies model layout for an output layer. - - The function is used to set model layout for an output layer. - - @param layout Model layout ("NCHW", "NHWC", etc) - will be applied to all output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputModelLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout") - .output_model_layout = std::move(layout); - return *this; - } - - /** @overload - @param layout_map Map of pairs: name of corresponding output layer - and its model layout ("NCHW", "NHWC", etc) - @return reference to this parameter structure. - */ - Params& - cfgOutputModelLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout") - .output_model_layout = std::move(layout_map); - return *this; - } - - /** @brief Specifies tensor precision for an output layer. - - The function is used to set tensor precision for an output layer.. - - @param precision Precision in OpenCV format (CV_8U, CV_32F, ...) - will be applied to all output layers. - @return reference to this parameter structure. - */ - Params& cfgOutputTensorPrecision(int precision) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision") - .output_tensor_precision = precision; - return *this; - } - - /** @overload - - @param precision_map Map of pairs: name of corresponding output layer - and its precision in OpenCV format (CV_8U, CV_32F, ...) - @return reference to this parameter structure. - */ - Params& - cfgOutputTensorPrecision(detail::AttrMap precision_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision") - .output_tensor_precision = std::move(precision_map); - return *this; - } - - /** @brief Specifies the new shape for input layers. - - The function is used to set new shape for input layers. - - @param new_shape New shape will be applied to all input layers. - @return reference to this parameter structure. - */ - Params& - cfgReshape(std::vector new_shape) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape") - .new_shapes = std::move(new_shape); - return *this; - } - - /** @overload - - @param new_shape_map Map of pairs: name of corresponding output layer - and its new shape. - @return reference to this parameter structure. - */ - Params& - cfgReshape(detail::AttrMap> new_shape_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape") - .new_shapes = std::move(new_shape_map); - return *this; - } - - /** @brief Specifies number of asynchronous inference requests. - - @param nireq Number of inference asynchronous requests. - @return reference to this parameter structure. - */ - Params& cfgNumRequests(const size_t nireq) { - if (nireq == 0) { - cv::util::throw_error( - std::logic_error("Number of inference requests" - " must be greater than zero.")); - } - m_desc.nireq = nireq; - return *this; - } - - /** @brief Specifies mean values for preprocessing. - * - The function is used to set mean values for input layer preprocessing. - - @param mean_values Float vector contains mean values - @return reference to this parameter structure. - */ - Params& cfgMean(std::vector mean_values) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values") - .mean_values = std::move(mean_values); - return *this; - } - - /** @overload - - @param mean_map Map of pairs: name of corresponding input layer - and its mean values. - @return reference to this parameter structure. - */ - Params& cfgMean(detail::AttrMap> mean_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values") - .mean_values = std::move(mean_map); - return *this; - } - - /** @brief Specifies scale values for preprocessing. - * - The function is used to set scale values for input layer preprocessing. - - @param scale_values Float vector contains scale values - @return reference to this parameter structure. - */ - Params& cfgScale(std::vector scale_values) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values") - .scale_values = std::move(scale_values); - return *this; - } - - /** @overload - - @param scale_map Map of pairs: name of corresponding input layer - and its mean values. - @return reference to this parameter structure. - */ - Params& cfgScale(detail::AttrMap> scale_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values") - .scale_values = std::move(scale_map); - return *this; - } - - /** @brief Specifies resize interpolation algorithm. - * - The function is used to configure resize preprocessing for input layer. - - @param interpolation Resize interpolation algorithm. - Supported algorithms: #INTER_NEAREST, #INTER_LINEAR, #INTER_CUBIC. - @return reference to this parameter structure. - */ - Params& cfgResize(int interpolation) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing") - .interpolation = std::move(interpolation); - return *this; - } - - /** @overload - - @param interpolation Map of pairs: name of corresponding input layer - and its resize algorithm. - @return reference to this parameter structure. - */ - Params& cfgResize(detail::AttrMap interpolation) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing") - .interpolation = std::move(interpolation); - return *this; - } - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::ov::backend(); } - std::string tag() const { return Net::tag(); } - cv::util::any params() const { return { m_desc }; } - // END(G-API's network parametrization API) - -protected: - detail::ParamDesc m_desc; -}; - -/* -* @brief This structure provides functions for generic network type that -* fill inference parameters. -* @see struct Generic -*/ -template<> -class Params { -public: - /** @brief Class constructor. - - Constructs Params based on model information and specifies default values for other - inference description parameters. Model is loaded and compiled using "OpenVINO Toolkit". - - @param tag string tag of the network for which these parameters are intended. - @param model_path Path to a model. - @param bin_path Path to a data file. - For IR format (*.bin): - If path is empty, will try to read a bin file with the same name as xml. - If the bin file with the same name is not found, will load IR without weights. - For PDPD (*.pdmodel) and ONNX (*.onnx) formats bin_path isn't used. - @param device target device to use. - */ - Params(const std::string &tag, - const std::string &model_path, - const std::string &bin_path, - const std::string &device) - : m_tag(tag), - m_desc( detail::ParamDesc::Kind{detail::ParamDesc::Model{model_path, bin_path}} - , device - , true /* is generic */ - , 0u - , 0u) { - } - - /** @overload - - This constructor for pre-compiled networks. Model is imported from pre-compiled - blob. - - @param tag string tag of the network for which these parameters are intended. - @param blob_path path to the compiled model (*.blob). - @param device target device to use. - */ - Params(const std::string &tag, - const std::string &blob_path, - const std::string &device) - : m_tag(tag), - m_desc( detail::ParamDesc::Kind{detail::ParamDesc::CompiledModel{blob_path}} - , device - , true /* is generic */ - , 0u - , 0u) { - } - - /** @see ov::Params::cfgPluginConfig. */ - Params& cfgPluginConfig(const detail::ParamDesc::PluginConfigT &config) { - m_desc.config = config; - return *this; - } - - /** @see ov::Params::cfgInputTensorLayout. */ - Params& cfgInputTensorLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout") - .input_tensor_layout = std::move(layout); - return *this; - } - - /** @overload */ - Params& - cfgInputTensorLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout") - .input_tensor_layout = std::move(layout_map); - return *this; - } - - /** @see ov::Params::cfgInputModelLayout. */ - Params& cfgInputModelLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout") - .input_model_layout = std::move(layout); - return *this; - } - - /** @overload */ - Params& - cfgInputModelLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout") - .input_model_layout = std::move(layout_map); - return *this; - } - - /** @see ov::Params::cfgOutputTensorLayout. */ - Params& cfgOutputTensorLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout") - .output_tensor_layout = std::move(layout); - return *this; - } - - /** @overload */ - Params& - cfgOutputTensorLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout") - .output_tensor_layout = std::move(layout_map); - return *this; - } - - /** @see ov::Params::cfgOutputModelLayout. */ - Params& cfgOutputModelLayout(std::string layout) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout") - .output_model_layout = std::move(layout); - return *this; - } - - /** @overload */ - Params& - cfgOutputModelLayout(detail::AttrMap layout_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout") - .output_model_layout = std::move(layout_map); - return *this; - } - - /** @see ov::Params::cfgOutputTensorPrecision. */ - Params& cfgOutputTensorPrecision(int precision) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision") - .output_tensor_precision = precision; - return *this; - } - - /** @overload */ - Params& - cfgOutputTensorPrecision(detail::AttrMap precision_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision") - .output_tensor_precision = std::move(precision_map); - return *this; - } - - /** @see ov::Params::cfgReshape. */ - Params& cfgReshape(std::vector new_shape) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape") - .new_shapes = std::move(new_shape); - return *this; - } - - /** @overload */ - Params& - cfgReshape(detail::AttrMap> new_shape_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape") - .new_shapes = std::move(new_shape_map); - return *this; - } - - /** @see ov::Params::cfgNumRequests. */ - Params& cfgNumRequests(const size_t nireq) { - if (nireq == 0) { - cv::util::throw_error( - std::logic_error("Number of inference requests" - " must be greater than zero.")); - } - m_desc.nireq = nireq; - return *this; - } - - /** @see ov::Params::cfgMean. */ - Params& cfgMean(std::vector mean_values) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values") - .mean_values = std::move(mean_values); - return *this; - } - - /** @overload */ - Params& cfgMean(detail::AttrMap> mean_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values") - .mean_values = std::move(mean_map); - return *this; - } - - /** @see ov::Params::cfgScale. */ - Params& cfgScale(std::vector scale_values) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values") - .scale_values = std::move(scale_values); - return *this; - } - - /** @overload */ - Params& cfgScale(detail::AttrMap> scale_map) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values") - .scale_values = std::move(scale_map); - return *this; - } - - /** @see ov::Params::cfgResize. */ - Params& cfgResize(int interpolation) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing") - .interpolation = std::move(interpolation); - return *this; - } - - /** @overload */ - Params& cfgResize(detail::AttrMap interpolation) { - detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing") - .interpolation = std::move(interpolation); - return *this; - } - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::ov::backend(); } - std::string tag() const { return m_tag; } - cv::util::any params() const { return { m_desc }; } - // END(G-API's network parametrization API) - -protected: - std::string m_tag; - detail::ParamDesc m_desc; -}; - -} // namespace ov - -namespace wip { namespace ov { -/** - * @brief Ask G-API OpenVINO backend to run only inference of model provided. - * - * G-API OpenVINO backend will perform only the inference of the model provided - * without populating input and copying back output data. - * This mode is used to evaluate the pure inference performance of the model without - * taking into account the i/o data transfer. - */ -struct benchmark_mode { }; - -} // namespace ov -} // namespace wip - -} // namespace gapi - -namespace detail -{ - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.wip.ov.benchmark_mode"; } - }; -} - -} // namespace cv - -#endif // OPENCV_GAPI_INFER_OV_HPP diff --git a/modules/gapi/include/opencv2/gapi/infer/parsers.hpp b/modules/gapi/include/opencv2/gapi/infer/parsers.hpp deleted file mode 100644 index e39d6fd4c6..0000000000 --- a/modules/gapi/include/opencv2/gapi/infer/parsers.hpp +++ /dev/null @@ -1,138 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - - -#ifndef OPENCV_GAPI_PARSERS_HPP -#define OPENCV_GAPI_PARSERS_HPP - -#include // std::tuple - -#include -#include - -namespace cv { namespace gapi { -namespace nn { -namespace parsers { - using GRects = GArray; - using GDetections = std::tuple, GArray>; - - G_TYPED_KERNEL(GParseSSDBL, , float, int)>, - "org.opencv.nn.parsers.parseSSD_BL") { - static std::tuple outMeta(const GMatDesc&, const GOpaqueDesc&, float, int) { - return std::make_tuple(empty_array_desc(), empty_array_desc()); - } - }; - - G_TYPED_KERNEL(GParseSSD, , float, bool, bool)>, - "org.opencv.nn.parsers.parseSSD") { - static GArrayDesc outMeta(const GMatDesc&, const GOpaqueDesc&, float, bool, bool) { - return empty_array_desc(); - } - }; - - G_TYPED_KERNEL(GParseYolo, , float, float, std::vector)>, - "org.opencv.nn.parsers.parseYolo") { - static std::tuple outMeta(const GMatDesc&, const GOpaqueDesc&, - float, float, const std::vector&) { - return std::make_tuple(empty_array_desc(), empty_array_desc()); - } - static const std::vector& defaultAnchors() { - static std::vector anchors { - 0.57273f, 0.677385f, 1.87446f, 2.06253f, 3.33843f, 5.47434f, 7.88282f, 3.52778f, 9.77052f, 9.16828f - }; - return anchors; - } - }; -} // namespace parsers -} // namespace nn - -/** @brief Parses output of SSD network. - -Extracts detection information (box, confidence, label) from SSD output and -filters it by given confidence and label. - -@note Function textual ID is "org.opencv.nn.parsers.parseSSD_BL" - -@param in Input CV_32F tensor with {1,1,N,7} dimensions. -@param inSz Size to project detected boxes to (size of the input image). -@param confidenceThreshold If confidence of the -detection is smaller than confidence threshold, detection is rejected. -@param filterLabel If provided (!= -1), only detections with -given label will get to the output. -@return a tuple with a vector of detected boxes and a vector of appropriate labels. -*/ -GAPI_EXPORTS_W std::tuple, GArray> parseSSD(const GMat& in, - const GOpaque& inSz, - const float confidenceThreshold = 0.5f, - const int filterLabel = -1); - -/** @brief Parses output of SSD network. - -Extracts detection information (box, confidence) from SSD output and -filters it by given confidence and by going out of bounds. - -@note Function textual ID is "org.opencv.nn.parsers.parseSSD" - -@param in Input CV_32F tensor with {1,1,N,7} dimensions. -@param inSz Size to project detected boxes to (size of the input image). -@param confidenceThreshold If confidence of the -detection is smaller than confidence threshold, detection is rejected. -@param alignmentToSquare If provided true, bounding boxes are extended to squares. -The center of the rectangle remains unchanged, the side of the square is -the larger side of the rectangle. -@param filterOutOfBounds If provided true, out-of-frame boxes are filtered. -@return a vector of detected bounding boxes. -*/ -GAPI_EXPORTS_W GArray parseSSD(const GMat& in, - const GOpaque& inSz, - const float confidenceThreshold, - const bool alignmentToSquare, - const bool filterOutOfBounds); - -/** @brief Parses output of Yolo network. - -Extracts detection information (box, confidence, label) from Yolo output, -filters it by given confidence and performs non-maximum suppression for overlapping boxes. - -@note Function textual ID is "org.opencv.nn.parsers.parseYolo" - -@param in Input CV_32F tensor with {1,13,13,N} dimensions, N should satisfy: -\f[\texttt{N} = (\texttt{num_classes} + \texttt{5}) * \texttt{5},\f] -where num_classes - a number of classes Yolo network was trained with. -@param inSz Size to project detected boxes to (size of the input image). -@param confidenceThreshold If confidence of the -detection is smaller than confidence threshold, detection is rejected. -@param nmsThreshold Non-maximum suppression threshold which controls minimum -relative box intersection area required for rejecting the box with a smaller confidence. -If 1.f, nms is not performed and no boxes are rejected. -@param anchors Anchors Yolo network was trained with. -@note The default anchor values are specified for YOLO v2 Tiny as described in Intel Open Model Zoo -documentation. -@return a tuple with a vector of detected boxes and a vector of appropriate labels. -*/ -GAPI_EXPORTS_W std::tuple, GArray> parseYolo(const GMat& in, - const GOpaque& inSz, - const float confidenceThreshold = 0.5f, - const float nmsThreshold = 0.5f, - const std::vector& anchors - = nn::parsers::GParseYolo::defaultAnchors()); - -} // namespace gapi -} // namespace cv - -// Reimport parseSSD & parseYolo under their initial namespace -namespace cv { -namespace gapi { -namespace streaming { - -using cv::gapi::parseSSD; -using cv::gapi::parseYolo; - -} // namespace streaming -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_PARSERS_HPP diff --git a/modules/gapi/include/opencv2/gapi/media.hpp b/modules/gapi/include/opencv2/gapi/media.hpp deleted file mode 100644 index 1470f00d04..0000000000 --- a/modules/gapi/include/opencv2/gapi/media.hpp +++ /dev/null @@ -1,258 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_MEDIA_HPP -#define OPENCV_GAPI_MEDIA_HPP - -#include // unique_ptr<>, shared_ptr<> -#include // array<> -#include // function<> -#include // forward<>() - -#include -#include - -// Forward declaration -namespace cv { -namespace gapi { -namespace s11n { -struct IOStream; -struct IIStream; -} // namespace s11n -} // namespace gapi -} // namespace cv - -namespace cv { - -/** \addtogroup gapi_data_structures - * @{ - * - * @brief Extra G-API data structures used to pass input/output data - * to the graph for processing. - */ - -/** - * @brief cv::MediaFrame class represents an image/media frame - * obtained from an external source. - * - * cv::MediaFrame represents image data as specified in - * cv::MediaFormat. cv::MediaFrame is designed to be a thin wrapper over some - * external memory of buffer; the class itself provides an uniform - * interface over such types of memory. cv::MediaFrame wraps data from - * a camera driver or from a media codec and provides an abstraction - * layer over this memory to G-API. MediaFrame defines a compact interface - * to access and manage the underlying data; the implementation is - * fully defined by the associated Adapter (which is usually - * user-defined). - * - * @sa cv::RMat - */ -class GAPI_EXPORTS MediaFrame { -public: - /// This enum defines different types of cv::MediaFrame provided - /// access to the underlying data. Note that different flags can't - /// be combined in this version. - enum class Access { - R, ///< Access data for reading - W, ///< Access data for writing - }; - class IAdapter; - class View; - using AdapterPtr = std::unique_ptr; - - /** - * @brief Constructs an empty MediaFrame - * - * The constructed object has no any data associated with it. - */ - MediaFrame(); - - /** - * @brief Constructs a MediaFrame with the given - * Adapter. MediaFrame takes ownership over the passed adapter. - * - * @param p an unique pointer to instance of IAdapter derived class. - */ - explicit MediaFrame(AdapterPtr &&p); - - /** - * @overload - * @brief Constructs a MediaFrame with the given parameters for - * the Adapter. The adapter of type `T` is costructed on the fly. - * - * @param args list of arguments to construct an adapter of type - * `T`. - */ - template static cv::MediaFrame Create(Args&&... args); - - /** - * @brief Obtain access to the underlying data with the given - * mode. - * - * Depending on the associated Adapter and the data wrapped, this - * method may be cheap (e.g., the underlying memory is local) or - * costly (if the underlying memory is external or device - * memory). - * - * @param mode an access mode flag - * @return a MediaFrame::View object. The views should be handled - * carefully, refer to the MediaFrame::View documentation for details. - */ - View access(Access mode) const; - - /** - * @brief Returns a media frame descriptor -- the information - * about the media format, dimensions, etc. - * @return a cv::GFrameDesc - */ - cv::GFrameDesc desc() const; - - // FIXME: design a better solution - // Should be used only if the actual adapter provides implementation - /// @private -- exclude from the OpenCV documentation for now. - cv::util::any blobParams() const; - - /** - * @brief Casts and returns the associated MediaFrame adapter to - * the particular adapter type `T`, returns nullptr if the type is - * different. - * - * This method may be useful if the adapter type is known by the - * caller, and some lower level access to the memory is required. - * Depending on the memory type, it may be more efficient than - * access(). - * - * @return a pointer to the adapter object, nullptr if the adapter - * type is different. - */ - template T* get() const { - static_assert(std::is_base_of::value, - "T is not derived from cv::MediaFrame::IAdapter!"); - auto* adapter = getAdapter(); - GAPI_Assert(adapter != nullptr); - return dynamic_cast(adapter); - } - - /** - * @brief Serialize MediaFrame's data to a byte array. - * - * @note The actual logic is implemented by frame's adapter class. - * Does nothing by default. - * - * @param os Bytestream to store serialized MediaFrame data in. - */ - void serialize(cv::gapi::s11n::IOStream& os) const; - -private: - struct Priv; - std::shared_ptr m; - IAdapter* getAdapter() const; -}; - -template -inline cv::MediaFrame cv::MediaFrame::Create(Args&&... args) { - std::unique_ptr ptr(new T(std::forward(args)...)); - return cv::MediaFrame(std::move(ptr)); -} - -/** - * @brief Provides access to the MediaFrame's underlying data. - * - * This object contains the necessary information to access the pixel - * data of the associated MediaFrame: arrays of pointers and strides - * (distance between every plane row, in bytes) for every image - * plane, as defined in cv::MediaFormat. - * There may be up to four image planes in MediaFrame. - * - * Depending on the MediaFrame::Access flag passed in - * MediaFrame::access(), a MediaFrame::View may be read- or - * write-only. - * - * Depending on the MediaFrame::IAdapter implementation associated - * with the parent MediaFrame, writing to memory with - * MediaFrame::Access::R flag may have no effect or lead to - * undefined behavior. Same applies to reading the memory with - * MediaFrame::Access::W flag -- again, depending on the IAdapter - * implementation, the host-side buffer the view provides access to - * may have no current data stored in (so in-place editing of the - * buffer contents may not be possible). - * - * MediaFrame::View objects must be handled carefully, as an external - * resource associated with MediaFrame may be locked for the time the - * MediaFrame::View object exists. Obtaining MediaFrame::View should - * be seen as "map" and destroying it as "unmap" in the "map/unmap" - * idiom (applicable to OpenCL, device memory, remote - * memory). - * - * When a MediaFrame buffer is accessed for writing, and the memory - * under MediaFrame::View::Ptrs is altered, the data synchronization - * of a host-side and device/remote buffer is not guaranteed until the - * MediaFrame::View is destroyed. In other words, the real data on the - * device or in a remote target may be updated at the MediaFrame::View - * destruction only -- but it depends on the associated - * MediaFrame::IAdapter implementation. - */ -class GAPI_EXPORTS MediaFrame::View final { -public: - static constexpr const size_t MAX_PLANES = 4; - using Ptrs = std::array; - using Strides = std::array; // in bytes - using Callback = std::function; - - /// @private - View(Ptrs&& ptrs, Strides&& strs, Callback &&cb = [](){}); - - /// @private - View(const View&) = delete; - - /// @private - View(View&&) = default; - - /// @private - View& operator = (const View&) = delete; - - ~View(); - - Ptrs ptr; ///< Array of image plane pointers - Strides stride; ///< Array of image plane strides, in bytes. - -private: - Callback m_cb; -}; - -/** - * @brief An interface class for MediaFrame data adapters. - * - * Implement this interface to wrap media data in the MediaFrame. It - * makes sense to implement this class if there is a custom - * cv::gapi::wip::IStreamSource defined -- in this case, a stream - * source can produce MediaFrame objects with this adapter and the - * media data may be passed to graph without any copy. For example, a - * GStreamer-based stream source can implement an adapter over - * `GstBuffer` and G-API will transparently use it in the graph. - */ -class GAPI_EXPORTS MediaFrame::IAdapter { -public: - virtual ~IAdapter() = 0; - virtual cv::GFrameDesc meta() const = 0; - virtual MediaFrame::View access(MediaFrame::Access) = 0; - // FIXME: design a better solution - // The default implementation does nothing - virtual cv::util::any blobParams() const; - virtual void serialize(cv::gapi::s11n::IOStream&) { - GAPI_Error("Generic serialize method of MediaFrame::IAdapter does nothing by default. " - "Please, implement it in derived class to properly serialize the object."); - } - virtual void deserialize(cv::gapi::s11n::IIStream&) { - GAPI_Error("Generic deserialize method of MediaFrame::IAdapter does nothing by default. " - "Please, implement it in derived class to properly deserialize the object."); - } -}; -/** @} */ - -} //namespace cv - -#endif // OPENCV_GAPI_MEDIA_HPP diff --git a/modules/gapi/include/opencv2/gapi/oak/infer.hpp b/modules/gapi/include/opencv2/gapi/oak/infer.hpp deleted file mode 100644 index 4a1b9f6db6..0000000000 --- a/modules/gapi/include/opencv2/gapi/oak/infer.hpp +++ /dev/null @@ -1,66 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2022 Intel Corporation - -#ifndef OPENCV_GAPI_OAK_INFER_HPP -#define OPENCV_GAPI_OAK_INFER_HPP - -#include -#include -#include -#include - -#include -#include - -#include // GAPI_EXPORTS -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace oak { - -namespace detail { -/** -* @brief This structure contains description of inference parameters -* which is specific to OAK models. -*/ -struct ParamDesc { - std::string blob_file; -}; -} // namespace detail - -/** - * Contains description of inference parameters and kit of functions that - * fill this parameters. - */ -template class Params { -public: - /** @brief Class constructor. - - Constructs Params based on model information and sets default values for other - inference description parameters. - - @param model Path to model (.blob file) - */ - explicit Params(const std::string &model) { - desc.blob_file = model; - }; - - // BEGIN(G-API's network parametrization API) - GBackend backend() const { return cv::gapi::oak::backend(); } - std::string tag() const { return Net::tag(); } - cv::util::any params() const { return { desc }; } - // END(G-API's network parametrization API) - -protected: - detail::ParamDesc desc; -}; - -} // namespace oak -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_OAK_INFER_HPP diff --git a/modules/gapi/include/opencv2/gapi/oak/oak.hpp b/modules/gapi/include/opencv2/gapi/oak/oak.hpp deleted file mode 100644 index 8b56b8a365..0000000000 --- a/modules/gapi/include/opencv2/gapi/oak/oak.hpp +++ /dev/null @@ -1,158 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_OAK_HPP -#define OPENCV_GAPI_OAK_HPP - -#include // IStreamSource -#include // GKernelPackage -#include // GOptRunArgsP - -namespace cv { -namespace gapi { -namespace oak { - -// FIXME: copypasted from dai library -struct EncoderConfig { - /** - * Rate control mode specifies if constant or variable bitrate should be used (H264 / H265) - */ - enum class RateControlMode: int { CBR, VBR }; - - /** - * Encoding profile, H264, H265 or MJPEG - */ - enum class Profile: int { H264_BASELINE, H264_HIGH, H264_MAIN, H265_MAIN, MJPEG }; - /** - * Specifies preferred bitrate (kb) of compressed output bitstream - */ - std::int32_t bitrate = 8000; - /** - * Every x number of frames a keyframe will be inserted - */ - std::int32_t keyframeFrequency = 30; - /** - * Specifies maximum bitrate (kb) of compressed output bitstream - */ - std::int32_t maxBitrate = 8000; - /** - * Specifies number of B frames to be inserted - */ - std::int32_t numBFrames = 0; - /** - * This options specifies how many frames are available in this nodes pool (can help if - * receiver node is slow at consuming - */ - std::uint32_t numFramesPool = 4; - /** - * Encoding profile, H264, H265 or MJPEG - */ - Profile profile = Profile::H265_MAIN; - /** - * Value between 0-100% (approximates quality) - */ - std::int32_t quality = 80; - /** - * Lossless mode ([M]JPEG only) - */ - bool lossless = false; - /** - * Rate control mode specifies if constant or variable bitrate should be used (H264 / H265) - */ - RateControlMode rateCtrlMode = RateControlMode::CBR; - /** - * Input and compressed output frame width - */ - std::int32_t width = 1920; - /** - * Input and compressed output frame height - */ - std::int32_t height = 1080; - /** - * Frame rate - */ - float frameRate = 30.0f; -}; - -G_API_OP(GEncFrame, (GFrame, EncoderConfig)>, "org.opencv.oak.enc_frame") { - static GArrayDesc outMeta(const GFrameDesc&, const EncoderConfig&) { - return cv::empty_array_desc(); - } -}; - -G_API_OP(GSobelXY, , "org.opencv.oak.sobelxy") { - static GFrameDesc outMeta(const GFrameDesc& in, const cv::Mat&, const cv::Mat&) { - return in; - } -}; - -G_API_OP(GCopy, , "org.opencv.oak.copy") { - static GFrameDesc outMeta(const GFrameDesc& in) { - return in; - } -}; - -// FIXME: add documentation on operations below - -GAPI_EXPORTS GArray encode(const GFrame& in, const EncoderConfig&); - -GAPI_EXPORTS GFrame sobelXY(const GFrame& in, - const cv::Mat& hk, - const cv::Mat& vk); - -GAPI_EXPORTS GFrame copy(const GFrame& in); - -// OAK backend & kernels //////////////////////////////////////////////////////// -GAPI_EXPORTS cv::gapi::GBackend backend(); -GAPI_EXPORTS cv::gapi::GKernelPackage kernels(); - -// Camera object /////////////////////////////////////////////////////////////// - -struct GAPI_EXPORTS ColorCameraParams { - /** - * Format of the frame one gets from the camera - */ - bool interleaved = false; - - // FIXME: extend - enum class BoardSocket: int { RGB, BGR }; - - BoardSocket board_socket = BoardSocket::RGB; - - // FIXME: extend - enum class Resolution: int { THE_1080_P }; - - Resolution resolution = Resolution::THE_1080_P; -}; - -class GAPI_EXPORTS ColorCamera: public cv::gapi::wip::IStreamSource { - cv::MediaFrame m_dummy; - ColorCameraParams m_params; - - virtual bool pull(cv::gapi::wip::Data &data) override; - virtual GMetaArg descr_of() const override; - -public: - ColorCamera(); - explicit ColorCamera(const ColorCameraParams& params); -}; - -} // namespace oak -} // namespace gapi - -namespace detail { -template<> struct CompileArgTag { - static const char* tag() { return "gapi.oak.colorCameraParams"; } -}; - -template<> struct CompileArgTag { - static const char* tag() { return "gapi.oak.encoderConfig"; } -}; -} // namespace detail - -} // namespace cv - -#endif // OPENCV_GAPI_OAK_HPP diff --git a/modules/gapi/include/opencv2/gapi/ocl/core.hpp b/modules/gapi/include/opencv2/gapi/ocl/core.hpp deleted file mode 100644 index b79aace0ca..0000000000 --- a/modules/gapi/include/opencv2/gapi/ocl/core.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OCL_CORE_API_HPP -#define OPENCV_GAPI_OCL_CORE_API_HPP - -#include // GAPI_EXPORTS -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace core { -namespace ocl { - -GAPI_EXPORTS_W cv::GKernelPackage kernels(); - -} // namespace ocl -} // namespace core -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_OCL_CORE_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/ocl/goclkernel.hpp b/modules/gapi/include/opencv2/gapi/ocl/goclkernel.hpp deleted file mode 100644 index b09082282f..0000000000 --- a/modules/gapi/include/opencv2/gapi/ocl/goclkernel.hpp +++ /dev/null @@ -1,260 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GOCLKERNEL_HPP -#define OPENCV_GAPI_GOCLKERNEL_HPP - -#include -#include -#include -#include - -#include -#include -#include -#include - -// FIXME: namespace scheme for backends? -namespace cv { - -namespace gimpl -{ - // Forward-declare an internal class - class GOCLExecutable; -} // namespace gimpl - -namespace gapi -{ -/** - * @brief This namespace contains G-API OpenCL backend functions, structures, and symbols. - */ -namespace ocl -{ - /** - * \addtogroup gapi_std_backends G-API Standard Backends - * @{ - */ - /** - * @brief Get a reference to OCL backend. - * - * At the moment, the OCL backend is built atop of OpenCV - * "Transparent API" (T-API), see cv::UMat for details. - * - * @sa gapi_std_backends - */ - GAPI_EXPORTS cv::gapi::GBackend backend(); - /** @} */ -} // namespace ocl -} // namespace gapi - - -// Represents arguments which are passed to a wrapped OCL function -// FIXME: put into detail? -class GAPI_EXPORTS GOCLContext -{ -public: - // Generic accessor API - template - const T& inArg(int input) { return m_args.at(input).get(); } - - // Syntax sugar - const cv::UMat& inMat(int input); - cv::UMat& outMatR(int output); // FIXME: Avoid cv::Mat m = ctx.outMatR() - - const cv::Scalar& inVal(int input); - cv::Scalar& outValR(int output); // FIXME: Avoid cv::Scalar s = ctx.outValR() - template std::vector& outVecR(int output) // FIXME: the same issue - { - return outVecRef(output).wref(); - } - template T& outOpaqueR(int output) // FIXME: the same issue - { - return outOpaqueRef(output).wref(); - } - -protected: - detail::VectorRef& outVecRef(int output); - detail::OpaqueRef& outOpaqueRef(int output); - - std::vector m_args; - std::unordered_map m_results; - - - friend class gimpl::GOCLExecutable; -}; - -class GAPI_EXPORTS GOCLKernel -{ -public: - // This function is kernel's execution entry point (does the processing work) - using F = std::function; - - GOCLKernel(); - explicit GOCLKernel(const F& f); - - void apply(GOCLContext &ctx); - -protected: - F m_f; -}; - -// FIXME: This is an ugly ad-hoc implementation. TODO: refactor - -namespace detail -{ -template struct ocl_get_in; -template<> struct ocl_get_in -{ - static cv::UMat get(GOCLContext &ctx, int idx) { return ctx.inMat(idx); } -}; -template<> struct ocl_get_in -{ - static cv::Scalar get(GOCLContext &ctx, int idx) { return ctx.inVal(idx); } -}; -template struct ocl_get_in > -{ - static const std::vector& get(GOCLContext &ctx, int idx) { return ctx.inArg(idx).rref(); } -}; -template<> struct ocl_get_in -{ - static cv::MediaFrame get(GOCLContext &ctx, int idx) { return ctx.inArg(idx); } -}; -template struct ocl_get_in > -{ - static const U& get(GOCLContext &ctx, int idx) { return ctx.inArg(idx).rref(); } -}; -template struct ocl_get_in -{ - static T get(GOCLContext &ctx, int idx) { return ctx.inArg(idx); } -}; - -struct tracked_cv_umat{ - //TODO Think if T - API could reallocate UMat to a proper size - how do we handle this ? - //tracked_cv_umat(cv::UMat& m) : r{(m)}, original_data{m.getMat(ACCESS_RW).data} {} - tracked_cv_umat(cv::UMat& m) : r(m), original_data{ nullptr } {} - cv::UMat &r; // FIXME: It was a value (not a reference) before. - // Actually OCL backend should allocate its internal data! - uchar* original_data; - - operator cv::UMat& (){ return r;} - void validate() const{ - //if (r.getMat(ACCESS_RW).data != original_data) - //{ - // util::throw_error - // (std::logic_error - // ("OpenCV kernel output parameter was reallocated. \n" - // "Incorrect meta data was provided ?")); - //} - - } -}; - -#ifdef _MSC_VER -#pragma warning(push) -#pragma warning(disable: 4702) // unreachable code -#endif -template -void postprocess_ocl(Outputs&... outs) -{ - struct - { - void operator()(tracked_cv_umat* bm) { bm->validate(); } - void operator()(...) { } - - } validate; - //dummy array to unfold parameter pack - int dummy[] = { 0, (validate(&outs), 0)... }; - cv::util::suppress_unused_warning(dummy); -} -#ifdef _MSC_VER -#pragma warning(pop) -#endif - -template struct ocl_get_out; -template<> struct ocl_get_out -{ - static tracked_cv_umat get(GOCLContext &ctx, int idx) - { - auto& r = ctx.outMatR(idx); - return{ r }; - } -}; -template<> struct ocl_get_out -{ - static cv::Scalar& get(GOCLContext &ctx, int idx) - { - return ctx.outValR(idx); - } -}; -template struct ocl_get_out > -{ - static std::vector& get(GOCLContext &ctx, int idx) { return ctx.outVecR(idx); } -}; -template struct ocl_get_out > -{ - static U& get(GOCLContext &ctx, int idx) { return ctx.outOpaqueR(idx); } -}; - -template -struct OCLCallHelper; - -// FIXME: probably can be simplified with std::apply or analogue. -template -struct OCLCallHelper, std::tuple > -{ - template - struct call_and_postprocess - { - template - static void call(Inputs&&... ins, Outputs&&... outs) - { - //not using a std::forward on outs is deliberate in order to - //cause compilation error, by trying to bind rvalue references to lvalue references - Impl::run(std::forward(ins)..., outs...); - - postprocess_ocl(outs...); - } - }; - - template - static void call_impl(GOCLContext &ctx, detail::Seq, detail::Seq) - { - //TODO: Make sure that OpenCV kernels do not reallocate memory for output parameters - //by comparing it's state (data ptr) before and after the call. - //Convert own::Scalar to cv::Scalar before call kernel and run kernel - //convert cv::Scalar to own::Scalar after call kernel and write back results - call_and_postprocess::get(ctx, IIs))...>::call(ocl_get_in::get(ctx, IIs)..., ocl_get_out::get(ctx, OIs)...); - } - - static void call(GOCLContext &ctx) - { - call_impl(ctx, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } -}; - -} // namespace detail - -template -class GOCLKernelImpl: public cv::detail::OCLCallHelper, - public cv::detail::KernelTag -{ - using P = detail::OCLCallHelper; - -public: - using API = K; - - static cv::gapi::GBackend backend() { return cv::gapi::ocl::backend(); } - static cv::GOCLKernel kernel() { return GOCLKernel(&P::call); } -}; - -#define GAPI_OCL_KERNEL(Name, API) struct Name: public cv::GOCLKernelImpl - -} // namespace cv - -#endif // OPENCV_GAPI_GOCLKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/ocl/imgproc.hpp b/modules/gapi/include/opencv2/gapi/ocl/imgproc.hpp deleted file mode 100644 index 1bb5911b18..0000000000 --- a/modules/gapi/include/opencv2/gapi/ocl/imgproc.hpp +++ /dev/null @@ -1,27 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OCL_IMGPROC_API_HPP -#define OPENCV_GAPI_OCL_IMGPROC_API_HPP - -#include // GAPI_EXPORTS -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace imgproc { -namespace ocl { - - GAPI_EXPORTS GKernelPackage kernels(); - -} // namespace ocl -} // namespace imgproc -} // namespace gapi -} // namespace cv - - -#endif // OPENCV_GAPI_OCL_IMGPROC_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/opencv_includes.hpp b/modules/gapi/include/opencv2/gapi/opencv_includes.hpp deleted file mode 100644 index 7c2c42d8a2..0000000000 --- a/modules/gapi/include/opencv2/gapi/opencv_includes.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// This file is part of OpenCV project. - -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OPENCV_INCLUDES_HPP -#define OPENCV_GAPI_OPENCV_INCLUDES_HPP - -#if !defined(GAPI_STANDALONE) -# include -# include -# include -# include -#define GAPI_OWN_TYPES_LIST cv::gapi::own::Rect, \ - cv::gapi::own::Size, \ - cv::gapi::own::Point, \ - cv::gapi::own::Point2f, \ - cv::gapi::own::Scalar, \ - cv::gapi::own::Mat -#else // Without OpenCV -# include -# include // cv::gapi::own::Rect/Size/Point -# include // cv::gapi::own::Scalar -# include -// replacement of cv's structures: -namespace cv { - using Rect = gapi::own::Rect; - using Size = gapi::own::Size; - using Point = gapi::own::Point; - using Point2f = gapi::own::Point2f; - using Point3f = gapi::own::Point3f; - using Scalar = gapi::own::Scalar; - using Mat = gapi::own::Mat; -} // namespace cv -#define GAPI_OWN_TYPES_LIST cv::gapi::own::VoidType - -#endif // !defined(GAPI_STANDALONE) - -#endif // OPENCV_GAPI_OPENCV_INCLUDES_HPP diff --git a/modules/gapi/include/opencv2/gapi/operators.hpp b/modules/gapi/include/opencv2/gapi/operators.hpp deleted file mode 100644 index 6794b44b6e..0000000000 --- a/modules/gapi/include/opencv2/gapi/operators.hpp +++ /dev/null @@ -1,70 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OPERATORS_HPP -#define OPENCV_GAPI_OPERATORS_HPP - -#include -#include - -namespace cv -{ -GAPI_EXPORTS cv::GMat operator+(const cv::GMat& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator+(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator+(const cv::GScalar& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator-(const cv::GMat& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator-(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator-(const cv::GScalar& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator*(const cv::GMat& lhs, float rhs); -GAPI_EXPORTS cv::GMat operator*(float lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator*(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator*(const cv::GScalar& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator/(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator/(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator/(const cv::GMat& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator&(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator|(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator^(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator~(const cv::GMat& lhs); - -GAPI_EXPORTS cv::GMat operator&(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator|(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator^(const cv::GScalar& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator&(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator|(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator^(const cv::GMat& lhs, const cv::GScalar& rhs); - -GAPI_EXPORTS cv::GMat operator>(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator>=(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator<(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator<=(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator==(const cv::GMat& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator!=(const cv::GMat& lhs, const cv::GMat& rhs); - -GAPI_EXPORTS cv::GMat operator>(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator>=(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator<(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator<=(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator==(const cv::GMat& lhs, const cv::GScalar& rhs); -GAPI_EXPORTS cv::GMat operator!=(const cv::GMat& lhs, const cv::GScalar& rhs); - -GAPI_EXPORTS cv::GMat operator>(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator>=(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator<(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator<=(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator==(const cv::GScalar& lhs, const cv::GMat& rhs); -GAPI_EXPORTS cv::GMat operator!=(const cv::GScalar& lhs, const cv::GMat& rhs); -} // cv - -#endif // OPENCV_GAPI_OPERATORS_HPP diff --git a/modules/gapi/include/opencv2/gapi/ot.hpp b/modules/gapi/include/opencv2/gapi/ot.hpp deleted file mode 100644 index b73d7e6ee0..0000000000 --- a/modules/gapi/include/opencv2/gapi/ot.hpp +++ /dev/null @@ -1,194 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2023 Intel Corporation - -#ifndef OPENCV_GAPI_OT_HPP -#define OPENCV_GAPI_OT_HPP - -#include -#include -#include - -namespace cv { -namespace gapi { -/** - * @brief This namespace contains G-API Operation Types for - * VAS Object Tracking module functionality. - */ -namespace ot { - -/** - * @enum TrackingStatus - * - * Tracking status twin for vas::ot::TrackingStatus - */ -enum TrackingStatus -{ - NEW = 0, /**< The object is newly added. */ - TRACKED, /**< The object is being tracked. */ - LOST /**< The object gets lost now. The object can be tracked again - by specifying detected object manually. */ -}; - -struct GAPI_EXPORTS_W_SIMPLE ObjectTrackerParams -{ - /** - * Maximum number of trackable objects in a frame. - * Valid range: 1 <= max_num_objects. Or it can be -1 if there is no limitation - * of maximum number in X86. KMB/TBH has limitation up to 1024. - * Default value is -1 which means there is no limitation in X86. KMB/TBH is -1 means 200. - */ - GAPI_PROP_RW int32_t max_num_objects = -1; - - /** - * Input color format. Supports 0(BGR), 1(NV12), 2(BGRX) and 4(I420) - */ - GAPI_PROP_RW int32_t input_image_format = 0; - - /** - * Specifies whether tracker to use detection class for keeping id of an object. - * If it is true, new detection will be associated from previous tracking only when - * those two have same class. - * class id of an object is fixed across video frames. - * If it is false, new detection can be associated across different-class objects. - * In this case, the class id of an object may change across video frames depending on the tracker input. - * It is recommended to turn this option off when it is likely that detector confuses the class of object. - * For example, when detector confuses bicycle and motorbike. Turning this option off will increase - * the tracking reliability as tracker will ignore the class label of detector. - * @n - * Default value is true. - */ - GAPI_PROP_RW bool tracking_per_class = true; - - bool operator==(const ObjectTrackerParams& other) const - { - return max_num_objects == other.max_num_objects - && input_image_format == other.input_image_format - && tracking_per_class == other.tracking_per_class; - } -}; - -using GTrackedInfo = std::tuple, cv::GArray, cv::GArray, cv::GArray>; - -G_API_OP(GTrackFromMat, , cv::GArray, float)>, "com.intel.track_from_mat") -{ - static std::tuple outMeta(cv::GMatDesc, cv::GArrayDesc, cv::GArrayDesc, float) - { - return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc(), - cv::empty_array_desc(), cv::empty_array_desc()); - } -}; - -G_API_OP(GTrackFromFrame, , cv::GArray, float)>, "com.intel.track_from_frame") -{ - static std::tuple outMeta(cv::GFrameDesc, cv::GArrayDesc, cv::GArrayDesc, float) - { - return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc(), - cv::empty_array_desc(), cv::empty_array_desc()); - } -}; - -/** - * @brief Tracks objects with video frames. - * If a detected object is overlapped enough with one of tracked object, the tracked object's - * informationis updated with the input detected object. - * On the other hand, if a detected object is overlapped with none of tracked objects, - * the detected object is newly added and ObjectTracker starts to track the object. - * In zero term tracking type, ObjectTracker clears tracked objects in case that empty - * list of detected objects is passed in. - * - * @param mat Input frame. - * @param detected_rects Detected objects rectangles in the input frame. - * @param detected_class_labels Detected objects class labels in the input frame. - * @param delta Frame_delta_t Delta time between two consecutive tracking in seconds. - * The valid range is [0.005 ~ 0.5]. - * @return Tracking results of target objects. - * cv::GArray Array of rectangles for tracked objects. - * cv::GArray Array of detected objects labels. - * cv::GArray Array of tracking IDs for objects. - * Numbering sequence starts from 1. - * The value 0 means the tracking ID of this object has - * not been assigned. - * cv::GArray Array of tracking statuses for objects. - */ -GAPI_EXPORTS_W std::tuple, - cv::GArray, - cv::GArray, - cv::GArray> - track(const cv::GMat& mat, - const cv::GArray& detected_rects, - const cv::GArray& detected_class_labels, - float delta); - - -/** - @overload - * @brief Tracks objects with video frames. Overload of track(...) for frame as GFrame. - * - * @param frame Input frame. - * @param detected_rects Detected objects rectangles in the input frame. - * @param detected_class_labels Detected objects class labels in the input frame. - * @param delta Frame_delta_t Delta time between two consecutive tracking in seconds. - * The valid range is [0.005 ~ 0.5]. - * @return Tracking results of target objects. - * @return Tracking results of target objects. - * cv::GArray Array of rectangles for tracked objects. - * cv::GArray Array of detected objects labels. - * cv::GArray Array of tracking IDs for objects. - * Numbering sequence starts from 1. - * The value 0 means the tracking ID of this object has - * not been assigned. - * cv::GArray Array of tracking statuses for objects. - */ -GAPI_EXPORTS_W std::tuple, - cv::GArray, - cv::GArray, - cv::GArray> - track(const cv::GFrame& frame, - const cv::GArray& detected_rects, - const cv::GArray& detected_class_labels, - float delta); -} // namespace ot -} // namespace gapi -} // namespace cv - -// FIXME: move to a separate file? -namespace cv -{ -namespace detail -{ -template<> struct CompileArgTag -{ - static const char* tag() - { - return "cv.gapi.ot.object_tracker_params"; - } -}; -} // namespace detail - -namespace gapi -{ -namespace s11n -{ -namespace detail -{ -template<> struct S11N { - static void serialize(IOStream &os, const cv::gapi::ot::ObjectTrackerParams &p) { - os << p. max_num_objects << p.input_image_format << p.tracking_per_class; - } - static cv::gapi::ot::ObjectTrackerParams deserialize(IIStream &is) { - cv::gapi::ot::ObjectTrackerParams p; - is >> p. max_num_objects >> p.input_image_format >> p.tracking_per_class; - return p; - } -}; -} // namespace detail -} // namespace s11n -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_OT_HPP diff --git a/modules/gapi/include/opencv2/gapi/own/assert.hpp b/modules/gapi/include/opencv2/gapi/own/assert.hpp deleted file mode 100644 index ab2fb896f1..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/assert.hpp +++ /dev/null @@ -1,60 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_OWN_ASSERT_HPP -#define OPENCV_GAPI_OWN_ASSERT_HPP - -#include - -#define GAPI_DbgAssertNoOp(expr) { \ - constexpr bool _assert_tmp = false && (expr); \ - cv::util::suppress_unused_warning(_assert_tmp); \ -} - -#if !defined(GAPI_STANDALONE) -#include -#define GAPI_Assert CV_Assert - -#if defined _DEBUG || defined CV_STATIC_ANALYSIS -# define GAPI_DbgAssert CV_DbgAssert -#else -# define GAPI_DbgAssert(expr) GAPI_DbgAssertNoOp(expr) -#endif - -#define GAPI_Error(msg) CV_Error(cv::Error::StsError, msg) - -#else -#include -#include -#include - -namespace detail -{ - [[noreturn]] inline void assert_abort(const char* str, int line, const char* file, const char* func) - { - std::stringstream ss; - ss << file << ":" << line << ": Assertion " << str << " in function " << func << " failed\n"; - cv::util::throw_error(std::logic_error(ss.str())); - } -} - -#define GAPI_Assert(expr) \ -{ if (!(expr)) ::detail::assert_abort(#expr, __LINE__, __FILE__, __func__); } - -#ifdef NDEBUG -# define GAPI_DbgAssert(expr) GAPI_DbgAssertNoOp(expr) -#else -# define GAPI_DbgAssert(expr) GAPI_Assert(expr) -#endif - -#define GAPI_Error(msg) { \ - ::detail::assert_abort(msg, __LINE__, __FILE__, __func__); \ -} - -#endif // GAPI_STANDALONE - -#endif // OPENCV_GAPI_OWN_ASSERT_HPP diff --git a/modules/gapi/include/opencv2/gapi/own/convert.hpp b/modules/gapi/include/opencv2/gapi/own/convert.hpp deleted file mode 100644 index 7bebec9cf0..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/convert.hpp +++ /dev/null @@ -1,55 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OWN_CONVERT_HPP -#define OPENCV_GAPI_OWN_CONVERT_HPP - -#if !defined(GAPI_STANDALONE) - -#include -#include - -namespace cv -{ - template - std::vector to_own(const cv::MatSize &sz) { - std::vector result(sz.dims()); - for (int i = 0; i < sz.dims(); i++) { - // Note: cv::MatSize is not iterable - result[i] = static_cast(sz[i]); - } - return result; - } - - cv::gapi::own::Mat to_own(Mat&&) = delete; - - inline cv::gapi::own::Mat to_own(Mat const& m) { - return (m.dims <= 2) - ? cv::gapi::own::Mat{m.rows, m.cols, m.type(), m.data, m.step} - : cv::gapi::own::Mat{to_own(m.size), m.type(), m.data}; - } - -namespace gapi -{ -namespace own -{ - - inline cv::Mat to_ocv(Mat const& m) { - return m.dims.empty() - ? cv::Mat{m.rows, m.cols, m.type(), m.data, m.step} - : cv::Mat{m.dims, m.type(), m.data}; - } - - cv::Mat to_ocv(Mat&&) = delete; - -} // namespace own -} // namespace gapi -} // namespace cv - -#endif // !defined(GAPI_STANDALONE) - -#endif // OPENCV_GAPI_OWN_CONVERT_HPP diff --git a/modules/gapi/include/opencv2/gapi/own/cvdefs.hpp b/modules/gapi/include/opencv2/gapi/own/cvdefs.hpp deleted file mode 100644 index d3bef98e98..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/cvdefs.hpp +++ /dev/null @@ -1,166 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_CV_DEFS_HPP -#define OPENCV_GAPI_CV_DEFS_HPP - -#if defined(GAPI_STANDALONE) -// Simulate OpenCV definitions taken from various -// OpenCV interface headers if G-API is built in a -// standalone mode. - -// interface.h: - -typedef unsigned char uchar; -typedef char schar; - -typedef unsigned short ushort; - -#define CV_USRTYPE1 (void)"CV_USRTYPE1 support has been dropped in OpenCV 4.0" - -#define CV_CN_MAX 512 -#define CV_CN_SHIFT 3 -#define CV_DEPTH_MAX (1 << CV_CN_SHIFT) - -#define CV_8U 0 -#define CV_8S 1 -#define CV_16U 2 -#define CV_16S 3 -#define CV_32S 4 -#define CV_32F 5 -#define CV_64F 6 -#define CV_16F 7 - -#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1) -#define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK) - -#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT)) -#define CV_MAKE_TYPE CV_MAKETYPE - -#define CV_8UC1 CV_MAKETYPE(CV_8U,1) -#define CV_8UC2 CV_MAKETYPE(CV_8U,2) -#define CV_8UC3 CV_MAKETYPE(CV_8U,3) -#define CV_8UC4 CV_MAKETYPE(CV_8U,4) -#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n)) - -#define CV_8SC1 CV_MAKETYPE(CV_8S,1) -#define CV_8SC2 CV_MAKETYPE(CV_8S,2) -#define CV_8SC3 CV_MAKETYPE(CV_8S,3) -#define CV_8SC4 CV_MAKETYPE(CV_8S,4) -#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n)) - -#define CV_16UC1 CV_MAKETYPE(CV_16U,1) -#define CV_16UC2 CV_MAKETYPE(CV_16U,2) -#define CV_16UC3 CV_MAKETYPE(CV_16U,3) -#define CV_16UC4 CV_MAKETYPE(CV_16U,4) -#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n)) - -#define CV_16SC1 CV_MAKETYPE(CV_16S,1) -#define CV_16SC2 CV_MAKETYPE(CV_16S,2) -#define CV_16SC3 CV_MAKETYPE(CV_16S,3) -#define CV_16SC4 CV_MAKETYPE(CV_16S,4) -#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n)) - -#define CV_32SC1 CV_MAKETYPE(CV_32S,1) -#define CV_32SC2 CV_MAKETYPE(CV_32S,2) -#define CV_32SC3 CV_MAKETYPE(CV_32S,3) -#define CV_32SC4 CV_MAKETYPE(CV_32S,4) -#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n)) - -#define CV_16FC1 CV_MAKETYPE(CV_16F,1) -#define CV_16FC2 CV_MAKETYPE(CV_16F,2) -#define CV_16FC3 CV_MAKETYPE(CV_16F,3) -#define CV_16FC4 CV_MAKETYPE(CV_16F,4) -#define CV_16FC(n) CV_MAKETYPE(CV_16F,(n)) - -#define CV_32FC1 CV_MAKETYPE(CV_32F,1) -#define CV_32FC2 CV_MAKETYPE(CV_32F,2) -#define CV_32FC3 CV_MAKETYPE(CV_32F,3) -#define CV_32FC4 CV_MAKETYPE(CV_32F,4) -#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n)) - -#define CV_64FC1 CV_MAKETYPE(CV_64F,1) -#define CV_64FC2 CV_MAKETYPE(CV_64F,2) -#define CV_64FC3 CV_MAKETYPE(CV_64F,3) -#define CV_64FC4 CV_MAKETYPE(CV_64F,4) -#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n)) - -// cvdef.h: - -#ifndef CV_ALWAYS_INLINE -# if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) -# define CV_ALWAYS_INLINE inline __attribute__((always_inline)) -# elif defined(_MSC_VER) -# define CV_ALWAYS_INLINE __forceinline -# else -# define CV_ALWAYS_INLINE inline -# endif -#endif - -#define CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT) -#define CV_MAT_CN(flags) ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1) -#define CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1) -#define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK) -#define CV_MAT_CONT_FLAG_SHIFT 14 -#define CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT) -#define CV_IS_MAT_CONT(flags) ((flags) & CV_MAT_CONT_FLAG) -#define CV_IS_CONT_MAT CV_IS_MAT_CONT -#define CV_SUBMAT_FLAG_SHIFT 15 -#define CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT) -#define CV_IS_SUBMAT(flags) ((flags) & CV_MAT_SUBMAT_FLAG) - -//** Size of each channel item, -// 0x8442211 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */ -#define CV_ELEM_SIZE1(type) \ - ((((sizeof(size_t)<<28)|0x8442211) >> CV_MAT_DEPTH(type)*4) & 15) - -#define CV_MAT_TYPE(flags) ((flags) & CV_MAT_TYPE_MASK) - -/** 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */ -#define CV_ELEM_SIZE(type) \ - (CV_MAT_CN(type) << ((((sizeof(size_t)/4+1)*16384|0x3a50) >> CV_MAT_DEPTH(type)*2) & 3)) - -#ifndef CV_OVERRIDE -# define CV_OVERRIDE override -#endif - -// base.h: -namespace cv -{ -enum BorderTypes { - BORDER_CONSTANT = 0, //!< `iiiiii|abcdefgh|iiiiiii` with some specified `i` - BORDER_REPLICATE = 1, //!< `aaaaaa|abcdefgh|hhhhhhh` - BORDER_REFLECT = 2, //!< `fedcba|abcdefgh|hgfedcb` - BORDER_WRAP = 3, //!< `cdefgh|abcdefgh|abcdefg` - BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba` - BORDER_TRANSPARENT = 5, //!< `uvwxyz|abcdefgh|ijklmno` - - BORDER_REFLECT101 = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101 - BORDER_DEFAULT = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101 - BORDER_ISOLATED = 16 //!< do not look outside of ROI -}; -// imgproc.hpp: -enum InterpolationFlags{ - INTER_NEAREST = 0, - INTER_LINEAR = 1, - INTER_CUBIC = 2, - INTER_AREA = 3, - INTER_LANCZOS4 = 4, - INTER_LINEAR_EXACT = 5, - INTER_MAX = 7, -}; -} // namespace cv - -static inline int cvFloor( double value ) -{ - int i = (int)value; - return i - (i > value); -} - -#endif // defined(GAPI_STANDALONE) - -#endif // OPENCV_GAPI_CV_DEFS_HPP diff --git a/modules/gapi/include/opencv2/gapi/own/exports.hpp b/modules/gapi/include/opencv2/gapi/own/exports.hpp deleted file mode 100644 index c36f4003d0..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/exports.hpp +++ /dev/null @@ -1,42 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OWN_TYPES_HPP -#define OPENCV_GAPI_OWN_TYPES_HPP - -# if defined(__OPENCV_BUILD) -# include -# define GAPI_EXPORTS CV_EXPORTS - /* special informative macros for wrapper generators */ -# define GAPI_PROP CV_PROP -# define GAPI_PROP_RW CV_PROP_RW -# define GAPI_WRAP CV_WRAP -# define GAPI_EXPORTS_W_SIMPLE CV_EXPORTS_W_SIMPLE -# define GAPI_EXPORTS_W CV_EXPORTS_W -# else -# define GAPI_PROP -# define GAPI_PROP_RW -# define GAPI_WRAP -# define GAPI_EXPORTS -# define GAPI_EXPORTS_W_SIMPLE -# define GAPI_EXPORTS_W - -#if 0 // Note: the following version currently is not needed for non-OpenCV build -# if defined _WIN32 -# define GAPI_EXPORTS __declspec(dllexport) -# elif defined __GNUC__ && __GNUC__ >= 4 -# define GAPI_EXPORTS __attribute__ ((visibility ("default"))) -# endif - -# ifndef GAPI_EXPORTS -# define GAPI_EXPORTS -# endif -#endif - -# endif - -#endif // OPENCV_GAPI_OWN_TYPES_HPP diff --git a/modules/gapi/include/opencv2/gapi/own/mat.hpp b/modules/gapi/include/opencv2/gapi/own/mat.hpp deleted file mode 100644 index ce9c0bf362..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/mat.hpp +++ /dev/null @@ -1,354 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OWN_MAT_HPP -#define OPENCV_GAPI_OWN_MAT_HPP - -#include -#include -#include -#include -#include - -#include //std::shared_ptr -#include //std::memcpy -#include //std::accumulate -#include -#include - -namespace cv { namespace gapi { namespace own { - namespace detail { - template - void assign_row(void* ptr, int cols, Scalar const& s) - { - auto p = static_cast(ptr); - for (int c = 0; c < cols; c++) - { - for (int ch = 0; ch < channels; ch++) - { - p[c * channels + ch] = saturate(s[ch], roundd); - } - } - } - - inline size_t default_step(int type, int cols) - { - return CV_ELEM_SIZE(type) * cols; - } - //Matrix header, i.e. fields that are unique to each Mat object. - //Devoted class is needed to implement custom behavior on move (erasing state of moved from object) - struct MatHeader{ - enum { AUTO_STEP = 0}; - enum { TYPE_MASK = 0x00000FFF }; - - MatHeader() = default; - - MatHeader(int _rows, int _cols, int type, void* _data, size_t _step) - : flags((type & TYPE_MASK)), rows(_rows), cols(_cols), data((uchar*)_data), step(_step == AUTO_STEP ? detail::default_step(type, _cols) : _step) - {} - - MatHeader(const std::vector &_dims, int type, void* _data) - : flags((type & TYPE_MASK)), data((uchar*)_data), step(0), dims(_dims) - {} - - MatHeader(const MatHeader& ) = default; - MatHeader(MatHeader&& src) : MatHeader(src) // reuse copy constructor here - { - MatHeader empty; //give it a name to call copy(not move) assignment below - src = empty; - } - MatHeader& operator=(const MatHeader& ) = default; - MatHeader& operator=(MatHeader&& src) - { - *this = src; //calling a copy assignment here, not move one - MatHeader empty; //give it a name to call copy(not move) assignment below - src = empty; - return *this; - } - /*! includes several bit-fields: - - depth - - number of channels - */ - int flags = 0; - - //! the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions - int rows = 0, cols = 0; - //! pointer to the data - uchar* data = nullptr; - size_t step = 0; - //! dimensions (ND-case) - std::vector dims; - }; - } // namespace detail - //concise version of cv::Mat suitable for GAPI needs (used when no dependence on OpenCV is required) - class Mat : public detail::MatHeader{ - public: - - Mat() = default; - - /** @overload - @param _rows Number of rows in a 2D array. - @param _cols Number of columns in a 2D array. - @param _type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or - CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. - @param _data Pointer to the user data. Matrix constructors that take data and step parameters do not - allocate matrix data. Instead, they just initialize the matrix header that points to the specified - data, which means that no data is copied. This operation is very efficient and can be used to - process external data using OpenCV functions. The external data is not automatically deallocated, so - you should take care of it. - @param _step Number of bytes each matrix row occupies. The value should include the padding bytes at - the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed - and the actual step is calculated as cols*elemSize(). See Mat::elemSize. - */ - Mat(int _rows, int _cols, int _type, void* _data, size_t _step = AUTO_STEP) - : MatHeader (_rows, _cols, _type, _data, _step) - {} - - Mat(const std::vector &_dims, int _type, void* _data) - : MatHeader (_dims, _type, _data) - {} - - Mat(std::vector &&_dims, int _type, void* _data) - : MatHeader (std::move(_dims), _type, _data) - {} - - Mat(Mat const& src, const Rect& roi ) - : Mat(src) - { - rows = roi.height; - cols = roi.width; - data = ptr(roi.y, roi.x); - } - - Mat(Mat const& ) = default; - Mat(Mat&& ) = default; - - Mat& operator=(Mat const& ) = default; - Mat& operator=(Mat&& ) = default; - - /** @brief Sets all or some of the array elements to the specified value. - @param s Assigned scalar converted to the actual array type. - */ - Mat& operator = (const Scalar& s) - { - constexpr unsigned max_channels = 4; //Scalar can't fit more than 4 - using func_p_t = void (*)(void*, int, Scalar const&); - using detail::assign_row; - #define TABLE_ENTRY(type) {assign_row, assign_row, assign_row, assign_row} - static constexpr func_p_t func_tbl[][max_channels] = { - TABLE_ENTRY(uchar), - TABLE_ENTRY(schar), - TABLE_ENTRY(ushort), - TABLE_ENTRY(short), - TABLE_ENTRY(int), - TABLE_ENTRY(float), - TABLE_ENTRY(double) - }; - #undef TABLE_ENTRY - - static_assert(CV_8U == 0 && CV_8S == 1 && CV_16U == 2 && CV_16S == 3 - && CV_32S == 4 && CV_32F == 5 && CV_64F == 6, - "OCV type ids used as indexes to array, thus exact numbers are important!" - ); - - const auto depth = static_cast(this->depth()); - GAPI_Assert(depth < sizeof(func_tbl)/sizeof(func_tbl[0])); - - if (dims.empty()) - { - const auto channels = static_cast(this->channels()); - GAPI_Assert(channels <= max_channels); - - auto* f = func_tbl[depth][channels - 1]; - for (int r = 0; r < rows; ++r) - { - (*f)(static_cast(ptr(r)), cols, s ); - } - } - else - { - auto* f = func_tbl[depth][0]; - // FIXME: better to refactor assign_row to use std::size_t by default - (*f)(static_cast(data), static_cast(total()), s); - } - return *this; - } - - /** @brief Returns the matrix element size in bytes. - - The method returns the matrix element size in bytes. For example, if the matrix type is CV_16SC3 , - the method returns 3\*sizeof(short) or 6. - */ - size_t elemSize() const - { - return CV_ELEM_SIZE(type()); - } - /** @brief Returns the type of a matrix element. - - The method returns a matrix element type. This is an identifier compatible with the CvMat type - system, like CV_16SC3 or 16-bit signed 3-channel array, and so on. - */ - int type() const {return CV_MAT_TYPE(flags);} - - /** @brief Returns the depth of a matrix element. - - The method returns the identifier of the matrix element depth (the type of each individual channel). - For example, for a 16-bit signed element array, the method returns CV_16S . A complete list of - matrix types contains the following values: - - CV_8U - 8-bit unsigned integers ( 0..255 ) - - CV_8S - 8-bit signed integers ( -128..127 ) - - CV_16U - 16-bit unsigned integers ( 0..65535 ) - - CV_16S - 16-bit signed integers ( -32768..32767 ) - - CV_32S - 32-bit signed integers ( -2147483648..2147483647 ) - - CV_32F - 32-bit floating-point numbers ( -FLT_MAX..FLT_MAX, INF, NAN ) - - CV_64F - 64-bit floating-point numbers ( -DBL_MAX..DBL_MAX, INF, NAN ) - */ - int depth() const {return CV_MAT_DEPTH(flags);} - - /** @brief Returns the number of matrix channels. - - The method returns the number of matrix channels. - If matrix is N-dimensional, -1 is returned. - */ - int channels() const {return dims.empty() ? CV_MAT_CN(flags) : -1;} - - /** - @param _rows New number of rows. - @param _cols New number of columns. - @param _type New matrix type. - */ - void create(int _rows, int _cols, int _type) - { - create(Size{_cols, _rows}, _type); - } - /** @overload - @param _size Alternative new matrix size specification: Size(cols, rows) - @param _type New matrix type. - */ - void create(Size _size, int _type) - { - GAPI_Assert(_size.height >= 0 && _size.width >= 0); - if (_size != Size{cols, rows} ) - { - Mat tmp{_size.height, _size.width, _type, nullptr}; - tmp.memory.reset(new uchar[ tmp.step * tmp.rows], [](uchar * p){delete[] p;}); - tmp.data = tmp.memory.get(); - - *this = std::move(tmp); - } - } - - void create(const std::vector &_dims, int _type) - { - // FIXME: make a proper reallocation-on-demands - // WARNING: no tensor views, so no strides - Mat tmp{_dims, _type, nullptr}; - // FIXME: this accumulate duplicates a lot - const auto sz = std::accumulate(_dims.begin(), _dims.end(), 1, std::multiplies()); - tmp.memory.reset(new uchar[CV_ELEM_SIZE(_type)*sz], [](uchar * p){delete[] p;}); - tmp.data = tmp.memory.get(); - *this = std::move(tmp); - } - - /** @brief Creates a full copy of the matrix and the underlying data. - - The method creates a full copy of the matrix. The original step[] is not taken into account. - So, the copy has a continuous buffer occupying total() * elemSize() bytes. - */ - Mat clone() const - { - Mat m; - copyTo(m); - return m; - } - - /** @brief Copies the matrix to another one. - - The method copies the matrix data to another matrix. Before copying the data, the method invokes : - @code - m.create(this->size(), this->type()); - @endcode - so that the destination matrix is reallocated if needed. While m.copyTo(m); works flawlessly, the - function does not handle the case of a partial overlap between the source and the destination - matrices. - */ - void copyTo(Mat& dst) const - { - if (dims.empty()) - { - dst.create(rows, cols, type()); - for (int r = 0; r < rows; ++r) - { - std::copy_n(ptr(r), detail::default_step(type(),cols), dst.ptr(r)); - } - } - else - { - dst.create(dims, depth()); - std::copy_n(data, total()*elemSize(), data); - } - } - - /** @brief Returns true if the array has no elements. - - The method returns true if Mat::total() is 0 or if Mat::data is NULL. Because of pop_back() and - resize() methods `M.total() == 0` does not imply that `M.data == NULL`. - */ - bool empty() const - { - return data == 0 || total() == 0; - } - - /** @brief Returns the total number of array elements. - - The method returns the number of array elements (a number of pixels if the array represents an - image). - */ - size_t total() const - { - return dims.empty() - ? (static_cast(rows) * cols) - : std::accumulate(dims.begin(), dims.end(), static_cast(1), std::multiplies()); - } - - /** @overload - @param roi Extracted submatrix specified as a rectangle. - */ - Mat operator()( const Rect& roi ) const - { - return Mat{*this, roi}; - } - - - /** @brief Returns a pointer to the specified matrix row. - - The methods return `uchar*` or typed pointer to the specified matrix row. See the sample in - Mat::isContinuous to know how to use these methods. - @param row Index along the dimension 0 - @param col Index along the dimension 1 - */ - uchar* ptr(int row, int col = 0) - { - return const_cast(const_cast(this)->ptr(row,col)); - } - /** @overload */ - const uchar* ptr(int row, int col = 0) const - { - return data + step * row + CV_ELEM_SIZE(type()) * col; - } - - - private: - //actual memory allocated for storage, or nullptr if object is non owning view to over memory - std::shared_ptr memory; - }; - -} //namespace own -} //namespace gapi -} //namespace cv - -#endif /* OPENCV_GAPI_OWN_MAT_HPP */ diff --git a/modules/gapi/include/opencv2/gapi/own/saturate.hpp b/modules/gapi/include/opencv2/gapi/own/saturate.hpp deleted file mode 100644 index 74eaecf57e..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/saturate.hpp +++ /dev/null @@ -1,83 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_OWN_SATURATE_HPP -#define OPENCV_GAPI_OWN_SATURATE_HPP - -#include - -#include - -#include -#include - -namespace cv { namespace gapi { namespace own { -//----------------------------- -// -// Numeric cast with saturation -// -//----------------------------- - -template::value && - std::is_integral::value && - std::is_integral::value> > -static CV_ALWAYS_INLINE DST saturate(SRC x) -{ - if (sizeof(DST) > sizeof(SRC)) - return static_cast(x); - - // compiler must recognize this saturation, - // so compile saturate(a + b) with adds - // instruction (e.g.: _mm_adds_epi16 if x86) - return x < std::numeric_limits::min()? - std::numeric_limits::min(): - x > std::numeric_limits::max()? - std::numeric_limits::max(): - static_cast(x); -} -template -static CV_ALWAYS_INLINE T saturate(T x) -{ - return x; -} - -template::value, bool> = true > -static CV_ALWAYS_INLINE DST saturate(SRC x, R) -{ - return static_cast(x); -} -template::value && - std::is_integral::value , bool> = true > -static CV_ALWAYS_INLINE DST saturate(SRC x, R) -{ - return saturate(x); -} -// Note, that OpenCV rounds differently: -// - like std::round() for add, subtract -// - like std::rint() for multiply, divide -template::value && - std::is_floating_point::value, bool> = true > -static CV_ALWAYS_INLINE DST saturate(SRC x, R round) -{ - int ix = static_cast(round(x)); - return saturate(ix); -} - -// explicit suffix 'd' for double type -inline double ceild(double x) { return ceil(x); } -inline double floord(double x) { return floor(x); } -inline double roundd(double x) { return round(x); } -inline double rintd(double x) { return rint(x); } - -} //namespace own -} //namespace gapi -} //namespace cv -#endif /* OPENCV_GAPI_OWN_SATURATE_HPP */ diff --git a/modules/gapi/include/opencv2/gapi/own/scalar.hpp b/modules/gapi/include/opencv2/gapi/own/scalar.hpp deleted file mode 100644 index 3b107befcc..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/scalar.hpp +++ /dev/null @@ -1,47 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_GAPI_OWN_SCALAR_HPP -#define OPENCV_GAPI_GAPI_OWN_SCALAR_HPP - -#include - -namespace cv -{ -namespace gapi -{ -namespace own -{ - -class GAPI_EXPORTS Scalar -{ -public: - Scalar() = default; - explicit Scalar(double v0) { val[0] = v0; } - Scalar(double v0, double v1, double v2 = 0, double v3 = 0) - : val{v0, v1, v2, v3} - { - } - - const double& operator[](int i) const { return val[i]; } - double& operator[](int i) { return val[i]; } - - static Scalar all(double v0) { return Scalar(v0, v0, v0, v0); } - - double val[4] = {0}; -}; - -inline bool operator==(const Scalar& lhs, const Scalar& rhs) -{ - return std::equal(std::begin(lhs.val), std::end(lhs.val), std::begin(rhs.val)); -} - -} // namespace own -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_GAPI_OWN_SCALAR_HPP diff --git a/modules/gapi/include/opencv2/gapi/own/types.hpp b/modules/gapi/include/opencv2/gapi/own/types.hpp deleted file mode 100644 index 211b5c85ff..0000000000 --- a/modules/gapi/include/opencv2/gapi/own/types.hpp +++ /dev/null @@ -1,162 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_TYPES_HPP -#define OPENCV_GAPI_TYPES_HPP - -#include // std::max, std::min -#include - -namespace cv -{ -namespace gapi -{ - -/** - * @brief This namespace contains G-API own data structures used in - * its standalone mode build. - */ -namespace own -{ - -class Point -{ -public: - Point() = default; - Point(int _x, int _y) : x(_x), y(_y) {} - - int x = 0; - int y = 0; -}; - -class Point2f -{ -public: - Point2f() = default; - Point2f(float _x, float _y) : x(_x), y(_y) {} - - float x = 0.f; - float y = 0.f; -}; - -class Point3f -{ -public: - Point3f() = default; - Point3f(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {} - - float x = 0.f; - float y = 0.f; - float z = 0.f; -}; - -class Rect -{ -public: - Rect() = default; - Rect(int _x, int _y, int _width, int _height) : x(_x), y(_y), width(_width), height(_height) {} -#if !defined(GAPI_STANDALONE) - Rect(const cv::Rect& other) : x(other.x), y(other.y), width(other.width), height(other.height) {} - inline Rect& operator=(const cv::Rect& other) - { - x = other.x; - y = other.x; - width = other.width; - height = other.height; - return *this; - } -#endif // !defined(GAPI_STANDALONE) - - int x = 0; //!< x coordinate of the top-left corner - int y = 0; //!< y coordinate of the top-left corner - int width = 0; //!< width of the rectangle - int height = 0; //!< height of the rectangle -}; - -inline bool operator==(const Rect& lhs, const Rect& rhs) -{ - return lhs.x == rhs.x && lhs.y == rhs.y && lhs.width == rhs.width && lhs.height == rhs.height; -} - -inline bool operator!=(const Rect& lhs, const Rect& rhs) -{ - return !(lhs == rhs); -} - -inline Rect& operator&=(Rect& lhs, const Rect& rhs) -{ - int x1 = std::max(lhs.x, rhs.x); - int y1 = std::max(lhs.y, rhs.y); - lhs.width = std::min(lhs.x + lhs.width, rhs.x + rhs.width) - x1; - lhs.height = std::min(lhs.y + lhs.height, rhs.y + rhs.height) - y1; - lhs.x = x1; - lhs.y = y1; - if( lhs.width <= 0 || lhs.height <= 0 ) - lhs = Rect(); - return lhs; -} - -inline Rect operator&(const Rect& lhs, const Rect& rhs) -{ - Rect result = lhs; - return result &= rhs; -} - -inline std::ostream& operator<<(std::ostream& o, const Rect& rect) -{ - return o << "[" << rect.width << " x " << rect.height << " from (" << rect.x << ", " << rect.y << ")]"; -} - -class Size -{ -public: - Size() = default; - Size(int _width, int _height) : width(_width), height(_height) {} -#if !defined(GAPI_STANDALONE) - Size(const cv::Size& other) : width(other.width), height(other.height) {} - inline Size& operator=(const cv::Size& rhs) - { - width = rhs.width; - height = rhs.height; - return *this; - } -#endif // !defined(GAPI_STANDALONE) - - int width = 0; - int height = 0; -}; - -inline Size& operator+=(Size& lhs, const Size& rhs) -{ - lhs.width += rhs.width; - lhs.height += rhs.height; - return lhs; -} - -inline bool operator==(const Size& lhs, const Size& rhs) -{ - return lhs.width == rhs.width && lhs.height == rhs.height; -} - -inline bool operator!=(const Size& lhs, const Size& rhs) -{ - return !(lhs == rhs); -} - - -inline std::ostream& operator<<(std::ostream& o, const Size& s) -{ - o << "[" << s.width << " x " << s.height << "]"; - return o; -} - -struct VoidType {}; -} // namespace own -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_TYPES_HPP diff --git a/modules/gapi/include/opencv2/gapi/plaidml/core.hpp b/modules/gapi/include/opencv2/gapi/plaidml/core.hpp deleted file mode 100644 index 20e8812b3a..0000000000 --- a/modules/gapi/include/opencv2/gapi/plaidml/core.hpp +++ /dev/null @@ -1,20 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - - -#ifndef OPENCV_GAPI_PLAIDML_CORE_HPP -#define OPENCV_GAPI_PLAIDML_CORE_HPP - -#include // GKernelPackage -#include // GAPI_EXPORTS - -namespace cv { namespace gapi { namespace core { namespace plaidml { - -GAPI_EXPORTS cv::GKernelPackage kernels(); - -}}}} - -#endif // OPENCV_GAPI_PLAIDML_CORE_HPP diff --git a/modules/gapi/include/opencv2/gapi/plaidml/gplaidmlkernel.hpp b/modules/gapi/include/opencv2/gapi/plaidml/gplaidmlkernel.hpp deleted file mode 100644 index e22ecc7211..0000000000 --- a/modules/gapi/include/opencv2/gapi/plaidml/gplaidmlkernel.hpp +++ /dev/null @@ -1,140 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation -// - - -#ifndef OPENCV_GAPI_GPLAIDMLKERNEL_HPP -#define OPENCV_GAPI_GPLAIDMLKERNEL_HPP - -#include -#include - -namespace plaidml -{ -namespace edsl -{ - class Tensor; -} // namespace edsl -} // namespace plaidml - -namespace cv -{ -namespace gapi -{ -namespace plaidml -{ - -GAPI_EXPORTS cv::gapi::GBackend backend(); - -} // namespace plaidml -} // namespace gapi - -struct GPlaidMLContext -{ - // Generic accessor API - template - const T& inArg(int input) { return m_args.at(input).get(); } - - // Syntax sugar - const plaidml::edsl::Tensor& inTensor(int input) - { - return inArg(input); - } - - plaidml::edsl::Tensor& outTensor(int output) - { - return *(m_results.at(output).get()); - } - - std::vector m_args; - std::unordered_map m_results; -}; - -class GAPI_EXPORTS GPlaidMLKernel -{ -public: - using F = std::function; - - GPlaidMLKernel() = default; - explicit GPlaidMLKernel(const F& f) : m_f(f) {} - - void apply(GPlaidMLContext &ctx) const - { - GAPI_Assert(m_f); - m_f(ctx); - } - -protected: - F m_f; -}; - - -namespace detail -{ - -template struct plaidml_get_in; -template<> struct plaidml_get_in -{ - static const plaidml::edsl::Tensor& get(GPlaidMLContext& ctx, int idx) - { - return ctx.inTensor(idx); - } -}; - -template struct plaidml_get_in -{ - static T get(GPlaidMLContext &ctx, int idx) { return ctx.inArg(idx); } -}; - -template struct plaidml_get_out; -template<> struct plaidml_get_out -{ - static plaidml::edsl::Tensor& get(GPlaidMLContext& ctx, int idx) - { - return ctx.outTensor(idx); - } -}; - -template -struct PlaidMLCallHelper; - -template -struct PlaidMLCallHelper, std::tuple > -{ - template - static void call_impl(GPlaidMLContext &ctx, detail::Seq, detail::Seq) - { - Impl::run(plaidml_get_in::get(ctx, IIs)..., plaidml_get_out::get(ctx, OIs)...); - } - - static void call(GPlaidMLContext& ctx) - { - call_impl(ctx, - typename detail::MkSeq::type(), - typename detail::MkSeq::type()); - } -}; - -} // namespace detail - -template -class GPlaidMLKernelImpl: public cv::detail::PlaidMLCallHelper, - public cv::detail::KernelTag -{ - using P = detail::PlaidMLCallHelper; - -public: - using API = K; - - static cv::gapi::GBackend backend() { return cv::gapi::plaidml::backend(); } - static cv::GPlaidMLKernel kernel() { return GPlaidMLKernel(&P::call); } -}; - -#define GAPI_PLAIDML_KERNEL(Name, API) struct Name: public cv::GPlaidMLKernelImpl - -} // namespace cv - -#endif // OPENCV_GAPI_GPLAIDMLKERNEL_HPP diff --git a/modules/gapi/include/opencv2/gapi/plaidml/plaidml.hpp b/modules/gapi/include/opencv2/gapi/plaidml/plaidml.hpp deleted file mode 100644 index 3207a8cb2e..0000000000 --- a/modules/gapi/include/opencv2/gapi/plaidml/plaidml.hpp +++ /dev/null @@ -1,53 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - - -#ifndef OPENCV_GAPI_PLAIDML_PLAIDML_HPP -#define OPENCV_GAPI_PLAIDML_PLAIDML_HPP - -#include -#include // CompileArgTag - -namespace cv -{ -namespace gapi -{ - -/** - * @brief This namespace contains G-API PlaidML backend functions, - * structures, and symbols. - */ -namespace plaidml -{ - -/** \addtogroup gapi_compile_args - * @{ - */ -/** - * @brief This structure represents the basic parameters for the experimental - * PlaidML backend. - */ -struct config -{ - std::string dev_id; //!< Device ID. Refer to PlaidML documentation for details. - std::string trg_id; //!< Target ID. Refer to PlaidML documentation for details. -}; -/** @} gapi_compile_args */ - -} // namespace plaidml -} // namespace gapi - -namespace detail -{ - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.plaidml.config"; } - }; -} // namespace detail - -} // namespace cv - -#endif // OPENCV_GAPI_PLAIDML_PLAIDML_HPP diff --git a/modules/gapi/include/opencv2/gapi/python/python.hpp b/modules/gapi/include/opencv2/gapi/python/python.hpp deleted file mode 100644 index 1857a938d5..0000000000 --- a/modules/gapi/include/opencv2/gapi/python/python.hpp +++ /dev/null @@ -1,71 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - - -#ifndef OPENCV_GAPI_PYTHON_API_HPP -#define OPENCV_GAPI_PYTHON_API_HPP - -#include // GKernelPackage -#include // GAPI_EXPORTS - -namespace cv { -namespace gapi { - -/** - * @brief This namespace contains G-API Python backend functions, - * structures, and symbols. - * - * This functionality is required to enable G-API custom operations - * and kernels when using G-API from Python, no need to use it in the - * C++ form. - */ -namespace python { - -GAPI_EXPORTS cv::gapi::GBackend backend(); - -struct GPythonContext -{ - const cv::GArgs &ins; - const cv::GMetaArgs &in_metas; - const cv::GTypesInfo &out_info; - - cv::optional m_state; -}; - -using Impl = std::function; -using Setup = std::function; - -class GAPI_EXPORTS GPythonKernel -{ -public: - GPythonKernel() = default; - GPythonKernel(Impl run, Setup setup); - - Impl run; - Setup setup = nullptr; - bool is_stateful = false; -}; - -class GAPI_EXPORTS GPythonFunctor : public cv::gapi::GFunctor -{ -public: - using Meta = cv::GKernel::M; - - GPythonFunctor(const char* id, const Meta& meta, const Impl& impl, - const Setup& setup = nullptr); - - GKernelImpl impl() const override; - gapi::GBackend backend() const override; - -private: - GKernelImpl impl_; -}; - -} // namespace python -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_PYTHON_API_HPP diff --git a/modules/gapi/include/opencv2/gapi/render.hpp b/modules/gapi/include/opencv2/gapi/render.hpp deleted file mode 100644 index 52e55b0d80..0000000000 --- a/modules/gapi/include/opencv2/gapi/render.hpp +++ /dev/null @@ -1,14 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - -#ifndef OPENCV_GAPI_RENDER_ROOT_HPP -#define OPENCV_GAPI_RENDER_ROOT_HPP - -// This file is just a shortcut to render/render.hpp - -#include - -#endif // OPENCV_GAPI_RENDER_ROOT_HPP diff --git a/modules/gapi/include/opencv2/gapi/render/render.hpp b/modules/gapi/include/opencv2/gapi/render/render.hpp deleted file mode 100644 index 8d93a6efc0..0000000000 --- a/modules/gapi/include/opencv2/gapi/render/render.hpp +++ /dev/null @@ -1,196 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2020 Intel Corporation - - -#ifndef OPENCV_GAPI_RENDER_HPP -#define OPENCV_GAPI_RENDER_HPP - -#include - -#include - -/** \defgroup gapi_draw G-API Drawing and composition functionality - * @{ - * - * @brief Functions for in-graph drawing. - * - * @note This is a Work in Progress functionality and APIs may - * change in the future releases. - * - * G-API can do some in-graph drawing with a generic operations and a - * set of [rendering primitives](@ref gapi_draw_prims). - * In contrast with traditional OpenCV, in G-API user need to form a - * *rendering list* of primitives to draw. This list can be built - * manually or generated within a graph. This list is passed to - * [special operations or functions](@ref gapi_draw_api) where all - * primitives are interpreted and applied to the image. - * - * For example, in a complex pipeline a list of detected objects - * can be translated in-graph to a list of cv::gapi::wip::draw::Rect - * primitives to highlight those with bounding boxes, or a list of - * detected faces can be translated in-graph to a list of - * cv::gapi::wip::draw::Mosaic primitives to hide sensitive content - * or protect privacy. - * - * Like any other operations, rendering in G-API can be reimplemented - * by different backends. Currently only an OpenCV-based backend is - * available. - * - * In addition to the graph-level operations, there are also regular - * (immediate) OpenCV-like functions are available -- see - * cv::gapi::wip::draw::render(). These functions are just wrappers - * over regular G-API and build the rendering graphs on the fly, so - * take compilation arguments as parameters. - * - * Currently this API is more machine-oriented than human-oriented. - * The main purpose is to translate a set of domain-specific objects - * to a list of primitives to draw. For example, in order to generate - * a picture like this: - * - * ![](modules/gapi/doc/pics/render_example.png) - * - * Rendering list needs to be generated as follows: - * - * @include modules/gapi/samples/draw_example.cpp - * - * @defgroup gapi_draw_prims Drawing primitives - * @defgroup gapi_draw_api Drawing operations and functions - * @} - */ - -namespace cv -{ -namespace gapi -{ -namespace wip -{ -namespace draw -{ - -using GMat2 = std::tuple; -using GMatDesc2 = std::tuple; - -//! @addtogroup gapi_draw_api -//! @{ -/** @brief The function renders on the input image passed drawing primitivies - -@param bgr input image: 8-bit unsigned 3-channel image @ref CV_8UC3. -@param prims vector of drawing primitivies -@param args graph compile time parameters -*/ -void GAPI_EXPORTS_W render(cv::Mat& bgr, - const Prims& prims, - cv::GCompileArgs&& args = {}); - -/** @brief The function renders on two NV12 planes passed drawing primitivies - -@param y_plane input image: 8-bit unsigned 1-channel image @ref CV_8UC1. -@param uv_plane input image: 8-bit unsigned 2-channel image @ref CV_8UC2. -@param prims vector of drawing primitivies -@param args graph compile time parameters -*/ -void GAPI_EXPORTS_W render(cv::Mat& y_plane, - cv::Mat& uv_plane, - const Prims& prims, - cv::GCompileArgs&& args = {}); - -/** @brief The function renders on the input media frame passed drawing primitivies - -@param frame input Media Frame : @ref cv::MediaFrame. -@param prims vector of drawing primitivies -@param args graph compile time parameters -*/ -void GAPI_EXPORTS render(cv::MediaFrame& frame, - const Prims& prims, - cv::GCompileArgs&& args = {}); - - -G_TYPED_KERNEL_M(GRenderNV12, )>, "org.opencv.render.nv12") -{ - static GMatDesc2 outMeta(GMatDesc y_plane, GMatDesc uv_plane, GArrayDesc) - { - return std::make_tuple(y_plane, uv_plane); - } -}; - -G_TYPED_KERNEL(GRenderBGR, )>, "org.opencv.render.bgr") -{ - static GMatDesc outMeta(GMatDesc bgr, GArrayDesc) - { - return bgr; - } -}; - -G_TYPED_KERNEL(GRenderFrame, )>, "org.opencv.render.frame") -{ - static GFrameDesc outMeta(GFrameDesc desc, GArrayDesc) - { - return desc; - } -}; - -/** @brief Renders on 3 channels input - -Output image must be 8-bit unsigned planar 3-channel image - -@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3 -@param prims draw primitives -*/ -GAPI_EXPORTS_W GMat render3ch(const GMat& src, const GArray& prims); - -/** @brief Renders on two planes - -Output y image must be 8-bit unsigned planar 1-channel image @ref CV_8UC1 -uv image must be 8-bit unsigned planar 2-channel image @ref CV_8UC2 - -@param y input image: 8-bit unsigned 1-channel image @ref CV_8UC1 -@param uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2 -@param prims draw primitives -*/ -GAPI_EXPORTS_W GMat2 renderNV12(const GMat& y, - const GMat& uv, - const GArray& prims); - -/** @brief Renders Media Frame - -Output media frame frame cv::MediaFrame - -@param m_frame input image: cv::MediaFrame @ref cv::MediaFrame -@param prims draw primitives -*/ -GAPI_EXPORTS GFrame renderFrame(const GFrame& m_frame, - const GArray& prims); - -//! @} gapi_draw_api - -} // namespace draw -} // namespace wip - -/** - * @brief This namespace contains G-API CPU rendering backend functions, - * structures, and symbols. See @ref gapi_draw for details. - */ -namespace render -{ -namespace ocv -{ - GAPI_EXPORTS_W cv::GKernelPackage kernels(); - -} // namespace ocv -} // namespace render -} // namespace gapi - -namespace detail -{ - template<> struct CompileArgTag - { - static const char* tag() { return "gapi.freetype_font"; } - }; -} // namespace detail - -} // namespace cv - -#endif // OPENCV_GAPI_RENDER_HPP diff --git a/modules/gapi/include/opencv2/gapi/render/render_types.hpp b/modules/gapi/include/opencv2/gapi/render/render_types.hpp deleted file mode 100644 index 6d70e3a877..0000000000 --- a/modules/gapi/include/opencv2/gapi/render/render_types.hpp +++ /dev/null @@ -1,359 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - - -#ifndef OPENCV_GAPI_RENDER_TYPES_HPP -#define OPENCV_GAPI_RENDER_TYPES_HPP - -#include -#include - -#include -#include -#include - -namespace cv -{ -namespace gapi -{ -namespace wip -{ -namespace draw -{ - -/** - * @brief This structure specifies which FreeType font to use by FText primitives. - */ -struct freetype_font -{ - /*@{*/ - std::string path; //!< The path to the font file (.ttf) - /*@{*/ -}; - -//! @addtogroup gapi_draw_prims -//! @{ -/** - * @brief This structure represents a text string to draw. - * - * Parameters match cv::putText(). - */ -struct GAPI_EXPORTS_W_SIMPLE Text -{ - /** - * @brief Text constructor - * - * @param text_ The text string to be drawn - * @param org_ The bottom-left corner of the text string in the image - * @param ff_ The font type, see #HersheyFonts - * @param fs_ The font scale factor that is multiplied by the font-specific base size - * @param color_ The text color - * @param thick_ The thickness of the lines used to draw a text - * @param lt_ The line type. See #LineTypes - * @param bottom_left_origin_ When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner - */ - GAPI_WRAP - Text(const std::string& text_, - const cv::Point& org_, - int ff_, - double fs_, - const cv::Scalar& color_, - int thick_ = 1, - int lt_ = 8, - bool bottom_left_origin_ = false) : - text(text_), org(org_), ff(ff_), fs(fs_), - color(color_), thick(thick_), lt(lt_), bottom_left_origin(bottom_left_origin_) - { - } - - GAPI_WRAP - Text() = default; - - /*@{*/ - GAPI_PROP_RW std::string text; //!< The text string to be drawn - GAPI_PROP_RW cv::Point org; //!< The bottom-left corner of the text string in the image - GAPI_PROP_RW int ff; //!< The font type, see #HersheyFonts - GAPI_PROP_RW double fs; //!< The font scale factor that is multiplied by the font-specific base size - GAPI_PROP_RW cv::Scalar color; //!< The text color - GAPI_PROP_RW int thick; //!< The thickness of the lines used to draw a text - GAPI_PROP_RW int lt; //!< The line type. See #LineTypes - GAPI_PROP_RW bool bottom_left_origin; //!< When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner - /*@{*/ -}; - -/** - * @brief This structure represents a text string to draw using - * FreeType renderer. - * - * If OpenCV is built without FreeType support, this primitive will - * fail at the execution stage. - */ -struct FText -{ - /** - * @brief FText constructor - * - * @param text_ The text string to be drawn - * @param org_ The bottom-left corner of the text string in the image - * @param fh_ The height of text - * @param color_ The text color - */ - FText(const std::wstring& text_, - const cv::Point& org_, - int fh_, - const cv::Scalar& color_) : - text(text_), org(org_), fh(fh_), color(color_) - { - } - - FText() = default; - - /*@{*/ - std::wstring text; //!< The text string to be drawn - cv::Point org; //!< The bottom-left corner of the text string in the image - int fh; //!< The height of text - cv::Scalar color; //!< The text color - /*@{*/ -}; - -/** - * @brief This structure represents a rectangle to draw. - * - * Parameters match cv::rectangle(). - */ -struct GAPI_EXPORTS_W_SIMPLE Rect -{ - /** - * @brief Rect constructor - * - * @param rect_ Coordinates of the rectangle - * @param color_ The bottom-left corner of the text string in the image - * @param thick_ The thickness of lines that make up the rectangle. Negative values, like #FILLED, mean that the function has to draw a filled rectangle - * @param lt_ The type of the line. See #LineTypes - * @param shift_ The number of fractional bits in the point coordinates - */ - Rect(const cv::Rect& rect_, - const cv::Scalar& color_, - int thick_ = 1, - int lt_ = 8, - int shift_ = 0) : - rect(rect_), color(color_), thick(thick_), lt(lt_), shift(shift_) - { - } - - GAPI_WRAP - Rect() = default; - - /*@{*/ - GAPI_PROP_RW cv::Rect rect; //!< Coordinates of the rectangle - GAPI_PROP_RW cv::Scalar color; //!< The rectangle color or brightness (grayscale image) - GAPI_PROP_RW int thick; //!< The thickness of lines that make up the rectangle. Negative values, like #FILLED, mean that the function has to draw a filled rectangle - GAPI_PROP_RW int lt; //!< The type of the line. See #LineTypes - GAPI_PROP_RW int shift; //!< The number of fractional bits in the point coordinates - /*@{*/ -}; - -/** - * @brief This structure represents a circle to draw. - * - * Parameters match cv::circle(). - */ -struct GAPI_EXPORTS_W_SIMPLE Circle -{ - /** - * @brief Circle constructor - * - * @param center_ The center of the circle - * @param radius_ The radius of the circle - * @param color_ The color of the circle - * @param thick_ The thickness of the circle outline, if positive. Negative values, like #FILLED, mean that a filled circle is to be drawn - * @param lt_ The Type of the circle boundary. See #LineTypes - * @param shift_ The Number of fractional bits in the coordinates of the center and in the radius value - */ - GAPI_WRAP - Circle(const cv::Point& center_, - int radius_, - const cv::Scalar& color_, - int thick_ = 1, - int lt_ = 8, - int shift_ = 0) : - center(center_), radius(radius_), color(color_), thick(thick_), lt(lt_), shift(shift_) - { - } - - GAPI_WRAP - Circle() = default; - - /*@{*/ - GAPI_PROP_RW cv::Point center; //!< The center of the circle - GAPI_PROP_RW int radius; //!< The radius of the circle - GAPI_PROP_RW cv::Scalar color; //!< The color of the circle - GAPI_PROP_RW int thick; //!< The thickness of the circle outline, if positive. Negative values, like #FILLED, mean that a filled circle is to be drawn - GAPI_PROP_RW int lt; //!< The Type of the circle boundary. See #LineTypes - GAPI_PROP_RW int shift; //!< The Number of fractional bits in the coordinates of the center and in the radius value - /*@{*/ -}; - -/** - * @brief This structure represents a line to draw. - * - * Parameters match cv::line(). - */ -struct GAPI_EXPORTS_W_SIMPLE Line -{ - /** - * @brief Line constructor - * - * @param pt1_ The first point of the line segment - * @param pt2_ The second point of the line segment - * @param color_ The line color - * @param thick_ The thickness of line - * @param lt_ The Type of the line. See #LineTypes - * @param shift_ The number of fractional bits in the point coordinates - */ - GAPI_WRAP - Line(const cv::Point& pt1_, - const cv::Point& pt2_, - const cv::Scalar& color_, - int thick_ = 1, - int lt_ = 8, - int shift_ = 0) : - pt1(pt1_), pt2(pt2_), color(color_), thick(thick_), lt(lt_), shift(shift_) - { - } - - GAPI_WRAP - Line() = default; - - /*@{*/ - GAPI_PROP_RW cv::Point pt1; //!< The first point of the line segment - GAPI_PROP_RW cv::Point pt2; //!< The second point of the line segment - GAPI_PROP_RW cv::Scalar color; //!< The line color - GAPI_PROP_RW int thick; //!< The thickness of line - GAPI_PROP_RW int lt; //!< The Type of the line. See #LineTypes - GAPI_PROP_RW int shift; //!< The number of fractional bits in the point coordinates - /*@{*/ -}; - -/** - * @brief This structure represents a mosaicing operation. - * - * Mosaicing is a very basic method to obfuscate regions in the image. - */ -struct GAPI_EXPORTS_W_SIMPLE Mosaic -{ - /** - * @brief Mosaic constructor - * - * @param mos_ Coordinates of the mosaic - * @param cellSz_ Cell size (same for X, Y) - * @param decim_ Decimation (0 stands for no decimation) - */ - Mosaic(const cv::Rect& mos_, - int cellSz_, - int decim_) : - mos(mos_), cellSz(cellSz_), decim(decim_) - { - } - - GAPI_WRAP - Mosaic() : cellSz(0), decim(0) {} - - /*@{*/ - GAPI_PROP_RW cv::Rect mos; //!< Coordinates of the mosaic - GAPI_PROP_RW int cellSz; //!< Cell size (same for X, Y) - GAPI_PROP_RW int decim; //!< Decimation (0 stands for no decimation) - /*@{*/ -}; - -/** - * @brief This structure represents an image to draw. - * - * Image is blended on a frame using the specified mask. - */ -struct GAPI_EXPORTS_W_SIMPLE Image -{ - /** - * @brief Mosaic constructor - * - * @param org_ The bottom-left corner of the image - * @param img_ Image to draw - * @param alpha_ Alpha channel for image to draw (same size and number of channels) - */ - GAPI_WRAP - Image(const cv::Point& org_, - const cv::Mat& img_, - const cv::Mat& alpha_) : - org(org_), img(img_), alpha(alpha_) - { - } - - GAPI_WRAP - Image() = default; - - /*@{*/ - GAPI_PROP_RW cv::Point org; //!< The bottom-left corner of the image - GAPI_PROP_RW cv::Mat img; //!< Image to draw - GAPI_PROP_RW cv::Mat alpha; //!< Alpha channel for image to draw (same size and number of channels) - /*@{*/ -}; - -/** - * @brief This structure represents a polygon to draw. - */ -struct GAPI_EXPORTS_W_SIMPLE Poly -{ - /** - * @brief Mosaic constructor - * - * @param points_ Points to connect - * @param color_ The line color - * @param thick_ The thickness of line - * @param lt_ The Type of the line. See #LineTypes - * @param shift_ The number of fractional bits in the point coordinate - */ - GAPI_WRAP - Poly(const std::vector& points_, - const cv::Scalar& color_, - int thick_ = 1, - int lt_ = 8, - int shift_ = 0) : - points(points_), color(color_), thick(thick_), lt(lt_), shift(shift_) - { - } - - GAPI_WRAP - Poly() = default; - - /*@{*/ - GAPI_PROP_RW std::vector points; //!< Points to connect - GAPI_PROP_RW cv::Scalar color; //!< The line color - GAPI_PROP_RW int thick; //!< The thickness of line - GAPI_PROP_RW int lt; //!< The Type of the line. See #LineTypes - GAPI_PROP_RW int shift; //!< The number of fractional bits in the point coordinate - /*@{*/ -}; - -using Prim = util::variant - < Text - , FText - , Rect - , Circle - , Line - , Mosaic - , Image - , Poly - >; - -using Prims = std::vector; -//! @} gapi_draw_prims - -} // namespace draw -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_RENDER_TYPES_HPP diff --git a/modules/gapi/include/opencv2/gapi/rmat.hpp b/modules/gapi/include/opencv2/gapi/rmat.hpp deleted file mode 100644 index ed456f901e..0000000000 --- a/modules/gapi/include/opencv2/gapi/rmat.hpp +++ /dev/null @@ -1,162 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_RMAT_HPP -#define OPENCV_GAPI_RMAT_HPP - -#include -#include - -// Forward declaration -namespace cv { -namespace gapi { -namespace s11n { -struct IOStream; -struct IIStream; -} // namespace s11n -} // namespace gapi -} // namespace cv - -namespace cv { - -// "Remote Mat", a general class which provides an abstraction layer over the data -// storage and placement (host, remote device etc) and allows to access this data. -// -// The device specific implementation is hidden in the RMat::IAdapter class -// -// The basic flow is the following: -// * Backend which is aware of the remote device: -// - Implements own AdapterT class which is derived from RMat::IAdapter -// - Wraps device memory into RMat via make_rmat utility function: -// cv::RMat rmat = cv::make_rmat(args); -// -// * End user: -// - Writes the code which works with RMats without any knowledge of the remote device: -// void func(const cv::RMat& in_rmat, cv::RMat& out_rmat) { -// // Fetch input data from the device, get mapped memory for output -// cv::RMat::View in_view = in_rmat.access(Access::R); -// cv::RMat::View out_view = out_rmat.access(Access::W); -// performCalculations(in_view, out_view); -// // data from out_view is transferred to the device when out_view is destroyed -// } -/** \addtogroup gapi_data_structures - * @{ - */ -class GAPI_EXPORTS RMat -{ -public: - // A lightweight wrapper on image data: - // - Doesn't own the memory; - // - Doesn't implement copy semantics (it's assumed that a view is created each time - // wrapped data is being accessed); - // - Has an optional callback which is called when the view is destroyed. - class GAPI_EXPORTS View - { - public: - using DestroyCallback = std::function; - using stepsT = std::vector; - - View() = default; - View(const GMatDesc& desc, uchar* data, const stepsT& steps = {}, DestroyCallback&& cb = nullptr); - View(const GMatDesc& desc, uchar* data, size_t step, DestroyCallback&& cb = nullptr); - - View(const View&) = delete; - View& operator=(const View&) = delete; - View(View&&) = default; - View& operator=(View&& v); - ~View() { if (m_cb) m_cb(); } - - cv::Size size() const { return m_desc.size; } - const std::vector& dims() const { return m_desc.dims; } - int cols() const { return m_desc.size.width; } - int rows() const { return m_desc.size.height; } - int type() const; - int depth() const { return m_desc.depth; } - int chan() const { return m_desc.chan; } - size_t elemSize() const { return CV_ELEM_SIZE(type()); } - - template T* ptr(int y = 0) { - return reinterpret_cast(m_data + step()*y); - } - template const T* ptr(int y = 0) const { - return reinterpret_cast(m_data + step()*y); - } - template T* ptr(int y, int x) { - return reinterpret_cast(m_data + step()*y + step(1)*x); - } - template const T* ptr(int y, int x) const { - return reinterpret_cast(m_data + step()*y + step(1)*x); - } - size_t step(size_t i = 0) const { - GAPI_DbgAssert(i; - - RMat() = default; - RMat(AdapterP&& a) : m_adapter(std::move(a)) {} - GMatDesc desc() const { return m_adapter->desc(); } - - // Note: When accessed for write there is no guarantee that returned view - // will contain actual snapshot of the mapped device memory - // (no guarantee that fetch from a device is performed). The only - // guaranty is that when the view is destroyed, its data will be - // transferred to the device - View access(Access a) const { return m_adapter->access(a); } - - // Cast underlying RMat adapter to the particular adapter type, - // return nullptr if underlying type is different - template T* get() const - { - static_assert(std::is_base_of::value, "T is not derived from IAdapter!"); - GAPI_Assert(m_adapter != nullptr); - return dynamic_cast(m_adapter.get()); - } - - void serialize(cv::gapi::s11n::IOStream& os) const { - m_adapter->serialize(os); - } - -private: - AdapterP m_adapter = nullptr; -}; - -template -RMat make_rmat(Ts&&... args) { return { std::make_shared(std::forward(args)...) }; } -/** @} */ - -} //namespace cv - -#endif /* OPENCV_GAPI_RMAT_HPP */ diff --git a/modules/gapi/include/opencv2/gapi/s11n.hpp b/modules/gapi/include/opencv2/gapi/s11n.hpp deleted file mode 100644 index a94f55c249..0000000000 --- a/modules/gapi/include/opencv2/gapi/s11n.hpp +++ /dev/null @@ -1,513 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020-2021 Intel Corporation - -#ifndef OPENCV_GAPI_S11N_HPP -#define OPENCV_GAPI_S11N_HPP - -#include -#include -#include -#include -#include -#include -#include -#include - -// FIXME: caused by deserialize_runarg -#if defined _MSC_VER -#pragma warning(push) -#pragma warning(disable: 4702) -#endif - -namespace cv { -namespace gapi { - -/** -* \addtogroup gapi_serialization -* @{ -*/ - -namespace detail { - GAPI_EXPORTS cv::GComputation getGraph(const std::vector &bytes); - - GAPI_EXPORTS cv::GMetaArgs getMetaArgs(const std::vector &bytes); - - GAPI_EXPORTS cv::GRunArgs getRunArgs(const std::vector &bytes); - - GAPI_EXPORTS std::vector getVectorOfStrings(const std::vector &bytes); - - template - cv::GCompileArgs getCompileArgs(const std::vector &bytes); - - template - cv::GRunArgs getRunArgsWithAdapters(const std::vector &bytes); -} // namespace detail - -/** @brief Serialize a graph represented by GComputation into an array of bytes. - * - * Check different overloads for more examples. - * @param c GComputation to serialize. - * @return serialized vector of bytes. - */ -GAPI_EXPORTS std::vector serialize(const cv::GComputation &c); - -/** @overload - * @param ca GCompileArgs to serialize. - */ -GAPI_EXPORTS std::vector serialize(const cv::GCompileArgs& ca); - -/** @overload - * @param ma GMetaArgs to serialize. - */ -GAPI_EXPORTS std::vector serialize(const cv::GMetaArgs& ma); - -/** @overload - * @param ra GRunArgs to serialize. - */ -GAPI_EXPORTS std::vector serialize(const cv::GRunArgs& ra); - -/** @overload - * @param vs std::vector to serialize. - */ -GAPI_EXPORTS std::vector serialize(const std::vector& vs); - -/** - * @private - */ -template static inline -T deserialize(const std::vector &bytes); - -/** @brief Deserialize GComputation from a byte array. - * - * Check different overloads for more examples. - * @param bytes serialized vector of bytes. - * @return deserialized GComputation object. - */ -template<> inline -cv::GComputation deserialize(const std::vector &bytes) { - return detail::getGraph(bytes); -} - -/** @brief Deserialize GMetaArgs from a byte array. - * - * Check different overloads for more examples. - * @param bytes serialized vector of bytes. - * @return deserialized GMetaArgs object. - */ -template<> inline -cv::GMetaArgs deserialize(const std::vector &bytes) { - return detail::getMetaArgs(bytes); -} - -/** @brief Deserialize GRunArgs from a byte array. - * - * Check different overloads for more examples. - * @param bytes serialized vector of bytes. - * @return deserialized GRunArgs object. - */ -template<> inline -cv::GRunArgs deserialize(const std::vector &bytes) { - return detail::getRunArgs(bytes); -} - -/** @brief Deserialize std::vector from a byte array. - * - * Check different overloads for more examples. - * @param bytes serialized vector of bytes. - * @return deserialized std::vector object. - */ -template<> inline -std::vector deserialize(const std::vector &bytes) { - return detail::getVectorOfStrings(bytes); -} - -/** - * @brief Deserialize GCompileArgs which types were specified in the template from a byte array. - * - * @note cv::gapi::s11n::detail::S11N template specialization must be provided to make a custom type - * in GCompileArgs deserializable. - * - * @param bytes vector of bytes to deserialize GCompileArgs object from. - * @return GCompileArgs object. - * @see GCompileArgs cv::gapi::s11n::detail::S11N - */ -template inline -typename std::enable_if::value, GCompileArgs>:: -type deserialize(const std::vector &bytes) { - return detail::getCompileArgs(bytes); -} - -/** - * @brief Deserialize GRunArgs including RMat and MediaFrame objects if any from a byte array. - * - * Adapter types are specified in the template. - * @note To be used properly specified adapter types must overload their deserialize() method. - * @param bytes vector of bytes to deserialize GRunArgs object from. - * @return GRunArgs including RMat and MediaFrame objects if any. - * @see RMat MediaFrame - */ -template inline -typename std::enable_if::value, GRunArgs>:: -type deserialize(const std::vector &bytes) { - return detail::getRunArgsWithAdapters(bytes); -} -} // namespace gapi -} // namespace cv - -namespace cv { -namespace gapi { -namespace s11n { - -/** @brief This structure is an interface for serialization routines. - * - * It's main purpose is to provide multiple overloads for operator<<() - * with basic C++ in addition to OpenCV/G-API types. - * - * This sctructure can be inherited and further extended with additional types. - * - * For example, it is utilized in cv::gapi::s11n::detail::S11N as input parameter - * in serialize() method. - */ -struct GAPI_EXPORTS IOStream { - virtual ~IOStream() = default; - // Define the native support for basic C++ types at the API level: - virtual IOStream& operator<< (bool) = 0; - virtual IOStream& operator<< (char) = 0; - virtual IOStream& operator<< (unsigned char) = 0; - virtual IOStream& operator<< (short) = 0; - virtual IOStream& operator<< (unsigned short) = 0; - virtual IOStream& operator<< (int) = 0; - virtual IOStream& operator<< (uint32_t) = 0; - virtual IOStream& operator<< (uint64_t) = 0; - virtual IOStream& operator<< (float) = 0; - virtual IOStream& operator<< (double) = 0; - virtual IOStream& operator<< (const std::string&) = 0; -}; - -/** @brief This structure is an interface for deserialization routines. - * - * It's main purpose is to provide multiple overloads for operator>>() - * with basic C++ in addition to OpenCV/G-API types. - * - * This structure can be inherited and further extended with additional types. - * - * For example, it is utilized in cv::gapi::s11n::detail::S11N as input parameter - * in deserialize() method. - */ -struct GAPI_EXPORTS IIStream { - virtual ~IIStream() = default; - virtual IIStream& operator>> (bool &) = 0; - virtual IIStream& operator>> (std::vector::reference) = 0; - virtual IIStream& operator>> (char &) = 0; - virtual IIStream& operator>> (unsigned char &) = 0; - virtual IIStream& operator>> (short &) = 0; - virtual IIStream& operator>> (unsigned short &) = 0; - virtual IIStream& operator>> (int &) = 0; - virtual IIStream& operator>> (float &) = 0; - virtual IIStream& operator>> (double &) = 0; - virtual IIStream& operator >> (uint32_t &) = 0; - virtual IIStream& operator >> (uint64_t &) = 0; - virtual IIStream& operator>> (std::string &) = 0; -}; - -namespace detail { -GAPI_EXPORTS std::unique_ptr getInStream(const std::vector &bytes); -} // namespace detail - -//////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////// -// S11N operators -// Note: operators for basic types are defined in IIStream/IOStream - -// OpenCV types //////////////////////////////////////////////////////////////// - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point &pt); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Point &pt); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point2f &pt); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Point2f &pt); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Point3f &pt); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Point3f &pt); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Size &sz); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Size &sz); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Rect &rc); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Rect &rc); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Scalar &s); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Scalar &s); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::Mat &m); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::Mat &m); - -// FIXME: for GRunArgs serialization -#if !defined(GAPI_STANDALONE) -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::UMat & um); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::UMat & um); -#endif // !defined(GAPI_STANDALONE) - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::RMat &r); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::RMat &r); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::gapi::wip::IStreamSource::Ptr &issptr); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::gapi::wip::IStreamSource::Ptr &issptr); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::detail::VectorRef &vr); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::detail::VectorRef &vr); - -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::detail::OpaqueRef &opr); -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::detail::OpaqueRef &opr); - -/// @private -- Exclude this function from OpenCV documentation -GAPI_EXPORTS IOStream& operator<< (IOStream& os, const cv::MediaFrame &mf); -/// @private -- Exclude this function from OpenCV documentation -GAPI_EXPORTS IIStream& operator>> (IIStream& is, cv::MediaFrame &mf); - -// Generic STL types //////////////////////////////////////////////////////////////// -template -IOStream& operator<< (IOStream& os, const std::map &m) { - const uint32_t sz = static_cast(m.size()); - os << sz; - for (const auto& it : m) os << it.first << it.second; - return os; -} -template -IIStream& operator>> (IIStream& is, std::map &m) { - m.clear(); - uint32_t sz = 0u; - is >> sz; - for (std::size_t i = 0; i < sz; ++i) { - K k{}; - V v{}; - is >> k >> v; - m[k] = v; - } - return is; -} - -template -IOStream& operator<< (IOStream& os, const std::unordered_map &m) { - const uint32_t sz = static_cast(m.size()); - os << sz; - for (auto &&it : m) os << it.first << it.second; - return os; -} -template -IIStream& operator>> (IIStream& is, std::unordered_map &m) { - m.clear(); - uint32_t sz = 0u; - is >> sz; - for (std::size_t i = 0; i < sz; ++i) { - K k{}; - V v{}; - is >> k >> v; - m[k] = v; - } - return is; -} - -template -IOStream& operator<< (IOStream& os, const std::vector &ts) { - const uint32_t sz = static_cast(ts.size()); - os << sz; - for (auto &&v : ts) os << v; - return os; -} -template -IIStream& operator>> (IIStream& is, std::vector &ts) { - uint32_t sz = 0u; - is >> sz; - if (sz == 0u) { - ts.clear(); - } - else { - ts.resize(sz); - for (std::size_t i = 0; i < sz; ++i) is >> ts[i]; - } - return is; -} - -// Generic: variant serialization -namespace detail { -template -IOStream& put_v(IOStream&, const V&, std::size_t) { - GAPI_Error("variant>>: requested index is invalid"); -} - -template -IOStream& put_v(IOStream& os, const V& v, std::size_t x) { - return (x == 0u) - ? os << cv::util::get(v) - : put_v(os, v, x-1); -} - -template -IIStream& get_v(IIStream&, V&, std::size_t, std::size_t) { - GAPI_Error("variant<<: requested index is invalid"); -} - -template -IIStream& get_v(IIStream& is, V& v, std::size_t i, std::size_t gi) { - if (i == gi) { - X x{}; - is >> x; - v = V{std::move(x)}; - return is; - } else return get_v(is, v, i+1, gi); -} -} // namespace detail - -//! @overload -template -IOStream& operator<< (IOStream& os, const cv::util::variant &v) { - os << static_cast(v.index()); - return detail::put_v, Ts...>(os, v, v.index()); -} -//! @overload -template -IIStream& operator>> (IIStream& is, cv::util::variant &v) { - int idx = -1; - is >> idx; - GAPI_Assert(idx >= 0 && idx < (int)sizeof...(Ts)); - return detail::get_v, Ts...>(is, v, 0u, idx); -} - -// FIXME: consider a better solution -/// @private -- Exclude this function from OpenCV documentation -template -void getRunArgByIdx (IIStream& is, cv::util::variant &v, uint32_t idx) { - is = detail::get_v, Ts...>(is, v, 0u, idx); -} -} // namespace s11n - -namespace detail -{ -template struct try_deserialize_comparg; - -template<> struct try_deserialize_comparg> { -static cv::util::optional exec(const std::string&, cv::gapi::s11n::IIStream&) { - return { }; - } -}; - -template -struct try_deserialize_comparg> { -static cv::util::optional exec(const std::string& tag, cv::gapi::s11n::IIStream& is) { - if (tag == cv::detail::CompileArgTag::tag()) { - static_assert(cv::gapi::s11n::detail::has_S11N_spec::value, - "cv::gapi::deserialize expects Types to have S11N " - "specializations with deserialization callbacks!"); - return cv::util::optional( - GCompileArg { cv::gapi::s11n::detail::S11N::deserialize(is) }); - } - return try_deserialize_comparg>::exec(tag, is); -} -}; - -template -struct deserialize_arg_with_adapter; - -template -struct deserialize_arg_with_adapter { -static GRunArg exec(cv::gapi::s11n::IIStream& is) { - std::unique_ptr ptr(new TA); - ptr->deserialize(is); - return GRunArg { RA(std::move(ptr)) }; -} -}; - -template -struct deserialize_arg_with_adapter { -static GRunArg exec(cv::gapi::s11n::IIStream&) { - GAPI_Error("No suitable adapter class found during RMat/MediaFrame deserialization. " - "Please, make sure you've passed them in cv::gapi::deserialize() template"); - return GRunArg{}; -} -}; - -template -struct deserialize_runarg { -static GRunArg exec(cv::gapi::s11n::IIStream& is, uint32_t idx) { - if (idx == GRunArg::index_of()) { - // Type or void (if not found) - using TA = typename cv::util::find_adapter_impl::type; - return deserialize_arg_with_adapter::exec(is); - } else if (idx == GRunArg::index_of()) { - // Type or void (if not found) - using TA = typename cv::util::find_adapter_impl::type; - return deserialize_arg_with_adapter::exec(is); - } else { // not an adapter holding type runarg - use default deserialization - GRunArg arg; - getRunArgByIdx(is, arg, idx); - return arg; - } -} -}; - -template -inline cv::util::optional tryDeserializeCompArg(const std::string& tag, - const std::vector& sArg) { - std::unique_ptr pArgIs = cv::gapi::s11n::detail::getInStream(sArg); - return try_deserialize_comparg>::exec(tag, *pArgIs); -} - -template -cv::GCompileArgs getCompileArgs(const std::vector &sArgs) { - cv::GCompileArgs args; - - std::unique_ptr pIs = cv::gapi::s11n::detail::getInStream(sArgs); - cv::gapi::s11n::IIStream& is = *pIs; - - uint32_t sz = 0; - is >> sz; - for (uint32_t i = 0; i < sz; ++i) { - std::string tag; - is >> tag; - - std::vector sArg; - is >> sArg; - - cv::util::optional dArg = - cv::gapi::detail::tryDeserializeCompArg(tag, sArg); - - if (dArg.has_value()) - { - args.push_back(dArg.value()); - } - } - - return args; -} - -template -cv::GRunArgs getRunArgsWithAdapters(const std::vector &bytes) { - std::unique_ptr pIs = cv::gapi::s11n::detail::getInStream(bytes); - cv::gapi::s11n::IIStream& is = *pIs; - cv::GRunArgs args; - - uint32_t sz = 0; - is >> sz; - for (uint32_t i = 0; i < sz; ++i) { - uint32_t idx = 0; - is >> idx; - args.push_back(cv::gapi::detail::deserialize_runarg::exec(is, idx)); - } - - return args; -} -} // namespace detail -/** @} */ - -} // namespace gapi -} // namespace cv - -#if defined _MSC_VER -#pragma warning(pop) -#endif - -#endif // OPENCV_GAPI_S11N_HPP diff --git a/modules/gapi/include/opencv2/gapi/s11n/base.hpp b/modules/gapi/include/opencv2/gapi/s11n/base.hpp deleted file mode 100644 index 760e8515f6..0000000000 --- a/modules/gapi/include/opencv2/gapi/s11n/base.hpp +++ /dev/null @@ -1,80 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020-2021 Intel Corporation - -#ifndef OPENCV_GAPI_S11N_BASE_HPP -#define OPENCV_GAPI_S11N_BASE_HPP - -#include -#include - -namespace cv { -namespace gapi { - -/** - * @brief This namespace contains G-API serialization and - * deserialization functions and data structures. - */ -namespace s11n { -struct IOStream; -struct IIStream; - -namespace detail { - -//! @addtogroup gapi_serialization -//! @{ - -struct NotImplemented { -}; - -/** @brief This structure allows to implement serialization routines for custom types. - * - * The default S11N for custom types is not implemented. - * - * @note When providing an overloaded implementation for S11N with your type - * don't inherit it from NotImplemented structure. - * - * @note There are lots of overloaded >> and << operators for basic and OpenCV/G-API types - * which can be utilized when serializing a custom type. - * - * Example of usage: - * @snippet samples/cpp/tutorial_code/gapi/doc_snippets/api_ref_snippets.cpp S11N usage - * - */ -template -struct S11N: public NotImplemented { - /** - * @brief This function allows user to serialize their custom type. - * - * @note The default overload throws an exception if called. User need to - * properly overload the function to use it. - */ - static void serialize(IOStream &, const T &) { - GAPI_Error("No serialization routine is provided!"); - } - /** - * @brief This function allows user to deserialize their custom type. - * - * @note The default overload throws an exception if called. User need to - * properly overload the function to use it. - */ - static T deserialize(IIStream &) { - GAPI_Error("No deserialization routine is provided!"); - } -}; - -/// @private -- Exclude this struct from OpenCV documentation -template struct has_S11N_spec { - static constexpr bool value = !std::is_base_of::type>>::value; -}; -//! @} gapi_serialization - -} // namespace detail -} // namespace s11n -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_S11N_BASE_HPP diff --git a/modules/gapi/include/opencv2/gapi/stereo.hpp b/modules/gapi/include/opencv2/gapi/stereo.hpp deleted file mode 100644 index 9b00267082..0000000000 --- a/modules/gapi/include/opencv2/gapi/stereo.hpp +++ /dev/null @@ -1,85 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distereoibution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_STEREO_HPP -#define OPENCV_GAPI_STEREO_HPP - -#include -#include -#include - -namespace cv { -namespace gapi { - -/** - * The enum specified format of result that you get from @ref cv::gapi::stereo. - */ -enum class StereoOutputFormat { - DEPTH_FLOAT16, ///< Floating point 16 bit value, CV_16FC1. - ///< This identifier is deprecated, use DEPTH_16F instead. - DEPTH_FLOAT32, ///< Floating point 32 bit value, CV_32FC1 - ///< This identifier is deprecated, use DEPTH_16F instead. - DISPARITY_FIXED16_11_5, ///< 16 bit signed: first bit for sign, - ///< 10 bits for integer part, - ///< 5 bits for fractional part. - ///< This identifier is deprecated, - ///< use DISPARITY_16Q_10_5 instead. - DISPARITY_FIXED16_12_4, ///< 16 bit signed: first bit for sign, - ///< 11 bits for integer part, - ///< 4 bits for fractional part. - ///< This identifier is deprecated, - ///< use DISPARITY_16Q_11_4 instead. - DEPTH_16F = DEPTH_FLOAT16, ///< Same as DEPTH_FLOAT16 - DEPTH_32F = DEPTH_FLOAT32, ///< Same as DEPTH_FLOAT32 - DISPARITY_16Q_10_5 = DISPARITY_FIXED16_11_5, ///< Same as DISPARITY_FIXED16_11_5 - DISPARITY_16Q_11_4 = DISPARITY_FIXED16_12_4 ///< Same as DISPARITY_FIXED16_12_4 -}; - - -/** - * @brief This namespace contains G-API Operation Types for Stereo and - * related functionality. - */ -namespace calib3d { - -G_TYPED_KERNEL(GStereo, , "org.opencv.stereo") { - static GMatDesc outMeta(const GMatDesc &left, const GMatDesc &right, const StereoOutputFormat of) { - GAPI_Assert(left.chan == 1); - GAPI_Assert(left.depth == CV_8U); - - GAPI_Assert(right.chan == 1); - GAPI_Assert(right.depth == CV_8U); - - switch(of) { - case StereoOutputFormat::DEPTH_FLOAT16: - return left.withDepth(CV_16FC1); - case StereoOutputFormat::DEPTH_FLOAT32: - return left.withDepth(CV_32FC1); - case StereoOutputFormat::DISPARITY_FIXED16_11_5: - case StereoOutputFormat::DISPARITY_FIXED16_12_4: - return left.withDepth(CV_16SC1); - default: - GAPI_Error("Unknown output format!"); - } - } -}; - -} // namespace calib3d - -/** @brief Computes disparity/depth map for the specified stereo-pair. -The function computes disparity or depth map depending on passed StereoOutputFormat argument. - -@param left 8-bit single-channel left image of @ref CV_8UC1 type. -@param right 8-bit single-channel right image of @ref CV_8UC1 type. -@param of enum to specified output kind: depth or disparity and corresponding type -*/ -GAPI_EXPORTS GMat stereo(const GMat& left, - const GMat& right, - const StereoOutputFormat of = StereoOutputFormat::DEPTH_FLOAT32); -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STEREO_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/cap.hpp b/modules/gapi/include/opencv2/gapi/streaming/cap.hpp deleted file mode 100644 index 9c2185c1ab..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/cap.hpp +++ /dev/null @@ -1,149 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_CAP_HPP -#define OPENCV_GAPI_STREAMING_CAP_HPP - -/** - * YOUR ATTENTION PLEASE! - * - * This is a header-only implementation of cv::VideoCapture-based - * Stream source. It is not built by default with G-API as G-API - * doesn't depend on videoio module. - * - * If you want to use it in your application, please make sure - * videioio is available in your OpenCV package and is linked to your - * application. - * - * Note for developers: please don't put videoio dependency in G-API - * because of this file. - */ -#include -#include - -#include -#include -#include - -namespace cv { -namespace gapi { -namespace wip { - -/** - * @brief OpenCV's VideoCapture-based streaming source. - * - * This class implements IStreamSource interface. - * Its constructor takes the same parameters as cv::VideoCapture does. - * - * Please make sure that videoio OpenCV module is available before using - * this in your application (G-API doesn't depend on it directly). - * - * @note stream sources are passed to G-API via shared pointers, so - * please gapi::make_src<> to create objects and ptr() to pass a - * GCaptureSource to cv::gin(). - */ -class GCaptureSource: public IStreamSource -{ -public: - explicit GCaptureSource(int id, const std::map &properties = {}) - : cap(id) { prep(properties); } - - explicit GCaptureSource(const std::string &path, - const std::map &properties = {}) - : cap(path) { prep(properties); } - - void set(int propid, double value) { - cap.set(propid, value); - } - - // TODO: Add more constructor overloads to make it - // fully compatible with VideoCapture's interface. - -protected: - cv::VideoCapture cap; - cv::Mat first; - bool first_pulled = false; - int64_t counter = 0; - - void prep(const std::map &properties) - { - for (const auto &it : properties) { - cap.set(it.first, it.second); - } - - // Prepare first frame to report its meta to engine - // when needed - GAPI_Assert(first.empty()); - cv::Mat tmp; - if (!cap.read(tmp)) - { - GAPI_Error("Couldn't grab the very first frame"); - } - // NOTE: Some decode/media VideoCapture backends continue - // owning the video buffer under cv::Mat so in order to - // process it safely in a highly concurrent pipeline, clone() - // is the only right way. - first = tmp.clone(); - } - - virtual bool pull(cv::gapi::wip::Data &data) override - { - if (!first_pulled) - { - GAPI_Assert(!first.empty()); - first_pulled = true; - data = first; // no need to clone here since it was cloned already - } - else - { - if (!cap.isOpened()) return false; - - cv::Mat frame; - if (!cap.read(frame)) - { - // end-of-stream happened - return false; - } - // Same reason to clone as in prep() - data = frame.clone(); - } - // Tag data with seq_id/ts - const auto now = std::chrono::system_clock::now(); - const auto dur = std::chrono::duration_cast - (now.time_since_epoch()); - data.meta[cv::gapi::streaming::meta_tag::timestamp] = int64_t{dur.count()}; - data.meta[cv::gapi::streaming::meta_tag::seq_id] = int64_t{counter++}; - return true; - } - - virtual GMetaArg descr_of() const override - { - GAPI_Assert(!first.empty()); - return cv::GMetaArg{cv::descr_of(first)}; - } -}; - -// NB: Overload for using from python -GAPI_EXPORTS_W cv::Ptr -inline make_capture_src(const std::string& path, - const std::map& properties = {}) -{ - return make_src(path, properties); -} - -// NB: Overload for using from python -GAPI_EXPORTS_W cv::Ptr -inline make_capture_src(const int id, - const std::map& properties = {}) -{ - return make_src(id, properties); -} - -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_CAP_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/desync.hpp b/modules/gapi/include/opencv2/gapi/streaming/desync.hpp deleted file mode 100644 index 0e04f5beb9..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/desync.hpp +++ /dev/null @@ -1,86 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020-2021 Intel Corporation - - -#ifndef OPENCV_GAPI_GSTREAMING_DESYNC_HPP -#define OPENCV_GAPI_GSTREAMING_DESYNC_HPP - -#include - -#include -#include -#include -#include -#include - -namespace cv { -namespace gapi { -namespace streaming { - -namespace detail { -struct GDesync { - static const char *id() { - return "org.opencv.streaming.desync"; - } - - // An universal yield for desync. - // Yields output objects according to the input Types... - // Reuses gkernel machinery. - // FIXME: This function can be generic and declared in gkernel.hpp - // (it is there already, but a part of GKernelType[M] - template - static std::tuple yield(cv::GCall &call, cv::detail::Seq) { - return std::make_tuple(cv::detail::Yield::yield(call, IIs)...); - } -}; - -template -G desync(const G &g) { - cv::GKernel k{ - GDesync::id() // kernel id - , "" // kernel tag - , [](const GMetaArgs &a, const GArgs &) {return a;} // outMeta callback - , {cv::detail::GTypeTraits::shape} // output Shape - , {cv::detail::GTypeTraits::op_kind} // input data kinds - , {cv::detail::GObtainCtor::get()} // output template ctors - , {cv::detail::GTypeTraits::op_kind} // output data kinds - }; - cv::GCall call(std::move(k)); - call.pass(g); - return std::get<0>(GDesync::yield(call, cv::detail::MkSeq<1>::type())); -} -} // namespace detail - -/** - * @brief Starts a desynchronized branch in the graph. - * - * This operation takes a single G-API data object and returns a - * graph-level "duplicate" of this object. - * - * Operations which use this data object can be desynchronized - * from the rest of the graph. - * - * This operation has no effect when a GComputation is compiled with - * regular cv::GComputation::compile(), since cv::GCompiled objects - * always produce their full output vectors. - * - * This operation only makes sense when a GComputation is compiled in - * streaming mode with cv::GComputation::compileStreaming(). If this - * operation is used and there are desynchronized outputs, the user - * should use a special version of cv::GStreamingCompiled::pull() - * which produces an array of cv::util::optional<> objects. - * - * @note This feature is highly experimental now and is currently - * limited to a single GMat/GFrame argument only. - */ -GAPI_EXPORTS GMat desync(const GMat &g); -GAPI_EXPORTS GFrame desync(const GFrame &f); - -} // namespace streaming -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_GSTREAMING_DESYNC_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/format.hpp b/modules/gapi/include/opencv2/gapi/streaming/format.hpp deleted file mode 100644 index 739a3852a6..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/format.hpp +++ /dev/null @@ -1,94 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_GSTREAMING_FORMAT_HPP -#define OPENCV_GAPI_GSTREAMING_FORMAT_HPP - -#include // GKernelPackage - -namespace cv { -namespace gapi { -namespace streaming { - -GAPI_EXPORTS cv::GKernelPackage kernels(); - -G_API_OP(GBGR, , "org.opencv.streaming.BGR") -{ - static GMatDesc outMeta(const GFrameDesc& in) { return GMatDesc{CV_8U, 3, in.size}; } -}; - -G_API_OP(GY, , "org.opencv.streaming.Y") { - static GMatDesc outMeta(const GFrameDesc& frameDesc) { - return GMatDesc { CV_8U, 1, frameDesc.size , false }; - } -}; - -G_API_OP(GUV, , "org.opencv.streaming.UV") { - static GMatDesc outMeta(const GFrameDesc& frameDesc) { - return GMatDesc { CV_8U, 2, cv::Size(frameDesc.size.width / 2, frameDesc.size.height / 2), - false }; - } -}; - -/** @brief Gets bgr plane from input frame - -@note Function textual ID is "org.opencv.streaming.BGR" - -@param in Input frame -@return Image in BGR format -*/ -GAPI_EXPORTS cv::GMat BGR(const cv::GFrame& in); - -/** @brief Extracts Y plane from media frame. - -Output image is 8-bit 1-channel image of @ref CV_8UC1. - -@note Function textual ID is "org.opencv.streaming.Y" - -@param frame input media frame. -*/ -GAPI_EXPORTS GMat Y(const cv::GFrame& frame); - -/** @brief Extracts UV plane from media frame. - -Output image is 8-bit 2-channel image of @ref CV_8UC2. - -@note Function textual ID is "org.opencv.streaming.UV" - -@param frame input media frame. -*/ -GAPI_EXPORTS GMat UV(const cv::GFrame& frame); -} // namespace streaming - -//! @addtogroup gapi_transform -//! @{ -/** @brief Makes a copy of the input image. Note that this copy may be not real -(no actual data copied). Use this function to maintain graph contracts, -e.g when graph's input needs to be passed directly to output, like in Streaming mode. - -@note Function textual ID is "org.opencv.streaming.copy" - -@param in Input image -@return Copy of the input -*/ -GAPI_EXPORTS_W GMat copy(const GMat& in); - -/** @brief Makes a copy of the input frame. Note that this copy may be not real -(no actual data copied). Use this function to maintain graph contracts, -e.g when graph's input needs to be passed directly to output, like in Streaming mode. - -@note Function textual ID is "org.opencv.streaming.copy" - -@param in Input frame -@return Copy of the input -*/ -GAPI_EXPORTS GFrame copy(const GFrame& in); -//! @} gapi_transform - -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_GSTREAMING_FORMAT_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamerpipeline.hpp b/modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamerpipeline.hpp deleted file mode 100644 index c566656cb6..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamerpipeline.hpp +++ /dev/null @@ -1,59 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERPIPELINE_HPP -#define OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERPIPELINE_HPP - -#include -#include - -#include -#include -#include - -namespace cv { -namespace gapi { -namespace wip { -namespace gst { - -class GAPI_EXPORTS_W GStreamerPipeline -{ -public: - class Priv; - - GAPI_WRAP explicit GStreamerPipeline(const std::string& pipeline); - IStreamSource::Ptr getStreamingSource(const std::string& appsinkName, - const GStreamerSource::OutputType outputType = - GStreamerSource::OutputType::MAT); - virtual ~GStreamerPipeline(); - -protected: - explicit GStreamerPipeline(std::unique_ptr priv); - - std::unique_ptr m_priv; -}; - -} // namespace gst - -using GStreamerPipeline = gst::GStreamerPipeline; - -// NB: Function for using from python -// FIXME: a separate function is created due to absence of wrappers for `shared_ptr<> ` -// Ideally would be to wrap the `GStreamerPipeline::getStreamingSource()` method as is -GAPI_EXPORTS_W cv::Ptr -inline get_streaming_source(cv::Ptr& pipeline, - const std::string& appsinkName, - const GStreamerSource::OutputType outputType - = GStreamerSource::OutputType::MAT) -{ - return pipeline->getStreamingSource(appsinkName, outputType); -} - -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERPIPELINE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamersource.hpp b/modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamersource.hpp deleted file mode 100644 index 8b8a5ae312..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamersource.hpp +++ /dev/null @@ -1,97 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERSOURCE_HPP -#define OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERSOURCE_HPP - -#include -#include - -#include - -namespace cv { -namespace gapi { -namespace wip { -namespace gst { - -/** - * @brief OpenCV's GStreamer streaming source. - * Streams cv::Mat-s/cv::MediaFrame from passed GStreamer pipeline. - * - * This class implements IStreamSource interface. - * - * To create GStreamerSource instance you need to pass 'pipeline' and, optionally, 'outputType' - * arguments into constructor. - * 'pipeline' should represent GStreamer pipeline in form of textual description. - * Almost any custom pipeline is supported which can be successfully ran via gst-launch. - * The only two limitations are: - * - there should be __one__ appsink element in the pipeline to pass data to OpenCV app. - * Pipeline can actually contain many sink elements, but it must have one and only one - * appsink among them. - * - * - data passed to appsink should be video-frame in NV12 or GRAY8 format. - * - * 'outputType' is used to select type of output data to produce: 'cv::MediaFrame' or 'cv::Mat'. - * To produce 'cv::MediaFrame'-s you need to pass 'GStreamerSource::OutputType::FRAME' and, - * correspondingly, 'GStreamerSource::OutputType::MAT' to produce 'cv::Mat'-s. - * Please note, that in the last case, output 'cv::Mat' will be of BGR format, internal conversion - * from NV12 / GRAY8 GStreamer data will happen. - * Default value for 'outputType' is 'GStreamerSource::OutputType::MAT'. - * - * @note Stream sources are passed to G-API via shared pointers, so please use gapi::make_src<> - * to create objects and ptr() to pass a GStreamerSource to cv::gin(). - * - * @note You need to build OpenCV with GStreamer support to use this class. - */ - -class GStreamerPipelineFacade; - -class GAPI_EXPORTS GStreamerSource : public IStreamSource -{ -public: - class Priv; - - // Indicates what type of data should be produced by GStreamerSource: cv::MediaFrame or cv::Mat - enum class OutputType { - FRAME, - MAT - }; - - GStreamerSource(const std::string& pipeline, - const GStreamerSource::OutputType outputType = - GStreamerSource::OutputType::MAT); - GStreamerSource(std::shared_ptr pipeline, - const std::string& appsinkName, - const GStreamerSource::OutputType outputType = - GStreamerSource::OutputType::MAT); - - bool pull(cv::gapi::wip::Data& data) override; - GMetaArg descr_of() const override; - ~GStreamerSource() override; - -protected: - explicit GStreamerSource(std::unique_ptr priv); - - std::unique_ptr m_priv; -}; - -} // namespace gst - -using GStreamerSource = gst::GStreamerSource; - -// NB: Overload for using from python -GAPI_EXPORTS_W cv::Ptr -inline make_gst_src(const std::string& pipeline, - const GStreamerSource::OutputType outputType = - GStreamerSource::OutputType::MAT) -{ - return make_src(pipeline, outputType); -} -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERSOURCE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/meta.hpp b/modules/gapi/include/opencv2/gapi/streaming/meta.hpp deleted file mode 100644 index cdd3d371cb..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/meta.hpp +++ /dev/null @@ -1,80 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - - -#ifndef OPENCV_GAPI_GSTREAMING_META_HPP -#define OPENCV_GAPI_GSTREAMING_META_HPP - -#include -#include -#include -#include - -namespace cv { -namespace gapi { -namespace streaming { - -// FIXME: the name is debatable -namespace meta_tag { -static constexpr const char * timestamp = "org.opencv.gapi.meta.timestamp"; -static constexpr const char * seq_id = "org.opencv.gapi.meta.seq_id"; -} // namespace meta_tag - -namespace detail { -struct GMeta { - static const char *id() { - return "org.opencv.streaming.meta"; - } - // A universal yield for meta(), same as in GDesync - template - static std::tuple yield(cv::GCall &call, cv::detail::Seq) { - return std::make_tuple(cv::detail::Yield::yield(call, IIs)...); - } - // Also a universal outMeta stub here - static GMetaArgs getOutMeta(const GMetaArgs &args, const GArgs &) { - return args; - } -}; -} // namespace detail - -template -cv::GOpaque meta(G g, const std::string &tag) { - using O = cv::GOpaque; - cv::GKernel k{ - detail::GMeta::id() // kernel id - , tag // kernel tag. Use meta tag here - , &detail::GMeta::getOutMeta // outMeta callback - , {cv::detail::GTypeTraits::shape} // output Shape - , {cv::detail::GTypeTraits::op_kind} // input data kinds - , {cv::detail::GObtainCtor::get()} // output template ctors - , {cv::detail::GTypeTraits::op_kind} // output data kind - }; - cv::GCall call(std::move(k)); - call.pass(g); - return std::get<0>(detail::GMeta::yield(call, cv::detail::MkSeq<1>::type())); -} - -template -cv::GOpaque timestamp(G g) { - return meta(g, meta_tag::timestamp); -} - -template -cv::GOpaque seq_id(G g) { - return meta(g, meta_tag::seq_id); -} - -template -cv::GOpaque seqNo(G g) { - // Old name, compatibility only - return seq_id(g); -} - -} // namespace streaming -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_GSTREAMING_META_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/onevpl/accel_types.hpp b/modules/gapi/include/opencv2/gapi/streaming/onevpl/accel_types.hpp deleted file mode 100644 index b670aebd1d..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/onevpl/accel_types.hpp +++ /dev/null @@ -1,76 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2022 Intel Corporation - -#ifndef GAPI_STREAMING_ONEVPL_ACCEL_TYPES_HPP -#define GAPI_STREAMING_ONEVPL_ACCEL_TYPES_HPP - -#include -#include - -#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS - -namespace cv { -namespace gapi { -namespace wip { -namespace onevpl { - -enum class AccelType: uint8_t { - HOST, - DX11, - VAAPI, - - LAST_VALUE = std::numeric_limits::max() -}; - -GAPI_EXPORTS const char* to_cstring(AccelType type); - -struct IDeviceSelector; -struct GAPI_EXPORTS Device { - friend struct IDeviceSelector; - using Ptr = void*; - - ~Device(); - const std::string& get_name() const; - Ptr get_ptr() const; - AccelType get_type() const; -private: - Device(Ptr device_ptr, const std::string& device_name, - AccelType device_type); - - std::string name; - Ptr ptr; - AccelType type; -}; - -struct GAPI_EXPORTS Context { - friend struct IDeviceSelector; - using Ptr = void*; - - ~Context(); - Ptr get_ptr() const; - AccelType get_type() const; -private: - Context(Ptr ctx_ptr, AccelType ctx_type); - Ptr ptr; - AccelType type; -}; - -GAPI_EXPORTS Device create_host_device(); -GAPI_EXPORTS Context create_host_context(); - -GAPI_EXPORTS Device create_dx11_device(Device::Ptr device_ptr, - const std::string& device_name); -GAPI_EXPORTS Context create_dx11_context(Context::Ptr ctx_ptr); - -GAPI_EXPORTS Device create_vaapi_device(Device::Ptr device_ptr, - const std::string& device_name); -GAPI_EXPORTS Context create_vaapi_context(Context::Ptr ctx_ptr); -} // namespace onevpl -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // GAPI_STREAMING_ONEVPL_ACCEL_TYPES_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp b/modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp deleted file mode 100644 index 0db9a86e58..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp +++ /dev/null @@ -1,209 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_ONEVPL_CFG_PARAMS_HPP -#define OPENCV_GAPI_STREAMING_ONEVPL_CFG_PARAMS_HPP - -#include -#include -#include - -#include -#include - -namespace cv { -namespace gapi { -namespace wip { -namespace onevpl { - -/** - * @brief Public class is using for creation of onevpl::GSource instances. - * - * Class members available through methods @ref CfgParam::get_name() and @ref CfgParam::get_value() are used by - * onevpl::GSource inner logic to create or find oneVPL particular implementation - * (software/hardware, specific API version and etc.). - * - * @note Because oneVPL may provide several implementations which are satisfying with multiple (or single one) @ref CfgParam - * criteria therefore it is possible to configure `preferred` parameters. This kind of CfgParams are created - * using `is_major = false` argument in @ref CfgParam::create method and are not used by creating oneVPL particular implementations. - * Instead they fill out a "score table" to select preferable implementation from available list. Implementation are satisfying - * with most of these optional params would be chosen. - * If no one optional CfgParam params were present then first of available oneVPL implementation would be applied. - * Please get on https://spec.oneapi.io/versions/latest/elements/oneVPL/source/API_ref/VPL_disp_api_func.html?highlight=mfxcreateconfig#mfxsetconfigfilterproperty - * for using OneVPL configuration. In this schema `mfxU8 *name` represents @ref CfgParam::get_name() and - * `mfxVariant value` is @ref CfgParam::get_value() - */ -struct GAPI_EXPORTS CfgParam { - using name_t = std::string; - using value_t = cv::util::variant; - /** - * @brief frames_pool_size_name - * - * Special configuration parameter name for onevp::GSource: - * - * @note frames_pool_size_name allows to allocate surfaces pool appropriate size to keep - * decoded frames in accelerator memory ready before - * they would be consumed by onevp::GSource::pull operation. If you see - * a lot of WARNING about lack of free surface then it's time to increase - * frames_pool_size_name but be aware of accelerator free memory volume. - * If not set then MFX implementation use - * mfxFrameAllocRequest::NumFrameSuggested behavior - * - */ - static constexpr const char *frames_pool_size_name() { return "frames_pool_size"; } - static CfgParam create_frames_pool_size(size_t value); - - /** - * @brief acceleration_mode_name - * - * Special configuration parameter names for onevp::GSource: - * - * @note acceleration_mode_name allows to activate hardware acceleration & - * device memory management. - * Supported values: - * - MFX_ACCEL_MODE_VIA_D3D11 Will activate DX11 acceleration and will produces - * MediaFrames with data allocated in DX11 device memory - * - * If not set then MFX implementation will use default acceleration behavior: - * all decoding operation uses default GPU resources but MediaFrame produces - * data allocated by using host RAM - * - */ - static constexpr const char *acceleration_mode_name() { return "mfxImplDescription.AccelerationMode"; } - static CfgParam create_acceleration_mode(uint32_t value); - static CfgParam create_acceleration_mode(const char* value); - - /** - * @brief decoder_id_name - * - * Special configuration parameter names for onevp::GSource: - * - * @note decoder_id_name allows to specify VPL decoder type which MUST present - * in case of RAW video input data and MUST NOT present as CfgParam if video - * stream incapsulated into container(*.mp4, *.mkv and so on). In latter case - * onevp::GSource will determine it automatically - * Supported values: - * - MFX_CODEC_AVC - * - MFX_CODEC_HEVC - * - MFX_CODEC_MPEG2 - * - MFX_CODEC_VC1 - * - MFX_CODEC_CAPTURE - * - MFX_CODEC_VP9 - * - MFX_CODEC_AV1 - * - */ - static constexpr const char *decoder_id_name() { return "mfxImplDescription.mfxDecoderDescription.decoder.CodecID"; } - static CfgParam create_decoder_id(uint32_t value); - static CfgParam create_decoder_id(const char* value); - - static constexpr const char *implementation_name() { return "mfxImplDescription.Impl"; } - static CfgParam create_implementation(uint32_t value); - static CfgParam create_implementation(const char* value); - - - static constexpr const char *vpp_frames_pool_size_name() { return "vpp_frames_pool_size"; } - static CfgParam create_vpp_frames_pool_size(size_t value); - - static constexpr const char *vpp_in_width_name() { return "vpp.In.Width"; } - static CfgParam create_vpp_in_width(uint16_t value); - - static constexpr const char *vpp_in_height_name() { return "vpp.In.Height"; } - static CfgParam create_vpp_in_height(uint16_t value); - - static constexpr const char *vpp_in_crop_x_name() { return "vpp.In.CropX"; } - static CfgParam create_vpp_in_crop_x(uint16_t value); - - static constexpr const char *vpp_in_crop_y_name() { return "vpp.In.CropY"; } - static CfgParam create_vpp_in_crop_y(uint16_t value); - - static constexpr const char *vpp_in_crop_w_name() { return "vpp.In.CropW"; } - static CfgParam create_vpp_in_crop_w(uint16_t value); - - static constexpr const char *vpp_in_crop_h_name() { return "vpp.In.CropH"; } - static CfgParam create_vpp_in_crop_h(uint16_t value); - - - static constexpr const char *vpp_out_fourcc_name() { return "vpp.Out.FourCC"; } - static CfgParam create_vpp_out_fourcc(uint32_t value); - - static constexpr const char *vpp_out_chroma_format_name() { return "vpp.Out.ChromaFormat"; } - static CfgParam create_vpp_out_chroma_format(uint16_t value); - - static constexpr const char *vpp_out_width_name() { return "vpp.Out.Width"; } - static CfgParam create_vpp_out_width(uint16_t value); - - static constexpr const char *vpp_out_height_name() { return "vpp.Out.Height"; } - static CfgParam create_vpp_out_height(uint16_t value); - - static constexpr const char *vpp_out_crop_x_name() { return "vpp.Out.CropX"; } - static CfgParam create_vpp_out_crop_x(uint16_t value); - - static constexpr const char *vpp_out_crop_y_name() { return "vpp.Out.CropY"; } - static CfgParam create_vpp_out_crop_y(uint16_t value); - - static constexpr const char *vpp_out_crop_w_name() { return "vpp.Out.CropW"; } - static CfgParam create_vpp_out_crop_w(uint16_t value); - - static constexpr const char *vpp_out_crop_h_name() { return "vpp.Out.CropH"; } - static CfgParam create_vpp_out_crop_h(uint16_t value); - - static constexpr const char *vpp_out_pic_struct_name() { return "vpp.Out.PicStruct"; } - static CfgParam create_vpp_out_pic_struct(uint16_t value); - - static constexpr const char *vpp_out_framerate_n_name() { return "vpp.Out.FrameRateExtN"; } - static CfgParam create_vpp_out_framerate_n(uint32_t value); - - static constexpr const char *vpp_out_framerate_d_name() { return "vpp.Out.FrameRateExtD"; } - static CfgParam create_vpp_out_framerate_d(uint32_t value); - - /** - * Create generic onevp::GSource configuration parameter. - * - *@param name name of parameter. - *@param value value of parameter. - *@param is_major TRUE if parameter MUST be provided by OneVPL inner implementation, FALSE for optional (for resolve multiple available implementations). - * - */ - template - static CfgParam create(const std::string& name, ValueType&& value, bool is_major = true) { - CfgParam param(name, CfgParam::value_t(std::forward(value)), is_major); - return param; - } - - struct Priv; - - const name_t& get_name() const; - const value_t& get_value() const; - bool is_major() const; - std::string to_string() const; - - bool operator==(const CfgParam& rhs) const; - bool operator< (const CfgParam& rhs) const; - bool operator!=(const CfgParam& rhs) const; - - CfgParam& operator=(const CfgParam& src); - CfgParam& operator=(CfgParam&& src); - CfgParam(const CfgParam& src); - CfgParam(CfgParam&& src); - ~CfgParam(); -private: - CfgParam(const std::string& param_name, value_t&& param_value, bool is_major_param); - std::shared_ptr m_priv; -}; - -} //namespace onevpl -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_ONEVPL_CFG_PARAMS_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/onevpl/data_provider_interface.hpp b/modules/gapi/include/opencv2/gapi/streaming/onevpl/data_provider_interface.hpp deleted file mode 100644 index ec683a7527..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/onevpl/data_provider_interface.hpp +++ /dev/null @@ -1,105 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef GAPI_STREAMING_ONEVPL_ONEVPL_DATA_PROVIDER_INTERFACE_HPP -#define GAPI_STREAMING_ONEVPL_ONEVPL_DATA_PROVIDER_INTERFACE_HPP -#include -#include -#include - -#include // GAPI_EXPORTS -namespace cv { -namespace gapi { -namespace wip { -namespace onevpl { - -struct GAPI_EXPORTS DataProviderException : public std::exception { - DataProviderException(const std::string& descr); - DataProviderException(std::string&& descr); - - virtual ~DataProviderException() = default; - virtual const char* what() const noexcept override; -private: - std::string reason; -}; - -struct GAPI_EXPORTS DataProviderSystemErrorException final : public DataProviderException { - DataProviderSystemErrorException(int error_code, const std::string& description = std::string()); - ~DataProviderSystemErrorException() = default; -}; - -struct GAPI_EXPORTS DataProviderUnsupportedException final : public DataProviderException { - DataProviderUnsupportedException(const std::string& description); - ~DataProviderUnsupportedException() = default; -}; - -struct GAPI_EXPORTS DataProviderImplementationException : public DataProviderException { - DataProviderImplementationException(const std::string& description); - ~DataProviderImplementationException() = default; -}; -/** - * @brief Public interface allows to customize extraction of video stream data - * used by onevpl::GSource instead of reading stream from file (by default). - * - * Interface implementation constructor MUST provide consistency and creates fully operable object. - * If error happened implementation MUST throw `DataProviderException` kind exceptions - * - * @note Interface implementation MUST manage stream and other constructed resources by itself to avoid any kind of leak. - * For simple interface implementation example please see `StreamDataProvider` in `tests/streaming/gapi_streaming_tests.cpp` - */ -struct GAPI_EXPORTS IDataProvider { - using Ptr = std::shared_ptr; - using mfx_codec_id_type = uint32_t; - - /** - * NB: here is supposed to be forward declaration of mfxBitstream - * But according to current oneVPL implementation it is impossible to forward - * declare untagged struct mfxBitstream. - * - * IDataProvider makes sense only for HAVE_VPL is ON and to keep IDataProvider - * interface API/ABI compliant between core library and user application layer - * let's introduce wrapper mfx_bitstream which inherits mfxBitstream in private - * G-API code section and declare forward for wrapper mfx_bitstream here - */ - struct mfx_bitstream; - - virtual ~IDataProvider() = default; - - /** - * The function is used by onevpl::GSource to extract codec id from data - * - */ - virtual mfx_codec_id_type get_mfx_codec_id() const = 0; - - /** - * The function is used by onevpl::GSource to extract binary data stream from @ref IDataProvider - * implementation. - * - * It MUST throw `DataProviderException` kind exceptions in fail cases. - * It MUST return MFX_ERR_MORE_DATA in EOF which considered as not-fail case. - * - * @param in_out_bitsream the input-output reference on MFX bitstream buffer which MUST be empty at the first request - * to allow implementation to allocate it by itself and to return back. Subsequent invocation of `fetch_bitstream_data` - * MUST use the previously used in_out_bitsream to avoid skipping rest of frames which haven't been consumed - * @return true for fetched data, false on EOF and throws exception on error - */ - virtual bool fetch_bitstream_data(std::shared_ptr &in_out_bitsream) = 0; - - /** - * The function is used by onevpl::GSource to check more binary data availability. - * - * It MUST return TRUE in case of EOF and NO_THROW exceptions. - * - * @return boolean value which detects end of stream - */ - virtual bool empty() const = 0; -}; -} // namespace onevpl -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // GAPI_STREAMING_ONEVPL_ONEVPL_DATA_PROVIDER_INTERFACE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/onevpl/default.hpp b/modules/gapi/include/opencv2/gapi/streaming/onevpl/default.hpp deleted file mode 100644 index 8b547e1aba..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/onevpl/default.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2022 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_ONEVPL_UTILS_HPP -#define OPENCV_GAPI_STREAMING_ONEVPL_UTILS_HPP - -#include // GAPI_EXPORTS -#include -#include - -namespace cv { -namespace gapi { -namespace wip { -namespace onevpl { - -/** - * @brief Provides default device selector based on config. - */ -GAPI_EXPORTS std::shared_ptr getDefaultDeviceSelector(const std::vector& cfg_params); - -} // namespace onevpl -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_ONEVPL_UTILS_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp b/modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp deleted file mode 100644 index 2e2d879fba..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp +++ /dev/null @@ -1,61 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef GAPI_STREAMING_ONEVPL_DEVICE_SELECTOR_INTERFACE_HPP -#define GAPI_STREAMING_ONEVPL_DEVICE_SELECTOR_INTERFACE_HPP - -#include -#include -#include -#include - -#include - -namespace cv { -namespace gapi { -namespace wip { -namespace onevpl { -struct GAPI_EXPORTS IDeviceSelector { - using Ptr = std::shared_ptr; - - struct GAPI_EXPORTS Score { - friend struct IDeviceSelector; - using Type = int16_t; - static constexpr Type MaxActivePriority = std::numeric_limits::max(); - static constexpr Type MinActivePriority = 0; - static constexpr Type MaxPassivePriority = MinActivePriority - 1; - static constexpr Type MinPassivePriority = std::numeric_limits::min(); - - Score(Type val); - ~Score(); - - operator Type () const; - Type get() const; - friend bool operator< (Score lhs, Score rhs) { - return lhs.get() < rhs.get(); - } - private: - Type value; - }; - - using DeviceScoreTable = std::map; - using DeviceContexts = std::vector; - - virtual ~IDeviceSelector(); - virtual DeviceScoreTable select_devices() const = 0; - virtual DeviceContexts select_context() = 0; -protected: - template - static Entity create(Args &&...args) { - return Entity(std::forward(args)...); - } -}; -} // namespace onevpl -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // GAPI_STREAMING_ONEVPL_DEVICE_SELECTOR_INTERFACE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/onevpl/source.hpp b/modules/gapi/include/opencv2/gapi/streaming/onevpl/source.hpp deleted file mode 100644 index 04dc2e246d..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/onevpl/source.hpp +++ /dev/null @@ -1,94 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_ONEVPL_ONEVPL_SOURCE_HPP -#define OPENCV_GAPI_STREAMING_ONEVPL_ONEVPL_SOURCE_HPP - -#include -#include -#include -#include -#include -#include - -namespace cv { -namespace gapi { -namespace wip { -namespace onevpl { -using CfgParams = std::vector; - -/** - * @brief G-API streaming source based on OneVPL implementation. - * - * This class implements IStreamSource interface. - * Its constructor takes source file path (in usual way) or @ref onevpl::IDataProvider - * interface implementation (for not file-based sources). It also allows to pass-through - * oneVPL configuration parameters by using several @ref onevpl::CfgParam. - * - * @note stream sources are passed to G-API via shared pointers, so - * please gapi::make_onevpl_src<> to create objects and ptr() to pass a - * GSource to cv::gin(). - */ -class GAPI_EXPORTS GSource : public IStreamSource -{ -public: - struct Priv; - - GSource(const std::string& filePath, - const CfgParams& cfg_params = CfgParams{}); - - GSource(const std::string& filePath, - const CfgParams& cfg_params, - const std::string& device_id, - void* accel_device_ptr, - void* accel_ctx_ptr); - - GSource(const std::string& filePath, - const CfgParams& cfg_params, - const Device &device, const Context &ctx); - - GSource(const std::string& filePath, - const CfgParams& cfg_params, - std::shared_ptr selector); - - - GSource(std::shared_ptr source, - const CfgParams& cfg_params = CfgParams{}); - - GSource(std::shared_ptr source, - const CfgParams& cfg_params, - const std::string& device_id, - void* accel_device_ptr, - void* accel_ctx_ptr); - - GSource(std::shared_ptr source, - const CfgParams& cfg_params, - std::shared_ptr selector); - - ~GSource() override; - - bool pull(cv::gapi::wip::Data& data) override; - GMetaArg descr_of() const override; - -private: - explicit GSource(std::unique_ptr&& impl); - std::unique_ptr m_priv; -}; -} // namespace onevpl - -using GVPLSource = onevpl::GSource; - -template -GAPI_EXPORTS_W cv::Ptr inline make_onevpl_src(Args&&... args) -{ - return make_src(std::forward(args)...); -} - -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_ONEVPL_ONEVPL_SOURCE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/queue_source.hpp b/modules/gapi/include/opencv2/gapi/streaming/queue_source.hpp deleted file mode 100644 index bd385ed16e..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/queue_source.hpp +++ /dev/null @@ -1,67 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2023 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_QUEUE_SOURCE_HPP -#define OPENCV_GAPI_STREAMING_QUEUE_SOURCE_HPP - -#include // shared_ptr -#include // is_base_of - -#include // GRunArgs -#include // GMetaArg + all descr_of -#include // IStreamSource - -namespace cv { -namespace gapi { -namespace wip { -struct Data; // fwd-declare to avoid circular? header dependencies - -class GAPI_EXPORTS QueueSourceBase: public cv::gapi::wip::IStreamSource { - class Priv; - std::shared_ptr m_priv; - // FIXME: Need to understand how it works with IStreamSource's shared_from_this - // Can we avoid having too many shared_ptrs here? - -public: - explicit QueueSourceBase(const cv::GMetaArg &m); - void push(Data &&data); - virtual bool pull(Data &data) override; - virtual void halt() override; - virtual GMetaArg descr_of() const override; - virtual ~QueueSourceBase() = default; -}; - -/** - * @brief Queued streaming pipeline source. - * - */ -template -class QueueSource final: public QueueSourceBase -{ -public: - using Meta = decltype(cv::descr_of(T{})); - explicit QueueSource(Meta m) : QueueSourceBase(GMetaArg{m}) { - } - void push(T t) { - QueueSourceBase::push(Data{t}); - } -}; - -class GAPI_EXPORTS QueueInput { - std::vector > m_sources; - -public: - explicit QueueInput(const cv::GMetaArgs &args); - - void push(cv::GRunArgs &&ins); - operator cv::GRunArgs(); -}; - -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_SOURCE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/source.hpp b/modules/gapi/include/opencv2/gapi/streaming/source.hpp deleted file mode 100644 index 267469ad1b..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/source.hpp +++ /dev/null @@ -1,67 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2019 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_SOURCE_HPP -#define OPENCV_GAPI_STREAMING_SOURCE_HPP - -#include // shared_ptr -#include // is_base_of - -#include // GMetaArg - - -namespace cv { -namespace gapi { -namespace wip { -struct Data; // forward-declaration of Data to avoid circular dependencies - -/** - * @brief Abstract streaming pipeline source. - * - * Implement this interface if you want customize the way how data is - * streaming into GStreamingCompiled. - * - * Objects implementing this interface can be passed to - * GStreamingCompiled using setSource() with cv::gin(). Regular - * compiled graphs (GCompiled) don't support input objects of this - * type. - * - * Default cv::VideoCapture-based implementation is available, see - * cv::gapi::wip::GCaptureSource. - * - * @note stream sources are passed to G-API via shared pointers, so - * please use ptr() when passing a IStreamSource implementation to - * cv::gin(). - */ -class IStreamSource: public std::enable_shared_from_this -{ -public: - using Ptr = std::shared_ptr; - Ptr ptr() { return shared_from_this(); } - virtual bool pull(Data &data) = 0; - virtual GMetaArg descr_of() const = 0; - virtual void halt() { - // Do nothing by default to maintain compatibility with the existing sources... - // In fact needs to be decorated atop of the child classes to maintain the behavior - // FIXME: Make it mandatory in OpenCV 5.0 - }; - virtual ~IStreamSource() = default; -}; - -template -IStreamSource::Ptr inline make_src(Args&&... args) -{ - static_assert(std::is_base_of::value, - "T must implement the cv::gapi::IStreamSource interface!"); - auto src_ptr = std::make_shared(std::forward(args)...); - return src_ptr->ptr(); -} - -} // namespace wip -} // namespace gapi -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_SOURCE_HPP diff --git a/modules/gapi/include/opencv2/gapi/streaming/sync.hpp b/modules/gapi/include/opencv2/gapi/streaming/sync.hpp deleted file mode 100644 index 5801e6f00a..0000000000 --- a/modules/gapi/include/opencv2/gapi/streaming/sync.hpp +++ /dev/null @@ -1,30 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_STREAMING_SYNC_HPP -#define OPENCV_GAPI_STREAMING_SYNC_HPP - -namespace cv { -namespace gapi { -namespace streaming { - -enum class sync_policy { - dont_sync, - drop -}; - -} // namespace streaming -} // namespace gapi - -namespace detail { - template<> struct CompileArgTag { - static const char* tag() { return "gapi.streaming.sync_policy"; } - }; - -} // namespace detail -} // namespace cv - -#endif // OPENCV_GAPI_STREAMING_SYNC_HPP diff --git a/modules/gapi/include/opencv2/gapi/util/any.hpp b/modules/gapi/include/opencv2/gapi/util/any.hpp deleted file mode 100644 index 94451c7717..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/any.hpp +++ /dev/null @@ -1,190 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_UTIL_ANY_HPP -#define OPENCV_GAPI_UTIL_ANY_HPP - -#include -#include -#include -#include - -#include - -#if defined(_MSC_VER) - // disable MSVC warning on "multiple copy constructors specified" -# pragma warning(disable: 4521) -#endif - -namespace cv -{ - -namespace internal -{ - template - T down_cast(Source operand) - { -#if defined(__GXX_RTTI) || defined(_CPPRTTI) - return dynamic_cast(operand); -#else -#ifdef __GNUC__ -#warning used static cast instead of dynamic because RTTI is disabled -#else -#pragma message("WARNING: used static cast instead of dynamic because RTTI is disabled") -#endif - return static_cast(operand); -#endif - } -} - -namespace util -{ - class bad_any_cast : public std::bad_cast - { - public: - virtual const char* what() const noexcept override - { - return "Bad any cast"; - } - }; - - //modeled against C++17 std::any - - class any - { - private: - struct holder; - using holder_ptr = std::unique_ptr; - struct holder - { - virtual holder_ptr clone() = 0; - virtual ~holder() = default; - }; - - template - struct holder_impl : holder - { - value_t v; - template - holder_impl(arg_t&& a) : v(std::forward(a)) {} - holder_ptr clone() override { return holder_ptr(new holder_impl (v));} - }; - - holder_ptr hldr; - public: - template - any(value_t&& arg) : hldr(new holder_impl::type>( std::forward(arg))) {} - - any(any const& src) : hldr( src.hldr ? src.hldr->clone() : nullptr) {} - //simple hack in order not to write enable_if for the template constructor - any(any & src) : any (const_cast(src)) {} - - any() = default; - any(any&& ) = default; - - any& operator=(any&&) = default; - - any& operator=(any const& src) - { - any copy(src); - swap(*this, copy); - return *this; - } - - template - friend value_t* any_cast(any* operand); - - template - friend const value_t* any_cast(const any* operand); - - template - friend value_t& unsafe_any_cast(any& operand); - - template - friend const value_t& unsafe_any_cast(const any& operand); - - friend void swap(any & lhs, any& rhs) - { - swap(lhs.hldr, rhs.hldr); - } - - }; - - template - value_t* any_cast(any* operand) - { - auto casted = internal::down_cast::type> *>(operand->hldr.get()); - if (casted){ - return & (casted->v); - } - return nullptr; - } - - template - const value_t* any_cast(const any* operand) - { - auto casted = internal::down_cast::type> *>(operand->hldr.get()); - if (casted){ - return & (casted->v); - } - return nullptr; - } - - template - value_t& any_cast(any& operand) - { - auto ptr = any_cast(&operand); - if (ptr) - { - return *ptr; - } - - throw_error(bad_any_cast()); - } - - - template - const value_t& any_cast(const any& operand) - { - auto ptr = any_cast(&operand); - if (ptr) - { - return *ptr; - } - - throw_error(bad_any_cast()); - } - - template - inline value_t& unsafe_any_cast(any& operand) - { -#ifdef DEBUG - return any_cast(operand); -#else - return static_cast::type> *>(operand.hldr.get())->v; -#endif - } - - template - inline const value_t& unsafe_any_cast(const any& operand) - { -#ifdef DEBUG - return any_cast(operand); -#else - return static_cast::type> *>(operand.hldr.get())->v; -#endif - } - -} // namespace util -} // namespace cv - -#if defined(_MSC_VER) - // Enable "multiple copy constructors specified" back -# pragma warning(default: 4521) -#endif - -#endif // OPENCV_GAPI_UTIL_ANY_HPP diff --git a/modules/gapi/include/opencv2/gapi/util/compiler_hints.hpp b/modules/gapi/include/opencv2/gapi/util/compiler_hints.hpp deleted file mode 100644 index a41a97145d..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/compiler_hints.hpp +++ /dev/null @@ -1,19 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - -#ifndef OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP -#define OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP - -namespace cv -{ -namespace util -{ - //! Utility template function to prevent "unused" warnings by various compilers. - template void suppress_unused_warning( const T& ) {} -} // namespace util -} // namespace cv - -#endif /* OPENCV_GAPI_UTIL_COMPILER_HINTS_HPP */ diff --git a/modules/gapi/include/opencv2/gapi/util/copy_through_move.hpp b/modules/gapi/include/opencv2/gapi/util/copy_through_move.hpp deleted file mode 100644 index 1a1121eb21..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/copy_through_move.hpp +++ /dev/null @@ -1,34 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP -#define OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP - -#include //decay_t - -namespace cv -{ -namespace util -{ - //This is a tool to move initialize captures of a lambda in C++11 - template - struct copy_through_move_t{ - T value; - const T& get() const {return value;} - T& get() {return value;} - copy_through_move_t(T&& g) : value(std::move(g)) {} - copy_through_move_t(copy_through_move_t&&) = default; - copy_through_move_t(copy_through_move_t const& lhs) : copy_through_move_t(std::move(const_cast(lhs))) {} - }; - - template - copy_through_move_t> copy_through_move(T&& t){ - return std::forward(t); - } -} // namespace util -} // namespace cv - -#endif /* OPENCV_GAPI_UTIL_COPY_THROUGH_MOVE_HPP */ diff --git a/modules/gapi/include/opencv2/gapi/util/optional.hpp b/modules/gapi/include/opencv2/gapi/util/optional.hpp deleted file mode 100644 index dca03cadad..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/optional.hpp +++ /dev/null @@ -1,178 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_UTIL_OPTIONAL_HPP -#define OPENCV_GAPI_UTIL_OPTIONAL_HPP - -#include - -// A poor man's `optional` implementation, incompletely modeled against C++17 spec. -namespace cv -{ -namespace util -{ - class bad_optional_access: public std::exception - { - public: - virtual const char *what() const noexcept override - { - return "Bad optional access"; - } - }; - - // TODO: nullopt_t - - // Interface /////////////////////////////////////////////////////////////// - template class optional - { - public: - // Constructors - // NB.: there were issues with Clang 3.8 when =default() was used - // instead {} - optional() {} - optional(const optional&) = default; - explicit optional(T&&) noexcept; - explicit optional(const T&) noexcept; - optional(optional&&) noexcept; - // TODO: optional(nullopt_t) noexcept; - // TODO: optional(const optional &) - // TODO: optional(optional &&) - // TODO: optional(Args&&...) - // TODO: optional(initializer_list) - // TODO: optional(U&& value); - - // Assignment - optional& operator=(const optional&) = default; - optional& operator=(optional&&); - - // Observers - T* operator-> (); - const T* operator-> () const; - T& operator* (); - const T& operator* () const; - // TODO: && versions - - operator bool() const noexcept; - bool has_value() const noexcept; - - T& value(); - const T& value() const; - // TODO: && versions - - template - T value_or(U &&default_value) const; - - void swap(optional &other) noexcept; - void reset() noexcept; - // TODO: emplace - - // TODO: operator==, !=, <, <=, >, >= - - private: - struct nothing {}; - util::variant m_holder; - }; - - template - optional::type> make_optional(T&& value); - - // TODO: Args... and initializer_list versions - - // Implementation ////////////////////////////////////////////////////////// - template optional::optional(T &&v) noexcept - : m_holder(std::move(v)) - { - } - - template optional::optional(const T &v) noexcept - : m_holder(v) - { - } - - template optional::optional(optional&& rhs) noexcept - : m_holder(std::move(rhs.m_holder)) - { - rhs.reset(); - } - - template optional& optional::operator=(optional&& rhs) - { - m_holder = std::move(rhs.m_holder); - rhs.reset(); - return *this; - } - - template T* optional::operator-> () - { - return & *(*this); - } - - template const T* optional::operator-> () const - { - return & *(*this); - } - - template T& optional::operator* () - { - return this->value(); - } - - template const T& optional::operator* () const - { - return this->value(); - } - - template optional::operator bool() const noexcept - { - return this->has_value(); - } - - template bool optional::has_value() const noexcept - { - return util::holds_alternative(m_holder); - } - - template T& optional::value() - { - if (!this->has_value()) - throw_error(bad_optional_access()); - return util::get(m_holder); - } - - template const T& optional::value() const - { - if (!this->has_value()) - throw_error(bad_optional_access()); - return util::get(m_holder); - } - - template - template T optional::value_or(U &&default_value) const - { - return (this->has_value() ? this->value() : T(default_value)); - } - - template void optional::swap(optional &other) noexcept - { - m_holder.swap(other.m_holder); - } - - template void optional::reset() noexcept - { - if (this->has_value()) - m_holder = nothing{}; - } - - template - optional::type> make_optional(T&& value) - { - return optional::type>(std::forward(value)); - } -} // namespace util -} // namespace cv - -#endif // OPENCV_GAPI_UTIL_OPTIONAL_HPP diff --git a/modules/gapi/include/opencv2/gapi/util/throw.hpp b/modules/gapi/include/opencv2/gapi/util/throw.hpp deleted file mode 100644 index 689bf583cf..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/throw.hpp +++ /dev/null @@ -1,36 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_UTIL_THROW_HPP -#define OPENCV_GAPI_UTIL_THROW_HPP - -#include // std::forward - -#if !defined(__EXCEPTIONS) -#include -#include -#endif - -namespace cv -{ -namespace util -{ -template -[[noreturn]] void throw_error(ExceptionType &&e) -{ -#if defined(__EXCEPTIONS) || defined(_CPPUNWIND) - throw std::forward(e); -#else - fprintf(stderr, "An exception thrown! %s\n" , e.what()); - fflush(stderr); - abort(); -#endif -} -} // namespace util -} // namespace cv - -#endif // OPENCV_GAPI_UTIL_THROW_HPP diff --git a/modules/gapi/include/opencv2/gapi/util/type_traits.hpp b/modules/gapi/include/opencv2/gapi/util/type_traits.hpp deleted file mode 100644 index 637f18460b..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/type_traits.hpp +++ /dev/null @@ -1,31 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - - -#ifndef OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP -#define OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP - -#include - -namespace cv -{ -namespace util -{ - //these are C++14 parts of type_traits : - template< bool B, class T = void > - using enable_if_t = typename std::enable_if::type; - - template - using decay_t = typename std::decay::type; - - //this is not part of C++14 but still, of pretty common usage - template - using are_different_t = enable_if_t< !std::is_same, decay_t>::value, V>; - -} // namespace cv -} // namespace util - -#endif // OPENCV_GAPI_UTIL_TYPE_TRAITS_HPP diff --git a/modules/gapi/include/opencv2/gapi/util/util.hpp b/modules/gapi/include/opencv2/gapi/util/util.hpp deleted file mode 100644 index 3be46d7ec2..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/util.hpp +++ /dev/null @@ -1,190 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018-2019 Intel Corporation - - -#ifndef OPENCV_GAPI_UTIL_HPP -#define OPENCV_GAPI_UTIL_HPP - -#include - -// \cond HIDDEN_SYMBOLS -// This header file contains some generic utility functions which are -// used in other G-API Public API headers. -// -// PLEASE don't put any stuff here if it is NOT used in public API headers! - -namespace cv -{ -namespace detail -{ - // Recursive integer sequence type, useful for enumerating elements of - // template parameter packs. - template struct Seq { using next = Seq; }; - template struct MkSeq { using type = typename MkSeq::type::next; }; - template<> struct MkSeq<0>{ using type = Seq<>; }; - - // Checks if elements of variadic template satisfy the given Predicate. - // Implemented via tuple, with an interface to accept plain type lists - template class, typename, typename...> struct all_satisfy; - - template class F, typename T, typename... Ts> - struct all_satisfy > - { - static const constexpr bool value = F::value - && all_satisfy >::value; - }; - template class F, typename T> - struct all_satisfy > - { - static const constexpr bool value = F::value; - }; - - template class F, typename T, typename... Ts> - struct all_satisfy: public all_satisfy > {}; - - // Permute given tuple type C with given integer sequence II - // Sequence may be less than tuple C size. - template struct permute_tuple; - - template - struct permute_tuple > - { - using type = std::tuple< typename std::tuple_element::type... >; - }; - - // Given T..., generates a type sequence of sizeof...(T)-1 elements - // which is T... without its last element - // Implemented via tuple, with an interface to accept plain type lists - template struct all_but_last; - - template - struct all_but_last > - { - using C = std::tuple; - using S = typename MkSeq::value - 1>::type; - using type = typename permute_tuple::type; - }; - - template - struct all_but_last: public all_but_last > {}; - - template - using all_but_last_t = typename all_but_last::type; - - // NB.: This is here because there's no constexpr std::max in C++11 - template struct max_of_t - { - static constexpr const std::size_t rest = max_of_t::value; - static constexpr const std::size_t value = rest > S0 ? rest : S0; - }; - template struct max_of_t - { - static constexpr const std::size_t value = S; - }; - - template - struct contains : std::false_type{}; - - template - struct contains : std::integral_constant::value || - contains::value> {}; - template - struct contains> : std::integral_constant::value> {}; - - template - struct all_unique : std::true_type{}; - - template - struct all_unique : std::integral_constant::value && - all_unique::value> {}; - - template - struct tuple_wrap_helper; - - template struct tuple_wrap_helper - { - using type = std::tuple; - static type get(T&& obj) { return std::make_tuple(std::move(obj)); } - }; - - template - struct tuple_wrap_helper> - { - using type = std::tuple; - static type get(std::tuple&& objs) { return std::forward>(objs); } - }; - - template - struct make_void { typedef void type;}; - - template - using void_t = typename make_void::type; - -} // namespace detail - -namespace util -{ -template -struct overload_lamba_set; - -template -struct overload_lamba_set : public L1 -{ - overload_lamba_set(L1&& lambda) : L1(std::move(lambda)) {} - overload_lamba_set(const L1& lambda) : L1(lambda) {} - - using L1::operator(); -}; - -template -struct overload_lamba_set : public L1, public overload_lamba_set -{ - using base_type = overload_lamba_set; - overload_lamba_set(L1 &&lambda1, L&& ...lambdas): - L1(std::move(lambda1)), - base_type(std::forward(lambdas)...) {} - - overload_lamba_set(const L1 &lambda1, L&& ...lambdas): - L1(lambda1), - base_type(std::forward(lambdas)...) {} - - using L1::operator(); - using base_type::operator(); -}; - -template -overload_lamba_set overload_lambdas(L&& ...lambdas) -{ - return overload_lamba_set(std::forward(lambdas)...); -} - -template -struct find_adapter_impl; - -template -struct find_adapter_impl -{ - using type = typename std::conditional::value, - T, - void>::type; - static constexpr bool found = std::is_base_of::value; -}; - -template -struct find_adapter_impl -{ - using type = typename std::conditional::value, - T, - typename find_adapter_impl::type>::type; - static constexpr bool found = std::is_base_of::value || - find_adapter_impl::found; -}; -} // namespace util -} // namespace cv - -// \endcond - -#endif // OPENCV_GAPI_UTIL_HPP diff --git a/modules/gapi/include/opencv2/gapi/util/variant.hpp b/modules/gapi/include/opencv2/gapi/util/variant.hpp deleted file mode 100644 index 48b55646c5..0000000000 --- a/modules/gapi/include/opencv2/gapi/util/variant.hpp +++ /dev/null @@ -1,667 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2018 Intel Corporation - - -#ifndef OPENCV_GAPI_UTIL_VARIANT_HPP -#define OPENCV_GAPI_UTIL_VARIANT_HPP - -#include -#include - -#include -#include -#include // max_of_t -#include - -// A poor man's `variant` implementation, incompletely modeled against C++17 spec. -namespace cv -{ -namespace util -{ - namespace detail - { - template - struct type_list_index_helper - { - static const constexpr bool is_same = std::is_same::value; - static const constexpr std::size_t value = - std::conditional, type_list_index_helper>::type::value; - }; - - template - struct type_list_index_helper - { - static_assert(std::is_same::value, "Type not found"); - static const constexpr std::size_t value = I; - }; - } - - template - struct type_list_index - { - static const constexpr std::size_t value = detail::type_list_index_helper<0, Target, Types...>::value; - }; - - template - struct type_list_element - { - using type = typename std::tuple_element >::type; - }; - - class bad_variant_access: public std::exception - { - public: - virtual const char *what() const noexcept override - { - return "Bad variant access"; - } - }; - - // Interface /////////////////////////////////////////////////////////////// - struct monostate {}; - inline bool operator==(const util::monostate&, const util::monostate&) - { - return true; - } - - template // FIXME: no references, arrays, and void - class variant - { - // FIXME: Replace with std::aligned_union after gcc4.8 support is dropped - static constexpr const std::size_t S = cv::detail::max_of_t::value; - static constexpr const std::size_t A = cv::detail::max_of_t::value; - using Memory = typename std::aligned_storage::type[1]; - - template struct cctr_h { - static void help(Memory memory, const Memory from) { - new (memory) T(*reinterpret_cast(from)); - } - }; - - template struct mctr_h { - static void help(Memory memory, void *pval) { - new (memory) T(std::move(*reinterpret_cast(pval))); - } - }; - - //FIXME: unify with cctr_h and mctr_h - template struct cnvrt_ctor_h { - static void help(Memory memory, void* from) { - using util::decay_t; - new (memory) decay_t(std::forward(*reinterpret_cast*>(from))); - } - }; - - template struct copy_h { - static void help(Memory to, const Memory from) { - *reinterpret_cast(to) = *reinterpret_cast(from); - } - }; - - template struct move_h { - static void help(Memory to, Memory from) { - *reinterpret_cast(to) = std::move(*reinterpret_cast(from)); - } - }; - - //FIXME: unify with copy_h and move_h - template struct cnvrt_assign_h { - static void help(Memory to, void* from) { - using util::decay_t; - *reinterpret_cast*>(to) = std::forward(*reinterpret_cast*>(from)); - } - }; - - template struct swap_h { - static void help(Memory to, Memory from) { - std::swap(*reinterpret_cast(to), *reinterpret_cast(from)); - } - }; - - template struct dtor_h { - static void help(Memory memory) { - (void) memory; // MSCV warning - reinterpret_cast(memory)->~T(); - } - }; - - template struct equal_h { - static bool help(const Memory lhs, const Memory rhs) { - const T& t_lhs = *reinterpret_cast(lhs); - const T& t_rhs = *reinterpret_cast(rhs); - return t_lhs == t_rhs; - } - }; - - typedef void (*CCtr) (Memory, const Memory); // Copy c-tor (variant) - typedef void (*MCtr) (Memory, void*); // Generic move c-tor - typedef void (*Copy) (Memory, const Memory); // Copy assignment - typedef void (*Move) (Memory, Memory); // Move assignment - - typedef void (*Swap) (Memory, Memory); // Swap - typedef void (*Dtor) (Memory); // Destructor - - using cnvrt_assgn_t = void (*) (Memory, void*); // Converting assignment (via std::forward) - using cnvrt_ctor_t = void (*) (Memory, void*); // Converting constructor (via std::forward) - - typedef bool (*Equal)(const Memory, const Memory); // Equality test (external) - - static constexpr std::array cctrs(){ return {{(&cctr_h::help)...}};} - static constexpr std::array mctrs(){ return {{(&mctr_h::help)...}};} - static constexpr std::array cpyrs(){ return {{(©_h::help)...}};} - static constexpr std::array mvers(){ return {{(&move_h::help)...}};} - static constexpr std::array swprs(){ return {{(&swap_h::help)...}};} - static constexpr std::array dtors(){ return {{(&dtor_h::help)...}};} - - template - struct conditional_ref : std::conditional::type&, typename std::remove_reference::type > {}; - - template - using conditional_ref_t = typename conditional_ref::type; - - - template - static constexpr std::array cnvrt_assgnrs(){ - return {{(&cnvrt_assign_h>::help)...}}; - } - - template - static constexpr std::array cnvrt_ctors(){ - return {{(&cnvrt_ctor_h>::help)...}}; - } - - std::size_t m_index = 0; - - protected: - template friend T& get(variant &v); - template friend const T& get(const variant &v); - template friend T* get_if(variant *v) noexcept; - template friend const T* get_if(const variant *v) noexcept; - - template friend bool operator==(const variant &lhs, - const variant &rhs); - Memory memory; - - public: - // Constructors - variant() noexcept; - variant(const variant& other); - variant(variant&& other) noexcept; - // are_different_t is a SFINAE trick to avoid variant(T &&t) with T=variant - // for some reason, this version is called instead of variant(variant&& o) when - // variant is used in STL containers (examples: vector assignment). - template< - typename T, - typename = util::are_different_t - > - explicit variant(T&& t); - // template explicit variant(Args&&... args); - // FIXME: other constructors - - // Destructor - ~variant(); - - // Assignment - variant& operator=(const variant& rhs); - variant& operator=(variant &&rhs) noexcept; - - // SFINAE trick to avoid operator=(T&&) with T=variant<>, see comment above - template< - typename T, - typename = util::are_different_t - > - variant& operator=(T&& t) noexcept; - - // Observers - std::size_t index() const noexcept; - // FIXME: valueless_by_exception() - - // Modifiers - // FIXME: emplace() - void swap(variant &rhs) noexcept; - - // Non-C++17x! - template static constexpr std::size_t index_of(); - }; - - // FIMXE: visit - template - T* get_if(util::variant* v) noexcept; - - template - const T* get_if(const util::variant* v) noexcept; - - template - T& get(util::variant &v); - - template - const T& get(const util::variant &v); - - template - typename util::type_list_element::type& get(util::variant &v); - - template - const typename util::type_list_element::type& get(const util::variant &v); - - template - bool holds_alternative(const util::variant &v) noexcept; - - - // Visitor - namespace detail - { - struct visitor_interface {}; - - // Class `visitor_return_type_deduction_helper` - // introduces solution for deduction `return_type` in `visit` function in common way - // for both Lambda and class Visitor and keep one interface invocation point: `visit` only - // his helper class is required to unify return_type deduction mechanism because - // for Lambda it is possible to take type of `decltype(visitor(get<0>(var)))` - // but for class Visitor there is no operator() in base case, - // because it provides `operator() (std::size_t index, ...)` - // So `visitor_return_type_deduction_helper` expose `operator()` - // uses only for class Visitor only for deduction `return type` in visit() - template - struct visitor_return_type_deduction_helper - { - using return_type = R; - - // to be used in Lambda return type deduction context only - template - return_type operator() (T&&); - }; - } - - // Special purpose `static_visitor` can receive additional arguments - template - struct static_visitor : public detail::visitor_interface, - public detail::visitor_return_type_deduction_helper { - - // assign responsibility for return type deduction to helper class - using return_type = typename detail::visitor_return_type_deduction_helper::return_type; - using detail::visitor_return_type_deduction_helper::operator(); - friend Impl; - - template - return_type operator() (std::size_t index, VariantValue&& value, Args&& ...args) - { - suppress_unused_warning(index); - return static_cast(this)-> visit( - std::forward(value), - std::forward(args)...); - } - }; - - // Special purpose `static_indexed_visitor` can receive additional arguments - // And make forwarding current variant index as runtime function argument to its `Impl` - template - struct static_indexed_visitor : public detail::visitor_interface, - public detail::visitor_return_type_deduction_helper { - - // assign responsibility for return type deduction to helper class - using return_type = typename detail::visitor_return_type_deduction_helper::return_type; - using detail::visitor_return_type_deduction_helper::operator(); - friend Impl; - - template - return_type operator() (std::size_t Index, VariantValue&& value, Args&& ...args) - { - return static_cast(this)-> visit(Index, - std::forward(value), - std::forward(args)...); - } - }; - - template - struct variant_size; - - template - struct variant_size> - : std::integral_constant { }; - // FIXME: T&&, const TT&& versions. - - // Implementation ////////////////////////////////////////////////////////// - template - variant::variant() noexcept - { - typedef typename std::tuple_element<0, std::tuple >::type TFirst; - new (memory) TFirst(); - } - - template - variant::variant(const variant &other) - : m_index(other.m_index) - { - (cctrs()[m_index])(memory, other.memory); - } - - template - variant::variant(variant &&other) noexcept - : m_index(other.m_index) - { - (mctrs()[m_index])(memory, other.memory); - } - - template - template - variant::variant(T&& t) - : m_index(util::type_list_index, Ts...>::value) - { - const constexpr bool is_lvalue_arg = std::is_lvalue_reference::value; - (cnvrt_ctors()[m_index])(memory, const_cast *>(&t)); - } - - template - variant::~variant() - { - (dtors()[m_index])(memory); - } - - template - variant& variant::operator=(const variant &rhs) - { - if (m_index != rhs.m_index) - { - (dtors()[ m_index])(memory); - (cctrs()[rhs.m_index])(memory, rhs.memory); - m_index = rhs.m_index; - } - else - { - (cpyrs()[rhs.m_index])(memory, rhs.memory); - } - return *this; - } - - template - variant& variant::operator=(variant &&rhs) noexcept - { - if (m_index != rhs.m_index) - { - (dtors()[ m_index])(memory); - (mctrs()[rhs.m_index])(memory, rhs.memory); - m_index = rhs.m_index; - } - else - { - (mvers()[rhs.m_index])(memory, rhs.memory); - } - return *this; - } - - template - template - variant& variant::operator=(T&& t) noexcept - { - using decayed_t = util::decay_t; - // FIXME: No version with implicit type conversion available! - const constexpr std::size_t t_index = - util::type_list_index::value; - - const constexpr bool is_lvalue_arg = std::is_lvalue_reference::value; - - if (t_index != m_index) - { - (dtors()[m_index])(memory); - (cnvrt_ctors()[t_index])(memory, &t); - m_index = t_index; - } - else - { - (cnvrt_assgnrs()[m_index])(memory, &t); - } - return *this; - - } - - template - std::size_t util::variant::index() const noexcept - { - return m_index; - } - - template - void variant::swap(variant &rhs) noexcept - { - if (m_index == rhs.index()) - { - (swprs()[m_index](memory, rhs.memory)); - } - else - { - variant tmp(std::move(*this)); - *this = std::move(rhs); - rhs = std::move(tmp); - } - } - - template - template - constexpr std::size_t variant::index_of() - { - return util::type_list_index::value; // FIXME: tests! - } - - template - T* get_if(util::variant* v) noexcept - { - const constexpr std::size_t t_index = - util::type_list_index::value; - - if (v && v->index() == t_index) - return (T*)(&v->memory); // workaround for ICC 2019 - // original code: return reinterpret_cast(v.memory); - return nullptr; - } - - template - const T* get_if(const util::variant* v) noexcept - { - const constexpr std::size_t t_index = - util::type_list_index::value; - - if (v && v->index() == t_index) - return (const T*)(&v->memory); // workaround for ICC 2019 - // original code: return reinterpret_cast(v.memory); - return nullptr; - } - - template - T& get(util::variant &v) - { - if (auto* p = get_if(&v)) - return *p; - else - throw_error(bad_variant_access()); - } - - template - const T& get(const util::variant &v) - { - if (auto* p = get_if(&v)) - return *p; - else - throw_error(bad_variant_access()); - } - - template - typename util::type_list_element::type& get(util::variant &v) - { - using ReturnType = typename util::type_list_element::type; - return const_cast(get(static_cast &>(v))); - } - - template - const typename util::type_list_element::type& get(const util::variant &v) - { - static_assert(Index < sizeof...(Types), - "`Index` it out of bound of `util::variant` type list"); - using ReturnType = typename util::type_list_element::type; - return get(v); - } - - template - bool holds_alternative(const util::variant &v) noexcept - { - return v.index() == util::variant::template index_of(); - } - -#if defined(__GNUC__) && (__GNUC__ == 11 || __GNUC__ == 12) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" -#endif - - template bool operator==(const variant &lhs, - const variant &rhs) - { - using V = variant; - - // Instantiate table only here since it requires operator== for - // should have operator== only if this one is used, not in general - static const std::array eqs = { - {(&V::template equal_h::help)...} - }; - if (lhs.index() != rhs.index()) - return false; - return (eqs[lhs.index()])(lhs.memory, rhs.memory); - } - -#if defined(__GNUC__) && (__GNUC__ == 11 || __GNUC__ == 12) -#pragma GCC diagnostic pop -#endif - - template bool operator!=(const variant &lhs, - const variant &rhs) - { - return !(lhs == rhs); - } - -namespace detail -{ - // terminate recursion implementation for `non-void` ReturnType - template - ReturnType apply_visitor_impl(Visitor&&, Variant&, - std::true_type, std::false_type, - VisitorArgs&& ...) - { - return {}; - } - - // terminate recursion implementation for `void` ReturnType - template - void apply_visitor_impl(Visitor&&, Variant&, - std::true_type, std::true_type, - VisitorArgs&& ...) - { - } - - // Intermediate resursion processor for Lambda Visitors - template - typename std::enable_if::type>::value, ReturnType>::type - apply_visitor_impl(Visitor&& visitor, Variant&& v, std::false_type not_processed, - std::integral_constant should_no_return, - VisitorArgs&& ...args) - { - static_assert(std::is_same(v)))>::value, - "Different `ReturnType`s detected! All `Visitor::visit` or `overload_lamba_set`" - " must return the same type"); - suppress_unused_warning(not_processed); - if (v.index() == CurIndex) - { - return visitor.operator()(get(v), std::forward(args)... ); - } - - using is_variant_processed_t = std::integral_constant= ElemCount>; - return apply_visitor_impl( - std::forward(visitor), - std::forward(v), - is_variant_processed_t{}, - should_no_return, - std::forward(args)...); - } - - //Visual Studio 2014 compilation fix: cast visitor to base class before invoke operator() - template - typename std::enable_if::type>, - typename std::decay::type>::value, ReturnType>::type - invoke_class_visitor(Visitor& visitor, Value&& v, VisitorArgs&&...args) - { - return static_cast::type>&>(visitor).operator() (CurIndex, std::forward(v), std::forward(args)... ); - } - - //Visual Studio 2014 compilation fix: cast visitor to base class before invoke operator() - template - typename std::enable_if::type>, - typename std::decay::type>::value, ReturnType>::type - invoke_class_visitor(Visitor& visitor, Value&& v, VisitorArgs&&...args) - { - return static_cast::type>&>(visitor).operator() (CurIndex, std::forward(v), std::forward(args)... ); - } - - // Intermediate recursion processor for special case `visitor_interface` derived Visitors - template - typename std::enable_if::type>::value, ReturnType>::type - apply_visitor_impl(Visitor&& visitor, Variant&& v, std::false_type not_processed, - std::integral_constant should_no_return, - VisitorArgs&& ...args) - { - static_assert(std::is_same(v)))>::value, - "Different `ReturnType`s detected! All `Visitor::visit` or `overload_lamba_set`" - " must return the same type"); - suppress_unused_warning(not_processed); - if (v.index() == CurIndex) - { - return invoke_class_visitor(visitor, get(v), std::forward(args)... ); - } - - using is_variant_processed_t = std::integral_constant= ElemCount>; - return apply_visitor_impl( - std::forward(visitor), - std::forward(v), - is_variant_processed_t{}, - should_no_return, - std::forward(args)...); - } -} // namespace detail - - template - auto visit(Visitor &visitor, const Variant& var, VisitorArg &&...args) -> decltype(visitor(get<0>(var))) - { - constexpr std::size_t varsize = util::variant_size::value; - static_assert(varsize != 0, "utils::variant must contains one type at least "); - using is_variant_processed_t = std::false_type; - - using ReturnType = decltype(visitor(get<0>(var))); - using return_t = std::is_same; - return detail::apply_visitor_impl( - std::forward(visitor), - var, is_variant_processed_t{}, - return_t{}, - std::forward(args)...); - } - - template - auto visit(Visitor&& visitor, const Variant& var) -> decltype(visitor(get<0>(var))) - { - constexpr std::size_t varsize = util::variant_size::value; - static_assert(varsize != 0, "utils::variant must contains one type at least "); - using is_variant_processed_t = std::false_type; - - using ReturnType = decltype(visitor(get<0>(var))); - using return_t = std::is_same; - return detail::apply_visitor_impl( - std::forward(visitor), - var, is_variant_processed_t{}, - return_t{}); - } -} // namespace util -} // namespace cv - -#endif // OPENCV_GAPI_UTIL_VARIANT_HPP diff --git a/modules/gapi/include/opencv2/gapi/video.hpp b/modules/gapi/include/opencv2/gapi/video.hpp deleted file mode 100644 index 4dcc1d4182..0000000000 --- a/modules/gapi/include/opencv2/gapi/video.hpp +++ /dev/null @@ -1,364 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2020 Intel Corporation - -#ifndef OPENCV_GAPI_VIDEO_HPP -#define OPENCV_GAPI_VIDEO_HPP - -#include // std::tuple - -#include - - -/** \defgroup gapi_video G-API Video processing functionality - */ - -namespace cv { namespace gapi { - -/** @brief Structure for the Kalman filter's initialization parameters.*/ - -struct GAPI_EXPORTS KalmanParams -{ - // initial state - - //! corrected state (x(k)): x(k)=x'(k)+K(k)*(z(k)-H*x'(k)) - Mat state; - //! posteriori error estimate covariance matrix (P(k)): P(k)=(I-K(k)*H)*P'(k) - Mat errorCov; - - // dynamic system description - - //! state transition matrix (A) - Mat transitionMatrix; - //! measurement matrix (H) - Mat measurementMatrix; - //! process noise covariance matrix (Q) - Mat processNoiseCov; - //! measurement noise covariance matrix (R) - Mat measurementNoiseCov; - //! control matrix (B) (Optional: not used if there's no control) - Mat controlMatrix; -}; - -/** - * @brief This namespace contains G-API Operations and functions for - * video-oriented algorithms, like optical flow and background subtraction. - */ -namespace video -{ -using GBuildPyrOutput = std::tuple, GScalar>; - -using GOptFlowLKOutput = std::tuple, - cv::GArray, - cv::GArray>; - -G_TYPED_KERNEL(GBuildOptFlowPyramid, , - "org.opencv.video.buildOpticalFlowPyramid") -{ - static std::tuple - outMeta(GMatDesc,const Size&,GScalarDesc,bool,int,int,bool) - { - return std::make_tuple(empty_array_desc(), empty_scalar_desc()); - } -}; - -G_TYPED_KERNEL(GCalcOptFlowLK, - ,cv::GArray,Size, - GScalar,TermCriteria,int,double)>, - "org.opencv.video.calcOpticalFlowPyrLK") -{ - static std::tuple outMeta(GMatDesc,GMatDesc,GArrayDesc, - GArrayDesc,const Size&,GScalarDesc, - const TermCriteria&,int,double) - { - return std::make_tuple(empty_array_desc(), empty_array_desc(), empty_array_desc()); - } - -}; - -G_TYPED_KERNEL(GCalcOptFlowLKForPyr, - ,cv::GArray, - cv::GArray,cv::GArray,Size,GScalar, - TermCriteria,int,double)>, - "org.opencv.video.calcOpticalFlowPyrLKForPyr") -{ - static std::tuple outMeta(GArrayDesc,GArrayDesc, - GArrayDesc,GArrayDesc, - const Size&,GScalarDesc, - const TermCriteria&,int,double) - { - return std::make_tuple(empty_array_desc(), empty_array_desc(), empty_array_desc()); - } -}; - -enum BackgroundSubtractorType -{ - TYPE_BS_MOG2, - TYPE_BS_KNN -}; - -/** @brief Structure for the Background Subtractor operation's initialization parameters.*/ - -struct BackgroundSubtractorParams -{ - //! Type of the Background Subtractor operation. - BackgroundSubtractorType operation = TYPE_BS_MOG2; - - //! Length of the history. - int history = 500; - - //! For MOG2: Threshold on the squared Mahalanobis distance between the pixel - //! and the model to decide whether a pixel is well described by - //! the background model. - //! For KNN: Threshold on the squared distance between the pixel and the sample - //! to decide whether a pixel is close to that sample. - double threshold = 16; - - //! If true, the algorithm will detect shadows and mark them. - bool detectShadows = true; - - //! The value between 0 and 1 that indicates how fast - //! the background model is learnt. - //! Negative parameter value makes the algorithm use some automatically - //! chosen learning rate. - double learningRate = -1; - - //! default constructor - BackgroundSubtractorParams() {} - - /** Full constructor - @param op MOG2/KNN Background Subtractor type. - @param histLength Length of the history. - @param thrshld For MOG2: Threshold on the squared Mahalanobis distance between - the pixel and the model to decide whether a pixel is well described by the background model. - For KNN: Threshold on the squared distance between the pixel and the sample to decide - whether a pixel is close to that sample. - @param detect If true, the algorithm will detect shadows and mark them. It decreases the - speed a bit, so if you do not need this feature, set the parameter to false. - @param lRate The value between 0 and 1 that indicates how fast the background model is learnt. - Negative parameter value makes the algorithm to use some automatically chosen learning rate. - */ - BackgroundSubtractorParams(BackgroundSubtractorType op, int histLength, - double thrshld, bool detect, double lRate) : operation(op), - history(histLength), - threshold(thrshld), - detectShadows(detect), - learningRate(lRate){} -}; - -G_TYPED_KERNEL(GBackgroundSubtractor, , - "org.opencv.video.BackgroundSubtractor") -{ - static GMatDesc outMeta(const GMatDesc& in, const BackgroundSubtractorParams& bsParams) - { - GAPI_Assert(bsParams.history >= 0); - GAPI_Assert(bsParams.learningRate <= 1); - return in.withType(CV_8U, 1); - } -}; - -void checkParams(const cv::gapi::KalmanParams& kfParams, - const cv::GMatDesc& measurement, const cv::GMatDesc& control = {}); - -G_TYPED_KERNEL(GKalmanFilter, , GMat, KalmanParams)>, - "org.opencv.video.KalmanFilter") -{ - static GMatDesc outMeta(const GMatDesc& measurement, const GOpaqueDesc&, - const GMatDesc& control, const KalmanParams& kfParams) - { - checkParams(kfParams, measurement, control); - return measurement.withSize(Size(1, kfParams.transitionMatrix.rows)); - } -}; - -G_TYPED_KERNEL(GKalmanFilterNoControl, , KalmanParams)>, "org.opencv.video.KalmanFilterNoControl") -{ - static GMatDesc outMeta(const GMatDesc& measurement, const GOpaqueDesc&, const KalmanParams& kfParams) - { - checkParams(kfParams, measurement); - return measurement.withSize(Size(1, kfParams.transitionMatrix.rows)); - } -}; -} //namespace video - -//! @addtogroup gapi_video -//! @{ -/** @brief Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK. - -@note Function textual ID is "org.opencv.video.buildOpticalFlowPyramid" - -@param img 8-bit input image. -@param winSize window size of optical flow algorithm. Must be not less than winSize - argument of calcOpticalFlowPyrLK. It is needed to calculate required - padding for pyramid levels. -@param maxLevel 0-based maximal pyramid level number. -@param withDerivatives set to precompute gradients for the every pyramid level. If pyramid is - constructed without the gradients then calcOpticalFlowPyrLK will calculate - them internally. -@param pyrBorder the border mode for pyramid layers. -@param derivBorder the border mode for gradients. -@param tryReuseInputImage put ROI of input image into the pyramid if possible. You can pass false - to force data copying. - -@return - - output pyramid. - - number of levels in constructed pyramid. Can be less than maxLevel. - */ -GAPI_EXPORTS std::tuple, GScalar> -buildOpticalFlowPyramid(const GMat &img, - const Size &winSize, - const GScalar &maxLevel, - bool withDerivatives = true, - int pyrBorder = BORDER_REFLECT_101, - int derivBorder = BORDER_CONSTANT, - bool tryReuseInputImage = true); - -/** @brief Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade -method with pyramids. - -See @cite Bouguet00 . - -@note Function textual ID is "org.opencv.video.calcOpticalFlowPyrLK" - -@param prevImg first 8-bit input image (GMat) or pyramid (GArray) constructed by -buildOpticalFlowPyramid. -@param nextImg second input image (GMat) or pyramid (GArray) of the same size and the same -type as prevImg. -@param prevPts GArray of 2D points for which the flow needs to be found; point coordinates must be -single-precision floating-point numbers. -@param predPts GArray of 2D points initial for the flow search; make sense only when -OPTFLOW_USE_INITIAL_FLOW flag is passed; in that case the vector must have the same size as in -the input. -@param winSize size of the search window at each pyramid level. -@param maxLevel 0-based maximal pyramid level number; if set to 0, pyramids are not used (single -level), if set to 1, two levels are used, and so on; if pyramids are passed to input then -algorithm will use as many levels as pyramids have but no more than maxLevel. -@param criteria parameter, specifying the termination criteria of the iterative search algorithm -(after the specified maximum number of iterations criteria.maxCount or when the search window -moves by less than criteria.epsilon). -@param flags operation flags: - - **OPTFLOW_USE_INITIAL_FLOW** uses initial estimations, stored in nextPts; if the flag is - not set, then prevPts is copied to nextPts and is considered the initial estimate. - - **OPTFLOW_LK_GET_MIN_EIGENVALS** use minimum eigen values as an error measure (see - minEigThreshold description); if the flag is not set, then L1 distance between patches - around the original and a moved point, divided by number of pixels in a window, is used as a - error measure. -@param minEigThresh the algorithm calculates the minimum eigen value of a 2x2 normal matrix of -optical flow equations (this matrix is called a spatial gradient matrix in @cite Bouguet00), divided -by number of pixels in a window; if this value is less than minEigThreshold, then a corresponding -feature is filtered out and its flow is not processed, so it allows to remove bad points and get a -performance boost. - -@return - - GArray of 2D points (with single-precision floating-point coordinates) -containing the calculated new positions of input features in the second image. - - status GArray (of unsigned chars); each element of the vector is set to 1 if -the flow for the corresponding features has been found, otherwise, it is set to 0. - - GArray of errors (doubles); each element of the vector is set to an error for the -corresponding feature, type of the error measure can be set in flags parameter; if the flow wasn't -found then the error is not defined (use the status parameter to find such cases). - */ -GAPI_EXPORTS std::tuple, GArray, GArray> -calcOpticalFlowPyrLK(const GMat &prevImg, - const GMat &nextImg, - const GArray &prevPts, - const GArray &predPts, - const Size &winSize = Size(21, 21), - const GScalar &maxLevel = 3, - const TermCriteria &criteria = TermCriteria(TermCriteria::COUNT | - TermCriteria::EPS, - 30, 0.01), - int flags = 0, - double minEigThresh = 1e-4); - -/** -@overload -@note Function textual ID is "org.opencv.video.calcOpticalFlowPyrLKForPyr" -*/ -GAPI_EXPORTS std::tuple, GArray, GArray> -calcOpticalFlowPyrLK(const GArray &prevPyr, - const GArray &nextPyr, - const GArray &prevPts, - const GArray &predPts, - const Size &winSize = Size(21, 21), - const GScalar &maxLevel = 3, - const TermCriteria &criteria = TermCriteria(TermCriteria::COUNT | - TermCriteria::EPS, - 30, 0.01), - int flags = 0, - double minEigThresh = 1e-4); - -/** @brief Gaussian Mixture-based or K-nearest neighbours-based Background/Foreground Segmentation Algorithm. -The operation generates a foreground mask. - -@return Output image is foreground mask, i.e. 8-bit unsigned 1-channel (binary) matrix @ref CV_8UC1. - -@note Functional textual ID is "org.opencv.video.BackgroundSubtractor" - -@param src input image: Floating point frame is used without scaling and should be in range [0,255]. -@param bsParams Set of initialization parameters for Background Subtractor kernel. -*/ -GAPI_EXPORTS GMat BackgroundSubtractor(const GMat& src, const cv::gapi::video::BackgroundSubtractorParams& bsParams); - -/** @brief Standard Kalman filter algorithm . - -@note Functional textual ID is "org.opencv.video.KalmanFilter" - -@param measurement input matrix: 32-bit or 64-bit float 1-channel matrix containing measurements. -@param haveMeasurement dynamic input flag that indicates whether we get measurements -at a particular iteration . -@param control input matrix: 32-bit or 64-bit float 1-channel matrix contains control data -for changing dynamic system. -@param kfParams Set of initialization parameters for Kalman filter kernel. - -@return Output matrix is predicted or corrected state. They can be 32-bit or 64-bit float -1-channel matrix @ref CV_32FC1 or @ref CV_64FC1. - -@details If measurement matrix is given (haveMeasurements == true), corrected state will -be returned which corresponds to the pipeline -cv::KalmanFilter::predict(control) -> cv::KalmanFilter::correct(measurement). -Otherwise, predicted state will be returned which corresponds to the call of -cv::KalmanFilter::predict(control). -@sa cv::KalmanFilter -*/ -GAPI_EXPORTS GMat KalmanFilter(const GMat& measurement, const GOpaque& haveMeasurement, - const GMat& control, const cv::gapi::KalmanParams& kfParams); - -/** @overload -The case of Standard Kalman filter algorithm when there is no control in a dynamic system. -In this case the controlMatrix is empty and control vector is absent. - -@note Function textual ID is "org.opencv.video.KalmanFilterNoControl" - -@param measurement input matrix: 32-bit or 64-bit float 1-channel matrix containing measurements. -@param haveMeasurement dynamic input flag that indicates whether we get measurements -at a particular iteration. -@param kfParams Set of initialization parameters for Kalman filter kernel. - -@return Output matrix is predicted or corrected state. They can be 32-bit or 64-bit float -1-channel matrix @ref CV_32FC1 or @ref CV_64FC1. - -@sa cv::KalmanFilter - */ -GAPI_EXPORTS GMat KalmanFilter(const GMat& measurement, const GOpaque& haveMeasurement, - const cv::gapi::KalmanParams& kfParams); - -//! @} gapi_video -} //namespace gapi -} //namespace cv - - -namespace cv { namespace detail { -template<> struct CompileArgTag -{ - static const char* tag() - { - return "org.opencv.video.background_substractor_params"; - } -}; -} // namespace detail -} // namespace cv - -#endif // OPENCV_GAPI_VIDEO_HPP diff --git a/modules/gapi/misc/python/package/gapi/__init__.py b/modules/gapi/misc/python/package/gapi/__init__.py deleted file mode 100644 index 2b21e54e41..0000000000 --- a/modules/gapi/misc/python/package/gapi/__init__.py +++ /dev/null @@ -1,323 +0,0 @@ -__all__ = ['op', 'kernel'] - -import sys -import cv2 as cv - -# NB: Register function in specific module -def register(mname): - def parameterized(func): - sys.modules[mname].__dict__[func.__name__] = func - return func - return parameterized - - -@register('cv2.gapi') -def networks(*args): - return cv.gapi_GNetPackage(list(map(cv.detail.strip, args))) - - -@register('cv2.gapi') -def compile_args(*args): - return list(map(cv.GCompileArg, args)) - - -@register('cv2') -def GIn(*args): - return [*args] - - -@register('cv2') -def GOut(*args): - return [*args] - - -@register('cv2') -def gin(*args): - return [*args] - - -@register('cv2.gapi') -def descr_of(*args): - return [*args] - - -@register('cv2') -class GOpaque(): - # NB: Inheritance from c++ class cause segfault. - # So just aggregate cv.GOpaqueT instead of inheritance - def __new__(cls, argtype): - return cv.GOpaqueT(argtype) - - class Bool(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_BOOL) - - class Int(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_INT) - - class Int64(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_INT64) - - class UInt64(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_UINT64) - - class Double(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_DOUBLE) - - class Float(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_FLOAT) - - class String(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_STRING) - - class Point(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_POINT) - - class Point2f(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_POINT2F) - - class Point3f(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_POINT3F) - - class Size(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_SIZE) - - class Rect(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_RECT) - - class Prim(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_DRAW_PRIM) - - class Any(): - def __new__(self): - return cv.GOpaqueT(cv.gapi.CV_ANY) - -@register('cv2') -class GArray(): - # NB: Inheritance from c++ class cause segfault. - # So just aggregate cv.GArrayT instead of inheritance - def __new__(cls, argtype): - return cv.GArrayT(argtype) - - class Bool(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_BOOL) - - class Int(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_INT) - - class Int64(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_INT64) - - class UInt64(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_UINT64) - - class Double(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_DOUBLE) - - class Float(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_FLOAT) - - class String(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_STRING) - - class Point(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_POINT) - - class Point2f(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_POINT2F) - - class Point3f(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_POINT3F) - - class Size(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_SIZE) - - class Rect(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_RECT) - - class Scalar(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_SCALAR) - - class Mat(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_MAT) - - class GMat(): - def __new__(self): - return cv.GArrayT(cv.gapi.CV_GMAT) - - class Prim(): - def __new__(self): - return cv.GArray(cv.gapi.CV_DRAW_PRIM) - - class Any(): - def __new__(self): - return cv.GArray(cv.gapi.CV_ANY) - - -# NB: Top lvl decorator takes arguments -def op(op_id, in_types, out_types): - - garray_types= { - cv.GArray.Bool: cv.gapi.CV_BOOL, - cv.GArray.Int: cv.gapi.CV_INT, - cv.GArray.Int64: cv.gapi.CV_INT64, - cv.GArray.UInt64: cv.gapi.CV_UINT64, - cv.GArray.Double: cv.gapi.CV_DOUBLE, - cv.GArray.Float: cv.gapi.CV_FLOAT, - cv.GArray.String: cv.gapi.CV_STRING, - cv.GArray.Point: cv.gapi.CV_POINT, - cv.GArray.Point2f: cv.gapi.CV_POINT2F, - cv.GArray.Point3f: cv.gapi.CV_POINT3F, - cv.GArray.Size: cv.gapi.CV_SIZE, - cv.GArray.Rect: cv.gapi.CV_RECT, - cv.GArray.Scalar: cv.gapi.CV_SCALAR, - cv.GArray.Mat: cv.gapi.CV_MAT, - cv.GArray.GMat: cv.gapi.CV_GMAT, - cv.GArray.Prim: cv.gapi.CV_DRAW_PRIM, - cv.GArray.Any: cv.gapi.CV_ANY - } - - gopaque_types= { - cv.GOpaque.Size: cv.gapi.CV_SIZE, - cv.GOpaque.Rect: cv.gapi.CV_RECT, - cv.GOpaque.Bool: cv.gapi.CV_BOOL, - cv.GOpaque.Int: cv.gapi.CV_INT, - cv.GOpaque.Int64: cv.gapi.CV_INT64, - cv.GOpaque.UInt64: cv.gapi.CV_UINT64, - cv.GOpaque.Double: cv.gapi.CV_DOUBLE, - cv.GOpaque.Float: cv.gapi.CV_FLOAT, - cv.GOpaque.String: cv.gapi.CV_STRING, - cv.GOpaque.Point: cv.gapi.CV_POINT, - cv.GOpaque.Point2f: cv.gapi.CV_POINT2F, - cv.GOpaque.Point3f: cv.gapi.CV_POINT3F, - cv.GOpaque.Size: cv.gapi.CV_SIZE, - cv.GOpaque.Rect: cv.gapi.CV_RECT, - cv.GOpaque.Prim: cv.gapi.CV_DRAW_PRIM, - cv.GOpaque.Any: cv.gapi.CV_ANY - } - - type2str = { - cv.gapi.CV_BOOL: 'cv.gapi.CV_BOOL' , - cv.gapi.CV_INT: 'cv.gapi.CV_INT' , - cv.gapi.CV_INT64: 'cv.gapi.CV_INT64' , - cv.gapi.CV_UINT64: 'cv.gapi.CV_UINT64' , - cv.gapi.CV_DOUBLE: 'cv.gapi.CV_DOUBLE' , - cv.gapi.CV_FLOAT: 'cv.gapi.CV_FLOAT' , - cv.gapi.CV_STRING: 'cv.gapi.CV_STRING' , - cv.gapi.CV_POINT: 'cv.gapi.CV_POINT' , - cv.gapi.CV_POINT2F: 'cv.gapi.CV_POINT2F' , - cv.gapi.CV_POINT3F: 'cv.gapi.CV_POINT3F' , - cv.gapi.CV_SIZE: 'cv.gapi.CV_SIZE', - cv.gapi.CV_RECT: 'cv.gapi.CV_RECT', - cv.gapi.CV_SCALAR: 'cv.gapi.CV_SCALAR', - cv.gapi.CV_MAT: 'cv.gapi.CV_MAT', - cv.gapi.CV_GMAT: 'cv.gapi.CV_GMAT', - cv.gapi.CV_DRAW_PRIM: 'cv.gapi.CV_DRAW_PRIM' - } - - # NB: Second lvl decorator takes class to decorate - def op_with_params(cls): - if not in_types: - raise Exception('{} operation should have at least one input!'.format(cls.__name__)) - - if not out_types: - raise Exception('{} operation should have at least one output!'.format(cls.__name__)) - - for i, t in enumerate(out_types): - if t not in [cv.GMat, cv.GScalar, *garray_types, *gopaque_types]: - raise Exception('{} unsupported output type: {} in position: {}' - .format(cls.__name__, t.__name__, i)) - - def on(*args): - if len(in_types) != len(args): - raise Exception('Invalid number of input elements!\nExpected: {}, Actual: {}' - .format(len(in_types), len(args))) - - for i, (t, a) in enumerate(zip(in_types, args)): - if t in garray_types: - if not isinstance(a, cv.GArrayT): - raise Exception("{} invalid type for argument {}.\nExpected: {}, Actual: {}" - .format(cls.__name__, i, cv.GArrayT.__name__, type(a).__name__)) - - elif a.type() != garray_types[t]: - raise Exception("{} invalid GArrayT type for argument {}.\nExpected: {}, Actual: {}" - .format(cls.__name__, i, type2str[garray_types[t]], type2str[a.type()])) - - elif t in gopaque_types: - if not isinstance(a, cv.GOpaqueT): - raise Exception("{} invalid type for argument {}.\nExpected: {}, Actual: {}" - .format(cls.__name__, i, cv.GOpaqueT.__name__, type(a).__name__)) - - elif a.type() != gopaque_types[t]: - raise Exception("{} invalid GOpaque type for argument {}.\nExpected: {}, Actual: {}" - .format(cls.__name__, i, type2str[gopaque_types[t]], type2str[a.type()])) - - else: - if t != type(a): - raise Exception('{} invalid input type for argument {}.\nExpected: {}, Actual: {}' - .format(cls.__name__, i, t.__name__, type(a).__name__)) - - op = cv.gapi.__op(op_id, cls.outMeta, *args) - - out_protos = [] - for i, out_type in enumerate(out_types): - if out_type == cv.GMat: - out_protos.append(op.getGMat()) - elif out_type == cv.GScalar: - out_protos.append(op.getGScalar()) - elif out_type in gopaque_types: - out_protos.append(op.getGOpaque(gopaque_types[out_type])) - elif out_type in garray_types: - out_protos.append(op.getGArray(garray_types[out_type])) - else: - raise Exception("""In {}: G-API operation can't produce the output with type: {} in position: {}""" - .format(cls.__name__, out_type.__name__, i)) - - return tuple(out_protos) if len(out_protos) != 1 else out_protos[0] - - # NB: Extend operation class - cls.id = op_id - cls.on = staticmethod(on) - return cls - - return op_with_params - - -def kernel(op_cls): - # NB: Second lvl decorator takes class to decorate - def kernel_with_params(cls): - # NB: Add new members to kernel class - cls.id = op_cls.id - cls.outMeta = op_cls.outMeta - return cls - - return kernel_with_params - - -cv.gapi.wip.GStreamerPipeline = cv.gapi_wip_gst_GStreamerPipeline diff --git a/modules/gapi/misc/python/pyopencv_gapi.hpp b/modules/gapi/misc/python/pyopencv_gapi.hpp deleted file mode 100644 index 66c3910756..0000000000 --- a/modules/gapi/misc/python/pyopencv_gapi.hpp +++ /dev/null @@ -1,1172 +0,0 @@ -#ifndef OPENCV_GAPI_PYOPENCV_GAPI_HPP -#define OPENCV_GAPI_PYOPENCV_GAPI_HPP - -#ifdef HAVE_OPENCV_GAPI - -#ifdef _MSC_VER -#pragma warning(disable: 4503) // "decorated name length exceeded" -#endif - -#include -#include - -// NB: Python wrapper replaces :: with _ for classes -using gapi_GKernelPackage = cv::GKernelPackage; -using gapi_GNetPackage = cv::gapi::GNetPackage; -using gapi_ie_PyParams = cv::gapi::ie::PyParams; -using gapi_onnx_PyParams = cv::gapi::onnx::PyParams; -using gapi_ov_PyParams = cv::gapi::ov::PyParams; -using gapi_wip_IStreamSource_Ptr = cv::Ptr; -using detail_ExtractArgsCallback = cv::detail::ExtractArgsCallback; -using detail_ExtractMetaCallback = cv::detail::ExtractMetaCallback; -using vector_GNetParam = std::vector; -using vector_GMat = std::vector; -using gapi_streaming_queue_capacity = cv::gapi::streaming::queue_capacity; -using GStreamerSource_OutputType = cv::gapi::wip::GStreamerSource::OutputType; -using map_string_and_int = std::map; -using map_string_and_string = std::map; -using map_string_and_string = std::map; -using map_string_and_vector_size_t = std::map>; -using map_string_and_vector_float = std::map>; -using map_int_and_double = std::map; -using ep_OpenVINO = cv::gapi::onnx::ep::OpenVINO; -using ep_DirectML = cv::gapi::onnx::ep::DirectML; -using ep_CoreML = cv::gapi::onnx::ep::CoreML; -using ep_CUDA = cv::gapi::onnx::ep::CUDA; -using ep_TensorRT = cv::gapi::onnx::ep::TensorRT; - -// NB: Python wrapper generate T_U for T -// This behavior is only observed for inputs -using GOpaque_bool = cv::GOpaque; -using GOpaque_int = cv::GOpaque; -using GOpaque_double = cv::GOpaque; -using GOpaque_float = cv::GOpaque; -using GOpaque_string = cv::GOpaque; -using GOpaque_Point2i = cv::GOpaque; -using GOpaque_Point2f = cv::GOpaque; -using GOpaque_Size = cv::GOpaque; -using GOpaque_Rect = cv::GOpaque; - -using GArray_bool = cv::GArray; -using GArray_int = cv::GArray; -using GArray_double = cv::GArray; -using GArray_float = cv::GArray; -using GArray_string = cv::GArray; -using GArray_Point2i = cv::GArray; -using GArray_Point2f = cv::GArray; -using GArray_Point3f = cv::GArray; -using GArray_Size = cv::GArray; -using GArray_Rect = cv::GArray; -using GArray_Scalar = cv::GArray; -using GArray_Mat = cv::GArray; -using GArray_GMat = cv::GArray; -using GArray_Prim = cv::GArray; - -// FIXME: Python wrapper generate code without namespace std, -// so it cause error: "string wasn't declared" -// 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 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(v).get(); - Py_INCREF(o); - return o; -} - -// #FIXME: Is it possible to implement pyopencv_from/pyopencv_to for generic -// cv::variant ? -template <> -PyObject* pyopencv_from(const cv::gapi::wip::draw::Prim& prim) -{ - switch (prim.index()) - { - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - case cv::gapi::wip::draw::Prim::index_of(): - return pyopencv_from(cv::util::get(prim)); - } - - util::throw_error(std::logic_error("Unsupported draw primitive type")); -} - -template <> -PyObject* pyopencv_from(const cv::gapi::wip::draw::Prims& value) -{ - return pyopencv_from_generic_vec(value); -} - -template<> -bool pyopencv_to(PyObject* obj, cv::gapi::wip::draw::Prim& value, const ArgInfo&) -{ -#define TRY_EXTRACT(Prim) \ - if (PyObject_TypeCheck(obj, reinterpret_cast(pyopencv_gapi_wip_draw_##Prim##_TypePtr))) \ - { \ - value = reinterpret_cast(obj)->v; \ - return true; \ - } \ - - TRY_EXTRACT(Rect) - TRY_EXTRACT(Text) - TRY_EXTRACT(Circle) - TRY_EXTRACT(Line) - TRY_EXTRACT(Mosaic) - TRY_EXTRACT(Image) - TRY_EXTRACT(Poly) -#undef TRY_EXTRACT - - failmsg("Unsupported primitive type"); - return false; -} - -template <> -bool pyopencv_to(PyObject* obj, cv::gapi::wip::draw::Prims& value, const ArgInfo& info) -{ - return pyopencv_to_generic_vec(obj, value, info); -} - -template <> -bool pyopencv_to(PyObject* obj, cv::GMetaArg& value, const ArgInfo&) -{ -#define TRY_EXTRACT(Meta) \ - if (PyObject_TypeCheck(obj, \ - reinterpret_cast(pyopencv_##Meta##_TypePtr))) \ - { \ - value = reinterpret_cast(obj)->v; \ - return true; \ - } \ - - TRY_EXTRACT(GMatDesc) - TRY_EXTRACT(GScalarDesc) - TRY_EXTRACT(GArrayDesc) - TRY_EXTRACT(GOpaqueDesc) -#undef TRY_EXTRACT - - failmsg("Unsupported cv::GMetaArg type"); - return false; -} - -template <> -bool pyopencv_to(PyObject* obj, cv::GMetaArgs& value, const ArgInfo& info) -{ - return pyopencv_to_generic_vec(obj, value, info); -} - - -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()); \ - } - -#define UNSUPPORTED(T) case cv::detail::OpaqueKind::CV_##T: break - switch (value.opaque_kind) - { - HANDLE_CASE(BOOL, bool); - HANDLE_CASE(INT, int); - HANDLE_CASE(INT64, int64_t); - HANDLE_CASE(UINT64, uint64_t); - 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(POINT3F, cv::Point3f); - 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); - HANDLE_CASE(DRAW_PRIM, cv::gapi::wip::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& value, const ArgInfo& info) -{ - return pyopencv_to_generic_vec(obj, value, info); -} - -template <> -PyObject* pyopencv_from(const std::vector& value) -{ - return pyopencv_from_generic_vec(value); -} - -template <> -bool pyopencv_to(PyObject* obj, std::vector& value, const ArgInfo& info) -{ - return pyopencv_to_generic_vec(obj, value, info); -} - -template <> -PyObject* pyopencv_from(const std::vector& value) -{ - return pyopencv_from_generic_vec(value); -} - -template<> -PyObject* pyopencv_from(const cv::detail::OpaqueRef& o) -{ - switch (o.getKind()) - { - case cv::detail::OpaqueKind::CV_BOOL : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_INT : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_INT64 : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_UINT64 : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_DOUBLE : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_FLOAT : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_STRING : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_POINT : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_POINT2F : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_POINT3F : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_SIZE : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_RECT : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_UNKNOWN : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_DRAW_PRIM : return pyopencv_from(o.rref()); - case cv::detail::OpaqueKind::CV_SCALAR : break; - case cv::detail::OpaqueKind::CV_MAT : break; - } - - PyErr_SetString(PyExc_TypeError, "Unsupported GOpaque type"); - return NULL; -} - -template <> -PyObject* pyopencv_from(const cv::detail::VectorRef& v) -{ - switch (v.getKind()) - { - case cv::detail::OpaqueKind::CV_BOOL : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_INT : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_INT64 : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_UINT64 : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_DOUBLE : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_FLOAT : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_STRING : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_POINT : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_POINT2F : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_POINT3F : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_SIZE : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_RECT : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_SCALAR : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_MAT : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_UNKNOWN : return pyopencv_from_generic_vec(v.rref()); - case cv::detail::OpaqueKind::CV_DRAW_PRIM : return pyopencv_from_generic_vec(v.rref()); - } - - PyErr_SetString(PyExc_TypeError, "Unsupported GArray type"); - return NULL; -} - -template <> -PyObject* pyopencv_from(const GRunArg& v) -{ - switch (v.index()) - { - case GRunArg::index_of(): - return pyopencv_from(util::get(v)); - - case GRunArg::index_of(): - return pyopencv_from(util::get(v)); - - case GRunArg::index_of(): - return pyopencv_from(util::get(v)); - - case GRunArg::index_of(): - return pyopencv_from(util::get(v)); - } - - PyErr_SetString(PyExc_TypeError, "Failed to unpack GRunArgs. Index of variant is unknown"); - return NULL; -} - -template -PyObject* pyopencv_from(const cv::optional& opt) -{ - if (!opt.has_value()) - { - Py_RETURN_NONE; - } - return pyopencv_from(*opt); -} - -template <> -PyObject* pyopencv_from(const GOptRunArg& v) -{ - switch (v.index()) - { - case GOptRunArg::index_of>(): - return pyopencv_from(util::get>(v)); - - case GOptRunArg::index_of>(): - return pyopencv_from(util::get>(v)); - - case GOptRunArg::index_of>(): - return pyopencv_from(util::get>(v)); - - case GOptRunArg::index_of>(): - return pyopencv_from(util::get>(v)); - } - - PyErr_SetString(PyExc_TypeError, "Failed to unpack GOptRunArg. Index of variant is unknown"); - return NULL; -} - -template<> -PyObject* pyopencv_from(const GRunArgs& value) -{ - return value.size() == 1 ? pyopencv_from(value[0]) : pyopencv_from_generic_vec(value); -} - -template<> -PyObject* pyopencv_from(const GOptRunArgs& value) -{ - return value.size() == 1 ? pyopencv_from(value[0]) : pyopencv_from_generic_vec(value); -} - -// FIXME: cv::variant should be wrapped once for all types. -template <> -PyObject* pyopencv_from(const cv::util::variant& v) -{ - using RunArgs = cv::util::variant; - switch (v.index()) - { - case RunArgs::index_of(): - return pyopencv_from(util::get(v)); - case RunArgs::index_of(): - return pyopencv_from(util::get(v)); - } - - PyErr_SetString(PyExc_TypeError, "Failed to recognize kind of RunArgs. Index of variant is unknown"); - return NULL; -} - -template -void pyopencv_to_with_check(PyObject* from, T& to, const std::string& msg = "") -{ - if (!pyopencv_to(from, to, ArgInfo("", false))) - { - cv::util::throw_error(std::logic_error(msg)); - } -} - -template -void pyopencv_to_generic_vec_with_check(PyObject* from, - std::vector& to, - const std::string& msg = "") -{ - if (!pyopencv_to_generic_vec(from, to, ArgInfo("", false))) - { - cv::util::throw_error(std::logic_error(msg)); - } -} - -template -static T extract_proto_args(PyObject* py_args) -{ - using namespace cv; - - GProtoArgs args; - Py_ssize_t size = PyList_Size(py_args); - args.reserve(size); - for (int i = 0; i < size; ++i) - { - PyObject* item = PyList_GetItem(py_args, i); - if (PyObject_TypeCheck(item, reinterpret_cast(pyopencv_GScalar_TypePtr))) - { - args.emplace_back(reinterpret_cast(item)->v); - } - else if (PyObject_TypeCheck(item, reinterpret_cast(pyopencv_GMat_TypePtr))) - { - args.emplace_back(reinterpret_cast(item)->v); - } - else if (PyObject_TypeCheck(item, reinterpret_cast(pyopencv_GOpaqueT_TypePtr))) - { - args.emplace_back(reinterpret_cast(item)->v.strip()); - } - else if (PyObject_TypeCheck(item, reinterpret_cast(pyopencv_GArrayT_TypePtr))) - { - args.emplace_back(reinterpret_cast(item)->v.strip()); - } - else - { - util::throw_error(std::logic_error("Unsupported type for GProtoArgs")); - } - } - - return T(std::move(args)); -} - -static cv::detail::OpaqueRef extract_opaque_ref(PyObject* from, cv::detail::OpaqueKind kind) -{ -#define HANDLE_CASE(T, O) case cv::detail::OpaqueKind::CV_##T: \ -{ \ - O obj{}; \ - pyopencv_to_with_check(from, obj, "Failed to obtain " # O); \ - return cv::detail::OpaqueRef{std::move(obj)}; \ -} -#define UNSUPPORTED(T) case cv::detail::OpaqueKind::CV_##T: break - switch (kind) - { - HANDLE_CASE(BOOL, bool); - HANDLE_CASE(INT, int); - HANDLE_CASE(INT64, int64_t); - HANDLE_CASE(UINT64, uint64_t); - 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(POINT3F, cv::Point3f); - HANDLE_CASE(SIZE, cv::Size); - HANDLE_CASE(RECT, cv::Rect); - HANDLE_CASE(UNKNOWN, cv::GArg); - UNSUPPORTED(SCALAR); - UNSUPPORTED(MAT); - UNSUPPORTED(DRAW_PRIM); -#undef HANDLE_CASE -#undef UNSUPPORTED - } - util::throw_error(std::logic_error("Unsupported type for GOpaqueT")); -} - -static cv::detail::VectorRef extract_vector_ref(PyObject* from, cv::detail::OpaqueKind kind) -{ -#define HANDLE_CASE(T, O) case cv::detail::OpaqueKind::CV_##T: \ -{ \ - std::vector obj; \ - pyopencv_to_generic_vec_with_check(from, obj, "Failed to obtain vector of " # O); \ - return cv::detail::VectorRef{std::move(obj)}; \ -} -#define UNSUPPORTED(T) case cv::detail::OpaqueKind::CV_##T: break - switch (kind) - { - HANDLE_CASE(BOOL, bool); - HANDLE_CASE(INT, int); - HANDLE_CASE(INT64, int64_t); - HANDLE_CASE(UINT64, uint64_t); - 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(POINT3F, cv::Point3f); - HANDLE_CASE(SIZE, cv::Size); - HANDLE_CASE(RECT, cv::Rect); - HANDLE_CASE(SCALAR, cv::Scalar); - HANDLE_CASE(MAT, cv::Mat); - HANDLE_CASE(UNKNOWN, cv::GArg); - HANDLE_CASE(DRAW_PRIM, cv::gapi::wip::draw::Prim); -#undef HANDLE_CASE -#undef UNSUPPORTED - } - util::throw_error(std::logic_error("Unsupported type for GArrayT")); -} - -static cv::GRunArg extract_run_arg(const cv::GTypeInfo& info, PyObject* item) -{ - switch (info.shape) - { - case cv::GShape::GMAT: - { - // NB: In case streaming it can be IStreamSource or cv::Mat - if (PyObject_TypeCheck(item, - reinterpret_cast(pyopencv_gapi_wip_IStreamSource_TypePtr))) - { - cv::gapi::wip::IStreamSource::Ptr source = - reinterpret_cast(item)->v; - return source; - } - cv::Mat obj; - pyopencv_to_with_check(item, obj, "Failed to obtain cv::Mat"); - return obj; - } - case cv::GShape::GSCALAR: - { - cv::Scalar obj; - pyopencv_to_with_check(item, obj, "Failed to obtain cv::Scalar"); - return obj; - } - case cv::GShape::GOPAQUE: - { - return extract_opaque_ref(item, info.kind); - } - case cv::GShape::GARRAY: - { - return extract_vector_ref(item, info.kind); - } - case cv::GShape::GFRAME: - { - // NB: Isn't supported yet. - break; - } - } - - util::throw_error(std::logic_error("Unsupported output shape")); -} - -static cv::GRunArgs extract_run_args(const cv::GTypesInfo& info, PyObject* py_args) -{ - GAPI_Assert(PyList_Check(py_args)); - - cv::GRunArgs args; - Py_ssize_t list_size = PyList_Size(py_args); - args.reserve(list_size); - - for (int i = 0; i < list_size; ++i) - { - args.push_back(extract_run_arg(info[i], PyList_GetItem(py_args, i))); - } - - return args; -} - -static cv::GMetaArg extract_meta_arg(const cv::GTypeInfo& info, PyObject* item) -{ - switch (info.shape) - { - case cv::GShape::GMAT: - { - cv::Mat obj; - pyopencv_to_with_check(item, obj, "Failed to obtain cv::Mat"); - return cv::GMetaArg{cv::descr_of(obj)}; - } - case cv::GShape::GSCALAR: - { - cv::Scalar obj; - pyopencv_to_with_check(item, obj, "Failed to obtain cv::Scalar"); - return cv::GMetaArg{cv::descr_of(obj)}; - } - case cv::GShape::GARRAY: - { - return cv::GMetaArg{cv::empty_array_desc()}; - } - case cv::GShape::GOPAQUE: - { - return cv::GMetaArg{cv::empty_gopaque_desc()}; - } - case cv::GShape::GFRAME: - { - // NB: Isn't supported yet. - break; - } - } - util::throw_error(std::logic_error("Unsupported output shape")); -} - -static cv::GMetaArgs extract_meta_args(const cv::GTypesInfo& info, PyObject* py_args) -{ - GAPI_Assert(PyList_Check(py_args)); - - cv::GMetaArgs metas; - Py_ssize_t list_size = PyList_Size(py_args); - metas.reserve(list_size); - - for (int i = 0; i < list_size; ++i) - { - metas.push_back(extract_meta_arg(info[i], PyList_GetItem(py_args, i))); - } - - return metas; -} - -static cv::GRunArgs run_py_kernel(cv::detail::PyObjectHolder 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 - { - // NB: Doesn't increase reference counter (false), - // because PyObject already have ownership. - // In case exception decrement reference counter. - cv::detail::PyObjectHolder args( - PyTuple_New(ctx.m_state.has_value() ? 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. - if (cv::util::holds_alternative(in_metas[i])) - { - PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i])); - continue; - } - - switch (in_metas[i].index()) - { - case cv::GMetaArg::index_of(): - PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get())); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get())); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get())); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(args.get(), i, pyopencv_from(ins[i].get())); - break; - case cv::GMetaArg::index_of(): - util::throw_error(std::logic_error("GFrame isn't supported for custom operation")); - break; - } - } - - if (ctx.m_state.has_value()) - { - PyTuple_SetItem(args.get(), ins.size(), pyopencv_from(ctx.m_state.value())); - } - - // 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); - - 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 (out_info.size() == 1) - { - outs = cv::GRunArgs{extract_run_arg(out_info[0], result.get())}; - } - else if (out_info.size() > 1) - { - GAPI_Assert(PyTuple_Check(result.get())); - - Py_ssize_t tuple_size = PyTuple_Size(result.get()); - outs.reserve(tuple_size); - - for (int i = 0; i < tuple_size; ++i) - { - outs.push_back(extract_run_arg(out_info[i], PyTuple_GetItem(result.get(), i))); - } - } - else - { - // Seems to be impossible case. - GAPI_Error("InternalError"); - } - } - catch (...) - { - PyGILState_Release(gstate); - throw; - } - PyGILState_Release(gstate); - - return outs; -} - -static void unpackMetasToTuple(const cv::GMetaArgs& meta, - const cv::GArgs& gargs, - cv::detail::PyObjectHolder& tuple) -{ - size_t idx = 0; - for (auto&& m : meta) - { - switch (m.index()) - { - case cv::GMetaArg::index_of(): - PyTuple_SetItem(tuple.get(), idx, pyopencv_from(cv::util::get(m))); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(tuple.get(), idx, - pyopencv_from(cv::util::get(m))); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(tuple.get(), idx, - pyopencv_from(cv::util::get(m))); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(tuple.get(), idx, - pyopencv_from(cv::util::get(m))); - break; - case cv::GMetaArg::index_of(): - PyTuple_SetItem(tuple.get(), idx, pyopencv_from(gargs[idx])); - break; - case cv::GMetaArg::index_of(): - util::throw_error( - std::logic_error("GFrame isn't supported for custom operation")); - break; - } - ++idx; - } -} - -static cv::GArg run_py_setup(cv::detail::PyObjectHolder setup, - const cv::GMetaArgs &meta, - const cv::GArgs &gargs) -{ - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - cv::GArg state; - 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); - unpackMetasToTuple(meta, gargs, args); - - PyObject *py_kernel_state = PyObject_CallObject(setup.get(), args.get()); - if (PyErr_Occurred()) - { - PyErr_PrintEx(0); - PyErr_Clear(); - throw std::logic_error("Python kernel setup failed with error!"); - } - // NB: In fact it's impossible situation, because errors were handled above. - GAPI_Assert(py_kernel_state && "Python kernel setup returned NULL!"); - - if (!pyopencv_to(py_kernel_state, state, ArgInfo("arg", false))) - { - util::throw_error(std::logic_error("Failed to convert python state")); - } - } - catch (...) - { - PyGILState_Release(gstate); - throw; - } - PyGILState_Release(gstate); - return state; -} - -static GMetaArg get_meta_arg(PyObject* obj) -{ - cv::GMetaArg arg; - if (!pyopencv_to(obj, arg, ArgInfo("arg", false))) - { - util::throw_error(std::logic_error("Unsupported output meta type")); - } - return arg; -} - -static cv::GMetaArgs get_meta_args(PyObject* tuple) -{ - size_t size = PyTuple_Size(tuple); - - cv::GMetaArgs metas; - metas.reserve(size); - for (size_t i = 0; i < size; ++i) - { - metas.push_back(get_meta_arg(PyTuple_GetItem(tuple, i))); - } - - return metas; -} - -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 - { - // 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); - unpackMetasToTuple(meta, gargs, args); - // 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, because 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 (...) - { - PyGILState_Release(gstate); - throw; - } - PyGILState_Release(gstate); - - return out_metas; -} - -static PyObject* pyopencv_cv_gapi_kernels(PyObject* , PyObject* py_args, PyObject*) -{ - using namespace cv; - GKernelPackage pkg; - Py_ssize_t size = PyTuple_Size(py_args); - - for (int i = 0; i < size; ++i) - { - PyObject* user_kernel = PyTuple_GetItem(py_args, i); - - 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; - } - - 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; - } - 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))) - { - PyErr_SetString(PyExc_TypeError, "Failed to obtain string"); - return NULL; - } - - using namespace std::placeholders; - - 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(run_py_setup, 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); -} - -static PyObject* pyopencv_cv_gapi_op(PyObject* , PyObject* py_args, PyObject*) -{ - using namespace cv; - Py_ssize_t size = PyTuple_Size(py_args); - std::string id; - if (!pyopencv_to(PyTuple_GetItem(py_args, 0), id, ArgInfo("id", false))) - { - PyErr_SetString(PyExc_TypeError, "Failed to obtain: operation id must be a string"); - return NULL; - } - PyObject* outMeta = PyTuple_GetItem(py_args, 1); - - cv::GArgs args; - for (int i = 2; i < size; i++) - { - PyObject* item = PyTuple_GetItem(py_args, i); - if (PyObject_TypeCheck(item, - reinterpret_cast(pyopencv_GMat_TypePtr))) - { - args.emplace_back(reinterpret_cast(item)->v); - } - else if (PyObject_TypeCheck(item, - reinterpret_cast(pyopencv_GScalar_TypePtr))) - { - args.emplace_back(reinterpret_cast(item)->v); - } - else if (PyObject_TypeCheck(item, - reinterpret_cast(pyopencv_GOpaqueT_TypePtr))) - { - auto&& arg = reinterpret_cast(item)->v.arg(); -#define HC(T, K) case cv::GOpaqueT::Storage:: index_of>(): \ - args.emplace_back(cv::util::get>(arg)); \ - break; \ - - SWITCH(arg.index(), GOPAQUE_TYPE_LIST_G, HC) -#undef HC - } - else if (PyObject_TypeCheck(item, - reinterpret_cast(pyopencv_GArrayT_TypePtr))) - { - auto&& arg = reinterpret_cast(item)->v.arg(); -#define HC(T, K) case cv::GArrayT::Storage:: index_of>(): \ - args.emplace_back(cv::util::get>(arg)); \ - break; \ - - SWITCH(arg.index(), GARRAY_TYPE_LIST_G, HC) -#undef HC - } - else - { - args.emplace_back(cv::GArg(cv::detail::PyObjectHolder{item})); - } - } - - 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))); -} - -template<> -bool pyopencv_to(PyObject* obj, cv::detail::ExtractArgsCallback& value, const ArgInfo&) -{ - cv::detail::PyObjectHolder holder{obj}; - value = cv::detail::ExtractArgsCallback{[=](const cv::GTypesInfo& info) - { - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - cv::GRunArgs args; - try - { - args = extract_run_args(info, holder.get()); - } - catch (...) - { - PyGILState_Release(gstate); - throw; - } - PyGILState_Release(gstate); - return args; - }}; - return true; -} - -template<> -bool pyopencv_to(PyObject* obj, cv::detail::ExtractMetaCallback& value, const ArgInfo&) -{ - cv::detail::PyObjectHolder holder{obj}; - value = cv::detail::ExtractMetaCallback{[=](const cv::GTypesInfo& info) - { - PyGILState_STATE gstate; - gstate = PyGILState_Ensure(); - - cv::GMetaArgs args; - try - { - args = extract_meta_args(info, holder.get()); - } - catch (...) - { - PyGILState_Release(gstate); - throw; - } - PyGILState_Release(gstate); - return args; - }}; - return true; -} - -template -struct PyOpenCV_Converter> -{ - static PyObject* from(const cv::GArray& p) - { - return pyopencv_from(cv::GArrayT(p)); - } - static bool to(PyObject *obj, cv::GArray& value, const ArgInfo& info) - { - if (PyObject_TypeCheck(obj, reinterpret_cast(pyopencv_GArrayT_TypePtr))) - { - auto& array = reinterpret_cast(obj)->v; - try - { - value = cv::util::get>(array.arg()); - } - catch (...) - { - return false; - } - return true; - } - return false; - } -}; - -template -struct PyOpenCV_Converter> -{ - static PyObject* from(const cv::GOpaque& p) - { - return pyopencv_from(cv::GOpaqueT(p)); - } - static bool to(PyObject *obj, cv::GOpaque& value, const ArgInfo& info) - { - if (PyObject_TypeCheck(obj, reinterpret_cast(pyopencv_GOpaqueT_TypePtr))) - { - auto& opaque = reinterpret_cast(obj)->v; - try - { - value = cv::util::get>(opaque.arg()); - } - catch (...) - { - return false; - } - return true; - } - return false; - } -}; - -template<> -bool pyopencv_to(PyObject* obj, cv::GProtoInputArgs& value, const ArgInfo& info) -{ - try - { - value = extract_proto_args(obj); - return true; - } - catch (...) - { - failmsg("Can't parse cv::GProtoInputArgs"); - return false; - } -} - -template<> -bool pyopencv_to(PyObject* obj, cv::GProtoOutputArgs& value, const ArgInfo& info) -{ - try - { - value = extract_proto_args(obj); - return true; - } - catch (...) - { - failmsg("Can't parse cv::GProtoOutputArgs"); - return false; - } -} - -// 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), "__op(...) -> retval\n"}, - - -#endif // HAVE_OPENCV_GAPI -#endif // OPENCV_GAPI_PYOPENCV_GAPI_HPP diff --git a/modules/gapi/misc/python/python_bridge.hpp b/modules/gapi/misc/python/python_bridge.hpp deleted file mode 100644 index f384b6907b..0000000000 --- a/modules/gapi/misc/python/python_bridge.hpp +++ /dev/null @@ -1,353 +0,0 @@ -// This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. -// -// Copyright (C) 2021 Intel Corporation - -#ifndef OPENCV_GAPI_PYTHON_BRIDGE_HPP -#define OPENCV_GAPI_PYTHON_BRIDGE_HPP - -#include -#include -#include -#include // Prim - -#define ID(T, E) T -#define ID_(T, E) ID(T, E), - -#define WRAP_ARGS(T, E, G) \ - G(T, E) - -#define SWITCH(type, LIST_G, HC) \ - switch(type) { \ - LIST_G(HC, HC) \ - default: \ - GAPI_Error("Unsupported type"); \ - } - -using cv::gapi::wip::draw::Prim; - -#define GARRAY_TYPE_LIST_G(G, G2) \ -WRAP_ARGS(bool , cv::gapi::ArgType::CV_BOOL, G) \ -WRAP_ARGS(int , cv::gapi::ArgType::CV_INT, G) \ -WRAP_ARGS(int64_t , cv::gapi::ArgType::CV_INT64, G) \ -WRAP_ARGS(uint64_t , cv::gapi::ArgType::CV_UINT64, G) \ -WRAP_ARGS(double , cv::gapi::ArgType::CV_DOUBLE, G) \ -WRAP_ARGS(float , cv::gapi::ArgType::CV_FLOAT, G) \ -WRAP_ARGS(std::string , cv::gapi::ArgType::CV_STRING, G) \ -WRAP_ARGS(cv::Point , cv::gapi::ArgType::CV_POINT, G) \ -WRAP_ARGS(cv::Point2f , cv::gapi::ArgType::CV_POINT2F, G) \ -WRAP_ARGS(cv::Point3f , cv::gapi::ArgType::CV_POINT3F, G) \ -WRAP_ARGS(cv::Size , cv::gapi::ArgType::CV_SIZE, G) \ -WRAP_ARGS(cv::Rect , cv::gapi::ArgType::CV_RECT, G) \ -WRAP_ARGS(cv::Scalar , cv::gapi::ArgType::CV_SCALAR, G) \ -WRAP_ARGS(cv::Mat , cv::gapi::ArgType::CV_MAT, G) \ -WRAP_ARGS(Prim , cv::gapi::ArgType::CV_DRAW_PRIM, G) \ -WRAP_ARGS(cv::GArg , cv::gapi::ArgType::CV_ANY, G) \ -WRAP_ARGS(cv::GMat , cv::gapi::ArgType::CV_GMAT, G2) \ - -#define GOPAQUE_TYPE_LIST_G(G, G2) \ -WRAP_ARGS(bool , cv::gapi::ArgType::CV_BOOL, G) \ -WRAP_ARGS(int , cv::gapi::ArgType::CV_INT, G) \ -WRAP_ARGS(int64_t , cv::gapi::ArgType::CV_INT64, G) \ -WRAP_ARGS(uint64_t , cv::gapi::ArgType::CV_UINT64, G) \ -WRAP_ARGS(double , cv::gapi::ArgType::CV_DOUBLE, G) \ -WRAP_ARGS(float , cv::gapi::ArgType::CV_FLOAT, G) \ -WRAP_ARGS(std::string , cv::gapi::ArgType::CV_STRING, G) \ -WRAP_ARGS(cv::Point , cv::gapi::ArgType::CV_POINT, G) \ -WRAP_ARGS(cv::Point2f , cv::gapi::ArgType::CV_POINT2F, G) \ -WRAP_ARGS(cv::Point3f , cv::gapi::ArgType::CV_POINT3F, G) \ -WRAP_ARGS(cv::Size , cv::gapi::ArgType::CV_SIZE, G) \ -WRAP_ARGS(cv::GArg , cv::gapi::ArgType::CV_ANY, G) \ -WRAP_ARGS(cv::Rect , cv::gapi::ArgType::CV_RECT, G2) \ - -namespace cv { -namespace gapi { - -// NB: cv.gapi.CV_BOOL in python -enum ArgType { - CV_BOOL, - CV_INT, - CV_INT64, - CV_UINT64, - CV_DOUBLE, - CV_FLOAT, - CV_STRING, - CV_POINT, - CV_POINT2F, - CV_POINT3F, - CV_SIZE, - CV_RECT, - CV_SCALAR, - CV_MAT, - CV_GMAT, - CV_DRAW_PRIM, - CV_ANY, -}; - -GAPI_EXPORTS_W inline cv::GInferOutputs infer(const String& name, const cv::GInferInputs& inputs) -{ - return infer(name, inputs); -} - -GAPI_EXPORTS_W inline GInferOutputs infer(const std::string& name, - const cv::GOpaque& roi, - const GInferInputs& inputs) -{ - return infer(name, roi, inputs); -} - -GAPI_EXPORTS_W inline GInferListOutputs infer(const std::string& name, - const cv::GArray& rois, - const GInferInputs& inputs) -{ - return infer(name, rois, inputs); -} - -GAPI_EXPORTS_W inline GInferListOutputs infer2(const std::string& name, - const cv::GMat in, - const GInferListInputs& inputs) -{ - return infer2(name, in, inputs); -} - -} // namespace gapi - -namespace detail { - -template