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/ImgTrans/CannyDetector_Demo.cpp

@@ -0,0 +1,97 @@
+/**
+ * @file CannyDetector_Demo.cpp
+ * @brief Sample code showing how to detect edges using the Canny Detector
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
+
+using namespace cv;
+
+//![variables]
+Mat src, src_gray;
+Mat dst, detected_edges;
+
+int lowThreshold = 0;
+const int max_lowThreshold = 100;
+const int ratio = 3;
+const int kernel_size = 3;
+const char* window_name = "Edge Map";
+//![variables]
+
+/**
+ * @function CannyThreshold
+ * @brief Trackbar callback - Canny thresholds input with a ratio 1:3
+ */
+static void CannyThreshold(int, void*)
+{
+    //![reduce_noise]
+    /// Reduce noise with a kernel 3x3
+    blur( src_gray, detected_edges, Size(3,3) );
+    //![reduce_noise]
+
+    //![canny]
+    /// Canny detector
+    Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );
+    //![canny]
+
+    /// Using Canny's output as a mask, we display our result
+    //![fill]
+    dst = Scalar::all(0);
+    //![fill]
+
+    //![copyto]
+    src.copyTo( dst, detected_edges);
+    //![copyto]
+
+    //![display]
+    imshow( window_name, dst );
+    //![display]
+}
+
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  //![load]
+  CommandLineParser parser( argc, argv, "{@input | fruits.jpg | input image}" );
+  src = imread( samples::findFile( parser.get<String>( "@input" ) ), IMREAD_COLOR ); // Load an image
+
+  if( src.empty() )
+  {
+    std::cout << "Could not open or find the image!\n" << std::endl;
+    std::cout << "Usage: " << argv[0] << " <Input image>" << std::endl;
+    return -1;
+  }
+  //![load]
+
+  //![create_mat]
+  /// Create a matrix of the same type and size as src (for dst)
+  dst.create( src.size(), src.type() );
+  //![create_mat]
+
+  //![convert_to_gray]
+  cvtColor( src, src_gray, COLOR_BGR2GRAY );
+  //![convert_to_gray]
+
+  //![create_window]
+  namedWindow( window_name, WINDOW_AUTOSIZE );
+  //![create_window]
+
+  //![create_trackbar]
+  /// Create a Trackbar for user to enter threshold
+  createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );
+  //![create_trackbar]
+
+  /// Show the image
+  CannyThreshold(0, 0);
+
+  /// Wait until user exit program by pressing a key
+  waitKey(0);
+
+  return 0;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp

@@ -0,0 +1,82 @@
+/**
+ * @function Geometric_Transforms_Demo.cpp
+ * @brief Demo code for Geometric Transforms
+ * @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 the image]
+    CommandLineParser parser( argc, argv, "{@input | lena.jpg | input image}" );
+    Mat src = imread( samples::findFile( 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;
+    }
+    //! [Load the image]
+
+    //! [Set your 3 points to calculate the  Affine Transform]
+    Point2f srcTri[3];
+    srcTri[0] = Point2f( 0.f, 0.f );
+    srcTri[1] = Point2f( src.cols - 1.f, 0.f );
+    srcTri[2] = Point2f( 0.f, src.rows - 1.f );
+
+    Point2f dstTri[3];
+    dstTri[0] = Point2f( 0.f, src.rows*0.33f );
+    dstTri[1] = Point2f( src.cols*0.85f, src.rows*0.25f );
+    dstTri[2] = Point2f( src.cols*0.15f, src.rows*0.7f );
+    //! [Set your 3 points to calculate the  Affine Transform]
+
+    //! [Get the Affine Transform]
+    Mat warp_mat = getAffineTransform( srcTri, dstTri );
+    //! [Get the Affine Transform]
+
+    //! [Apply the Affine Transform just found to the src image]
+    /// Set the dst image the same type and size as src
+    Mat warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
+
+    warpAffine( src, warp_dst, warp_mat, warp_dst.size() );
+    //! [Apply the Affine Transform just found to the src image]
+
+    /** Rotating the image after Warp */
+
+    //! [Compute a rotation matrix with respect to the center of the image]
+    Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );
+    double angle = -50.0;
+    double scale = 0.6;
+    //! [Compute a rotation matrix with respect to the center of the image]
+
+    //! [Get the rotation matrix with the specifications above]
+    Mat rot_mat = getRotationMatrix2D( center, angle, scale );
+    //! [Get the rotation matrix with the specifications above]
+
+    //! [Rotate the warped image]
+    Mat warp_rotate_dst;
+    warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );
+    //! [Rotate the warped image]
+
+    //! [Show what you got]
+    imshow( "Source image", src );
+    imshow( "Warp", warp_dst );
+    imshow( "Warp + Rotate", warp_rotate_dst );
+    //! [Show what you got]
+
+    //! [Wait until user exits the program]
+    waitKey();
+    //! [Wait until user exits the program]
+
+    return 0;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp

