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

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

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

3rdparty/opencv-4.5.4/doc/py_tutorials/py_gui/py_drawing_functions/py_drawing_functions.markdown

@@ -0,0 +1,113 @@
+Drawing Functions in OpenCV {#tutorial_py_drawing_functions}
+===========================
+
+Goal
+----
+
+-   Learn to draw different geometric shapes with OpenCV
+-   You will learn these functions : **cv.line()**, **cv.circle()** , **cv.rectangle()**,
+    **cv.ellipse()**, **cv.putText()** etc.
+
+Code
+----
+
+In all the above functions, you will see some common arguments as given below:
+
+-   img : The image where you want to draw the shapes
+-   color : Color of the shape. for BGR, pass it as a tuple, eg: (255,0,0) for blue. For
+    grayscale, just pass the scalar value.
+-   thickness : Thickness of the line or circle etc. If **-1** is passed for closed figures like
+    circles, it will fill the shape. *default thickness = 1*
+-   lineType : Type of line, whether 8-connected, anti-aliased line etc. *By default, it is
+    8-connected.* cv.LINE_AA gives anti-aliased line which looks great for curves.
+
+### Drawing Line
+
+To draw a line, you need to pass starting and ending coordinates of line. We will create a black
+image and draw a blue line on it from top-left to bottom-right corners.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+# Create a black image
+img = np.zeros((512,512,3), np.uint8)
+
+# Draw a diagonal blue line with thickness of 5 px
+cv.line(img,(0,0),(511,511),(255,0,0),5)
+@endcode
+### Drawing Rectangle
+
+To draw a rectangle, you need top-left corner and bottom-right corner of rectangle. This time we
+will draw a green rectangle at the top-right corner of image.
+@code{.py}
+cv.rectangle(img,(384,0),(510,128),(0,255,0),3)
+@endcode
+### Drawing Circle
+
+To draw a circle, you need its center coordinates and radius. We will draw a circle inside the
+rectangle drawn above.
+@code{.py}
+cv.circle(img,(447,63), 63, (0,0,255), -1)
+@endcode
+### Drawing Ellipse
+
+To draw the ellipse, we need to pass several arguments. One argument is the center location (x,y).
+Next argument is axes lengths (major axis length, minor axis length). angle is the angle of rotation
+of ellipse in anti-clockwise direction. startAngle and endAngle denotes the starting and ending of
+ellipse arc measured in clockwise direction from major axis. i.e. giving values 0 and 360 gives the
+full ellipse. For more details, check the documentation of **cv.ellipse()**. Below example draws a
+half ellipse at the center of the image.
+@code{.py}
+cv.ellipse(img,(256,256),(100,50),0,0,180,255,-1)
+@endcode
+### Drawing Polygon
+
+To draw a polygon, first you need coordinates of vertices. Make those points into an array of shape
+ROWSx1x2 where ROWS are number of vertices and it should be of type int32. Here we draw a small
+polygon of with four vertices in yellow color.
+@code{.py}
+pts = np.array([[10,5],[20,30],[70,20],[50,10]], np.int32)
+pts = pts.reshape((-1,1,2))
+cv.polylines(img,[pts],True,(0,255,255))
+@endcode
+
+@note If third argument is False, you will get a polylines joining all the points, not a closed
+shape.
+
+@note cv.polylines() can be used to draw multiple lines. Just create a list of all the lines you
+want to draw and pass it to the function. All lines will be drawn individually. It is a much better
+and faster way to draw a group of lines than calling cv.line() for each line.
+
+### Adding Text to Images:
+
+To put texts in images, you need specify following things.
+    -   Text data that you want to write
+    -   Position coordinates of where you want put it (i.e. bottom-left corner where data starts).
+    -   Font type (Check **cv.putText()** docs for supported fonts)
+    -   Font Scale (specifies the size of font)
+    -   regular things like color, thickness, lineType etc. For better look, lineType = cv.LINE_AA
+        is recommended.
+
+We will write **OpenCV** on our image in white color.
+@code{.py}
+font = cv.FONT_HERSHEY_SIMPLEX
+cv.putText(img,'OpenCV',(10,500), font, 4,(255,255,255),2,cv.LINE_AA)
+@endcode
+
+### Result
+
+So it is time to see the final result of our drawing. As you studied in previous articles, display
+the image to see it.
+
+![image](images/drawing_result.jpg)
+
+Additional Resources
+--------------------
+
+-#  The angles used in ellipse function is not our circular angles. For more details, visit [this
+    discussion](http://answers.opencv.org/question/14541/angles-in-ellipse-function/).
+
+Exercises
+---------
+
+-#  Try to create the logo of OpenCV using drawing functions available in OpenCV.

3rdparty/opencv-4.5.4/doc/py_tutorials/py_gui/py_image_display/py_image_display.markdown

@@ -0,0 +1,4 @@
+Getting Started with Images {#tutorial_py_image_display}
+===========================
+
+Tutorial content has been moved: @ref tutorial_display_image

3rdparty/opencv-4.5.4/doc/py_tutorials/py_gui/py_mouse_handling/py_mouse_handling.markdown

@@ -0,0 +1,111 @@
+Mouse as a Paint-Brush {#tutorial_py_mouse_handling}
+======================
+
+Goal
+----
+
+-   Learn to handle mouse events in OpenCV
+-   You will learn these functions : **cv.setMouseCallback()**
+
+Simple Demo
+-----------
+
+Here, we create a simple application which draws a circle on an image wherever we double-click on
+it.
+
+First we create a mouse callback function which is executed when a mouse event take place. Mouse
+event can be anything related to mouse like left-button down, left-button up, left-button
+double-click etc. It gives us the coordinates (x,y) for every mouse event. With this event and
+location, we can do whatever we like. To list all available events available, run the following code
+in Python terminal:
+@code{.py}
+import cv2 as cv
+events = [i for i in dir(cv) if 'EVENT' in i]
+print( events )
+@endcode
+Creating mouse callback function has a specific format which is same everywhere. It differs only in
+what the function does. So our mouse callback function does one thing, it draws a circle where we
+double-click. So see the code below. Code is self-explanatory from comments :
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+# mouse callback function
+def draw_circle(event,x,y,flags,param):
+    if event == cv.EVENT_LBUTTONDBLCLK:
+        cv.circle(img,(x,y),100,(255,0,0),-1)
+
+# Create a black image, a window and bind the function to window
+img = np.zeros((512,512,3), np.uint8)
+cv.namedWindow('image')
+cv.setMouseCallback('image',draw_circle)
+
+while(1):
+    cv.imshow('image',img)
+    if cv.waitKey(20) & 0xFF == 27:
+        break
+cv.destroyAllWindows()
+@endcode
+More Advanced Demo
+------------------
+
+Now we go for a much better application. In this, we draw either rectangles or circles (depending on
+the mode we select) by dragging the mouse like we do in Paint application. So our mouse callback
+function has two parts, one to draw rectangle and other to draw the circles. This specific example
+will be really helpful in creating and understanding some interactive applications like object
+tracking, image segmentation etc.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+drawing = False # true if mouse is pressed
+mode = True # if True, draw rectangle. Press 'm' to toggle to curve
+ix,iy = -1,-1
+
+# mouse callback function
+def draw_circle(event,x,y,flags,param):
+    global ix,iy,drawing,mode
+
+    if event == cv.EVENT_LBUTTONDOWN:
+        drawing = True
+        ix,iy = x,y
+
+    elif event == cv.EVENT_MOUSEMOVE:
+        if drawing == True:
+            if mode == True:
+                cv.rectangle(img,(ix,iy),(x,y),(0,255,0),-1)
+            else:
+                cv.circle(img,(x,y),5,(0,0,255),-1)
+
+    elif event == cv.EVENT_LBUTTONUP:
+        drawing = False
+        if mode == True:
+            cv.rectangle(img,(ix,iy),(x,y),(0,255,0),-1)
+        else:
+            cv.circle(img,(x,y),5,(0,0,255),-1)
+@endcode
+Next we have to bind this mouse callback function to OpenCV window. In the main loop, we should set
+a keyboard binding for key 'm' to toggle between rectangle and circle.
+@code{.py}
+img = np.zeros((512,512,3), np.uint8)
+cv.namedWindow('image')
+cv.setMouseCallback('image',draw_circle)
+
+while(1):
+    cv.imshow('image',img)
+    k = cv.waitKey(1) & 0xFF
+    if k == ord('m'):
+        mode = not mode
+    elif k == 27:
+        break
+
+cv.destroyAllWindows()
+@endcode
+Additional Resources
+--------------------
+
+Exercises
+---------
+
+-#  In our last example, we drew filled rectangle. You modify the code to draw an unfilled
+    rectangle.

3rdparty/opencv-4.5.4/doc/py_tutorials/py_gui/py_table_of_contents_gui.markdown

@@ -0,0 +1,27 @@
+Gui Features in OpenCV {#tutorial_py_table_of_contents_gui}
+======================
+
+-   @ref tutorial_display_image
+
+    Learn to load an
+    image, display it, and save it back
+
+-   @subpage tutorial_py_video_display
+
+    Learn to play videos,
+    capture videos from a camera, and write videos
+
+-   @subpage tutorial_py_drawing_functions
+
+    Learn to draw lines,
+    rectangles, ellipses, circles, etc with OpenCV
+
+-   @subpage tutorial_py_mouse_handling
+
+    Draw stuff with your
+    mouse
+
+-   @subpage tutorial_py_trackbar
+
+    Create trackbar to
+    control certain parameters

3rdparty/opencv-4.5.4/doc/py_tutorials/py_gui/py_trackbar/py_trackbar.markdown

@@ -0,0 +1,75 @@
+Trackbar as the Color Palette {#tutorial_py_trackbar}
+=============================
+
+Goal
+----
+
+-   Learn to bind trackbar to OpenCV windows
+-   You will learn these functions : **cv.getTrackbarPos()**, **cv.createTrackbar()** etc.
+
+Code Demo
+---------
+
+Here we will create a simple application which shows the color you specify. You have a window which
+shows the color and three trackbars to specify each of B,G,R colors. You slide the trackbar and
+correspondingly window color changes. By default, initial color will be set to Black.
+
+For cv.createTrackbar() function, first argument is the trackbar name, second one is the window
+name to which it is attached, third argument is the default value, fourth one is the maximum value
+and fifth one is the callback function which is executed every time trackbar value changes. The
+callback function always has a default argument which is the trackbar position. In our case,
+function does nothing, so we simply pass.
+
+Another important application of trackbar is to use it as a button or switch. OpenCV, by default,
+doesn't have button functionality. So you can use trackbar to get such functionality. In our
+application, we have created one switch in which application works only if switch is ON, otherwise
+screen is always black.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+def nothing(x):
+    pass
+
+# Create a black image, a window
+img = np.zeros((300,512,3), np.uint8)
+cv.namedWindow('image')
+
+# create trackbars for color change
+cv.createTrackbar('R','image',0,255,nothing)
+
+cv.createTrackbar('G','image',0,255,nothing)
+cv.createTrackbar('B','image',0,255,nothing)
+
+# create switch for ON/OFF functionality
+switch = '0 : OFF \n1 : ON'
+cv.createTrackbar(switch, 'image',0,1,nothing)
+
+while(1):
+    cv.imshow('image',img)
+    k = cv.waitKey(1) & 0xFF
+    if k == 27:
+        break
+
+    # get current positions of four trackbars
+    r = cv.getTrackbarPos('R','image')
+    g = cv.getTrackbarPos('G','image')
+    b = cv.getTrackbarPos('B','image')
+    s = cv.getTrackbarPos(switch,'image')
+
+    if s == 0:
+        img[:] = 0
+    else:
+        img[:] = [b,g,r]
+
+cv.destroyAllWindows()
+@endcode
+The screenshot of the application looks like below :
+
+![image](images/trackbar_screenshot.jpg)
+
+Exercises
+---------
+
+-#  Create a Paint application with adjustable colors and brush radius using trackbars. For drawing,
+    refer previous tutorial on mouse handling.

3rdparty/opencv-4.5.4/doc/py_tutorials/py_gui/py_video_display/py_video_display.markdown

@@ -0,0 +1,160 @@
+Getting Started with Videos {#tutorial_py_video_display}
+===========================
+
+Goal
+----
+
+-   Learn to read video, display video, and save video.
+-   Learn to capture video from a camera and display it.
+-   You will learn these functions : **cv.VideoCapture()**, **cv.VideoWriter()**
+
+Capture Video from Camera
+-------------------------
+
+Often, we have to capture live stream with a camera. OpenCV provides a very simple interface to do this.
+Let's capture a video from the camera (I am using the built-in webcam on my laptop), convert it into
+grayscale video and display it. Just a simple task to get started.
+
+To capture a video, you need to create a **VideoCapture** object. Its argument can be either the
+device index or the name of a video file. A device index is just the number to specify which camera.
+Normally one camera will be connected (as in my case). So I simply pass 0 (or -1). You can select
+the second camera by passing 1 and so on. After that, you can capture frame-by-frame. But at the
+end, don't forget to release the capture.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+cap = cv.VideoCapture(0)
+if not cap.isOpened():
+    print("Cannot open camera")
+    exit()
+while True:
+    # Capture frame-by-frame
+    ret, frame = cap.read()
+
+    # if frame is read correctly ret is True
+    if not ret:
+        print("Can't receive frame (stream end?). Exiting ...")
+        break
+    # Our operations on the frame come here
+    gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+    # Display the resulting frame
+    cv.imshow('frame', gray)
+    if cv.waitKey(1) == ord('q'):
+        break
+
+# When everything done, release the capture
+cap.release()
+cv.destroyAllWindows()@endcode
+`cap.read()` returns a bool (`True`/`False`). If the frame is read correctly, it will be `True`. So you can
+check for the end of the video by checking this returned value.
+
+Sometimes, cap may not have initialized the capture. In that case, this code shows an error. You can
+check whether it is initialized or not by the method **cap.isOpened()**. If it is `True`, OK.
+Otherwise open it using **cap.open()**.
+
+You can also access some of the features of this video using **cap.get(propId)** method where propId
+is a number from 0 to 18. Each number denotes a property of the video (if it is applicable to that
+video). Full details can be seen here: cv::VideoCapture::get().
+Some of these values can be modified using **cap.set(propId, value)**. Value is the new value you
+want.
+
+For example, I can check the frame width and height by `cap.get(cv.CAP_PROP_FRAME_WIDTH)` and `cap.get(cv.CAP_PROP_FRAME_HEIGHT)`. It gives me
+640x480 by default. But I want to modify it to 320x240. Just use `ret = cap.set(cv.CAP_PROP_FRAME_WIDTH,320)` and
+`ret = cap.set(cv.CAP_PROP_FRAME_HEIGHT,240)`.
+
+@note If you are getting an error, make sure your camera is working fine using any other camera application
+(like Cheese in Linux).
+
+Playing Video from file
+-----------------------
+
+Playing video from file is the same as capturing it from camera, just change the camera index to a video file name. Also while
+displaying the frame, use appropriate time for `cv.waitKey()`. If it is too less, video will be very
+fast and if it is too high, video will be slow (Well, that is how you can display videos in slow
+motion). 25 milliseconds will be OK in normal cases.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+cap = cv.VideoCapture('vtest.avi')
+
+while cap.isOpened():
+    ret, frame = cap.read()
+
+    # if frame is read correctly ret is True
+    if not ret:
+        print("Can't receive frame (stream end?). Exiting ...")
+        break
+    gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+
+    cv.imshow('frame', gray)
+    if cv.waitKey(1) == ord('q'):
+        break
+
+cap.release()
+cv.destroyAllWindows()
+@endcode
+
+@note Make sure a proper version of ffmpeg or gstreamer is installed. Sometimes it is a headache to
+work with video capture, mostly due to wrong installation of ffmpeg/gstreamer.
+
+Saving a Video
+--------------
+
+So we capture a video and process it frame-by-frame, and we want to save that video. For images, it is
+very simple: just use `cv.imwrite()`. Here, a little more work is required.
+
+This time we create a **VideoWriter** object. We should specify the output file name (eg:
+output.avi). Then we should specify the **FourCC** code (details in next paragraph). Then number of
+frames per second (fps) and frame size should be passed. And the last one is the **isColor** flag. If it is
+`True`, the encoder expect color frame, otherwise it works with grayscale frame.
+
+[FourCC](http://en.wikipedia.org/wiki/FourCC) is a 4-byte code used to specify the video codec. The
+list of available codes can be found in [fourcc.org](http://www.fourcc.org/codecs.php). It is
+platform dependent. The following codecs work fine for me.
+
+-   In Fedora: DIVX, XVID, MJPG, X264, WMV1, WMV2. (XVID is more preferable. MJPG results in high
+    size video. X264 gives very small size video)
+-   In Windows: DIVX (More to be tested and added)
+-   In OSX: MJPG (.mp4), DIVX (.avi), X264 (.mkv).
+
+FourCC code is passed as `cv.VideoWriter_fourcc('M','J','P','G')` or
+`cv.VideoWriter_fourcc(*'MJPG')` for MJPG.
+
+The below code captures from a camera, flips every frame in the vertical direction, and saves the video.
+@code{.py}
+import numpy as np
+import cv2 as cv
+
+cap = cv.VideoCapture(0)
+
+# Define the codec and create VideoWriter object
+fourcc = cv.VideoWriter_fourcc(*'XVID')
+out = cv.VideoWriter('output.avi', fourcc, 20.0, (640,  480))
+
+while cap.isOpened():
+    ret, frame = cap.read()
+    if not ret:
+        print("Can't receive frame (stream end?). Exiting ...")
+        break
+    frame = cv.flip(frame, 0)
+
+    # write the flipped frame
+    out.write(frame)
+
+    cv.imshow('frame', frame)
+    if cv.waitKey(1) == ord('q'):
+        break
+
+# Release everything if job is finished
+cap.release()
+out.release()
+cv.destroyAllWindows()
+@endcode
+
+Additional Resources
+--------------------
+
+Exercises
+---------