cv::gapi::wip Namespace Reference

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. More...

Namespaces
namespace	draw
namespace	gst
namespace	onevpl
namespace	ov

Classes
struct	Data
	This aggregate type represents all types which G-API can handle (via variant). More...
class	GAsyncCanceled
class	GAsyncContext
	A class to group async requests to cancel them in a single shot. More...
class	GCaptureSource
	OpenCV's VideoCapture-based streaming source. More...
class	IStreamSource
	Abstract streaming pipeline source. More...
class	QueueInput
class	QueueSource
	Queued streaming pipeline source. More...
class	QueueSourceBase

Typedefs
using	GStreamerPipeline = gst::GStreamerPipeline
using	GStreamerSource = gst::GStreamerSource
using	GVPLSource = onevpl::GSource

Functions
std::future< void >	async (GCompiled &gcmpld, GRunArgs &&ins, GRunArgsP &&outs)
std::future< void >	async (GCompiled &gcmpld, GRunArgs &&ins, GRunArgsP &&outs, GAsyncContext &ctx)
void	async (GCompiled &gcmpld, std::function< void(std::exception_ptr)> &&callback, GRunArgs &&ins, GRunArgsP &&outs)
void	async (GCompiled &gcmpld, std::function< void(std::exception_ptr)> &&callback, GRunArgs &&ins, GRunArgsP &&outs, GAsyncContext &ctx)
std::future< void >	async_apply (GComputation &gcomp, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args, GAsyncContext &ctx)
std::future< void >	async_apply (GComputation &gcomp, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args={})
void	async_apply (GComputation &gcomp, std::function< void(std::exception_ptr)> &&callback, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args, GAsyncContext &ctx)
void	async_apply (GComputation &gcomp, std::function< void(std::exception_ptr)> &&callback, GRunArgs &&ins, GRunArgsP &&outs, GCompileArgs &&args={})
cv::Ptr< IStreamSource >	get_streaming_source (cv::Ptr< GStreamerPipeline > &pipeline, const std::string &appsinkName, const GStreamerSource::OutputType outputType=GStreamerSource::OutputType::MAT)
cv::Ptr< IStreamSource >	make_capture_src (const int id, const std::map< int, double > &properties={})
cv::Ptr< IStreamSource >	make_capture_src (const std::string &path, const std::map< int, double > &properties={})
cv::Ptr< IStreamSource >	make_gst_src (const std::string &pipeline, const GStreamerSource::OutputType outputType=GStreamerSource::OutputType::MAT)
template<class... Args>
cv::Ptr< IStreamSource >	make_onevpl_src (Args &&... args)
cv::Ptr< cv::gapi::wip::IStreamSource >	make_py_src (const cv::Ptr< cv::gapi::wip::IStreamSource > &src)
	Creates a G-API IStreamSource that delegates to a Python-defined source.
template<class T , class... Args>
IStreamSource::Ptr	make_src (Args &&... args)

Detailed Description

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.

Typedef Documentation

GStreamerPipeline

using cv::gapi::wip::GStreamerPipeline = gst::GStreamerPipeline

GStreamerSource

using cv::gapi::wip::GStreamerSource = gst::GStreamerSource

GVPLSource

using cv::gapi::wip::GVPLSource = onevpl::GSource

Function Documentation

async() [1/4]

std::future< void > cv::gapi::wip::async	(	GCompiled &	gcmpld,
		GRunArgs &&	ins,
		GRunArgsP &&	outs )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

gcmpld	Compiled computation (graph) to run asynchronously
ins	Input parameters for gcmpld
outs	Output parameters for gcmpld

Returns

std::future<void> object to wait for completion of async operation

See also

async

async() [2/4]

std::future< void > cv::gapi::wip::async	(	GCompiled &	gcmpld,
		GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GAsyncContext &	ctx )

Parameters

gcmpld	Compiled computation (graph) to run asynchronously
ins	Input parameters for gcmpld
outs	Output parameters for gcmpld
ctx	Context this request belongs to

Returns

std::future<void> object to wait for completion of async operation

See also

async GAsyncContext

async() [3/4]

void cv::gapi::wip::async	(	GCompiled &	gcmpld,
		std::function< void(std::exception_ptr)> &&	callback,
		GRunArgs &&	ins,
		GRunArgsP &&	outs )

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)

Parameters

gcmpld	Compiled computation (graph) to start asynchronously
callback	Callback to be called when execution of gcmpld is done
ins	Input parameters for gcmpld
outs	Output parameters for gcmpld

async() [4/4]

void cv::gapi::wip::async	(	GCompiled &	gcmpld,
		std::function< void(std::exception_ptr)> &&	callback,
		GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GAsyncContext &	ctx )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

gcmpld	Compiled computation (graph) to run asynchronously
callback	Callback to be called when execution of gcmpld is done
ins	Input parameters for gcmpld
outs	Output parameters for gcmpld
ctx	Context this request belongs to

See also

async GAsyncContext

async_apply() [1/4]

std::future< void > cv::gapi::wip::async_apply	(	GComputation &	gcomp,
		GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GCompileArgs &&	args,
		GAsyncContext &	ctx )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

gcomp	Computation (graph) to run asynchronously
ins	Input parameters for gcomp
outs	Output parameters for gcomp
args	Compile arguments to pass to GComputation::apply()
ctx	Context this request belongs to