@@ -0,0 +1,106 @@
+/**
+ * @file HoughCircle_Demo.cpp
+ * @brief Demo code for Hough Transform
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+namespace
+{
+    // windows and trackbars name
+    const std::string windowName = "Hough Circle Detection Demo";
+    const std::string cannyThresholdTrackbarName = "Canny threshold";
+    const std::string accumulatorThresholdTrackbarName = "Accumulator Threshold";
+
+    // initial and max values of the parameters of interests.
+    const int cannyThresholdInitialValue = 100;
+    const int accumulatorThresholdInitialValue = 50;
+    const int maxAccumulatorThreshold = 200;
+    const int maxCannyThreshold = 255;
+
+    void HoughDetection(const Mat& src_gray, const Mat& src_display, int cannyThreshold, int accumulatorThreshold)
+    {
+        // will hold the results of the detection
+        std::vector<Vec3f> circles;
+        // runs the actual detection
+        HoughCircles( src_gray, circles, HOUGH_GRADIENT, 1, src_gray.rows/8, cannyThreshold, accumulatorThreshold, 0, 0 );
+
+        // clone the colour, input image for displaying purposes
+        Mat display = src_display.clone();
+        for( size_t i = 0; i < circles.size(); i++ )
+        {
+            Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
+            int radius = cvRound(circles[i][2]);
+            // circle center
+            circle( display, center, 3, Scalar(0,255,0), -1, 8, 0 );
+            // circle outline
+            circle( display, center, radius, Scalar(0,0,255), 3, 8, 0 );
+        }
+
+        // shows the results
+        imshow( windowName, display);
+    }
+}
+
+
+int main(int argc, char** argv)
+{
+    Mat src, src_gray;
+
+    // Read the image
+    String imageName("stuff.jpg"); // by default
+    if (argc > 1)
+    {
+       imageName = argv[1];
+    }
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR );
+
+    if( src.empty() )
+    {
+        std::cerr << "Invalid input image\n";
+        std::cout << "Usage : " << argv[0] << " <path_to_input_image>\n";;
+        return -1;
+    }
+
+    // Convert it to gray
+    cvtColor( src, src_gray, COLOR_BGR2GRAY );
+
+    // Reduce the noise so we avoid false circle detection
+    GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
+
+    //declare and initialize both parameters that are subjects to change
+    int cannyThreshold = cannyThresholdInitialValue;
+    int accumulatorThreshold = accumulatorThresholdInitialValue;
+
+    // create the main window, and attach the trackbars
+    namedWindow( windowName, WINDOW_AUTOSIZE );
+    createTrackbar(cannyThresholdTrackbarName, windowName, &cannyThreshold,maxCannyThreshold);
+    createTrackbar(accumulatorThresholdTrackbarName, windowName, &accumulatorThreshold, maxAccumulatorThreshold);
+
+    // infinite loop to display
+    // and refresh the content of the output image
+    // until the user presses q or Q
+    char key = 0;
+    while(key != 'q' && key != 'Q')
+    {
+        // those parameters cannot be =0
+        // so we must check here
+        cannyThreshold = std::max(cannyThreshold, 1);
+        accumulatorThreshold = std::max(accumulatorThreshold, 1);
+
+        //runs the detection, and update the display
+        HoughDetection(src_gray, src, cannyThreshold, accumulatorThreshold);
+
+        // get user key
+        key = (char)waitKey(10);
+    }
+
+    return 0;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp

@@ -0,0 +1,133 @@
+/**
+ * @file HoughLines_Demo.cpp
+ * @brief Demo code for Hough Transform
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+
+/** General variables */
+Mat src, edges;
+Mat src_gray;
+Mat standard_hough, probabilistic_hough;
+int min_threshold = 50;
+int max_trackbar = 150;
+
+const char* standard_name = "Standard Hough Lines Demo";
+const char* probabilistic_name = "Probabilistic Hough Lines Demo";
+
+int s_trackbar = max_trackbar;
+int p_trackbar = max_trackbar;
+
+/// Function Headers
+void help();
+void Standard_Hough( int, void* );
+void Probabilistic_Hough( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+   // Read the image
+    String imageName("building.jpg"); // by default
+    if (argc > 1)
+    {
+        imageName = argv[1];
+    }
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR );
+
+   if( src.empty() )
+     { help();
+       return -1;
+     }
+
+   /// Pass the image to gray
+   cvtColor( src, src_gray, COLOR_RGB2GRAY );
+
+   /// Apply Canny edge detector
+   Canny( src_gray, edges, 50, 200, 3 );
+
+   /// Create Trackbars for Thresholds
+   char thresh_label[50];
+   sprintf( thresh_label, "Thres: %d + input", min_threshold );
+
+   namedWindow( standard_name, WINDOW_AUTOSIZE );
+   createTrackbar( thresh_label, standard_name, &s_trackbar, max_trackbar, Standard_Hough);
+
+   namedWindow( probabilistic_name, WINDOW_AUTOSIZE );
+   createTrackbar( thresh_label, probabilistic_name, &p_trackbar, max_trackbar, Probabilistic_Hough);
+
+   /// Initialize
+   Standard_Hough(0, 0);
+   Probabilistic_Hough(0, 0);
+   waitKey(0);
+   return 0;
+}
+
+/**
+ * @function help
+ * @brief Indications of how to run this program and why is it for
+ */
+void help()
+{
+  printf("\t Hough Transform to detect lines \n ");
+  printf("\t---------------------------------\n ");
+  printf(" Usage: ./HoughLines_Demo <image_name> \n");
+}
+
+/**
+ * @function Standard_Hough
+ */
+void Standard_Hough( int, void* )
+{
+  vector<Vec2f> s_lines;
+  cvtColor( edges, standard_hough, COLOR_GRAY2BGR );
+
+  /// 1. Use Standard Hough Transform
+  HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );
+
+  /// Show the result
+  for( size_t i = 0; i < s_lines.size(); i++ )
+     {
+      float r = s_lines[i][0], t = s_lines[i][1];
+      double cos_t = cos(t), sin_t = sin(t);
+      double x0 = r*cos_t, y0 = r*sin_t;
+      double alpha = 1000;
+
+       Point pt1( cvRound(x0 + alpha*(-sin_t)), cvRound(y0 + alpha*cos_t) );
+       Point pt2( cvRound(x0 - alpha*(-sin_t)), cvRound(y0 - alpha*cos_t) );
+       line( standard_hough, pt1, pt2, Scalar(255,0,0), 3, LINE_AA);
+     }
+
+   imshow( standard_name, standard_hough );
+}
+
+/**
+ * @function Probabilistic_Hough
+ */
+void Probabilistic_Hough( int, void* )
+{
+  vector<Vec4i> p_lines;
+  cvtColor( edges, probabilistic_hough, COLOR_GRAY2BGR );
+
+  /// 2. Use Probabilistic Hough Transform
+  HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );
+
+  /// Show the result
+  for( size_t i = 0; i < p_lines.size(); i++ )
+     {
+       Vec4i l = p_lines[i];
+       line( probabilistic_hough, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(255,0,0), 3, LINE_AA);
+     }
+
+   imshow( probabilistic_name, probabilistic_hough );
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp

