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

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

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

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp

@@ -0,0 +1,51 @@
+/**
+ * @function EqualizeHist_Demo.cpp
+ * @brief Demo code for equalizeHist function
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [Load image]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    //! [Load image]
+
+    //! [Convert to grayscale]
+    cvtColor( src, src, COLOR_BGR2GRAY );
+    //! [Convert to grayscale]
+
+    //! [Apply Histogram Equalization]
+    Mat dst;
+    equalizeHist( src, dst );
+    //! [Apply Histogram Equalization]
+
+    //! [Display results]
+    imshow( "Source image", src );
+    imshow( "Equalized Image", dst );
+    //! [Display results]
+
+    //! [Wait until user exits the program]
+    waitKey();
+    //! [Wait until user exits the program]
+
+    return 0;
+
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp

@@ -0,0 +1,137 @@
+/**
+ * @file MatchTemplate_Demo.cpp
+ * @brief Sample code to use the function MatchTemplate
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+//! [declare]
+/// Global Variables
+bool use_mask;
+Mat img; Mat templ; Mat mask; Mat result;
+const char* image_window = "Source Image";
+const char* result_window = "Result window";
+
+int match_method;
+int max_Trackbar = 5;
+//! [declare]
+
+/// Function Headers
+void MatchingMethod( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  if (argc < 3)
+  {
+    cout << "Not enough parameters" << endl;
+    cout << "Usage:\n" << argv[0] << " <image_name> <template_name> [<mask_name>]" << endl;
+    return -1;
+  }
+
+  //! [load_image]
+  /// Load image and template
+  img = imread( argv[1], IMREAD_COLOR );
+  templ = imread( argv[2], IMREAD_COLOR );
+
+  if(argc > 3) {
+    use_mask = true;
+    mask = imread( argv[3], IMREAD_COLOR );
+  }
+
+  if(img.empty() || templ.empty() || (use_mask && mask.empty()))
+  {
+    cout << "Can't read one of the images" << endl;
+    return EXIT_FAILURE;
+  }
+  //! [load_image]
+
+  //! [create_windows]
+  /// Create windows
+  namedWindow( image_window, WINDOW_AUTOSIZE );
+  namedWindow( result_window, WINDOW_AUTOSIZE );
+  //! [create_windows]
+
+  //! [create_trackbar]
+  /// Create Trackbar
+  const char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
+  createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod );
+  //! [create_trackbar]
+
+  MatchingMethod( 0, 0 );
+
+  //! [wait_key]
+  waitKey(0);
+  return EXIT_SUCCESS;
+  //! [wait_key]
+}
+
+/**
+ * @function MatchingMethod
+ * @brief Trackbar callback
+ */
+void MatchingMethod( int, void* )
+{
+  //! [copy_source]
+  /// Source image to display
+  Mat img_display;
+  img.copyTo( img_display );
+  //! [copy_source]
+
+  //! [create_result_matrix]
+  /// Create the result matrix
+  int result_cols = img.cols - templ.cols + 1;
+  int result_rows = img.rows - templ.rows + 1;
+
+  result.create( result_rows, result_cols, CV_32FC1 );
+  //! [create_result_matrix]
+
+  //! [match_template]
+  /// Do the Matching and Normalize
+  bool method_accepts_mask = (TM_SQDIFF == match_method || match_method == TM_CCORR_NORMED);
+  if (use_mask && method_accepts_mask)
+    { matchTemplate( img, templ, result, match_method, mask); }
+  else
+    { matchTemplate( img, templ, result, match_method); }
+  //! [match_template]
+
+  //! [normalize]
+  normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );
+  //! [normalize]
+
+  //! [best_match]
+  /// Localizing the best match with minMaxLoc
+  double minVal; double maxVal; Point minLoc; Point maxLoc;
+  Point matchLoc;
+
+  minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
+  //! [best_match]
+
+  //! [match_loc]
+  /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values. For all the other methods, the higher the better
+  if( match_method  == TM_SQDIFF || match_method == TM_SQDIFF_NORMED )
+    { matchLoc = minLoc; }
+  else
+    { matchLoc = maxLoc; }
+  //! [match_loc]
+
+  //! [imshow]
+  /// Show me what you got
+  rectangle( img_display, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 );
+  rectangle( result, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 );
+
+  imshow( image_window, img_display );
+  imshow( result_window, result );
+  //! [imshow]
+
+  return;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp

