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

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

Log: 切换后端至PaddleOCR-NCNN，切换工程为CMake
Change-Id: I4d5d2c5d37505a4a24b389b1a4c5d12f17bfa38c

3rdparty/opencv-4.5.4/modules/photo/perf/opencl/perf_denoising.cpp

@@ -0,0 +1,97 @@
+// 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) 2014, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+#include "../perf_precomp.hpp"
+#include "opencv2/ts/ocl_perf.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace opencv_test {
+namespace ocl {
+
+OCL_PERF_TEST(Photo, DenoisingGrayscale)
+{
+    Mat _original = imread(getDataPath("cv/denoising/lena_noised_gaussian_sigma=10.png"), IMREAD_GRAYSCALE);
+    ASSERT_FALSE(_original.empty()) << "Could not load input image";
+
+    UMat result(_original.size(), _original.type()), original;
+    _original.copyTo(original);
+
+    declare.in(original).out(result).iterations(10);
+
+    OCL_TEST_CYCLE()
+            cv::fastNlMeansDenoising(original, result, 10);
+
+    SANITY_CHECK(result, 1);
+}
+
+OCL_PERF_TEST(Photo, DenoisingColored)
+{
+    Mat _original = imread(getDataPath("cv/denoising/lena_noised_gaussian_sigma=10.png"));
+    ASSERT_FALSE(_original.empty()) << "Could not load input image";
+
+    UMat result(_original.size(), _original.type()), original;
+    _original.copyTo(original);
+
+    declare.in(original).out(result).iterations(10);
+
+    OCL_TEST_CYCLE()
+            cv::fastNlMeansDenoisingColored(original, result, 10, 10);
+
+    SANITY_CHECK(result, 2);
+}
+
+OCL_PERF_TEST(Photo, DISABLED_DenoisingGrayscaleMulti)
+{
+    const int imgs_count = 3;
+
+    vector<UMat> original(imgs_count);
+    Mat tmp;
+    for (int i = 0; i < imgs_count; i++)
+    {
+        string original_path = format("cv/denoising/lena_noised_gaussian_sigma=20_multi_%d.png", i);
+        tmp = imread(getDataPath(original_path), IMREAD_GRAYSCALE);
+        ASSERT_FALSE(tmp.empty()) << "Could not load input image " << original_path;
+        tmp.copyTo(original[i]);
+        declare.in(original[i]);
+    }
+    UMat result(tmp.size(), tmp.type());
+    declare.out(result).iterations(10);
+
+    OCL_TEST_CYCLE()
+            cv::fastNlMeansDenoisingMulti(original, result, imgs_count / 2, imgs_count, 15);
+
+    SANITY_CHECK(result);
+}
+
+OCL_PERF_TEST(Photo, DISABLED_DenoisingColoredMulti)
+{
+    const int imgs_count = 3;
+
+    vector<UMat> original(imgs_count);
+    Mat tmp;
+    for (int i = 0; i < imgs_count; i++)
+    {
+        string original_path = format("cv/denoising/lena_noised_gaussian_sigma=20_multi_%d.png", i);
+        tmp = imread(getDataPath(original_path), IMREAD_COLOR);
+        ASSERT_FALSE(tmp.empty()) << "Could not load input image " << original_path;
+
+        tmp.copyTo(original[i]);
+        declare.in(original[i]);
+    }
+    UMat result(tmp.size(), tmp.type());
+    declare.out(result).iterations(10);
+
+    OCL_TEST_CYCLE()
+            cv::fastNlMeansDenoisingColoredMulti(original, result, imgs_count / 2, imgs_count, 10, 15);
+
+    SANITY_CHECK(result);
+}
+
+} } // namespace opencv_test::ocl
+
+#endif // HAVE_OPENCL

3rdparty/opencv-4.5.4/modules/photo/perf/perf_cuda.cpp

