OpenCV  4.10.0
Open Source Computer Vision
Loading...
Searching...
No Matches
Namespaces | Typedefs | Functions
core.hpp File Reference
#include <math.h>
#include <utility>
#include <opencv2/imgproc.hpp>
#include <opencv2/gapi/imgproc.hpp>
#include <opencv2/gapi/gmat.hpp>
#include <opencv2/gapi/gscalar.hpp>
#include <opencv2/gapi/gkernel.hpp>
#include <opencv2/gapi/streaming/format.hpp>
Include dependency graph for core.hpp:

Namespaces

namespace  cv
 "black box" representation of the file storage associated with a file on disk.
 
namespace  cv::gapi
 
namespace  cv::gapi::core
 This namespace contains G-API Operation Types for OpenCV Core module functionality.
 
namespace  cv::gapi::streaming
 This namespace contains G-API functions, structures, and symbols related to the Streaming execution mode.
 

Typedefs

using cv::gapi::core::GMat2 = std::tuple< GMat, GMat >
 
using cv::gapi::core::GMat3 = std::tuple< GMat, GMat, GMat >
 
using cv::gapi::core::GMat4 = std::tuple< GMat, GMat, GMat, GMat >
 
using cv::gapi::core::GMatScalar = std::tuple< GMat, GScalar >
 
using cv::gapi::core::GResize = cv::gapi::imgproc::GResize
 
using cv::gapi::core::GResizeP = cv::gapi::imgproc::GResizeP
 

Functions

GMat cv::gapi::absDiff (const GMat &src1, const GMat &src2)
 Calculates the per-element absolute difference between two matrices.
 
GMat cv::gapi::absDiffC (const GMat &src, const GScalar &c)
 Calculates absolute value of matrix elements.
 
GMat cv::gapi::add (const GMat &src1, const GMat &src2, int ddepth=-1)
 Calculates the per-element sum of two matrices.
 
GMat cv::gapi::addC (const GMat &src1, const GScalar &c, int ddepth=-1)
 Calculates the per-element sum of matrix and given scalar.
 
GMat cv::gapi::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 cv::gapi::addWeighted (const GMat &src1, double alpha, const GMat &src2, double beta, double gamma, int ddepth=-1)
 Calculates the weighted sum of two matrices.
 
