Download samples/python/find_obj.py from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 6.48 kB
-
https://huggingface.co/tgollogly/test/resolve/main/samples/python/find_obj.py
- Command line
-
hf download hf://tgollogly/test/samples/python/find_obj.py
-
curl -L -o find_obj.py https://huggingface.co/tgollogly/test/resolve/main/samples/python/find_obj.py
6.48 kB
| #!/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() | |