@@ -0,0 +1,67 @@
+/**
+ * @file Laplace_Demo.cpp
+ * @brief Sample code showing how to detect edges using the Laplace operator
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //![variables]
+    // Declare the variables we are going to use
+    Mat src, src_gray, dst;
+    int kernel_size = 3;
+    int scale = 1;
+    int delta = 0;
+    int ddepth = CV_16S;
+    const char* window_name = "Laplace Demo";
+    //![variables]
+
+    //![load]
+    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
+
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default lena.jpg] \n");
+        return -1;
+    }
+    //![load]
+
+    //![reduce_noise]
+    // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
+    GaussianBlur( src, src, Size(3, 3), 0, 0, BORDER_DEFAULT );
+    //![reduce_noise]
+
+    //![convert_to_gray]
+    cvtColor( src, src_gray, COLOR_BGR2GRAY ); // Convert the image to grayscale
+    //![convert_to_gray]
+
+    /// Apply Laplace function
+    Mat abs_dst;
+    //![laplacian]
+    Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
+    //![laplacian]
+
+    //![convert]
+    // converting back to CV_8U
+    convertScaleAbs( dst, abs_dst );
+    //![convert]
+
+    //![display]
+    imshow( window_name, abs_dst );
+    waitKey(0);
+    //![display]
+
+    return 0;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp

@@ -0,0 +1,114 @@
+/**
+ * @function Remap_Demo.cpp
+ * @brief Demo code for Remap
+ * @author Ana Huaman
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+
+using namespace cv;
+
+/// Function Headers
+void update_map( int &ind, Mat &map_x, Mat &map_y );
+
+/**
+ * @function main
+ */
+int main(int argc, const char** argv)
+{
+    CommandLineParser parser(argc, argv, "{@image |chicky_512.png|input image name}");
+    std::string filename = parser.get<std::string>(0);
+    //! [Load]
+    /// Load the image
+    Mat src = imread( samples::findFile( filename ), IMREAD_COLOR );
+    if (src.empty())
+    {
+        std::cout << "Cannot read image: " << filename << std::endl;
+        return -1;
+    }
+    //! [Load]
+
+    //! [Create]
+    /// Create dst, map_x and map_y with the same size as src:
+    Mat dst(src.size(), src.type());
+    Mat map_x(src.size(), CV_32FC1);
+    Mat map_y(src.size(), CV_32FC1);
+    //! [Create]
+
+    //! [Window]
+    /// Create window
+    const char* remap_window = "Remap demo";
+    namedWindow( remap_window, WINDOW_AUTOSIZE );
+    //! [Window]
+
+    //! [Loop]
+    /// Index to switch between the remap modes
+    int ind = 0;
+    for(;;)
+    {
+        /// Update map_x & map_y. Then apply remap
+        update_map(ind, map_x, map_y);
+        remap( src, dst, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) );
+
+        /// Display results
+        imshow( remap_window, dst );
+
+        /// Each 1 sec. Press ESC to exit the program
+        char c = (char)waitKey( 1000 );
+        if( c == 27 )
+        {
+            break;
+        }
+    }
+    //! [Loop]
+    return 0;
+}
+
+/**
+ * @function update_map
+ * @brief Fill the map_x and map_y matrices with 4 types of mappings
+ */
+//! [Update]
+void update_map( int &ind, Mat &map_x, Mat &map_y )
+{
+    for( int i = 0; i < map_x.rows; i++ )
+    {
+        for( int j = 0; j < map_x.cols; j++ )
+        {
+            switch( ind )
+            {
+            case 0:
+                if( j > map_x.cols*0.25 && j < map_x.cols*0.75 && i > map_x.rows*0.25 && i < map_x.rows*0.75 )
+                {
+                    map_x.at<float>(i, j) = 2*( j - map_x.cols*0.25f ) + 0.5f;
+                    map_y.at<float>(i, j) = 2*( i - map_x.rows*0.25f ) + 0.5f;
+                }
+                else
+                {
+                    map_x.at<float>(i, j) = 0;
+                    map_y.at<float>(i, j) = 0;
+                }
+                break;
+            case 1:
+                map_x.at<float>(i, j) = (float)j;
+                map_y.at<float>(i, j) = (float)(map_x.rows - i);
+                break;
+            case 2:
+                map_x.at<float>(i, j) = (float)(map_x.cols - j);
+                map_y.at<float>(i, j) = (float)i;
+                break;
+            case 3:
+                map_x.at<float>(i, j) = (float)(map_x.cols - j);
+                map_y.at<float>(i, j) = (float)(map_x.rows - i);
+                break;
+            default:
+                break;
+            } // end of switch
+        }
+    }
+    ind = (ind+1) % 4;
+}
+//! [Update]

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp

@@ -0,0 +1,124 @@
+/**
+ * @file Sobel_Demo.cpp
+ * @brief Sample code uses Sobel or Scharr OpenCV functions for edge detection
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  cv::CommandLineParser parser(argc, argv,
+                               "{@input   |lena.jpg|input image}"
+                               "{ksize   k|1|ksize (hit 'K' to increase its value at run time)}"
+                               "{scale   s|1|scale (hit 'S' to increase its value at run time)}"
+                               "{delta   d|0|delta (hit 'D' to increase its value at run time)}"
+                               "{help    h|false|show help message}");
+
+  cout << "The sample uses Sobel or Scharr OpenCV functions for edge detection\n\n";
+  parser.printMessage();
+  cout << "\nPress 'ESC' to exit program.\nPress 'R' to reset values ( ksize will be -1 equal to Scharr function )";
+
+  //![variables]
+  // First we declare the variables we are going to use
+  Mat image,src, src_gray;
+  Mat grad;
+  const String window_name = "Sobel Demo - Simple Edge Detector";
+  int ksize = parser.get<int>("ksize");
+  int scale = parser.get<int>("scale");
+  int delta = parser.get<int>("delta");
+  int ddepth = CV_16S;
+  //![variables]
+
+  //![load]
+  String imageName = parser.get<String>("@input");
+  // As usual we load our source image (src)
+  image = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+  // Check if image is loaded fine
+  if( image.empty() )
+  {
+    printf("Error opening image: %s\n", imageName.c_str());
+    return EXIT_FAILURE;
+  }
+  //![load]
+
+  for (;;)
+  {
+    //![reduce_noise]
+    // Remove noise by blurring with a Gaussian filter ( kernel size = 3 )
+    GaussianBlur(image, src, Size(3, 3), 0, 0, BORDER_DEFAULT);
+    //![reduce_noise]
+
+    //![convert_to_gray]
+    // Convert the image to grayscale
+    cvtColor(src, src_gray, COLOR_BGR2GRAY);
+    //![convert_to_gray]
+
+    //![sobel]
+    /// Generate grad_x and grad_y
+    Mat grad_x, grad_y;
+    Mat abs_grad_x, abs_grad_y;
+
+    /// Gradient X
+    Sobel(src_gray, grad_x, ddepth, 1, 0, ksize, scale, delta, BORDER_DEFAULT);
+
+    /// Gradient Y
+    Sobel(src_gray, grad_y, ddepth, 0, 1, ksize, scale, delta, BORDER_DEFAULT);
+    //![sobel]
+
+    //![convert]
+    // converting back to CV_8U
+    convertScaleAbs(grad_x, abs_grad_x);
+    convertScaleAbs(grad_y, abs_grad_y);
+    //![convert]
+
+    //![blend]
+    /// Total Gradient (approximate)
+    addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
+    //![blend]
+
+    //![display]
+    imshow(window_name, grad);
+    char key = (char)waitKey(0);
+    //![display]
+
+    if(key == 27)
+    {
+      return EXIT_SUCCESS;
+    }
+
+    if (key == 'k' || key == 'K')
+    {
+      ksize = ksize < 30 ? ksize+2 : -1;
+    }
+
+    if (key == 's' || key == 'S')
+    {
+      scale++;
+    }
+
+    if (key == 'd' || key == 'D')
+    {
+      delta++;
+    }
+
+    if (key == 'r' || key == 'R')
+    {
+      scale =  1;
+      ksize = -1;
+      delta =  0;
+    }
+  }
+  return EXIT_SUCCESS;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp

@@ -0,0 +1,84 @@
+/**
+ * @file copyMakeBorder_demo.cpp
+ * @brief Sample code that shows the functionality of copyMakeBorder
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+
+//![variables]
+// Declare the variables
+Mat src, dst;
+int top, bottom, left, right;
+int borderType = BORDER_CONSTANT;
+const char* window_name = "copyMakeBorder Demo";
+RNG rng(12345);
+//![variables]
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    //![load]
+    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
+
+    // Loads an image
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    // Check if image is loaded fine
+    if( src.empty()) {
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default lena.jpg] \n");
+        return -1;
+    }
+    //![load]
+
+    // Brief how-to for this program
+    printf( "\n \t copyMakeBorder Demo: \n" );
+    printf( "\t -------------------- \n" );
+    printf( " ** Press 'c' to set the border to a random constant value \n");
+    printf( " ** Press 'r' to set the border to be replicated \n");
+    printf( " ** Press 'ESC' to exit the program \n");
+
+    //![create_window]
+    namedWindow( window_name, WINDOW_AUTOSIZE );
+    //![create_window]
+
+    //![init_arguments]
+    // Initialize arguments for the filter
+    top = (int) (0.05*src.rows); bottom = top;
+    left = (int) (0.05*src.cols); right = left;
+    //![init_arguments]
+
+    for(;;)
+    {
+        //![update_value]
+        Scalar value( rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255) );
+        //![update_value]
+
+        //![copymakeborder]
+        copyMakeBorder( src, dst, top, bottom, left, right, borderType, value );
+        //![copymakeborder]
+
+        //![display]
+        imshow( window_name, dst );
+        //![display]
+
+        //![check_keypress]
+        char c = (char)waitKey(500);
+        if( c == 27 )
+        { break; }
+        else if( c == 'c' )
+        { borderType = BORDER_CONSTANT; }
+        else if( c == 'r' )
+        { borderType = BORDER_REPLICATE; }
+        //![check_keypress]
+    }
+
+    return 0;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp

@@ -0,0 +1,74 @@
+/**
+ * @file filter2D_demo.cpp
+ * @brief Sample code that shows how to implement your own linear filters by using filter2D function
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main ( int argc, char** argv )
+{
+    // Declare variables
+    Mat src, dst;
+
+    Mat kernel;
+    Point anchor;
+    double delta;
+    int ddepth;
+    int kernel_size;
+    const char* window_name = "filter2D Demo";
+
+    //![load]
+    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
+
+    // Loads an image
+    src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
+
+    if( src.empty() )
+    {
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default lena.jpg] \n");
+        return EXIT_FAILURE;
+    }
+    //![load]
+
+    //![init_arguments]
+    // Initialize arguments for the filter
+    anchor = Point( -1, -1 );
+    delta = 0;
+    ddepth = -1;
+    //![init_arguments]
+
+    // Loop - Will filter the image with different kernel sizes each 0.5 seconds
+    int ind = 0;
+    for(;;)
+    {
+        //![update_kernel]
+        // Update kernel size for a normalized box filter
+        kernel_size = 3 + 2*( ind%5 );
+        kernel = Mat::ones( kernel_size, kernel_size, CV_32F )/ (float)(kernel_size*kernel_size);
+        //![update_kernel]
+
+        //![apply_filter]
+        // Apply filter
+        filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT );
+        //![apply_filter]
+        imshow( window_name, dst );
+
+        char c = (char)waitKey(500);
+        // Press 'ESC' to exit the program
+        if( c == 27 )
+        { break; }
+
+        ind++;
+    }
+
+    return EXIT_SUCCESS;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp

@@ -0,0 +1,65 @@
+/**
+ * @file houghcircles.cpp
+ * @brief This program demonstrates circle finding with the Hough transform
+ */
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    //![load]
+    const char* filename = argc >=2 ? argv[1] : "smarties.png";
+
+    // Loads an image
+    Mat src = imread( samples::findFile( filename ), IMREAD_COLOR );
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default %s] \n", filename);
+        return EXIT_FAILURE;
+    }
+    //![load]
+
+    //![convert_to_gray]
+    Mat gray;
+    cvtColor(src, gray, COLOR_BGR2GRAY);
+    //![convert_to_gray]
+
+    //![reduce_noise]
+    medianBlur(gray, gray, 5);
+    //![reduce_noise]
+
+    //![houghcircles]
+    vector<Vec3f> circles;
+    HoughCircles(gray, circles, HOUGH_GRADIENT, 1,
+                 gray.rows/16,  // change this value to detect circles with different distances to each other
+                 100, 30, 1, 30 // change the last two parameters
+            // (min_radius & max_radius) to detect larger circles
+    );
+    //![houghcircles]
+
+    //![draw]
+    for( size_t i = 0; i < circles.size(); i++ )
+    {
+        Vec3i c = circles[i];
+        Point center = Point(c[0], c[1]);
+        // circle center
+        circle( src, center, 1, Scalar(0,100,100), 3, LINE_AA);
+        // circle outline
+        int radius = c[2];
+        circle( src, center, radius, Scalar(255,0,255), 3, LINE_AA);
+    }
+    //![draw]
+
+    //![display]
+    imshow("detected circles", src);
+    waitKey();
+    //![display]
+
+    return EXIT_SUCCESS;
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/houghlines.cpp