GMat cv::gapi::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 cv::gapi::bitwise_and (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::bitwise_not (const GMat &src)
 Inverts every bit of an array.
 
GMat cv::gapi::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 cv::gapi::bitwise_or (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::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 cv::gapi::bitwise_xor (const GMat &src1, const GScalar &src2)
 
std::tuple< GMat, GMatcv::gapi::cartToPolar (const GMat &x, const GMat &y, bool angleInDegrees=false)
 Calculates the magnitude and angle of 2D vectors.
 
GMat cv::gapi::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 cv::gapi::cmpEQ (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::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 cv::gapi::cmpGE (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::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 cv::gapi::cmpGT (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::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 cv::gapi::cmpLE (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::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 cv::gapi::cmpLT (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::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 cv::gapi::cmpNE (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::concatHor (const GMat &src1, const GMat &src2)
 Applies horizontal concatenation to given matrices.
 
GMat cv::gapi::concatHor (const std::vector< GMat > &v)
 
GMat cv::gapi::concatVert (const GMat &src1, const GMat &src2)
 Applies vertical concatenation to given matrices.
 
GMat cv::gapi::concatVert (const std::vector< GMat > &v)
 
GMat cv::gapi::convertTo (const GMat &src, int rdepth, double alpha=1, double beta=0)
 Converts a matrix to another data depth with optional scaling.
 
GOpaque< int > cv::gapi::countNonZero (const GMat &src)
 Counts non-zero array elements.
 
GMat cv::gapi::crop (const GMat &src, const Rect &rect)
 Crops a 2D matrix.
 
GMat cv::gapi::div (const GMat &src1, const GMat &src2, double scale, int ddepth=-1)
 Performs per-element division of two matrices.
 
GMat cv::gapi::divC (const GMat &src, const GScalar &divisor, double scale, int ddepth=-1)
 Divides matrix by scalar.
 
GMat cv::gapi::divRC (const GScalar &divident, const GMat &src, double scale, int ddepth=-1)
 Divides scalar by matrix.
 
GMat cv::gapi::flip (const GMat &src, int flipCode)
 Flips a 2D matrix around vertical, horizontal, or both axes.
 
 cv::gapi::core::G_TYPED_KERNEL (GAbsDiff,< GMat(GMat, GMat)>, "org.opencv.core.matrixop.absdiff")
 
 cv::gapi::core::G_TYPED_KERNEL (GAbsDiffC,< GMat(GMat, GScalar)>, "org.opencv.core.matrixop.absdiffC")
 
 cv::gapi::core::G_TYPED_KERNEL (GAdd,< GMat(GMat, GMat, int)>, "org.opencv.core.math.add")
 
 cv::gapi::core::G_TYPED_KERNEL (GAddC,< GMat(GMat, GScalar, int)>, "org.opencv.core.math.addC")
 
 cv::gapi::core::G_TYPED_KERNEL (GAddW,< GMat(GMat, double, GMat, double, double, int)>, "org.opencv.core.matrixop.addweighted")
 
 cv::gapi::core::G_TYPED_KERNEL (GAnd,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.bitwise_and")
 
 cv::gapi::core::G_TYPED_KERNEL (GAndS,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.bitwise_andS")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpEQ,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.compare.cmpEQ")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpEQScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpEQScalar")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpGE,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.compare.cmpGE")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpGEScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpGEScalar")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpGT,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.compare.cmpGT")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpGTScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpGTScalar")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpLE,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.compare.cmpLE")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpLEScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpLEScalar")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpLT,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.compare.cmpLT")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpLTScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpLTScalar")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpNE,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.compare.cmpNE")
 
 cv::gapi::core::G_TYPED_KERNEL (GCmpNEScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpNEScalar")
 
 cv::gapi::core::G_TYPED_KERNEL (GConcatHor,< GMat(GMat, GMat)>, "org.opencv.imgproc.transform.concatHor")
 
 cv::gapi::core::G_TYPED_KERNEL (GConcatVert,< GMat(GMat, GMat)>, "org.opencv.imgproc.transform.concatVert")
 
 cv::gapi::core::G_TYPED_KERNEL (GConvertTo,< GMat(GMat, int, double, double)>, "org.opencv.core.transform.convertTo")
 
 cv::gapi::core::G_TYPED_KERNEL (GCountNonZero,< GOpaque< int >(GMat)>, "org.opencv.core.matrixop.countNonZero")
 
 cv::gapi::core::G_TYPED_KERNEL (GCrop,< GMat(GMat, Rect)>, "org.opencv.core.transform.crop")
 
 cv::gapi::core::G_TYPED_KERNEL (GDiv,< GMat(GMat, GMat, double, int)>, "org.opencv.core.math.div")
 
 cv::gapi::core::G_TYPED_KERNEL (GDivC,< GMat(GMat, GScalar, double, int)>, "org.opencv.core.math.divC")
 
 cv::gapi::core::G_TYPED_KERNEL (GDivRC,< GMat(GScalar, GMat, double, int)>, "org.opencv.core.math.divRC")
 
 cv::gapi::core::G_TYPED_KERNEL (GFlip,< GMat(GMat, int)>, "org.opencv.core.transform.flip")
 
 cv::gapi::core::G_TYPED_KERNEL (GInRange,< GMat(GMat, GScalar, GScalar)>, "org.opencv.core.matrixop.inrange")
 
 cv::gapi::core::G_TYPED_KERNEL (GKMeans2D,< std::tuple< GOpaque< double >, GArray< int >, GArray< Point2f > >(GArray< Point2f >, int, GArray< int >, TermCriteria, int, KmeansFlags)>, "org.opencv.core.kmeans2D")
 
 cv::gapi::core::G_TYPED_KERNEL (GKMeans3D,< std::tuple< GOpaque< double >, GArray< int >, GArray< Point3f > >(GArray< Point3f >, int, GArray< int >, TermCriteria, int, KmeansFlags)>, "org.opencv.core.kmeans3D")
 
 cv::gapi::core::G_TYPED_KERNEL (GKMeansND,< std::tuple< GOpaque< double >, GMat, GMat >(GMat, int, GMat, TermCriteria, int, KmeansFlags)>, "org.opencv.core.kmeansND")
 
 cv::gapi::core::G_TYPED_KERNEL (GKMeansNDNoInit,< std::tuple< GOpaque< double >, GMat, GMat >(GMat, int, TermCriteria, int, KmeansFlags)>, "org.opencv.core.kmeansNDNoInit")
 
 cv::gapi::core::G_TYPED_KERNEL (GLUT,< GMat(GMat, Mat)>, "org.opencv.core.transform.LUT")
 
 cv::gapi::core::G_TYPED_KERNEL (GMask,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.mask")
 
 cv::gapi::core::G_TYPED_KERNEL (GMax,< GMat(GMat, GMat)>, "org.opencv.core.matrixop.max")
 
 cv::gapi::core::G_TYPED_KERNEL (GMean,< GScalar(GMat)>, "org.opencv.core.math.mean")
 
 cv::gapi::core::G_TYPED_KERNEL (GMerge3,< GMat(GMat, GMat, GMat)>, "org.opencv.core.transform.merge3")
 
 cv::gapi::core::G_TYPED_KERNEL (GMerge4,< GMat(GMat, GMat, GMat, GMat)>, "org.opencv.core.transform.merge4")
 
 cv::gapi::core::G_TYPED_KERNEL (GMin,< GMat(GMat, GMat)>, "org.opencv.core.matrixop.min")
 
 cv::gapi::core::G_TYPED_KERNEL (GMul,< GMat(GMat, GMat, double, int)>, "org.opencv.core.math.mul")
 
 cv::gapi::core::G_TYPED_KERNEL (GMulC,< GMat(GMat, GScalar, int)>, "org.opencv.core.math.mulC")
 
 cv::gapi::core::G_TYPED_KERNEL (GMulCOld,< GMat(GMat, double, int)>, "org.opencv.core.math.mulCOld")
 
 cv::gapi::core::G_TYPED_KERNEL (GMulS,< GMat(GMat, GScalar)>, "org.opencv.core.math.muls")
 
 cv::gapi::core::G_TYPED_KERNEL (GNormalize,< GMat(GMat, double, double, int, int)>, "org.opencv.core.normalize")
 
 cv::gapi::core::G_TYPED_KERNEL (GNormInf,< GScalar(GMat)>, "org.opencv.core.matrixop.norminf")
 
 cv::gapi::core::G_TYPED_KERNEL (GNormL1,< GScalar(GMat)>, "org.opencv.core.matrixop.norml1")
 
 cv::gapi::core::G_TYPED_KERNEL (GNormL2,< GScalar(GMat)>, "org.opencv.core.matrixop.norml2")
 
 cv::gapi::core::G_TYPED_KERNEL (GNot,< GMat(GMat)>, "org.opencv.core.pixelwise.bitwise_not")
 
 cv::gapi::core::G_TYPED_KERNEL (GOr,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.bitwise_or")
 
 cv::gapi::core::G_TYPED_KERNEL (GOrS,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.bitwise_orS")
 
 cv::gapi::core::G_TYPED_KERNEL (GPhase,< GMat(GMat, GMat, bool)>, "org.opencv.core.math.phase")
 
 cv::gapi::core::G_TYPED_KERNEL (GRemap,< GMat(GMat, Mat, Mat, int, int, Scalar)>, "org.opencv.core.transform.remap")
 
 cv::gapi::core::G_TYPED_KERNEL (GSelect,< GMat(GMat, GMat, GMat)>, "org.opencv.core.pixelwise.select")
 
 cv::gapi::streaming::G_TYPED_KERNEL (GSize,< GOpaque< Size >(GMat)>, "org.opencv.streaming.size")
 
 cv::gapi::streaming::G_TYPED_KERNEL (GSizeMF,< GOpaque< Size >(GFrame)>, "org.opencv.streaming.sizeMF")
 
 cv::gapi::streaming::G_TYPED_KERNEL (GSizeR,< GOpaque< Size >(GOpaque< Rect >)>, "org.opencv.streaming.sizeR")
 
 cv::gapi::core::G_TYPED_KERNEL (GSqrt,< GMat(GMat)>, "org.opencv.core.math.sqrt")
 
 cv::gapi::core::G_TYPED_KERNEL (GSub,< GMat(GMat, GMat, int)>, "org.opencv.core.math.sub")
 
 cv::gapi::core::G_TYPED_KERNEL (GSubC,< GMat(GMat, GScalar, int)>, "org.opencv.core.math.subC")
 
 cv::gapi::core::G_TYPED_KERNEL (GSubRC,< GMat(GScalar, GMat, int)>, "org.opencv.core.math.subRC")
 
 cv::gapi::core::G_TYPED_KERNEL (GSum,< GScalar(GMat)>, "org.opencv.core.matrixop.sum")
 
 cv::gapi::core::G_TYPED_KERNEL (GThreshold,< GMat(GMat, GScalar, GScalar, int)>, "org.opencv.core.matrixop.threshold")
 
 cv::gapi::core::G_TYPED_KERNEL (GTranspose,< GMat(GMat)>, "org.opencv.core.transpose")
 
 cv::gapi::core::G_TYPED_KERNEL (GWarpAffine,< GMat(GMat, const Mat &, Size, int, int, const cv::Scalar &)>, "org.opencv.core.warpAffine")
 
 cv::gapi::core::G_TYPED_KERNEL (GWarpPerspective,< GMat(GMat, const Mat &, Size, int, int, const cv::Scalar &)>, "org.opencv.core.warpPerspective")
 
 cv::gapi::core::G_TYPED_KERNEL (GXor,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.bitwise_xor")
 
 cv::gapi::core::G_TYPED_KERNEL (GXorS,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.bitwise_xorS")
 
 cv::gapi::core::G_TYPED_KERNEL_M (GCartToPolar,< GMat2(GMat, GMat, bool)>, "org.opencv.core.math.cartToPolar")
 
 cv::gapi::core::G_TYPED_KERNEL_M (GIntegral,< GMat2(GMat, int, int)>, "org.opencv.core.matrixop.integral")
 
 cv::gapi::core::G_TYPED_KERNEL_M (GPolarToCart,< GMat2(GMat, GMat, bool)>, "org.opencv.core.math.polarToCart")
 
 cv::gapi::core::G_TYPED_KERNEL_M (GSplit3,< GMat3(GMat)>, "org.opencv.core.transform.split3")
 
 cv::gapi::core::G_TYPED_KERNEL_M (GSplit4,< GMat4(GMat)>,"org.opencv.core.transform.split4")
 
 cv::gapi::core::G_TYPED_KERNEL_M (GThresholdOT,< GMatScalar(GMat, GScalar, int)>, "org.opencv.core.matrixop.thresholdOT")
 
GMat cv::gapi::inRange (const GMat &src, const GScalar &threshLow, const GScalar &threshUp)
 Applies a range-level threshold to each matrix element.
 
std::tuple< GMat, GMatcv::gapi::integral (const GMat &src, int sdepth=-1, int sqdepth=-1)
 Calculates the integral of an image.
 
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)
 
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)
 
std::tuple< GOpaque< double >, GMat, GMatcv::gapi::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, GMatcv::gapi::kmeans (const GMat &data, const int K, const TermCriteria &criteria, const int attempts, const KmeansFlags flags)
 
GMat cv::gapi::LUT (const GMat &src, const Mat &lut)
 Performs a look-up table transform of a matrix.
 
GMat cv::gapi::mask (const GMat &src, const GMat &mask)
 Applies a mask to a matrix.
 
GMat cv::gapi::max (const GMat &src1, const GMat &src2)
 Calculates per-element maximum of two matrices.
 
GScalar cv::gapi::mean (const GMat &src)
 Calculates an average (mean) of matrix elements.
 
GMat cv::gapi::merge3 (const GMat &src1, const GMat &src2, const GMat &src3)
 Creates one 3-channel matrix out of 3 single-channel ones.
 
GMat cv::gapi::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 cv::gapi::min (const GMat &src1, const GMat &src2)
 Calculates per-element minimum of two matrices.
 
GMat cv::gapi::mul (const GMat &src1, const GMat &src2, double scale=1.0, int ddepth=-1)
 Calculates the per-element scaled product of two matrices.
 
GMat cv::gapi::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 cv::gapi::mulC (const GMat &src, double multiplier, int ddepth=-1)
 Multiplies matrix by scalar.
 
GMat cv::gapi::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.
 
GMat cv::gapi::normalize (const GMat &src, double alpha, double beta, int norm_type, int ddepth=-1)
 Normalizes the norm or value range of an array.
 
GScalar cv::gapi::normInf (const GMat &src)
 Calculates the absolute infinite norm of a matrix.
 
GScalar cv::gapi::normL1 (const GMat &src)
 Calculates the absolute L1 norm of a matrix.
 
GScalar cv::gapi::normL2 (const GMat &src)
 Calculates the absolute L2 norm of a matrix.
 
GMat cv::gapi::phase (const GMat &x, const GMat &y, bool angleInDegrees=false)
 Calculates the rotation angle of 2D vectors.
 
std::tuple< GMat, GMatcv::gapi::polarToCart (const GMat &magnitude, const GMat &angle, bool angleInDegrees=false)
 Calculates x and y coordinates of 2D vectors from their magnitude and angle.
 
GMat cv::gapi::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 cv::gapi::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).
 
GOpaque< Sizecv::gapi::streaming::size (const GFrame &src)
 Gets dimensions from MediaFrame.
 
GOpaque< Sizecv::gapi::streaming::size (const GMat &src)
 Gets dimensions from Mat.
 
GOpaque< Sizecv::gapi::streaming::size (const GOpaque< Rect > &r)
 
std::tuple< GMat, GMat, GMatcv::gapi::split3 (const GMat &src)
 Divides a 3-channel matrix into 3 single-channel matrices.
 
std::tuple< GMat, GMat, GMat, GMatcv::gapi::split4 (const GMat &src)
 Divides a 4-channel matrix into 4 single-channel matrices.
 
GMat cv::gapi::sqrt (const GMat &src)
 Calculates a square root of array elements.
 
GMat cv::gapi::sub (const GMat &src1, const GMat &src2, int ddepth=-1)
 Calculates the per-element difference between two matrices.
 
GMat cv::gapi::subC (const GMat &src, const GScalar &c, int ddepth=-1)
 Calculates the per-element difference between matrix and given scalar.
 
GMat cv::gapi::subRC (const GScalar &c, const GMat &src, int ddepth=-1)
 Calculates the per-element difference between given scalar and the matrix.
 
GScalar cv::gapi::sum (const GMat &src)
 Calculates sum of all matrix elements.
 
std::tuple< GMat, GScalarcv::gapi::threshold (const GMat &src, const GScalar &maxval, int type)
 
GMat cv::gapi::threshold (const GMat &src, const GScalar &thresh, const GScalar &maxval, int type)
 Applies a fixed-level threshold to each matrix element.
 
GMat cv::gapi::transpose (const GMat &src)
 Transposes a matrix.
 
GMat cv::gapi::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 cv::gapi::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.