You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1683 lines
74 KiB
C++
1683 lines
74 KiB
C++
// This file is part of OpenCV project.
|
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
|
// of this distribution and at http://opencv.org/license.html.
|
|
//
|
|
// Copyright (C) 2018-2020 Intel Corporation
|
|
|
|
|
|
#ifndef OPENCV_GAPI_IMGPROC_HPP
|
|
#define OPENCV_GAPI_IMGPROC_HPP
|
|
|
|
#include <opencv2/imgproc.hpp>
|
|
|
|
#include <utility> // std::tuple
|
|
|
|
#include <opencv2/gapi/gkernel.hpp>
|
|
#include <opencv2/gapi/gmat.hpp>
|
|
#include <opencv2/gapi/gscalar.hpp>
|
|
|
|
|
|
/** \defgroup gapi_imgproc G-API Image processing functionality
|
|
@{
|
|
@defgroup gapi_filters Graph API: Image filters
|
|
@defgroup gapi_colorconvert Graph API: Converting image from one color space to another
|
|
@defgroup gapi_feature Graph API: Image Feature Detection
|
|
@defgroup gapi_shape Graph API: Image Structural Analysis and Shape Descriptors
|
|
@}
|
|
*/
|
|
|
|
namespace {
|
|
void validateFindingContoursMeta(const int depth, const int chan, const int mode)
|
|
{
|
|
GAPI_Assert(chan == 1);
|
|
switch (mode)
|
|
{
|
|
case cv::RETR_CCOMP:
|
|
GAPI_Assert(depth == CV_8U || depth == CV_32S);
|
|
break;
|
|
case cv::RETR_FLOODFILL:
|
|
GAPI_Assert(depth == CV_32S);
|
|
break;
|
|
default:
|
|
GAPI_Assert(depth == CV_8U);
|
|
break;
|
|
}
|
|
}
|
|
} // anonymous namespace
|
|
|
|
namespace cv { namespace gapi {
|
|
|
|
/**
|
|
* @brief This namespace contains G-API Operation Types for OpenCV
|
|
* ImgProc module functionality.
|
|
*/
|
|
namespace imgproc {
|
|
using GMat2 = std::tuple<GMat,GMat>;
|
|
using GMat3 = std::tuple<GMat,GMat,GMat>; // FIXME: how to avoid this?
|
|
using GFindContoursOutput = std::tuple<GArray<GArray<Point>>,GArray<Vec4i>>;
|
|
|
|
G_TYPED_KERNEL(GFilter2D, <GMat(GMat,int,Mat,Point,Scalar,int,Scalar)>,"org.opencv.imgproc.filters.filter2D") {
|
|
static GMatDesc outMeta(GMatDesc in, int ddepth, Mat, Point, Scalar, int, Scalar) {
|
|
return in.withDepth(ddepth);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GSepFilter, <GMat(GMat,int,Mat,Mat,Point,Scalar,int,Scalar)>, "org.opencv.imgproc.filters.sepfilter") {
|
|
static GMatDesc outMeta(GMatDesc in, int ddepth, Mat, Mat, Point, Scalar, int, Scalar) {
|
|
return in.withDepth(ddepth);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBoxFilter, <GMat(GMat,int,Size,Point,bool,int,Scalar)>, "org.opencv.imgproc.filters.boxfilter") {
|
|
static GMatDesc outMeta(GMatDesc in, int ddepth, Size, Point, bool, int, Scalar) {
|
|
return in.withDepth(ddepth);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBlur, <GMat(GMat,Size,Point,int,Scalar)>, "org.opencv.imgproc.filters.blur"){
|
|
static GMatDesc outMeta(GMatDesc in, Size, Point, int, Scalar) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GGaussBlur, <GMat(GMat,Size,double,double,int,Scalar)>, "org.opencv.imgproc.filters.gaussianBlur") {
|
|
static GMatDesc outMeta(GMatDesc in, Size, double, double, int, Scalar) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GMedianBlur, <GMat(GMat,int)>, "org.opencv.imgproc.filters.medianBlur") {
|
|
static GMatDesc outMeta(GMatDesc in, int) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GErode, <GMat(GMat,Mat,Point,int,int,Scalar)>, "org.opencv.imgproc.filters.erode") {
|
|
static GMatDesc outMeta(GMatDesc in, Mat, Point, int, int, Scalar) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GDilate, <GMat(GMat,Mat,Point,int,int,Scalar)>, "org.opencv.imgproc.filters.dilate") {
|
|
static GMatDesc outMeta(GMatDesc in, Mat, Point, int, int, Scalar) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GMorphologyEx, <GMat(GMat,MorphTypes,Mat,Point,int,BorderTypes,Scalar)>,
|
|
"org.opencv.imgproc.filters.morphologyEx") {
|
|
static GMatDesc outMeta(const GMatDesc &in, MorphTypes, Mat, Point, int,
|
|
BorderTypes, Scalar) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GSobel, <GMat(GMat,int,int,int,int,double,double,int,Scalar)>, "org.opencv.imgproc.filters.sobel") {
|
|
static GMatDesc outMeta(GMatDesc in, int ddepth, int, int, int, double, double, int, Scalar) {
|
|
return in.withDepth(ddepth);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL_M(GSobelXY, <GMat2(GMat,int,int,int,double,double,int,Scalar)>, "org.opencv.imgproc.filters.sobelxy") {
|
|
static std::tuple<GMatDesc, GMatDesc> outMeta(GMatDesc in, int ddepth, int, int, double, double, int, Scalar) {
|
|
return std::make_tuple(in.withDepth(ddepth), in.withDepth(ddepth));
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GLaplacian, <GMat(GMat,int, int, double, double, int)>,
|
|
"org.opencv.imgproc.filters.laplacian") {
|
|
static GMatDesc outMeta(GMatDesc in, int ddepth, int, double, double, int) {
|
|
return in.withDepth(ddepth);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBilateralFilter, <GMat(GMat,int, double, double, int)>,
|
|
"org.opencv.imgproc.filters.bilateralfilter") {
|
|
static GMatDesc outMeta(GMatDesc in, int, double, double, int) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GEqHist, <GMat(GMat)>, "org.opencv.imgproc.equalizeHist"){
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in.withType(CV_8U, 1);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCanny, <GMat(GMat,double,double,int,bool)>, "org.opencv.imgproc.feature.canny"){
|
|
static GMatDesc outMeta(GMatDesc in, double, double, int, bool) {
|
|
return in.withType(CV_8U, 1);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GGoodFeatures,
|
|
<cv::GArray<cv::Point2f>(GMat,int,double,double,Mat,int,bool,double)>,
|
|
"org.opencv.imgproc.feature.goodFeaturesToTrack") {
|
|
static GArrayDesc outMeta(GMatDesc, int, double, double, const Mat&, int, bool, double) {
|
|
return empty_array_desc();
|
|
}
|
|
};
|
|
|
|
using RetrMode = RetrievalModes;
|
|
using ContMethod = ContourApproximationModes;
|
|
G_TYPED_KERNEL(GFindContours, <GArray<GArray<Point>>(GMat,RetrMode,ContMethod,GOpaque<Point>)>,
|
|
"org.opencv.imgproc.shape.findContours")
|
|
{
|
|
static GArrayDesc outMeta(GMatDesc in, RetrMode mode, ContMethod, GOpaqueDesc)
|
|
{
|
|
validateFindingContoursMeta(in.depth, in.chan, mode);
|
|
return empty_array_desc();
|
|
}
|
|
};
|
|
|
|
// FIXME oc: make default value offset = Point()
|
|
G_TYPED_KERNEL(GFindContoursNoOffset, <GArray<GArray<Point>>(GMat,RetrMode,ContMethod)>,
|
|
"org.opencv.imgproc.shape.findContoursNoOffset")
|
|
{
|
|
static GArrayDesc outMeta(GMatDesc in, RetrMode mode, ContMethod)
|
|
{
|
|
validateFindingContoursMeta(in.depth, in.chan, mode);
|
|
return empty_array_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFindContoursH,<GFindContoursOutput(GMat,RetrMode,ContMethod,GOpaque<Point>)>,
|
|
"org.opencv.imgproc.shape.findContoursH")
|
|
{
|
|
static std::tuple<GArrayDesc,GArrayDesc>
|
|
outMeta(GMatDesc in, RetrMode mode, ContMethod, GOpaqueDesc)
|
|
{
|
|
validateFindingContoursMeta(in.depth, in.chan, mode);
|
|
return std::make_tuple(empty_array_desc(), empty_array_desc());
|
|
}
|
|
};
|
|
|
|
// FIXME oc: make default value offset = Point()
|
|
G_TYPED_KERNEL(GFindContoursHNoOffset,<GFindContoursOutput(GMat,RetrMode,ContMethod)>,
|
|
"org.opencv.imgproc.shape.findContoursHNoOffset")
|
|
{
|
|
static std::tuple<GArrayDesc,GArrayDesc>
|
|
outMeta(GMatDesc in, RetrMode mode, ContMethod)
|
|
{
|
|
validateFindingContoursMeta(in.depth, in.chan, mode);
|
|
return std::make_tuple(empty_array_desc(), empty_array_desc());
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBoundingRectMat, <GOpaque<Rect>(GMat)>,
|
|
"org.opencv.imgproc.shape.boundingRectMat") {
|
|
static GOpaqueDesc outMeta(GMatDesc in) {
|
|
if (in.depth == CV_8U)
|
|
{
|
|
GAPI_Assert(in.chan == 1);
|
|
}
|
|
else
|
|
{
|
|
GAPI_Assert (in.depth == CV_32S || in.depth == CV_32F);
|
|
int amount = detail::checkVector(in, 2u);
|
|
GAPI_Assert(amount != -1 &&
|
|
"Input Mat can't be described as vector of 2-dimentional points");
|
|
}
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBoundingRectVector32S, <GOpaque<Rect>(GArray<Point2i>)>,
|
|
"org.opencv.imgproc.shape.boundingRectVector32S") {
|
|
static GOpaqueDesc outMeta(GArrayDesc) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBoundingRectVector32F, <GOpaque<Rect>(GArray<Point2f>)>,
|
|
"org.opencv.imgproc.shape.boundingRectVector32F") {
|
|
static GOpaqueDesc outMeta(GArrayDesc) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine2DMat, <GOpaque<Vec4f>(GMat,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine2DMat") {
|
|
static GOpaqueDesc outMeta(GMatDesc in,DistanceTypes,double,double,double) {
|
|
int amount = detail::checkVector(in, 2u);
|
|
GAPI_Assert(amount != -1 &&
|
|
"Input Mat can't be described as vector of 2-dimentional points");
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine2DVector32S,
|
|
<GOpaque<Vec4f>(GArray<Point2i>,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine2DVector32S") {
|
|
static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine2DVector32F,
|
|
<GOpaque<Vec4f>(GArray<Point2f>,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine2DVector32F") {
|
|
static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine2DVector64F,
|
|
<GOpaque<Vec4f>(GArray<Point2d>,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine2DVector64F") {
|
|
static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine3DMat, <GOpaque<Vec6f>(GMat,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine3DMat") {
|
|
static GOpaqueDesc outMeta(GMatDesc in,int,double,double,double) {
|
|
int amount = detail::checkVector(in, 3u);
|
|
GAPI_Assert(amount != -1 &&
|
|
"Input Mat can't be described as vector of 3-dimentional points");
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine3DVector32S,
|
|
<GOpaque<Vec6f>(GArray<Point3i>,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine3DVector32S") {
|
|
static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine3DVector32F,
|
|
<GOpaque<Vec6f>(GArray<Point3f>,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine3DVector32F") {
|
|
static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GFitLine3DVector64F,
|
|
<GOpaque<Vec6f>(GArray<Point3d>,DistanceTypes,double,double,double)>,
|
|
"org.opencv.imgproc.shape.fitLine3DVector64F") {
|
|
static GOpaqueDesc outMeta(GArrayDesc,DistanceTypes,double,double,double) {
|
|
return empty_gopaque_desc();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBGR2RGB, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.bgr2rgb") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2YUV, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.rgb2yuv") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GYUV2RGB, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.yuv2rgb") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBGR2I420, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.bgr2i420") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
GAPI_Assert(in.depth == CV_8U);
|
|
GAPI_Assert(in.chan == 3);
|
|
GAPI_Assert(in.size.height % 2 == 0);
|
|
return in.withType(in.depth, 1).withSize(Size(in.size.width, in.size.height * 3 / 2));
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2I420, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.rgb2i420") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
GAPI_Assert(in.depth == CV_8U);
|
|
GAPI_Assert(in.chan == 3);
|
|
GAPI_Assert(in.size.height % 2 == 0);
|
|
return in.withType(in.depth, 1).withSize(Size(in.size.width, in.size.height * 3 / 2));
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GI4202BGR, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.i4202bgr") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
GAPI_Assert(in.depth == CV_8U);
|
|
GAPI_Assert(in.chan == 1);
|
|
GAPI_Assert(in.size.height % 3 == 0);
|
|
return in.withType(in.depth, 3).withSize(Size(in.size.width, in.size.height * 2 / 3));
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GI4202RGB, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.i4202rgb") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
GAPI_Assert(in.depth == CV_8U);
|
|
GAPI_Assert(in.chan == 1);
|
|
GAPI_Assert(in.size.height % 3 == 0);
|
|
return in.withType(in.depth, 3).withSize(Size(in.size.width, in.size.height * 2 / 3));
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GNV12toRGB, <GMat(GMat, GMat)>, "org.opencv.imgproc.colorconvert.nv12torgb") {
|
|
static GMatDesc outMeta(GMatDesc in_y, GMatDesc in_uv) {
|
|
GAPI_Assert(in_y.chan == 1);
|
|
GAPI_Assert(in_uv.chan == 2);
|
|
GAPI_Assert(in_y.depth == CV_8U);
|
|
GAPI_Assert(in_uv.depth == CV_8U);
|
|
// UV size should be aligned with Y
|
|
GAPI_Assert(in_y.size.width == 2 * in_uv.size.width);
|
|
GAPI_Assert(in_y.size.height == 2 * in_uv.size.height);
|
|
return in_y.withType(CV_8U, 3); // type will be CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GNV12toBGR, <GMat(GMat, GMat)>, "org.opencv.imgproc.colorconvert.nv12tobgr") {
|
|
static GMatDesc outMeta(GMatDesc in_y, GMatDesc in_uv) {
|
|
GAPI_Assert(in_y.chan == 1);
|
|
GAPI_Assert(in_uv.chan == 2);
|
|
GAPI_Assert(in_y.depth == CV_8U);
|
|
GAPI_Assert(in_uv.depth == CV_8U);
|
|
// UV size should be aligned with Y
|
|
GAPI_Assert(in_y.size.width == 2 * in_uv.size.width);
|
|
GAPI_Assert(in_y.size.height == 2 * in_uv.size.height);
|
|
return in_y.withType(CV_8U, 3); // type will be CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2Lab, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.rgb2lab") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBGR2LUV, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.bgr2luv") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GLUV2BGR, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.luv2bgr") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GYUV2BGR, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.yuv2bgr") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBGR2YUV, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.bgr2yuv") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in; // type still remains CV_8UC3;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2Gray, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.rgb2gray") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in.withType(CV_8U, 1);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2GrayCustom, <GMat(GMat,float,float,float)>, "org.opencv.imgproc.colorconvert.rgb2graycustom") {
|
|
static GMatDesc outMeta(GMatDesc in, float, float, float) {
|
|
return in.withType(CV_8U, 1);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBGR2Gray, <GMat(GMat)>, "org.opencv.imgproc.colorconvert.bgr2gray") {
|
|
static GMatDesc outMeta(GMatDesc in) {
|
|
return in.withType(CV_8U, 1);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GBayerGR2RGB, <cv::GMat(cv::GMat)>, "org.opencv.imgproc.colorconvert.bayergr2rgb") {
|
|
static cv::GMatDesc outMeta(cv::GMatDesc in) {
|
|
return in.withType(CV_8U, 3);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2HSV, <cv::GMat(cv::GMat)>, "org.opencv.imgproc.colorconvert.rgb2hsv") {
|
|
static cv::GMatDesc outMeta(cv::GMatDesc in) {
|
|
return in;
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GRGB2YUV422, <cv::GMat(cv::GMat)>, "org.opencv.imgproc.colorconvert.rgb2yuv422") {
|
|
static cv::GMatDesc outMeta(cv::GMatDesc in) {
|
|
GAPI_Assert(in.depth == CV_8U);
|
|
GAPI_Assert(in.chan == 3);
|
|
return in.withType(in.depth, 2);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GNV12toRGBp, <GMatP(GMat,GMat)>, "org.opencv.imgproc.colorconvert.nv12torgbp") {
|
|
static GMatDesc outMeta(GMatDesc inY, GMatDesc inUV) {
|
|
GAPI_Assert(inY.depth == CV_8U);
|
|
GAPI_Assert(inUV.depth == CV_8U);
|
|
GAPI_Assert(inY.chan == 1);
|
|
GAPI_Assert(inY.planar == false);
|
|
GAPI_Assert(inUV.chan == 2);
|
|
GAPI_Assert(inUV.planar == false);
|
|
GAPI_Assert(inY.size.width == 2 * inUV.size.width);
|
|
GAPI_Assert(inY.size.height == 2 * inUV.size.height);
|
|
return inY.withType(CV_8U, 3).asPlanar();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GNV12toGray, <GMat(GMat,GMat)>, "org.opencv.imgproc.colorconvert.nv12togray") {
|
|
static GMatDesc outMeta(GMatDesc inY, GMatDesc inUV) {
|
|
GAPI_Assert(inY.depth == CV_8U);
|
|
GAPI_Assert(inUV.depth == CV_8U);
|
|
GAPI_Assert(inY.chan == 1);
|
|
GAPI_Assert(inY.planar == false);
|
|
GAPI_Assert(inUV.chan == 2);
|
|
GAPI_Assert(inUV.planar == false);
|
|
|
|
GAPI_Assert(inY.size.width == 2 * inUV.size.width);
|
|
GAPI_Assert(inY.size.height == 2 * inUV.size.height);
|
|
return inY.withType(CV_8U, 1);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GNV12toBGRp, <GMatP(GMat,GMat)>, "org.opencv.imgproc.colorconvert.nv12tobgrp") {
|
|
static GMatDesc outMeta(GMatDesc inY, GMatDesc inUV) {
|
|
GAPI_Assert(inY.depth == CV_8U);
|
|
GAPI_Assert(inUV.depth == CV_8U);
|
|
GAPI_Assert(inY.chan == 1);
|
|
GAPI_Assert(inY.planar == false);
|
|
GAPI_Assert(inUV.chan == 2);
|
|
GAPI_Assert(inUV.planar == false);
|
|
GAPI_Assert(inY.size.width == 2 * inUV.size.width);
|
|
GAPI_Assert(inY.size.height == 2 * inUV.size.height);
|
|
return inY.withType(CV_8U, 3).asPlanar();
|
|
}
|
|
};
|
|
|
|
} //namespace imgproc
|
|
|
|
//! @addtogroup gapi_filters
|
|
//! @{
|
|
/** @brief Applies a separable linear filter to a matrix(image).
|
|
|
|
The function applies a separable linear filter to the matrix. That is, first, every row of src is
|
|
filtered with the 1D kernel kernelX. Then, every column of the result is filtered with the 1D
|
|
kernel kernelY. The final result is returned.
|
|
|
|
Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- In case of floating-point computation, rounding to nearest even is procedeed
|
|
if hardware supports it (if not - to nearest value).
|
|
- Function textual ID is "org.opencv.imgproc.filters.sepfilter"
|
|
@param src Source image.
|
|
@param ddepth desired depth of the destination image (the following combinations of src.depth() and ddepth are supported:
|
|
|
|
src.depth() = CV_8U, ddepth = -1/CV_16S/CV_32F/CV_64F
|
|
src.depth() = CV_16U/CV_16S, ddepth = -1/CV_32F/CV_64F
|
|
src.depth() = CV_32F, ddepth = -1/CV_32F/CV_64F
|
|
src.depth() = CV_64F, ddepth = -1/CV_64F
|
|
|
|
when ddepth=-1, the output image will have the same depth as the source)
|
|
@param kernelX Coefficients for filtering each row.
|
|
@param kernelY Coefficients for filtering each column.
|
|
@param anchor Anchor position within the kernel. The default value \f$(-1,-1)\f$ means that the anchor
|
|
is at the kernel center.
|
|
@param delta Value added to the filtered results before storing them.
|
|
@param borderType Pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa boxFilter, gaussianBlur, medianBlur
|
|
*/
|
|
GAPI_EXPORTS GMat sepFilter(const GMat& src, int ddepth, const Mat& kernelX, const Mat& kernelY, const Point& anchor /*FIXME: = Point(-1,-1)*/,
|
|
const Scalar& delta /*FIXME = GScalar(0)*/, int borderType = BORDER_DEFAULT,
|
|
const Scalar& borderValue = Scalar(0));
|
|
|
|
/** @brief Convolves an image with the kernel.
|
|
|
|
The function applies an arbitrary linear filter to an image. When
|
|
the aperture is partially outside the image, the function interpolates outlier pixel values
|
|
according to the specified border mode.
|
|
|
|
The function does actually compute correlation, not the convolution:
|
|
|
|
\f[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\f]
|
|
|
|
That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip
|
|
the kernel using flip and set the new anchor to `(kernel.cols - anchor.x - 1, kernel.rows -
|
|
anchor.y - 1)`.
|
|
|
|
Supported matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1.
|
|
Output image must have the same size and number of channels an input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.filter2D"
|
|
|
|
@param src input image.
|
|
@param ddepth desired depth of the destination image
|
|
@param kernel convolution kernel (or rather a correlation kernel), a single-channel floating point
|
|
matrix; if you want to apply different kernels to different channels, split the image into
|
|
separate color planes using split and process them individually.
|
|
@param anchor anchor of the kernel that indicates the relative position of a filtered point within
|
|
the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor
|
|
is at the kernel center.
|
|
@param delta optional value added to the filtered pixels before storing them in dst.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa sepFilter
|
|
*/
|
|
GAPI_EXPORTS GMat filter2D(const GMat& src, int ddepth, const Mat& kernel, const Point& anchor = Point(-1,-1), const Scalar& delta = Scalar(0),
|
|
int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0));
|
|
|
|
|
|
/** @brief Blurs an image using the box filter.
|
|
|
|
The function smooths an image using the kernel:
|
|
|
|
\f[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\f]
|
|
|
|
where
|
|
|
|
\f[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise} \end{cases}\f]
|
|
|
|
Unnormalized box filter is useful for computing various integral characteristics over each pixel
|
|
neighborhood, such as covariance matrices of image derivatives (used in dense optical flow
|
|
algorithms, and so on). If you need to compute pixel sums over variable-size windows, use cv::integral.
|
|
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.boxfilter"
|
|
|
|
@param src Source image.
|
|
@param dtype the output image depth (-1 to set the input image data type).
|
|
@param ksize blurring kernel size.
|
|
@param anchor Anchor position within the kernel. The default value \f$(-1,-1)\f$ means that the anchor
|
|
is at the kernel center.
|
|
@param normalize flag, specifying whether the kernel is normalized by its area or not.
|
|
@param borderType Pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa sepFilter, gaussianBlur, medianBlur, integral
|
|
*/
|
|
GAPI_EXPORTS GMat boxFilter(const GMat& src, int dtype, const Size& ksize, const Point& anchor = Point(-1,-1),
|
|
bool normalize = true, int borderType = BORDER_DEFAULT,
|
|
const Scalar& borderValue = Scalar(0));
|
|
|
|
/** @brief Blurs an image using the normalized box filter.
|
|
|
|
The function smooths an image using the kernel:
|
|
|
|
\f[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\f]
|
|
|
|
The call `blur(src, ksize, anchor, borderType)` is equivalent to `boxFilter(src, src.type(), ksize, anchor,
|
|
true, borderType)`.
|
|
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.blur"
|
|
|
|
@param src Source image.
|
|
@param ksize blurring kernel size.
|
|
@param anchor anchor point; default value Point(-1,-1) means that the anchor is at the kernel
|
|
center.
|
|
@param borderType border mode used to extrapolate pixels outside of the image, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa boxFilter, bilateralFilter, GaussianBlur, medianBlur
|
|
*/
|
|
GAPI_EXPORTS GMat blur(const GMat& src, const Size& ksize, const Point& anchor = Point(-1,-1),
|
|
int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0));
|
|
|
|
|
|
//GAPI_EXPORTS_W void blur( InputArray src, OutputArray dst,
|
|
// Size ksize, Point anchor = Point(-1,-1),
|
|
// int borderType = BORDER_DEFAULT );
|
|
|
|
|
|
/** @brief Blurs an image using a Gaussian filter.
|
|
|
|
The function filter2Ds the source image with the specified Gaussian kernel.
|
|
Output image must have the same type and number of channels an input image.
|
|
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.gaussianBlur"
|
|
|
|
@param src input image;
|
|
@param ksize Gaussian kernel size. ksize.width and ksize.height can differ but they both must be
|
|
positive and odd. Or, they can be zero's and then they are computed from sigma.
|
|
@param sigmaX Gaussian kernel standard deviation in X direction.
|
|
@param sigmaY Gaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be
|
|
equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height,
|
|
respectively (see cv::getGaussianKernel for details); to fully control the result regardless of
|
|
possible future modifications of all this semantics, it is recommended to specify all of ksize,
|
|
sigmaX, and sigmaY.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa sepFilter, boxFilter, medianBlur
|
|
*/
|
|
GAPI_EXPORTS GMat gaussianBlur(const GMat& src, const Size& ksize, double sigmaX, double sigmaY = 0,
|
|
int borderType = BORDER_DEFAULT, const Scalar& borderValue = Scalar(0));
|
|
|
|
/** @brief Blurs an image using the median filter.
|
|
|
|
The function smoothes an image using the median filter with the \f$\texttt{ksize} \times
|
|
\texttt{ksize}\f$ aperture. Each channel of a multi-channel image is processed independently.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
The median filter uses cv::BORDER_REPLICATE internally to cope with border pixels, see cv::BorderTypes
|
|
- Function textual ID is "org.opencv.imgproc.filters.medianBlur"
|
|
|
|
@param src input matrix (image)
|
|
@param ksize aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ...
|
|
@sa boxFilter, gaussianBlur
|
|
*/
|
|
GAPI_EXPORTS_W GMat medianBlur(const GMat& src, int ksize);
|
|
|
|
/** @brief Erodes an image by using a specific structuring element.
|
|
|
|
The function erodes the source image using the specified structuring element that determines the
|
|
shape of a pixel neighborhood over which the minimum is taken:
|
|
|
|
\f[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
|
|
|
|
Erosion can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently.
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.erode"
|
|
|
|
@param src input image
|
|
@param kernel structuring element used for erosion; if `element=Mat()`, a `3 x 3` rectangular
|
|
structuring element is used. Kernel can be created using getStructuringElement.
|
|
@param anchor position of the anchor within the element; default value (-1, -1) means that the
|
|
anchor is at the element center.
|
|
@param iterations number of times erosion is applied.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of a constant border
|
|
@sa dilate, morphologyEx
|
|
*/
|
|
GAPI_EXPORTS GMat erode(const GMat& src, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1,
|
|
int borderType = BORDER_CONSTANT,
|
|
const Scalar& borderValue = morphologyDefaultBorderValue());
|
|
|
|
/** @brief Erodes an image by using 3 by 3 rectangular structuring element.
|
|
|
|
The function erodes the source image using the rectangular structuring element with rectangle center as an anchor.
|
|
Erosion can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently.
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.erode"
|
|
|
|
@param src input image
|
|
@param iterations number of times erosion is applied.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of a constant border
|
|
@sa erode, dilate3x3
|
|
*/
|
|
GAPI_EXPORTS GMat erode3x3(const GMat& src, int iterations = 1,
|
|
int borderType = BORDER_CONSTANT,
|
|
const Scalar& borderValue = morphologyDefaultBorderValue());
|
|
|
|
/** @brief Dilates an image by using a specific structuring element.
|
|
|
|
The function dilates the source image using the specified structuring element that determines the
|
|
shape of a pixel neighborhood over which the maximum is taken:
|
|
\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
|
|
|
|
Dilation can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently.
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.dilate"
|
|
|
|
@param src input image.
|
|
@param kernel structuring element used for dilation; if elemenat=Mat(), a 3 x 3 rectangular
|
|
structuring element is used. Kernel can be created using getStructuringElement
|
|
@param anchor position of the anchor within the element; default value (-1, -1) means that the
|
|
anchor is at the element center.
|
|
@param iterations number of times dilation is applied.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of a constant border
|
|
@sa erode, morphologyEx, getStructuringElement
|
|
*/
|
|
GAPI_EXPORTS GMat dilate(const GMat& src, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1,
|
|
int borderType = BORDER_CONSTANT,
|
|
const Scalar& borderValue = morphologyDefaultBorderValue());
|
|
|
|
/** @brief Dilates an image by using 3 by 3 rectangular structuring element.
|
|
|
|
The function dilates the source image using the specified structuring element that determines the
|
|
shape of a pixel neighborhood over which the maximum is taken:
|
|
\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f]
|
|
|
|
Dilation can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently.
|
|
Supported input matrix data types are @ref CV_8UC1, @ref CV_8UC3, @ref CV_16UC1, @ref CV_16SC1, and @ref CV_32FC1.
|
|
Output image must have the same type, size, and number of channels as the input image.
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.dilate"
|
|
|
|
@param src input image.
|
|
@param iterations number of times dilation is applied.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of a constant border
|
|
@sa dilate, erode3x3
|
|
*/
|
|
|
|
GAPI_EXPORTS GMat dilate3x3(const GMat& src, int iterations = 1,
|
|
int borderType = BORDER_CONSTANT,
|
|
const Scalar& borderValue = morphologyDefaultBorderValue());
|
|
|
|
/** @brief Performs advanced morphological transformations.
|
|
|
|
The function can perform advanced morphological transformations using an erosion and dilation as
|
|
basic operations.
|
|
|
|
Any of the operations can be done in-place. In case of multi-channel images, each channel is
|
|
processed independently.
|
|
|
|
@note
|
|
- Function textual ID is "org.opencv.imgproc.filters.morphologyEx"
|
|
- The number of iterations is the number of times erosion or dilatation operation will be
|
|
applied. For instance, an opening operation (#MORPH_OPEN) with two iterations is equivalent to
|
|
apply successively: erode -> erode -> dilate -> dilate
|
|
(and not erode -> dilate -> erode -> dilate).
|
|
|
|
@param src Input image.
|
|
@param op Type of a morphological operation, see #MorphTypes
|
|
@param kernel Structuring element. It can be created using #getStructuringElement.
|
|
@param anchor Anchor position within the element. Both negative values mean that the anchor is at
|
|
the kernel center.
|
|
@param iterations Number of times erosion and dilation are applied.
|
|
@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
|
|
@param borderValue Border value in case of a constant border. The default value has a special
|
|
meaning.
|
|
@sa dilate, erode, getStructuringElement
|
|
*/
|
|
GAPI_EXPORTS GMat morphologyEx(const GMat &src, const MorphTypes op, const Mat &kernel,
|
|
const Point &anchor = Point(-1,-1),
|
|
const int iterations = 1,
|
|
const BorderTypes borderType = BORDER_CONSTANT,
|
|
const Scalar &borderValue = morphologyDefaultBorderValue());
|
|
|
|
/** @brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
|
|
|
|
In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$ separable kernel is used to
|
|
calculate the derivative. When \f$\texttt{ksize = 1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$
|
|
kernel is used (that is, no Gaussian smoothing is done). `ksize = 1` can only be used for the first
|
|
or the second x- or y- derivatives.
|
|
|
|
There is also the special value `ksize = FILTER_SCHARR (-1)` that corresponds to the \f$3\times3\f$ Scharr
|
|
filter that may give more accurate results than the \f$3\times3\f$ Sobel. The Scharr aperture is
|
|
|
|
\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f]
|
|
|
|
for the x-derivative, or transposed for the y-derivative.
|
|
|
|
The function calculates an image derivative by convolving the image with the appropriate kernel:
|
|
|
|
\f[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\f]
|
|
|
|
The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less
|
|
resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3)
|
|
or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first
|
|
case corresponds to a kernel of:
|
|
|
|
\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f]
|
|
|
|
The second case corresponds to a kernel of:
|
|
|
|
\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f]
|
|
|
|
@note
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.sobel"
|
|
|
|
@param src input image.
|
|
@param ddepth output image depth, see @ref filter_depths "combinations"; in the case of
|
|
8-bit input images it will result in truncated derivatives.
|
|
@param dx order of the derivative x.
|
|
@param dy order of the derivative y.
|
|
@param ksize size of the extended Sobel kernel; it must be odd.
|
|
@param scale optional scale factor for the computed derivative values; by default, no scaling is
|
|
applied (see cv::getDerivKernels for details).
|
|
@param delta optional delta value that is added to the results prior to storing them in dst.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa filter2D, gaussianBlur, cartToPolar
|
|
*/
|
|
GAPI_EXPORTS GMat Sobel(const GMat& src, int ddepth, int dx, int dy, int ksize = 3,
|
|
double scale = 1, double delta = 0,
|
|
int borderType = BORDER_DEFAULT,
|
|
const Scalar& borderValue = Scalar(0));
|
|
|
|
/** @brief Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
|
|
|
|
In all cases except one, the \f$\texttt{ksize} \times \texttt{ksize}\f$ separable kernel is used to
|
|
calculate the derivative. When \f$\texttt{ksize = 1}\f$, the \f$3 \times 1\f$ or \f$1 \times 3\f$
|
|
kernel is used (that is, no Gaussian smoothing is done). `ksize = 1` can only be used for the first
|
|
or the second x- or y- derivatives.
|
|
|
|
There is also the special value `ksize = FILTER_SCHARR (-1)` that corresponds to the \f$3\times3\f$ Scharr
|
|
filter that may give more accurate results than the \f$3\times3\f$ Sobel. The Scharr aperture is
|
|
|
|
\f[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\f]
|
|
|
|
for the x-derivative, or transposed for the y-derivative.
|
|
|
|
The function calculates an image derivative by convolving the image with the appropriate kernel:
|
|
|
|
\f[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\f]
|
|
|
|
The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less
|
|
resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3)
|
|
or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first
|
|
case corresponds to a kernel of:
|
|
|
|
\f[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\f]
|
|
|
|
The second case corresponds to a kernel of:
|
|
|
|
\f[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\f]
|
|
|
|
@note
|
|
- First returned matrix correspons to dx derivative while the second one to dy.
|
|
- Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
|
|
- Function textual ID is "org.opencv.imgproc.filters.sobelxy"
|
|
|
|
@param src input image.
|
|
@param ddepth output image depth, see @ref filter_depths "combinations"; in the case of
|
|
8-bit input images it will result in truncated derivatives.
|
|
@param order order of the derivatives.
|
|
@param ksize size of the extended Sobel kernel; it must be odd.
|
|
@param scale optional scale factor for the computed derivative values; by default, no scaling is
|
|
applied (see cv::getDerivKernels for details).
|
|
@param delta optional delta value that is added to the results prior to storing them in dst.
|
|
@param borderType pixel extrapolation method, see cv::BorderTypes
|
|
@param borderValue border value in case of constant border type
|
|
@sa filter2D, gaussianBlur, cartToPolar
|
|
*/
|
|
GAPI_EXPORTS 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));
|
|
|
|
/** @brief Calculates the Laplacian of an image.
|
|
|
|
The function calculates the Laplacian of the source image by adding up the second x and y
|
|
derivatives calculated using the Sobel operator:
|
|
|
|
\f[\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\f]
|
|
|
|
This is done when `ksize > 1`. When `ksize == 1`, the Laplacian is computed by filtering the image
|
|
with the following \f$3 \times 3\f$ aperture:
|
|
|
|
\f[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\f]
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.filters.laplacian"
|
|
|
|
@param src Source image.
|
|
@param ddepth Desired depth of the destination image.
|
|
@param ksize Aperture size used to compute the second-derivative filters. See #getDerivKernels for
|
|
details. The size must be positive and odd.
|
|
@param scale Optional scale factor for the computed Laplacian values. By default, no scaling is
|
|
applied. See #getDerivKernels for details.
|
|
@param delta Optional delta value that is added to the results prior to storing them in dst .
|
|
@param borderType Pixel extrapolation method, see #BorderTypes. #BORDER_WRAP is not supported.
|
|
@return Destination image of the same size and the same number of channels as src.
|
|
@sa Sobel, Scharr
|
|
*/
|
|
GAPI_EXPORTS GMat Laplacian(const GMat& src, int ddepth, int ksize = 1,
|
|
double scale = 1, double delta = 0, int borderType = BORDER_DEFAULT);
|
|
|
|
/** @brief Applies the bilateral filter to an image.
|
|
|
|
The function applies bilateral filtering to the input image, as described in
|
|
http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
|
|
bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is
|
|
very slow compared to most filters.
|
|
|
|
_Sigma values_: For simplicity, you can set the 2 sigma values to be the same. If they are small (\<
|
|
10), the filter will not have much effect, whereas if they are large (\> 150), they will have a very
|
|
strong effect, making the image look "cartoonish".
|
|
|
|
_Filter size_: Large filters (d \> 5) are very slow, so it is recommended to use d=5 for real-time
|
|
applications, and perhaps d=9 for offline applications that need heavy noise filtering.
|
|
|
|
This filter does not work inplace.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.filters.bilateralfilter"
|
|
|
|
@param src Source 8-bit or floating-point, 1-channel or 3-channel image.
|
|
@param d Diameter of each pixel neighborhood that is used during filtering. If it is non-positive,
|
|
it is computed from sigmaSpace.
|
|
@param sigmaColor Filter sigma in the color space. A larger value of the parameter means that
|
|
farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting
|
|
in larger areas of semi-equal color.
|
|
@param sigmaSpace Filter sigma in the coordinate space. A larger value of the parameter means that
|
|
farther pixels will influence each other as long as their colors are close enough (see sigmaColor
|
|
). When d\>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is
|
|
proportional to sigmaSpace.
|
|
@param borderType border mode used to extrapolate pixels outside of the image, see #BorderTypes
|
|
@return Destination image of the same size and type as src.
|
|
*/
|
|
GAPI_EXPORTS GMat bilateralFilter(const GMat& src, int d, double sigmaColor, double sigmaSpace,
|
|
int borderType = BORDER_DEFAULT);
|
|
|
|
//! @} gapi_filters
|
|
|
|
//! @addtogroup gapi_feature
|
|
//! @{
|
|
/** @brief Finds edges in an image using the Canny algorithm.
|
|
|
|
The function finds edges in the input image and marks them in the output map edges using the
|
|
Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The
|
|
largest value is used to find initial segments of strong edges. See
|
|
<http://en.wikipedia.org/wiki/Canny_edge_detector>
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.feature.canny"
|
|
|
|
@param image 8-bit input image.
|
|
@param threshold1 first threshold for the hysteresis procedure.
|
|
@param threshold2 second threshold for the hysteresis procedure.
|
|
@param apertureSize aperture size for the Sobel operator.
|
|
@param L2gradient a flag, indicating whether a more accurate \f$L_2\f$ norm
|
|
\f$=\sqrt{(dI/dx)^2 + (dI/dy)^2}\f$ should be used to calculate the image gradient magnitude (
|
|
L2gradient=true ), or whether the default \f$L_1\f$ norm \f$=|dI/dx|+|dI/dy|\f$ is enough (
|
|
L2gradient=false ).
|
|
*/
|
|
GAPI_EXPORTS GMat Canny(const GMat& image, double threshold1, double threshold2,
|
|
int apertureSize = 3, bool L2gradient = false);
|
|
|
|
/** @brief Determines strong corners on an image.
|
|
|
|
The function finds the most prominent corners in the image or in the specified image region, as
|
|
described in @cite Shi94
|
|
|
|
- Function calculates the corner quality measure at every source image pixel using the
|
|
#cornerMinEigenVal or #cornerHarris .
|
|
- Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are
|
|
retained).
|
|
- The corners with the minimal eigenvalue less than
|
|
\f$\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\f$ are rejected.
|
|
- The remaining corners are sorted by the quality measure in the descending order.
|
|
- Function throws away each corner for which there is a stronger corner at a distance less than
|
|
maxDistance.
|
|
|
|
The function can be used to initialize a point-based tracker of an object.
|
|
|
|
@note
|
|
- If the function is called with different values A and B of the parameter qualityLevel , and
|
|
A \> B, the vector of returned corners with qualityLevel=A will be the prefix of the output vector
|
|
with qualityLevel=B .
|
|
- Function textual ID is "org.opencv.imgproc.feature.goodFeaturesToTrack"
|
|
|
|
@param image Input 8-bit or floating-point 32-bit, single-channel image.
|
|
@param maxCorners Maximum number of corners to return. If there are more corners than are found,
|
|
the strongest of them is returned. `maxCorners <= 0` implies that no limit on the maximum is set
|
|
and all detected corners are returned.
|
|
@param qualityLevel Parameter characterizing the minimal accepted quality of image corners. The
|
|
parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue
|
|
(see #cornerMinEigenVal ) or the Harris function response (see #cornerHarris ). The corners with the
|
|
quality measure less than the product are rejected. For example, if the best corner has the
|
|
quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure
|
|
less than 15 are rejected.
|
|
@param minDistance Minimum possible Euclidean distance between the returned corners.
|
|
@param mask Optional region of interest. If the image is not empty (it needs to have the type
|
|
CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
|
|
@param blockSize Size of an average block for computing a derivative covariation matrix over each
|
|
pixel neighborhood. See cornerEigenValsAndVecs .
|
|
@param useHarrisDetector Parameter indicating whether to use a Harris detector (see #cornerHarris)
|
|
or #cornerMinEigenVal.
|
|
@param k Free parameter of the Harris detector.
|
|
|
|
@return vector of detected corners.
|
|
*/
|
|
GAPI_EXPORTS_W GArray<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);
|
|
|
|
/** @brief Equalizes the histogram of a grayscale image.
|
|
|
|
//! @} gapi_feature
|
|
|
|
The function equalizes the histogram of the input image using the following algorithm:
|
|
|
|
- Calculate the histogram \f$H\f$ for src .
|
|
- Normalize the histogram so that the sum of histogram bins is 255.
|
|
- Compute the integral of the histogram:
|
|
\f[H'_i = \sum _{0 \le j < i} H(j)\f]
|
|
- Transform the image using \f$H'\f$ as a look-up table: \f$\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\f$
|
|
|
|
The algorithm normalizes the brightness and increases the contrast of the image.
|
|
@note
|
|
- The returned image is of the same size and type as input.
|
|
- Function textual ID is "org.opencv.imgproc.equalizeHist"
|
|
|
|
@param src Source 8-bit single channel image.
|
|
*/
|
|
GAPI_EXPORTS GMat equalizeHist(const GMat& src);
|
|
|
|
//! @addtogroup gapi_shape
|
|
//! @{
|
|
/** @brief Finds contours in a binary image.
|
|
|
|
The function retrieves contours from the binary image using the algorithm @cite Suzuki85 .
|
|
The contours are a useful tool for shape analysis and object detection and recognition.
|
|
See squares.cpp in the OpenCV sample directory.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.findContours"
|
|
|
|
@param src Input gray-scale image @ref CV_8UC1. Non-zero pixels are treated as 1's. Zero
|
|
pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, #threshold ,
|
|
#adaptiveThreshold, #Canny, and others to create a binary image out of a grayscale or color one.
|
|
If mode equals to #RETR_CCOMP, the input can also be a 32-bit integer
|
|
image of labels ( @ref CV_32SC1 ). If #RETR_FLOODFILL then @ref CV_32SC1 is supported only.
|
|
@param mode Contour retrieval mode, see #RetrievalModes
|
|
@param method Contour approximation method, see #ContourApproximationModes
|
|
@param offset Optional offset by which every contour point is shifted. This is useful if the
|
|
contours are extracted from the image ROI and then they should be analyzed in the whole image
|
|
context.
|
|
|
|
@return GArray of detected contours. Each contour is stored as a GArray of points.
|
|
*/
|
|
GAPI_EXPORTS GArray<GArray<Point>>
|
|
findContours(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method,
|
|
const GOpaque<Point> &offset);
|
|
|
|
// FIXME oc: make default value offset = Point()
|
|
/** @overload
|
|
@note Function textual ID is "org.opencv.imgproc.shape.findContoursNoOffset"
|
|
*/
|
|
GAPI_EXPORTS GArray<GArray<Point>>
|
|
findContours(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method);
|
|
|
|
/** @brief Finds contours and their hierarchy in a binary image.
|
|
|
|
The function retrieves contours from the binary image using the algorithm @cite Suzuki85
|
|
and calculates their hierarchy.
|
|
The contours are a useful tool for shape analysis and object detection and recognition.
|
|
See squares.cpp in the OpenCV sample directory.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.findContoursH"
|
|
|
|
@param src Input gray-scale image @ref CV_8UC1. Non-zero pixels are treated as 1's. Zero
|
|
pixels remain 0's, so the image is treated as binary . You can use #compare, #inRange, #threshold ,
|
|
#adaptiveThreshold, #Canny, and others to create a binary image out of a grayscale or color one.
|
|
If mode equals to #RETR_CCOMP, the input can also be a 32-bit integer
|
|
image of labels ( @ref CV_32SC1 ). If #RETR_FLOODFILL -- @ref CV_32SC1 supports only.
|
|
@param mode Contour retrieval mode, see #RetrievalModes
|
|
@param method Contour approximation method, see #ContourApproximationModes
|
|
@param offset Optional offset by which every contour point is shifted. This is useful if the
|
|
contours are extracted from the image ROI and then they should be analyzed in the whole image
|
|
context.
|
|
|
|
@return
|
|
- GArray of detected contours. Each contour is stored as a GArray of points.
|
|
- Optional output GArray of cv::Vec4i, containing information about the image topology.
|
|
It has as many elements as the number of contours. For each i-th contour contours[i], the elements
|
|
hierarchy[i][0] , hierarchy[i][1] , hierarchy[i][2] , and hierarchy[i][3] are set to 0-based
|
|
indices in contours of the next and previous contours at the same hierarchical level, the first
|
|
child contour and the parent contour, respectively. If for the contour i there are no next,
|
|
previous, parent, or nested contours, the corresponding elements of hierarchy[i] will be negative.
|
|
*/
|
|
GAPI_EXPORTS std::tuple<GArray<GArray<Point>>,GArray<Vec4i>>
|
|
findContoursH(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method,
|
|
const GOpaque<Point> &offset);
|
|
|
|
// FIXME oc: make default value offset = Point()
|
|
/** @overload
|
|
@note Function textual ID is "org.opencv.imgproc.shape.findContoursHNoOffset"
|
|
*/
|
|
GAPI_EXPORTS std::tuple<GArray<GArray<Point>>,GArray<Vec4i>>
|
|
findContoursH(const GMat &src, const RetrievalModes mode, const ContourApproximationModes method);
|
|
|
|
/** @brief Calculates the up-right bounding rectangle of a point set or non-zero pixels
|
|
of gray-scale image.
|
|
|
|
The function calculates and returns the minimal up-right bounding rectangle for the specified
|
|
point set or non-zero pixels of gray-scale image.
|
|
|
|
@note
|
|
- Function textual ID is "org.opencv.imgproc.shape.boundingRectMat"
|
|
- In case of a 2D points' set given, Mat should be 2-dimensional, have a single row or column
|
|
if there are 2 channels, or have 2 columns if there is a single channel. Mat should have either
|
|
@ref CV_32S or @ref CV_32F depth
|
|
|
|
@param src Input gray-scale image @ref CV_8UC1; or input set of @ref CV_32S or @ref CV_32F
|
|
2D points stored in Mat.
|
|
*/
|
|
GAPI_EXPORTS_W GOpaque<Rect> boundingRect(const GMat& src);
|
|
|
|
/** @overload
|
|
|
|
Calculates the up-right bounding rectangle of a point set.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.boundingRectVector32S"
|
|
|
|
@param src Input 2D point set, stored in std::vector<cv::Point2i>.
|
|
*/
|
|
GAPI_EXPORTS_W GOpaque<Rect> boundingRect(const GArray<Point2i>& src);
|
|
|
|
/** @overload
|
|
|
|
Calculates the up-right bounding rectangle of a point set.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.boundingRectVector32F"
|
|
|
|
@param src Input 2D point set, stored in std::vector<cv::Point2f>.
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Rect> boundingRect(const GArray<Point2f>& src);
|
|
|
|
/** @brief Fits a line to a 2D point set.
|
|
|
|
The function fits a line to a 2D point set by minimizing \f$\sum_i \rho(r_i)\f$ where
|
|
\f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and \f$\rho(r)\f$ is a distance
|
|
function, one of the following:
|
|
- DIST_L2
|
|
\f[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\f]
|
|
- DIST_L1
|
|
\f[\rho (r) = r\f]
|
|
- DIST_L12
|
|
\f[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f]
|
|
- DIST_FAIR
|
|
\f[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\f]
|
|
- DIST_WELSCH
|
|
\f[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\f]
|
|
- DIST_HUBER
|
|
\f[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\f]
|
|
|
|
The algorithm is based on the M-estimator ( <http://en.wikipedia.org/wiki/M-estimator> ) technique
|
|
that iteratively fits the line using the weighted least-squares algorithm. After each iteration the
|
|
weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ .
|
|
|
|
@note
|
|
- Function textual ID is "org.opencv.imgproc.shape.fitLine2DMat"
|
|
- In case of an N-dimentional points' set given, Mat should be 2-dimensional, have a single row
|
|
or column if there are N channels, or have N columns if there is a single channel.
|
|
|
|
@param src Input set of 2D points stored in one of possible containers: Mat,
|
|
std::vector<cv::Point2i>, std::vector<cv::Point2f>, std::vector<cv::Point2d>.
|
|
@param distType Distance used by the M-estimator, see #DistanceTypes. @ref DIST_USER
|
|
and @ref DIST_C are not suppored.
|
|
@param param Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value
|
|
is chosen.
|
|
@param reps Sufficient accuracy for the radius (distance between the coordinate origin and the
|
|
line). 1.0 would be a good default value for reps. If it is 0, a default value is chosen.
|
|
@param aeps Sufficient accuracy for the angle. 0.01 would be a good default value for aeps.
|
|
If it is 0, a default value is chosen.
|
|
|
|
@return Output line parameters: a vector of 4 elements (like Vec4f) - (vx, vy, x0, y0),
|
|
where (vx, vy) is a normalized vector collinear to the line and (x0, y0) is a point on the line.
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec4f> fitLine2D(const GMat& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @overload
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.fitLine2DVector32S"
|
|
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec4f> fitLine2D(const GArray<Point2i>& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @overload
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.fitLine2DVector32F"
|
|
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec4f> fitLine2D(const GArray<Point2f>& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @overload
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.fitLine2DVector64F"
|
|
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec4f> fitLine2D(const GArray<Point2d>& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @brief Fits a line to a 3D point set.
|
|
|
|
The function fits a line to a 3D point set by minimizing \f$\sum_i \rho(r_i)\f$ where
|
|
\f$r_i\f$ is a distance between the \f$i^{th}\f$ point, the line and \f$\rho(r)\f$ is a distance
|
|
function, one of the following:
|
|
- DIST_L2
|
|
\f[\rho (r) = r^2/2 \quad \text{(the simplest and the fastest least-squares method)}\f]
|
|
- DIST_L1
|
|
\f[\rho (r) = r\f]
|
|
- DIST_L12
|
|
\f[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\f]
|
|
- DIST_FAIR
|
|
\f[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{where} \quad C=1.3998\f]
|
|
- DIST_WELSCH
|
|
\f[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{where} \quad C=2.9846\f]
|
|
- DIST_HUBER
|
|
\f[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \quad C=1.345\f]
|
|
|
|
The algorithm is based on the M-estimator ( <http://en.wikipedia.org/wiki/M-estimator> ) technique
|
|
that iteratively fits the line using the weighted least-squares algorithm. After each iteration the
|
|
weights \f$w_i\f$ are adjusted to be inversely proportional to \f$\rho(r_i)\f$ .
|
|
|
|
@note
|
|
- Function textual ID is "org.opencv.imgproc.shape.fitLine3DMat"
|
|
- In case of an N-dimentional points' set given, Mat should be 2-dimensional, have a single row
|
|
or column if there are N channels, or have N columns if there is a single channel.
|
|
|
|
@param src Input set of 3D points stored in one of possible containers: Mat,
|
|
std::vector<cv::Point3i>, std::vector<cv::Point3f>, std::vector<cv::Point3d>.
|
|
@param distType Distance used by the M-estimator, see #DistanceTypes. @ref DIST_USER
|
|
and @ref DIST_C are not suppored.
|
|
@param param Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value
|
|
is chosen.
|
|
@param reps Sufficient accuracy for the radius (distance between the coordinate origin and the
|
|
line). 1.0 would be a good default value for reps. If it is 0, a default value is chosen.
|
|
@param aeps Sufficient accuracy for the angle. 0.01 would be a good default value for aeps.
|
|
If it is 0, a default value is chosen.
|
|
|
|
@return Output line parameters: a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0, z0),
|
|
where (vx, vy, vz) is a normalized vector collinear to the line and (x0, y0, z0) is a point on
|
|
the line.
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec6f> fitLine3D(const GMat& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @overload
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.fitLine3DVector32S"
|
|
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec6f> fitLine3D(const GArray<Point3i>& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @overload
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.fitLine3DVector32F"
|
|
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec6f> fitLine3D(const GArray<Point3f>& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
/** @overload
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.shape.fitLine3DVector64F"
|
|
|
|
*/
|
|
GAPI_EXPORTS GOpaque<Vec6f> fitLine3D(const GArray<Point3d>& src, const DistanceTypes distType,
|
|
const double param = 0., const double reps = 0.,
|
|
const double aeps = 0.);
|
|
|
|
//! @} gapi_shape
|
|
|
|
//! @addtogroup gapi_colorconvert
|
|
//! @{
|
|
/** @brief Converts an image from BGR color space to RGB color space.
|
|
|
|
The function converts an input image from BGR color space to RGB.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image is 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2rgb"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa RGB2BGR
|
|
*/
|
|
GAPI_EXPORTS_W GMat BGR2RGB(const GMat& src);
|
|
|
|
/** @brief Converts an image from RGB color space to gray-scaled.
|
|
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
Resulting gray color value computed as
|
|
\f[\texttt{dst} (I)= \texttt{0.299} * \texttt{src}(I).R + \texttt{0.587} * \texttt{src}(I).G + \texttt{0.114} * \texttt{src}(I).B \f]
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2gray"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1.
|
|
@sa RGB2YUV
|
|
*/
|
|
GAPI_EXPORTS_W GMat RGB2Gray(const GMat& src);
|
|
|
|
/** @overload
|
|
Resulting gray color value computed as
|
|
\f[\texttt{dst} (I)= \texttt{rY} * \texttt{src}(I).R + \texttt{gY} * \texttt{src}(I).G + \texttt{bY} * \texttt{src}(I).B \f]
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2graycustom"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1.
|
|
@param rY float multiplier for R channel.
|
|
@param gY float multiplier for G channel.
|
|
@param bY float multiplier for B channel.
|
|
@sa RGB2YUV
|
|
*/
|
|
GAPI_EXPORTS GMat RGB2Gray(const GMat& src, float rY, float gY, float bY);
|
|
|
|
/** @brief Converts an image from BGR color space to gray-scaled.
|
|
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
Resulting gray color value computed as
|
|
\f[\texttt{dst} (I)= \texttt{0.114} * \texttt{src}(I).B + \texttt{0.587} * \texttt{src}(I).G + \texttt{0.299} * \texttt{src}(I).R \f]
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2gray"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1.
|
|
@sa BGR2LUV
|
|
*/
|
|
GAPI_EXPORTS GMat BGR2Gray(const GMat& src);
|
|
|
|
/** @brief Converts an image from RGB color space to YUV color space.
|
|
|
|
The function converts an input image from RGB color space to YUV.
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
|
|
In case of linear transformations, the range does not matter. But in case of a non-linear
|
|
transformation, an input RGB image should be normalized to the proper value range to get the correct
|
|
results, like here, at RGB \f$\rightarrow\f$ Y\*u\*v\* transformation.
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2yuv"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa YUV2RGB, RGB2Lab
|
|
*/
|
|
GAPI_EXPORTS GMat RGB2YUV(const GMat& src);
|
|
|
|
/** @brief Converts an image from BGR color space to I420 color space.
|
|
|
|
The function converts an input image from BGR color space to I420.
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 1-channel image. @ref CV_8UC1.
|
|
Width of I420 output image must be the same as width of input image.
|
|
Height of I420 output image must be equal 3/2 from height of input image.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2i420"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa I4202BGR
|
|
*/
|
|
GAPI_EXPORTS GMat BGR2I420(const GMat& src);
|
|
|
|
/** @brief Converts an image from RGB color space to I420 color space.
|
|
|
|
The function converts an input image from RGB color space to I420.
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 1-channel image. @ref CV_8UC1.
|
|
Width of I420 output image must be the same as width of input image.
|
|
Height of I420 output image must be equal 3/2 from height of input image.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2i420"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa I4202RGB
|
|
*/
|
|
GAPI_EXPORTS GMat RGB2I420(const GMat& src);
|
|
|
|
/** @brief Converts an image from I420 color space to BGR color space.
|
|
|
|
The function converts an input image from I420 color space to BGR.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image. @ref CV_8UC3.
|
|
Width of BGR output image must be the same as width of input image.
|
|
Height of BGR output image must be equal 2/3 from height of input image.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.i4202bgr"
|
|
|
|
@param src input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@sa BGR2I420
|
|
*/
|
|
GAPI_EXPORTS GMat I4202BGR(const GMat& src);
|
|
|
|
/** @brief Converts an image from I420 color space to BGR color space.
|
|
|
|
The function converts an input image from I420 color space to BGR.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image. @ref CV_8UC3.
|
|
Width of RGB output image must be the same as width of input image.
|
|
Height of RGB output image must be equal 2/3 from height of input image.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.i4202rgb"
|
|
|
|
@param src input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@sa RGB2I420
|
|
*/
|
|
GAPI_EXPORTS GMat I4202RGB(const GMat& src);
|
|
|
|
/** @brief Converts an image from BGR color space to LUV color space.
|
|
|
|
The function converts an input image from BGR color space to LUV.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2luv"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa RGB2Lab, RGB2LUV
|
|
*/
|
|
GAPI_EXPORTS GMat BGR2LUV(const GMat& src);
|
|
|
|
/** @brief Converts an image from LUV color space to BGR color space.
|
|
|
|
The function converts an input image from LUV color space to BGR.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.luv2bgr"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa BGR2LUV
|
|
*/
|
|
GAPI_EXPORTS GMat LUV2BGR(const GMat& src);
|
|
|
|
/** @brief Converts an image from YUV color space to BGR color space.
|
|
|
|
The function converts an input image from YUV color space to BGR.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.yuv2bgr"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa BGR2YUV
|
|
*/
|
|
GAPI_EXPORTS GMat YUV2BGR(const GMat& src);
|
|
|
|
/** @brief Converts an image from BGR color space to YUV color space.
|
|
|
|
The function converts an input image from BGR color space to YUV.
|
|
The conventional ranges for B, G, and R channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.bgr2yuv"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
@sa YUV2BGR
|
|
*/
|
|
GAPI_EXPORTS GMat BGR2YUV(const GMat& src);
|
|
|
|
/** @brief Converts an image from RGB color space to Lab color space.
|
|
|
|
The function converts an input image from BGR color space to Lab.
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC1.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2lab"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC1.
|
|
@sa RGB2YUV, RGB2LUV
|
|
*/
|
|
GAPI_EXPORTS GMat RGB2Lab(const GMat& src);
|
|
|
|
/** @brief Converts an image from YUV color space to RGB.
|
|
The function converts an input image from YUV color space to RGB.
|
|
The conventional ranges for Y, U, and V channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.yuv2rgb"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@sa RGB2Lab, RGB2YUV
|
|
*/
|
|
GAPI_EXPORTS GMat YUV2RGB(const GMat& src);
|
|
|
|
/** @brief Converts an image from NV12 (YUV420p) color space to RGB.
|
|
The function converts an input image from NV12 color space to RGB.
|
|
The conventional ranges for Y, U, and V channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12torgb"
|
|
|
|
@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2.
|
|
|
|
@sa YUV2RGB, NV12toBGR
|
|
*/
|
|
GAPI_EXPORTS GMat NV12toRGB(const GMat& src_y, const GMat& src_uv);
|
|
|
|
/** @brief Converts an image from NV12 (YUV420p) color space to gray-scaled.
|
|
The function converts an input image from NV12 color space to gray-scaled.
|
|
The conventional ranges for Y, U, and V channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12togray"
|
|
|
|
@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2.
|
|
|
|
@sa YUV2RGB, NV12toBGR
|
|
*/
|
|
GAPI_EXPORTS GMat NV12toGray(const GMat& src_y, const GMat& src_uv);
|
|
|
|
/** @brief Converts an image from NV12 (YUV420p) color space to BGR.
|
|
The function converts an input image from NV12 color space to RGB.
|
|
The conventional ranges for Y, U, and V channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12tobgr"
|
|
|
|
@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2.
|
|
|
|
@sa YUV2BGR, NV12toRGB
|
|
*/
|
|
GAPI_EXPORTS GMat NV12toBGR(const GMat& src_y, const GMat& src_uv);
|
|
|
|
/** @brief Converts an image from BayerGR color space to RGB.
|
|
The function converts an input image from BayerGR color space to RGB.
|
|
The conventional ranges for G, R, and B channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.bayergr2rgb"
|
|
|
|
@param src_gr input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
|
|
@sa YUV2BGR, NV12toRGB
|
|
*/
|
|
GAPI_EXPORTS GMat BayerGR2RGB(const GMat& src_gr);
|
|
|
|
/** @brief Converts an image from RGB color space to HSV.
|
|
The function converts an input image from RGB color space to HSV.
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2hsv"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@sa YUV2BGR, NV12toRGB
|
|
*/
|
|
GAPI_EXPORTS GMat RGB2HSV(const GMat& src);
|
|
|
|
/** @brief Converts an image from RGB color space to YUV422.
|
|
The function converts an input image from RGB color space to YUV422.
|
|
The conventional ranges for R, G, and B channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned 2-channel image @ref CV_8UC2.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.rgb2yuv422"
|
|
|
|
@param src input image: 8-bit unsigned 3-channel image @ref CV_8UC3.
|
|
|
|
@sa YUV2BGR, NV12toRGB
|
|
*/
|
|
GAPI_EXPORTS GMat RGB2YUV422(const GMat& src);
|
|
|
|
/** @brief Converts an image from NV12 (YUV420p) color space to RGB.
|
|
The function converts an input image from NV12 color space to RGB.
|
|
The conventional ranges for Y, U, and V channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned planar 3-channel image @ref CV_8UC1.
|
|
Planar image memory layout is three planes laying in the memory contiguously,
|
|
so the image height should be plane_height*plane_number,
|
|
image type is @ref CV_8UC1.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12torgbp"
|
|
|
|
@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2.
|
|
|
|
@sa YUV2RGB, NV12toBGRp, NV12toRGB
|
|
*/
|
|
GAPI_EXPORTS GMatP NV12toRGBp(const GMat &src_y, const GMat &src_uv);
|
|
|
|
/** @brief Converts an image from NV12 (YUV420p) color space to BGR.
|
|
The function converts an input image from NV12 color space to BGR.
|
|
The conventional ranges for Y, U, and V channel values are 0 to 255.
|
|
|
|
Output image must be 8-bit unsigned planar 3-channel image @ref CV_8UC1.
|
|
Planar image memory layout is three planes laying in the memory contiguously,
|
|
so the image height should be plane_height*plane_number,
|
|
image type is @ref CV_8UC1.
|
|
|
|
@note Function textual ID is "org.opencv.imgproc.colorconvert.nv12torgbp"
|
|
|
|
@param src_y input image: 8-bit unsigned 1-channel image @ref CV_8UC1.
|
|
@param src_uv input image: 8-bit unsigned 2-channel image @ref CV_8UC2.
|
|
|
|
@sa YUV2RGB, NV12toRGBp, NV12toBGR
|
|
*/
|
|
GAPI_EXPORTS GMatP NV12toBGRp(const GMat &src_y, const GMat &src_uv);
|
|
|
|
//! @} gapi_colorconvert
|
|
} //namespace gapi
|
|
} //namespace cv
|
|
|
|
#endif // OPENCV_GAPI_IMGPROC_HPP
|