@@ -0,0 +1,106 @@
+/**
+ * @file BackProject_Demo1.cpp
+ * @brief Sample code for backproject function usage
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global Variables
+Mat hue;
+int bins = 25;
+
+/// Function Headers
+void Hist_and_Backproj(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char* argv[] )
+{
+    //! [Read the image]
+    CommandLineParser parser( argc, argv, "{@input |  | input image}" );
+    Mat src = imread( parser.get<String>( "@input" ) );
+    if( src.empty() )
+    {
+        cout << "Could not open or find the image!\n" << endl;
+        cout << "Usage: " << argv[0] << " <Input image>" << endl;
+        return -1;
+    }
+    //! [Read the image]
+
+    //! [Transform it to HSV]
+    Mat hsv;
+    cvtColor( src, hsv, COLOR_BGR2HSV );
+    //! [Transform it to HSV]
+
+    //! [Use only the Hue value]
+    hue.create(hsv.size(), hsv.depth());
+    int ch[] = { 0, 0 };
+    mixChannels( &hsv, 1, &hue, 1, ch, 1 );
+    //! [Use only the Hue value]
+
+    //! [Create Trackbar to enter the number of bins]
+    const char* window_image = "Source image";
+    namedWindow( window_image );
+    createTrackbar("* Hue  bins: ", window_image, &bins, 180, Hist_and_Backproj );
+    Hist_and_Backproj(0, 0);
+    //! [Create Trackbar to enter the number of bins]
+
+    //! [Show the image]
+    imshow( window_image, src );
+    // Wait until user exits the program
+    waitKey();
+    //! [Show the image]
+
+    return 0;
+}
+
+/**
+ * @function Hist_and_Backproj
+ * @brief Callback to Trackbar
+ */
+void Hist_and_Backproj(int, void* )
+{
+    //! [initialize]
+    int histSize = MAX( bins, 2 );
+    float hue_range[] = { 0, 180 };
+    const float* ranges[] = { hue_range };
+    //! [initialize]
+
+    //! [Get the Histogram and normalize it]
+    Mat hist;
+    calcHist( &hue, 1, 0, Mat(), hist, 1, &histSize, ranges, true, false );
+    normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+    //! [Get the Histogram and normalize it]
+
+    //! [Get Backprojection]
+    Mat backproj;
+    calcBackProject( &hue, 1, 0, hist, backproj, ranges, 1, true );
+    //! [Get Backprojection]
+
+    //! [Draw the backproj]
+    imshow( "BackProj", backproj );
+    //! [Draw the backproj]
+
+    //! [Draw the histogram]
+    int w = 400, h = 400;
+    int bin_w = cvRound( (double) w / histSize );
+    Mat histImg = Mat::zeros( h, w, CV_8UC3 );
+
+    for (int i = 0; i < bins; i++)
+    {
+        rectangle( histImg, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( hist.at<float>(i)*h/255.0 ) ),
+                   Scalar( 0, 0, 255 ), FILLED );
+    }
+
+    imshow( "Histogram", histImg );
+    //! [Draw the histogram]
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp

