OpenCV  4.10.0
开源计算机视觉
加载中...
搜索中...
无匹配
命名空间 | 类型定义 | 函数
core.hpp 文件参考
#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>
包含 core.hpp 的依赖图

命名空间

命名空间  cv
 硬盘上与文件关联的文件存储“黑盒”表示。
 
命名空间  cv::gapi
 
命名空间  cv::gapi::core
 此命名空间包含 OpenCV Core 功能的 G-API 操作类型。
 
命名空间  cv::gapi::streaming
 此命名空间包含与流执行模式相关的 G-API 函数、结构和符号。
 

类型定义

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

函数

GMat cv::gapi::absDiff (const GMat &src1, const GMat &src2)
 计算两个矩阵中每个元素的绝对差。
 
GMat cv::gapi::absDiffC (const GMat &src, const GScalar &c)
 计算矩阵元素的绝对值。
 
GMat cv::gapi::add (const GMat &src1, const GMat &src2, int ddepth=-1)
 计算两个矩阵的元素级和。
 
GMat cv::gapi::addC (const GMat &src1, const GScalar &c, int ddepth=-1)
 计算矩阵和给定标量的元素级和。
 
GMat cv::gapi::addC (const GScalar &c, const GMat &src1, int ddepth=-1)
 这是一个提供方便的重载成员函数。它与上述函数的区别仅在于它接受的参数。
 
GMat cv::gapi::addWeighted (const GMat &src1, double alpha, const GMat &src2, double beta, double gamma, int ddepth=-1)
 计算两个矩阵的加权总和。
 
GMat cv::gapi::bitwise_and (const GMat &src1, const GMat &src2)
 计算两个矩阵 (src1 & src2) 的按位与。计算相同大小的两个矩阵的每个元素按位逻辑与。
 