@@ -0,0 +1,89 @@
+/**
+ * @file houghlines.cpp
+ * @brief This program demonstrates line finding with the Hough transform
+ */
+
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+int main(int argc, char** argv)
+{
+    // Declare the output variables
+    Mat dst, cdst, cdstP;
+
+    //![load]
+    const char* default_file = "sudoku.png";
+    const char* filename = argc >=2 ? argv[1] : default_file;
+
+    // Loads an image
+    Mat src = imread( samples::findFile( filename ), IMREAD_GRAYSCALE );
+
+    // Check if image is loaded fine
+    if(src.empty()){
+        printf(" Error opening image\n");
+        printf(" Program Arguments: [image_name -- default %s] \n", default_file);
+        return -1;
+    }
+    //![load]
+
+    //![edge_detection]
+    // Edge detection
+    Canny(src, dst, 50, 200, 3);
+    //![edge_detection]
+
+    // Copy edges to the images that will display the results in BGR
+    cvtColor(dst, cdst, COLOR_GRAY2BGR);
+    cdstP = cdst.clone();
+
+    //![hough_lines]
+    // Standard Hough Line Transform
+    vector<Vec2f> lines; // will hold the results of the detection
+    HoughLines(dst, lines, 1, CV_PI/180, 150, 0, 0 ); // runs the actual detection
+    //![hough_lines]
+    //![draw_lines]
+    // Draw the lines
+    for( size_t i = 0; i < lines.size(); i++ )
+    {
+        float rho = lines[i][0], theta = lines[i][1];
+        Point pt1, pt2;
+        double a = cos(theta), b = sin(theta);
+        double x0 = a*rho, y0 = b*rho;
+        pt1.x = cvRound(x0 + 1000*(-b));
+        pt1.y = cvRound(y0 + 1000*(a));
+        pt2.x = cvRound(x0 - 1000*(-b));
+        pt2.y = cvRound(y0 - 1000*(a));
+        line( cdst, pt1, pt2, Scalar(0,0,255), 3, LINE_AA);
+    }
+    //![draw_lines]
+
+    //![hough_lines_p]
+    // Probabilistic Line Transform
+    vector<Vec4i> linesP; // will hold the results of the detection
+    HoughLinesP(dst, linesP, 1, CV_PI/180, 50, 50, 10 ); // runs the actual detection
+    //![hough_lines_p]
+    //![draw_lines_p]
+    // Draw the lines
+    for( size_t i = 0; i < linesP.size(); i++ )
+    {
+        Vec4i l = linesP[i];
+        line( cdstP, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0,0,255), 3, LINE_AA);
+    }
+    //![draw_lines_p]
+
+    //![imshow]
+    // Show results
+    imshow("Source", src);
+    imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst);
+    imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP);
+    //![imshow]
+
+    //![exit]
+    // Wait and Exit
+    waitKey();
+    return 0;
+    //![exit]
+}