@@ -0,0 +1,105 @@
+/**
+ * @file BackProject_Demo2.cpp
+ * @brief Sample code for backproject function usage ( a bit more elaborated )
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global Variables
+Mat src, hsv, mask;
+
+int low = 20, up = 20;
+const char* window_image = "Source image";
+
+/// Function Headers
+void Hist_and_Backproj( );
+void pickPoint (int event, int x, int y, int, void* );
+
+/**
+ * @function main
+ */
+int main( int, char** argv )
+{
+    /// Read the image
+    src = imread( argv[1] );
+
+    /// Transform it to HSV
+    cvtColor( src, hsv, COLOR_BGR2HSV );
+
+    /// Show the image
+    namedWindow( window_image );
+    imshow( window_image, src );
+
+    /// Set Trackbars for floodfill thresholds
+    createTrackbar( "Low thresh", window_image, &low, 255, 0 );
+    createTrackbar( "High thresh", window_image, &up, 255, 0 );
+    /// Set a Mouse Callback
+    setMouseCallback( window_image, pickPoint, 0 );
+
+    waitKey();
+    return 0;
+}
+
+/**
+ * @function pickPoint
+ */
+void pickPoint (int event, int x, int y, int, void* )
+{
+    if( event != EVENT_LBUTTONDOWN )
+    {
+        return;
+    }
+
+    // Fill and get the mask
+    Point seed = Point( x, y );
+
+    int newMaskVal = 255;
+    Scalar newVal = Scalar( 120, 120, 120 );
+
+    int connectivity = 8;
+    int flags = connectivity + (newMaskVal << 8 ) + FLOODFILL_FIXED_RANGE + FLOODFILL_MASK_ONLY;
+
+    Mat mask2 = Mat::zeros( src.rows + 2, src.cols + 2, CV_8U );
+    floodFill( src, mask2, seed, newVal, 0, Scalar( low, low, low ), Scalar( up, up, up), flags );
+    mask = mask2( Range( 1, mask2.rows - 1 ), Range( 1, mask2.cols - 1 ) );
+
+    imshow( "Mask", mask );
+
+    Hist_and_Backproj( );
+}
+
+/**
+ * @function Hist_and_Backproj
+ */
+void Hist_and_Backproj( )
+{
+    Mat hist;
+    int h_bins = 30; int s_bins = 32;
+    int histSize[] = { h_bins, s_bins };
+
+    float h_range[] = { 0, 180 };
+    float s_range[] = { 0, 256 };
+    const float* ranges[] = { h_range, s_range };
+
+    int channels[] = { 0, 1 };
+
+    /// Get the Histogram and normalize it
+    calcHist( &hsv, 1, channels, mask, hist, 2, histSize, ranges, true, false );
+
+    normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+
+    /// Get Backprojection
+    Mat backproj;
+    calcBackProject( &hsv, 1, channels, hist, backproj, ranges, 1, true );
+
+    /// Draw the backproj
+    imshow( "BackProj", backproj );
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp

@@ -0,0 +1,89 @@
+/**
+ * @function calcHist_Demo.cpp
+ * @brief Demo code to use the function calcHist
+ * @author
+ */
+
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main(int argc, char** argv)
+{
+    //! [Load image]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR );
+    if( src.empty() )
+    {
+        return EXIT_FAILURE;
+    }
+    //! [Load image]
+
+    //! [Separate the image in 3 places ( B, G and R )]
+    vector<Mat> bgr_planes;
+    split( src, bgr_planes );
+    //! [Separate the image in 3 places ( B, G and R )]
+
+    //! [Establish the number of bins]
+    int histSize = 256;
+    //! [Establish the number of bins]
+
+    //! [Set the ranges ( for B,G,R) )]
+    float range[] = { 0, 256 }; //the upper boundary is exclusive
+    const float* histRange[] = { range };
+    //! [Set the ranges ( for B,G,R) )]
+
+    //! [Set histogram param]
+    bool uniform = true, accumulate = false;
+    //! [Set histogram param]
+
+    //! [Compute the histograms]
+    Mat b_hist, g_hist, r_hist;
+    calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, histRange, uniform, accumulate );
+    calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, histRange, uniform, accumulate );
+    calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, histRange, uniform, accumulate );
+    //! [Compute the histograms]
+
+    //! [Draw the histograms for B, G and R]
+    int hist_w = 512, hist_h = 400;
+    int bin_w = cvRound( (double) hist_w/histSize );
+
+    Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );
+    //! [Draw the histograms for B, G and R]
+
+    //! [Normalize the result to ( 0, histImage.rows )]
+    normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    //! [Normalize the result to ( 0, histImage.rows )]
+
+    //! [Draw for each channel]
+    for( int i = 1; i < histSize; i++ )
+    {
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ),
+              Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
+              Scalar( 255, 0, 0), 2, 8, 0  );
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ),
+              Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
+              Scalar( 0, 255, 0), 2, 8, 0  );
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ),
+              Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
+              Scalar( 0, 0, 255), 2, 8, 0  );
+    }
+    //! [Draw for each channel]
+
+    //! [Display]
+    imshow("Source image", src );
+    imshow("calcHist Demo", histImage );
+    waitKey();
+    //! [Display]
+
+    return EXIT_SUCCESS;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp

