mirror of https://github.com/opencv/opencv.git
Merge pull request #25268 from gursimarsingh:samples_cleanup_python
Removed obsolete python samples #25268 Clean Samples #25006 This PR removes 36 obsolete python samples from the project, as part of an effort to keep the codebase clean and focused on current best practices. Some of these samples will be updated with latest algorithms or will be combined with other existing samples. Removed Samples: > browse.py camshift.py coherence.py color_histogram.py contours.py deconvolution.py dft.py dis_opt_flow.py distrans.py edge.py feature_homography.py find_obj.py fitline.py gabor_threads.py hist.py houghcircles.py houghlines.py inpaint.py kalman.py kmeans.py laplace.py lk_homography.py lk_track.py logpolar.py mosse.py mser.py opt_flow.py plane_ar.py squares.py stitching.py text_skewness_correction.py texture_flow.py turing.py video_threaded.py video_v4l2.py watershed.py These changes aim to improve the repository's clarity and usability by removing examples that are no longer relevant or have been superseded by more up-to-date techniques.pull/25998/head
Gursimar Singh
4 months ago
committed by
GitHub
parent
f24e80297a
commit
3dcc8c38b4
42 changed files with 69 additions and 1711 deletions
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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> |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
@ -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() |
||||
Loading…
Reference in new issue