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/Histograms_Matching/back_projection/calcBackProject_Demo1.py

@@ -0,0 +1,71 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+def Hist_and_Backproj(val):
+    ## [initialize]
+    bins = val
+    histSize = max(bins, 2)
+    ranges = [0, 180] # hue_range
+    ## [initialize]
+
+    ## [Get the Histogram and normalize it]
+    hist = cv.calcHist([hue], [0], None, [histSize], ranges, accumulate=False)
+    cv.normalize(hist, hist, alpha=0, beta=255, norm_type=cv.NORM_MINMAX)
+    ## [Get the Histogram and normalize it]
+
+    ## [Get Backprojection]
+    backproj = cv.calcBackProject([hue], [0], hist, ranges, scale=1)
+    ## [Get Backprojection]
+
+    ## [Draw the backproj]
+    cv.imshow('BackProj', backproj)
+    ## [Draw the backproj]
+
+    ## [Draw the histogram]
+    w = 400
+    h = 400
+    bin_w = int(round(w / histSize))
+    histImg = np.zeros((h, w, 3), dtype=np.uint8)
+
+    for i in range(bins):
+        cv.rectangle(histImg, (i*bin_w, h), ( (i+1)*bin_w, h - int(np.round( hist[i]*h/255.0 )) ), (0, 0, 255), cv.FILLED)
+
+    cv.imshow('Histogram', histImg)
+    ## [Draw the histogram]
+
+## [Read the image]
+parser = argparse.ArgumentParser(description='Code for Back Projection tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='home.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Read the image]
+
+## [Transform it to HSV]
+hsv = cv.cvtColor(src, cv.COLOR_BGR2HSV)
+## [Transform it to HSV]
+
+## [Use only the Hue value]
+ch = (0, 0)
+hue = np.empty(hsv.shape, hsv.dtype)
+cv.mixChannels([hsv], [hue], ch)
+## [Use only the Hue value]
+
+## [Create Trackbar to enter the number of bins]
+window_image = 'Source image'
+cv.namedWindow(window_image)
+bins = 25
+cv.createTrackbar('* Hue  bins: ', window_image, bins, 180, Hist_and_Backproj )
+Hist_and_Backproj(bins)
+## [Create Trackbar to enter the number of bins]
+
+## [Show the image]
+cv.imshow(window_image, src)
+cv.waitKey()
+## [Show the image]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/Histograms_Matching/back_projection/calcBackProject_Demo2.py