@@ -0,0 +1,95 @@
+/**
+ * @file compareHist_Demo.cpp
+ * @brief Sample code to use the function compareHist
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+const char* keys =
+    "{ help  h| | Print help message. }"
+    "{ @input1 | | Path to input image 1. }"
+    "{ @input2 | | Path to input image 2. }"
+    "{ @input3 | | Path to input image 3. }";
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //! [Load three images with different environment settings]
+    CommandLineParser parser( argc, argv, keys );
+    Mat src_base = imread( parser.get<String>("input1") );
+    Mat src_test1 = imread( parser.get<String>("input2") );
+    Mat src_test2 = imread( parser.get<String>("input3") );
+    if( src_base.empty() || src_test1.empty() || src_test2.empty() )
+    {
+        cout << "Could not open or find the images!\n" << endl;
+        parser.printMessage();
+        return -1;
+    }
+    //! [Load three images with different environment settings]
+
+    //! [Convert to HSV]
+    Mat hsv_base, hsv_test1, hsv_test2;
+    cvtColor( src_base, hsv_base, COLOR_BGR2HSV );
+    cvtColor( src_test1, hsv_test1, COLOR_BGR2HSV );
+    cvtColor( src_test2, hsv_test2, COLOR_BGR2HSV );
+    //! [Convert to HSV]
+
+    //! [Convert to HSV half]
+    Mat hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows ), Range( 0, hsv_base.cols ) );
+    //! [Convert to HSV half]
+
+    //! [Using 50 bins for hue and 60 for saturation]
+    int h_bins = 50, s_bins = 60;
+    int histSize[] = { h_bins, s_bins };
+
+    // hue varies from 0 to 179, saturation from 0 to 255
+    float h_ranges[] = { 0, 180 };
+    float s_ranges[] = { 0, 256 };
+
+    const float* ranges[] = { h_ranges, s_ranges };
+
+    // Use the 0-th and 1-st channels
+    int channels[] = { 0, 1 };
+    //! [Using 50 bins for hue and 60 for saturation]
+
+    //! [Calculate the histograms for the HSV images]
+    Mat hist_base, hist_half_down, hist_test1, hist_test2;
+
+    calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
+    normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
+    normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
+    normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
+    normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
+    //! [Calculate the histograms for the HSV images]
+
+    //! [Apply the histogram comparison methods]
+    for( int compare_method = 0; compare_method < 4; compare_method++ )
+    {
+        double base_base = compareHist( hist_base, hist_base, compare_method );
+        double base_half = compareHist( hist_base, hist_half_down, compare_method );
+        double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+        double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+
+        cout << "Method " << compare_method << " Perfect, Base-Half, Base-Test(1), Base-Test(2) : "
+             <<  base_base << " / " << base_half << " / " << base_test1 << " / " << base_test2 << endl;
+    }
+    //! [Apply the histogram comparison methods]
+
+    cout << "Done \n";
+    return 0;
+}