官方samples

Author: makelove

官方samples/CMakeLists.txt

@@ -0,0 +1,6 @@
+if(INSTALL_PYTHON_EXAMPLES)
+  file(GLOB install_list *.py )
+  install(FILES ${install_list}
+          DESTINATION ${OPENCV_SAMPLES_SRC_INSTALL_PATH}/python
+          PERMISSIONS OWNER_READ GROUP_READ WORLD_READ COMPONENT samples)
+endif()

官方samples/_coverage.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+'''
+Utility for measuring python opencv API coverage by samples.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+from glob import glob
+import cv2
+import re
+
+if __name__ == '__main__':
+    cv2_callable = set(['cv2.'+name for name in dir(cv2) if callable( getattr(cv2, name) )])
+
+    found = set()
+    for fn in glob('*.py'):
+        print(' --- ', fn)
+        code = open(fn).read()
+        found |= set(re.findall('cv2?\.\w+', code))
+
+    cv2_used = found & cv2_callable
+    cv2_unused = cv2_callable - cv2_used
+    with open('unused_api.txt', 'w') as f:
+        f.write('\n'.join(sorted(cv2_unused)))
+
+    r = 1.0 * len(cv2_used) / len(cv2_callable)
+    print('\ncv2 api coverage: %d / %d  (%.1f%%)' % ( len(cv2_used), len(cv2_callable), r*100 ))

官方samples/_doc.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+
+'''
+Scans current directory for *.py files and reports
+ones with missing __doc__ string.
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+from glob import glob
+
+if __name__ == '__main__':
+    print('--- undocumented files:')
+    for fn in glob('*.py'):
+        loc = {}
+        try:
+            if PY3:
+                exec(open(fn).read(), loc)
+            else:
+                execfile(fn, loc)
+        except:
+            pass
+        if '__doc__' not in loc:
+            print(fn)

官方samples/_run_winpack_demo_python27.cmd

@@ -0,0 +1,47 @@
+@echo off
+if NOT exist %CD%\..\..\..\build (
+  echo ERROR: OpenCV Winpack installation is required
+  pause
+  exit
+)
+
+:: Path to FFMPEG binary files
+set PATH=%PATH%;%CD%\..\..\..\build\bin\
+
+:: Detect Python binary
+python -V
+if %ERRORLEVEL% EQU 0 (
+  set PYTHON=python
+) else (
+  if exist C:\Python27-x64\python.exe (
+    set PYTHON=C:\Python27-x64\python.exe
+  ) else (
+    if exist C:\Python27\python.exe (
+      set PYTHON=C:\Python27\python.exe
+    ) else (
+      echo ERROR: Python not found
+      pause
+      exit
+    )
+  )
+)
+echo Using python: %PYTHON%
+
+:: Detect python architecture
+%PYTHON% -c "import platform; exit(64 if platform.architecture()[0] == '64bit' else 32)"
+if %ERRORLEVEL% EQU 32 (
+  echo Detected: Python 32-bit
+  set PYTHONPATH=%CD%\..\..\..\build\python\2.7\x86
+) else (
+  if %ERRORLEVEL% EQU 64 (
+    echo Detected: Python 64-bit
+    set PYTHONPATH=%CD%\..\..\..\build\python\2.7\x64
+  ) else (
+    echo ERROR: Unknown python arch
+    pause
+    exit
+  )
+)
+
+:: Launch demo
+%PYTHON% demo.py

