cv::gapi Namespace Reference

Namespaces
namespace	calib3d
	This namespace contains G-API Operation Types for Stereo and related functionality.
namespace	compound
namespace	core
	This namespace contains G-API Operation Types for OpenCV Core module functionality.
namespace	cpu
	This namespace contains G-API CPU backend functions, structures, and symbols.
namespace	fluid
	This namespace contains G-API Fluid backend functions, structures, and symbols.
namespace	ie
	This namespace contains G-API OpenVINO backend functions, structures, and symbols.
namespace	imgproc
	This namespace contains G-API Operation Types for OpenCV ImgProc module functionality.
namespace	nn
namespace	oak
namespace	ocl
	This namespace contains G-API OpenCL backend functions, structures, and symbols.
namespace	onnx
	This namespace contains G-API ONNX Runtime backend functions, structures, and symbols.
namespace	ot
	This namespace contains G-API Operation Types for VAS Object Tracking module functionality.
namespace	ov
	This namespace contains G-API OpenVINO 2.0 backend functions, structures, and symbols.
namespace	own
	This namespace contains G-API own data structures used in its standalone mode build.
namespace	plaidml
	This namespace contains G-API PlaidML backend functions, structures, and symbols.
namespace	python
	This namespace contains G-API Python backend functions, structures, and symbols.
namespace	render
	This namespace contains G-API CPU rendering backend functions, structures, and symbols. See G-API Drawing and composition functionality for details.
namespace	s11n
	This namespace contains G-API serialization and deserialization functions and data structures.
namespace	streaming
	This namespace contains G-API functions, structures, and symbols related to the Streaming execution mode.
namespace	video
	This namespace contains G-API Operations and functions for video-oriented algorithms, like optical flow and background subtraction.
namespace	wip
	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.

Classes
struct	Generic
	Generic network type: input and output layers are configured dynamically at runtime. More...
struct	GNetPackage
	A container class for network configurations. Similar to GKernelPackage. Use cv::gapi::networks() to construct this object. More...
struct	KalmanParams
	Structure for the Kalman filter's initialization parameters. More...
struct	use_only
	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). More...

Typedefs
using	GKernelPackage = cv::GKernelPackage

Enumerations
enum class	StereoOutputFormat {   DEPTH_FLOAT16 ,   DEPTH_FLOAT32 ,   DISPARITY_FIXED16_11_5 ,   DISPARITY_FIXED16_12_4 ,   DEPTH_16F = DEPTH_FLOAT16 ,   DEPTH_32F = DEPTH_FLOAT32 ,   DISPARITY_16Q_10_5 = DISPARITY_FIXED16_11_5 ,   DISPARITY_16Q_11_4 = DISPARITY_FIXED16_12_4 }

Functions
GMat	absDiff (const GMat &src1, const GMat &src2)
	Calculates the per-element absolute difference between two matrices.
GMat	absDiffC (const GMat &src, const GScalar &c)
	Calculates absolute value of matrix elements.
GMat	add (const GMat &src1, const GMat &src2, int ddepth=-1)
	Calculates the per-element sum of two matrices.
GMat	addC (const GMat &src1, const GScalar &c, int ddepth=-1)
	Calculates the per-element sum of matrix and given scalar.
GMat	addC (const GScalar &c, const GMat &src1, int ddepth=-1)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat	addWeighted (const GMat &src1, double alpha, const GMat &src2, double beta, double gamma, int ddepth=-1)
	Calculates the weighted sum of two matrices.
GMat	BackgroundSubtractor (const GMat &src, const cv::gapi::video::BackgroundSubtractorParams &bsParams)
	Gaussian Mixture-based or K-nearest neighbours-based Background/Foreground Segmentation Algorithm. The operation generates a foreground mask.
GMat	BayerGR2RGB (const GMat &src_gr)
	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.
GMat	BGR2Gray (const GMat &src)
	Converts an image from BGR color space to gray-scaled.
GMat	BGR2I420 (const GMat &src)
	Converts an image from BGR color space to I420 color space.
GMat	BGR2LUV (const GMat &src)
	Converts an image from BGR color space to LUV color space.
GMat	BGR2RGB (const GMat &src)
	Converts an image from BGR color space to RGB color space.
GMat	BGR2YUV (const GMat &src)
	Converts an image from BGR color space to YUV color space.
