diff --git a/doc/tutorials/others/meanshift.markdown b/doc/tutorials/others/meanshift.markdown
index 858ad1b7c9..1fab48b34d 100644
--- a/doc/tutorials/others/meanshift.markdown
+++ b/doc/tutorials/others/meanshift.markdown
@@ -135,5 +135,5 @@ Additional Resources
 Exercises
 ---------
 
--#  OpenCV comes with a Python [sample](https://github.com/opencv/opencv/blob/5.x/samples/python/camshift.py) for an interactive demo of camshift. Use it, hack it, understand
-    it.
+-#  OpenCV comes with a Python [sample](https://github.com/opencv/opencv/blob/5.x/samples/python/snippets/camshift.py) for an interactive demo of camshift. Use it, hack it, understand
+    it.
\ No newline at end of file
diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp
index a1b1390f7f..4d4027e9ca 100644
--- a/modules/core/include/opencv2/core.hpp
+++ b/modules/core/include/opencv2/core.hpp
@@ -2160,6 +2160,10 @@ the invert function (preferably using the #DECOMP_SVD method, as the most accura
 */
 CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar);
 
+/** @example samples/python/snippets/dft.py
+An example on Discrete Fourier transform (DFT) in python.
+*/
+
 /** @brief Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.
 
 The function cv::dft performs one of the following:
@@ -3055,7 +3059,10 @@ private:
 //!  @{
 
 /** @example samples/cpp/snippets/kmeans.cpp
-An example on K-means clustering
+An example on k-means clustering
+*/
+/** @example samples/python/snippets/kmeans.py
+An example on k-means clustering in python
 */
 
 /** @brief Finds centers of clusters and groups input samples around the clusters.
diff --git a/modules/features2d/include/opencv2/features2d.hpp b/modules/features2d/include/opencv2/features2d.hpp
index 827334d442..6d675ddd2b 100644
--- a/modules/features2d/include/opencv2/features2d.hpp
+++ b/modules/features2d/include/opencv2/features2d.hpp
@@ -482,6 +482,10 @@ public:
     CV_WRAP virtual String getDefaultName() const CV_OVERRIDE;
 };
 
+/** @example samples/python/snippets/mser.py
+An example using Maximally stable extremal region(MSER) extractor in python
+*/
+
 /** @brief Maximally stable extremal region extractor
 
 The class encapsulates all the parameters of the %MSER extraction algorithm (see [wiki
diff --git a/modules/imgproc/include/opencv2/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc.hpp
index c33b833b0f..f9eceb4e98 100644
--- a/modules/imgproc/include/opencv2/imgproc.hpp
+++ b/modules/imgproc/include/opencv2/imgproc.hpp
@@ -1847,7 +1847,10 @@ CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth,
                           int borderType = BORDER_DEFAULT );
 
 /** @example samples/cpp/snippets/laplace.cpp
-An example using Laplace transformations for edge detection
+An example using Laplace filter for edge detection
+*/
+/** @example samples/python/snippets/laplace.py
+An example using Laplace filter for edge detection in python
 */
 
 /** @brief Calculates the Laplacian of an image.
@@ -1968,6 +1971,10 @@ CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize,
                                 int ksize, double k,
                                 int borderType = BORDER_DEFAULT );
 
+/** @example samples/python/snippets/texture_flow.py
+An example using cornerEigenValsAndVecs in python
+*/
+
 /** @brief Calculates eigenvalues and eigenvectors of image blocks for corner detection.
 
 For every pixel \f$p\f$ , the function cornerEigenValsAndVecs considers a blockSize \f$\times\f$ blockSize
@@ -2158,6 +2165,9 @@ CV_EXPORTS CV_WRAP_AS(goodFeaturesToTrackWithQuality) void goodFeaturesToTrack(
 An example using the Hough line detector
 ![Sample input image](Hough_Lines_Tutorial_Original_Image.jpg) ![Output image](Hough_Lines_Tutorial_Result.jpg)
 */
+/** @example samples/python/snippets/houghlines.py
+An example using the Hough line detector in python
+*/
 
 /** @brief Finds lines in a binary image using the standard Hough transform.
 
@@ -2248,6 +2258,9 @@ CV_EXPORTS_W void HoughLinesPointSet( InputArray point, OutputArray lines, int l
 /** @example samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp
 An example using the Hough circle detector
 */
+/** @example samples/python/snippets/houghcircles.py
+An example using the Hough circle detector in python
+*/
 
 /** @brief Finds circles in a grayscale image using the Hough transform.
 
@@ -2689,6 +2702,9 @@ CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
 /** @example samples/cpp/snippets/polar_transforms.cpp
 An example using the cv::linearPolar and cv::logPolar operations
 */
+/** @example samples/python/snippets/logpolar.py
+An example using the linearPolar and logPolar operations in python
+*/
 
 /** @brief Remaps an image to semilog-polar coordinates space.
 
@@ -3423,6 +3439,9 @@ CV_EXPORTS_AS(EMD) float wrapperEMD( InputArray signature1, InputArray signature
 /** @example samples/cpp/snippets/watershed.cpp
 An example using the watershed algorithm
 */
+/** @example samples/python/snippets/watershed.py
+An example using the watershed algorithm using python
+*/
 
 /** @brief Performs a marker-based image segmentation using the watershed algorithm.
 
@@ -3535,6 +3554,9 @@ CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect,
 /** @example samples/cpp/snippets/distrans.cpp
 An example on using the distance transform
 */
+/** @example samples/python/snippets/distrans.py
+An example on using the distance transform in python
+*/
 
 /** @brief Calculates the distance to the closest zero pixel for each pixel of the source image.
 
@@ -4069,6 +4091,10 @@ CV_EXPORTS_W void findContoursLinkRuns(InputArray image, OutputArrayOfArrays con
 //! @overload
 CV_EXPORTS_W void findContoursLinkRuns(InputArray image, OutputArrayOfArrays contours);
 
+/** @example samples/python/snippets/squares.py
+An example using approxPolyDP function in python.
+*/
+
 /** @brief Approximates a polygonal curve(s) with the specified precision.
 
 The function cv::approxPolyDP approximates a curve or a polygon with another curve/polygon with less
@@ -4401,6 +4427,10 @@ CV_EXPORTS_W RotatedRect fitEllipseAMS( InputArray points );
  */
 CV_EXPORTS_W RotatedRect fitEllipseDirect( InputArray points );
 
+/** @example samples/python/snippets/fitline.py
+An example for fitting line in python
+*/
+
 /** @brief Fits a line to a 2D or 3D point set.
 
 The function fitLine fits a line to a 2D or 3D point set by minimizing \f$\sum_i \rho(r_i)\f$ where
@@ -4762,6 +4792,9 @@ CV_EXPORTS void polylines(InputOutputArray img, const Point* const* pts, const i
                           int ncontours, bool isClosed, const Scalar& color,
                           int thickness = 1, int lineType = LINE_8, int shift = 0 );
 
+/** @example samples/python/snippets/contours.py
+An example program illustrates the use of findContours and drawContours in python
+*/
 
 /** @example samples/cpp/snippets/segment_objects.cpp
 An example using drawContours to clean up a background segmentation result
diff --git a/modules/stitching/include/opencv2/stitching.hpp b/modules/stitching/include/opencv2/stitching.hpp
index bde1411bc0..cf4b150fb4 100644
--- a/modules/stitching/include/opencv2/stitching.hpp
+++ b/modules/stitching/include/opencv2/stitching.hpp
@@ -113,7 +113,7 @@ namespace cv {
 A basic example on image stitching
 */
 
-/** @example samples/python/stitching.py
+/** @example samples/python/snippets/stitching.py
 A basic example on image stitching in Python.
 */
 
diff --git a/modules/video/include/opencv2/video/tracking.hpp b/modules/video/include/opencv2/video/tracking.hpp
index 737abf435c..b1fc24f36c 100644
--- a/modules/video/include/opencv2/video/tracking.hpp
+++ b/modules/video/include/opencv2/video/tracking.hpp
@@ -74,7 +74,7 @@ See the OpenCV sample camshiftdemo.c that tracks colored objects.
 
 @note
 -   (Python) A sample explaining the camshift tracking algorithm can be found at
-    opencv_source_code/samples/python/camshift.py
+    opencv_source_code/samples/python/snippets/camshift.py
  */
 CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_IN_OUT Rect& window,
                                    TermCriteria criteria );