3rdparty/opencv-4.5.4/samples/cpp/tutorial_code/ImgTrans/imageSegmentation.cpp

@@ -0,0 +1,168 @@
+/**
+ * @brief Sample code showing how to segment overlapping objects using Laplacian filtering, in addition to Watershed and Distance Transformation
+ * @author OpenCV Team
+ */
+
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+int main(int argc, char *argv[])
+{
+    //! [load_image]
+    // Load the image
+    CommandLineParser parser( argc, argv, "{@input | cards.png | input image}" );
+    Mat src = imread( samples::findFile( 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;
+    }
+
+    // Show the source image
+    imshow("Source Image", src);
+    //! [load_image]
+
+    //! [black_bg]
+    // Change the background from white to black, since that will help later to extract
+    // better results during the use of Distance Transform
+    Mat mask;
+    inRange(src, Scalar(255, 255, 255), Scalar(255, 255, 255), mask);
+    src.setTo(Scalar(0, 0, 0), mask);
+
+    // Show output image
+    imshow("Black Background Image", src);
+    //! [black_bg]
+
+    //! [sharp]
+    // Create a kernel that we will use to sharpen our image
+    Mat kernel = (Mat_<float>(3,3) <<
+                  1,  1, 1,
+                  1, -8, 1,
+                  1,  1, 1); // an approximation of second derivative, a quite strong kernel
+
+    // do the laplacian filtering as it is
+    // well, we need to convert everything in something more deeper then CV_8U
+    // because the kernel has some negative values,
+    // and we can expect in general to have a Laplacian image with negative values
+    // BUT a 8bits unsigned int (the one we are working with) can contain values from 0 to 255
+    // so the possible negative number will be truncated
+    Mat imgLaplacian;
+    filter2D(src, imgLaplacian, CV_32F, kernel);
+    Mat sharp;
+    src.convertTo(sharp, CV_32F);
+    Mat imgResult = sharp - imgLaplacian;
+
+    // convert back to 8bits gray scale
+    imgResult.convertTo(imgResult, CV_8UC3);
+    imgLaplacian.convertTo(imgLaplacian, CV_8UC3);
+
+    // imshow( "Laplace Filtered Image", imgLaplacian );
+    imshow( "New Sharped Image", imgResult );
+    //! [sharp]
+
+    //! [bin]
+    // Create binary image from source image
+    Mat bw;
+    cvtColor(imgResult, bw, COLOR_BGR2GRAY);
+    threshold(bw, bw, 40, 255, THRESH_BINARY | THRESH_OTSU);
+    imshow("Binary Image", bw);
+    //! [bin]
+
+    //! [dist]
+    // Perform the distance transform algorithm
+    Mat dist;
+    distanceTransform(bw, dist, DIST_L2, 3);
+
+    // Normalize the distance image for range = {0.0, 1.0}
+    // so we can visualize and threshold it
+    normalize(dist, dist, 0, 1.0, NORM_MINMAX);
+    imshow("Distance Transform Image", dist);
+    //! [dist]
+
+    //! [peaks]
+    // Threshold to obtain the peaks
+    // This will be the markers for the foreground objects
+    threshold(dist, dist, 0.4, 1.0, THRESH_BINARY);
+
+    // Dilate a bit the dist image
+    Mat kernel1 = Mat::ones(3, 3, CV_8U);
+    dilate(dist, dist, kernel1);
+    imshow("Peaks", dist);
+    //! [peaks]
+
+    //! [seeds]
+    // Create the CV_8U version of the distance image
+    // It is needed for findContours()
+    Mat dist_8u;
+    dist.convertTo(dist_8u, CV_8U);
+
+    // Find total markers
+    vector<vector<Point> > contours;
+    findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
+
+    // Create the marker image for the watershed algorithm
+    Mat markers = Mat::zeros(dist.size(), CV_32S);
+
+    // Draw the foreground markers
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        drawContours(markers, contours, static_cast<int>(i), Scalar(static_cast<int>(i)+1), -1);
+    }
+
+    // Draw the background marker
+    circle(markers, Point(5,5), 3, Scalar(255), -1);
+    Mat markers8u;
+    markers.convertTo(markers8u, CV_8U, 10);
+    imshow("Markers", markers8u);
+    //! [seeds]
+
+    //! [watershed]
+    // Perform the watershed algorithm
+    watershed(imgResult, markers);
+
+    Mat mark;
+    markers.convertTo(mark, CV_8U);
+    bitwise_not(mark, mark);
+    //    imshow("Markers_v2", mark); // uncomment this if you want to see how the mark
+    // image looks like at that point
+
+    // Generate random colors
+    vector<Vec3b> colors;
+    for (size_t i = 0; i < contours.size(); i++)
+    {
+        int b = theRNG().uniform(0, 256);
+        int g = theRNG().uniform(0, 256);
+        int r = theRNG().uniform(0, 256);
+
+        colors.push_back(Vec3b((uchar)b, (uchar)g, (uchar)r));
+    }
+
+    // Create the result image
+    Mat dst = Mat::zeros(markers.size(), CV_8UC3);
+
+    // Fill labeled objects with random colors
+    for (int i = 0; i < markers.rows; i++)
+    {
+        for (int j = 0; j < markers.cols; j++)
+        {
+            int index = markers.at<int>(i,j);
+            if (index > 0 && index <= static_cast<int>(contours.size()))
+            {
+                dst.at<Vec3b>(i,j) = colors[index-1];
+            }
+        }
+    }
+
+    // Visualize the final image
+    imshow("Final Result", dst);
+    //! [watershed]
+
+    waitKey();
+    return 0;
+}