GMat	bilateralFilter (const GMat &src, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
	Applies the bilateral filter to an image.
cv::GRunArg	bind (cv::GRunArgP &out)
	Wraps output GRunArgsP available during graph execution to GRunArgs which can be serialized.
cv::GRunArgsP	bind (cv::GRunArgs &out_args)
	Wraps deserialized output GRunArgs to GRunArgsP which can be used by GCompiled.
GMat	bitwise_and (const GMat &src1, const GMat &src2)
	computes bitwise conjunction of the two matrixes (src1 & src2) Calculates the per-element bit-wise logical conjunction of two matrices of the same size.
GMat	bitwise_and (const GMat &src1, const GScalar &src2)
GMat	bitwise_not (const GMat &src)
	Inverts every bit of an array.
GMat	bitwise_or (const GMat &src1, const GMat &src2)
	computes bitwise disjunction of the two matrixes (src1 | src2) Calculates the per-element bit-wise logical disjunction of two matrices of the same size.
GMat	bitwise_or (const GMat &src1, const GScalar &src2)
GMat	bitwise_xor (const GMat &src1, const GMat &src2)
	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.
GMat	bitwise_xor (const GMat &src1, const GScalar &src2)
GMat	blur (const GMat &src, const Size &ksize, const Point &anchor=Point(-1,-1), int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Blurs an image using the normalized box filter.
GOpaque< Rect >	boundingRect (const GArray< Point2f > &src)
GOpaque< Rect >	boundingRect (const GArray< Point2i > &src)
GOpaque< Rect >	boundingRect (const GMat &src)
	Calculates the up-right bounding rectangle of a point set or non-zero pixels of gray-scale image.
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))
	Blurs an image using the box filter.
std::tuple< GArray< GMat >, 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)
	Constructs the image pyramid which can be passed to calcOpticalFlowPyrLK.
std::tuple< GArray< Point2f >, GArray< uchar >, GArray< float > >	calcOpticalFlowPyrLK (const GArray< GMat > &prevPyr, const GArray< GMat > &nextPyr, const GArray< Point2f > &prevPts, const GArray< Point2f > &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)
std::tuple< GArray< Point2f >, GArray< uchar >, GArray< float > >	calcOpticalFlowPyrLK (const GMat &prevImg, const GMat &nextImg, const GArray< Point2f > &prevPts, const GArray< Point2f > &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)
	Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.