@@ -0,0 +1,79 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+low = 20
+up = 20
+
+def callback_low(val):
+    global low
+    low = val
+
+def callback_up(val):
+    global up
+    up = val
+
+def pickPoint(event, x, y, flags, param):
+    if event != cv.EVENT_LBUTTONDOWN:
+        return
+
+    # Fill and get the mask
+    seed = (x, y)
+    newMaskVal = 255
+    newVal = (120, 120, 120)
+    connectivity = 8
+    flags = connectivity + (newMaskVal << 8 ) + cv.FLOODFILL_FIXED_RANGE + cv.FLOODFILL_MASK_ONLY
+
+    mask2 = np.zeros((src.shape[0] + 2, src.shape[1] + 2), dtype=np.uint8)
+    print('low:', low, 'up:', up)
+    cv.floodFill(src, mask2, seed, newVal, (low, low, low), (up, up, up), flags)
+    mask = mask2[1:-1,1:-1]
+
+    cv.imshow('Mask', mask)
+    Hist_and_Backproj(mask)
+
+def Hist_and_Backproj(mask):
+    h_bins = 30
+    s_bins = 32
+    histSize = [h_bins, s_bins]
+    h_range = [0, 180]
+    s_range = [0, 256]
+    ranges = h_range + s_range # Concat list
+    channels = [0, 1]
+
+    # Get the Histogram and normalize it
+    hist = cv.calcHist([hsv], channels, mask, histSize, ranges, accumulate=False)
+    cv.normalize(hist, hist, alpha=0, beta=255, norm_type=cv.NORM_MINMAX)
+
+    # Get Backprojection
+    backproj = cv.calcBackProject([hsv], channels, hist, ranges, scale=1)
+
+    # Draw the backproj
+    cv.imshow('BackProj', backproj)
+
+# Read the image
+parser = argparse.ArgumentParser(description='Code for Back Projection tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='home.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Transform it to HSV
+hsv = cv.cvtColor(src, cv.COLOR_BGR2HSV)
+
+# Show the image
+window_image = 'Source image'
+cv.namedWindow(window_image)
+cv.imshow(window_image, src)
+
+# Set Trackbars for floodfill thresholds
+cv.createTrackbar('Low thresh', window_image, low, 255, callback_low)
+cv.createTrackbar('High thresh', window_image, up, 255, callback_up)
+# Set a Mouse Callback
+cv.setMouseCallback(window_image, pickPoint)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/Histograms_Matching/histogram_calculation/calcHist_Demo.py

@@ -0,0 +1,71 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Load image]
+parser = argparse.ArgumentParser(description='Code for Histogram Calculation tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Load image]
+
+## [Separate the image in 3 places ( B, G and R )]
+bgr_planes = cv.split(src)
+## [Separate the image in 3 places ( B, G and R )]
+
+## [Establish the number of bins]
+histSize = 256
+## [Establish the number of bins]
+
+## [Set the ranges ( for B,G,R) )]
+histRange = (0, 256) # the upper boundary is exclusive
+## [Set the ranges ( for B,G,R) )]
+
+## [Set histogram param]
+accumulate = False
+## [Set histogram param]
+
+## [Compute the histograms]
+b_hist = cv.calcHist(bgr_planes, [0], None, [histSize], histRange, accumulate=accumulate)
+g_hist = cv.calcHist(bgr_planes, [1], None, [histSize], histRange, accumulate=accumulate)
+r_hist = cv.calcHist(bgr_planes, [2], None, [histSize], histRange, accumulate=accumulate)
+## [Compute the histograms]
+
+## [Draw the histograms for B, G and R]
+hist_w = 512
+hist_h = 400
+bin_w = int(round( hist_w/histSize ))
+
+histImage = np.zeros((hist_h, hist_w, 3), dtype=np.uint8)
+## [Draw the histograms for B, G and R]
+
+## [Normalize the result to ( 0, histImage.rows )]
+cv.normalize(b_hist, b_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
+cv.normalize(g_hist, g_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
+cv.normalize(r_hist, r_hist, alpha=0, beta=hist_h, norm_type=cv.NORM_MINMAX)
+## [Normalize the result to ( 0, histImage.rows )]
+
+## [Draw for each channel]
+for i in range(1, histSize):
+    cv.line(histImage, ( bin_w*(i-1), hist_h - int(b_hist[i-1]) ),
+            ( bin_w*(i), hist_h - int(b_hist[i]) ),
+            ( 255, 0, 0), thickness=2)
+    cv.line(histImage, ( bin_w*(i-1), hist_h - int(g_hist[i-1]) ),
+            ( bin_w*(i), hist_h - int(g_hist[i]) ),
+            ( 0, 255, 0), thickness=2)
+    cv.line(histImage, ( bin_w*(i-1), hist_h - int(r_hist[i-1]) ),
+            ( bin_w*(i), hist_h - int(r_hist[i]) ),
+            ( 0, 0, 255), thickness=2)
+## [Draw for each channel]
+
+## [Display]
+cv.imshow('Source image', src)
+cv.imshow('calcHist Demo', histImage)
+cv.waitKey()
+## [Display]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/Histograms_Matching/histogram_comparison/compareHist_Demo.py

@@ -0,0 +1,69 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Load three images with different environment settings]
+parser = argparse.ArgumentParser(description='Code for Histogram Comparison tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.')
+parser.add_argument('--input2', help='Path to input image 2.')
+parser.add_argument('--input3', help='Path to input image 3.')
+args = parser.parse_args()
+
+src_base = cv.imread(args.input1)
+src_test1 = cv.imread(args.input2)
+src_test2 = cv.imread(args.input3)
+if src_base is None or src_test1 is None or src_test2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+## [Load three images with different environment settings]
+
+## [Convert to HSV]
+hsv_base = cv.cvtColor(src_base, cv.COLOR_BGR2HSV)
+hsv_test1 = cv.cvtColor(src_test1, cv.COLOR_BGR2HSV)
+hsv_test2 = cv.cvtColor(src_test2, cv.COLOR_BGR2HSV)
+## [Convert to HSV]
+
+## [Convert to HSV half]
+hsv_half_down = hsv_base[hsv_base.shape[0]//2:,:]
+## [Convert to HSV half]
+
+## [Using 50 bins for hue and 60 for saturation]
+h_bins = 50
+s_bins = 60
+histSize = [h_bins, s_bins]
+
+# hue varies from 0 to 179, saturation from 0 to 255
+h_ranges = [0, 180]
+s_ranges = [0, 256]
+ranges = h_ranges + s_ranges # concat lists
+
+# Use the 0-th and 1-st channels
+channels = [0, 1]
+## [Using 50 bins for hue and 60 for saturation]
+
+## [Calculate the histograms for the HSV images]
+hist_base = cv.calcHist([hsv_base], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_base, hist_base, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+
+hist_half_down = cv.calcHist([hsv_half_down], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_half_down, hist_half_down, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+
+hist_test1 = cv.calcHist([hsv_test1], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_test1, hist_test1, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+
+hist_test2 = cv.calcHist([hsv_test2], channels, None, histSize, ranges, accumulate=False)
+cv.normalize(hist_test2, hist_test2, alpha=0, beta=1, norm_type=cv.NORM_MINMAX)
+## [Calculate the histograms for the HSV images]
+
+## [Apply the histogram comparison methods]
+for compare_method in range(4):
+    base_base = cv.compareHist(hist_base, hist_base, compare_method)
+    base_half = cv.compareHist(hist_base, hist_half_down, compare_method)
+    base_test1 = cv.compareHist(hist_base, hist_test1, compare_method)
+    base_test2 = cv.compareHist(hist_base, hist_test2, compare_method)
+
+    print('Method:', compare_method, 'Perfect, Base-Half, Base-Test(1), Base-Test(2) :',\
+          base_base, '/', base_half, '/', base_test1, '/', base_test2)
+## [Apply the histogram comparison methods]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/Histograms_Matching/histogram_equalization/EqualizeHist_Demo.py

@@ -0,0 +1,31 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+## [Load image]
+parser = argparse.ArgumentParser(description='Code for Histogram Equalization tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Load image]
+
+## [Convert to grayscale]
+src = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+## [Convert to grayscale]
+
+## [Apply Histogram Equalization]
+dst = cv.equalizeHist(src)
+## [Apply Histogram Equalization]
+
+## [Display results]
+cv.imshow('Source image', src)
+cv.imshow('Equalized Image', dst)
+## [Display results]
+
+## [Wait until user exits the program]
+cv.waitKey()
+## [Wait until user exits the program]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/Filter2D/filter2D.py

@@ -0,0 +1,54 @@
+"""
+@file filter2D.py
+@brief Sample code that shows how to implement your own linear filters by using filter2D function
+"""
+import sys
+import cv2 as cv
+import numpy as np
+
+
+def main(argv):
+    window_name = 'filter2D Demo'
+
+    ## [load]
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: filter2D.py [image_name -- default lena.jpg] \n')
+        return -1
+    ## [load]
+    ## [init_arguments]
+    # Initialize ddepth argument for the filter
+    ddepth = -1
+    ## [init_arguments]
+    # Loop - Will filter the image with different kernel sizes each 0.5 seconds
+    ind = 0
+    while True:
+        ## [update_kernel]
+        # Update kernel size for a normalized box filter
+        kernel_size = 3 + 2 * (ind % 5)
+        kernel = np.ones((kernel_size, kernel_size), dtype=np.float32)
+        kernel /= (kernel_size * kernel_size)
+        ## [update_kernel]
+        ## [apply_filter]
+        # Apply filter
+        dst = cv.filter2D(src, ddepth, kernel)
+        ## [apply_filter]
+        cv.imshow(window_name, dst)
+
+        c = cv.waitKey(500)
+        if c == 27:
+            break
+
+        ind += 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/HoughCircle/hough_circle.py

@@ -0,0 +1,59 @@
+import sys
+import cv2 as cv
+import numpy as np
+
+
+def main(argv):
+    ## [load]
+    default_file = 'smarties.png'
+    filename = argv[0] if len(argv) > 0 else default_file
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(filename), cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: hough_circle.py [image_name -- default ' + default_file + '] \n')
+        return -1
+    ## [load]
+
+    ## [convert_to_gray]
+    # Convert it to gray
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    ## [convert_to_gray]
+
+    ## [reduce_noise]
+    # Reduce the noise to avoid false circle detection
+    gray = cv.medianBlur(gray, 5)
+    ## [reduce_noise]
+
+    ## [houghcircles]
+    rows = gray.shape[0]
+    circles = cv.HoughCircles(gray, cv.HOUGH_GRADIENT, 1, rows / 8,
+                               param1=100, param2=30,
+                               minRadius=1, maxRadius=30)
+    ## [houghcircles]
+
+    ## [draw]
+    if circles is not None:
+        circles = np.uint16(np.around(circles))
+        for i in circles[0, :]:
+            center = (i[0], i[1])
+            # circle center
+            cv.circle(src, center, 1, (0, 100, 100), 3)
+            # circle outline
+            radius = i[2]
+            cv.circle(src, center, radius, (255, 0, 255), 3)
+    ## [draw]
+
+    ## [display]
+    cv.imshow("detected circles", src)
+    cv.waitKey(0)
+    ## [display]
+
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/HoughLine/hough_lines.py

@@ -0,0 +1,79 @@
+"""
+@file hough_lines.py
+@brief This program demonstrates line finding with the Hough transform
+"""
+import sys
+import math
+import cv2 as cv
+import numpy as np
+
+
+def main(argv):
+    ## [load]
+    default_file = 'sudoku.png'
+    filename = argv[0] if len(argv) > 0 else default_file
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(filename), cv.IMREAD_GRAYSCALE)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: hough_lines.py [image_name -- default ' + default_file + '] \n')
+        return -1
+    ## [load]
+
+    ## [edge_detection]
+    # Edge detection
+    dst = cv.Canny(src, 50, 200, None, 3)
+    ## [edge_detection]
+
+    # Copy edges to the images that will display the results in BGR
+    cdst = cv.cvtColor(dst, cv.COLOR_GRAY2BGR)
+    cdstP = np.copy(cdst)
+
+    ## [hough_lines]
+    #  Standard Hough Line Transform
+    lines = cv.HoughLines(dst, 1, np.pi / 180, 150, None, 0, 0)
+    ## [hough_lines]
+    ## [draw_lines]
+    # Draw the lines
+    if lines is not None:
+        for i in range(0, len(lines)):
+            rho = lines[i][0][0]
+            theta = lines[i][0][1]
+            a = math.cos(theta)
+            b = math.sin(theta)
+            x0 = a * rho
+            y0 = b * rho
+            pt1 = (int(x0 + 1000*(-b)), int(y0 + 1000*(a)))
+            pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a)))
+
+            cv.line(cdst, pt1, pt2, (0,0,255), 3, cv.LINE_AA)
+    ## [draw_lines]
+
+    ## [hough_lines_p]
+    # Probabilistic Line Transform
+    linesP = cv.HoughLinesP(dst, 1, np.pi / 180, 50, None, 50, 10)
+    ## [hough_lines_p]
+    ## [draw_lines_p]
+    # Draw the lines
+    if linesP is not None:
+        for i in range(0, len(linesP)):
+            l = linesP[i][0]
+            cv.line(cdstP, (l[0], l[1]), (l[2], l[3]), (0,0,255), 3, cv.LINE_AA)
+    ## [draw_lines_p]
+    ## [imshow]
+    # Show results
+    cv.imshow("Source", src)
+    cv.imshow("Detected Lines (in red) - Standard Hough Line Transform", cdst)
+    cv.imshow("Detected Lines (in red) - Probabilistic Line Transform", cdstP)
+    ## [imshow]
+    ## [exit]
+    # Wait and Exit
+    cv.waitKey()
+    return 0
+    ## [exit]
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/LaPlace/laplace_demo.py

@@ -0,0 +1,59 @@
+"""
+@file laplace_demo.py
+@brief Sample code showing how to detect edges using the Laplace operator
+"""
+import sys
+import cv2 as cv
+
+def main(argv):
+    # [variables]
+    # Declare the variables we are going to use
+    ddepth = cv.CV_16S
+    kernel_size = 3
+    window_name = "Laplace Demo"
+    # [variables]
+
+    # [load]
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR) # Load an image
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image')
+        print ('Program Arguments: [image_name -- default lena.jpg]')
+        return -1
+    # [load]
+
+    # [reduce_noise]
+    # Remove noise by blurring with a Gaussian filter
+    src = cv.GaussianBlur(src, (3, 3), 0)
+    # [reduce_noise]
+
+    # [convert_to_gray]
+    # Convert the image to grayscale
+    src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    # [convert_to_gray]
+
+    # Create Window
+    cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
+
+    # [laplacian]
+    # Apply Laplace function
+    dst = cv.Laplacian(src_gray, ddepth, ksize=kernel_size)
+    # [laplacian]
+
+    # [convert]
+    # converting back to uint8
+    abs_dst = cv.convertScaleAbs(dst)
+    # [convert]
+
+    # [display]
+    cv.imshow(window_name, abs_dst)
+    cv.waitKey(0)
+    # [display]
+
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/MakeBorder/copy_make_border.py

@@ -0,0 +1,69 @@
+"""
+@file copy_make_border.py
+@brief Sample code that shows the functionality of copyMakeBorder
+"""
+import sys
+from random import randint
+import cv2 as cv
+
+
+def main(argv):
+    ## [variables]
+    # First we declare the variables we are going to use
+    borderType = cv.BORDER_CONSTANT
+    window_name = "copyMakeBorder Demo"
+    ## [variables]
+    ## [load]
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    # Loads an image
+    src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: copy_make_border.py [image_name -- default lena.jpg] \n')
+        return -1
+    ## [load]
+    # Brief how-to for this program
+    print ('\n'
+           '\t 	 copyMakeBorder Demo: \n'
+           '	 -------------------- \n'
+           ' ** Press \'c\' to set the border to a random constant value \n'
+           ' ** Press \'r\' to set the border to be replicated \n'
+           ' ** Press \'ESC\' to exit the program ')
+    ## [create_window]
+    cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
+    ## [create_window]
+    ## [init_arguments]
+    # Initialize arguments for the filter
+    top = int(0.05 * src.shape[0])  # shape[0] = rows
+    bottom = top
+    left = int(0.05 * src.shape[1])  # shape[1] = cols
+    right = left
+    ## [init_arguments]
+    while 1:
+        ## [update_value]
+        value = [randint(0, 255), randint(0, 255), randint(0, 255)]
+        ## [update_value]
+        ## [copymakeborder]
+        dst = cv.copyMakeBorder(src, top, bottom, left, right, borderType, None, value)
+        ## [copymakeborder]
+        ## [display]
+        cv.imshow(window_name, dst)
+        ## [display]
+        ## [check_keypress]
+        c = cv.waitKey(500)
+
+        if c == 27:
+            break
+        elif c == 99: # 99 = ord('c')
+            borderType = cv.BORDER_CONSTANT
+        elif c == 114: # 114 = ord('r')
+            borderType = cv.BORDER_REPLICATE
+        ## [check_keypress]
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/SobelDemo/sobel_demo.py

@@ -0,0 +1,74 @@
+"""
+@file sobel_demo.py
+@brief Sample code using Sobel and/or Scharr OpenCV functions to make a simple Edge Detector
+"""
+import sys
+import cv2 as cv
+
+
+def main(argv):
+    ## [variables]
+    # First we declare the variables we are going to use
+    window_name = ('Sobel Demo - Simple Edge Detector')
+    scale = 1
+    delta = 0
+    ddepth = cv.CV_16S
+    ## [variables]
+
+    ## [load]
+    # As usual we load our source image (src)
+    # Check number of arguments
+    if len(argv) < 1:
+        print ('Not enough parameters')
+        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
+        return -1
+
+    # Load the image
+    src = cv.imread(argv[0], cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image: ' + argv[0])
+        return -1
+    ## [load]
+
+    ## [reduce_noise]
+    # Remove noise by blurring with a Gaussian filter ( kernel size = 3 )
+    src = cv.GaussianBlur(src, (3, 3), 0)
+    ## [reduce_noise]
+
+    ## [convert_to_gray]
+    # Convert the image to grayscale
+    gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    ## [convert_to_gray]
+
+    ## [sobel]
+    # Gradient-X
+    # grad_x = cv.Scharr(gray,ddepth,1,0)
+    grad_x = cv.Sobel(gray, ddepth, 1, 0, ksize=3, scale=scale, delta=delta, borderType=cv.BORDER_DEFAULT)
+
+    # Gradient-Y
+    # grad_y = cv.Scharr(gray,ddepth,0,1)
+    grad_y = cv.Sobel(gray, ddepth, 0, 1, ksize=3, scale=scale, delta=delta, borderType=cv.BORDER_DEFAULT)
+    ## [sobel]
+
+    ## [convert]
+    # converting back to uint8
+    abs_grad_x = cv.convertScaleAbs(grad_x)
+    abs_grad_y = cv.convertScaleAbs(grad_y)
+    ## [convert]
+
+    ## [blend]
+    ## Total Gradient (approximate)
+    grad = cv.addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0)
+    ## [blend]
+
+    ## [display]
+    cv.imshow(window_name, grad)
+    cv.waitKey(0)
+    ## [display]
+
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/canny_detector/CannyDetector_Demo.py

@@ -0,0 +1,34 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+max_lowThreshold = 100
+window_name = 'Edge Map'
+title_trackbar = 'Min Threshold:'
+ratio = 3
+kernel_size = 3
+
+def CannyThreshold(val):
+    low_threshold = val
+    img_blur = cv.blur(src_gray, (3,3))
+    detected_edges = cv.Canny(img_blur, low_threshold, low_threshold*ratio, kernel_size)
+    mask = detected_edges != 0
+    dst = src * (mask[:,:,None].astype(src.dtype))
+    cv.imshow(window_name, dst)
+
+parser = argparse.ArgumentParser(description='Code for Canny Edge Detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='fruits.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+cv.namedWindow(window_name)
+cv.createTrackbar(title_trackbar, window_name , 0, max_lowThreshold, CannyThreshold)
+
+CannyThreshold(0)
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/distance_transformation/imageSegmentation.py

@@ -0,0 +1,139 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+## [load_image]
+# Load the image
+parser = argparse.ArgumentParser(description='Code for Image Segmentation with Distance Transform and Watershed Algorithm.\
+    Sample code showing how to segment overlapping objects using Laplacian filtering, \
+    in addition to Watershed and Distance Transformation')
+parser.add_argument('--input', help='Path to input image.', default='cards.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Show source image
+cv.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
+src[np.all(src == 255, axis=2)] = 0
+
+# Show output image
+cv.imshow('Black Background Image', src)
+## [black_bg]
+
+## [sharp]
+# Create a kernel that we will use to sharpen our image
+# an approximation of second derivative, a quite strong kernel
+kernel = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]], dtype=np.float32)
+
+# 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
+imgLaplacian = cv.filter2D(src, cv.CV_32F, kernel)
+sharp = np.float32(src)
+imgResult = sharp - imgLaplacian
+
+# convert back to 8bits gray scale
+imgResult = np.clip(imgResult, 0, 255)
+imgResult = imgResult.astype('uint8')
+imgLaplacian = np.clip(imgLaplacian, 0, 255)
+imgLaplacian = np.uint8(imgLaplacian)
+
+#cv.imshow('Laplace Filtered Image', imgLaplacian)
+cv.imshow('New Sharped Image', imgResult)
+## [sharp]
+
+## [bin]
+# Create binary image from source image
+bw = cv.cvtColor(imgResult, cv.COLOR_BGR2GRAY)
+_, bw = cv.threshold(bw, 40, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
+cv.imshow('Binary Image', bw)
+## [bin]
+
+## [dist]
+# Perform the distance transform algorithm
+dist = cv.distanceTransform(bw, cv.DIST_L2, 3)
+
+# Normalize the distance image for range = {0.0, 1.0}
+# so we can visualize and threshold it
+cv.normalize(dist, dist, 0, 1.0, cv.NORM_MINMAX)
+cv.imshow('Distance Transform Image', dist)
+## [dist]
+
+## [peaks]
+# Threshold to obtain the peaks
+# This will be the markers for the foreground objects
+_, dist = cv.threshold(dist, 0.4, 1.0, cv.THRESH_BINARY)
+
+# Dilate a bit the dist image
+kernel1 = np.ones((3,3), dtype=np.uint8)
+dist = cv.dilate(dist, kernel1)
+cv.imshow('Peaks', dist)
+## [peaks]
+
+## [seeds]
+# Create the CV_8U version of the distance image
+# It is needed for findContours()
+dist_8u = dist.astype('uint8')
+
+# Find total markers
+contours, _ = cv.findContours(dist_8u, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
+
+# Create the marker image for the watershed algorithm
+markers = np.zeros(dist.shape, dtype=np.int32)
+
+# Draw the foreground markers
+for i in range(len(contours)):
+    cv.drawContours(markers, contours, i, (i+1), -1)
+
+# Draw the background marker
+cv.circle(markers, (5,5), 3, (255,255,255), -1)
+markers_8u = (markers * 10).astype('uint8')
+cv.imshow('Markers', markers_8u)
+## [seeds]
+
+## [watershed]
+# Perform the watershed algorithm
+cv.watershed(imgResult, markers)
+
+#mark = np.zeros(markers.shape, dtype=np.uint8)
+mark = markers.astype('uint8')
+mark = cv.bitwise_not(mark)
+# uncomment this if you want to see how the mark
+# image looks like at that point
+#cv.imshow('Markers_v2', mark)
+
+# Generate random colors
+colors = []
+for contour in contours:
+    colors.append((rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)))
+
+# Create the result image
+dst = np.zeros((markers.shape[0], markers.shape[1], 3), dtype=np.uint8)
+
+# Fill labeled objects with random colors
+for i in range(markers.shape[0]):
+    for j in range(markers.shape[1]):
+        index = markers[i,j]
+        if index > 0 and index <= len(contours):
+            dst[i,j,:] = colors[index-1]
+
+# Visualize the final image
+cv.imshow('Final Result', dst)
+## [watershed]
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/remap/Remap_Demo.py

@@ -0,0 +1,65 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Update]
+def update_map(ind, map_x, map_y):
+    if ind == 0:
+        for i in range(map_x.shape[0]):
+            for j in range(map_x.shape[1]):
+                if j > map_x.shape[1]*0.25 and j < map_x.shape[1]*0.75 and i > map_x.shape[0]*0.25 and i < map_x.shape[0]*0.75:
+                    map_x[i,j] = 2 * (j-map_x.shape[1]*0.25) + 0.5
+                    map_y[i,j] = 2 * (i-map_y.shape[0]*0.25) + 0.5
+                else:
+                    map_x[i,j] = 0
+                    map_y[i,j] = 0
+    elif ind == 1:
+        for i in range(map_x.shape[0]):
+            map_x[i,:] = [x for x in range(map_x.shape[1])]
+        for j in range(map_y.shape[1]):
+            map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
+    elif ind == 2:
+        for i in range(map_x.shape[0]):
+            map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
+        for j in range(map_y.shape[1]):
+            map_y[:,j] = [y for y in range(map_y.shape[0])]
+    elif ind == 3:
+        for i in range(map_x.shape[0]):
+            map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
+        for j in range(map_y.shape[1]):
+            map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
+## [Update]
+
+parser = argparse.ArgumentParser(description='Code for Remapping tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='chicky_512.png')
+args = parser.parse_args()
+
+## [Load]
+src = cv.imread(cv.samples.findFile(args.input), cv.IMREAD_COLOR)
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+## [Load]
+
+## [Create]
+map_x = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
+map_y = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
+## [Create]
+
+## [Window]
+window_name = 'Remap demo'
+cv.namedWindow(window_name)
+## [Window]
+
+## [Loop]
+ind = 0
+while True:
+    update_map(ind, map_x, map_y)
+    ind = (ind + 1) % 4
+    dst = cv.remap(src, map_x, map_y, cv.INTER_LINEAR)
+    cv.imshow(window_name, dst)
+    c = cv.waitKey(1000)
+    if c == 27:
+        break
+## [Loop]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ImgTrans/warp_affine/Geometric_Transforms_Demo.py

@@ -0,0 +1,54 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+## [Load the image]
+parser = argparse.ArgumentParser(description='Code for Affine Transformations tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+## [Load the image]
+
+## [Set your 3 points to calculate the  Affine Transform]
+srcTri = np.array( [[0, 0], [src.shape[1] - 1, 0], [0, src.shape[0] - 1]] ).astype(np.float32)
+dstTri = np.array( [[0, src.shape[1]*0.33], [src.shape[1]*0.85, src.shape[0]*0.25], [src.shape[1]*0.15, src.shape[0]*0.7]] ).astype(np.float32)
+## [Set your 3 points to calculate the  Affine Transform]
+
+## [Get the Affine Transform]
+warp_mat = cv.getAffineTransform(srcTri, dstTri)
+## [Get the Affine Transform]
+
+## [Apply the Affine Transform just found to the src image]
+warp_dst = cv.warpAffine(src, warp_mat, (src.shape[1], src.shape[0]))
+## [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]
+center = (warp_dst.shape[1]//2, warp_dst.shape[0]//2)
+angle = -50
+scale = 0.6
+## [Compute a rotation matrix with respect to the center of the image]
+
+## [Get the rotation matrix with the specifications above]
+rot_mat = cv.getRotationMatrix2D( center, angle, scale )
+## [Get the rotation matrix with the specifications above]
+
+## [Rotate the warped image]
+warp_rotate_dst = cv.warpAffine(warp_dst, rot_mat, (warp_dst.shape[1], warp_dst.shape[0]))
+## [Rotate the warped image]
+
+## [Show what you got]
+cv.imshow('Source image', src)
+cv.imshow('Warp', warp_dst)
+cv.imshow('Warp + Rotate', warp_rotate_dst)
+## [Show what you got]
+
+## [Wait until user exits the program]
+cv.waitKey()
+## [Wait until user exits the program]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ShapeDescriptors/bounding_rects_circles/generalContours_demo1.py

@@ -0,0 +1,82 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    ## [Canny]
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+    ## [Canny]
+
+    ## [findContours]
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    ## [findContours]
+
+    ## [allthework]
+    # Approximate contours to polygons + get bounding rects and circles
+    contours_poly = [None]*len(contours)
+    boundRect = [None]*len(contours)
+    centers = [None]*len(contours)
+    radius = [None]*len(contours)
+    for i, c in enumerate(contours):
+        contours_poly[i] = cv.approxPolyDP(c, 3, True)
+        boundRect[i] = cv.boundingRect(contours_poly[i])
+        centers[i], radius[i] = cv.minEnclosingCircle(contours_poly[i])
+    ## [allthework]
+
+    ## [zeroMat]
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    ## [zeroMat]
+
+    ## [forContour]
+    # Draw polygonal contour + bonding rects + circles
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours_poly, i, color)
+        cv.rectangle(drawing, (int(boundRect[i][0]), int(boundRect[i][1])), \
+          (int(boundRect[i][0]+boundRect[i][2]), int(boundRect[i][1]+boundRect[i][3])), color, 2)
+        cv.circle(drawing, (int(centers[i][0]), int(centers[i][1])), int(radius[i]), color, 2)
+    ## [forContour]
+
+    ## [showDrawings]
+    # Show in a window
+    cv.imshow('Contours', drawing)
+    ## [showDrawings]
+
+## [setup]
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Creating Bounding boxes and circles for contours tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+## [setup]
+
+## [createWindow]
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+## [createWindow]
+## [trackbar]
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+## [trackbar]
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ShapeDescriptors/bounding_rotated_ellipses/generalContours_demo2.py

@@ -0,0 +1,82 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    ## [Canny]
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+    ## [Canny]
+
+    ## [findContours]
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    ## [findContours]
+
+    # Find the rotated rectangles and ellipses for each contour
+    minRect = [None]*len(contours)
+    minEllipse = [None]*len(contours)
+    for i, c in enumerate(contours):
+        minRect[i] = cv.minAreaRect(c)
+        if c.shape[0] > 5:
+            minEllipse[i] = cv.fitEllipse(c)
+
+    # Draw contours + rotated rects + ellipses
+    ## [zeroMat]
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    ## [zeroMat]
+    ## [forContour]
+    for i, c in enumerate(contours):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        # contour
+        cv.drawContours(drawing, contours, i, color)
+        # ellipse
+        if c.shape[0] > 5:
+            cv.ellipse(drawing, minEllipse[i], color, 2)
+        # rotated rectangle
+        box = cv.boxPoints(minRect[i])
+        box = np.intp(box) #np.intp: Integer used for indexing (same as C ssize_t; normally either int32 or int64)
+        cv.drawContours(drawing, [box], 0, color)
+    ## [forContour]
+
+    ## [showDrawings]
+    # Show in a window
+    cv.imshow('Contours', drawing)
+    ## [showDrawings]
+
+## [setup]
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Creating Bounding rotated boxes and ellipses for contours tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+## [setup]
+
+## [createWindow]
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+## [createWindow]
+## [trackbar]
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+## [trackbar]
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ShapeDescriptors/find_contours/findContours_demo.py

@@ -0,0 +1,50 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+
+    # Find contours
+    contours, hierarchy = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+    # Draw contours
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours, i, color, 2, cv.LINE_8, hierarchy, 0)
+
+    # Show in a window
+    cv.imshow('Contours', drawing)
+
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Finding contours in your image tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='HappyFish.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ShapeDescriptors/hull/hull_demo.py

@@ -0,0 +1,57 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+    # Find the convex hull object for each contour
+    hull_list = []
+    for i in range(len(contours)):
+        hull = cv.convexHull(contours[i])
+        hull_list.append(hull)
+
+    # Draw contours + hull results
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours, i, color)
+        cv.drawContours(drawing, hull_list, i, color)
+
+    # Show in a window
+    cv.imshow('Contours', drawing)
+
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Convex Hull tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ShapeDescriptors/moments/moments_demo.py

@@ -0,0 +1,83 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+rng.seed(12345)
+
+def thresh_callback(val):
+    threshold = val
+
+    ## [Canny]
+    # Detect edges using Canny
+    canny_output = cv.Canny(src_gray, threshold, threshold * 2)
+    ## [Canny]
+
+    ## [findContours]
+    # Find contours
+    contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+    ## [findContours]
+
+    # Get the moments
+    mu = [None]*len(contours)
+    for i in range(len(contours)):
+        mu[i] = cv.moments(contours[i])
+
+    # Get the mass centers
+    mc = [None]*len(contours)
+    for i in range(len(contours)):
+        # add 1e-5 to avoid division by zero
+        mc[i] = (mu[i]['m10'] / (mu[i]['m00'] + 1e-5), mu[i]['m01'] / (mu[i]['m00'] + 1e-5))
+
+    # Draw contours
+    ## [zeroMat]
+    drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8)
+    ## [zeroMat]
+    ## [forContour]
+    for i in range(len(contours)):
+        color = (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256))
+        cv.drawContours(drawing, contours, i, color, 2)
+        cv.circle(drawing, (int(mc[i][0]), int(mc[i][1])), 4, color, -1)
+    ## [forContour]
+
+    ## [showDrawings]
+    # Show in a window
+    cv.imshow('Contours', drawing)
+    ## [showDrawings]
+
+    # Calculate the area with the moments 00 and compare with the result of the OpenCV function
+    for i in range(len(contours)):
+        print(' * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f' % (i, mu[i]['m00'], cv.contourArea(contours[i]), cv.arcLength(contours[i], True)))
+
+## [setup]
+# Load source image
+parser = argparse.ArgumentParser(description='Code for Image Moments tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+# Convert image to gray and blur it
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+src_gray = cv.blur(src_gray, (3,3))
+## [setup]
+
+## [createWindow]
+# Create Window
+source_window = 'Source'
+cv.namedWindow(source_window)
+cv.imshow(source_window, src)
+## [createWindow]
+## [trackbar]
+max_thresh = 255
+thresh = 100 # initial threshold
+cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
+thresh_callback(thresh)
+## [trackbar]
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/ShapeDescriptors/point_polygon_test/pointPolygonTest_demo.py

@@ -0,0 +1,52 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+
+# Create an image
+r = 100
+src = np.zeros((4*r, 4*r), dtype=np.uint8)
+
+# Create a sequence of points to make a contour
+vert = [None]*6
+vert[0] = (3*r//2, int(1.34*r))
+vert[1] = (1*r, 2*r)
+vert[2] = (3*r//2, int(2.866*r))
+vert[3] = (5*r//2, int(2.866*r))
+vert[4] = (3*r, 2*r)
+vert[5] = (5*r//2, int(1.34*r))
+
+# Draw it in src
+for i in range(6):
+    cv.line(src, vert[i],  vert[(i+1)%6], ( 255 ), 3)
+
+# Get the contours
+contours, _ = cv.findContours(src, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+
+# Calculate the distances to the contour
+raw_dist = np.empty(src.shape, dtype=np.float32)
+for i in range(src.shape[0]):
+    for j in range(src.shape[1]):
+        raw_dist[i,j] = cv.pointPolygonTest(contours[0], (j,i), True)
+
+minVal, maxVal, _, maxDistPt = cv.minMaxLoc(raw_dist)
+minVal = abs(minVal)
+maxVal = abs(maxVal)
+
+# Depicting the  distances graphically
+drawing = np.zeros((src.shape[0], src.shape[1], 3), dtype=np.uint8)
+for i in range(src.shape[0]):
+    for j in range(src.shape[1]):
+        if raw_dist[i,j] < 0:
+            drawing[i,j,0] = 255 - abs(raw_dist[i,j]) * 255 / minVal
+        elif raw_dist[i,j] > 0:
+            drawing[i,j,2] = 255 - raw_dist[i,j] * 255 / maxVal
+        else:
+            drawing[i,j,0] = 255
+            drawing[i,j,1] = 255
+            drawing[i,j,2] = 255
+
+cv.circle(drawing,maxDistPt, int(maxVal),(255,255,255), 1, cv.LINE_8, 0)
+cv.imshow('Source', src)
+cv.imshow('Distance and inscribed circle', drawing)
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/TrackingMotion/corner_subpixels/cornerSubPix_Demo.py

@@ -0,0 +1,70 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+source_window = 'Image'
+maxTrackbar = 25
+rng.seed(12345)
+
+def goodFeaturesToTrack_Demo(val):
+    maxCorners = max(val, 1)
+
+    # Parameters for Shi-Tomasi algorithm
+    qualityLevel = 0.01
+    minDistance = 10
+    blockSize = 3
+    gradientSize = 3
+    useHarrisDetector = False
+    k = 0.04
+
+    # Copy the source image
+    copy = np.copy(src)
+
+    # Apply corner detection
+    corners = cv.goodFeaturesToTrack(src_gray, maxCorners, qualityLevel, minDistance, None, \
+        blockSize=blockSize, gradientSize=gradientSize, useHarrisDetector=useHarrisDetector, k=k)
+
+    # Draw corners detected
+    print('** Number of corners detected:', corners.shape[0])
+    radius = 4
+    for i in range(corners.shape[0]):
+        cv.circle(copy, (int(corners[i,0,0]), int(corners[i,0,1])), radius, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    # Show what you got
+    cv.namedWindow(source_window)
+    cv.imshow(source_window, copy)
+
+    # Set the needed parameters to find the refined corners
+    winSize = (5, 5)
+    zeroZone = (-1, -1)
+    criteria = (cv.TERM_CRITERIA_EPS + cv.TermCriteria_COUNT, 40, 0.001)
+
+    # Calculate the refined corner locations
+    corners = cv.cornerSubPix(src_gray, corners, winSize, zeroZone, criteria)
+
+    # Write them down
+    for i in range(corners.shape[0]):
+        print(" -- Refined Corner [", i, "]  (", corners[i,0,0], ",", corners[i,0,1], ")")
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Shi-Tomasi corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='pic3.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Create a window and a trackbar
+cv.namedWindow(source_window)
+maxCorners = 10 # initial threshold
+cv.createTrackbar('Threshold: ', source_window, maxCorners, maxTrackbar, goodFeaturesToTrack_Demo)
+cv.imshow(source_window, src)
+goodFeaturesToTrack_Demo(maxCorners)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/TrackingMotion/generic_corner_detector/cornerDetector_Demo.py

@@ -0,0 +1,80 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+myHarris_window = 'My Harris corner detector'
+myShiTomasi_window = 'My Shi Tomasi corner detector'
+myHarris_qualityLevel = 50
+myShiTomasi_qualityLevel = 50
+max_qualityLevel = 100
+rng.seed(12345)
+
+def myHarris_function(val):
+    myHarris_copy = np.copy(src)
+    myHarris_qualityLevel = max(val, 1)
+
+    for i in range(src_gray.shape[0]):
+        for j in range(src_gray.shape[1]):
+            if Mc[i,j] > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel:
+                cv.circle(myHarris_copy, (j,i), 4, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    cv.imshow(myHarris_window, myHarris_copy)
+
+def myShiTomasi_function(val):
+    myShiTomasi_copy = np.copy(src)
+    myShiTomasi_qualityLevel = max(val, 1)
+
+    for i in range(src_gray.shape[0]):
+        for j in range(src_gray.shape[1]):
+            if myShiTomasi_dst[i,j] > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel:
+                cv.circle(myShiTomasi_copy, (j,i), 4, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    cv.imshow(myShiTomasi_window, myShiTomasi_copy)
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Creating your own corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='building.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Set some parameters
+blockSize = 3
+apertureSize = 3
+
+# My Harris matrix -- Using cornerEigenValsAndVecs
+myHarris_dst = cv.cornerEigenValsAndVecs(src_gray, blockSize, apertureSize)
+
+# calculate Mc
+Mc = np.empty(src_gray.shape, dtype=np.float32)
+for i in range(src_gray.shape[0]):
+    for j in range(src_gray.shape[1]):
+        lambda_1 = myHarris_dst[i,j,0]
+        lambda_2 = myHarris_dst[i,j,1]
+        Mc[i,j] = lambda_1*lambda_2 - 0.04*pow( ( lambda_1 + lambda_2 ), 2 )
+
+myHarris_minVal, myHarris_maxVal, _, _ = cv.minMaxLoc(Mc)
+
+# Create Window and Trackbar
+cv.namedWindow(myHarris_window)
+cv.createTrackbar('Quality Level:', myHarris_window, myHarris_qualityLevel, max_qualityLevel, myHarris_function)
+myHarris_function(myHarris_qualityLevel)
+
+# My Shi-Tomasi -- Using cornerMinEigenVal
+myShiTomasi_dst = cv.cornerMinEigenVal(src_gray, blockSize, apertureSize)
+
+myShiTomasi_minVal, myShiTomasi_maxVal, _, _ = cv.minMaxLoc(myShiTomasi_dst)
+
+# Create Window and Trackbar
+cv.namedWindow(myShiTomasi_window)
+cv.createTrackbar('Quality Level:', myShiTomasi_window, myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function)
+myShiTomasi_function(myShiTomasi_qualityLevel)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/TrackingMotion/good_features_to_track/goodFeaturesToTrack_Demo.py

@@ -0,0 +1,58 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+import random as rng
+
+source_window = 'Image'
+maxTrackbar = 100
+rng.seed(12345)
+
+def goodFeaturesToTrack_Demo(val):
+    maxCorners = max(val, 1)
+
+    # Parameters for Shi-Tomasi algorithm
+    qualityLevel = 0.01
+    minDistance = 10
+    blockSize = 3
+    gradientSize = 3
+    useHarrisDetector = False
+    k = 0.04
+
+    # Copy the source image
+    copy = np.copy(src)
+
+    # Apply corner detection
+    corners = cv.goodFeaturesToTrack(src_gray, maxCorners, qualityLevel, minDistance, None, \
+        blockSize=blockSize, gradientSize=gradientSize, useHarrisDetector=useHarrisDetector, k=k)
+
+    # Draw corners detected
+    print('** Number of corners detected:', corners.shape[0])
+    radius = 4
+    for i in range(corners.shape[0]):
+        cv.circle(copy, (int(corners[i,0,0]), int(corners[i,0,1])), radius, (rng.randint(0,256), rng.randint(0,256), rng.randint(0,256)), cv.FILLED)
+
+    # Show what you got
+    cv.namedWindow(source_window)
+    cv.imshow(source_window, copy)
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Shi-Tomasi corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='pic3.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Create a window and a trackbar
+cv.namedWindow(source_window)
+maxCorners = 23 # initial threshold
+cv.createTrackbar('Threshold: ', source_window, maxCorners, maxTrackbar, goodFeaturesToTrack_Demo)
+cv.imshow(source_window, src)
+goodFeaturesToTrack_Demo(maxCorners)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/TrackingMotion/harris_detector/cornerHarris_Demo.py

@@ -0,0 +1,55 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+source_window = 'Source image'
+corners_window = 'Corners detected'
+max_thresh = 255
+
+def cornerHarris_demo(val):
+    thresh = val
+
+    # Detector parameters
+    blockSize = 2
+    apertureSize = 3
+    k = 0.04
+
+    # Detecting corners
+    dst = cv.cornerHarris(src_gray, blockSize, apertureSize, k)
+
+    # Normalizing
+    dst_norm = np.empty(dst.shape, dtype=np.float32)
+    cv.normalize(dst, dst_norm, alpha=0, beta=255, norm_type=cv.NORM_MINMAX)
+    dst_norm_scaled = cv.convertScaleAbs(dst_norm)
+
+    # Drawing a circle around corners
+    for i in range(dst_norm.shape[0]):
+        for j in range(dst_norm.shape[1]):
+            if int(dst_norm[i,j]) > thresh:
+                cv.circle(dst_norm_scaled, (j,i), 5, (0), 2)
+
+    # Showing the result
+    cv.namedWindow(corners_window)
+    cv.imshow(corners_window, dst_norm_scaled)
+
+# Load source image and convert it to gray
+parser = argparse.ArgumentParser(description='Code for Harris corner detector tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='building.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+
+# Create a window and a trackbar
+cv.namedWindow(source_window)
+thresh = 200 # initial threshold
+cv.createTrackbar('Threshold: ', source_window, thresh, max_thresh, cornerHarris_demo)
+cv.imshow(source_window, src)
+cornerHarris_demo(thresh)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/core/AddingImages/adding_images.py

@@ -0,0 +1,36 @@
+from __future__ import print_function
+
+import cv2 as cv
+
+alpha = 0.5
+
+try:
+    raw_input          # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+print(''' Simple Linear Blender
+-----------------------
+* Enter alpha [0.0-1.0]: ''')
+input_alpha = float(raw_input().strip())
+if 0 <= alpha <= 1:
+    alpha = input_alpha
+# [load]
+src1 = cv.imread(cv.samples.findFile('LinuxLogo.jpg'))
+src2 = cv.imread(cv.samples.findFile('WindowsLogo.jpg'))
+# [load]
+if src1 is None:
+    print("Error loading src1")
+    exit(-1)
+elif src2 is None:
+    print("Error loading src2")
+    exit(-1)
+# [blend_images]
+beta = (1.0 - alpha)
+dst = cv.addWeighted(src1, alpha, src2, beta, 0.0)
+# [blend_images]
+# [display]
+cv.imshow('dst', dst)
+cv.waitKey(0)
+# [display]
+cv.destroyAllWindows()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.py

@@ -0,0 +1,80 @@
+from __future__ import print_function
+import sys
+
+import cv2 as cv
+import numpy as np
+
+
+def print_help():
+    print('''
+    This program demonstrated the use of the discrete Fourier transform (DFT).
+    The dft of an image is taken and it's power spectrum is displayed.
+    Usage:
+    discrete_fourier_transform.py [image_name -- default lena.jpg]''')
+
+
+def main(argv):
+
+    print_help()
+
+    filename = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    I = cv.imread(cv.samples.findFile(filename), cv.IMREAD_GRAYSCALE)
+    if I is None:
+        print('Error opening image')
+        return -1
+    ## [expand]
+    rows, cols = I.shape
+    m = cv.getOptimalDFTSize( rows )
+    n = cv.getOptimalDFTSize( cols )
+    padded = cv.copyMakeBorder(I, 0, m - rows, 0, n - cols, cv.BORDER_CONSTANT, value=[0, 0, 0])
+    ## [expand]
+    ## [complex_and_real]
+    planes = [np.float32(padded), np.zeros(padded.shape, np.float32)]
+    complexI = cv.merge(planes)         # Add to the expanded another plane with zeros
+    ## [complex_and_real]
+    ## [dft]
+    cv.dft(complexI, complexI)         # this way the result may fit in the source matrix
+    ## [dft]
+    # compute the magnitude and switch to logarithmic scale
+    # = > log(1 + sqrt(Re(DFT(I)) ^ 2 + Im(DFT(I)) ^ 2))
+    ## [magnitude]
+    cv.split(complexI, planes)                   # planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
+    cv.magnitude(planes[0], planes[1], planes[0])# planes[0] = magnitude
+    magI = planes[0]
+    ## [magnitude]
+    ## [log]
+    matOfOnes = np.ones(magI.shape, dtype=magI.dtype)
+    cv.add(matOfOnes, magI, magI) #  switch to logarithmic scale
+    cv.log(magI, magI)
+    ## [log]
+    ## [crop_rearrange]
+    magI_rows, magI_cols = magI.shape
+    # crop the spectrum, if it has an odd number of rows or columns
+    magI = magI[0:(magI_rows & -2), 0:(magI_cols & -2)]
+    cx = int(magI_rows/2)
+    cy = int(magI_cols/2)
+
+    q0 = magI[0:cx, 0:cy]         # Top-Left - Create a ROI per quadrant
+    q1 = magI[cx:cx+cx, 0:cy]     # Top-Right
+    q2 = magI[0:cx, cy:cy+cy]     # Bottom-Left
+    q3 = magI[cx:cx+cx, cy:cy+cy] # Bottom-Right
+
+    tmp = np.copy(q0)               # swap quadrants (Top-Left with Bottom-Right)
+    magI[0:cx, 0:cy] = q3
+    magI[cx:cx + cx, cy:cy + cy] = tmp
+
+    tmp = np.copy(q1)               # swap quadrant (Top-Right with Bottom-Left)
+    magI[cx:cx + cx, 0:cy] = q2
+    magI[0:cx, cy:cy + cy] = tmp
+    ## [crop_rearrange]
+    ## [normalize]
+    cv.normalize(magI, magI, 0, 1, cv.NORM_MINMAX) # Transform the matrix with float values into a
+    ## viewable image form(float between values 0 and 1).
+    ## [normalize]
+    cv.imshow("Input Image"       , I   )    # Show the result
+    cv.imshow("spectrum magnitude", magI)
+    cv.waitKey()
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/core/file_input_output/file_input_output.py

@@ -0,0 +1,157 @@
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import sys
+
+def help(filename):
+    print (
+        '''
+        {0} shows the usage of the OpenCV serialization functionality. \n\n
+        usage:\n
+            python3 {0} outputfile.yml.gz\n\n
+        The output file may be either in XML, YAML or JSON. You can even compress it\n
+        by specifying this in its extension like xml.gz yaml.gz etc... With\n
+        FileStorage you can serialize objects in OpenCV.\n\n
+        For example: - create a class and have it serialized\n
+                     - use it to read and write matrices.\n
+        '''.format(filename)
+    )
+
+class MyData:
+    A = 97
+    X = np.pi
+    name = 'mydata1234'
+
+    def __repr__(self):
+        s = '{ name = ' + self.name + ', X = ' + str(self.X)
+        s = s + ', A = ' +  str(self.A) + '}'
+        return s
+
+    ## [inside]
+    def write(self, fs, name):
+        fs.startWriteStruct(name, cv.FileNode_MAP|cv.FileNode_FLOW)
+        fs.write('A', self.A)
+        fs.write('X', self.X)
+        fs.write('name', self.name)
+        fs.endWriteStruct()
+
+    def read(self, node):
+        if (not node.empty()):
+            self.A = int(node.getNode('A').real())
+            self.X = node.getNode('X').real()
+            self.name = node.getNode('name').string()
+        else:
+            self.A = self.X = 0
+            self.name = ''
+    ## [inside]
+
+def main(argv):
+    if len(argv) != 2:
+        help(argv[0])
+        exit(1)
+
+    # write
+    ## [iomati]
+    R = np.eye(3,3)
+    T = np.zeros((3,1))
+    ## [iomati]
+    ## [customIOi]
+    m = MyData()
+    ## [customIOi]
+
+    filename = argv[1]
+
+    ## [open]
+    s = cv.FileStorage(filename, cv.FileStorage_WRITE)
+    # or:
+    # s = cv.FileStorage()
+    # s.open(filename, cv.FileStorage_WRITE)
+    ## [open]
+
+    ## [writeNum]
+    s.write('iterationNr', 100)
+    ## [writeNum]
+
+    ## [writeStr]
+    s.startWriteStruct('strings', cv.FileNode_SEQ)
+    for elem in ['image1.jpg', 'Awesomeness', '../data/baboon.jpg']:
+        s.write('', elem)
+    s.endWriteStruct()
+    ## [writeStr]
+
+    ## [writeMap]
+    s.startWriteStruct('Mapping', cv.FileNode_MAP)
+    s.write('One', 1)
+    s.write('Two', 2)
+    s.endWriteStruct()
+    ## [writeMap]
+
+    ## [iomatw]
+    s.write('R_MAT', R)
+    s.write('T_MAT', T)
+    ## [iomatw]
+
+    ## [customIOw]
+    m.write(s, 'MyData')
+    ## [customIOw]
+    ## [close]
+    s.release()
+    ## [close]
+    print ('Write Done.')
+
+    # read
+    print ('\nReading: ')
+    s = cv.FileStorage()
+    s.open(filename, cv.FileStorage_READ)
+
+    ## [readNum]
+    n = s.getNode('iterationNr')
+    itNr = int(n.real())
+    ## [readNum]
+    print (itNr)
+
+    if (not s.isOpened()):
+        print ('Failed to open ', filename, file=sys.stderr)
+        help(argv[0])
+        exit(1)
+
+    ## [readStr]
+    n = s.getNode('strings')
+    if (not n.isSeq()):
+        print ('strings is not a sequence! FAIL', file=sys.stderr)
+        exit(1)
+
+    for i in range(n.size()):
+        print (n.at(i).string())
+    ## [readStr]
+
+    ## [readMap]
+    n = s.getNode('Mapping')
+    print ('Two',int(n.getNode('Two').real()),'; ')
+    print ('One',int(n.getNode('One').real()),'\n')
+    ## [readMap]
+
+    ## [iomat]
+    R = s.getNode('R_MAT').mat()
+    T = s.getNode('T_MAT').mat()
+    ## [iomat]
+    ## [customIO]
+    m.read(s.getNode('MyData'))
+    ## [customIO]
+
+    print ('\nR =',R)
+    print ('T =',T,'\n')
+    print ('MyData =','\n',m,'\n')
+
+    ## [nonexist]
+    print ('Attempt to read NonExisting (should initialize the data structure',
+            'with its default).')
+    m.read(s.getNode('NonExisting'))
+    print ('\nNonExisting =','\n',m)
+    ## [nonexist]
+
+    print ('\nTip: Open up',filename,'with a text editor to see the serialized data.')
+
+if __name__ == '__main__':
+    main(sys.argv)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/core/mat_mask_operations/mat_mask_operations.py

@@ -0,0 +1,100 @@
+from __future__ import print_function
+import sys
+import time
+
+import numpy as np
+import cv2 as cv
+
+## [basic_method]
+def is_grayscale(my_image):
+    return len(my_image.shape) < 3
+
+
+def saturated(sum_value):
+    if sum_value > 255:
+        sum_value = 255
+    if sum_value < 0:
+        sum_value = 0
+
+    return sum_value
+
+
+def sharpen(my_image):
+    if is_grayscale(my_image):
+        height, width = my_image.shape
+    else:
+        my_image = cv.cvtColor(my_image, cv.CV_8U)
+        height, width, n_channels = my_image.shape
+
+    result = np.zeros(my_image.shape, my_image.dtype)
+    ## [basic_method_loop]
+    for j in range(1, height - 1):
+        for i in range(1, width - 1):
+            if is_grayscale(my_image):
+                sum_value = 5 * my_image[j, i] - my_image[j + 1, i] - my_image[j - 1, i] \
+                            - my_image[j, i + 1] - my_image[j, i - 1]
+                result[j, i] = saturated(sum_value)
+            else:
+                for k in range(0, n_channels):
+                    sum_value = 5 * my_image[j, i, k] - my_image[j + 1, i, k]  \
+                                - my_image[j - 1, i, k] - my_image[j, i + 1, k]\
+                                - my_image[j, i - 1, k]
+                    result[j, i, k] = saturated(sum_value)
+    ## [basic_method_loop]
+    return result
+## [basic_method]
+
+def main(argv):
+    filename = 'lena.jpg'
+
+    img_codec = cv.IMREAD_COLOR
+    if argv:
+        filename = sys.argv[1]
+        if len(argv) >= 2 and sys.argv[2] == "G":
+            img_codec = cv.IMREAD_GRAYSCALE
+
+    src = cv.imread(cv.samples.findFile(filename), img_codec)
+
+    if src is None:
+        print("Can't open image [" + filename + "]")
+        print("Usage:")
+        print("mat_mask_operations.py [image_path -- default lena.jpg] [G -- grayscale]")
+        return -1
+
+    cv.namedWindow("Input", cv.WINDOW_AUTOSIZE)
+    cv.namedWindow("Output", cv.WINDOW_AUTOSIZE)
+
+    cv.imshow("Input", src)
+    t = round(time.time())
+
+    dst0 = sharpen(src)
+
+    t = (time.time() - t)
+    print("Hand written function time passed in seconds: %s" % t)
+
+    cv.imshow("Output", dst0)
+    cv.waitKey()
+
+    t = time.time()
+    ## [kern]
+    kernel = np.array([[0, -1, 0],
+                       [-1, 5, -1],
+                       [0, -1, 0]], np.float32)  # kernel should be floating point type
+    ## [kern]
+    ## [filter2D]
+    dst1 = cv.filter2D(src, -1, kernel)
+    # ddepth = -1, means destination image has depth same as input image
+    ## [filter2D]
+
+    t = (time.time() - t)
+    print("Built-in filter2D time passed in seconds:     %s" % t)
+
+    cv.imshow("Output", dst1)
+
+    cv.waitKey(0)
+    cv.destroyAllWindows()
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/core/mat_operations/mat_operations.py

@@ -0,0 +1,92 @@
+from __future__ import division
+import cv2 as cv
+import numpy as np
+
+# Snippet code for Operations with images tutorial (not intended to be run)
+
+def load():
+    # Input/Output
+    filename = 'img.jpg'
+    ## [Load an image from a file]
+    img = cv.imread(filename)
+    ## [Load an image from a file]
+
+    ## [Load an image from a file in grayscale]
+    img = cv.imread(filename, cv.IMREAD_GRAYSCALE)
+    ## [Load an image from a file in grayscale]
+
+    ## [Save image]
+    cv.imwrite(filename, img)
+    ## [Save image]
+
+def access_pixel():
+    # Accessing pixel intensity values
+    img = np.empty((4,4,3), np.uint8)
+    y = 0
+    x = 0
+    ## [Pixel access 1]
+    _intensity = img[y,x]
+    ## [Pixel access 1]
+
+    ## [Pixel access 3]
+    _blue = img[y,x,0]
+    _green = img[y,x,1]
+    _red = img[y,x,2]
+    ## [Pixel access 3]
+
+    ## [Pixel access 5]
+    img[y,x] = 128
+    ## [Pixel access 5]
+
+def reference_counting():
+    # Memory management and reference counting
+    ## [Reference counting 2]
+    img = cv.imread('image.jpg')
+    _img1 = np.copy(img)
+    ## [Reference counting 2]
+
+    ## [Reference counting 3]
+    img = cv.imread('image.jpg')
+    _sobelx = cv.Sobel(img, cv.CV_32F, 1, 0)
+    ## [Reference counting 3]
+
+def primitive_operations():
+    img = np.empty((4,4,3), np.uint8)
+    ## [Set image to black]
+    img[:] = 0
+    ## [Set image to black]
+
+    ## [Select ROI]
+    _smallImg = img[10:110,10:110]
+    ## [Select ROI]
+
+    ## [BGR to Gray]
+    img = cv.imread('image.jpg')
+    _grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+    ## [BGR to Gray]
+
+    src = np.ones((4,4), np.uint8)
+    ## [Convert to CV_32F]
+    _dst = src.astype(np.float32)
+    ## [Convert to CV_32F]
+
+def visualize_images():
+    ## [imshow 1]
+    img = cv.imread('image.jpg')
+    cv.namedWindow('image', cv.WINDOW_AUTOSIZE)
+    cv.imshow('image', img)
+    cv.waitKey()
+    ## [imshow 1]
+
+    ## [imshow 2]
+    img = cv.imread('image.jpg')
+    grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
+    sobelx = cv.Sobel(grey, cv.CV_32F, 1, 0)
+    # find minimum and maximum intensities
+    minVal = np.amin(sobelx)
+    maxVal = np.amax(sobelx)
+    draw = cv.convertScaleAbs(sobelx, alpha=255.0/(maxVal - minVal), beta=-minVal * 255.0/(maxVal - minVal))
+    cv.namedWindow('image', cv.WINDOW_AUTOSIZE)
+    cv.imshow('image', draw)
+    cv.waitKey()
+    ## [imshow 2]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/dnn/dnn_conversion/common/test/voc_segm_test.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+from ..accuracy_eval import SemSegmEvaluation
+from ..utils import plot_acc
+
+
+def test_segm_models(models_list, data_fetcher, eval_params, experiment_name, is_print_eval_params=True,
+                     is_plot_acc=True):
+    if is_print_eval_params:
+        print(
+            "===== Running evaluation of the classification models with the following params:\n"
+            "\t0. val data location: {}\n"
+            "\t1. val data labels: {}\n"
+            "\t2. frame size: {}\n"
+            "\t3. batch size: {}\n"
+            "\t4. transform to RGB: {}\n"
+            "\t5. log file location: {}\n".format(
+                eval_params.imgs_segm_dir,
+                eval_params.img_cls_file,
+                eval_params.frame_size,
+                eval_params.batch_size,
+                eval_params.bgr_to_rgb,
+                eval_params.log
+            )
+        )
+
+    accuracy_evaluator = SemSegmEvaluation(eval_params.log, eval_params.img_cls_file, eval_params.batch_size)
+    accuracy_evaluator.process(models_list, data_fetcher)
+    accuracy_array = np.array(accuracy_evaluator.general_fw_accuracy)
+
+    print(
+        "===== End of processing. Accuracy results:\n"
+        "\t1. max accuracy (top-5) for the original model: {}\n"
+        "\t2. max accuracy (top-5) for the DNN model: {}\n".format(
+            max(accuracy_array[:, 0]),
+            max(accuracy_array[:, 1]),
+        )
+    )
+
+    if is_plot_acc:
+        plot_acc(accuracy_array, experiment_name)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/dnn/dnn_conversion/pytorch/segmentation/py_to_py_fcn_resnet50.py

@@ -0,0 +1,59 @@
+from torchvision import models
+
+from ..pytorch_model import (
+    PyTorchModelPreparer,
+    PyTorchModelProcessor,
+    PyTorchDnnModelProcessor
+)
+from ...common.utils import set_pytorch_env, create_parser
+
+
+class PyTorchFcnResNet50(PyTorchModelPreparer):
+    def __init__(self, model_name, original_model):
+        super(PyTorchFcnResNet50, self).__init__(model_name, original_model)
+
+
+def main():
+    parser = create_parser()
+    cmd_args = parser.parse_args()
+    set_pytorch_env()
+
+    # Test the base process of model retrieval
+    resnets = PyTorchFcnResNet50(
+        model_name="resnet50",
+        original_model=models.segmentation.fcn_resnet50(pretrained=True)
+    )
+    model_dict = resnets.get_prepared_models()
+
+    if cmd_args.is_evaluate:
+        from ...common.test_config import TestConfig
+        from ...common.accuracy_eval import PASCALDataFetch
+        from ...common.test.voc_segm_test import test_segm_models
+
+        eval_params = TestConfig()
+
+        model_names = list(model_dict.keys())
+        original_model_name = model_names[0]
+        dnn_model_name = model_names[1]
+
+        #img_dir, segm_dir, names_file, segm_cls_colors_file, preproc)
+        data_fetcher = PASCALDataFetch(
+            imgs_dir=eval_params.imgs_segm_dir,
+            frame_size=eval_params.frame_size,
+            bgr_to_rgb=eval_params.bgr_to_rgb,
+
+        )
+
+        test_segm_models(
+            [
+                PyTorchModelProcessor(model_dict[original_model_name], original_model_name),
+                PyTorchDnnModelProcessor(model_dict[dnn_model_name], dnn_model_name)
+            ],
+            data_fetcher,
+            eval_params,
+            original_model_name
+        )
+
+
+if __name__ == "__main__":
+    main()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/Homography/panorama_stitching_rotating_camera.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+def basicPanoramaStitching(img1Path, img2Path):
+    img1 = cv.imread(cv.samples.findFile(img1Path))
+    img2 = cv.imread(cv.samples.findFile(img2Path))
+
+    # [camera-pose-from-Blender-at-location-1]
+    c1Mo = np.array([[0.9659258723258972, 0.2588190734386444, 0.0, 1.5529145002365112],
+                     [ 0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443],
+                     [-0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654],
+                     [0, 0, 0, 1]],dtype=np.float64)
+    # [camera-pose-from-Blender-at-location-1]
+
+    # [camera-pose-from-Blender-at-location-2]
+    c2Mo = np.array([[0.9659258723258972, -0.2588190734386444, 0.0, -1.5529145002365112],
+                     [-0.08852133899927139, -0.3303661346435547, -0.9396926164627075, -0.10281121730804443],
+                     [0.24321036040782928, 0.9076734185218811, -0.342020183801651, 6.130080699920654],
+                     [0, 0, 0, 1]],dtype=np.float64)
+    # [camera-pose-from-Blender-at-location-2]
+
+    # [camera-intrinsics-from-Blender]
+    cameraMatrix = np.array([[700.0, 0.0, 320.0], [0.0, 700.0, 240.0], [0, 0, 1]], dtype=np.float32)
+    # [camera-intrinsics-from-Blender]
+
+    # [extract-rotation]
+    R1 = c1Mo[0:3, 0:3]
+    R2 = c2Mo[0:3, 0:3]
+    #[extract-rotation]
+
+    # [compute-rotation-displacement]
+    R2 = R2.transpose()
+    R_2to1 = np.dot(R1,R2)
+    # [compute-rotation-displacement]
+
+    # [compute-homography]
+    H = cameraMatrix.dot(R_2to1).dot(np.linalg.inv(cameraMatrix))
+    H = H / H[2][2]
+    # [compute-homography]
+
+    # [stitch]
+    img_stitch = cv.warpPerspective(img2, H, (img2.shape[1]*2, img2.shape[0]))
+    img_stitch[0:img1.shape[0], 0:img1.shape[1]] = img1
+    # [stitch]
+
+    img_space = np.zeros((img1.shape[0],50,3), dtype=np.uint8)
+    img_compare = cv.hconcat([img1,img_space, img2])
+
+    cv.imshow("Final", img_compare)
+    cv.imshow("Panorama", img_stitch)
+    cv.waitKey(0)
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Code for homography tutorial. Example 5: basic panorama stitching from a rotating camera.")
+    parser.add_argument("-I1","--image1", help = "path to first image", default="Blender_Suzanne1.jpg")
+    parser.add_argument("-I2","--image2", help = "path to second image", default="Blender_Suzanne2.jpg")
+    args = parser.parse_args()
+    print("Panorama Stitching Started")
+    basicPanoramaStitching(args.image1, args.image2)
+    print("Panorama Stitching Completed Successfully")
+
+
+if __name__ == '__main__':
+    main()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/Homography/perspective_correction.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import sys
+
+
+def randomColor():
+    color = np.random.randint(0, 255,(1, 3))
+    return color[0].tolist()
+
+def  perspectiveCorrection(img1Path, img2Path ,patternSize ):
+    img1 = cv.imread(cv.samples.findFile(img1Path))
+    img2 = cv.imread(cv.samples.findFile(img2Path))
+
+    # [find-corners]
+    ret1, corners1 = cv.findChessboardCorners(img1, patternSize)
+    ret2, corners2 = cv.findChessboardCorners(img2, patternSize)
+    # [find-corners]
+
+    if not ret1 or not ret2:
+        print("Error, cannot find the chessboard corners in both images.")
+        sys.exit(-1)
+
+    # [estimate-homography]
+    H, _ = cv.findHomography(corners1, corners2)
+    print(H)
+    # [estimate-homography]
+
+    # [warp-chessboard]
+    img1_warp = cv.warpPerspective(img1, H, (img1.shape[1], img1.shape[0]))
+    # [warp-chessboard]
+
+    img_draw_warp = cv.hconcat([img2, img1_warp])
+    cv.imshow("Desired chessboard view / Warped source chessboard view", img_draw_warp )
+
+    corners1 = corners1.tolist()
+    corners1 = [a[0] for a in corners1]
+
+    # [compute-transformed-corners]
+    img_draw_matches = cv.hconcat([img1, img2])
+    for i in range(len(corners1)):
+        pt1 = np.array([corners1[i][0], corners1[i][1], 1])
+        pt1 = pt1.reshape(3, 1)
+        pt2 = np.dot(H, pt1)
+        pt2 = pt2/pt2[2]
+        end = (int(img1.shape[1] + pt2[0]), int(pt2[1]))
+        cv.line(img_draw_matches, tuple([int(j) for j in corners1[i]]), end, randomColor(), 2)
+
+    cv.imshow("Draw matches", img_draw_matches)
+    cv.waitKey(0)
+    # [compute-transformed-corners]
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-I1', "--image1", help="Path to the first image", default="left02.jpg")
+    parser.add_argument('-I2', "--image2", help="Path to the second image", default="left01.jpg")
+    parser.add_argument('-H', "--height", help="Height of pattern size", default=6)
+    parser.add_argument('-W', "--width", help="Width of pattern size", default=9)
+    args = parser.parse_args()
+
+    img1Path = args.image1
+    img2Path = args.image2
+    h = args.height
+    w = args.width
+    perspectiveCorrection(img1Path, img2Path, (w, h))
+
+if __name__ == "__main__":
+    main()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/akaze_matching/AKAZE_match.py

@@ -0,0 +1,81 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+from math import sqrt
+
+## [load]
+parser = argparse.ArgumentParser(description='Code for AKAZE local features matching tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='graf1.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='graf3.png')
+parser.add_argument('--homography', help='Path to the homography matrix.', default='H1to3p.xml')
+args = parser.parse_args()
+
+img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img1 is None or img2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+fs = cv.FileStorage(cv.samples.findFile(args.homography), cv.FILE_STORAGE_READ)
+homography = fs.getFirstTopLevelNode().mat()
+## [load]
+
+## [AKAZE]
+akaze = cv.AKAZE_create()
+kpts1, desc1 = akaze.detectAndCompute(img1, None)
+kpts2, desc2 = akaze.detectAndCompute(img2, None)
+## [AKAZE]
+
+## [2-nn matching]
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE_HAMMING)
+nn_matches = matcher.knnMatch(desc1, desc2, 2)
+## [2-nn matching]
+
+## [ratio test filtering]
+matched1 = []
+matched2 = []
+nn_match_ratio = 0.8 # Nearest neighbor matching ratio
+for m, n in nn_matches:
+    if m.distance < nn_match_ratio * n.distance:
+        matched1.append(kpts1[m.queryIdx])
+        matched2.append(kpts2[m.trainIdx])
+## [ratio test filtering]
+
+## [homography check]
+inliers1 = []
+inliers2 = []
+good_matches = []
+inlier_threshold = 2.5 # Distance threshold to identify inliers with homography check
+for i, m in enumerate(matched1):
+    col = np.ones((3,1), dtype=np.float64)
+    col[0:2,0] = m.pt
+
+    col = np.dot(homography, col)
+    col /= col[2,0]
+    dist = sqrt(pow(col[0,0] - matched2[i].pt[0], 2) +\
+                pow(col[1,0] - matched2[i].pt[1], 2))
+
+    if dist < inlier_threshold:
+        good_matches.append(cv.DMatch(len(inliers1), len(inliers2), 0))
+        inliers1.append(matched1[i])
+        inliers2.append(matched2[i])
+## [homography check]
+
+## [draw final matches]
+res = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img1, inliers1, img2, inliers2, good_matches, res)
+cv.imwrite("akaze_result.png", res)
+
+inlier_ratio = len(inliers1) / float(len(matched1))
+print('A-KAZE Matching Results')
+print('*******************************')
+print('# Keypoints 1:                        \t', len(kpts1))
+print('# Keypoints 2:                        \t', len(kpts2))
+print('# Matches:                            \t', len(matched1))
+print('# Inliers:                            \t', len(inliers1))
+print('# Inliers Ratio:                      \t', inlier_ratio)
+
+cv.imshow('result', res)
+cv.waitKey()
+## [draw final matches]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/feature_description/SURF_matching_Demo.py

@@ -0,0 +1,35 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Detection tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='box_in_scene.png')
+args = parser.parse_args()
+
+img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img1 is None or img2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints1, descriptors1 = detector.detectAndCompute(img1, None)
+keypoints2, descriptors2 = detector.detectAndCompute(img2, None)
+
+#-- Step 2: Matching descriptor vectors with a brute force matcher
+# Since SURF is a floating-point descriptor NORM_L2 is used
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_BRUTEFORCE)
+matches = matcher.match(descriptors1, descriptors2)
+
+#-- Draw matches
+img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches)
+
+#-- Show detected matches
+cv.imshow('Matches', img_matches)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/feature_detection/SURF_detection_Demo.py

@@ -0,0 +1,27 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Detection tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='box.png')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input), cv.IMREAD_GRAYSCALE)
+if src is None:
+    print('Could not open or find the image:', args.input)
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints = detector.detect(src)
+
+#-- Draw keypoints
+img_keypoints = np.empty((src.shape[0], src.shape[1], 3), dtype=np.uint8)
+cv.drawKeypoints(src, keypoints, img_keypoints)
+
+#-- Show detected (drawn) keypoints
+cv.imshow('SURF Keypoints', img_keypoints)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/feature_flann_matcher/SURF_FLANN_matching_Demo.py

@@ -0,0 +1,42 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Matching with FLANN tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='box_in_scene.png')
+args = parser.parse_args()
+
+img1 = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img2 = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img1 is None or img2 is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints1, descriptors1 = detector.detectAndCompute(img1, None)
+keypoints2, descriptors2 = detector.detectAndCompute(img2, None)
+
+#-- Step 2: Matching descriptor vectors with a FLANN based matcher
+# Since SURF is a floating-point descriptor NORM_L2 is used
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
+knn_matches = matcher.knnMatch(descriptors1, descriptors2, 2)
+
+#-- Filter matches using the Lowe's ratio test
+ratio_thresh = 0.7
+good_matches = []
+for m,n in knn_matches:
+    if m.distance < ratio_thresh * n.distance:
+        good_matches.append(m)
+
+#-- Draw matches
+img_matches = np.empty((max(img1.shape[0], img2.shape[0]), img1.shape[1]+img2.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img1, keypoints1, img2, keypoints2, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
+
+#-- Show detected matches
+cv.imshow('Good Matches', img_matches)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/features2D/feature_homography/SURF_FLANN_matching_homography_Demo.py

@@ -0,0 +1,77 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+parser = argparse.ArgumentParser(description='Code for Feature Matching with FLANN tutorial.')
+parser.add_argument('--input1', help='Path to input image 1.', default='box.png')
+parser.add_argument('--input2', help='Path to input image 2.', default='box_in_scene.png')
+args = parser.parse_args()
+
+img_object = cv.imread(cv.samples.findFile(args.input1), cv.IMREAD_GRAYSCALE)
+img_scene = cv.imread(cv.samples.findFile(args.input2), cv.IMREAD_GRAYSCALE)
+if img_object is None or img_scene is None:
+    print('Could not open or find the images!')
+    exit(0)
+
+#-- Step 1: Detect the keypoints using SURF Detector, compute the descriptors
+minHessian = 400
+detector = cv.xfeatures2d_SURF.create(hessianThreshold=minHessian)
+keypoints_obj, descriptors_obj = detector.detectAndCompute(img_object, None)
+keypoints_scene, descriptors_scene = detector.detectAndCompute(img_scene, None)
+
+#-- Step 2: Matching descriptor vectors with a FLANN based matcher
+# Since SURF is a floating-point descriptor NORM_L2 is used
+matcher = cv.DescriptorMatcher_create(cv.DescriptorMatcher_FLANNBASED)
+knn_matches = matcher.knnMatch(descriptors_obj, descriptors_scene, 2)
+
+#-- Filter matches using the Lowe's ratio test
+ratio_thresh = 0.75
+good_matches = []
+for m,n in knn_matches:
+    if m.distance < ratio_thresh * n.distance:
+        good_matches.append(m)
+
+#-- Draw matches
+img_matches = np.empty((max(img_object.shape[0], img_scene.shape[0]), img_object.shape[1]+img_scene.shape[1], 3), dtype=np.uint8)
+cv.drawMatches(img_object, keypoints_obj, img_scene, keypoints_scene, good_matches, img_matches, flags=cv.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
+
+#-- Localize the object
+obj = np.empty((len(good_matches),2), dtype=np.float32)
+scene = np.empty((len(good_matches),2), dtype=np.float32)
+for i in range(len(good_matches)):
+    #-- Get the keypoints from the good matches
+    obj[i,0] = keypoints_obj[good_matches[i].queryIdx].pt[0]
+    obj[i,1] = keypoints_obj[good_matches[i].queryIdx].pt[1]
+    scene[i,0] = keypoints_scene[good_matches[i].trainIdx].pt[0]
+    scene[i,1] = keypoints_scene[good_matches[i].trainIdx].pt[1]
+
+H, _ =  cv.findHomography(obj, scene, cv.RANSAC)
+
+#-- Get the corners from the image_1 ( the object to be "detected" )
+obj_corners = np.empty((4,1,2), dtype=np.float32)
+obj_corners[0,0,0] = 0
+obj_corners[0,0,1] = 0
+obj_corners[1,0,0] = img_object.shape[1]
+obj_corners[1,0,1] = 0
+obj_corners[2,0,0] = img_object.shape[1]
+obj_corners[2,0,1] = img_object.shape[0]
+obj_corners[3,0,0] = 0
+obj_corners[3,0,1] = img_object.shape[0]
+
+scene_corners = cv.perspectiveTransform(obj_corners, H)
+
+#-- Draw lines between the corners (the mapped object in the scene - image_2 )
+cv.line(img_matches, (int(scene_corners[0,0,0] + img_object.shape[1]), int(scene_corners[0,0,1])),\
+    (int(scene_corners[1,0,0] + img_object.shape[1]), int(scene_corners[1,0,1])), (0,255,0), 4)
+cv.line(img_matches, (int(scene_corners[1,0,0] + img_object.shape[1]), int(scene_corners[1,0,1])),\
+    (int(scene_corners[2,0,0] + img_object.shape[1]), int(scene_corners[2,0,1])), (0,255,0), 4)
+cv.line(img_matches, (int(scene_corners[2,0,0] + img_object.shape[1]), int(scene_corners[2,0,1])),\
+    (int(scene_corners[3,0,0] + img_object.shape[1]), int(scene_corners[3,0,1])), (0,255,0), 4)
+cv.line(img_matches, (int(scene_corners[3,0,0] + img_object.shape[1]), int(scene_corners[3,0,1])),\
+    (int(scene_corners[0,0,0] + img_object.shape[1]), int(scene_corners[0,0,1])), (0,255,0), 4)
+
+#-- Show detected matches
+cv.imshow('Good Matches & Object detection', img_matches)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/highgui/trackbar/AddingImagesTrackbar.py

@@ -0,0 +1,48 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import argparse
+
+alpha_slider_max = 100
+title_window = 'Linear Blend'
+
+## [on_trackbar]
+def on_trackbar(val):
+    alpha = val / alpha_slider_max
+    beta = ( 1.0 - alpha )
+    dst = cv.addWeighted(src1, alpha, src2, beta, 0.0)
+    cv.imshow(title_window, dst)
+## [on_trackbar]
+
+parser = argparse.ArgumentParser(description='Code for Adding a Trackbar to our applications tutorial.')
+parser.add_argument('--input1', help='Path to the first input image.', default='LinuxLogo.jpg')
+parser.add_argument('--input2', help='Path to the second input image.', default='WindowsLogo.jpg')
+args = parser.parse_args()
+
+## [load]
+# Read images ( both have to be of the same size and type )
+src1 = cv.imread(cv.samples.findFile(args.input1))
+src2 = cv.imread(cv.samples.findFile(args.input2))
+## [load]
+if src1 is None:
+    print('Could not open or find the image: ', args.input1)
+    exit(0)
+
+if src2 is None:
+    print('Could not open or find the image: ', args.input2)
+    exit(0)
+
+## [window]
+cv.namedWindow(title_window)
+## [window]
+
+## [create_trackbar]
+trackbar_name = 'Alpha x %d' % alpha_slider_max
+cv.createTrackbar(trackbar_name, title_window , 0, alpha_slider_max, on_trackbar)
+## [create_trackbar]
+
+# Show some stuff
+on_trackbar(0)
+
+# Wait until user press some key
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/BasicGeometricDrawing/basic_geometric_drawing.py

@@ -0,0 +1,115 @@
+import cv2 as cv
+import numpy as np
+
+W = 400
+## [my_ellipse]
+def my_ellipse(img, angle):
+    thickness = 2
+    line_type = 8
+
+    cv.ellipse(img,
+                (W // 2, W // 2),
+                (W // 4, W // 16),
+                angle,
+                0,
+                360,
+                (255, 0, 0),
+                thickness,
+                line_type)
+## [my_ellipse]
+## [my_filled_circle]
+def my_filled_circle(img, center):
+    thickness = -1
+    line_type = 8
+
+    cv.circle(img,
+               center,
+               W // 32,
+               (0, 0, 255),
+               thickness,
+               line_type)
+## [my_filled_circle]
+## [my_polygon]
+def my_polygon(img):
+    line_type = 8
+
+    # Create some points
+    ppt = np.array([[W / 4, 7 * W / 8], [3 * W / 4, 7 * W / 8],
+                    [3 * W / 4, 13 * W / 16], [11 * W / 16, 13 * W / 16],
+                    [19 * W / 32, 3 * W / 8], [3 * W / 4, 3 * W / 8],
+                    [3 * W / 4, W / 8], [26 * W / 40, W / 8],
+                    [26 * W / 40, W / 4], [22 * W / 40, W / 4],
+                    [22 * W / 40, W / 8], [18 * W / 40, W / 8],
+                    [18 * W / 40, W / 4], [14 * W / 40, W / 4],
+                    [14 * W / 40, W / 8], [W / 4, W / 8],
+                    [W / 4, 3 * W / 8], [13 * W / 32, 3 * W / 8],
+                    [5 * W / 16, 13 * W / 16], [W / 4, 13 * W / 16]], np.int32)
+    ppt = ppt.reshape((-1, 1, 2))
+    cv.fillPoly(img, [ppt], (255, 255, 255), line_type)
+    # Only drawind the lines would be:
+    # cv.polylines(img, [ppt], True, (255, 0, 255), line_type)
+## [my_polygon]
+## [my_line]
+def my_line(img, start, end):
+    thickness = 2
+    line_type = 8
+
+    cv.line(img,
+             start,
+             end,
+             (0, 0, 0),
+             thickness,
+             line_type)
+## [my_line]
+## [create_images]
+# Windows names
+atom_window = "Drawing 1: Atom"
+rook_window = "Drawing 2: Rook"
+
+# Create black empty images
+size = W, W, 3
+atom_image = np.zeros(size, dtype=np.uint8)
+rook_image = np.zeros(size, dtype=np.uint8)
+## [create_images]
+## [draw_atom]
+# 1. Draw a simple atom:
+# -----------------------
+
+# 1.a. Creating ellipses
+my_ellipse(atom_image, 90)
+my_ellipse(atom_image, 0)
+my_ellipse(atom_image, 45)
+my_ellipse(atom_image, -45)
+
+# 1.b. Creating circles
+my_filled_circle(atom_image, (W // 2, W // 2))
+## [draw_atom]
+## [draw_rook]
+
+# 2. Draw a rook
+# ------------------
+# 2.a. Create a convex polygon
+my_polygon(rook_image)
+## [rectangle]
+# 2.b. Creating rectangles
+cv.rectangle(rook_image,
+              (0, 7 * W // 8),
+              (W, W),
+              (0, 255, 255),
+              -1,
+              8)
+## [rectangle]
+
+#  2.c. Create a few lines
+my_line(rook_image, (0, 15 * W // 16), (W, 15 * W // 16))
+my_line(rook_image, (W // 4, 7 * W // 8), (W // 4, W))
+my_line(rook_image, (W // 2, 7 * W // 8), (W // 2, W))
+my_line(rook_image, (3 * W // 4, 7 * W // 8), (3 * W // 4, W))
+## [draw_rook]
+cv.imshow(atom_window, atom_image)
+cv.moveWindow(atom_window, 0, 200)
+cv.imshow(rook_window, rook_image)
+cv.moveWindow(rook_window, W, 200)
+
+cv.waitKey(0)
+cv.destroyAllWindows()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/HitMiss/hit_miss.py

@@ -0,0 +1,38 @@
+import cv2 as cv
+import numpy as np
+
+input_image = np.array((
+    [0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 255, 255, 255, 0, 0, 0, 255],
+    [0, 255, 255, 255, 0, 0, 0, 0],
+    [0, 255, 255, 255, 0, 255, 0, 0],
+    [0, 0, 255, 0, 0, 0, 0, 0],
+    [0, 0, 255, 0, 0, 255, 255, 0],
+    [0,255, 0, 255, 0, 0, 255, 0],
+    [0, 255, 255, 255, 0, 0, 0, 0]), dtype="uint8")
+
+kernel = np.array((
+        [0, 1, 0],
+        [1, -1, 1],
+        [0, 1, 0]), dtype="int")
+
+output_image = cv.morphologyEx(input_image, cv.MORPH_HITMISS, kernel)
+
+rate = 50
+kernel = (kernel + 1) * 127
+kernel = np.uint8(kernel)
+
+kernel = cv.resize(kernel, None, fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
+cv.imshow("kernel", kernel)
+cv.moveWindow("kernel", 0, 0)
+
+input_image = cv.resize(input_image, None, fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
+cv.imshow("Original", input_image)
+cv.moveWindow("Original", 0, 200)
+
+output_image = cv.resize(output_image, None , fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
+cv.imshow("Hit or Miss", output_image)
+cv.moveWindow("Hit or Miss", 500, 200)
+
+cv.waitKey(0)
+cv.destroyAllWindows()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/Pyramids/pyramids.py

@@ -0,0 +1,51 @@
+import sys
+import cv2 as cv
+
+
+def main(argv):
+    print("""
+    Zoom In-Out demo
+    ------------------
+    * [i] -> Zoom [i]n
+    * [o] -> Zoom [o]ut
+    * [ESC] -> Close program
+    """)
+    ## [load]
+    filename = argv[0] if len(argv) > 0 else 'chicky_512.png'
+
+    # Load the image
+    src = cv.imread(cv.samples.findFile(filename))
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image!')
+        print ('Usage: pyramids.py [image_name -- default ../data/chicky_512.png] \n')
+        return -1
+    ## [load]
+    ## [loop]
+    while 1:
+        rows, cols, _channels = map(int, src.shape)
+        ## [show_image]
+        cv.imshow('Pyramids Demo', src)
+        ## [show_image]
+        k = cv.waitKey(0)
+
+        if k == 27:
+            break
+            ## [pyrup]
+        elif chr(k) == 'i':
+            src = cv.pyrUp(src, dstsize=(2 * cols, 2 * rows))
+            print ('** Zoom In: Image x 2')
+            ## [pyrup]
+            ## [pyrdown]
+        elif chr(k) == 'o':
+            src = cv.pyrDown(src, dstsize=(cols // 2, rows // 2))
+            print ('** Zoom Out: Image / 2')
+            ## [pyrdown]
+    ## [loop]
+
+    cv.destroyAllWindows()
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/Smoothing/smoothing.py

@@ -0,0 +1,107 @@
+import sys
+import cv2 as cv
+import numpy as np
+
+#  Global Variables
+
+DELAY_CAPTION = 1500
+DELAY_BLUR = 100
+MAX_KERNEL_LENGTH = 31
+
+src = None
+dst = None
+window_name = 'Smoothing Demo'
+
+
+def main(argv):
+    cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
+
+    # Load the source image
+    imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
+
+    global src
+    src = cv.imread(cv.samples.findFile(imageName))
+    if src is None:
+        print ('Error opening image')
+        print ('Usage: smoothing.py [image_name -- default ../data/lena.jpg] \n')
+        return -1
+
+    if display_caption('Original Image') != 0:
+        return 0
+
+    global dst
+    dst = np.copy(src)
+    if display_dst(DELAY_CAPTION) != 0:
+        return 0
+
+    # Applying Homogeneous blur
+    if display_caption('Homogeneous Blur') != 0:
+        return 0
+
+    ## [blur]
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.blur(src, (i, i))
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [blur]
+
+    # Applying Gaussian blur
+    if display_caption('Gaussian Blur') != 0:
+        return 0
+
+    ## [gaussianblur]
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.GaussianBlur(src, (i, i), 0)
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [gaussianblur]
+
+    # Applying Median blur
+    if display_caption('Median Blur') != 0:
+        return 0
+
+    ## [medianblur]
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.medianBlur(src, i)
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [medianblur]
+
+    # Applying Bilateral Filter
+    if display_caption('Bilateral Blur') != 0:
+        return 0
+
+    ## [bilateralfilter]
+    # Remember, bilateral is a bit slow, so as value go higher, it takes long time
+    for i in range(1, MAX_KERNEL_LENGTH, 2):
+        dst = cv.bilateralFilter(src, i, i * 2, i / 2)
+        if display_dst(DELAY_BLUR) != 0:
+            return 0
+    ## [bilateralfilter]
+
+    #  Done
+    display_caption('Done!')
+
+    return 0
+
+
+def display_caption(caption):
+    global dst
+    dst = np.zeros(src.shape, src.dtype)
+    rows, cols, _ch = src.shape
+    cv.putText(dst, caption,
+                (int(cols / 4), int(rows / 2)),
+                cv.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255))
+
+    return display_dst(DELAY_CAPTION)
+
+
+def display_dst(delay):
+    cv.imshow(window_name, dst)
+    c = cv.waitKey(delay)
+    if c >= 0 : return -1
+    return 0
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.py

@@ -0,0 +1,92 @@
+
+import cv2 as cv
+import numpy as np
+import argparse
+
+W = 52          # window size is WxW
+C_Thr = 0.43    # threshold for coherency
+LowThr = 35     # threshold1 for orientation, it ranges from 0 to 180
+HighThr = 57    # threshold2 for orientation, it ranges from 0 to 180
+
+## [calcGST]
+## [calcJ_header]
+## [calcGST_proto]
+def calcGST(inputIMG, w):
+## [calcGST_proto]
+    img = inputIMG.astype(np.float32)
+
+    # GST components calculation (start)
+    # J =  (J11 J12; J12 J22) - GST
+    imgDiffX = cv.Sobel(img, cv.CV_32F, 1, 0, 3)
+    imgDiffY = cv.Sobel(img, cv.CV_32F, 0, 1, 3)
+    imgDiffXY = cv.multiply(imgDiffX, imgDiffY)
+    ## [calcJ_header]
+
+    imgDiffXX = cv.multiply(imgDiffX, imgDiffX)
+    imgDiffYY = cv.multiply(imgDiffY, imgDiffY)
+
+    J11 = cv.boxFilter(imgDiffXX, cv.CV_32F, (w,w))
+    J22 = cv.boxFilter(imgDiffYY, cv.CV_32F, (w,w))
+    J12 = cv.boxFilter(imgDiffXY, cv.CV_32F, (w,w))
+    # GST components calculations (stop)
+
+    # eigenvalue calculation (start)
+    # lambda1 = 0.5*(J11 + J22 + sqrt((J11-J22)^2 + 4*J12^2))
+    # lambda2 = 0.5*(J11 + J22 - sqrt((J11-J22)^2 + 4*J12^2))
+    tmp1 = J11 + J22
+    tmp2 = J11 - J22
+    tmp2 = cv.multiply(tmp2, tmp2)
+    tmp3 = cv.multiply(J12, J12)
+    tmp4 = np.sqrt(tmp2 + 4.0 * tmp3)
+
+    lambda1 = 0.5*(tmp1 + tmp4)    # biggest eigenvalue
+    lambda2 = 0.5*(tmp1 - tmp4)    # smallest eigenvalue
+    # eigenvalue calculation (stop)
+
+    # Coherency calculation (start)
+    # Coherency = (lambda1 - lambda2)/(lambda1 + lambda2)) - measure of anisotropism
+    # Coherency is anisotropy degree (consistency of local orientation)
+    imgCoherencyOut = cv.divide(lambda1 - lambda2, lambda1 + lambda2)
+    # Coherency calculation (stop)
+
+    # orientation angle calculation (start)
+    # tan(2*Alpha) = 2*J12/(J22 - J11)
+    # Alpha = 0.5 atan2(2*J12/(J22 - J11))
+    imgOrientationOut = cv.phase(J22 - J11, 2.0 * J12, angleInDegrees = True)
+    imgOrientationOut = 0.5 * imgOrientationOut
+    # orientation angle calculation (stop)
+
+    return imgCoherencyOut, imgOrientationOut
+## [calcGST]
+
+parser = argparse.ArgumentParser(description='Code for Anisotropic image segmentation tutorial.')
+parser.add_argument('-i', '--input', help='Path to input image.', required=True)
+args = parser.parse_args()
+
+imgIn = cv.imread(args.input, cv.IMREAD_GRAYSCALE)
+if imgIn is None:
+    print('Could not open or find the image: {}'.format(args.input))
+    exit(0)
+
+## [main_extra]
+## [main]
+imgCoherency, imgOrientation = calcGST(imgIn, W)
+
+## [thresholding]
+_, imgCoherencyBin = cv.threshold(imgCoherency, C_Thr, 255, cv.THRESH_BINARY)
+_, imgOrientationBin = cv.threshold(imgOrientation, LowThr, HighThr, cv.THRESH_BINARY)
+## [thresholding]
+
+## [combining]
+imgBin = cv.bitwise_and(imgCoherencyBin, imgOrientationBin)
+## [combining]
+## [main]
+
+imgCoherency = cv.normalize(imgCoherency, None, alpha=0, beta=1, norm_type=cv.NORM_MINMAX, dtype=cv.CV_32F)
+imgOrientation = cv.normalize(imgOrientation, None, alpha=0, beta=1, norm_type=cv.NORM_MINMAX, dtype=cv.CV_32F)
+
+cv.imshow('result.jpg', np.uint8(0.5*(imgIn + imgBin)))
+cv.imshow('Coherency.jpg', imgCoherency)
+cv.imshow('Orientation.jpg', imgOrientation)
+cv.waitKey(0)
+## [main_extra]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/BasicLinearTransforms.py

@@ -0,0 +1,55 @@
+from __future__ import print_function
+from builtins import input
+import cv2 as cv
+import numpy as np
+import argparse
+
+# Read image given by user
+## [basic-linear-transform-load]
+parser = argparse.ArgumentParser(description='Code for Changing the contrast and brightness of an image! tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+image = cv.imread(cv.samples.findFile(args.input))
+if image is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+## [basic-linear-transform-load]
+
+## [basic-linear-transform-output]
+new_image = np.zeros(image.shape, image.dtype)
+## [basic-linear-transform-output]
+
+## [basic-linear-transform-parameters]
+alpha = 1.0 # Simple contrast control
+beta = 0    # Simple brightness control
+
+# Initialize values
+print(' Basic Linear Transforms ')
+print('-------------------------')
+try:
+    alpha = float(input('* Enter the alpha value [1.0-3.0]: '))
+    beta = int(input('* Enter the beta value [0-100]: '))
+except ValueError:
+    print('Error, not a number')
+## [basic-linear-transform-parameters]
+
+# Do the operation new_image(i,j) = alpha*image(i,j) + beta
+# Instead of these 'for' loops we could have used simply:
+# new_image = cv.convertScaleAbs(image, alpha=alpha, beta=beta)
+# but we wanted to show you how to access the pixels :)
+## [basic-linear-transform-operation]
+for y in range(image.shape[0]):
+    for x in range(image.shape[1]):
+        for c in range(image.shape[2]):
+            new_image[y,x,c] = np.clip(alpha*image[y,x,c] + beta, 0, 255)
+## [basic-linear-transform-operation]
+
+## [basic-linear-transform-display]
+# Show stuff
+cv.imshow('Original Image', image)
+cv.imshow('New Image', new_image)
+
+# Wait until user press some key
+cv.waitKey()
+## [basic-linear-transform-display]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/changing_contrast_brightness_image.py

@@ -0,0 +1,74 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+
+alpha = 1.0
+alpha_max = 500
+beta = 0
+beta_max = 200
+gamma = 1.0
+gamma_max = 200
+
+def basicLinearTransform():
+    res = cv.convertScaleAbs(img_original, alpha=alpha, beta=beta)
+    img_corrected = cv.hconcat([img_original, res])
+    cv.imshow("Brightness and contrast adjustments", img_corrected)
+
+def gammaCorrection():
+    ## [changing-contrast-brightness-gamma-correction]
+    lookUpTable = np.empty((1,256), np.uint8)
+    for i in range(256):
+        lookUpTable[0,i] = np.clip(pow(i / 255.0, gamma) * 255.0, 0, 255)
+
+    res = cv.LUT(img_original, lookUpTable)
+    ## [changing-contrast-brightness-gamma-correction]
+
+    img_gamma_corrected = cv.hconcat([img_original, res])
+    cv.imshow("Gamma correction", img_gamma_corrected)
+
+def on_linear_transform_alpha_trackbar(val):
+    global alpha
+    alpha = val / 100
+    basicLinearTransform()
+
+def on_linear_transform_beta_trackbar(val):
+    global beta
+    beta = val - 100
+    basicLinearTransform()
+
+def on_gamma_correction_trackbar(val):
+    global gamma
+    gamma = val / 100
+    gammaCorrection()
+
+parser = argparse.ArgumentParser(description='Code for Changing the contrast and brightness of an image! tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='lena.jpg')
+args = parser.parse_args()
+
+img_original = cv.imread(cv.samples.findFile(args.input))
+if img_original is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+img_corrected = np.empty((img_original.shape[0], img_original.shape[1]*2, img_original.shape[2]), img_original.dtype)
+img_gamma_corrected = np.empty((img_original.shape[0], img_original.shape[1]*2, img_original.shape[2]), img_original.dtype)
+
+img_corrected = cv.hconcat([img_original, img_original])
+img_gamma_corrected = cv.hconcat([img_original, img_original])
+
+cv.namedWindow('Brightness and contrast adjustments')
+cv.namedWindow('Gamma correction')
+
+alpha_init = int(alpha *100)
+cv.createTrackbar('Alpha gain (contrast)', 'Brightness and contrast adjustments', alpha_init, alpha_max, on_linear_transform_alpha_trackbar)
+beta_init = beta + 100
+cv.createTrackbar('Beta bias (brightness)', 'Brightness and contrast adjustments', beta_init, beta_max, on_linear_transform_beta_trackbar)
+gamma_init = int(gamma * 100)
+cv.createTrackbar('Gamma correction', 'Gamma correction', gamma_init, gamma_max, on_gamma_correction_trackbar)
+
+on_linear_transform_alpha_trackbar(alpha_init)
+on_gamma_correction_trackbar(gamma_init)
+
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/erosion_dilatation/morphology_1.py

@@ -0,0 +1,78 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+src = None
+erosion_size = 0
+max_elem = 2
+max_kernel_size = 21
+title_trackbar_element_shape = 'Element:\n 0: Rect \n 1: Cross \n 2: Ellipse'
+title_trackbar_kernel_size = 'Kernel size:\n 2n +1'
+title_erosion_window = 'Erosion Demo'
+title_dilation_window = 'Dilation Demo'
+
+
+## [main]
+def main(image):
+    global src
+    src = cv.imread(cv.samples.findFile(image))
+    if src is None:
+        print('Could not open or find the image: ', image)
+        exit(0)
+
+    cv.namedWindow(title_erosion_window)
+    cv.createTrackbar(title_trackbar_element_shape, title_erosion_window, 0, max_elem, erosion)
+    cv.createTrackbar(title_trackbar_kernel_size, title_erosion_window, 0, max_kernel_size, erosion)
+
+    cv.namedWindow(title_dilation_window)
+    cv.createTrackbar(title_trackbar_element_shape, title_dilation_window, 0, max_elem, dilatation)
+    cv.createTrackbar(title_trackbar_kernel_size, title_dilation_window, 0, max_kernel_size, dilatation)
+
+    erosion(0)
+    dilatation(0)
+    cv.waitKey()
+## [main]
+
+# optional mapping of values with morphological shapes
+def morph_shape(val):
+    if val == 0:
+        return cv.MORPH_RECT
+    elif val == 1:
+        return cv.MORPH_CROSS
+    elif val == 2:
+        return cv.MORPH_ELLIPSE
+
+
+## [erosion]
+def erosion(val):
+    erosion_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_erosion_window)
+    erosion_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_erosion_window))
+
+    ## [kernel]
+    element = cv.getStructuringElement(erosion_shape, (2 * erosion_size + 1, 2 * erosion_size + 1),
+                                       (erosion_size, erosion_size))
+    ## [kernel]
+    erosion_dst = cv.erode(src, element)
+    cv.imshow(title_erosion_window, erosion_dst)
+## [erosion]
+
+
+## [dilation]
+def dilatation(val):
+    dilatation_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_dilation_window)
+    dilation_shape = morph_shape(cv.getTrackbarPos(title_trackbar_element_shape, title_dilation_window))
+
+    element = cv.getStructuringElement(dilation_shape, (2 * dilatation_size + 1, 2 * dilatation_size + 1),
+                                       (dilatation_size, dilatation_size))
+    dilatation_dst = cv.dilate(src, element)
+    cv.imshow(title_dilation_window, dilatation_dst)
+## [dilation]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Code for Eroding and Dilating tutorial.')
+    parser.add_argument('--input', help='Path to input image.', default='LinuxLogo.jpg')
+    args = parser.parse_args()
+
+    main(args.input)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/hough_line_transform/hough_line_transform.py

@@ -0,0 +1,22 @@
+import cv2 as cv
+import numpy as np
+
+img = cv.imread(cv.samples.findFile('sudoku.png'))
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+edges = cv.Canny(gray,50,150,apertureSize = 3)
+
+lines = cv.HoughLines(edges,1,np.pi/180,200)
+for line in lines:
+    rho,theta = line[0]
+    a = np.cos(theta)
+    b = np.sin(theta)
+    x0 = a*rho
+    y0 = b*rho
+    x1 = int(x0 + 1000*(-b))
+    y1 = int(y0 + 1000*(a))
+    x2 = int(x0 - 1000*(-b))
+    y2 = int(y0 - 1000*(a))
+
+    cv.line(img,(x1,y1),(x2,y2),(0,0,255),2)
+
+cv.imwrite('houghlines3.jpg',img)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/hough_line_transform/probabilistic_hough_line_transform.py

@@ -0,0 +1,12 @@
+import cv2 as cv
+import numpy as np
+
+img = cv.imread(cv.samples.findFile('sudoku.png'))
+gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
+edges = cv.Canny(gray,50,150,apertureSize = 3)
+lines = cv.HoughLinesP(edges,1,np.pi/180,100,minLineLength=100,maxLineGap=10)
+for line in lines:
+    x1,y1,x2,y2 = line[0]
+    cv.line(img,(x1,y1),(x2,y2),(0,255,0),2)
+
+cv.imwrite('houghlines5.jpg',img)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/match_template/match_template.py

@@ -0,0 +1,97 @@
+from __future__ import print_function
+import sys
+import cv2 as cv
+
+## [global_variables]
+use_mask = False
+img = None
+templ = None
+mask = None
+image_window = "Source Image"
+result_window = "Result window"
+
+match_method = 0
+max_Trackbar = 5
+## [global_variables]
+
+def main(argv):
+
+    if (len(sys.argv) < 3):
+        print('Not enough parameters')
+        print('Usage:\nmatch_template_demo.py <image_name> <template_name> [<mask_name>]')
+        return -1
+
+    ## [load_image]
+    global img
+    global templ
+    img = cv.imread(sys.argv[1], cv.IMREAD_COLOR)
+    templ = cv.imread(sys.argv[2], cv.IMREAD_COLOR)
+
+    if (len(sys.argv) > 3):
+        global use_mask
+        use_mask = True
+        global mask
+        mask = cv.imread( sys.argv[3], cv.IMREAD_COLOR )
+
+    if ((img is None) or (templ is None) or (use_mask and (mask is None))):
+        print('Can\'t read one of the images')
+        return -1
+    ## [load_image]
+
+    ## [create_windows]
+    cv.namedWindow( image_window, cv.WINDOW_AUTOSIZE )
+    cv.namedWindow( result_window, cv.WINDOW_AUTOSIZE )
+    ## [create_windows]
+
+    ## [create_trackbar]
+    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'
+    cv.createTrackbar( trackbar_label, image_window, match_method, max_Trackbar, MatchingMethod )
+    ## [create_trackbar]
+
+    MatchingMethod(match_method)
+
+    ## [wait_key]
+    cv.waitKey(0)
+    return 0
+    ## [wait_key]
+
+def MatchingMethod(param):
+
+    global match_method
+    match_method = param
+
+    ## [copy_source]
+    img_display = img.copy()
+    ## [copy_source]
+    ## [match_template]
+    method_accepts_mask = (cv.TM_SQDIFF == match_method or match_method == cv.TM_CCORR_NORMED)
+    if (use_mask and method_accepts_mask):
+        result = cv.matchTemplate(img, templ, match_method, None, mask)
+    else:
+        result = cv.matchTemplate(img, templ, match_method)
+    ## [match_template]
+
+    ## [normalize]
+    cv.normalize( result, result, 0, 1, cv.NORM_MINMAX, -1 )
+    ## [normalize]
+    ## [best_match]
+    _minVal, _maxVal, minLoc, maxLoc = cv.minMaxLoc(result, None)
+    ## [best_match]
+
+    ## [match_loc]
+    if (match_method == cv.TM_SQDIFF or match_method == cv.TM_SQDIFF_NORMED):
+        matchLoc = minLoc
+    else:
+        matchLoc = maxLoc
+    ## [match_loc]
+
+    ## [imshow]
+    cv.rectangle(img_display, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
+    cv.rectangle(result, matchLoc, (matchLoc[0] + templ.shape[0], matchLoc[1] + templ.shape[1]), (0,0,0), 2, 8, 0 )
+    cv.imshow(image_window, img_display)
+    cv.imshow(result_window, result)
+    ## [imshow]
+    pass
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/morph_lines_detection/morph_lines_detection.py

@@ -0,0 +1,136 @@
+"""
+@file morph_lines_detection.py
+@brief Use morphology transformations for extracting horizontal and vertical lines sample code
+"""
+import numpy as np
+import sys
+import cv2 as cv
+
+
+def show_wait_destroy(winname, img):
+    cv.imshow(winname, img)
+    cv.moveWindow(winname, 500, 0)
+    cv.waitKey(0)
+    cv.destroyWindow(winname)
+
+
+def main(argv):
+    # [load_image]
+    # Check number of arguments
+    if len(argv) < 1:
+        print ('Not enough parameters')
+        print ('Usage:\nmorph_lines_detection.py < path_to_image >')
+        return -1
+
+    # Load the image
+    src = cv.imread(argv[0], cv.IMREAD_COLOR)
+
+    # Check if image is loaded fine
+    if src is None:
+        print ('Error opening image: ' + argv[0])
+        return -1
+
+    # Show source image
+    cv.imshow("src", src)
+    # [load_image]
+
+    # [gray]
+    # Transform source image to gray if it is not already
+    if len(src.shape) != 2:
+        gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+    else:
+        gray = src
+
+    # Show gray image
+    show_wait_destroy("gray", gray)
+    # [gray]
+
+    # [bin]
+    # Apply adaptiveThreshold at the bitwise_not of gray, notice the ~ symbol
+    gray = cv.bitwise_not(gray)
+    bw = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 15, -2)
+    # Show binary image
+    show_wait_destroy("binary", bw)
+    # [bin]
+
+    # [init]
+    # Create the images that will use to extract the horizontal and vertical lines
+    horizontal = np.copy(bw)
+    vertical = np.copy(bw)
+    # [init]
+
+    # [horiz]
+    # Specify size on horizontal axis
+    cols = horizontal.shape[1]
+    horizontal_size = cols // 30
+
+    # Create structure element for extracting horizontal lines through morphology operations
+    horizontalStructure = cv.getStructuringElement(cv.MORPH_RECT, (horizontal_size, 1))
+
+    # Apply morphology operations
+    horizontal = cv.erode(horizontal, horizontalStructure)
+    horizontal = cv.dilate(horizontal, horizontalStructure)
+
+    # Show extracted horizontal lines
+    show_wait_destroy("horizontal", horizontal)
+    # [horiz]
+
+    # [vert]
+    # Specify size on vertical axis
+    rows = vertical.shape[0]
+    verticalsize = rows // 30
+
+    # Create structure element for extracting vertical lines through morphology operations
+    verticalStructure = cv.getStructuringElement(cv.MORPH_RECT, (1, verticalsize))
+
+    # Apply morphology operations
+    vertical = cv.erode(vertical, verticalStructure)
+    vertical = cv.dilate(vertical, verticalStructure)
+
+    # Show extracted vertical lines
+    show_wait_destroy("vertical", vertical)
+    # [vert]
+
+    # [smooth]
+    # Inverse vertical image
+    vertical = cv.bitwise_not(vertical)
+    show_wait_destroy("vertical_bit", vertical)
+
+    '''
+    Extract edges and smooth image according to the logic
+    1. extract edges
+    2. dilate(edges)
+    3. src.copyTo(smooth)
+    4. blur smooth img
+    5. smooth.copyTo(src, edges)
+    '''
+
+    # Step 1
+    edges = cv.adaptiveThreshold(vertical, 255, cv.ADAPTIVE_THRESH_MEAN_C, \
+                                cv.THRESH_BINARY, 3, -2)
+    show_wait_destroy("edges", edges)
+
+    # Step 2
+    kernel = np.ones((2, 2), np.uint8)
+    edges = cv.dilate(edges, kernel)
+    show_wait_destroy("dilate", edges)
+
+    # Step 3
+    smooth = np.copy(vertical)
+
+    # Step 4
+    smooth = cv.blur(smooth, (2, 2))
+
+    # Step 5
+    (rows, cols) = np.where(edges != 0)
+    vertical[rows, cols] = smooth[rows, cols]
+
+    # Show final result
+    show_wait_destroy("smooth - final", vertical)
+    # [smooth]
+
+    return 0
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/opening_closing_hats/morphology_2.py

@@ -0,0 +1,48 @@
+from __future__ import print_function
+import cv2 as cv
+import numpy as np
+import argparse
+
+morph_size = 0
+max_operator = 4
+max_elem = 2
+max_kernel_size = 21
+title_trackbar_operator_type = 'Operator:\n 0: Opening - 1: Closing  \n 2: Gradient - 3: Top Hat \n 4: Black Hat'
+title_trackbar_element_type = 'Element:\n 0: Rect - 1: Cross - 2: Ellipse'
+title_trackbar_kernel_size = 'Kernel size:\n 2n + 1'
+title_window = 'Morphology Transformations Demo'
+morph_op_dic = {0: cv.MORPH_OPEN, 1: cv.MORPH_CLOSE, 2: cv.MORPH_GRADIENT, 3: cv.MORPH_TOPHAT, 4: cv.MORPH_BLACKHAT}
+
+def morphology_operations(val):
+    morph_operator = cv.getTrackbarPos(title_trackbar_operator_type, title_window)
+    morph_size = cv.getTrackbarPos(title_trackbar_kernel_size, title_window)
+    morph_elem = 0
+    val_type = cv.getTrackbarPos(title_trackbar_element_type, title_window)
+    if val_type == 0:
+        morph_elem = cv.MORPH_RECT
+    elif val_type == 1:
+        morph_elem = cv.MORPH_CROSS
+    elif val_type == 2:
+        morph_elem = cv.MORPH_ELLIPSE
+
+    element = cv.getStructuringElement(morph_elem, (2*morph_size + 1, 2*morph_size+1), (morph_size, morph_size))
+    operation = morph_op_dic[morph_operator]
+    dst = cv.morphologyEx(src, operation, element)
+    cv.imshow(title_window, dst)
+
+parser = argparse.ArgumentParser(description='Code for More Morphology Transformations tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='LinuxLogo.jpg')
+args = parser.parse_args()
+
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+
+cv.namedWindow(title_window)
+cv.createTrackbar(title_trackbar_operator_type, title_window , 0, max_operator, morphology_operations)
+cv.createTrackbar(title_trackbar_element_type, title_window , 0, max_elem, morphology_operations)
+cv.createTrackbar(title_trackbar_kernel_size, title_window , 0, max_kernel_size, morphology_operations)
+
+morphology_operations(0)
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/threshold/threshold.py

@@ -0,0 +1,54 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+max_value = 255
+max_type = 4
+max_binary_value = 255
+trackbar_type = 'Type: \n 0: Binary \n 1: Binary Inverted \n 2: Truncate \n 3: To Zero \n 4: To Zero Inverted'
+trackbar_value = 'Value'
+window_name = 'Threshold Demo'
+
+## [Threshold_Demo]
+def Threshold_Demo(val):
+    #0: Binary
+    #1: Binary Inverted
+    #2: Threshold Truncated
+    #3: Threshold to Zero
+    #4: Threshold to Zero Inverted
+    threshold_type = cv.getTrackbarPos(trackbar_type, window_name)
+    threshold_value = cv.getTrackbarPos(trackbar_value, window_name)
+    _, dst = cv.threshold(src_gray, threshold_value, max_binary_value, threshold_type )
+    cv.imshow(window_name, dst)
+## [Threshold_Demo]
+
+parser = argparse.ArgumentParser(description='Code for Basic Thresholding Operations tutorial.')
+parser.add_argument('--input', help='Path to input image.', default='stuff.jpg')
+args = parser.parse_args()
+
+## [load]
+# Load an image
+src = cv.imread(cv.samples.findFile(args.input))
+if src is None:
+    print('Could not open or find the image: ', args.input)
+    exit(0)
+# Convert the image to Gray
+src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
+## [load]
+
+## [window]
+# Create a window to display results
+cv.namedWindow(window_name)
+## [window]
+
+## [trackbar]
+# Create Trackbar to choose type of Threshold
+cv.createTrackbar(trackbar_type, window_name , 3, max_type, Threshold_Demo)
+# Create Trackbar to choose Threshold value
+cv.createTrackbar(trackbar_value, window_name , 0, max_value, Threshold_Demo)
+## [trackbar]
+
+# Call the function to initialize
+Threshold_Demo(0)
+# Wait until user finishes program
+cv.waitKey()

3rdparty/opencv-4.5.4/samples/python/tutorial_code/imgProc/threshold_inRange/threshold_inRange.py

@@ -0,0 +1,107 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+max_value = 255
+max_value_H = 360//2
+low_H = 0
+low_S = 0
+low_V = 0
+high_H = max_value_H
+high_S = max_value
+high_V = max_value
+window_capture_name = 'Video Capture'
+window_detection_name = 'Object Detection'
+low_H_name = 'Low H'
+low_S_name = 'Low S'
+low_V_name = 'Low V'
+high_H_name = 'High H'
+high_S_name = 'High S'
+high_V_name = 'High V'
+
+## [low]
+def on_low_H_thresh_trackbar(val):
+    global low_H
+    global high_H
+    low_H = val
+    low_H = min(high_H-1, low_H)
+    cv.setTrackbarPos(low_H_name, window_detection_name, low_H)
+## [low]
+
+## [high]
+def on_high_H_thresh_trackbar(val):
+    global low_H
+    global high_H
+    high_H = val
+    high_H = max(high_H, low_H+1)
+    cv.setTrackbarPos(high_H_name, window_detection_name, high_H)
+## [high]
+
+def on_low_S_thresh_trackbar(val):
+    global low_S
+    global high_S
+    low_S = val
+    low_S = min(high_S-1, low_S)
+    cv.setTrackbarPos(low_S_name, window_detection_name, low_S)
+
+def on_high_S_thresh_trackbar(val):
+    global low_S
+    global high_S
+    high_S = val
+    high_S = max(high_S, low_S+1)
+    cv.setTrackbarPos(high_S_name, window_detection_name, high_S)
+
+def on_low_V_thresh_trackbar(val):
+    global low_V
+    global high_V
+    low_V = val
+    low_V = min(high_V-1, low_V)
+    cv.setTrackbarPos(low_V_name, window_detection_name, low_V)
+
+def on_high_V_thresh_trackbar(val):
+    global low_V
+    global high_V
+    high_V = val
+    high_V = max(high_V, low_V+1)
+    cv.setTrackbarPos(high_V_name, window_detection_name, high_V)
+
+parser = argparse.ArgumentParser(description='Code for Thresholding Operations using inRange tutorial.')
+parser.add_argument('--camera', help='Camera divide number.', default=0, type=int)
+args = parser.parse_args()
+
+## [cap]
+cap = cv.VideoCapture(args.camera)
+## [cap]
+
+## [window]
+cv.namedWindow(window_capture_name)
+cv.namedWindow(window_detection_name)
+## [window]
+
+## [trackbar]
+cv.createTrackbar(low_H_name, window_detection_name , low_H, max_value_H, on_low_H_thresh_trackbar)
+cv.createTrackbar(high_H_name, window_detection_name , high_H, max_value_H, on_high_H_thresh_trackbar)
+cv.createTrackbar(low_S_name, window_detection_name , low_S, max_value, on_low_S_thresh_trackbar)
+cv.createTrackbar(high_S_name, window_detection_name , high_S, max_value, on_high_S_thresh_trackbar)
+cv.createTrackbar(low_V_name, window_detection_name , low_V, max_value, on_low_V_thresh_trackbar)
+cv.createTrackbar(high_V_name, window_detection_name , high_V, max_value, on_high_V_thresh_trackbar)
+## [trackbar]
+
+while True:
+    ## [while]
+    ret, frame = cap.read()
+    if frame is None:
+        break
+
+    frame_HSV = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+    frame_threshold = cv.inRange(frame_HSV, (low_H, low_S, low_V), (high_H, high_S, high_V))
+    ## [while]
+
+    ## [show]
+    cv.imshow(window_capture_name, frame)
+    cv.imshow(window_detection_name, frame_threshold)
+    ## [show]
+
+    key = cv.waitKey(30)
+    if key == ord('q') or key == 27:
+        break

3rdparty/opencv-4.5.4/samples/python/tutorial_code/introduction/display_image/display_image.py

@@ -0,0 +1,19 @@
+## [imports]
+import cv2 as cv
+import sys
+## [imports]
+## [imread]
+img = cv.imread(cv.samples.findFile("starry_night.jpg"))
+## [imread]
+## [empty]
+if img is None:
+    sys.exit("Could not read the image.")
+## [empty]
+## [imshow]
+cv.imshow("Display window", img)
+k = cv.waitKey(0)
+## [imshow]
+## [imsave]
+if k == ord("s"):
+    cv.imwrite("starry_night.png", img)
+## [imsave]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/introduction/documentation/documentation.py

@@ -0,0 +1,5 @@
+print('Not showing this text because it is outside the snippet')
+
+## [hello_world]
+print('Hello world!')
+## [hello_world]

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)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/objectDetection/cascade_classifier/objectDetection.py

@@ -0,0 +1,61 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+def detectAndDisplay(frame):
+    frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+    frame_gray = cv.equalizeHist(frame_gray)
+
+    #-- Detect faces
+    faces = face_cascade.detectMultiScale(frame_gray)
+    for (x,y,w,h) in faces:
+        center = (x + w//2, y + h//2)
+        frame = cv.ellipse(frame, center, (w//2, h//2), 0, 0, 360, (255, 0, 255), 4)
+
+        faceROI = frame_gray[y:y+h,x:x+w]
+        #-- In each face, detect eyes
+        eyes = eyes_cascade.detectMultiScale(faceROI)
+        for (x2,y2,w2,h2) in eyes:
+            eye_center = (x + x2 + w2//2, y + y2 + h2//2)
+            radius = int(round((w2 + h2)*0.25))
+            frame = cv.circle(frame, eye_center, radius, (255, 0, 0 ), 4)
+
+    cv.imshow('Capture - Face detection', frame)
+
+parser = argparse.ArgumentParser(description='Code for Cascade Classifier tutorial.')
+parser.add_argument('--face_cascade', help='Path to face cascade.', default='data/haarcascades/haarcascade_frontalface_alt.xml')
+parser.add_argument('--eyes_cascade', help='Path to eyes cascade.', default='data/haarcascades/haarcascade_eye_tree_eyeglasses.xml')
+parser.add_argument('--camera', help='Camera divide number.', type=int, default=0)
+args = parser.parse_args()
+
+face_cascade_name = args.face_cascade
+eyes_cascade_name = args.eyes_cascade
+
+face_cascade = cv.CascadeClassifier()
+eyes_cascade = cv.CascadeClassifier()
+
+#-- 1. Load the cascades
+if not face_cascade.load(cv.samples.findFile(face_cascade_name)):
+    print('--(!)Error loading face cascade')
+    exit(0)
+if not eyes_cascade.load(cv.samples.findFile(eyes_cascade_name)):
+    print('--(!)Error loading eyes cascade')
+    exit(0)
+
+camera_device = args.camera
+#-- 2. Read the video stream
+cap = cv.VideoCapture(camera_device)
+if not cap.isOpened:
+    print('--(!)Error opening video capture')
+    exit(0)
+
+while True:
+    ret, frame = cap.read()
+    if frame is None:
+        print('--(!) No captured frame -- Break!')
+        break
+
+    detectAndDisplay(frame)
+
+    if cv.waitKey(10) == 27:
+        break

3rdparty/opencv-4.5.4/samples/python/tutorial_code/photo/hdr_imaging/hdr_imaging.py

@@ -0,0 +1,56 @@
+from __future__ import print_function
+from __future__ import division
+import cv2 as cv
+import numpy as np
+import argparse
+import os
+
+def loadExposureSeq(path):
+    images = []
+    times = []
+    with open(os.path.join(path, 'list.txt')) as f:
+        content = f.readlines()
+    for line in content:
+        tokens = line.split()
+        images.append(cv.imread(os.path.join(path, tokens[0])))
+        times.append(1 / float(tokens[1]))
+
+    return images, np.asarray(times, dtype=np.float32)
+
+parser = argparse.ArgumentParser(description='Code for High Dynamic Range Imaging tutorial.')
+parser.add_argument('--input', type=str, help='Path to the directory that contains images and exposure times.')
+args = parser.parse_args()
+
+if not args.input:
+    parser.print_help()
+    exit(0)
+
+## [Load images and exposure times]
+images, times = loadExposureSeq(args.input)
+## [Load images and exposure times]
+
+## [Estimate camera response]
+calibrate = cv.createCalibrateDebevec()
+response = calibrate.process(images, times)
+## [Estimate camera response]
+
+## [Make HDR image]
+merge_debevec = cv.createMergeDebevec()
+hdr = merge_debevec.process(images, times, response)
+## [Make HDR image]
+
+## [Tonemap HDR image]
+tonemap = cv.createTonemap(2.2)
+ldr = tonemap.process(hdr)
+## [Tonemap HDR image]
+
+## [Perform exposure fusion]
+merge_mertens = cv.createMergeMertens()
+fusion = merge_mertens.process(images)
+## [Perform exposure fusion]
+
+## [Write results]
+cv.imwrite('fusion.png', fusion * 255)
+cv.imwrite('ldr.png', ldr * 255)
+cv.imwrite('hdr.hdr', hdr)
+## [Write results]

3rdparty/opencv-4.5.4/samples/python/tutorial_code/video/background_subtraction/bg_sub.py

@@ -0,0 +1,51 @@
+from __future__ import print_function
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This program shows how to use background subtraction methods provided by \
+                                              OpenCV. You can process both videos and images.')
+parser.add_argument('--input', type=str, help='Path to a video or a sequence of image.', default='vtest.avi')
+parser.add_argument('--algo', type=str, help='Background subtraction method (KNN, MOG2).', default='MOG2')
+args = parser.parse_args()
+
+## [create]
+#create Background Subtractor objects
+if args.algo == 'MOG2':
+    backSub = cv.createBackgroundSubtractorMOG2()
+else:
+    backSub = cv.createBackgroundSubtractorKNN()
+## [create]
+
+## [capture]
+capture = cv.VideoCapture(cv.samples.findFileOrKeep(args.input))
+if not capture.isOpened():
+    print('Unable to open: ' + args.input)
+    exit(0)
+## [capture]
+
+while True:
+    ret, frame = capture.read()
+    if frame is None:
+        break
+
+    ## [apply]
+    #update the background model
+    fgMask = backSub.apply(frame)
+    ## [apply]
+
+    ## [display_frame_number]
+    #get the frame number and write it on the current frame
+    cv.rectangle(frame, (10, 2), (100,20), (255,255,255), -1)
+    cv.putText(frame, str(capture.get(cv.CAP_PROP_POS_FRAMES)), (15, 15),
+               cv.FONT_HERSHEY_SIMPLEX, 0.5 , (0,0,0))
+    ## [display_frame_number]
+
+    ## [show]
+    #show the current frame and the fg masks
+    cv.imshow('Frame', frame)
+    cv.imshow('FG Mask', fgMask)
+    ## [show]
+
+    keyboard = cv.waitKey(30)
+    if keyboard == 'q' or keyboard == 27:
+        break

3rdparty/opencv-4.5.4/samples/python/tutorial_code/video/meanshift/camshift.py

@@ -0,0 +1,50 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This sample demonstrates the camshift algorithm. \
+                                              The example file can be downloaded from: \
+                                              https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
+parser.add_argument('image', type=str, help='path to image file')
+args = parser.parse_args()
+
+cap = cv.VideoCapture(args.image)
+
+# take first frame of the video
+ret,frame = cap.read()
+
+# setup initial location of window
+x, y, w, h = 300, 200, 100, 50 # simply hardcoded the values
+track_window = (x, y, w, h)
+
+# set up the ROI for tracking
+roi = frame[y:y+h, x:x+w]
+hsv_roi =  cv.cvtColor(roi, cv.COLOR_BGR2HSV)
+mask = cv.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
+roi_hist = cv.calcHist([hsv_roi],[0],mask,[180],[0,180])
+cv.normalize(roi_hist,roi_hist,0,255,cv.NORM_MINMAX)
+
+# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
+term_crit = ( cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1 )
+
+while(1):
+    ret, frame = cap.read()
+
+    if ret == True:
+        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+        dst = cv.calcBackProject([hsv],[0],roi_hist,[0,180],1)
+
+        # apply camshift to get the new location
+        ret, track_window = cv.CamShift(dst, track_window, term_crit)
+
+        # Draw it on image
+        pts = cv.boxPoints(ret)
+        pts = np.int0(pts)
+        img2 = cv.polylines(frame,[pts],True, 255,2)
+        cv.imshow('img2',img2)
+
+        k = cv.waitKey(30) & 0xff
+        if k == 27:
+            break
+    else:
+        break

3rdparty/opencv-4.5.4/samples/python/tutorial_code/video/meanshift/meanshift.py

@@ -0,0 +1,49 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This sample demonstrates the meanshift algorithm. \
+                                              The example file can be downloaded from: \
+                                              https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
+parser.add_argument('image', type=str, help='path to image file')
+args = parser.parse_args()
+
+cap = cv.VideoCapture(args.image)
+
+# take first frame of the video
+ret,frame = cap.read()
+
+# setup initial location of window
+x, y, w, h = 300, 200, 100, 50 # simply hardcoded the values
+track_window = (x, y, w, h)
+
+# set up the ROI for tracking
+roi = frame[y:y+h, x:x+w]
+hsv_roi =  cv.cvtColor(roi, cv.COLOR_BGR2HSV)
+mask = cv.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
+roi_hist = cv.calcHist([hsv_roi],[0],mask,[180],[0,180])
+cv.normalize(roi_hist,roi_hist,0,255,cv.NORM_MINMAX)
+
+# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
+term_crit = ( cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1 )
+
+while(1):
+    ret, frame = cap.read()
+
+    if ret == True:
+        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
+        dst = cv.calcBackProject([hsv],[0],roi_hist,[0,180],1)
+
+        # apply meanshift to get the new location
+        ret, track_window = cv.meanShift(dst, track_window, term_crit)
+
+        # Draw it on image
+        x,y,w,h = track_window
+        img2 = cv.rectangle(frame, (x,y), (x+w,y+h), 255,2)
+        cv.imshow('img2',img2)
+
+        k = cv.waitKey(30) & 0xff
+        if k == 27:
+            break
+    else:
+        break

3rdparty/opencv-4.5.4/samples/python/tutorial_code/video/optical_flow/optical_flow.py

@@ -0,0 +1,62 @@
+import numpy as np
+import cv2 as cv
+import argparse
+
+parser = argparse.ArgumentParser(description='This sample demonstrates Lucas-Kanade Optical Flow calculation. \
+                                              The example file can be downloaded from: \
+                                              https://www.bogotobogo.com/python/OpenCV_Python/images/mean_shift_tracking/slow_traffic_small.mp4')
+parser.add_argument('image', type=str, help='path to image file')
+args = parser.parse_args()
+
+cap = cv.VideoCapture(args.image)
+
+# params for ShiTomasi corner detection
+feature_params = dict( maxCorners = 100,
+                       qualityLevel = 0.3,
+                       minDistance = 7,
+                       blockSize = 7 )
+
+# Parameters for lucas kanade optical flow
+lk_params = dict( winSize  = (15,15),
+                  maxLevel = 2,
+                  criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
+
+# Create some random colors
+color = np.random.randint(0,255,(100,3))
+
+# Take first frame and find corners in it
+ret, old_frame = cap.read()
+old_gray = cv.cvtColor(old_frame, cv.COLOR_BGR2GRAY)
+p0 = cv.goodFeaturesToTrack(old_gray, mask = None, **feature_params)
+
+# Create a mask image for drawing purposes
+mask = np.zeros_like(old_frame)
+
+while(1):
+    ret,frame = cap.read()
+    frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+
+    # calculate optical flow
+    p1, st, err = cv.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)
+
+    # Select good points
+    if p1 is not None:
+        good_new = p1[st==1]
+        good_old = p0[st==1]
+
+    # draw the tracks
+    for i,(new,old) in enumerate(zip(good_new, good_old)):
+        a,b = new.ravel()
+        c,d = old.ravel()
+        mask = cv.line(mask, (int(a),int(b)),(int(c),int(d)), color[i].tolist(), 2)
+        frame = cv.circle(frame,(int(a),int(b)),5,color[i].tolist(),-1)
+    img = cv.add(frame,mask)
+
+    cv.imshow('frame',img)
+    k = cv.waitKey(30) & 0xff
+    if k == 27:
+        break
+
+    # Now update the previous frame and previous points
+    old_gray = frame_gray.copy()
+    p0 = good_new.reshape(-1,1,2)

3rdparty/opencv-4.5.4/samples/python/tutorial_code/video/optical_flow/optical_flow_dense.py

@@ -0,0 +1,23 @@
+import numpy as np
+import cv2 as cv
+cap = cv.VideoCapture(cv.samples.findFile("vtest.avi"))
+ret, frame1 = cap.read()
+prvs = cv.cvtColor(frame1,cv.COLOR_BGR2GRAY)
+hsv = np.zeros_like(frame1)
+hsv[...,1] = 255
+while(1):
+    ret, frame2 = cap.read()
+    next = cv.cvtColor(frame2,cv.COLOR_BGR2GRAY)
+    flow = cv.calcOpticalFlowFarneback(prvs,next, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+    mag, ang = cv.cartToPolar(flow[...,0], flow[...,1])
+    hsv[...,0] = ang*180/np.pi/2
+    hsv[...,2] = cv.normalize(mag,None,0,255,cv.NORM_MINMAX)
+    bgr = cv.cvtColor(hsv,cv.COLOR_HSV2BGR)
+    cv.imshow('frame2',bgr)
+    k = cv.waitKey(30) & 0xff
+    if k == 27:
+        break
+    elif k == ord('s'):
+        cv.imwrite('opticalfb.png',frame2)
+        cv.imwrite('opticalhsv.png',bgr)
+    prvs = next

3rdparty/opencv-4.5.4/samples/python/tutorial_code/videoio/video-input-psnr-ssim.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+import argparse
+import sys
+
+# [get-psnr]
+def getPSNR(I1, I2):
+    s1 = cv.absdiff(I1, I2) #|I1 - I2|
+    s1 = np.float32(s1)     # cannot make a square on 8 bits
+    s1 = s1 * s1            # |I1 - I2|^2
+    sse = s1.sum()          # sum elements per channel
+    if sse <= 1e-10:        # sum channels
+        return 0            # for small values return zero
+    else:
+        shape = I1.shape
+        mse = 1.0 * sse / (shape[0] * shape[1] * shape[2])
+        psnr = 10.0 * np.log10((255 * 255) / mse)
+        return psnr
+# [get-psnr]
+
+# [get-mssim]
+def getMSSISM(i1, i2):
+    C1 = 6.5025
+    C2 = 58.5225
+    # INITS
+
+    I1 = np.float32(i1) # cannot calculate on one byte large values
+    I2 = np.float32(i2)
+
+    I2_2 = I2 * I2 # I2^2
+    I1_2 = I1 * I1 # I1^2
+    I1_I2 = I1 * I2 # I1 * I2
+    # END INITS
+
+    # PRELIMINARY COMPUTING
+    mu1 = cv.GaussianBlur(I1, (11, 11), 1.5)
+    mu2 = cv.GaussianBlur(I2, (11, 11), 1.5)
+
+    mu1_2 = mu1 * mu1
+    mu2_2 = mu2 * mu2
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_2 = cv.GaussianBlur(I1_2, (11, 11), 1.5)
+    sigma1_2 -= mu1_2
+
+    sigma2_2 = cv.GaussianBlur(I2_2, (11, 11), 1.5)
+    sigma2_2 -= mu2_2
+
+    sigma12 = cv.GaussianBlur(I1_I2, (11, 11), 1.5)
+    sigma12 -= mu1_mu2
+
+    t1 = 2 * mu1_mu2 + C1
+    t2 = 2 * sigma12 + C2
+    t3 = t1 * t2                    # t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1
+    t2 = sigma1_2 + sigma2_2 + C2
+    t1 = t1 * t2                    # t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    ssim_map = cv.divide(t3, t1)    # ssim_map =  t3./t1;
+
+    mssim = cv.mean(ssim_map)       # mssim = average of ssim map
+    return mssim
+# [get-mssim]
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--delay", type=int, default=30, help=" Time delay")
+    parser.add_argument("-v", "--psnrtriggervalue", type=int, default=30, help="PSNR Trigger Value")
+    parser.add_argument("-r", "--ref", type=str, default="Megamind.avi", help="Path to reference video")
+    parser.add_argument("-t", "--undertest", type=str, default="Megamind_bugy.avi",
+                        help="Path to the video to be tested")
+    args = parser.parse_args()
+
+    sourceReference = args.ref
+    sourceCompareWith = args.undertest
+    delay = args.delay
+    psnrTriggerValue = args.psnrtriggervalue
+
+    framenum = -1 # Frame counter
+
+    captRefrnc = cv.VideoCapture(cv.samples.findFileOrKeep(sourceReference))
+    captUndTst = cv.VideoCapture(cv.samples.findFileOrKeep(sourceCompareWith))
+
+    if not captRefrnc.isOpened():
+        print("Could not open the reference " + sourceReference)
+        sys.exit(-1)
+    if not captUndTst.isOpened():
+        print("Could not open case test " + sourceCompareWith)
+        sys.exit(-1)
+
+    refS = (int(captRefrnc.get(cv.CAP_PROP_FRAME_WIDTH)), int(captRefrnc.get(cv.CAP_PROP_FRAME_HEIGHT)))
+    uTSi = (int(captUndTst.get(cv.CAP_PROP_FRAME_WIDTH)), int(captUndTst.get(cv.CAP_PROP_FRAME_HEIGHT)))
+
+    if refS != uTSi:
+        print("Inputs have different size!!! Closing.")
+        sys.exit(-1)
+
+    WIN_UT = "Under Test"
+    WIN_RF = "Reference"
+
+    cv.namedWindow(WIN_RF, cv.WINDOW_AUTOSIZE)
+    cv.namedWindow(WIN_UT, cv.WINDOW_AUTOSIZE)
+    cv.moveWindow(WIN_RF, 400, 0) #750,  2 (bernat =0)
+    cv.moveWindow(WIN_UT, refS[0], 0) #1500, 2
+
+    print("Reference frame resolution: Width={} Height={} of nr#: {}".format(refS[0], refS[1],
+                                                                             captRefrnc.get(cv.CAP_PROP_FRAME_COUNT)))
+    print("PSNR trigger value {}".format(psnrTriggerValue))
+
+    while True: # Show the image captured in the window and repeat
+        _, frameReference = captRefrnc.read()
+        _, frameUnderTest = captUndTst.read()
+
+        if frameReference is None or frameUnderTest is None:
+            print(" < < <  Game over!  > > > ")
+            break
+
+        framenum += 1
+        psnrv = getPSNR(frameReference, frameUnderTest)
+        print("Frame: {}# {}dB".format(framenum, round(psnrv, 3)), end=" ")
+
+        if (psnrv < psnrTriggerValue and psnrv):
+            mssimv = getMSSISM(frameReference, frameUnderTest)
+            print("MSSISM: R {}% G {}% B {}%".format(round(mssimv[2] * 100, 2), round(mssimv[1] * 100, 2),
+                                                     round(mssimv[0] * 100, 2)), end=" ")
+
+        print()
+
+        cv.imshow(WIN_RF, frameReference)
+        cv.imshow(WIN_UT, frameUnderTest)
+
+        k = cv.waitKey(delay)
+        if k == 27:
+            break
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()