def feature_match(img1, img2):
originial = img2
img1 = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)
img2 = cv2.cvtColor(img2, cv2.COLOR_RGB2GRAY)
h, w = img1.shape
h2, w2 = img2.shape
if h > h2 and w > w2:
img1 = resize_with_aspect_ratio(img1, height=h2 // 2)
pts1, desc1 = ORB_descriptor(img1, 1000)
pts2, desc2 = ORB_descriptor(img2, 10000)
dmatches = get_matches(desc1, desc2)
h, w = img1.shape
dst = find_image_in_frame(dmatches, pts1, pts2, h, w)
img2 = cv2.polylines(originial, [np.int32(dst)], True, (0, 0, 255), 10,
cv2.LINE_AA)
res = cv2.drawMatches(img1,
pts1,
img2,
pts2,
dmatches[:5],
None,
flags=cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS)
return res
def q3(image, sift1):
center = get_img_center(image)
# a) Rotate the given image clockwise by 60 degrees.
rot = imutils.rotate_bound(image, 60)
#rot = rotate(image, center[0], center[1], 60)
plt.imshow(rot), plt.show()
# b) Extract the SIFT features and show the keypoints on the rotated image using the same
# parameter setting as for Task 1 (for the reduced number of keypoints).
keyPoints1, des1 = sift1.detector.detectAndCompute(image, None)
keyPoints2, des2 = sift1.detector.detectAndCompute(rot, None)
bf = cv2.BFMatcher()
# c)the keypoints in both images similar which shows that they share the same common features.
# d) Match the SIFT descriptors of the keypoints of the rotated image with those of the original
#image using the nearest-neighbour distance ratio method
matches = bf.match(des1, des2)
# We sort them in ascending order of their distances so that best matches (with low distance) come to front
matches = sorted(matches, key=lambda x: x.distance)
# Show the keypoints of the 5 best-matching descriptors on both the original and the scaled image.
img_q3 = cv2.drawMatches(
image, keyPoints1, rot, keyPoints2, matches[:7], None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
plt.imshow(img_q3), plt.show()
img3 = cv2.drawKeypoints(image, keyPoints1, image)
cv2.imwrite('b3.jpg', img3)
cv2.imwrite('d3.jpg', img_q3)
def orb_stitcher(imgs):
# find the keypoints with ORB
orb1 = cv2.ORB_create(1000, 1.1, 13)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
kp_master, des_master = orb1.detectAndCompute(imgs[0], None)
kp_secondary, des_secondary = orb1.detectAndCompute(imgs[1], None)
matches = bf.match(des_secondary, des_master)
# Sort them in the order of their distance.
matches = sorted(matches, key=lambda x: x.distance)
selected = []
for m in matches:
if m.distance < 40:
selected.append(m)
out_img = cv2.drawMatches(imgs[1], kp_secondary, imgs[0], kp_master,
selected, None)
cv2.namedWindow('www', cv2.WINDOW_NORMAL)
cv2.imshow('www', out_img)
# cv2.imwrite('matches.jpg',out_img)
cv2.waitKey(0)
warped = None
if len(selected) > 10:
dst_pts = np.float32([kp_master[m.trainIdx].pt
for m in selected]).reshape(-1, 1, 2)
src_pts = np.float32([kp_secondary[m.queryIdx].pt
for m in selected]).reshape(-1, 1, 2)
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
h, w = imgs[0].shape[0:2]
pts = np.float32([[0, 0], [w, 0], [w, h], [0, h],
[0, 0]]).reshape(-1, 1, 2)
dst = cv2.perspectiveTransform(pts, M)
max_extent = np.max(dst, axis=0)[0].astype(np.int)[::-1]
sz_out = (max(max_extent[1],
imgs[0].shape[1]), max(max_extent[0], imgs[0].shape[0]))
# img2 = cv2.polylines(imgs[0], [np.int32(dst)], True, [0,255,0], 3, cv2.LINE_AA)
cv2.namedWindow('w', cv2.WINDOW_NORMAL)
warped = cv2.warpPerspective(imgs[1], M, dsize=sz_out)
img_for_show = warped.copy()
img_for_show[0:imgs[0].shape[0], 0:imgs[0].shape[1], 1] = imgs[0][:, :,
1]
cv2.imshow('w', img_for_show)
cv2.waitKey(0)
return warped
def viewImage():
img_ = right()
# img_ = cv2.resize(img_, (0,0), fx=1, fy=1)
img1 = cv2.cvtColor(img_, cv2.COLOR_BGR2GRAY)
img = rear()
# img = cv2.resize(img, (0,0), fx=1, fy=1)
img2 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
sift = cv2.xfeatures2d.SIFT_create()
# find the key points and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
match = cv2.BFMatcher()
matches = match.knnMatch(des1, des2, k=2)
good = []
for m, n in matches:
if m.distance < 0.8 * n.distance:
good.append(m)
draw_params = dict(
matchColor=(0, 255, 0), # draw matches in green color
singlePointColor=None,
flags=2)
img3 = cv2.drawMatches(img_, kp1, img, kp2, good, None, **draw_params)
cv2.imshow("original_image_drawMatches.jpg", img3)
MIN_MATCH_COUNT = 10
if len(good) > MIN_MATCH_COUNT:
src_pts = np.float32([kp1[m.queryIdx].pt
for m in good]).reshape(-1, 1, 2)
dst_pts = np.float32([kp2[m.trainIdx].pt
for m in good]).reshape(-1, 1, 2)
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
h, w = img1.shape
pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1],
[w - 1, 0]]).reshape(-1, 1, 2)
dst = cv2.perspectiveTransform(pts, M)
img2 = cv2.polylines(img2, [np.int32(dst)], True, 255, 3, cv2.LINE_AA)
cv2.imshow("original_image_overlapping.jpg", img2)
# dst = np.concatenate((rightImg, rearImg), 1)
# cv2.imshow("Image", )
cv2.waitKey(0)
cv2.destroyAllWindows()
def align_image(feature_image, target_image):
ORB = cv2.ORB_create(MAX_FEATURE)
feature_keypoints, feature_descriptors = ORB.detectAndCompute(
feature_image, None)
target_keypoints, target_descriptors = ORB.detectAndCompute(
target_image, None)
matcher = cv2.DescriptorMatcher_create(
cv2.DESCRIPTOR_MATCHER_BRUTEFORCE_HAMMING)
matches = matcher.match(feature_descriptors, target_descriptors, None)
matches.sort(key=lambda x: x.distance, reverse=False)
num_good_matches = int(len(matches) * GOOD_MATCH_PERCENT)
matches = matches[:num_good_matches]
img_matches = cv2.drawMatches(feature_image, feature_keypoints,
target_image, target_keypoints, matches,
None)
cv2.imwrite("image-matches.jpg", img_matches)
feature_points = np.zeros((len(matches), 2), dtype=np.float32)
target_points = np.zeros((len(matches), 2), dtype=np.float32)
for i, match in enumerate(matches):
feature_points[i, :] = feature_keypoints[match.queryIdx].pt
target_points[i, :] = target_keypoints[match.trainIdx].pt
homography_matrix, mask = cv2.findHomography(target_points, feature_points,
cv2.RANSAC)
height, width, channels = feature_image.shape
perspective_corrected_image = cv2.warpPerspective(target_image,
homography_matrix,
(width, height))
return perspective_corrected_image, homography_matrix
def q2(image, sift):
# a)Enlarge the given image by a scale percentage of 115.
scale = 115
scale = scale/100
width = int(image.shape[1] * scale)
height = int(image.shape[0] * scale)
new_dim = (width, height)
resized = cv2.resize(image, new_dim)
# b) Extract the SIFT features and show the keypoints on the scaled image using the same
# parameter setting as for Task 1 (for the reduced number of keypoints).
## find the keypoints and descriptors using sift detector
keyPoints1, des1 = sift.detector.detectAndCompute(image, None)
# Since I have already found keypoints, call sift.compute() which computes the descriptors
# from the keypoints that has been already found
keyPoints2, des2 = sift.detector.detectAndCompute(resized, None)
img2 = cv2.drawKeypoints(image, keyPoints1, image)
# Hint: Brute-force matching is available in OpenCV for feature matching.
bf_matcher = cv2.BFMatcher()
#use Matcher.match() method to get the best matches in two images
matches = bf_matcher.match(des1, des2)
#matches = bf_matcher.knnMatch(des1, des2, k=2)
# c)the keypoints in both images similar which shows that they share the same common features.
# d) Match the SIFT descriptors of the keypoints of the scaled image with those of the original image
# using the nearest-neighbour distance ratio method
# We sort them in ascending order of their distances so that best matches (with low distance) come to front
matches = sorted(matches, key=lambda x: x.distance)
# Show the keypoints of the 5 best-matching descriptors on both the original and the scaled image.
img_q2=cv2.drawMatches(image, keyPoints1, resized, keyPoints2,
matches[:6], None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
plt.imshow(img_q2), plt.show()
cv2.imwrite('d2.jpg', img_q2)
cv2.imwrite('b2.jpg', img2)
def rectify_pair(image_left, image_right, viz=False):
#特征点匹配
#1.用surf进行特征点检测
grayL = cv2.cvtColor(image_left, cv2.COLOR_BGR2GRAY)
grayR = cv2.cvtColor(image_right, cv2.COLOR_BGR2GRAY)
surf = cv2.xfeatures2d.SURF_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = surf.detectAndCompute(grayL, None)
kp2, des2 = surf.detectAndCompute(grayR, None)
img = cv2.drawKeypoints(grayL, kp1, image_left)
cv2.imshow("keyPointsOfLeft", img)
#2.用BFMATCHER进行特征点匹配
bf = cv2.BFMatcher(cv2.NORM_L1, crossCheck=False)
# 特征描述子匹配
matches = bf.match(des1, des2)
points1 = []
points2 = []
for match in matches:
points1.append(kp1[match.queryIdx].pt)
points2.append(kp2[match.trainIdx].pt)
#matches=sorted(matches,key=lambda x:x.distance)
# print(len(matches))
img3 = cv2.drawMatches(grayL, kp1, grayR, kp2, matches[:20], None, flags=2)
cv2.imshow('matches', img3)
# find the fundamental matrix
F, mask = cv2.findFundamentalMat(np.array(points1), np.array(points2),
cv2.RANSAC, 3, 0.99)
# rectify the images, produce the homographies: H_left and H_right
retval, H_left, H_right = cv2.stereoRectifyUncalibrated(
np.array(points1), np.array(points2), F, image_left.shape[:2])
return F, H_left, H_right
#opencv----特征匹配----BFMatching
from cv2 import cv2
from matplotlib import pyplot as plt
#读取需要特征匹配的两张照片，格式为灰度图。
template = cv2.imread("template_adjust.jpg", 0)
target = cv2.imread("target1.jpg", 0)
orb = cv2.ORB_create() #建立orb特征检测器
kp1, des1 = orb.detectAndCompute(template, None) #计算template中的特征点和描述符
kp2, des2 = orb.detectAndCompute(target, None) #计算target中的
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) #建立匹配关系
mathces = bf.match(des1, des2) #匹配描述符
mathces = sorted(mathces, key=lambda x: x.distance) #据距离来排序
result = cv2.drawMatches(template,
kp1,
target,
kp2,
mathces[:40],
None,
flags=2) #画出匹配关系
plt.imshow(result), plt.show() #matplotlib描绘出来
def tracking_orb():
cap = cv2.VideoCapture('find_chocolate.mp4')
ret, frm = cap.read()
img_chocolate = cv2.imread('marker.jpg')
frm_count = 0
key = None
# Setting video format. Google for "fourcc"
fourcc = cv2.VideoWriter_fourcc(*'XVID')
# Setting up new video writer
image_size = (frm.shape[1], frm.shape[0])
# writer = cv2.VideoWriter('sample_tracking_orb.avi', fourcc, frames_per_second, image_size)
out = cv2.VideoWriter('sample_tracking_orb.mp4', fourcc, 30.0, image_size)
while ret:
## Create ORB object and BF object(using HAMMING)
orb = cv2.ORB_create()
gray2 = cv2.cvtColor(frm, cv2.COLOR_BGR2GRAY)
gray1 = cv2.cvtColor(img_chocolate, cv2.COLOR_BGR2GRAY)
# gray2 = cv2.equalizeHist(gray2)
# gray1 = cv2.equalizeHist(gray1)
## Find the keypoints and descriptors with ORB
kpts1, descs1 = orb.detectAndCompute(gray1, None)
kpts2, descs2 = orb.detectAndCompute(gray2, None)
# create BFMatcher object
## match descriptors and sort them in the order of their distance
bf = cv2.BFMatcher(cv2.NORM_HAMMING2, crossCheck=True)
# Match descriptors.
matches = bf.match(descs1, descs2)
# Sort them in the order of their distance.
dmatches = sorted(matches, key=lambda x: x.distance)
## extract the matched keypoints
src_pts = np.float32([kpts1[m.queryIdx].pt
for m in dmatches]).reshape(-1, 1, 2)
dst_pts = np.float32([kpts2[m.trainIdx].pt
for m in dmatches]).reshape(-1, 1, 2)
## find homography matrix and do perspective transform
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
h, w = img_chocolate.shape[:2]
pts = np.float32([[0, 0], [0, h - 1], [w - 1, h - 1],
[w - 1, 0]]).reshape(-1, 1, 2)
dst = cv2.perspectiveTransform(pts, M)
## draw found regions
frm = cv2.polylines(frm, [np.int32(dst)], True, (0, 0, 255), 1,
cv2.LINE_AA)
## draw match lines
res = cv2.drawMatches(img_chocolate,
kpts1,
frm,
kpts2,
dmatches[:8],
None,
flags=2)
# writer.write(res)
cv2.namedWindow('orb_match', cv2.WINDOW_NORMAL)
# cv2.imshow("orb_match", frm)
out.write(frm)
cv2.imshow("orb_match", res)
# Pause on pressing of space.
if key == ord(' '):
wait_period = 0
else:
wait_period = 30
key = cv2.waitKey(wait_period)
ret, frm = cap.read()
frm_count += 1
cv2.destroyAllWindows()
cap.release()
out.release()
return 0
print("[INFO] descriotion size of BRISK = {}".format(BRISK.descriptorSize()))
print("[INFO] stage 3: matching features!")
# create a BFMatcher instance
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
# Match descriptors.
matches = bf.match(des1, des2)
# Sort them in the order of their distance.
matches = sorted(matches, key=lambda x: x.distance)
# Draw first 10 matches.
img3 = cv2.drawMatches(img1, kp1, img2, kp2, matches[:20], None, flags=2)
# showing matches keypoints
plt.title("BRISK")
plt.imshow(img3), plt.show()
# saving matches keypoints in file
cv2.imwrite("images/outputs/BRISK_result.jpg", img3)
print("[INFO] size of features = {}".format(len(matches[:10])))
print("[INFO] computing Precision!")
correct_matches = int(
input("Please enter the number of correct matches: "))
incorrect_matches = 10 - correct_matches
kp1, des1 = sift.detectAndCompute(gray1, None)
kp2, des2 = sift.detectAndCompute(gray2, None)
########
# test #
########
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append(m)
good = sorted(good, key=lambda x: x.distance)
show = cv2.drawMatches(img1, kp1, img2, kp2, good[:20], None, flags=2)
imshow(imdiv(show, 1.5))
########
# test #
########
#记录特征点的x，y坐标
pos1 = np.float32([kp.pt for kp in kp1])
pos2 = np.float32([kp.pt for kp in kp2])
#特征值匹配
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
good = []
for m, n in matches:
start_time = time.time()
IM.detectAKAZE()
print(f'finished detect in {time.time()-start_time}')
start_time = time.time()
IM.KNNmatchAKAZE(projErr=5)
print(f'finished matching in {time.time()-start_time}')
start_time = time.time()
with open('./data/matching_pairs/ORB_matching_pair.npy', 'wb') as f:
np.save(f, IM.src_pts)
np.save(f, IM.dst_pts)
print(f'There are {len(IM.tar_kps)} feature points in target image.')
print(f'There are {len(IM.ref_kps)} feature points in reference image.')
print(f'There are {len(IM.matches)} pairs matching pairs.')
print(
f'There are {len(IM.mask[IM.mask == 1])} pairs matching pairs after RANSAC.'
)
# print(f"Process finished --- {(time.time() - start_time)} seconds ---")
img4 = img4 = cv2.drawMatches(
tar_img,
IM.tar_kps,
ref_img,
IM.ref_kps,
IM.matches,
None,
flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS,
matchesMask=IM.mask)
cv2.imwrite('Match.jpg', img4)