@@ -129,6 +129,10 @@ CV_EXPORTS_W int buildOpticalFlowPyramid( InputArray img, OutputArrayOfArrays py
 An example using the Lucas-Kanade optical flow algorithm
 */
 
+/** @example samples/python/snippets/lk_track.py
+An example using the Lucas-Kanade optical flow algorithm in python
+*/
+
 /** @brief Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with
 pyramids.
 
@@ -183,6 +187,10 @@ CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg,
                                         TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01),
                                         int flags = 0, double minEigThreshold = 1e-4 );
 
+/** @example samples/python/snippets/opt_flow.py
+An example to show optical flow in python
+*/
+
 /** @brief Computes a dense optical flow using the Gunnar Farneback's algorithm.
 
 @param prev first 8-bit single-channel input image.
@@ -350,6 +358,11 @@ double findTransformECC(InputArray templateImage, InputArray inputImage,
 An example using the standard Kalman filter
 */
 
+
+/** @example samples/python/snippets/kalman.py
+An example using the standard Kalman filter in Python.
+ */
+
 /** @brief Kalman filter class.
 
 The class implements a standard Kalman filter <http://en.wikipedia.org/wiki/Kalman_filter>,
@@ -431,9 +444,14 @@ CV_EXPORTS_W Mat readOpticalFlow( const String& path );
  */
 CV_EXPORTS_W bool writeOpticalFlow( const String& path, InputArray flow );
 
+/** @example samples/python/snippets/dis_opt_flow.py
+An example using the dense optical flow and DIS optical flow algorithms in python
+*/
+
 /** @example samples/cpp/snippets/dis_opticalflow.cpp
 An example using the dense optical flow and DIS optical flow algorithms
 */
+
 /**
    Base class for dense optical flow algorithms
 */
diff --git a/samples/python/browse.py b/samples/python/browse.py
deleted file mode 100755
index b55f8d9373..0000000000
--- a/samples/python/browse.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-
-'''
-browse.py
-=========
-
-Sample shows how to implement a simple hi resolution image navigation
-
-Usage
------
-browse.py [image filename]
-
-'''
-
-import numpy as np
-import cv2 as cv
-
-# built-in modules
-import sys
-
-def main():
-    if len(sys.argv) > 1:
-        fn = cv.samples.findFile(sys.argv[1])
-        print('loading %s ...' % fn)
-        img = cv.imread(fn)
-        if img is None:
-            print('Failed to load fn:', fn)
-            sys.exit(1)
-
-    else:
-        sz = 4096
-        print('generating %dx%d procedural image ...' % (sz, sz))
-        img = np.zeros((sz, sz), np.uint8)
-        track = np.cumsum(np.random.rand(500000, 2)-0.5, axis=0)
-        track = np.int32(track*10 + (sz/2, sz/2))
-        cv.polylines(img, [track], 0, 255, 1, cv.LINE_AA)
-
-
-    small = img
-    for _i in range(3):
-        small = cv.pyrDown(small)
-
-    def onmouse(event, x, y, flags, param):
-        h, _w = img.shape[:2]
-        h1, _w1 = small.shape[:2]
-        x, y = 1.0*x*h/h1, 1.0*y*h/h1
-        zoom = cv.getRectSubPix(img, (800, 600), (x+0.5, y+0.5))
-        cv.imshow('zoom', zoom)
-
-    cv.imshow('preview', small)
-    cv.setMouseCallback('preview', onmouse)
-    cv.waitKey()
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/coherence.py b/samples/python/coherence.py
deleted file mode 100755
index 76d86527f3..0000000000
--- a/samples/python/coherence.py
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Coherence-enhancing filtering example
-=====================================
-
-inspired by
-  Joachim Weickert "Coherence-Enhancing Shock Filters"
-  http://www.mia.uni-saarland.de/Publications/weickert-dagm03.pdf
-'''
-
-import numpy as np
-import cv2 as cv
-
-def coherence_filter(img, sigma = 11, str_sigma = 11, blend = 0.5, iter_n = 4):
-    h, w = img.shape[:2]
-
-    for i in range(iter_n):
-        print(i)
-
-        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
-        eigen = cv.cornerEigenValsAndVecs(gray, str_sigma, 3)
-        eigen = eigen.reshape(h, w, 3, 2)  # [[e1, e2], v1, v2]
-        x, y = eigen[:,:,1,0], eigen[:,:,1,1]
-
-        gxx = cv.Sobel(gray, cv.CV_32F, 2, 0, ksize=sigma)
-        gxy = cv.Sobel(gray, cv.CV_32F, 1, 1, ksize=sigma)
-        gyy = cv.Sobel(gray, cv.CV_32F, 0, 2, ksize=sigma)
-        gvv = x*x*gxx + 2*x*y*gxy + y*y*gyy
-        m = gvv < 0
-
-        ero = cv.erode(img, None)
-        dil = cv.dilate(img, None)
-        img1 = ero
-        img1[m] = dil[m]
-        img = np.uint8(img*(1.0 - blend) + img1*blend)
-    print('done')
-    return img
-
-
-def main():
-    import sys
-    try:
-        fn = sys.argv[1]
-    except:
-        fn = 'baboon.jpg'
-
-    src = cv.imread(cv.samples.findFile(fn))
-
-    def nothing(*argv):
-        pass
-
-    def update():
-        sigma = cv.getTrackbarPos('sigma', 'control')*2+1
-        str_sigma = cv.getTrackbarPos('str_sigma', 'control')*2+1
-        blend = cv.getTrackbarPos('blend', 'control') / 10.0
-        print('sigma: %d  str_sigma: %d  blend_coef: %f' % (sigma, str_sigma, blend))
-        dst = coherence_filter(src, sigma=sigma, str_sigma = str_sigma, blend = blend)
-        cv.imshow('dst', dst)
-
-    cv.namedWindow('control', 0)
-    cv.createTrackbar('sigma', 'control', 9, 15, nothing)
-    cv.createTrackbar('blend', 'control', 7, 10, nothing)
-    cv.createTrackbar('str_sigma', 'control', 9, 15, nothing)
-
-
-    print('Press SPACE to update the image\n')
-
-    cv.imshow('src', src)
-    update()
-    while True:
-        ch = cv.waitKey()
-        if ch == ord(' '):
-            update()
-        if ch == 27:
-            break
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/color_histogram.py b/samples/python/color_histogram.py
deleted file mode 100755
index a1924bab8b..0000000000
--- a/samples/python/color_histogram.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Video histogram sample to show live histogram of video
-
-Keys:
-    ESC    - exit
-
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-# built-in modules
-import sys
-
-# local modules
-import video
-
-class App():
-
-    def set_scale(self, val):
-        self.hist_scale = val
-
-    def run(self):
-        hsv_map = np.zeros((180, 256, 3), np.uint8)
-        h, s = np.indices(hsv_map.shape[:2])
-        hsv_map[:,:,0] = h
-        hsv_map[:,:,1] = s
-        hsv_map[:,:,2] = 255
-        hsv_map = cv.cvtColor(hsv_map, cv.COLOR_HSV2BGR)
-        cv.imshow('hsv_map', hsv_map)
-
-        cv.namedWindow('hist', 0)
-        self.hist_scale = 10
-
-        cv.createTrackbar('scale', 'hist', self.hist_scale, 32, self.set_scale)
-
-        try:
-            fn = sys.argv[1]
-        except:
-            fn = 0
-        cam = video.create_capture(fn, fallback='synth:bg=baboon.jpg:class=chess:noise=0.05')
-
-        while True:
-            _flag, frame = cam.read()
-            cv.imshow('camera', frame)
-
-            small = cv.pyrDown(frame)
-
-            hsv = cv.cvtColor(small, cv.COLOR_BGR2HSV)
-            dark = hsv[...,2] < 32
-            hsv[dark] = 0
-            h = cv.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
-
-            h = np.clip(h*0.005*self.hist_scale, 0, 1)
-            vis = hsv_map*h[:,:,np.newaxis] / 255.0
-            cv.imshow('hist', vis)
-
-            ch = cv.waitKey(1)
-            if ch == 27:
-                break
-
-        print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    App().run()
-    cv.destroyAllWindows()
diff --git a/samples/python/deconvolution.py b/samples/python/deconvolution.py
deleted file mode 100755
index b276ca8cfb..0000000000
--- a/samples/python/deconvolution.py
+++ /dev/null
@@ -1,137 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Wiener deconvolution.
-
-Sample shows how DFT can be used to perform Weiner deconvolution [1]
-of an image with user-defined point spread function (PSF)
-
-Usage:
-  deconvolution.py  [--circle]
-      [--angle <degrees>]
-      [--d <diameter>]
-      [--snr <signal/noise ratio in db>]
-      [<input image>]
-
-  Use sliders to adjust PSF paramitiers.
-  Keys:
-    SPACE - switch btw linear/circular PSF
-    ESC   - exit
-
-Examples:
-  deconvolution.py --angle 135 --d 22  licenseplate_motion.jpg
-    (image source: http://www.topazlabs.com/infocus/_images/licenseplate_compare.jpg)
-
-  deconvolution.py --angle 86 --d 31  text_motion.jpg
-  deconvolution.py --circle --d 19  text_defocus.jpg
-    (image source: compact digital photo camera, no artificial distortion)
-
-
-[1] http://en.wikipedia.org/wiki/Wiener_deconvolution
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-# local module
-from common import nothing
-
-
-def blur_edge(img, d=31):
-    h, w  = img.shape[:2]
-    img_pad = cv.copyMakeBorder(img, d, d, d, d, cv.BORDER_WRAP)
-    img_blur = cv.GaussianBlur(img_pad, (2*d+1, 2*d+1), -1)[d:-d,d:-d]
-    y, x = np.indices((h, w))
-    dist = np.dstack([x, w-x-1, y, h-y-1]).min(-1)
-    w = np.minimum(np.float32(dist)/d, 1.0)
-    return img*w + img_blur*(1-w)
-
-def motion_kernel(angle, d, sz=65):
-    kern = np.ones((1, d), np.float32)
-    c, s = np.cos(angle), np.sin(angle)
-    A = np.float32([[c, -s, 0], [s, c, 0]])
-    sz2 = sz // 2
-    A[:,2] = (sz2, sz2) - np.dot(A[:,:2], ((d-1)*0.5, 0))
-    kern = cv.warpAffine(kern, A, (sz, sz), flags=cv.INTER_CUBIC)
-    return kern
-
-def defocus_kernel(d, sz=65):
-    kern = np.zeros((sz, sz), np.uint8)
-    cv.circle(kern, (sz, sz), d, 255, -1, cv.LINE_AA, shift=1)
-    kern = np.float32(kern) / 255.0
-    return kern
-
-
-def main():
-    import sys, getopt
-    opts, args = getopt.getopt(sys.argv[1:], '', ['circle', 'angle=', 'd=', 'snr='])
-    opts = dict(opts)
-    try:
-        fn = args[0]
-    except:
-        fn = 'licenseplate_motion.jpg'
-
-    win = 'deconvolution'
-
-    img = cv.imread(cv.samples.findFile(fn), cv.IMREAD_GRAYSCALE)
-    if img is None:
-        print('Failed to load file:', fn)
-        sys.exit(1)
-
-    img = np.float32(img)/255.0
-    cv.imshow('input', img)
-
-    img = blur_edge(img)
-    IMG = cv.dft(img, flags=cv.DFT_COMPLEX_OUTPUT)
-
-    defocus = '--circle' in opts
-
-    def update(_):
-        ang = np.deg2rad( cv.getTrackbarPos('angle', win) )
-        d = cv.getTrackbarPos('d', win)
-        noise = 10**(-0.1*cv.getTrackbarPos('SNR (db)', win))
-
-        if defocus:
-            psf = defocus_kernel(d)
-        else:
-            psf = motion_kernel(ang, d)
-        cv.imshow('psf', psf)
-
-        psf /= psf.sum()
-        psf_pad = np.zeros_like(img)
-        kh, kw = psf.shape
-        psf_pad[:kh, :kw] = psf
-        PSF = cv.dft(psf_pad, flags=cv.DFT_COMPLEX_OUTPUT, nonzeroRows = kh)
-        PSF2 = (PSF**2).sum(-1)
-        iPSF = PSF / (PSF2 + noise)[...,np.newaxis]
-        RES = cv.mulSpectrums(IMG, iPSF, 0)
-        res = cv.idft(RES, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT )
-        res = np.roll(res, -kh//2, 0)
-        res = np.roll(res, -kw//2, 1)
-        cv.imshow(win, res)
-
-    cv.namedWindow(win)
-    cv.namedWindow('psf', 0)
-    cv.createTrackbar('angle', win, int(opts.get('--angle', 135)), 180, update)
-    cv.createTrackbar('d', win, int(opts.get('--d', 22)), 50, update)
-    cv.createTrackbar('SNR (db)', win, int(opts.get('--snr', 25)), 50, update)
-    update(None)
-
-    while True:
-        ch = cv.waitKey()
-        if ch == 27:
-            break
-        if ch == ord(' '):
-            defocus = not defocus
-            update(None)
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/edge.py b/samples/python/edge.py
deleted file mode 100755
index e85c2f6288..0000000000
--- a/samples/python/edge.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-
-'''
-This sample demonstrates Canny edge detection.
-
-Usage:
-  edge.py [<video source>]
-
-  Trackbars control edge thresholds.
-
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import cv2 as cv
-import numpy as np
-
-# relative module
-import video
-
-# built-in module
-import sys
-
-
-def main():
-    try:
-        fn = sys.argv[1]
-    except:
-        fn = 0
-
-    def nothing(*arg):
-        pass
-
-    cv.namedWindow('edge')
-    cv.createTrackbar('thrs1', 'edge', 2000, 5000, nothing)
-    cv.createTrackbar('thrs2', 'edge', 4000, 5000, nothing)
-
-    cap = video.create_capture(fn)
-    while True:
-        _flag, img = cap.read()
-        gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
-        thrs1 = cv.getTrackbarPos('thrs1', 'edge')
-        thrs2 = cv.getTrackbarPos('thrs2', 'edge')
-        edge = cv.Canny(gray, thrs1, thrs2, apertureSize=5)
-        vis = img.copy()
-        vis = np.uint8(vis/2.)
-        vis[edge != 0] = (0, 255, 0)
-        cv.imshow('edge', vis)
-        ch = cv.waitKey(5)
-        if ch == 27:
-            break
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/feature_homography.py b/samples/python/feature_homography.py
deleted file mode 100755
index 80537e0367..0000000000
--- a/samples/python/feature_homography.py
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Feature homography
-==================
-
-Example of using features2d framework for interactive video homography matching.
-ORB features and FLANN matcher are used. The actual tracking is implemented by
-PlaneTracker class in plane_tracker.py
-
-Inspired by http://www.youtube.com/watch?v=-ZNYoL8rzPY
-
-video: http://www.youtube.com/watch?v=FirtmYcC0Vc
-
-Usage
------
-feature_homography.py [<video source>]
-
-Keys:
-   SPACE  -  pause video
-
-Select a textured planar object to track by drawing a box with a mouse.
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-# local modules
-import video
-from video import presets
-import common
-from common import getsize, draw_keypoints
-from plane_tracker import PlaneTracker
-
-
-class App:
-    def __init__(self, src):
-        self.cap = video.create_capture(src, presets['book'])
-        self.frame = None
-        self.paused = False
-        self.tracker = PlaneTracker()
-
-        cv.namedWindow('plane')
-        self.rect_sel = common.RectSelector('plane', self.on_rect)
-
-    def on_rect(self, rect):
-        self.tracker.clear()
-        self.tracker.add_target(self.frame, rect)
-
-    def run(self):
-        while True:
-            playing = not self.paused and not self.rect_sel.dragging
-            if playing or self.frame is None:
-                ret, frame = self.cap.read()
-                if not ret:
-                    break
-                self.frame = frame.copy()
-
-            w, h = getsize(self.frame)
-            vis = np.zeros((h, w*2, 3), np.uint8)
-            vis[:h,:w] = self.frame
-            if len(self.tracker.targets) > 0:
-                target = self.tracker.targets[0]
-                vis[:,w:] = target.image
-                draw_keypoints(vis[:,w:], target.keypoints)
-                x0, y0, x1, y1 = target.rect
-                cv.rectangle(vis, (x0+w, y0), (x1+w, y1), (0, 255, 0), 2)
-
-            if playing:
-                tracked = self.tracker.track(self.frame)
-                if len(tracked) > 0:
-                    tracked = tracked[0]
-                    cv.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2)
-                    for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)):
-                        cv.line(vis, (x0+w, y0), (x1, y1), (0, 255, 0))
-            draw_keypoints(vis, self.tracker.frame_points)
-
-            self.rect_sel.draw(vis)
-            cv.imshow('plane', vis)
-            ch = cv.waitKey(1)
-            if ch == ord(' '):
-                self.paused = not self.paused
-            if ch == 27:
-                break
-
-
-if __name__ == '__main__':
-    print(__doc__)
-
-    import sys
-    try:
-        video_src = sys.argv[1]
-    except:
-        video_src = 0
-    App(video_src).run()
diff --git a/samples/python/find_obj.py b/samples/python/find_obj.py
deleted file mode 100755
index c5783bf456..0000000000
--- a/samples/python/find_obj.py
+++ /dev/null
@@ -1,197 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Feature-based image matching sample.
-
-Note, that you will need the https://github.com/opencv/opencv_contrib repo for SIFT and SURF
-
-USAGE
-  find_obj.py [--feature=<sift|surf|orb|akaze|brisk>[-flann]] [ <image1> <image2> ]
-
-  --feature  - Feature to use. Can be sift, surf, orb or brisk. Append '-flann'
-               to feature name to use Flann-based matcher instead bruteforce.
-
-  Press left mouse button on a feature point to see its matching point.
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-from common import anorm, getsize
-
-FLANN_INDEX_KDTREE = 1  # bug: flann enums are missing
-FLANN_INDEX_LSH    = 6
-
-
-def init_feature(name):
-    chunks = name.split('-')
-    if chunks[0] == 'sift':
-        detector = cv.SIFT_create()
-        norm = cv.NORM_L2
-    elif chunks[0] == 'surf':
-        detector = cv.xfeatures2d.SURF_create(800)
-        norm = cv.NORM_L2
-    elif chunks[0] == 'orb':
-        detector = cv.ORB_create(400)
-        norm = cv.NORM_HAMMING
-    elif chunks[0] == 'akaze':
-        detector = cv.AKAZE_create()
-        norm = cv.NORM_HAMMING
-    elif chunks[0] == 'brisk':
-        detector = cv.BRISK_create()
-        norm = cv.NORM_HAMMING
-    else:
-        return None, None
-    if 'flann' in chunks:
-        if norm == cv.NORM_L2:
-            flann_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
-        else:
-            flann_params= dict(algorithm = FLANN_INDEX_LSH,
-                               table_number = 6, # 12
-                               key_size = 12,     # 20
-                               multi_probe_level = 1) #2
-        matcher = cv.FlannBasedMatcher(flann_params, {})  # bug : need to pass empty dict (#1329)
-    else:
-        matcher = cv.BFMatcher(norm)
-    return detector, matcher
-
-
-def filter_matches(kp1, kp2, matches, ratio = 0.75):
-    mkp1, mkp2 = [], []
-    for m in matches:
-        if len(m) == 2 and m[0].distance < m[1].distance * ratio:
-            m = m[0]
-            mkp1.append( kp1[m.queryIdx] )
-            mkp2.append( kp2[m.trainIdx] )
-    p1 = np.float32([kp.pt for kp in mkp1])
-    p2 = np.float32([kp.pt for kp in mkp2])
-    kp_pairs = zip(mkp1, mkp2)
-    return p1, p2, list(kp_pairs)
-
-def explore_match(win, img1, img2, kp_pairs, status = None, H = None):
-    h1, w1 = img1.shape[:2]
-    h2, w2 = img2.shape[:2]
-    vis = np.zeros((max(h1, h2), w1+w2), np.uint8)
-    vis[:h1, :w1] = img1
-    vis[:h2, w1:w1+w2] = img2
-    vis = cv.cvtColor(vis, cv.COLOR_GRAY2BGR)
-
-    if H is not None:
-        corners = np.float32([[0, 0], [w1, 0], [w1, h1], [0, h1]])
-        corners = np.int32( cv.perspectiveTransform(corners.reshape(1, -1, 2), H).reshape(-1, 2) + (w1, 0) )
-        cv.polylines(vis, [corners], True, (255, 255, 255))
-
-    if status is None:
-        status = np.ones(len(kp_pairs), np.bool_)
-        status = status.reshape((len(kp_pairs), 1))
-    p1, p2 = [], []  # python 2 / python 3 change of zip unpacking
-    for kpp in kp_pairs:
-        p1.append(np.int32(kpp[0].pt))
-        p2.append(np.int32(np.array(kpp[1].pt) + [w1, 0]))
-
-    green = (0, 255, 0)
-    red = (0, 0, 255)
-    kp_color = (51, 103, 236)
-    for (x1, y1), (x2, y2), inlier in zip(p1, p2, status):
-        if inlier:
-            col = green
-            cv.circle(vis, (x1, y1), 2, col, -1)
-            cv.circle(vis, (x2, y2), 2, col, -1)
-        else:
-            col = red
-            r = 2
-            thickness = 3
-            cv.line(vis, (x1-r, y1-r), (x1+r, y1+r), col, thickness)
-            cv.line(vis, (x1-r, y1+r), (x1+r, y1-r), col, thickness)
-            cv.line(vis, (x2-r, y2-r), (x2+r, y2+r), col, thickness)
-            cv.line(vis, (x2-r, y2+r), (x2+r, y2-r), col, thickness)
-    vis0 = vis.copy()
-    for (x1, y1), (x2, y2), inlier in zip(p1, p2, status):
-        if inlier:
-            cv.line(vis, (x1, y1), (x2, y2), green)
-
-    cv.imshow(win, vis)
-
-    def onmouse(event, x, y, flags, param):
-        cur_vis = vis
-        if flags & cv.EVENT_FLAG_LBUTTON:
-            cur_vis = vis0.copy()
-            r = 8
-            m = (anorm(np.array(p1) - (x, y)) < r) | (anorm(np.array(p2) - (x, y)) < r)
-            idxs = np.where(m)[0]
-
-            kp1s, kp2s = [], []
-            for i in idxs:
-                (x1, y1), (x2, y2) = p1[i], p2[i]
-                col = (red, green)[status[i][0]]
-                cv.line(cur_vis, (x1, y1), (x2, y2), col)
-                kp1, kp2 = kp_pairs[i]
-                kp1s.append(kp1)
-                kp2s.append(kp2)
-            cur_vis = cv.drawKeypoints(cur_vis, kp1s, None, flags=4, color=kp_color)
-            cur_vis[:,w1:] = cv.drawKeypoints(cur_vis[:,w1:], kp2s, None, flags=4, color=kp_color)
-
-        cv.imshow(win, cur_vis)
-    cv.setMouseCallback(win, onmouse)
-    return vis
-
-
-def main():
-    import sys, getopt
-    opts, args = getopt.getopt(sys.argv[1:], '', ['feature='])
-    opts = dict(opts)
-    feature_name = opts.get('--feature', 'brisk')
-    try:
-        fn1, fn2 = args
-    except:
-        fn1 = 'box.png'
-        fn2 = 'box_in_scene.png'
-
-    img1 = cv.imread(cv.samples.findFile(fn1), cv.IMREAD_GRAYSCALE)
-    img2 = cv.imread(cv.samples.findFile(fn2), cv.IMREAD_GRAYSCALE)
-    detector, matcher = init_feature(feature_name)
-
-    if img1 is None:
-        print('Failed to load fn1:', fn1)
-        sys.exit(1)
-
-    if img2 is None:
-        print('Failed to load fn2:', fn2)
-        sys.exit(1)
-
-    if detector is None:
-        print('unknown feature:', feature_name)
-        sys.exit(1)
-
-    print('using', feature_name)
-
-    kp1, desc1 = detector.detectAndCompute(img1, None)
-    kp2, desc2 = detector.detectAndCompute(img2, None)
-    print('img1 - %d features, img2 - %d features' % (len(kp1), len(kp2)))
-
-    def match_and_draw(win):
-        print('matching...')
-        raw_matches = matcher.knnMatch(desc1, trainDescriptors = desc2, k = 2) #2
-        p1, p2, kp_pairs = filter_matches(kp1, kp2, raw_matches)
-        if len(p1) >= 4:
-            H, status = cv.findHomography(p1, p2, cv.RANSAC, 5.0)
-            print('%d / %d  inliers/matched' % (np.sum(status), len(status)))
-        else:
-            H, status = None, None
-            print('%d matches found, not enough for homography estimation' % len(p1))
-
-        _vis = explore_match(win, img1, img2, kp_pairs, status, H)
-
-    match_and_draw('find_obj')
-    cv.waitKey()
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/gabor_threads.py b/samples/python/gabor_threads.py
deleted file mode 100755
index dd14e6bf43..0000000000
--- a/samples/python/gabor_threads.py
+++ /dev/null
@@ -1,82 +0,0 @@
-#!/usr/bin/env python
-
-'''
-gabor_threads.py
-=========
-
-Sample demonstrates:
-- use of multiple Gabor filter convolutions to get Fractalius-like image effect (http://www.redfieldplugins.com/filterFractalius.htm)
-- use of python threading to accelerate the computation
-
-Usage
------
-gabor_threads.py [image filename]
-
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-from multiprocessing.pool import ThreadPool
-
-
-def build_filters():
-    filters = []
-    ksize = 31
-    for theta in np.arange(0, np.pi, np.pi / 16):
-        kern = cv.getGaborKernel((ksize, ksize), 4.0, theta, 10.0, 0.5, 0, ktype=cv.CV_32F)
-        kern /= 1.5*kern.sum()
-        filters.append(kern)
-    return filters
-
-def process(img, filters):
-    accum = np.zeros_like(img)
-    for kern in filters:
-        fimg = cv.filter2D(img, cv.CV_8UC3, kern)
-        np.maximum(accum, fimg, accum)
-    return accum
-
-def process_threaded(img, filters, threadn = 8):
-    accum = np.zeros_like(img)
-    def f(kern):
-        return cv.filter2D(img, cv.CV_8UC3, kern)
-    pool = ThreadPool(processes=threadn)
-    for fimg in pool.imap_unordered(f, filters):
-        np.maximum(accum, fimg, accum)
-    return accum
-
-def main():
-    import sys
-    from common import Timer
-
-    try:
-        img_fn = sys.argv[1]
-    except:
-        img_fn = 'baboon.jpg'
-
-    img = cv.imread(cv.samples.findFile(img_fn))
-    if img is None:
-        print('Failed to load image file:', img_fn)
-        sys.exit(1)
-
-    filters = build_filters()
-
-    with Timer('running single-threaded'):
-        res1 = process(img, filters)
-    with Timer('running multi-threaded'):
-        res2 = process_threaded(img, filters)
-
-    print('res1 == res2: ', (res1 == res2).all())
-    cv.imshow('img', img)
-    cv.imshow('result', res2)
-    cv.waitKey()
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/hist.py b/samples/python/hist.py
deleted file mode 100755
index 8c1f4546a8..0000000000
--- a/samples/python/hist.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/usr/bin/env python
-
-''' This is a sample for histogram plotting for RGB images and grayscale images for better understanding of colour distribution
-
-Benefit : Learn how to draw histogram of images
-          Get familier with cv.calcHist, cv.equalizeHist,cv.normalize and some drawing functions
-
-Level : Beginner or Intermediate
-
-Functions : 1) hist_curve : returns histogram of an image drawn as curves
-            2) hist_lines : return histogram of an image drawn as bins ( only for grayscale images )
-
-Usage : python hist.py <image_file>
-
-Abid Rahman 3/14/12 debug Gary Bradski
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-bins = np.arange(256).reshape(256,1)
-
-def hist_curve(im):
-    h = np.zeros((300,256,3))
-    if len(im.shape) == 2:
-        color = [(255,255,255)]
-    elif im.shape[2] == 3:
-        color = [ (255,0,0),(0,255,0),(0,0,255) ]
-    for ch, col in enumerate(color):
-        hist_item = cv.calcHist([im],[ch],None,[256],[0,256])
-        cv.normalize(hist_item,hist_item,0,255,cv.NORM_MINMAX)
-        hist=np.int32(np.around(hist_item))
-        pts = np.int32(np.column_stack((bins,hist)))
-        cv.polylines(h,[pts],False,col)
-    y=np.flipud(h)
-    return y
-
-def hist_lines(im):
-    h = np.zeros((300,256,3))
-    if len(im.shape)!=2:
-        print("hist_lines applicable only for grayscale images")
-        #print("so converting image to grayscale for representation"
-        im = cv.cvtColor(im,cv.COLOR_BGR2GRAY)
-    hist_item = cv.calcHist([im],[0],None,[256],[0,256])
-    cv.normalize(hist_item,hist_item,0,255,cv.NORM_MINMAX)
-    hist = np.int32(np.around(hist_item))
-    for x,y in enumerate(hist):
-        cv.line(h,(x,0),(x,y[0]),(255,255,255))
-    y = np.flipud(h)
-    return y
-
-
-def main():
-    import sys
-
-    if len(sys.argv)>1:
-        fname = sys.argv[1]
-    else :
-        fname = 'lena.jpg'
-        print("usage : python hist.py <image_file>")
-
-    im = cv.imread(cv.samples.findFile(fname))
-
-    if im is None:
-        print('Failed to load image file:', fname)
-        sys.exit(1)
-
-    gray = cv.cvtColor(im,cv.COLOR_BGR2GRAY)
-
-
-    print(''' Histogram plotting \n
-    Keymap :\n
-    a - show histogram for color image in curve mode \n
-    b - show histogram in bin mode \n
-    c - show equalized histogram (always in bin mode) \n
-    d - show histogram for gray image in curve mode \n
-    e - show histogram for a normalized image in curve mode \n
-    Esc - exit \n
-    ''')
-
-    cv.imshow('image',im)
-    while True:
-        k = cv.waitKey(0)
-        if k == ord('a'):
-            curve = hist_curve(im)
-            cv.imshow('histogram',curve)
-            cv.imshow('image',im)
-            print('a')
-        elif k == ord('b'):
-            print('b')
-            lines = hist_lines(im)
-            cv.imshow('histogram',lines)
-            cv.imshow('image',gray)
-        elif k == ord('c'):
-            print('c')
-            equ = cv.equalizeHist(gray)
-            lines = hist_lines(equ)
-            cv.imshow('histogram',lines)
-            cv.imshow('image',equ)
-        elif k == ord('d'):
-            print('d')
-            curve = hist_curve(gray)
-            cv.imshow('histogram',curve)
-            cv.imshow('image',gray)
-        elif k == ord('e'):
-            print('e')
-            norm = cv.normalize(gray, gray, alpha = 0,beta = 255,norm_type = cv.NORM_MINMAX)
-            lines = hist_lines(norm)
-            cv.imshow('histogram',lines)
-            cv.imshow('image',norm)
-        elif k == 27:
-            print('ESC')
-            cv.destroyAllWindows()
-            break
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/inpaint.py b/samples/python/inpaint.py
deleted file mode 100755
index 53f8e9886f..0000000000
--- a/samples/python/inpaint.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Inpainting sample.
-
-Inpainting repairs damage to images by floodfilling
-the damage with surrounding image areas.
-
-Usage:
-  inpaint.py [<image>]
-
-Keys:
-  SPACE - inpaint
-  r     - reset the inpainting mask
-  ESC   - exit
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-from common import Sketcher
-
-def main():
-    import sys
-    try:
-        fn = sys.argv[1]
-    except:
-        fn = 'fruits.jpg'
-
-    img = cv.imread(cv.samples.findFile(fn))
-    if img is None:
-        print('Failed to load image file:', fn)
-        sys.exit(1)
-
-    img_mark = img.copy()
-    mark = np.zeros(img.shape[:2], np.uint8)
-    sketch = Sketcher('img', [img_mark, mark], lambda : ((255, 255, 255), 255))
-
-    while True:
-        ch = cv.waitKey()
-        if ch == 27:
-            break
-        if ch == ord(' '):
-            res = cv.inpaint(img_mark, mark, 3, cv.INPAINT_TELEA)
-            cv.imshow('inpaint', res)
-        if ch == ord('r'):
-            img_mark[:] = img
-            mark[:] = 0
-            sketch.show()
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/lk_homography.py b/samples/python/lk_homography.py
deleted file mode 100755
index 38a05f63b6..0000000000
--- a/samples/python/lk_homography.py
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Lucas-Kanade homography tracker
-===============================
-
-Lucas-Kanade sparse optical flow demo. Uses goodFeaturesToTrack
-for track initialization and back-tracking for match verification
-between frames. Finds homography between reference and current views.
-
-Usage
------
-lk_homography.py [<video_source>]
-
-
-Keys
-----
-ESC   - exit
-SPACE - start tracking
-r     - toggle RANSAC
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-import video
-from common import draw_str
-from video import presets
-
-lk_params = dict( winSize  = (19, 19),
-                  maxLevel = 2,
-                  criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03))
-
-feature_params = dict( maxCorners = 1000,
-                       qualityLevel = 0.01,
-                       minDistance = 8,
-                       blockSize = 19 )
-
-def checkedTrace(img0, img1, p0, back_threshold = 1.0):
-    p1, _st, _err = cv.calcOpticalFlowPyrLK(img0, img1, p0, None, **lk_params)
-    p0r, _st, _err = cv.calcOpticalFlowPyrLK(img1, img0, p1, None, **lk_params)
-    d = abs(p0-p0r).reshape(-1, 2).max(-1)
-    status = d < back_threshold
-    return p1, status
-
-green = (0, 255, 0)
-red = (0, 0, 255)
-
-class App:
-    def __init__(self, video_src):
-        self.cam = self.cam = video.create_capture(video_src, presets['book'])
-        self.p0 = None
-        self.use_ransac = True
-
-    def run(self):
-        while True:
-            _ret, frame = self.cam.read()
-            frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
-            vis = frame.copy()
-            if self.p0 is not None:
-                p2, trace_status = checkedTrace(self.gray1, frame_gray, self.p1)
-
-                self.p1 = p2[trace_status].copy()
-                self.p0 = self.p0[trace_status].copy()
-                self.gray1 = frame_gray
-
-                if len(self.p0) < 4:
-                    self.p0 = None
-                    continue
-                H, status = cv.findHomography(self.p0, self.p1, (0, cv.RANSAC)[self.use_ransac], 10.0)
-                h, w = frame.shape[:2]
-                overlay = cv.warpPerspective(self.frame0, H, (w, h))
-                vis = cv.addWeighted(vis, 0.5, overlay, 0.5, 0.0)
-
-                for (x0, y0), (x1, y1), good in zip(self.p0[:,0], self.p1[:,0], status[:,0]):
-                    if good:
-                        cv.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (0, 128, 0))
-                    cv.circle(vis, (int(x1), int(y1)), 2, (red, green)[good], -1)
-                draw_str(vis, (20, 20), 'track count: %d' % len(self.p1))
-                if self.use_ransac:
-                    draw_str(vis, (20, 40), 'RANSAC')
-            else:
-                p = cv.goodFeaturesToTrack(frame_gray, **feature_params)
-                if p is not None:
-                    for x, y in p[:,0]:
-                        cv.circle(vis, (int(x), int(y)), 2, green, -1)
-                    draw_str(vis, (20, 20), 'feature count: %d' % len(p))
-
-            cv.imshow('lk_homography', vis)
-
-            ch = cv.waitKey(1)
-            if ch == 27:
-                break
-            if ch == ord(' '):
-                self.frame0 = frame.copy()
-                self.p0 = cv.goodFeaturesToTrack(frame_gray, **feature_params)
-                if self.p0 is not None:
-                    self.p1 = self.p0
-                    self.gray0 = frame_gray
-                    self.gray1 = frame_gray
-            if ch == ord('r'):
-                self.use_ransac = not self.use_ransac
-
-
-
-def main():
-    import sys
-    try:
-        video_src = sys.argv[1]
-    except:
-        video_src = 0
-
-    App(video_src).run()
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/mosse.py b/samples/python/mosse.py
deleted file mode 100755
index e6027b2745..0000000000
--- a/samples/python/mosse.py
+++ /dev/null
@@ -1,190 +0,0 @@
-#!/usr/bin/env python
-
-'''
-MOSSE tracking sample
-
-This sample implements correlation-based tracking approach, described in [1].
-
-Usage:
-  mosse.py [--pause] [<video source>]
-
-  --pause  -  Start with playback paused at the first video frame.
-              Useful for tracking target selection.
-
-  Draw rectangles around objects with a mouse to track them.
-
-Keys:
-  SPACE    - pause video
-  c        - clear targets
-
-[1] David S. Bolme et al. "Visual Object Tracking using Adaptive Correlation Filters"
-    http://www.cs.colostate.edu/~draper/papers/bolme_cvpr10.pdf
-'''
-
-import numpy as np
-import cv2 as cv
-from common import draw_str, RectSelector
-import video
-
-def rnd_warp(a):
-    h, w = a.shape[:2]
-    T = np.zeros((2, 3))
-    coef = 0.2
-    ang = (np.random.rand()-0.5)*coef
-    c, s = np.cos(ang), np.sin(ang)
-    T[:2, :2] = [[c,-s], [s, c]]
-    T[:2, :2] += (np.random.rand(2, 2) - 0.5)*coef
-    c = (w/2, h/2)
-    T[:,2] = c - np.dot(T[:2, :2], c)
-    return cv.warpAffine(a, T, (w, h), borderMode = cv.BORDER_REFLECT)
-
-def divSpec(A, B):
-    Ar, Ai = A[...,0], A[...,1]
-    Br, Bi = B[...,0], B[...,1]
-    C = (Ar+1j*Ai)/(Br+1j*Bi)
-    C = np.dstack([np.real(C), np.imag(C)]).copy()
-    return C
-
-eps = 1e-5
-
-class MOSSE:
-    def __init__(self, frame, rect):
-        x1, y1, x2, y2 = rect
-        w, h = map(cv.getOptimalDFTSize, [x2-x1, y2-y1])
-        x1, y1 = (x1+x2-w)//2, (y1+y2-h)//2
-        self.pos = x, y = x1+0.5*(w-1), y1+0.5*(h-1)
-        self.size = w, h
-        img = cv.getRectSubPix(frame, (w, h), (x, y))
-
-        self.win = cv.createHanningWindow((w, h), cv.CV_32F)
-        g = np.zeros((h, w), np.float32)
-        g[h//2, w//2] = 1
-        g = cv.GaussianBlur(g, (-1, -1), 2.0)
-        g /= g.max()
-
-        self.G = cv.dft(g, flags=cv.DFT_COMPLEX_OUTPUT)
-        self.H1 = np.zeros_like(self.G)
-        self.H2 = np.zeros_like(self.G)
-        for _i in range(128):
-            a = self.preprocess(rnd_warp(img))
-            A = cv.dft(a, flags=cv.DFT_COMPLEX_OUTPUT)
-            self.H1 += cv.mulSpectrums(self.G, A, 0, conjB=True)
-            self.H2 += cv.mulSpectrums(     A, A, 0, conjB=True)
-        self.update_kernel()
-        self.update(frame)
-
-    def update(self, frame, rate = 0.125):
-        (x, y), (w, h) = self.pos, self.size
-        self.last_img = img = cv.getRectSubPix(frame, (w, h), (x, y))
-        img = self.preprocess(img)
-        self.last_resp, (dx, dy), self.psr = self.correlate(img)
-        self.good = self.psr > 8.0
-        if not self.good:
-            return
-
-        self.pos = x+dx, y+dy
-        self.last_img = img = cv.getRectSubPix(frame, (w, h), self.pos)
-        img = self.preprocess(img)
-
-        A = cv.dft(img, flags=cv.DFT_COMPLEX_OUTPUT)
-        H1 = cv.mulSpectrums(self.G, A, 0, conjB=True)
-        H2 = cv.mulSpectrums(     A, A, 0, conjB=True)
-        self.H1 = self.H1 * (1.0-rate) + H1 * rate
-        self.H2 = self.H2 * (1.0-rate) + H2 * rate
-        self.update_kernel()
-
-    @property
-    def state_vis(self):
-        f = cv.idft(self.H, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT )
-        h, w = f.shape
-        f = np.roll(f, -h//2, 0)
-        f = np.roll(f, -w//2, 1)
-        kernel = np.uint8( (f-f.min()) / f.ptp()*255 )
-        resp = self.last_resp
-        resp = np.uint8(np.clip(resp/resp.max(), 0, 1)*255)
-        vis = np.hstack([self.last_img, kernel, resp])
-        return vis
-
-    def draw_state(self, vis):
-        (x, y), (w, h) = self.pos, self.size
-        x1, y1, x2, y2 = int(x-0.5*w), int(y-0.5*h), int(x+0.5*w), int(y+0.5*h)
-        cv.rectangle(vis, (x1, y1), (x2, y2), (0, 0, 255))
-        if self.good:
-            cv.circle(vis, (int(x), int(y)), 2, (0, 0, 255), -1)
-        else:
-            cv.line(vis, (x1, y1), (x2, y2), (0, 0, 255))
-            cv.line(vis, (x2, y1), (x1, y2), (0, 0, 255))
-        draw_str(vis, (x1, y2+16), 'PSR: %.2f' % self.psr)
-
-    def preprocess(self, img):
-        img = np.log(np.float32(img)+1.0)
-        img = (img-img.mean()) / (img.std()+eps)
-        return img*self.win
-
-    def correlate(self, img):
-        C = cv.mulSpectrums(cv.dft(img, flags=cv.DFT_COMPLEX_OUTPUT), self.H, 0, conjB=True)
-        resp = cv.idft(C, flags=cv.DFT_SCALE | cv.DFT_REAL_OUTPUT)
-        h, w = resp.shape
-        _, mval, _, (mx, my) = cv.minMaxLoc(resp)
-        side_resp = resp.copy()
-        cv.rectangle(side_resp, (mx-5, my-5), (mx+5, my+5), 0, -1)
-        smean, sstd = side_resp.mean(), side_resp.std()
-        psr = (mval-smean) / (sstd+eps)
-        return resp, (mx-w//2, my-h//2), psr
-
-    def update_kernel(self):
-        self.H = divSpec(self.H1, self.H2)
-        self.H[...,1] *= -1
-
-class App:
-    def __init__(self, video_src, paused = False):
-        self.cap = video.create_capture(video_src)
-        _, self.frame = self.cap.read()
-        cv.imshow('frame', self.frame)
-        self.rect_sel = RectSelector('frame', self.onrect)
-        self.trackers = []
-        self.paused = paused
-
-    def onrect(self, rect):
-        frame_gray = cv.cvtColor(self.frame, cv.COLOR_BGR2GRAY)
-        tracker = MOSSE(frame_gray, rect)
-        self.trackers.append(tracker)
-
-    def run(self):
-        while True:
-            if not self.paused:
-                ret, self.frame = self.cap.read()
-                if not ret:
-                    break
-                frame_gray = cv.cvtColor(self.frame, cv.COLOR_BGR2GRAY)
-                for tracker in self.trackers:
-                    tracker.update(frame_gray)
-
-            vis = self.frame.copy()
-            for tracker in self.trackers:
-                tracker.draw_state(vis)
-            if len(self.trackers) > 0:
-                cv.imshow('tracker state', self.trackers[-1].state_vis)
-            self.rect_sel.draw(vis)
-
-            cv.imshow('frame', vis)
-            ch = cv.waitKey(10)
-            if ch == 27:
-                break
-            if ch == ord(' '):
-                self.paused = not self.paused
-            if ch == ord('c'):
-                self.trackers = []
-
-
-if __name__ == '__main__':
-    print (__doc__)
-    import sys, getopt
-    opts, args = getopt.getopt(sys.argv[1:], '', ['pause'])
-    opts = dict(opts)
-    try:
-        video_src = args[0]
-    except:
-        video_src = '0'
-
-    App(video_src, paused = '--pause' in opts).run()
diff --git a/samples/python/plane_ar.py b/samples/python/plane_ar.py
deleted file mode 100755
index 934550c0f5..0000000000
--- a/samples/python/plane_ar.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Planar augmented reality
-==================
-
-This sample shows an example of augmented reality overlay over a planar object
-tracked by PlaneTracker from plane_tracker.py. solvePnP function is used to
-estimate the tracked object location in 3d space.
-
-video: http://www.youtube.com/watch?v=pzVbhxx6aog
-
-Usage
------
-plane_ar.py [<video source>]
-
-Keys:
-   SPACE  -  pause video
-   c      -  clear targets
-
-Select a textured planar object to track by drawing a box with a mouse.
-Use 'focal' slider to adjust to camera focal length for proper video augmentation.
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-import video
-import common
-from plane_tracker import PlaneTracker
-from video import presets
-
-# Simple model of a house - cube with a triangular prism "roof"
-ar_verts = np.float32([[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0],
-                       [0, 0, 1], [0, 1, 1], [1, 1, 1], [1, 0, 1],
-                       [0, 0.5, 2], [1, 0.5, 2]])
-ar_edges = [(0, 1), (1, 2), (2, 3), (3, 0),
-            (4, 5), (5, 6), (6, 7), (7, 4),
-            (0, 4), (1, 5), (2, 6), (3, 7),
-            (4, 8), (5, 8), (6, 9), (7, 9), (8, 9)]
-
-class App:
-    def __init__(self, src):
-        self.cap = video.create_capture(src, presets['book'])
-        self.frame = None
-        self.paused = False
-        self.tracker = PlaneTracker()
-
-        cv.namedWindow('plane')
-        cv.createTrackbar('focal', 'plane', 25, 50, common.nothing)
-        self.rect_sel = common.RectSelector('plane', self.on_rect)
-
-    def on_rect(self, rect):
-        self.tracker.add_target(self.frame, rect)
-
-    def run(self):
-        while True:
-            playing = not self.paused and not self.rect_sel.dragging
-            if playing or self.frame is None:
-                ret, frame = self.cap.read()
-                if not ret:
-                    break
-                self.frame = frame.copy()
-
-            vis = self.frame.copy()
-            if playing:
-                tracked = self.tracker.track(self.frame)
-                for tr in tracked:
-                    cv.polylines(vis, [np.int32(tr.quad)], True, (255, 255, 255), 2)
-                    for (x, y) in np.int32(tr.p1):
-                        cv.circle(vis, (x, y), 2, (255, 255, 255))
-                    self.draw_overlay(vis, tr)
-
-            self.rect_sel.draw(vis)
-            cv.imshow('plane', vis)
-            ch = cv.waitKey(1)
-            if ch == ord(' '):
-                self.paused = not self.paused
-            if ch == ord('c'):
-                self.tracker.clear()
-            if ch == 27:
-                break
-
-    def draw_overlay(self, vis, tracked):
-        x0, y0, x1, y1 = tracked.target.rect
-        quad_3d = np.float32([[x0, y0, 0], [x1, y0, 0], [x1, y1, 0], [x0, y1, 0]])
-        fx = 0.5 + cv.getTrackbarPos('focal', 'plane') / 50.0
-        h, w = vis.shape[:2]
-        K = np.float64([[fx*w, 0, 0.5*(w-1)],
-                        [0, fx*w, 0.5*(h-1)],
-                        [0.0,0.0,      1.0]])
-        dist_coef = np.zeros(4)
-        _ret, rvec, tvec = cv.solvePnP(quad_3d, tracked.quad, K, dist_coef)
-        verts = ar_verts * [(x1-x0), (y1-y0), -(x1-x0)*0.3] + (x0, y0, 0)
-        verts = cv.projectPoints(verts, rvec, tvec, K, dist_coef)[0].reshape(-1, 2)
-        for i, j in ar_edges:
-            (x0, y0), (x1, y1) = verts[i], verts[j]
-            cv.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (255, 255, 0), 2)
-
-
-if __name__ == '__main__':
-    print(__doc__)
-
-    import sys
-    try:
-        video_src = sys.argv[1]
-    except:
-        video_src = 0
-    App(video_src).run()
diff --git a/samples/python/camshift.py b/samples/python/snippets/camshift.py
similarity index 100%
rename from samples/python/camshift.py
rename to samples/python/snippets/camshift.py
diff --git a/samples/python/contours.py b/samples/python/snippets/contours.py
similarity index 100%
rename from samples/python/contours.py
rename to samples/python/snippets/contours.py
diff --git a/samples/python/dft.py b/samples/python/snippets/dft.py
similarity index 98%
rename from samples/python/dft.py
rename to samples/python/snippets/dft.py
index 98bc87dc24..d103af7b45 100755
--- a/samples/python/dft.py
+++ b/samples/python/snippets/dft.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 '''
-sample for disctrete fourier transform (dft)
+sample for discrete fourier transform (dft)
 
 USAGE:
     dft.py <image_file>
diff --git a/samples/python/dis_opt_flow.py b/samples/python/snippets/dis_opt_flow.py
similarity index 100%
rename from samples/python/dis_opt_flow.py
rename to samples/python/snippets/dis_opt_flow.py
diff --git a/samples/python/distrans.py b/samples/python/snippets/distrans.py
similarity index 100%
rename from samples/python/distrans.py
rename to samples/python/snippets/distrans.py
diff --git a/samples/python/fitline.py b/samples/python/snippets/fitline.py
similarity index 100%
rename from samples/python/fitline.py
rename to samples/python/snippets/fitline.py
diff --git a/samples/python/houghcircles.py b/samples/python/snippets/houghcircles.py
similarity index 100%
rename from samples/python/houghcircles.py
rename to samples/python/snippets/houghcircles.py
diff --git a/samples/python/houghlines.py b/samples/python/snippets/houghlines.py
similarity index 100%
rename from samples/python/houghlines.py
rename to samples/python/snippets/houghlines.py
diff --git a/samples/python/kalman.py b/samples/python/snippets/kalman.py
similarity index 100%
rename from samples/python/kalman.py
rename to samples/python/snippets/kalman.py
diff --git a/samples/python/kmeans.py b/samples/python/snippets/kmeans.py
similarity index 100%
rename from samples/python/kmeans.py
rename to samples/python/snippets/kmeans.py
diff --git a/samples/python/laplace.py b/samples/python/snippets/laplace.py
similarity index 100%
rename from samples/python/laplace.py
rename to samples/python/snippets/laplace.py
diff --git a/samples/python/lk_track.py b/samples/python/snippets/lk_track.py
similarity index 100%
rename from samples/python/lk_track.py
rename to samples/python/snippets/lk_track.py
diff --git a/samples/python/logpolar.py b/samples/python/snippets/logpolar.py
similarity index 100%
rename from samples/python/logpolar.py
rename to samples/python/snippets/logpolar.py
diff --git a/samples/python/mser.py b/samples/python/snippets/mser.py
similarity index 100%
rename from samples/python/mser.py
rename to samples/python/snippets/mser.py
diff --git a/samples/python/opt_flow.py b/samples/python/snippets/opt_flow.py
similarity index 100%
rename from samples/python/opt_flow.py
rename to samples/python/snippets/opt_flow.py
diff --git a/samples/python/squares.py b/samples/python/snippets/squares.py
similarity index 100%
rename from samples/python/squares.py
rename to samples/python/snippets/squares.py
diff --git a/samples/python/stitching.py b/samples/python/snippets/stitching.py
similarity index 100%
rename from samples/python/stitching.py
rename to samples/python/snippets/stitching.py
diff --git a/samples/python/texture_flow.py b/samples/python/snippets/texture_flow.py
similarity index 100%
rename from samples/python/texture_flow.py
rename to samples/python/snippets/texture_flow.py
diff --git a/samples/python/watershed.py b/samples/python/snippets/watershed.py
similarity index 100%
rename from samples/python/watershed.py
rename to samples/python/snippets/watershed.py
diff --git a/samples/python/text_skewness_correction.py b/samples/python/text_skewness_correction.py
deleted file mode 100644
index c3e97a333b..0000000000
--- a/samples/python/text_skewness_correction.py
+++ /dev/null
@@ -1,60 +0,0 @@
-'''
-Text skewness correction
-This tutorial demonstrates how to correct the skewness in a text.
-The program takes as input a skewed source image and shows non skewed text.
-
-Usage:
-        python text_skewness_correction.py --image "Image path"
-'''
-
-import numpy as np
-import cv2 as cv
-import sys
-import argparse
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-i", "--image", default="imageTextR.png", help="path to input image file")
-    args = vars(parser.parse_args())
-
-    # load the image from disk
-    image = cv.imread(cv.samples.findFile(args["image"]))
-    if image is None:
-        print("can't read image " + args["image"])
-        sys.exit(-1)
-    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
-
-    # threshold the image, setting all foreground pixels to
-    # 255 and all background pixels to 0
-    thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)[1]
-
-    # Applying erode filter to remove random noise
-    erosion_size = 1
-    element = cv.getStructuringElement(cv.MORPH_RECT, (2 * erosion_size + 1, 2 * erosion_size + 1), (erosion_size, erosion_size) )
-    thresh = cv.erode(thresh, element)
-
-    coords = cv.findNonZero(thresh)
-    angle = cv.minAreaRect(coords)[-1]
-    # the `cv.minAreaRect` function returns values in the
-    # range [0, 90) if the angle is more than 45 we need to subtract 90 from it
-    if angle > 45:
-        angle = (angle - 90)
-
-    (h, w) = image.shape[:2]
-    center = (w // 2, h // 2)
-    M = cv.getRotationMatrix2D(center, angle, 1.0)
-    rotated = cv.warpAffine(image, M, (w, h), flags=cv.INTER_CUBIC, borderMode=cv.BORDER_REPLICATE)
-    cv.putText(rotated, "Angle: {:.2f} degrees".format(angle), (10, 30), cv.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-
-    # show the output image
-    print("[INFO] angle: {:.2f}".format(angle))
-    cv.imshow("Input", image)
-    cv.imshow("Rotated", rotated)
-    cv.waitKey(0)
-
-
-if __name__ == "__main__":
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/turing.py b/samples/python/turing.py
deleted file mode 100755
index 5eb56cb157..0000000000
--- a/samples/python/turing.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Multiscale Turing Patterns generator
-====================================
-
-Inspired by http://www.jonathanmccabe.com/Cyclic_Symmetric_Multi-Scale_Turing_Patterns.pdf
-'''
-
-import numpy as np
-import cv2 as cv
-from common import draw_str
-import getopt, sys
-from itertools import count
-
-help_message = '''
-USAGE: turing.py [-o <output.avi>]
-
-Press ESC to stop.
-'''
-
-def main():
-    print(help_message)
-
-    w, h = 512, 512
-
-    args, _args_list = getopt.getopt(sys.argv[1:], 'o:', [])
-    args = dict(args)
-    out = None
-    if '-o' in args:
-        fn = args['-o']
-        out = cv.VideoWriter(args['-o'], cv.VideoWriter_fourcc(*'DIB '), 30.0, (w, h), False)
-        print('writing %s ...' % fn)
-
-    a = np.zeros((h, w), np.float32)
-    cv.randu(a, np.array([0]), np.array([1]))
-
-    def process_scale(a_lods, lod):
-        d = a_lods[lod] - cv.pyrUp(a_lods[lod+1])
-        for _i in range(lod):
-            d = cv.pyrUp(d)
-        v = cv.GaussianBlur(d*d, (3, 3), 0)
-        return np.sign(d), v
-
-    scale_num = 6
-    for frame_i in count():
-        a_lods = [a]
-        for i in range(scale_num):
-            a_lods.append(cv.pyrDown(a_lods[-1]))
-        ms, vs = [], []
-        for i in range(1, scale_num):
-            m, v = process_scale(a_lods, i)
-            ms.append(m)
-            vs.append(v)
-        mi = np.argmin(vs, 0)
-        a += np.choose(mi, ms) * 0.025
-        a = (a-a.min()) / a.ptp()
-
-        if out:
-            out.write(a)
-        vis = a.copy()
-        draw_str(vis, (20, 20), 'frame %d' % frame_i)
-        cv.imshow('a', vis)
-        if cv.waitKey(5) == 27:
-            break
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/video_threaded.py b/samples/python/video_threaded.py
deleted file mode 100755
index cbc73d296b..0000000000
--- a/samples/python/video_threaded.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env python
-
-'''
-Multithreaded video processing sample.
-Usage:
-   video_threaded.py {<video device number>|<video file name>}
-
-   Shows how python threading capabilities can be used
-   to organize parallel captured frame processing pipeline
-   for smoother playback.
-
-Keyboard shortcuts:
-
-   ESC - exit
-   space - switch between multi and single threaded processing
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-from multiprocessing.pool import ThreadPool
-from collections import deque
-
-from common import clock, draw_str, StatValue
-import video
-
-
-class DummyTask:
-    def __init__(self, data):
-        self.data = data
-    def ready(self):
-        return True
-    def get(self):
-        return self.data
-
-def main():
-    import sys
-
-    try:
-        fn = sys.argv[1]
-    except:
-        fn = 0
-    cap = video.create_capture(fn)
-
-
-    def process_frame(frame, t0):
-        # some intensive computation...
-        frame = cv.medianBlur(frame, 19)
-        frame = cv.medianBlur(frame, 19)
-        return frame, t0
-
-    threadn = cv.getNumberOfCPUs()
-    pool = ThreadPool(processes = threadn)
-    pending = deque()
-
-    threaded_mode = True
-
-    latency = StatValue()
-    frame_interval = StatValue()
-    last_frame_time = clock()
-    while True:
-        while len(pending) > 0 and pending[0].ready():
-            res, t0 = pending.popleft().get()
-            latency.update(clock() - t0)
-            draw_str(res, (20, 20), "threaded      :  " + str(threaded_mode))
-            draw_str(res, (20, 40), "latency        :  %.1f ms" % (latency.value*1000))
-            draw_str(res, (20, 60), "frame interval :  %.1f ms" % (frame_interval.value*1000))
-            cv.imshow('threaded video', res)
-        if len(pending) < threadn:
-            _ret, frame = cap.read()
-            t = clock()
-            frame_interval.update(t - last_frame_time)
-            last_frame_time = t
-            if threaded_mode:
-                task = pool.apply_async(process_frame, (frame.copy(), t))
-            else:
-                task = DummyTask(process_frame(frame, t))
-            pending.append(task)
-        ch = cv.waitKey(1)
-        if ch == ord(' '):
-            threaded_mode = not threaded_mode
-        if ch == 27:
-            break
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()
diff --git a/samples/python/video_v4l2.py b/samples/python/video_v4l2.py
deleted file mode 100644
index abebb2a2ca..0000000000
--- a/samples/python/video_v4l2.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env python
-
-'''
-VideoCapture sample showcasing  some features of the Video4Linux2 backend
-
-Sample shows how VideoCapture class can be used to control parameters
-of a webcam such as focus or framerate.
-Also the sample provides an example how to access raw images delivered
-by the hardware to get a grayscale image in a very efficient fashion.
-
-Keys:
-    ESC    - exit
-    g      - toggle optimized grayscale conversion
-
-'''
-
-# Python 2/3 compatibility
-from __future__ import print_function
-
-import numpy as np
-import cv2 as cv
-
-def main():
-
-    def decode_fourcc(v):
-        v = int(v)
-        return "".join([chr((v >> 8 * i) & 0xFF) for i in range(4)])
-
-    font = cv.FONT_HERSHEY_SIMPLEX
-    color = (0, 255, 0)
-
-    cap = cv.VideoCapture(0)
-    cap.set(cv.CAP_PROP_AUTOFOCUS, 0)  # Known bug: https://github.com/opencv/opencv/pull/5474
-
-    cv.namedWindow("Video")
-
-    convert_rgb = True
-    fps = int(cap.get(cv.CAP_PROP_FPS))
-    focus = int(min(cap.get(cv.CAP_PROP_FOCUS) * 100, 2**31-1))  # ceil focus to C_LONG as Python3 int can go to +inf
-
-    cv.createTrackbar("FPS", "Video", fps, 30, lambda v: cap.set(cv.CAP_PROP_FPS, v))
-    cv.createTrackbar("Focus", "Video", focus, 100, lambda v: cap.set(cv.CAP_PROP_FOCUS, v / 100))
-
-    while True:
-        _status, img = cap.read()
-
-        fourcc = decode_fourcc(cap.get(cv.CAP_PROP_FOURCC))
-
-        fps = cap.get(cv.CAP_PROP_FPS)
-
-        if not bool(cap.get(cv.CAP_PROP_CONVERT_RGB)):
-            if fourcc == "MJPG":
-                img = cv.imdecode(img, cv.IMREAD_GRAYSCALE)
-            elif fourcc == "YUYV":
-                img = cv.cvtColor(img, cv.COLOR_YUV2GRAY_YUYV)
-            else:
-                print("unsupported format")
-                break
-
-        cv.putText(img, "Mode: {}".format(fourcc), (15, 40), font, 1.0, color)
-        cv.putText(img, "FPS: {}".format(fps), (15, 80), font, 1.0, color)
-        cv.imshow("Video", img)
-
-        k = cv.waitKey(1)
-
-        if k == 27:
-            break
-        elif k == ord('g'):
-            convert_rgb = not convert_rgb
-            cap.set(cv.CAP_PROP_CONVERT_RGB, 1 if convert_rgb else 0)
-
-    print('Done')
-
-
-if __name__ == '__main__':
-    print(__doc__)
-    main()
-    cv.destroyAllWindows()