blumia/deepin-ocr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: 切换后端至PaddleOCR-NCNN，切换工程为CMake

Browse Source 
1.项目后端整体迁移至PaddleOCR-NCNN算法，已通过基本的兼容性测试
2.工程改为使用CMake组织，后续为了更好地兼容第三方库，不再提供QMake工程
3.重整权利声明文件，重整代码工程，确保最小化侵权风险

Log: 切换后端至PaddleOCR-NCNN，切换工程为CMake
Change-Id: I4d5d2c5d37505a4a24b389b1a4c5d12f17bfa38c
This commit is contained in:
wangzhengyang
2022-05-10 09:54:44 +08:00
parent ecdd171c6f
commit 718c41634f
10018 changed files with 3593797 additions and 186748 deletions
Download Patch File Download Diff File Expand all files Collapse all files

404
3rdparty/opencv-4.5.4/modules/gapi/test/gapi_desc_tests.cpp vendored Normal file
View File

@ -0,0 +1,404 @@
// 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
#include "test_precomp.hpp"
#include <opencv2/gapi/cpu/gcpukernel.hpp>
namespace opencv_test
{
namespace
{
G_TYPED_KERNEL(KTest, <cv::GScalar(cv::GScalar)>, "org.opencv.test.scalar_kernel") {
static cv::GScalarDesc outMeta(cv::GScalarDesc in) { return in; }
};
GAPI_OCV_KERNEL(GOCVScalarTest, KTest)
{
static void run(const cv::Scalar &in, cv::Scalar &out) { out = in+cv::Scalar(1); }
};
}
TEST(GAPI_MetaDesc, MatDescOneCh)
{
cv::Mat mat(240, 320, CV_8U);
const auto desc = cv::descr_of(mat);
EXPECT_EQ(CV_8U, desc.depth);
EXPECT_EQ(1, desc.chan);
EXPECT_EQ(320, desc.size.width);
EXPECT_EQ(240, desc.size.height);
EXPECT_FALSE(desc.isND());
}
TEST(GAPI_MetaDesc, MatDescThreeCh)
{
cv::Mat mat(480, 640, CV_8UC3);
const auto desc = cv::descr_of(mat);
EXPECT_EQ(CV_8U, desc.depth);
EXPECT_EQ(3, desc.chan);
EXPECT_EQ(640, desc.size.width);
EXPECT_EQ(480, desc.size.height);
EXPECT_FALSE(desc.isND());
}
TEST(GAPI_MetaDesc, MatDescND)
{
std::vector<int> dims = {1,3,299,299};
cv::Mat m(dims, CV_32F);
const auto desc = cv::descr_of(m);
EXPECT_EQ(CV_32F, desc.depth);
EXPECT_EQ(-1, desc.chan);
EXPECT_EQ(1, desc.dims[0]);
EXPECT_EQ(3, desc.dims[1]);
EXPECT_EQ(299, desc.dims[2]);
EXPECT_EQ(299, desc.dims[3]);
EXPECT_TRUE(desc.isND());
}
TEST(GAPI_MetaDesc, VecMatDesc)
{
std::vector<cv::Mat> vec1 = {
cv::Mat(240, 320, CV_8U)};
const auto desc1 = cv::descrs_of(vec1);
EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc1[0]));
std::vector<cv::UMat> vec2 = {
cv::UMat(480, 640, CV_8UC3)};
const auto desc2 = cv::descrs_of(vec2);
EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc2[0]));
}
TEST(GAPI_MetaDesc, CanDescribe)
{
constexpr int w = 15;
constexpr int h = 7;
cv::Mat m0(h, w, CV_8UC3);
cv::GMatDesc md0{CV_8U,3,{w,h},false};
cv::Mat m1(h*3, w, CV_8UC1);
cv::GMatDesc md10{CV_8U,3,{w,h},true};
cv::GMatDesc md11{CV_8U,1,{w,h*3},false};
EXPECT_TRUE (md0 .canDescribe(m0));
EXPECT_FALSE(md0 .canDescribe(m1));
EXPECT_TRUE (md10.canDescribe(m1));
EXPECT_TRUE (md11.canDescribe(m1));
}
TEST(GAPI_MetaDesc, OwnMatDescOneCh)
{
cv::gapi::own::Mat mat(240, 320, CV_8U, nullptr);
const auto desc = cv::gapi::own::descr_of(mat);
EXPECT_EQ(CV_8U, desc.depth);
EXPECT_EQ(1, desc.chan);
EXPECT_EQ(320, desc.size.width);
EXPECT_EQ(240, desc.size.height);
EXPECT_FALSE(desc.isND());
}
TEST(GAPI_MetaDesc, OwnMatDescThreeCh)
{
cv::gapi::own::Mat mat(480, 640, CV_8UC3, nullptr);
const auto desc = cv::gapi::own::descr_of(mat);
EXPECT_EQ(CV_8U, desc.depth);
EXPECT_EQ(3, desc.chan);
EXPECT_EQ(640, desc.size.width);
EXPECT_EQ(480, desc.size.height);
EXPECT_FALSE(desc.isND());
}
TEST(GAPI_MetaDesc, OwnMatDescND)
{
std::vector<int> dims = {1,3,224,224};
cv::gapi::own::Mat m(dims, CV_32F, nullptr);
const auto desc = cv::gapi::own::descr_of(m);
EXPECT_EQ(CV_32F, desc.depth);
EXPECT_EQ(-1, desc.chan);
EXPECT_EQ(1, desc.dims[0]);
EXPECT_EQ(3, desc.dims[1]);
EXPECT_EQ(224, desc.dims[2]);
EXPECT_EQ(224, desc.dims[3]);
EXPECT_TRUE(desc.isND());
}
TEST(GAPI_MetaDesc, VecOwnMatDesc)
{
std::vector<cv::gapi::own::Mat> vec = {
cv::gapi::own::Mat(240, 320, CV_8U, nullptr),
cv::gapi::own::Mat(480, 640, CV_8UC3, nullptr)};
const auto desc = cv::gapi::own::descrs_of(vec);
EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc[0]));
EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc[1]));
}
TEST(GAPI_MetaDesc, AdlVecOwnMatDesc)
{
std::vector<cv::gapi::own::Mat> vec = {
cv::gapi::own::Mat(240, 320, CV_8U, nullptr),
cv::gapi::own::Mat(480, 640, CV_8UC3, nullptr)};
const auto desc = descrs_of(vec);
EXPECT_EQ((GMatDesc{CV_8U, 1, {320, 240}}), get<GMatDesc>(desc[0]));
EXPECT_EQ((GMatDesc{CV_8U, 3, {640, 480}}), get<GMatDesc>(desc[1]));
}
TEST(GAPI_MetaDesc, Compare_Equal_MatDesc)
{
const auto desc1 = cv::GMatDesc{CV_8U, 1, {64, 64}};
const auto desc2 = cv::GMatDesc{CV_8U, 1, {64, 64}};
EXPECT_TRUE(desc1 == desc2);
}
TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc)
{
const auto desc1 = cv::GMatDesc{CV_8U, 1, {64, 64}};
const auto desc2 = cv::GMatDesc{CV_32F, 1, {64, 64}};
EXPECT_TRUE(desc1 != desc2);
}
TEST(GAPI_MetaDesc, Compare_Equal_MatDesc_ND)
{
const auto desc1 = cv::GMatDesc{CV_8U, {1,3,224,224}};
const auto desc2 = cv::GMatDesc{CV_8U, {1,3,224,224}};
EXPECT_TRUE(desc1 == desc2);
}
TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc_ND_1)
{
const auto desc1 = cv::GMatDesc{CV_8U, {1,1000}};
const auto desc2 = cv::GMatDesc{CV_32F, {1,1000}};
EXPECT_TRUE(desc1 != desc2);
}
TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc_ND_2)
{
const auto desc1 = cv::GMatDesc{CV_8U, {1,1000}};
const auto desc2 = cv::GMatDesc{CV_8U, {1,1400}};
EXPECT_TRUE(desc1 != desc2);
}
TEST(GAPI_MetaDesc, Compare_Not_Equal_MatDesc_ND_3)
{
const auto desc1 = cv::GMatDesc{CV_8U, {1,1000}};
const auto desc2 = cv::GMatDesc{CV_8U, 1, {32,32}};
EXPECT_TRUE(desc1 != desc2);
}
TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_1)
{
cv::GMat in;
cv::GComputation cc(in, in+in);
const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
EXPECT_NO_THROW(cc.compile(desc1));
EXPECT_NO_THROW(cc.compile(desc2));
// FIXME: custom exception type?
// It is worth checking if compilation fails with different number
// of meta parameters
EXPECT_THROW(cc.compile(desc1, desc1), std::logic_error);
EXPECT_THROW(cc.compile(desc1, desc2, desc2), std::logic_error);
}
TEST(GAPI_MetaDesc, Compile_MatchMetaNumber_2)
{
cv::GMat a, b;
cv::GComputation cc(cv::GIn(a, b), cv::GOut(a+b));
const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
EXPECT_NO_THROW(cc.compile(desc1, desc1));
const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
EXPECT_NO_THROW(cc.compile(desc2, desc2));
// FIXME: custom exception type?
EXPECT_THROW(cc.compile(desc1), std::logic_error);
EXPECT_THROW(cc.compile(desc2), std::logic_error);
EXPECT_THROW(cc.compile(desc2, desc2, desc2), std::logic_error);
}
TEST(GAPI_MetaDesc, Compile_MatchMetaType_Mat)
{
cv::GMat in;
cv::GComputation cc(in, in+in);
EXPECT_NO_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{64,64}}));
// FIXME: custom exception type?
EXPECT_THROW(cc.compile(cv::empty_scalar_desc()), std::logic_error);
}
TEST(GAPI_MetaDesc, Compile_MatchMetaType_Scalar)
{
cv::GScalar in;
cv::GComputation cc(cv::GIn(in), cv::GOut(KTest::on(in)));
const auto desc1 = cv::descr_of(cv::Scalar(128));
const auto desc2 = cv::GMatDesc{CV_8U,1,{64,64}};
const auto pkg = cv::gapi::kernels<GOCVScalarTest>();
EXPECT_NO_THROW(cc.compile(desc1, cv::compile_args(pkg)));
// FIXME: custom exception type?
EXPECT_THROW(cc.compile(desc2, cv::compile_args(pkg)), std::logic_error);
}
TEST(GAPI_MetaDesc, Compile_MatchMetaType_Mixed)
{
cv::GMat a;
cv::GScalar v;
cv::GComputation cc(cv::GIn(a, v), cv::GOut(cv::gapi::addC(a, v)));
const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
const auto desc2 = cv::descr_of(cv::Scalar(4));
EXPECT_NO_THROW(cc.compile(desc1, desc2));
// FIXME: custom exception type(s)?
EXPECT_THROW(cc.compile(desc1), std::logic_error);
EXPECT_THROW(cc.compile(desc2), std::logic_error);
EXPECT_THROW(cc.compile(desc2, desc1), std::logic_error);
EXPECT_THROW(cc.compile(desc1, desc1, desc1), std::logic_error);
EXPECT_THROW(cc.compile(desc1, desc2, desc1), std::logic_error);
}
TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaNumber_1)
{
cv::GComputationT<cv::GMat(cv::GMat)> cc([](cv::GMat in)
{
return in+in;
});
const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
EXPECT_NO_THROW(cc.compile(desc1));
EXPECT_NO_THROW(cc.compile(desc2));
}
TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaNumber_2)
{
cv::GComputationT<cv::GMat(cv::GMat,cv::GMat)> cc([](cv::GMat a, cv::GMat b)
{
return a + b;
});
const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
EXPECT_NO_THROW(cc.compile(desc1, desc1));
const auto desc2 = cv::GMatDesc{CV_32F,1,{128,128}};
EXPECT_NO_THROW(cc.compile(desc2, desc2));
}
TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Mat)
{
cv::GComputationT<cv::GMat(cv::GMat)> cc([](cv::GMat in)
{
return in+in;
});
EXPECT_NO_THROW(cc.compile(cv::GMatDesc{CV_8U,1,{64,64}}));
}
TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Scalar)
{
cv::GComputationT<cv::GScalar(cv::GScalar)> cc([](cv::GScalar in)
{
return KTest::on(in);
});
const auto desc1 = cv::descr_of(cv::Scalar(128));
const auto pkg = cv::gapi::kernels<GOCVScalarTest>();
// EXPECT_NO_THROW(cc.compile(desc1, cv::compile_args(pkg)));
cc.compile(desc1, cv::compile_args(pkg));
}
TEST(GAPI_MetaDesc, Typed_Compile_MatchMetaType_Mixed)
{
cv::GComputationT<cv::GMat(cv::GMat,cv::GScalar)> cc([](cv::GMat a, cv::GScalar v)
{
return cv::gapi::addC(a, v);
});
const auto desc1 = cv::GMatDesc{CV_8U,1,{64,64}};
const auto desc2 = cv::descr_of(cv::Scalar(4));
EXPECT_NO_THROW(cc.compile(desc1, desc2));
}
TEST(GAPI_MetaDesc, Compare_Planar)
{
const auto desc0 = cv::GMatDesc{CV_8U,3,{32,32},false};
const auto desc1 = cv::GMatDesc{CV_8U,3,{32,32},false};
const auto desc2 = cv::GMatDesc{CV_8U,3,{32,32},true};
const auto desc3 = cv::GMatDesc{CV_8U,3,{64,64},true};
EXPECT_TRUE(desc0 == desc1);
EXPECT_TRUE(desc1 != desc2);
EXPECT_TRUE(desc1 != desc3);
EXPECT_TRUE(desc2 != desc3);
}
TEST(GAPI_MetaDesc, Sanity_asPlanar)
{
constexpr int w = 32;
constexpr int h = 16;
const auto desc1 = cv::GMatDesc{CV_8U,3,{w,h},false};
const auto desc2 = cv::GMatDesc{CV_8U,3,{w,h},true};
EXPECT_NO_THROW(desc1.asPlanar());
EXPECT_NO_THROW(desc2.asInterleaved());
EXPECT_ANY_THROW(desc1.asInterleaved());
EXPECT_ANY_THROW(desc2.asPlanar());
}
TEST(GAPI_MetaDesc, Compare_asPlanar)
{
constexpr int w = 32;
constexpr int h = 64;
const auto desc0 = cv::GMatDesc{CV_8U,3,{w,h},false};
const auto desc1 = cv::GMatDesc{CV_8U,3,{w,h},true};
EXPECT_TRUE(desc0.asPlanar() == desc1);
EXPECT_TRUE(desc1.asInterleaved() == desc0);
}
TEST(GAPI_MetaDesc, Compare_asPlanarTransform)
{
constexpr int w = 64;
constexpr int h = 32;
const auto desc0 = cv::GMatDesc{CV_8U,3,{w,h},true};
const auto desc1 = cv::GMatDesc{CV_8U,1,{w,h*3},false};
EXPECT_ANY_THROW(desc0.asPlanar(3));
EXPECT_NO_THROW(desc1.asPlanar(3));
EXPECT_TRUE(desc1.asPlanar(3) == desc0);
}
} // namespace opencv_test