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

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

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

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ml/introduction_to_pca/introduction_to_pca.py

@@ -0,0 +1,100 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+from math import atan2, cos, sin, sqrt, pi
+
+def drawAxis(img, p_, q_, colour, scale):
+    p = list(p_)
+    q = list(q_)
+    ## [visualization1]
+    angle = atan2(p[1] - q[1], p[0] - q[0]) # angle in radians
+    hypotenuse = sqrt((p[1] - q[1]) * (p[1] - q[1]) + (p[0] - q[0]) * (p[0] - q[0]))
+
+    # Here we lengthen the arrow by a factor of scale
+    q[0] = p[0] - scale * hypotenuse * cos(angle)
+    q[1] = p[1] - scale * hypotenuse * sin(angle)
+    cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
+
+    # create the arrow hooks
+    p[0] = q[0] + 9 * cos(angle + pi / 4)
+    p[1] = q[1] + 9 * sin(angle + pi / 4)
+    cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
+
+    p[0] = q[0] + 9 * cos(angle - pi / 4)
+    p[1] = q[1] + 9 * sin(angle - pi / 4)
+    cv.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv.LINE_AA)
+    ## [visualization1]
+
+def getOrientation(pts, img):
+    ## [pca]
+    # Construct a buffer used by the pca analysis
+    sz = len(pts)
+    data_pts = np.empty((sz, 2), dtype=np.float64)
+    for i in range(data_pts.shape[0]):
+        data_pts[i,0] = pts[i,0,0]
+        data_pts[i,1] = pts[i,0,1]
+
+    # Perform PCA analysis
+    mean = np.empty((0))
+    mean, eigenvectors, eigenvalues = cv.PCACompute2(data_pts, mean)
+
+    # Store the center of the object
+    cntr = (int(mean[0,0]), int(mean[0,1]))
+    ## [pca]
+
+    ## [visualization]
+    # Draw the principal components
+    cv.circle(img, cntr, 3, (255, 0, 255), 2)
+    p1 = (cntr[0] + 0.02 * eigenvectors[0,0] * eigenvalues[0,0], cntr[1] + 0.02 * eigenvectors[0,1] * eigenvalues[0,0])
+    p2 = (cntr[0] - 0.02 * eigenvectors[1,0] * eigenvalues[1,0], cntr[1] - 0.02 * eigenvectors[1,1] * eigenvalues[1,0])
+    drawAxis(img, cntr, p1, (0, 255, 0), 1)
+    drawAxis(img, cntr, p2, (255, 255, 0), 5)
+
+    angle = atan2(eigenvectors[0,1], eigenvectors[0,0]) # orientation in radians
+    ## [visualization]
+
+    return angle
+
+## [pre-process]
+# Load image
+parser = argparse.ArgumentParser(description='Code for Introduction to Principal Component Analysis (PCA) tutorial.\
+                                              This program demonstrates how to use OpenCV PCA to extract the orientation of an object.')
+parser.add_argument('--input', help='Path to input image.', default='pca_test1.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+# Check if image is loaded successfully
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+cv.imshow('src', src)
+
+# Convert image to grayscale
+gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Convert image to binary
+_, bw = cv.threshold(gray, 50, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
+## [pre-process]
+
+## [contours]
+# Find all the contours in the thresholded image
+contours, _ = cv.findContours(bw, cv.RETR_LIST, cv.CHAIN_APPROX_NONE)
+
+for i, c in enumerate(contours):
+    # Calculate the area of each contour
+    area = cv.contourArea(c)
+    # Ignore contours that are too small or too large
+    if area < 1e2 or 1e5 < area:
+        continue
+
+    # Draw each contour only for visualisation purposes
+    cv.drawContours(src, contours, i, (0, 0, 255), 2)
+    # Find the orientation of each shape
+    getOrientation(c, src)
+## [contours]
+
+cv.imshow('output', src)
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ml/introduction_to_svm/introduction_to_svm.py

@@ -0,0 +1,62 @@
+import cv2 as cv
+import numpy as np
+
+# Set up training data
+## [setup1]
+labels = np.array([1, -1, -1, -1])
+trainingData = np.matrix([[501, 10], [255, 10], [501, 255], [10, 501]], dtype=np.float32)
+## [setup1]
+
+# Train the SVM
+## [init]
+svm = cv.ml.SVM_create()
+svm.setType(cv.ml.SVM_C_SVC)
+svm.setKernel(cv.ml.SVM_LINEAR)
+svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, 100, 1e-6))
+## [init]
+## [train]
+svm.train(trainingData, cv.ml.ROW_SAMPLE, labels)
+## [train]
+
+# Data for visual representation
+width = 512
+height = 512
+image = np.zeros((height, width, 3), dtype=np.uint8)
+
+# Show the decision regions given by the SVM
+## [show]
+green = (0,255,0)
+blue = (255,0,0)
+for i in range(image.shape[0]):
+    for j in range(image.shape[1]):
+        sampleMat = np.matrix([[j,i]], dtype=np.float32)
+        response = svm.predict(sampleMat)[1]
+
+        if response == 1:
+            image[i,j] = green
+        elif response == -1:
+            image[i,j] = blue
+## [show]
+
+# Show the training data
+## [show_data]
+thickness = -1
+cv.circle(image, (501,  10), 5, (  0,   0,   0), thickness)
+cv.circle(image, (255,  10), 5, (255, 255, 255), thickness)
+cv.circle(image, (501, 255), 5, (255, 255, 255), thickness)
+cv.circle(image, ( 10, 501), 5, (255, 255, 255), thickness)
+## [show_data]
+
+# Show support vectors
+## [show_vectors]
+thickness = 2
+sv = svm.getUncompressedSupportVectors()
+
+for i in range(sv.shape[0]):
+    cv.circle(image, (int(sv[i,0]), int(sv[i,1])), 6, (128, 128, 128), thickness)
+## [show_vectors]
+
+cv.imwrite('result.png', image) # save the image
+
+cv.imshow('SVM Simple Example', image) # show it to the user
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ml/non_linear_svms/non_linear_svms.py