Returns

std::future<void> object to wait for completion of async operation

See also

async_apply async GAsyncContext

async_apply() [2/4]

std::future< void > cv::gapi::wip::async_apply	(	GComputation &	gcomp,
		GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GCompileArgs &&	args = {} )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

gcomp	Computation (graph) to run asynchronously
ins	Input parameters for gcomp
outs	Output parameters for gcomp
args	Compile arguments to pass to GComputation::apply()

Returns

std::future<void> object to wait for completion of async operation

See also

async_apply async

async_apply() [3/4]

void cv::gapi::wip::async_apply	(	GComputation &	gcomp,
		std::function< void(std::exception_ptr)> &&	callback,
		GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GCompileArgs &&	args,
		GAsyncContext &	ctx )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters

gcomp	Computation (graph) to run asynchronously
callback	Callback to be called when execution of gcomp is done
ins	Input parameters for gcomp
outs	Output parameters for gcomp
args	Compile arguments to pass to GComputation::apply()
ctx	Context this request belongs to

See also

async_apply async GAsyncContext

async_apply() [4/4]

void cv::gapi::wip::async_apply	(	GComputation &	gcomp,
		std::function< void(std::exception_ptr)> &&	callback,
		GRunArgs &&	ins,
		GRunArgsP &&	outs,
		GCompileArgs &&	args = {} )

In contrast to async() functions, these do call GComputation::apply() member function of the GComputation passed in.

Parameters

gcomp	Computation (graph) to run asynchronously
callback	Callback to be called when execution of gcomp is done
ins	Input parameters for gcomp
outs	Output parameters for gcomp
args	Compile arguments to pass to GComputation::apply()

See also

async

get_streaming_source()

cv::Ptr< IStreamSource > cv::gapi::wip::get_streaming_source ( cv::Ptr< GStreamerPipeline > & pipeline, const std::string & appsinkName, const GStreamerSource::OutputType outputType = GStreamerSource::OutputType::MAT )

inline

Python:
	cv.gapi.wip.get_streaming_source(	pipeline, appsinkName[, outputType]	) ->	retval

make_capture_src() [1/2]

cv::Ptr< IStreamSource > cv::gapi::wip::make_capture_src ( const int id, const std::map< int, double > & properties = {} )

inline

Python:
	cv.gapi.wip.make_capture_src(	path[, properties]	) ->	retval
	cv.gapi.wip.make_capture_src(	id[, properties]	) ->	retval

make_capture_src() [2/2]

cv::Ptr< IStreamSource > cv::gapi::wip::make_capture_src ( const std::string & path, const std::map< int, double > & properties = {} )

inline

Python:
	cv.gapi.wip.make_capture_src(	path[, properties]	) ->	retval
	cv.gapi.wip.make_capture_src(	id[, properties]	) ->	retval

make_gst_src()

cv::Ptr< IStreamSource > cv::gapi::wip::make_gst_src ( const std::string & pipeline, const GStreamerSource::OutputType outputType = GStreamerSource::OutputType::MAT )

inline

Python:
	cv.gapi.wip.make_gst_src(	pipeline[, outputType]	) ->	retval

Here is the call graph for this function:

make_onevpl_src()

template<class... Args>

cv::Ptr< IStreamSource > cv::gapi::wip::make_onevpl_src ( Args &&... args )

inline

Here is the call graph for this function:

make_py_src()

cv::Ptr< cv::gapi::wip::IStreamSource > cv::gapi::wip::make_py_src

(

const cv::Ptr< cv::gapi::wip::IStreamSource > &

src

)

Python:
	cv.gapi.wip.make_py_src(	src	) ->	retval

Creates a G-API IStreamSource that delegates to a Python-defined source.

This factory function wraps a Python object (for example, an instance of a class implementing a pull() and a descr_of() method) into a cv::gapi::wip::IStreamSource, enabling it to be used within a G-API computation graph. The OpenCV Python bindings automatically convert the PyObject into a cv::Ptr<IStreamSource>.

Parameters

src	A cv::Ptr<IStreamSource> that internally holds the original Python object.

Returns

A cv::Ptr<IStreamSource> that wraps the provided Python object. On each frame pull, G-API will:

• Acquire the Python GIL
• Call the Python object’s pull() method
• Convert the resulting NumPy array to a cv::Mat
• Pass the cv::Mat into the G-API pipeline

Note

In Python, you can use the returned make_py_src as follows:

class MyClass:
    def __init__(self):
        # Initialize your source
    def pull(self):
        # Return the next frame as a numpy.ndarray or None for end-of-stream
    def descr_of(self):
        # Return a numpy.ndarray that describes the format of the frames
 
# Create a G-API source from a Python class
py_src = cv.gapi.wip.make_py_src(MyClass())
 
# Define a simple graph: input → copy → output
g_in = cv.GMat()
g_out = cv.gapi.copy(g_in)
graph = cv.GComputation(g_in, g_out)
 
# Compile the pipeline for streaming and assign the source
pipeline = graph.compileStreaming()
pipeline.setSource([py_src])
pipeline.start()

make_src()

template<class T , class... Args>

IStreamSource::Ptr cv::gapi::wip::make_src ( Args &&... args )

inline