592 lines
19 KiB
C++
592 lines
19 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 Intel Corporation
|
|
|
|
|
|
// FIXME: move out from Common
|
|
|
|
#include "../test_precomp.hpp"
|
|
#include <opencv2/gapi/cpu/core.hpp>
|
|
|
|
#include <ade/util/algorithm.hpp>
|
|
|
|
namespace opencv_test
|
|
{
|
|
namespace
|
|
{
|
|
G_TYPED_KERNEL(GCompoundDoubleAddC, <GMat(GMat, GScalar)>, "org.opencv.test.compound_double_addC")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in, GScalarDesc) { return in; }
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundDoubleAddCImpl, GCompoundDoubleAddC)
|
|
{
|
|
static GMat expand(cv::GMat in, cv::GScalar s)
|
|
{
|
|
return cv::gapi::addC(cv::gapi::addC(in, s), s);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundAddC, <GMat(GMat, GScalar)>, "org.opencv.test.compound_addC")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in, GScalarDesc) { return in; }
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundAddCImpl, GCompoundAddC)
|
|
{
|
|
static GMat expand(cv::GMat in, cv::GScalar s)
|
|
{
|
|
return cv::gapi::addC(in, s);
|
|
}
|
|
};
|
|
|
|
using GMat3 = std::tuple<GMat,GMat,GMat>;
|
|
using GMat2 = std::tuple<GMat,GMat>;
|
|
|
|
G_TYPED_KERNEL_M(GCompoundMergeWithSplit, <GMat3(GMat, GMat, GMat)>, "org.opencv.test.compound_merge_split")
|
|
{
|
|
static std::tuple<GMatDesc,GMatDesc,GMatDesc> outMeta(GMatDesc a, GMatDesc b, GMatDesc c)
|
|
{
|
|
return std::make_tuple(a, b, c);
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundMergeWithSplitImpl, GCompoundMergeWithSplit)
|
|
{
|
|
static GMat3 expand(cv::GMat a, cv::GMat b, cv::GMat c)
|
|
{
|
|
return cv::gapi::split3(cv::gapi::merge3(a, b, c));
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundAddWithAddC, <GMat(GMat, GMat, GScalar)>, "org.opencv.test.compound_add_with_addc")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in, GMatDesc, GScalarDesc)
|
|
{
|
|
return in;
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundAddWithAddCImpl, GCompoundAddWithAddC)
|
|
{
|
|
static GMat expand(cv::GMat in1, cv::GMat in2, cv::GScalar s)
|
|
{
|
|
return cv::gapi::addC(cv::gapi::add(in1, in2), s);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL_M(GCompoundSplitWithAdd, <GMat2(GMat)>, "org.opencv.test.compound_split_with_add")
|
|
{
|
|
static std::tuple<GMatDesc, GMatDesc> outMeta(GMatDesc in)
|
|
{
|
|
const auto out_depth = in.depth;
|
|
const auto out_desc = in.withType(out_depth, 1);
|
|
return std::make_tuple(out_desc, out_desc);
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundSplitWithAddImpl, GCompoundSplitWithAdd)
|
|
{
|
|
static GMat2 expand(cv::GMat in)
|
|
{
|
|
cv::GMat a, b, c;
|
|
std::tie(a, b, c) = cv::gapi::split3(in);
|
|
return std::make_tuple(cv::gapi::add(a, b), c);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL_M(GCompoundParallelAddC, <GMat2(GMat, GScalar)>, "org.opencv.test.compound_parallel_addc")
|
|
{
|
|
static std::tuple<GMatDesc, GMatDesc> outMeta(GMatDesc in, GScalarDesc)
|
|
{
|
|
return std::make_tuple(in, in);
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundParallelAddCImpl, GCompoundParallelAddC)
|
|
{
|
|
static GMat2 expand(cv::GMat in, cv::GScalar s)
|
|
{
|
|
return std::make_tuple(cv::gapi::addC(in, s), cv::gapi::addC(in, s));
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundAddImpl, cv::gapi::core::GAdd)
|
|
{
|
|
static GMat expand(cv::GMat in1, cv::GMat in2, int)
|
|
{
|
|
return cv::gapi::sub(cv::gapi::sub(in1, in2), in2);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundAddWithAddCWithDoubleAddC, <GMat(GMat, GMat, GScalar)>, "org.opencv.test.compound_add_with_addC_with_double_addC")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in, GMatDesc, GScalarDesc)
|
|
{
|
|
return in;
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundAddWithAddCWithDoubleAddCImpl, GCompoundAddWithAddCWithDoubleAddC)
|
|
{
|
|
static GMat expand(cv::GMat in1, cv::GMat in2, cv::GScalar s)
|
|
{
|
|
return GCompoundDoubleAddC::on(GCompoundAddWithAddC::on(in1, in2, s), s);
|
|
}
|
|
};
|
|
|
|
using GDoubleArray = cv::GArray<double>;
|
|
G_TYPED_KERNEL(GNegateArray, <GDoubleArray(GDoubleArray)>, "org.opencv.test.negate_array")
|
|
{
|
|
static GArrayDesc outMeta(const GArrayDesc&) { return empty_array_desc(); }
|
|
};
|
|
|
|
GAPI_OCV_KERNEL(GNegateArrayImpl, GNegateArray)
|
|
{
|
|
static void run(const std::vector<double>& in, std::vector<double>& out)
|
|
{
|
|
ade::util::transform(in, std::back_inserter(out), std::negate<double>());
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GMaxInArray, <GScalar(GDoubleArray)>, "org.opencv.test.max_in_array")
|
|
{
|
|
static GScalarDesc outMeta(const GArrayDesc&) { return empty_scalar_desc(); }
|
|
};
|
|
|
|
GAPI_OCV_KERNEL(GMaxInArrayImpl, GMaxInArray)
|
|
{
|
|
static void run(const std::vector<double>& in, cv::Scalar& out)
|
|
{
|
|
out = *std::max_element(in.begin(), in.end());
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundMaxInArray, <GScalar(GDoubleArray)>, "org.opencv.test.compound_max_in_array")
|
|
{
|
|
static GScalarDesc outMeta(const GArrayDesc&) { return empty_scalar_desc(); }
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundMaxInArrayImpl, GCompoundMaxInArray)
|
|
{
|
|
static GScalar expand(GDoubleArray in)
|
|
{
|
|
return GMaxInArray::on(in);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundNegateArray, <GDoubleArray(GDoubleArray)>, "org.opencv.test.compound_negate_array")
|
|
{
|
|
static GArrayDesc outMeta(const GArrayDesc&) { return empty_array_desc(); }
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundNegateArrayImpl, GCompoundNegateArray)
|
|
{
|
|
static GDoubleArray expand(GDoubleArray in)
|
|
{
|
|
return GNegateArray::on(in);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(SetDiagKernel, <GMat(GMat, GDoubleArray)>, "org.opencv.test.empty_kernel")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in, GArrayDesc) { return in; }
|
|
};
|
|
|
|
void setDiag(cv::Mat& in, const std::vector<double>& diag)
|
|
{
|
|
GAPI_Assert(in.rows == static_cast<int>(diag.size()));
|
|
GAPI_Assert(in.cols == static_cast<int>(diag.size()));
|
|
for (int i = 0; i < in.rows; ++i)
|
|
{
|
|
in.at<uchar>(i, i) = static_cast<uchar>(diag[i]);
|
|
}
|
|
}
|
|
|
|
GAPI_OCV_KERNEL(SetDiagKernelImpl, SetDiagKernel)
|
|
{
|
|
static void run(const cv::Mat& in, const std::vector<double>& v, cv::Mat& out)
|
|
{
|
|
in.copyTo(out);
|
|
setDiag(out, v);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundGMatGArrayGMat, <GMat(GMat, GDoubleArray, GMat)>, "org.opencv.test.compound_gmat_garray_gmat")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in, GArrayDesc, GMatDesc) { return in; }
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundGMatGArrayGMatImpl, GCompoundGMatGArrayGMat)
|
|
{
|
|
static GMat expand(GMat a, GDoubleArray b, GMat c)
|
|
{
|
|
return SetDiagKernel::on(cv::gapi::add(a, c), b);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GToInterleaved, <GMat(GMatP)>, "org.opencv.test.to_interleaved")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in)
|
|
{
|
|
GAPI_Assert(in.planar == true);
|
|
GAPI_Assert(in.chan == 3);
|
|
return in.asInterleaved();
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GToPlanar, <GMatP(GMat)>, "org.opencv.test.to_planar")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in)
|
|
{
|
|
GAPI_Assert(in.planar == false);
|
|
GAPI_Assert(in.chan == 3);
|
|
return in.asPlanar();
|
|
}
|
|
};
|
|
|
|
GAPI_OCV_KERNEL(GToInterleavedImpl, GToInterleaved)
|
|
{
|
|
static void run(const cv::Mat& in, cv::Mat& out)
|
|
{
|
|
constexpr int inPlanesCount = 3;
|
|
int inPlaneHeight = in.rows / inPlanesCount;
|
|
|
|
std::vector<cv::Mat> inPlanes(inPlanesCount);
|
|
for (int i = 0; i < inPlanesCount; ++i)
|
|
{
|
|
int startRow = i * inPlaneHeight;
|
|
int endRow = startRow + inPlaneHeight;
|
|
inPlanes[i] = in.rowRange(startRow, endRow);
|
|
}
|
|
|
|
cv::merge(inPlanes, out);
|
|
}
|
|
};
|
|
|
|
GAPI_OCV_KERNEL(GToPlanarImpl, GToPlanar)
|
|
{
|
|
static void run(const cv::Mat& in, cv::Mat& out)
|
|
{
|
|
std::vector<cv::Mat> inPlanes;
|
|
cv::split(in, inPlanes);
|
|
cv::vconcat(inPlanes, out);
|
|
}
|
|
};
|
|
|
|
G_TYPED_KERNEL(GCompoundToInterleavedToPlanar, <GMatP(GMatP)>,
|
|
"org.opencv.test.compound_to_interleaved_to_planar")
|
|
{
|
|
static GMatDesc outMeta(GMatDesc in)
|
|
{
|
|
GAPI_Assert(in.planar == true);
|
|
GAPI_Assert(in.chan == 3);
|
|
return in;
|
|
}
|
|
};
|
|
|
|
GAPI_COMPOUND_KERNEL(GCompoundToInterleavedToPlanarImpl, GCompoundToInterleavedToPlanar)
|
|
{
|
|
static GMatP expand(cv::GMatP in)
|
|
{
|
|
return GToPlanar::on(GToInterleaved::on(in));
|
|
}
|
|
};
|
|
} // namespace
|
|
|
|
// FIXME avoid cv::combine that use custom and default kernels together
|
|
TEST(GCompoundKernel, ReplaceDefaultKernel)
|
|
{
|
|
cv::GMat in1, in2;
|
|
auto out = cv::gapi::add(in1, in2);
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundAddImpl>();
|
|
const auto full_pkg = cv::gapi::combine(cv::gapi::core::cpu::kernels(), custom_pkg);
|
|
cv::GComputation comp(cv::GIn(in1, in2), cv::GOut(out));
|
|
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat(3, 3, CV_8UC1),
|
|
ref_mat(3, 3, CV_8UC1);
|
|
|
|
comp.apply(cv::gin(in_mat1, in_mat2), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat1 - in_mat2 - in_mat2;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, DoubleAddC)
|
|
{
|
|
cv::GMat in1, in2;
|
|
cv::GScalar s;
|
|
auto add_res = cv::gapi::add(in1, in2);
|
|
auto super = GCompoundDoubleAddC::on(add_res, s);
|
|
auto out = cv::gapi::addC(super, s);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundDoubleAddCImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
|
|
|
|
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat(3, 3, CV_8UC1),
|
|
ref_mat(3, 3, CV_8UC1);
|
|
|
|
cv::Scalar scalar = 2;
|
|
|
|
comp.apply(cv::gin(in_mat1, in_mat2, scalar), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat1 + in_mat2 + scalar + scalar + scalar;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, AddC)
|
|
{
|
|
cv::GMat in1, in2;
|
|
cv::GScalar s;
|
|
auto add_res = cv::gapi::add(in1, in2);
|
|
auto super = GCompoundAddC::on(add_res, s);
|
|
auto out = cv::gapi::addC(super, s);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundAddCImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
|
|
|
|
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat(3, 3, CV_8UC1),
|
|
ref_mat(3, 3, CV_8UC1);
|
|
|
|
cv::Scalar scalar = 2;
|
|
|
|
comp.apply(cv::gin(in_mat1, in_mat2, scalar), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat1 + in_mat2 + scalar + scalar;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, MergeWithSplit)
|
|
{
|
|
cv::GMat in, a1, b1, c1,
|
|
a2, b2, c2;
|
|
|
|
std::tie(a1, b1, c1) = cv::gapi::split3(in);
|
|
std::tie(a2, b2, c2) = GCompoundMergeWithSplit::on(a1, b1, c1);
|
|
auto out = cv::gapi::merge3(a2, b2, c2);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundMergeWithSplitImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
|
|
|
cv::Mat in_mat = cv::Mat::eye(3, 3, CV_8UC3), out_mat, ref_mat;
|
|
comp.apply(cv::gin(in_mat), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, AddWithAddC)
|
|
{
|
|
cv::GMat in1, in2;
|
|
cv::GScalar s;
|
|
auto out = GCompoundAddWithAddC::on(in1, in2, s);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundAddWithAddCImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
|
|
|
|
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat(3, 3, CV_8UC1),
|
|
ref_mat(3, 3, CV_8UC1);
|
|
|
|
cv::Scalar scalar = 2;
|
|
|
|
comp.apply(cv::gin(in_mat1, in_mat2, scalar), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat1 + in_mat2 + scalar;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, SplitWithAdd)
|
|
{
|
|
cv::GMat in, out1, out2;
|
|
std::tie(out1, out2) = GCompoundSplitWithAdd::on(in);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundSplitWithAddImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in), cv::GOut(out1, out2));
|
|
|
|
cv::Mat in_mat = cv::Mat::eye(3, 3, CV_8UC3),
|
|
out_mat1(3, 3, CV_8UC1),
|
|
out_mat2(3, 3, CV_8UC1),
|
|
ref_mat1(3, 3, CV_8UC1),
|
|
ref_mat2(3, 3, CV_8UC1);
|
|
|
|
comp.apply(cv::gin(in_mat), cv::gout(out_mat1, out_mat2), cv::compile_args(full_pkg));
|
|
|
|
std::vector<cv::Mat> channels(3);
|
|
cv::split(in_mat, channels);
|
|
|
|
ref_mat1 = channels[0] + channels[1];
|
|
ref_mat2 = channels[2];
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat1, ref_mat1, NORM_INF));
|
|
EXPECT_EQ(0, cvtest::norm(out_mat2, ref_mat2, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, ParallelAddC)
|
|
{
|
|
cv::GMat in1, out1, out2;
|
|
cv::GScalar in2;
|
|
std::tie(out1, out2) = GCompoundParallelAddC::on(in1, in2);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundParallelAddCImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in1, in2), cv::GOut(out1, out2));
|
|
|
|
cv::Mat in_mat = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat1(3, 3, CV_8UC1),
|
|
out_mat2(3, 3, CV_8UC1),
|
|
ref_mat1(3, 3, CV_8UC1),
|
|
ref_mat2(3, 3, CV_8UC1);
|
|
|
|
cv::Scalar scalar = 2;
|
|
|
|
comp.apply(cv::gin(in_mat, scalar), cv::gout(out_mat1, out_mat2), cv::compile_args(full_pkg));
|
|
|
|
ref_mat1 = in_mat + scalar;
|
|
ref_mat2 = in_mat + scalar;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat1, ref_mat1, NORM_INF));
|
|
EXPECT_EQ(0, cvtest::norm(out_mat2, ref_mat2, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, GCompundKernelAndDefaultUseOneData)
|
|
{
|
|
cv::GMat in1, in2;
|
|
cv::GScalar s;
|
|
auto out = cv::gapi::add(GCompoundAddWithAddC::on(in1, in2, s), cv::gapi::addC(in2, s));
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundAddWithAddCImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
|
|
|
|
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat(3, 3, CV_8UC1),
|
|
ref_mat(3, 3, CV_8UC1);
|
|
|
|
cv::Scalar scalar = 2;
|
|
|
|
comp.apply(cv::gin(in_mat1, in_mat2, scalar), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat1 + in_mat2 + scalar + in_mat2 + scalar;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, CompoundExpandedToCompound)
|
|
{
|
|
cv::GMat in1, in2;
|
|
cv::GScalar s;
|
|
auto out = GCompoundAddWithAddCWithDoubleAddC::on(in1, in2, s);
|
|
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundAddWithAddCWithDoubleAddCImpl,
|
|
GCompoundAddWithAddCImpl,
|
|
GCompoundDoubleAddCImpl>();
|
|
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in1, in2, s), cv::GOut(out));
|
|
|
|
cv::Mat in_mat1 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(3, 3, CV_8UC1),
|
|
out_mat(3, 3, CV_8UC1),
|
|
ref_mat(3, 3, CV_8UC1);
|
|
|
|
cv::Scalar scalar = 2;
|
|
|
|
comp.apply(cv::gin(in_mat1, in_mat2, scalar), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
ref_mat = in_mat1 + in_mat2 + scalar + scalar + scalar;
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
}
|
|
|
|
TEST(GCompoundKernel, MaxInArray)
|
|
{
|
|
GDoubleArray in;
|
|
auto out = GCompoundMaxInArray::on(in);
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundMaxInArrayImpl, GMaxInArrayImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
|
std::vector<double> v = { 1, 5, -2, 3, 10, 2};
|
|
cv::Scalar out_scl;
|
|
cv::Scalar ref_scl(*std::max_element(v.begin(), v.end()));
|
|
|
|
comp.apply(cv::gin(v), cv::gout(out_scl), cv::compile_args(full_pkg));
|
|
|
|
EXPECT_EQ(out_scl, ref_scl);
|
|
}
|
|
|
|
TEST(GCompoundKernel, NegateArray)
|
|
{
|
|
GDoubleArray in;
|
|
GDoubleArray out = GCompoundNegateArray::on(in);
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundNegateArrayImpl, GNegateArrayImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
|
std::vector<double> in_v = {1, 5, -2, -10, 3};
|
|
std::vector<double> out_v;
|
|
std::vector<double> ref_v;
|
|
ade::util::transform(in_v, std::back_inserter(ref_v), std::negate<double>());
|
|
|
|
comp.apply(cv::gin(in_v), cv::gout(out_v), cv::compile_args(full_pkg));
|
|
|
|
EXPECT_EQ(out_v, ref_v);
|
|
}
|
|
|
|
TEST(GCompoundKernel, RightGArrayHandle)
|
|
{
|
|
cv::GMat in[2];
|
|
GDoubleArray a;
|
|
cv::GMat out = GCompoundGMatGArrayGMat::on(in[0], a, in[1]);
|
|
const auto custom_pkg = cv::gapi::kernels<GCompoundGMatGArrayGMatImpl, SetDiagKernelImpl>();
|
|
const auto full_pkg = cv::gapi::combine(custom_pkg, cv::gapi::core::cpu::kernels());
|
|
cv::GComputation comp(cv::GIn(in[0], a, in[1]), cv::GOut(out));
|
|
std::vector<double> in_v(3, 1.0);
|
|
cv::Mat in_mat1 = cv::Mat::eye(cv::Size(3, 3), CV_8UC1),
|
|
in_mat2 = cv::Mat::eye(cv::Size(3, 3), CV_8UC1),
|
|
out_mat;
|
|
cv::Mat ref_mat= in_mat1 + in_mat2;
|
|
setDiag(ref_mat, in_v);
|
|
|
|
comp.apply(cv::gin(in_mat1, in_v, in_mat2), cv::gout(out_mat), cv::compile_args(full_pkg));
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
|
|
}
|
|
|
|
TEST(GCompoundKernel, ToInterleavedToPlanar)
|
|
{
|
|
cv::GMatP in;
|
|
cv::GMatP out = GCompoundToInterleavedToPlanar::on(in);
|
|
const auto pkg = cv::gapi::kernels<GCompoundToInterleavedToPlanarImpl,
|
|
GToInterleavedImpl,
|
|
GToPlanarImpl>();
|
|
|
|
cv::GComputation comp(cv::GIn(in), cv::GOut(out));
|
|
|
|
constexpr int numPlanes = 3;
|
|
cv::Mat in_mat(cv::Size(15, 15), CV_8UC1),
|
|
out_mat,
|
|
ref_mat;
|
|
|
|
cv::randu(in_mat, 0, 255);
|
|
ref_mat = in_mat;
|
|
|
|
comp.compile(cv::descr_of(in_mat).asPlanar(numPlanes), cv::compile_args(pkg))
|
|
(cv::gin(in_mat), cv::gout(out_mat));
|
|
|
|
EXPECT_EQ(0, cvtest::norm(out_mat, ref_mat, NORM_INF));
|
|
|
|
}
|
|
} // opencv_test
|