GMat	Canny (const GMat &image, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
	Finds edges in an image using the Canny algorithm.
std::tuple< GMat, GMat >	cartToPolar (const GMat &x, const GMat &y, bool angleInDegrees=false)
	Calculates the magnitude and angle of 2D vectors.
GMat	cmpEQ (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are equal to elements in second.
GMat	cmpEQ (const GMat &src1, const GScalar &src2)
GMat	cmpGE (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are greater or equal compare to elements in second.
GMat	cmpGE (const GMat &src1, const GScalar &src2)
GMat	cmpGT (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are greater compare to elements in second.
GMat	cmpGT (const GMat &src1, const GScalar &src2)
GMat	cmpLE (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are less or equal compare to elements in second.
GMat	cmpLE (const GMat &src1, const GScalar &src2)
GMat	cmpLT (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are less than elements in second.
GMat	cmpLT (const GMat &src1, const GScalar &src2)
GMat	cmpNE (const GMat &src1, const GMat &src2)
	Performs the per-element comparison of two matrices checking if elements from first matrix are not equal to elements in second.
GMat	cmpNE (const GMat &src1, const GScalar &src2)
template<typename... Ps>
cv::GKernelPackage	combine (const cv::GKernelPackage &a, const cv::GKernelPackage &b, Ps &&... rest)
	Combines multiple G-API kernel packages into one.
cv::GKernelPackage	combine (const cv::GKernelPackage &lhs, const cv::GKernelPackage &rhs)
GMat	concatHor (const GMat &src1, const GMat &src2)
	Applies horizontal concatenation to given matrices.
GMat	concatHor (const std::vector< GMat > &v)
GMat	concatVert (const GMat &src1, const GMat &src2)
	Applies vertical concatenation to given matrices.
GMat	concatVert (const std::vector< GMat > &v)
GMat	convertTo (const GMat &src, int rdepth, double alpha=1, double beta=0)
	Converts a matrix to another data depth with optional scaling.
GFrame	copy (const GFrame &in)
	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.
GMat	copy (const GMat &in)
	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.
GOpaque< int >	countNonZero (const GMat &src)
	Counts non-zero array elements.
GMat	crop (const GMat &src, const Rect &rect)
	Crops a 2D matrix.
template<>
cv::GComputation	deserialize (const std::vector< char > &bytes)
	Deserialize GComputation from a byte array.
template<>
cv::GMetaArgs	deserialize (const std::vector< char > &bytes)
	Deserialize GMetaArgs from a byte array.
template<>
cv::GRunArgs	deserialize (const std::vector< char > &bytes)
	Deserialize GRunArgs from a byte array.
template<>
std::vector< std::string >	deserialize (const std::vector< char > &bytes)
	Deserialize std::vector<std::string> from a byte array.
template<typename T , typename... Types>
std::enable_if< std::is_same< T, GCompileArgs >::value, GCompileArgs >::type	deserialize (const std::vector< char > &bytes)
	Deserialize GCompileArgs which types were specified in the template from a byte array.
template<typename T , typename AtLeastOneAdapterT , typename... AdapterTypes>
std::enable_if< std::is_same< T, GRunArgs >::value, GRunArgs >::type	deserialize (const std::vector< char > &bytes)
	Deserialize GRunArgs including RMat and MediaFrame objects if any from a byte array.
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())
	Dilates an image by using a specific structuring element.
GMat	dilate3x3 (const GMat &src, int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	Dilates an image by using 3 by 3 rectangular structuring element.
GMat	div (const GMat &src1, const GMat &src2, double scale, int ddepth=-1)
	Performs per-element division of two matrices.
GMat	divC (const GMat &src, const GScalar &divisor, double scale, int ddepth=-1)
	Divides matrix by scalar.
GMat	divRC (const GScalar &divident, const GMat &src, double scale, int ddepth=-1)
	Divides scalar by matrix.
GMat	equalizeHist (const GMat &src)
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())
	Erodes an image by using a specific structuring element.
GMat	erode3x3 (const GMat &src, int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
	Erodes an image by using 3 by 3 rectangular structuring element.
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))
	Convolves an image with the kernel.
GArray< GArray< Point > >	findContours (const GMat &src, const RetrievalModes mode, const ContourApproximationModes method)
GArray< GArray< Point > >	findContours (const GMat &src, const RetrievalModes mode, const ContourApproximationModes method, const GOpaque< Point > &offset)
	Finds contours in a binary image.
std::tuple< GArray< GArray< Point > >, GArray< Vec4i > >	findContoursH (const GMat &src, const RetrievalModes mode, const ContourApproximationModes method)
std::tuple< GArray< GArray< Point > >, GArray< Vec4i > >	findContoursH (const GMat &src, const RetrievalModes mode, const ContourApproximationModes method, const GOpaque< Point > &offset)
	Finds contours and their hierarchy in a binary image.
GOpaque< Vec4f >	fitLine2D (const GArray< Point2d > &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
GOpaque< Vec4f >	fitLine2D (const GArray< Point2f > &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
GOpaque< Vec4f >	fitLine2D (const GArray< Point2i > &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
GOpaque< Vec4f >	fitLine2D (const GMat &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
	Fits a line to a 2D point set.
GOpaque< Vec6f >	fitLine3D (const GArray< Point3d > &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
GOpaque< Vec6f >	fitLine3D (const GArray< Point3f > &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
GOpaque< Vec6f >	fitLine3D (const GArray< Point3i > &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
GOpaque< Vec6f >	fitLine3D (const GMat &src, const DistanceTypes distType, const double param=0., const double reps=0., const double aeps=0.)
	Fits a line to a 3D point set.
GMat	flip (const GMat &src, int flipCode)
	Flips a 2D matrix around vertical, horizontal, or both axes.
GMat	gaussianBlur (const GMat &src, const Size &ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Blurs an image using a Gaussian filter.
GArray< Point2f >	goodFeaturesToTrack (const GMat &image, int maxCorners, double qualityLevel, double minDistance, const Mat &mask=Mat(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
	Determines strong corners on an image.
GMat	I4202BGR (const GMat &src)
	Converts an image from I420 color space to BGR color space.
GMat	I4202RGB (const GMat &src)
	Converts an image from I420 color space to BGR color space.
template<typename Net , typename... Args>
Net::Result	infer (Args &&... args)
	Calculates response for the specified network (template parameter) given the input data.
template<typename T = Generic>
cv::GInferListOutputs	infer (const std::string &tag, const cv::GArray< cv::Rect > &rois, const cv::GInferInputs &inputs)
	Calculates responses for the specified network for every region in the source image.
template<typename T = Generic>
cv::GInferOutputs	infer (const std::string &tag, const cv::GInferInputs &inputs)
	Calculates response for generic network.
template<typename T = Generic>
cv::GInferOutputs	infer (const std::string &tag, const cv::GOpaque< cv::Rect > &roi, const cv::GInferInputs &inputs)
	Calculates response for the generic network for the specified region in the source image. Currently expects a single-input network only.
template<typename Net , typename... Args>
Net::ResultL	infer (cv::GArray< cv::Rect > roi, Args &&... args)
	Calculates responses for the specified network (template parameter) for every region in the source image.
template<typename Net , typename T >
Net::Result	infer (cv::GOpaque< cv::Rect > roi, T in)
	Calculates response for the specified network (template parameter) for the specified region in the source image. Currently expects a single-input network only.
template<typename T = Generic, typename Input >
std::enable_if< cv::detail::accepted_infer_types< Input >::value, cv::GInferListOutputs >::type	infer2 (const std::string &tag, const Input &in, const cv::GInferListInputs &inputs)
	Calculates responses for the specified network for every region in the source image, extended version.
template<typename Net , typename T , typename... Args>
Net::ResultL	infer2 (T image, cv::GArray< Args >... args)
	Calculates responses for the specified network (template parameter) for every region in the source image, extended version.
GMat	inRange (const GMat &src, const GScalar &threshLow, const GScalar &threshUp)
	Applies a range-level threshold to each matrix element.
std::tuple< GMat, GMat >	integral (const GMat &src, int sdepth=-1, int sqdepth=-1)
	Calculates the integral of an image.
void	island (const std::string &name, GProtoInputArgs &&ins, GProtoOutputArgs &&outs)
	Define an tagged island (subgraph) within a computation.
GMat	KalmanFilter (const GMat &measurement, const GOpaque< bool > &haveMeasurement, const cv::gapi::KalmanParams &kfParams)
GMat	KalmanFilter (const GMat &measurement, const GOpaque< bool > &haveMeasurement, const GMat &control, const cv::gapi::KalmanParams &kfParams)
	Standard Kalman filter algorithm http://en.wikipedia.org/wiki/Kalman_filter.
template<typename... KK>
GKernelPackage	kernels ()
	Create a kernel package object containing kernels and transformations specified in variadic template argument.
template<typename... FF>
GKernelPackage	kernels (FF &... functors)
std::tuple< GOpaque< double >, GArray< int >, GArray< Point2f > >	kmeans (const GArray< Point2f > &data, const int K, const GArray< int > &bestLabels, const TermCriteria &criteria, const int attempts, const KmeansFlags flags)
std::tuple< GOpaque< double >, GArray< int >, GArray< Point3f > >	kmeans (const GArray< Point3f > &data, const int K, const GArray< int > &bestLabels, const TermCriteria &criteria, const int attempts, const KmeansFlags flags)
std::tuple< GOpaque< double >, GMat, GMat >	kmeans (const GMat &data, const int K, const GMat &bestLabels, const TermCriteria &criteria, const int attempts, const KmeansFlags flags)
	Finds centers of clusters and groups input samples around the clusters.
std::tuple< GOpaque< double >, GMat, GMat >	kmeans (const GMat &data, const int K, const TermCriteria &criteria, const int attempts, const KmeansFlags flags)
GMat	Laplacian (const GMat &src, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
	Calculates the Laplacian of an image.
GMat	LUT (const GMat &src, const Mat &lut)
	Performs a look-up table transform of a matrix.
GMat	LUV2BGR (const GMat &src)
	Converts an image from LUV color space to BGR color space.
GMat	mask (const GMat &src, const GMat &mask)
	Applies a mask to a matrix.
GMat	max (const GMat &src1, const GMat &src2)
	Calculates per-element maximum of two matrices.
GScalar	mean (const GMat &src)
	Calculates an average (mean) of matrix elements.
GMat	medianBlur (const GMat &src, int ksize)
	Blurs an image using the median filter.
GMat	merge3 (const GMat &src1, const GMat &src2, const GMat &src3)
	Creates one 3-channel matrix out of 3 single-channel ones.
GMat	merge4 (const GMat &src1, const GMat &src2, const GMat &src3, const GMat &src4)
	Creates one 4-channel matrix out of 4 single-channel ones.
GMat	min (const GMat &src1, const GMat &src2)
	Calculates per-element minimum of two matrices.
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())
	Performs advanced morphological transformations.
GMat	mul (const GMat &src1, const GMat &src2, double scale=1.0, int ddepth=-1)
	Calculates the per-element scaled product of two matrices.
GMat	mulC (const GMat &src, const GScalar &multiplier, int ddepth=-1)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
GMat	mulC (const GMat &src, double multiplier, int ddepth=-1)
	Multiplies matrix by scalar.
GMat	mulC (const GScalar &multiplier, const GMat &src, int ddepth=-1)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename... Args>
cv::gapi::GNetPackage	networks (Args &&... args)
GMat	normalize (const GMat &src, double alpha, double beta, int norm_type, int ddepth=-1)
	Normalizes the norm or value range of an array.
GScalar	normInf (const GMat &src)
	Calculates the absolute infinite norm of a matrix.
GScalar	normL1 (const GMat &src)
	Calculates the absolute L1 norm of a matrix.
GScalar	normL2 (const GMat &src)
	Calculates the absolute L2 norm of a matrix.
GMat	NV12toBGR (const GMat &src_y, const GMat &src_uv)
	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.
GMatP	NV12toBGRp (const GMat &src_y, const GMat &src_uv)
	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.
GMat	NV12toGray (const GMat &src_y, const GMat &src_uv)
	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.
GMat	NV12toRGB (const GMat &src_y, const GMat &src_uv)
	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.
GMatP	NV12toRGBp (const GMat &src_y, const GMat &src_uv)
	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.
bool	operator!= (const GBackend &lhs, const GBackend &rhs)
cv::gapi::GNetPackage &	operator+= (cv::gapi::GNetPackage &lhs, const cv::gapi::GNetPackage &rhs)
GArray< Rect >	parseSSD (const GMat &in, const GOpaque< Size > &inSz, const float confidenceThreshold, const bool alignmentToSquare, const bool filterOutOfBounds)
	Parses output of SSD network.
std::tuple< GArray< Rect >, GArray< int > >	parseSSD (const GMat &in, const GOpaque< Size > &inSz, const float confidenceThreshold=0.5f, const int filterLabel=-1)
	Parses output of SSD network.
std::tuple< GArray< Rect >, GArray< int > >	parseYolo (const GMat &in, const GOpaque< Size > &inSz, const float confidenceThreshold=0.5f, const float nmsThreshold=0.5f, const std::vector< float > &anchors=nn::parsers::GParseYolo::defaultAnchors())
	Parses output of Yolo network.
GMat	phase (const GMat &x, const GMat &y, bool angleInDegrees=false)
	Calculates the rotation angle of 2D vectors.
std::tuple< GMat, GMat >	polarToCart (const GMat &magnitude, const GMat &angle, bool angleInDegrees=false)
	Calculates x and y coordinates of 2D vectors from their magnitude and angle.
GMat	remap (const GMat &src, const Mat &map1, const Mat &map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
	Applies a generic geometrical transformation to an image.
GMat	resize (const GMat &src, const Size &dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
	Resizes an image.
GMatP	resizeP (const GMatP &src, const Size &dsize, int interpolation=cv::INTER_LINEAR)
	Resizes a planar image.
GMat	RGB2Gray (const GMat &src)
	Converts an image from RGB color space to gray-scaled.
GMat	RGB2Gray (const GMat &src, float rY, float gY, float bY)
GMat	RGB2HSV (const GMat &src)
	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.
GMat	RGB2I420 (const GMat &src)
	Converts an image from RGB color space to I420 color space.
GMat	RGB2Lab (const GMat &src)
	Converts an image from RGB color space to Lab color space.
GMat	RGB2YUV (const GMat &src)
	Converts an image from RGB color space to YUV color space.
GMat	RGB2YUV422 (const GMat &src)
	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.
GMat	select (const GMat &src1, const GMat &src2, const GMat &mask)
	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).
GMat	sepFilter (const GMat &src, int ddepth, const Mat &kernelX, const Mat &kernelY, const Point &anchor, const Scalar &delta, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
	Applies a separable linear filter to a matrix(image).
std::vector< char >	serialize (const cv::GCompileArgs &ca)
std::vector< char >	serialize (const cv::GComputation &c)
	Serialize a graph represented by GComputation into an array of bytes.
std::vector< char >	serialize (const cv::GMetaArgs &ma)
std::vector< char >	serialize (const cv::GRunArgs &ra)
std::vector< char >	serialize (const std::vector< std::string > &vs)
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))
	Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
std::tuple< GMat, GMat >	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))
	Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
std::tuple< GMat, GMat, GMat >	split3 (const GMat &src)
	Divides a 3-channel matrix into 3 single-channel matrices.
std::tuple< GMat, GMat, GMat, GMat >	split4 (const GMat &src)
	Divides a 4-channel matrix into 4 single-channel matrices.
GMat	sqrt (const GMat &src)
	Calculates a square root of array elements.
GMat	stereo (const GMat &left, const GMat &right, const StereoOutputFormat of=StereoOutputFormat::DEPTH_FLOAT32)
	Computes disparity/depth map for the specified stereo-pair. The function computes disparity or depth map depending on passed StereoOutputFormat argument.
GMat	sub (const GMat &src1, const GMat &src2, int ddepth=-1)
	Calculates the per-element difference between two matrices.
GMat	subC (const GMat &src, const GScalar &c, int ddepth=-1)
	Calculates the per-element difference between matrix and given scalar.
GMat	subRC (const GScalar &c, const GMat &src, int ddepth=-1)
	Calculates the per-element difference between given scalar and the matrix.
GScalar	sum (const GMat &src)
	Calculates sum of all matrix elements.
std::tuple< GMat, GScalar >	threshold (const GMat &src, const GScalar &maxval, int type)
GMat	threshold (const GMat &src, const GScalar &thresh, const GScalar &maxval, int type)
	Applies a fixed-level threshold to each matrix element.
GMat	transpose (const GMat &src)
	Transposes a matrix.
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())
	Applies an affine transformation to an image.
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())
	Applies a perspective transformation to an image.
GMat	YUV2BGR (const GMat &src)
	Converts an image from YUV color space to BGR color space.
GMat	YUV2RGB (const GMat &src)
	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.

Typedef Documentation

GKernelPackage

using cv::gapi::GKernelPackage = typedef cv::GKernelPackage

Enumeration Type Documentation

StereoOutputFormat

enum class cv::gapi::StereoOutputFormat

strong

The enum specified format of result that you get from cv::gapi::stereo.

Enumerator
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	Same as DEPTH_FLOAT16.
DEPTH_32F	Same as DEPTH_FLOAT32.
DISPARITY_16Q_10_5	Same as DISPARITY_FIXED16_11_5.
DISPARITY_16Q_11_4	Same as DISPARITY_FIXED16_12_4.

Function Documentation

combine() [1/2]

template<typename... Ps>

cv::GKernelPackage cv::gapi::combine	(	const cv::GKernelPackage &	a,
		const cv::GKernelPackage &	b,
		Ps &&...	rest
	)

Python:
	cv.gapi.combine(	lhs, rhs	) ->	retval

Combines multiple G-API kernel packages into one.

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

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

Returns

The resulting kernel package

Here is the call graph for this function:

combine() [2/2]

cv::GKernelPackage cv::gapi::combine	(	const cv::GKernelPackage &	lhs,
		const cv::GKernelPackage &	rhs
	)

Python:
	cv.gapi.combine(	lhs, rhs	) ->	retval

deserialize() [1/3]

template<>

cv::GMetaArgs cv::gapi::deserialize ( const std::vector< char > &  bytes )

inline

Deserialize GMetaArgs from a byte array.

Check different overloads for more examples.

Parameters

bytes

serialized vector of bytes.

Returns

deserialized GMetaArgs object.

deserialize() [2/3]

template<>

cv::GRunArgs cv::gapi::deserialize ( const std::vector< char > &  bytes )

inline

Deserialize GRunArgs from a byte array.

Check different overloads for more examples.

Parameters

bytes

serialized vector of bytes.

Returns

deserialized GRunArgs object.

deserialize() [3/3]

template<>

std::vector< std::string > cv::gapi::deserialize ( const std::vector< char > &  bytes )

inline

Deserialize std::vector<std::string> from a byte array.

Check different overloads for more examples.

Parameters

bytes

serialized vector of bytes.

Returns

deserialized std::vector<std::string> object.

equalizeHist()

GMat cv::gapi::equalizeHist

(

const GMat &

src

)

Python:
	cv.gapi.equalizeHist(	src	) ->	retval

gapi_feature

The function equalizes the histogram of the input image using the following algorithm:

• Calculate the histogram \(H\) for src .
• Normalize the histogram so that the sum of histogram bins is 255.
• Compute the integral of the histogram:

  \[H'_i = \sum _{0 \le j < i} H(j)\]

• Transform the image using \(H'\) as a look-up table: \(\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\)

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"

Parameters

src	Source 8-bit single channel image.

infer() [1/6]

template<typename Net , typename... Args>

Net::Result cv::gapi::infer

(

Args &&...

args

)

Python:
	cv.gapi.infer(	name, inputs	) ->	retval
	cv.gapi.infer(	name, roi, inputs	) ->	retval
	cv.gapi.infer(	name, rois, inputs	) ->	retval

Calculates response for the specified network (template parameter) given the input data.

Template Parameters

A	network type defined with G_API_NET() macro.

Parameters

args	network's input parameters as specified in G_API_NET() macro.

Returns

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.

See also

G_API_NET()

infer() [2/6]

template<typename T = Generic>

cv::GInferListOutputs cv::gapi::infer	(	const std::string &	tag,
		const cv::GArray< cv::Rect > &	rois,
		const cv::GInferInputs &	inputs
	)

Python:
	cv.gapi.infer(	name, inputs	) ->	retval
	cv.gapi.infer(	name, roi, inputs	) ->	retval
	cv.gapi.infer(	name, rois, inputs	) ->	retval

Calculates responses for the specified network for every region in the source image.

Parameters

tag	a network tag
rois	a list of rectangles describing regions of interest in the source image. Usually an output of object detector or tracker.
inputs	networks's inputs

Returns

a cv::GInferListOutputs

infer() [3/6]

template<typename T = Generic>

cv::GInferOutputs cv::gapi::infer	(	const std::string &	tag,
		const cv::GInferInputs &	inputs
	)

Python:
	cv.gapi.infer(	name, inputs	) ->	retval
	cv.gapi.infer(	name, roi, inputs	) ->	retval
	cv.gapi.infer(	name, rois, inputs	) ->	retval

Calculates response for generic network.

Parameters

tag	a network tag
inputs	networks's inputs

Returns

a GInferOutputs

Here is the call graph for this function:

infer() [4/6]

template<typename T = Generic>

cv::GInferOutputs cv::gapi::infer	(	const std::string &	tag,
		const cv::GOpaque< cv::Rect > &	roi,
		const cv::GInferInputs &	inputs
	)

Python:
	cv.gapi.infer(	name, inputs	) ->	retval
	cv.gapi.infer(	name, roi, inputs	) ->	retval
	cv.gapi.infer(	name, rois, inputs	) ->	retval

Calculates response for the generic network for the specified region in the source image. Currently expects a single-input network only.

Parameters

tag	a network tag
roi	a an object describing the region of interest in the source image. May be calculated in the same graph dynamically.
inputs	networks's inputs

Returns

a cv::GInferOutputs

infer() [5/6]

template<typename Net , typename... Args>

Net::ResultL cv::gapi::infer	(	cv::GArray< cv::Rect >	roi,
		Args &&...	args
	)

Python:
	cv.gapi.infer(	name, inputs	) ->	retval
	cv.gapi.infer(	name, roi, inputs	) ->	retval
	cv.gapi.infer(	name, rois, inputs	) ->	retval

Calculates responses for the specified network (template parameter) for every region in the source image.

Template Parameters

A	network type defined with G_API_NET() macro.

Parameters

roi	a list of rectangles describing regions of interest in the source image. Usually an output of object detector or tracker.
args	network's input parameters as specified in G_API_NET() macro. NOTE: verified to work reliably with 1-input topologies only.

Returns

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.

See also

G_API_NET()

infer() [6/6]

template<typename Net , typename T >

Net::Result cv::gapi::infer	(	cv::GOpaque< cv::Rect >	roi,
		T	in
	)

Python:
	cv.gapi.infer(	name, inputs	) ->	retval
	cv.gapi.infer(	name, roi, inputs	) ->	retval
	cv.gapi.infer(	name, rois, inputs	) ->	retval

Calculates response for the specified network (template parameter) for the specified region in the source image. Currently expects a single-input network only.

Template Parameters

A	network type defined with G_API_NET() macro.

Parameters

in	input image where to take ROI from.
roi	an object describing the region of interest in the source image. May be calculated in the same graph dynamically.

Returns

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.

See also

G_API_NET()

infer2() [1/2]

template<typename T = Generic, typename Input >

std::enable_if< cv::detail::accepted_infer_types< Input >::value, cv::GInferListOutputs >::type cv::gapi::infer2	(	const std::string &	tag,
		const Input &	in,
		const cv::GInferListInputs &	inputs
	)

Python:
	cv.gapi.infer2(	name, in_, inputs	) ->	retval

Calculates responses for the specified network for every region in the source image, extended version.

Parameters

tag	a network tag
in	a source image containing regions of interest.
inputs	networks's inputs

Returns

a cv::GInferListOutputs

Here is the call graph for this function:

infer2() [2/2]

template<typename Net , typename T , typename... Args>

Net::ResultL cv::gapi::infer2	(	T	image,
		cv::GArray< Args >...	args
	)

Python:
	cv.gapi.infer2(	name, in_, inputs	) ->	retval

Calculates responses for the specified network (template parameter) for every region in the source image, extended version.

Template Parameters

A	network type defined with G_API_NET() macro.

Parameters

image	A source image containing regions of interest
args	GArray<> objects of cv::Rect or cv::GMat, one per every network input: If a cv::GArray<cv::Rect> is passed, the appropriate regions are taken from image and preprocessed to this particular network input; If a cv::GArray<cv::GMat> is passed, the underlying data traited as tensor (no automatic preprocessing happen).

Returns

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.

See also

G_API_NET()

island()

void cv::gapi::island ( const std::string &  name, GProtoInputArgs &&  ins, GProtoOutputArgs &&  outs  )

protected

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.

Parameters

name	name of the Island to create
ins	vector of input data objects where the subgraph begins
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.

kmeans() [1/4]

std::tuple< GOpaque< double >, GArray< int >, GArray< Point2f > > cv::gapi::kmeans	(	const GArray< Point2f > &	data,
		const int	K,
		const GArray< int > &	bestLabels,
		const TermCriteria &	criteria,
		const int	attempts,
		const KmeansFlags	flags
	)

Python:
	cv.gapi.kmeans(	data, K, bestLabels, criteria, attempts, flags	) ->	retval
	cv.gapi.kmeans(	data, K, criteria, attempts, flags	) ->	retval

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

Note

Function textual ID is "org.opencv.core.kmeans2D"

kmeans() [2/4]

std::tuple< GOpaque< double >, GArray< int >, GArray< Point3f > > cv::gapi::kmeans	(	const GArray< Point3f > &	data,
		const int	K,
		const GArray< int > &	bestLabels,
		const TermCriteria &	criteria,
		const int	attempts,
		const KmeansFlags	flags
	)

Python:
	cv.gapi.kmeans(	data, K, bestLabels, criteria, attempts, flags	) ->	retval
	cv.gapi.kmeans(	data, K, criteria, attempts, flags	) ->	retval

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

Note

Function textual ID is "org.opencv.core.kmeans3D"

kmeans() [3/4]

std::tuple< GOpaque< double >, GMat, GMat > cv::gapi::kmeans	(	const GMat &	data,
		const int	K,
		const GMat &	bestLabels,
		const TermCriteria &	criteria,
		const int	attempts,
		const KmeansFlags	flags
	)

Python:
	cv.gapi.kmeans(	data, K, bestLabels, criteria, attempts, flags	) ->	retval
	cv.gapi.kmeans(	data, K, criteria, attempts, flags	) ->	retval

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, \(\texttt{bestLabels}_i\) contains a 0-based cluster index for the \(i^{th}\) 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 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.

Parameters

data	Data for clustering. An array of N-Dimensional points with float coordinates is needed. Function can take GArray<Point2f>, GArray<Point3f> for 2D and 3D cases or GMat for any dimentionality and channels.
K	Number of clusters to split the set by.
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.
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.
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).
flags	Flag that can take values of cv::KmeansFlags .

Returns

• Compactness measure that is computed as

  \[\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\]

  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.

kmeans() [4/4]

std::tuple< GOpaque< double >, GMat, GMat > cv::gapi::kmeans	(	const GMat &	data,
		const int	K,
		const TermCriteria &	criteria,
		const int	attempts,
		const KmeansFlags	flags
	)

Python:
	cv.gapi.kmeans(	data, K, bestLabels, criteria, attempts, flags	) ->	retval
	cv.gapi.kmeans(	data, K, criteria, attempts, flags	) ->	retval

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

Note

• Function textual ID is "org.opencv.core.kmeansNDNoInit"
• KMEANS_USE_INITIAL_LABELS flag must not be set while using this overload.

networks()

template<typename... Args>

cv::gapi::GNetPackage cv::gapi::networks

(

Args &&...

args

)

Here is the call graph for this function:

operator!=()

bool cv::gapi::operator!= ( const GBackend &  lhs, const GBackend &  rhs  )

inline

operator+=()

cv::gapi::GNetPackage & cv::gapi::operator+= ( cv::gapi::GNetPackage &  lhs, const cv::gapi::GNetPackage &  rhs  )

inline

parseSSD() [1/2]

GArray< Rect > cv::gapi::parseSSD	(	const GMat &	in,
		const GOpaque< Size > &	inSz,
		const float	confidenceThreshold,
		const bool	alignmentToSquare,
		const bool	filterOutOfBounds
	)

Python:
	cv.gapi.parseSSD(	in_, inSz[, confidenceThreshold[, filterLabel]]	) ->	retval
	cv.gapi.parseSSD(	in_, inSz, confidenceThreshold, alignmentToSquare, filterOutOfBounds	) ->	retval

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"

Parameters

in	Input CV_32F tensor with {1,1,N,7} dimensions.
inSz	Size to project detected boxes to (size of the input image).
confidenceThreshold	If confidence of the detection is smaller than confidence threshold, detection is rejected.
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.
filterOutOfBounds	If provided true, out-of-frame boxes are filtered.

Returns

a vector of detected bounding boxes.

Here is the call graph for this function:

parseSSD() [2/2]

std::tuple< GArray< Rect >, GArray< int > > cv::gapi::parseSSD	(	const GMat &	in,
		const GOpaque< Size > &	inSz,
		const float	confidenceThreshold = 0.5f,
		const int	filterLabel = -1
	)

Python:
	cv.gapi.parseSSD(	in_, inSz[, confidenceThreshold[, filterLabel]]	) ->	retval
	cv.gapi.parseSSD(	in_, inSz, confidenceThreshold, alignmentToSquare, filterOutOfBounds	) ->	retval

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"

Parameters

in	Input CV_32F tensor with {1,1,N,7} dimensions.
inSz	Size to project detected boxes to (size of the input image).
confidenceThreshold	If confidence of the detection is smaller than confidence threshold, detection is rejected.
filterLabel	If provided (!= -1), only detections with given label will get to the output.

Returns

a tuple with a vector of detected boxes and a vector of appropriate labels.

Here is the call graph for this function:

parseYolo()

std::tuple< GArray< Rect >, GArray< int > > cv::gapi::parseYolo	(	const GMat &	in,
		const GOpaque< Size > &	inSz,
		const float	confidenceThreshold = 0.5f,
		const float	nmsThreshold = 0.5f,
		const std::vector< float > &	anchors = nn::parsers::GParseYolo::defaultAnchors()
	)

Python:
	cv.gapi.parseYolo(	in_, inSz[, confidenceThreshold[, nmsThreshold[, anchors]]]	) ->	retval

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"

Parameters

in	Input CV_32F tensor with {1,13,13,N} dimensions, N should satisfy: \[\texttt{N} = (\texttt{num_classes} + \texttt{5}) * \texttt{5},\] where num_classes - a number of classes Yolo network was trained with.
inSz	Size to project detected boxes to (size of the input image).
confidenceThreshold	If confidence of the detection is smaller than confidence threshold, detection is rejected.
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.
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.

Returns

a tuple with a vector of detected boxes and a vector of appropriate labels.

Here is the call graph for this function:

stereo()

GMat cv::gapi::stereo	(	const GMat &	left,
		const GMat &	right,
		const StereoOutputFormat	of = StereoOutputFormat::DEPTH_FLOAT32
	)

Computes disparity/depth map for the specified stereo-pair. The function computes disparity or depth map depending on passed StereoOutputFormat argument.

Parameters

left	8-bit single-channel left image of CV_8UC1 type.
right	8-bit single-channel right image of CV_8UC1 type.
of	enum to specified output kind: depth or disparity and corresponding type

Here is the call graph for this function:

transpose()

GMat cv::gapi::transpose

(

const GMat &

src

)

Python:
	cv.gapi.transpose(	src	) ->	retval

Transposes a matrix.

The function transposes the matrix:

\[\texttt{dst} (i,j) = \texttt{src} (j,i)\]

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.

Parameters

src	input array.