官方samples/asift.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+
+'''
+Affine invariant feature-based image matching sample.
+
+This sample is similar to find_obj.py, but uses the affine transformation
+space sampling technique, called ASIFT [1]. While the original implementation
+is based on SIFT, you can try to use SURF or ORB detectors instead. Homography RANSAC
+is used to reject outliers. Threading is used for faster affine sampling.
+
+[1] http://www.ipol.im/pub/algo/my_affine_sift/
+
+USAGE
+  asift.py [--feature=<sift|surf|orb|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
+
+# built-in modules
+import itertools as it
+from multiprocessing.pool import ThreadPool
+
+# local modules
+from common import Timer
+from find_obj import init_feature, filter_matches, explore_match
+
+
+def affine_skew(tilt, phi, img, mask=None):
+    '''
+    affine_skew(tilt, phi, img, mask=None) -> skew_img, skew_mask, Ai
+
+    Ai - is an affine transform matrix from skew_img to img
+    '''
+    h, w = img.shape[:2]
+    if mask is None:
+        mask = np.zeros((h, w), np.uint8)
+        mask[:] = 255
+    A = np.float32([[1, 0, 0], [0, 1, 0]])
+    if phi != 0.0:
+        phi = np.deg2rad(phi)
+        s, c = np.sin(phi), np.cos(phi)
+        A = np.float32([[c,-s], [ s, c]])
+        corners = [[0, 0], [w, 0], [w, h], [0, h]]
+        tcorners = np.int32( np.dot(corners, A.T) )
+        x, y, w, h = cv2.boundingRect(tcorners.reshape(1,-1,2))
+        A = np.hstack([A, [[-x], [-y]]])
+        img = cv2.warpAffine(img, A, (w, h), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REPLICATE)
+    if tilt != 1.0:
+        s = 0.8*np.sqrt(tilt*tilt-1)
+        img = cv2.GaussianBlur(img, (0, 0), sigmaX=s, sigmaY=0.01)
+        img = cv2.resize(img, (0, 0), fx=1.0/tilt, fy=1.0, interpolation=cv2.INTER_NEAREST)
+        A[0] /= tilt
+    if phi != 0.0 or tilt != 1.0:
+        h, w = img.shape[:2]
+        mask = cv2.warpAffine(mask, A, (w, h), flags=cv2.INTER_NEAREST)
+    Ai = cv2.invertAffineTransform(A)
+    return img, mask, Ai
+
+
+def affine_detect(detector, img, mask=None, pool=None):
+    '''
+    affine_detect(detector, img, mask=None, pool=None) -> keypoints, descrs
+
+    Apply a set of affine transormations to the image, detect keypoints and
+    reproject them into initial image coordinates.
+    See http://www.ipol.im/pub/algo/my_affine_sift/ for the details.
+
+    ThreadPool object may be passed to speedup the computation.
+    '''
+    params = [(1.0, 0.0)]
+    for t in 2**(0.5*np.arange(1,6)):
+        for phi in np.arange(0, 180, 72.0 / t):
+            params.append((t, phi))
+
+    def f(p):
+        t, phi = p
+        timg, tmask, Ai = affine_skew(t, phi, img)
+        keypoints, descrs = detector.detectAndCompute(timg, tmask)
+        for kp in keypoints:
+            x, y = kp.pt
+            kp.pt = tuple( np.dot(Ai, (x, y, 1)) )
+        if descrs is None:
+            descrs = []
+        return keypoints, descrs
+
+    keypoints, descrs = [], []
+    if pool is None:
+        ires = it.imap(f, params)
+    else:
+        ires = pool.imap(f, params)
+
+    for i, (k, d) in enumerate(ires):
+        print('affine sampling: %d / %d\r' % (i+1, len(params)), end='')
+        keypoints.extend(k)
+        descrs.extend(d)
+
+    print()
+    return keypoints, np.array(descrs)
+
+if __name__ == '__main__':
+    print(__doc__)
+
+    import sys, getopt
+    opts, args = getopt.getopt(sys.argv[1:], '', ['feature='])
+    opts = dict(opts)
+    feature_name = opts.get('--feature', 'brisk-flann')
+    try:
+        fn1, fn2 = args
+    except:
+        fn1 = '../data/aero1.jpg'
+        fn2 = '../data/aero3.jpg'
+
+    img1 = cv2.imread(fn1, 0)
+    img2 = cv2.imread(fn2, 0)
+    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)
+
+    pool=ThreadPool(processes = cv2.getNumberOfCPUs())
+    kp1, desc1 = affine_detect(detector, img1, pool=pool)
+    kp2, desc2 = affine_detect(detector, img2, pool=pool)
+    print('img1 - %d features, img2 - %d features' % (len(kp1), len(kp2)))
+
+    def match_and_draw(win):
+        with Timer('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 = cv2.findHomography(p1, p2, cv2.RANSAC, 5.0)
+            print('%d / %d  inliers/matched' % (np.sum(status), len(status)))
+            # do not draw outliers (there will be a lot of them)
+            kp_pairs = [kpp for kpp, flag in zip(kp_pairs, status) if flag]
+        else:
+            H, status = None, None
+            print('%d matches found, not enough for homography estimation' % len(p1))
+
+        vis = explore_match(win, img1, img2, kp_pairs, None, H)
+
+
+    match_and_draw('affine find_obj')
+    cv2.waitKey()
+    cv2.destroyAllWindows()

官方samples/browse.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+
+'''
+browse.py
+=========
+
+Sample shows how to implement a simple hi resolution image navigation
+
+Usage
+-----
+browse.py [image filename]
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2
+
+# built-in modules
+import sys
+
+if __name__ == '__main__':
+    print('This sample shows how to implement a simple hi resolution image navigation.')
+    print('USAGE: browse.py [image filename]')
+    print()
+
+    if len(sys.argv) > 1:
+        fn = sys.argv[1]
+        print('loading %s ...' % fn)
+        img = cv2.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))
+        cv2.polylines(img, [track], 0, 255, 1, cv2.LINE_AA)
+
+
+    small = img
+    for i in xrange(3):
+        small = cv2.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 = cv2.getRectSubPix(img, (800, 600), (x+0.5, y+0.5))
+        cv2.imshow('zoom', zoom)
+
+    cv2.imshow('preview', small)
+    cv2.setMouseCallback('preview', onmouse)
+    cv2.waitKey()
+    cv2.destroyAllWindows()