@@ -0,0 +1,189 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+#include "opencv2/photo/cuda.hpp"
+#include "opencv2/ts/cuda_perf.hpp"
+
+#include "opencv2/opencv_modules.hpp"
+
+#if defined (HAVE_CUDA) && defined(HAVE_OPENCV_CUDAARITHM) && defined(HAVE_OPENCV_CUDAIMGPROC)
+
+namespace opencv_test { namespace {
+using namespace perf;
+
+#define CUDA_DENOISING_IMAGE_SIZES testing::Values(perf::szVGA, perf::sz720p)
+
+//////////////////////////////////////////////////////////////////////
+// nonLocalMeans
+
+DEF_PARAM_TEST(Sz_Depth_Cn_WinSz_BlockSz, cv::Size, MatDepth, MatCn, int, int);
+
+PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, CUDA_NonLocalMeans,
+            Combine(CUDA_DENOISING_IMAGE_SIZES,
+                    Values<MatDepth>(CV_8U),
+                    CUDA_CHANNELS_1_3,
+                    Values(21),
+                    Values(5)))
+{
+    declare.time(600.0);
+
+    const cv::Size size = GET_PARAM(0);
+    const int depth = GET_PARAM(1);
+    const int channels = GET_PARAM(2);
+    const int search_widow_size = GET_PARAM(3);
+    const int block_size = GET_PARAM(4);
+
+    const float h = 10;
+    const int borderMode = cv::BORDER_REFLECT101;
+
+    const int type = CV_MAKE_TYPE(depth, channels);
+
+    cv::Mat src(size, type);
+    declare.in(src, WARMUP_RNG);
+
+    if (PERF_RUN_CUDA())
+    {
+        const cv::cuda::GpuMat d_src(src);
+        cv::cuda::GpuMat dst;
+
+        TEST_CYCLE() cv::cuda::nonLocalMeans(d_src, dst, h, search_widow_size, block_size, borderMode);
+
+        CUDA_SANITY_CHECK(dst);
+    }
+    else
+    {
+        FAIL_NO_CPU();
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////
+// fastNonLocalMeans
+
+DEF_PARAM_TEST(Sz_Depth_Cn_WinSz_BlockSz, cv::Size, MatDepth, MatCn, int, int);
+
+PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, CUDA_FastNonLocalMeans,
+            Combine(CUDA_DENOISING_IMAGE_SIZES,
+                    Values<MatDepth>(CV_8U),
+                    CUDA_CHANNELS_1_3,
+                    Values(21),
+                    Values(7)))
+{
+    declare.time(60.0);
+
+    const cv::Size size = GET_PARAM(0);
+    const int depth = GET_PARAM(1);
+    const int search_widow_size = GET_PARAM(2);
+    const int block_size = GET_PARAM(3);
+
+    const float h = 10;
+    const int type = CV_MAKE_TYPE(depth, 1);
+
+    cv::Mat src(size, type);
+    declare.in(src, WARMUP_RNG);
+
+    if (PERF_RUN_CUDA())
+    {
+        const cv::cuda::GpuMat d_src(src);
+        cv::cuda::GpuMat dst;
+
+        TEST_CYCLE() cv::cuda::fastNlMeansDenoising(d_src, dst, h, search_widow_size, block_size);
+
+        CUDA_SANITY_CHECK(dst);
+    }
+    else
+    {
+        cv::Mat dst;
+
+        TEST_CYCLE() cv::fastNlMeansDenoising(src, dst, h, block_size, search_widow_size);
+
+        CPU_SANITY_CHECK(dst);
+    }
+}
+
+//////////////////////////////////////////////////////////////////////
+// fastNonLocalMeans (colored)
+
+DEF_PARAM_TEST(Sz_Depth_WinSz_BlockSz, cv::Size, MatDepth, int, int);
+
+PERF_TEST_P(Sz_Depth_WinSz_BlockSz, CUDA_FastNonLocalMeansColored,
+            Combine(CUDA_DENOISING_IMAGE_SIZES,
+                    Values<MatDepth>(CV_8U),
+                    Values(21),
+                    Values(7)))
+{
+    declare.time(60.0);
+
+    const cv::Size size = GET_PARAM(0);
+    const int depth = GET_PARAM(1);
+    const int search_widow_size = GET_PARAM(2);
+    const int block_size = GET_PARAM(3);
+
+    const float h = 10;
+    const int type = CV_MAKE_TYPE(depth, 3);
+
+    cv::Mat src(size, type);
+    declare.in(src, WARMUP_RNG);
+
+    if (PERF_RUN_CUDA())
+    {
+        const cv::cuda::GpuMat d_src(src);
+        cv::cuda::GpuMat dst;
+
+        TEST_CYCLE() cv::cuda::fastNlMeansDenoisingColored(d_src, dst, h, h, search_widow_size, block_size);
+
+        CUDA_SANITY_CHECK(dst);
+    }
+    else
+    {
+        cv::Mat dst;
+
+        TEST_CYCLE() cv::fastNlMeansDenoisingColored(src, dst, h, h, block_size, search_widow_size);
+
+        CPU_SANITY_CHECK(dst);
+    }
+}
+
+}} // namespace
+#endif

3rdparty/opencv-4.5.4/modules/photo/perf/perf_inpaint.cpp

@@ -0,0 +1,37 @@
+#include "perf_precomp.hpp"
+
+namespace opencv_test
+{
+
+CV_ENUM(InpaintingMethod, INPAINT_NS, INPAINT_TELEA)
+typedef tuple<Size, InpaintingMethod> InpaintArea_InpaintingMethod_t;
+typedef perf::TestBaseWithParam<InpaintArea_InpaintingMethod_t> InpaintArea_InpaintingMethod;
+
+
+PERF_TEST_P(InpaintArea_InpaintingMethod, inpaint,
+            testing::Combine(
+                testing::Values(::perf::szSmall24, ::perf::szSmall32, ::perf::szSmall64),
+                InpaintingMethod::all()
+                )
+            )
+{
+    Mat src = imread(getDataPath("gpu/hog/road.png"));
+
+    Size sz = get<0>(GetParam());
+    int inpaintingMethod = get<1>(GetParam());
+
+    Mat mask(src.size(), CV_8UC1, Scalar(0));
+    Mat result(src.size(), src.type());
+
+    Rect inpaintArea(src.cols/3, src.rows/3, sz.width, sz.height);
+    mask(inpaintArea).setTo(255);
+
+    declare.in(src, mask).out(result).time(120);
+
+    TEST_CYCLE() inpaint(src, mask, result, 10.0, inpaintingMethod);
+
+    Mat inpaintedArea = result(inpaintArea);
+    SANITY_CHECK(inpaintedArea);
+}
+
+} // namespace

3rdparty/opencv-4.5.4/modules/photo/perf/perf_main.cpp

@@ -0,0 +1,15 @@
+#include "perf_precomp.hpp"
+#include "opencv2/ts/cuda_perf.hpp"
+
+static const char * impls[] = {
+#ifdef HAVE_CUDA
+    "cuda",
+#endif
+    "plain"
+};
+
+#if defined(HAVE_HPX)
+    #include <hpx/hpx_main.hpp>
+#endif
+
+CV_PERF_TEST_MAIN_WITH_IMPLS(photo, impls, perf::printCudaInfo())

3rdparty/opencv-4.5.4/modules/photo/perf/perf_precomp.hpp

@@ -0,0 +1,7 @@
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/photo.hpp"
+
+#endif