@@ -0,0 +1,117 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import random as rng
+
+NTRAINING_SAMPLES = 100 # Number of training samples per class
+FRAC_LINEAR_SEP = 0.9   # Fraction of samples which compose the linear separable part
+
+# Data for visual representation
+WIDTH = 512
+HEIGHT = 512
+I = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
+
+# --------------------- 1. Set up training data randomly ---------------------------------------
+trainData = np.empty((2*NTRAINING_SAMPLES, 2), dtype=np.float32)
+labels = np.empty((2*NTRAINING_SAMPLES, 1), dtype=np.int32)
+
+rng.seed(100) # Random value generation class
+
+# Set up the linearly separable part of the training data
+nLinearSamples = int(FRAC_LINEAR_SEP * NTRAINING_SAMPLES)
+
+## [setup1]
+# Generate random points for the class 1
+trainClass = trainData[0:nLinearSamples,:]
+# The x coordinate of the points is in [0, 0.4)
+c = trainClass[:,0:1]
+c[:] = np.random.uniform(0.0, 0.4 * WIDTH, c.shape)
+# The y coordinate of the points is in [0, 1)
+c = trainClass[:,1:2]
+c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
+
+# Generate random points for the class 2
+trainClass = trainData[2*NTRAINING_SAMPLES-nLinearSamples:2*NTRAINING_SAMPLES,:]
+# The x coordinate of the points is in [0.6, 1]
+c = trainClass[:,0:1]
+c[:] = np.random.uniform(0.6*WIDTH, WIDTH, c.shape)
+# The y coordinate of the points is in [0, 1)
+c = trainClass[:,1:2]
+c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
+## [setup1]
+
+#------------------ Set up the non-linearly separable part of the training data ---------------
+## [setup2]
+# Generate random points for the classes 1 and 2
+trainClass = trainData[nLinearSamples:2*NTRAINING_SAMPLES-nLinearSamples,:]
+# The x coordinate of the points is in [0.4, 0.6)
+c = trainClass[:,0:1]
+c[:] = np.random.uniform(0.4*WIDTH, 0.6*WIDTH, c.shape)
+# The y coordinate of the points is in [0, 1)
+c = trainClass[:,1:2]
+c[:] = np.random.uniform(0.0, HEIGHT, c.shape)
+## [setup2]
+
+#------------------------- Set up the labels for the classes ---------------------------------
+labels[0:NTRAINING_SAMPLES,:] = 1                   # Class 1
+labels[NTRAINING_SAMPLES:2*NTRAINING_SAMPLES,:] = 2 # Class 2
+
+#------------------------ 2. Set up the support vector machines parameters --------------------
+print('Starting training process')
+## [init]
+svm = cv.ml.SVM_create()
+svm.setType(cv.ml.SVM_C_SVC)
+svm.setC(0.1)
+svm.setKernel(cv.ml.SVM_LINEAR)
+svm.setTermCriteria((cv.TERM_CRITERIA_MAX_ITER, int(1e7), 1e-6))
+## [init]
+
+#------------------------ 3. Train the svm ----------------------------------------------------
+## [train]
+svm.train(trainData, cv.ml.ROW_SAMPLE, labels)
+## [train]
+print('Finished training process')
+
+#------------------------ 4. Show the decision regions ----------------------------------------
+## [show]
+green = (0,100,0)
+blue = (100,0,0)
+for i in range(I.shape[0]):
+    for j in range(I.shape[1]):
+        sampleMat = np.matrix([[j,i]], dtype=np.float32)
+        response = svm.predict(sampleMat)[1]
+
+        if response == 1:
+            I[i,j] = green
+        elif response == 2:
+            I[i,j] = blue
+## [show]
+
+#----------------------- 5. Show the training data --------------------------------------------
+## [show_data]
+thick = -1
+# Class 1
+for i in range(NTRAINING_SAMPLES):
+    px = trainData[i,0]
+    py = trainData[i,1]
+    cv.circle(I, (int(px), int(py)), 3, (0, 255, 0), thick)
+
+# Class 2
+for i in range(NTRAINING_SAMPLES, 2*NTRAINING_SAMPLES):
+    px = trainData[i,0]
+    py = trainData[i,1]
+    cv.circle(I, (int(px), int(py)), 3, (255, 0, 0), thick)
+## [show_data]
+
+#------------------------- 6. Show support vectors --------------------------------------------
+## [show_vectors]
+thick = 2
+sv = svm.getUncompressedSupportVectors()
+
+for i in range(sv.shape[0]):
+    cv.circle(I, (int(sv[i,0]), int(sv[i,1])), 6, (128, 128, 128), thick)
+## [show_vectors]
+
+cv.imwrite('result.png', I)                      # save the Image
+cv.imshow('SVM for Non-Linear Training Data', I) # show it to the user
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ml/py_svm_opencv/hogsvm.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+import cv2 as cv
+import numpy as np
+
+SZ=20
+bin_n = 16 # Number of bins
+
+
+affine_flags = cv.WARP_INVERSE_MAP|cv.INTER_LINEAR
+
+## [deskew]
+def deskew(img):
+    m = cv.moments(img)
+    if abs(m['mu02']) < 1e-2:
+        return img.copy()
+    skew = m['mu11']/m['mu02']
+    M = np.float32([[1, skew, -0.5*SZ*skew], [0, 1, 0]])
+    img = cv.warpAffine(img,M,(SZ, SZ),flags=affine_flags)
+    return img
+## [deskew]
+
+## [hog]
+def hog(img):
+    gx = cv.Sobel(img, cv.CV_32F, 1, 0)
+    gy = cv.Sobel(img, cv.CV_32F, 0, 1)
+    mag, ang = cv.cartToPolar(gx, gy)
+    bins = np.int32(bin_n*ang/(2*np.pi))    # quantizing binvalues in (0...16)
+    bin_cells = bins[:10,:10], bins[10:,:10], bins[:10,10:], bins[10:,10:]
+    mag_cells = mag[:10,:10], mag[10:,:10], mag[:10,10:], mag[10:,10:]
+    hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
+    hist = np.hstack(hists)     # hist is a 64 bit vector
+    return hist
+## [hog]
+
+img = cv.imread(cv.samples.findFile('digits.png'),0)
+if img is None:
+    raise Exception("we need the digits.png image from samples/data here !")
+
+
+cells = [np.hsplit(row,100) for row in np.vsplit(img,50)]
+
+# First half is trainData, remaining is testData
+train_cells = [ i[:50] for i in cells ]
+test_cells = [ i[50:] for i in cells]
+
+######     Now training      ########################
+
+deskewed = [list(map(deskew,row)) for row in train_cells]
+hogdata = [list(map(hog,row)) for row in deskewed]
+trainData = np.float32(hogdata).reshape(-1,64)
+responses = np.repeat(np.arange(10),250)[:,np.newaxis]
+
+svm = cv.ml.SVM_create()
+svm.setKernel(cv.ml.SVM_LINEAR)
+svm.setType(cv.ml.SVM_C_SVC)
+svm.setC(2.67)
+svm.setGamma(5.383)
+
+svm.train(trainData, cv.ml.ROW_SAMPLE, responses)
+svm.save('svm_data.dat')
+
+######     Now testing      ########################
+
+deskewed = [list(map(deskew,row)) for row in test_cells]
+hogdata = [list(map(hog,row)) for row in deskewed]
+testData = np.float32(hogdata).reshape(-1,bin_n*4)
+result = svm.predict(testData)[1]
+
+#######   Check Accuracy   ########################
+mask = result==responses
+correct = np.count_nonzero(mask)
+print(correct*100.0/result.size)