GMat cv::gapi::bitwise_and (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::bitwise_not (const GMat &src)
 反转数组中的每个位。
 
GMat cv::gapi::bitwise_or (const GMat &src1, const GMat &src2)
 计算两个矩阵 (src1 | src2) 的按位或。计算相同大小的两个矩阵的每个元素按位逻辑或。
 
GMat cv::gapi::bitwise_or (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::bitwise_xor (const GMat &src1, const GMat &src2)
 计算两个矩阵的按位逻辑"异或" (src1 ^ src2)。计算相同大小的两个矩阵的每个元素按位逻辑"异或"。
 
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)
 计算二维向量的幅值和角度。
 
GMat cv::gapi::cmpEQ (const GMat &src1, const GMat &src2)
 执行两个矩阵的每个元素比较,检查第一个矩阵的元素是否等于第二个矩阵中的元素。
 
GMat cv::gapi::cmpEQ (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::cmpGE (const GMat &src1, const GMat &src2)
 执行两个矩阵的每个元素比较,检查第一个矩阵的元素是否大于或等于第二个矩阵中的元素。
 
GMat cv::gapi::cmpGE (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::cmpGT (const GMat &src1, const GMat &src2)
 执行两个矩阵的每个元素比较,检查第一个矩阵的元素是否大于第二个矩阵中的元素。
 
GMat cv::gapi::cmpGT (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::cmpLE (const GMat &src1, const GMat &src2)
 对所有矩阵元素进行逐元素比较,检查第一个矩阵的元素是否小于或等于第二个矩阵的元素。
 
GMat cv::gapi::cmpLE (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::cmpLT (const GMat &src1, const GMat &src2)
 对所有矩阵元素进行逐元素比较,检查第一个矩阵的元素是否小于第二个矩阵的元素。
 
GMat cv::gapi::cmpLT (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::cmpNE (const GMat &src1, const GMat &src2)
 对所有矩阵元素进行逐元素比较,检查第一个矩阵的元素是否不等于第二个矩阵的元素。
 
GMat cv::gapi::cmpNE (const GMat &src1, const GScalar &src2)
 
GMat cv::gapi::concatHor (const GMat &src1, const GMat &src2)
 对给定矩阵应用水平连接。
 
GMat cv::gapi::concatHor (const std::vector< GMat > &v)
 
GMat cv::gapi::concatVert (const GMat &src1, const GMat &src2)
 对给定矩阵应用垂直连接。
 
GMat cv::gapi::concatVert (const std::vector< GMat > &v)
 
GMat cv::gapi::convertTo (const GMat &src, int rdepth, double alpha=1, double beta=0)
 将矩阵转换到另一种数据深度,可选比例缩放。
 
GOpaque< int > cv::gapi::countNonZero (const GMat &src)
 计算非零数组元素的数量。
 
GMat cv::gapi::crop (const GMat &src, const Rect &rect)
 裁剪2D矩阵。
 
GMat cv::gapi::div (const GMat &src1, const GMat &src2, double scale, int ddepth=-1)
 对两个矩阵执行逐元素除法。
 
GMat cv::gapi::divC (const GMat &src, const GScalar &divisor, double scale, int ddepth=-1)
 用矩阵除以标量。
 
GMat cv::gapi::divRC (const GScalar &divident, const GMat &src, double scale, int ddepth=-1)
 用标量除以矩阵。
 
GMat cv::gapi::flip (const GMat &src, int flipCode)
 沿垂直、水平或同时沿两个轴翻转2D矩阵。
 
 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_TYPEDKERNEL: (GAnd,< GMat(GMat, GMat)>, "org.opencv.core.pixelwise.bitwise_and")
 
 cv::gapi::core::G_TYPEDKERNEL: (GAndS,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.bitwise_andS")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpEQ,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpEQ")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpEQScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpEQScalar")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpGE,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpGE")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpGEScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpGEScalar")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpGT,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpGT")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpGTScalar,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpGTScalar")
 
 cv::gapi::core::G_TYPEDKERNEL: (GCmpLE,< GMat(GMat, GScalar)>, "org.opencv.core.pixelwise.compare.cmpLE")
 
 cv::gapi::core::G_TYPEDKERNEL: (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(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, 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, < interviewing GMat(GMat, GMat) >, "org.opencv.core.matrixop.min")
 
 cv::gapi::core::G_TYPED KERNEL (GMul, < interviewing GMat(GMat, GMat, double, int) >, "org.opencv.core.math.mul")
 
 cv::gapi::core::G_TYPED KERNEL (GMulC, < interviewing GMat(GMat, GScalar, int) >, "org.opencv.core.math.mulC")
 
 cv::gapi::core::G_TYPED KERNEL (GMulCOld, < interviewing GMat(GMat, double, int) >, "org.opencv.core.math.mulCOld")
 
 cv::gapi::core::G_TYPED KERNEL (GMulS, < interviewing GMat(GMat, GScalar) >, "org.opencv.core.math.muls")
 
 cv::gapi::core::G_TYPED KERNEL (GNormalize, < interviewing GMat(GMat, double, double, int, int) >, "org.opencv.core.normalize")
 
 cv::gapi::core::G_TYPED KERNEL (GNormInf, < interviewing GScalar(GMat) >, "org.opencv.core.matrixop.norminf")
 
 cv::gapi::core::G_TYPED KERNEL (GNormL1, < interviewing GScalar(GMat) >, "org.opencv.core.matrixop.norml1")
 
 cv::gapi::core::G_TYPED KERNEL (GNormL2, < interviewing GScalar(GMat) >, "org.opencv.core.matrixop.norml2")
 
 cv::gapi::core::G_TYPED KERNEL (GNot, < interviewing GMat(GMat) >, "org.opencv.core.pixelwise.bitwise_not")
 
 cv::gapi::core::G_TYPED KERNEL (GOr, < interviewing GMat(GMat, GMat) >, "org.opencv.core.pixelwise.bitwise_or")
 
 cv::gapi::core::G_TYPED KERNEL (GOrS, < interviewing GMat(GMat, GScalar) >, "org.opencv.core.pixelwise.bitwise_orS")
 
 cv::gapi::core::G_TYPED KERNEL (GPhase, < interviewing GMat(GMat, GMat, bool) >, "org.opencv.core.math.phase")
 
 cv::gapi::core::G_TYPED KERNEL (GRemap, < interviewing GMat(GMat, Mat, Mat, int, int, Scalar) >, "org.opencv.core.transform.remap")
 
 cv::gapi::core::G_TYPED KERNEL (GSelect, < interviewing 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< 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,
 
 cv::gapi::core::G_TYPED KERNEL (GSum,< GScalar(
 
 cv::gapi::core::G_TYPED KERNEL (GThreshold,<
 
 cv::gapi::core::G_TYPED KERNEL (GTranspose,<
 
 cv::gapi::core::G_TYPED KERNEL (GWarpAffine,<
 
 cv::gapi::core::G_TYPED KERNEL (GWarpPerspective,<
 
 cv::gapi::core::G_TYPED KERNEL (GXor,<
 
 cv::gapi::core::G_TYPED KERNEL (GXorS,<
 
 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)
 将阈值范围应用于每个矩阵元素。
 
std::tuple< GMat, GMatcv::gapi::integral (const GMat &src, int sdepth=-1, int sqdepth=-1)
 计算图像的积分。
 
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)
 寻找聚类中心并将输入样本分组到聚类周围。
 
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)
 执行矩阵的查找表转换。
 
GMat cv::gapi::mask (const GMat &src, const GMat &mask)
 将掩码应用于矩阵。
 
GMat cv::gapi::max (const GMat &src1, const GMat &src2)
 计算两矩阵的每个元素的取最大值的操作。
 
GScalar cv::gapi::mean (const GMat &src)
 计算矩阵元素的平均值(均值)。
 
GMat cv::gapi::merge3 (const GMat &src1, const GMat &src2, const GMat &src3)
 从3个单通道矩阵创建一个3通道矩阵。
 
GMat cv::gapi::merge4 (const GMat &src1, const GMat &src2, const GMat &src3, const GMat &src4)
 从4个单通道矩阵创建一个4通道矩阵。
 
GMat cv::gapi::min (const GMat &src1, const GMat &src2)
 计算两矩阵的每个元素的取最小值的操作。
 
GMat cv::gapi::mul (const GMat &src1, const GMat &src2, double scale=1.0, int ddepth=-1)
 计算两矩阵的每个元素的缩放乘积。
 
GMat cv::gapi::mulC (const GMat &src, const GScalar &multiplier, int ddepth=-1)
 这是一个提供方便的重载成员函数。它与上述函数的区别仅在于它接受的参数。
 
GMat cv::gapi::mulC (const GMat &src, double multiplier, int ddepth=-1)
 将矩阵乘以标量。
 
GMat cv::gapi::mulC (const GScalar &multiplier, const GMat &src, int ddepth=-1)
 这是一个提供方便的重载成员函数。它与上述函数的区别仅在于它接受的参数。
 
GMat cv::gapi::normalize (const GMat &src, double alpha, double beta, int norm_type, int ddepth=-1)
 归一化数组的标准或值范围。
 
GScalar cv::gapi::normInf (const GMat &src)
 计算矩阵的绝对无限范数。
 
GScalar cv::gapi::normL1 (const GMat &src)
 计算矩阵的绝对L1范数。
 
GScalar cv::gapi::normL2 (const GMat &src)
 计算矩阵的绝对L2范数。
 
GMat cv::gapi::phase (const GMat &x, const GMat &y, bool angleInDegrees=false)
 计算2D向量的旋转角度。
 
std::tuple< GMat, GMatcv::gapi::polarToCart (const magnitude, const GMat &angle, bool angleInDegrees=false)
 根据向量的大小和角度计算2D向量的x和y坐标。
 
GMat cv::gapi::remap (const GMat &src, const Mat &map1, const Mat &map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar &borderValue=Scalar())
 对一个图像应用通用的几何变换。
 
GMat cv::gapi::select (const GMat &src1, const GMat &src2, const GMat &mask)
 根据给定的掩码从输入矩阵的第一个或第二个中选择值。如果掩码矩阵的对应值是255,则将输出矩阵设置为第一个输入矩阵的值,如果掩码矩阵的值设置为0,则设置为第二个输入矩阵的值。
 
GOpaque< Sizecv::gapi::streaming::size (const GFrame &src)
 从MediaFrame中获取尺寸。
 
GOpaque< Sizecv::gapi::streaming::size (const GMat &src)
 从Mat中获取尺寸。
 
GOpaque< Sizecv::gapi::streaming::size (const GOpaque< Rect > &r)
 
std::tuple< GMat, GMat, GMatcv::gapi::split3 (const GMat &src)
 将3通道矩阵分割为3个单通道矩阵。
 
std::tuple< GMat, GMat, GMat, GMatcv::gapi::split4 (const GMat &src)
 将4通道矩阵分割为4个单通道矩阵。
 
GMat cv::gapi::sqrt (const GMat &src)
 计算数组元素的平方根。
 
GMat cv::gapi::sub (const GMat &src1, const GMat &src2, int ddepth=-1)
 计算两个矩阵每个元素的差值。
 
GMat cv::gapi::subC (const GMat &src, const GScalar &c, int ddepth=-1)
 计算矩阵与给定标量的每个元素差值。
 
GMat cv::gapi::subRC (const GScalar &c, const GMat &src, int ddepth=-1)
 计算给定标量与矩阵的每个元素差值。
 
GScalar cv::gapi::sum (const GMat &src)
 计算矩阵所有元素的总和。
 
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)
 对每个矩阵元素应用固定级别阈值。
 
GMat cv::gapi::transpose (const GMat &src)
 转置矩阵。
 
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())
 对图像应用仿射变换。
 
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())
 对图像应用透视变换。