def matched_key_points(n_stills):
for i in range(2, n_stills + 1):
#Loading images
img1 = cv2.imread('Motion_Image' + str(i-1) + '.png')
img2 = cv2.imread('Motion_Image' + str(i) + '.png')
kaze = cv2.KAZE_create() #note: opencv3 does not have SIFT or SURF
kp1, des1 = kaze.detectAndCompute(img1,None)
kp2, des2 = kaze.detectAndCompute(img2,None)
bf = cv2.BFMatcher()
# print type(des1)
matches = bf.knnMatch(des1,des2,k=2)
# print matches
good = []
for m,n in matches:
if m.distance < 0.05*n.distance:
good.append([m])
# matches = sorted(matches, key = lambda x:x.distance)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good,flags=2,outImg =None)
plt.imshow(img3),plt.show()
def match(img1, img2): sift = cv2.xfeatures2d.SIFT_create() kp1, des1 = sift.detectAndCompute(img1,None) kp1_img = cv2.drawKeypoints(img1, kp1, img1, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) kp2, des2 = sift.detectAndCompute(img2,None) kp2_img=cv2.drawKeypoints(img2,kp2,img2,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) bf = cv2.BFMatcher() matches = bf.knnMatch(des1,des2, k=2) good = [] src = [] dst = [] for m,n in matches: if m.distance < 0.7*n.distance: good.append([m]) src_pts = np.float32([ kp1[m[0].queryIdx].pt for m in good ]).reshape(-1,1,2) des_cor = [kp2[m[0].trainIdx].pt for m in good] dst_pts = np.float32(des_cor).reshape(-1,1,2) centroid = findCentroid(des_cor) img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good, img2, flags=2) M, mask = cv2.findHomography(src_pts, dst_pts) return (matches, kp1_img, kp2_img, img3, M, centroid)
def comprassionFlann(frame1,frame2):
good = []
sift = cv.xfeatures2d.SURF_create(nOctaves=3)
kp1, des1 = sift.detectAndCompute(frame1,None)
kp2, des2 = sift.detectAndCompute(frame2,None)
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
flann = cv.FlannBasedMatcher(index_params,search_params)
matches = flann.knnMatch(des1,des2,k=2)
matchesMask = [[0,0] for i in range(len(matches))]
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
good.append(m)
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv.drawMatchesKnn(frame1,kp1,frame2,kp2,matches,None,**draw_params)
#plt.imshow(img3),plt.show()
return(img3,good)
def comprassionWithImagesParallel(frame1,frame2):
numberOfSlide = []
sift = cv.xfeatures2d.SURF_create()
#SURF
#surf = cv.xfeatures2d.SURF_create()
#Находим точки
kpts1 = sift.detect(frame1,None)
kpts2 = sift.detect(frame2,None)
#Дескриптор
#descriptor = cv.BRISK_create()
#brief = cv.xfeatures2d.BriefDescriptorExtractor_create()
#Матчер
matcher = cv.BFMatcher()
good = []
goods = []
k1, d1 = sift.compute(frame1, kpts1)
k2, d2 = sift.compute(frame2, kpts2)
if (d1 is not None and d2 is not None):
matches = matcher.knnMatch(d1,d2,k=2)
try:
for m,n in matches:
if m.distance < 0.85*n.distance:
good.append([m])
goods.append(m)
except(ValueError):
print("VALUEERROR")
return(None,None)
img3 = cv.drawMatchesKnn(frame1,k1,frame2,k2,good,frame1,flags=2)
#plt.imshow(img3),plt.show()
return(img3,good)
def processImagesFlannBasedMatcher(frame1,frame2):
frame1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
frame2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
# detector = cv2.xfeatures2d.SIFT_create()
detector = cv2.xfeatures2d.SURF_create(500)
kp1, desc1 = detector.detectAndCompute(frame1, None)
kp2, desc2 = detector.detectAndCompute(frame2, None)
# FlannBasedMatcher
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
# or pass empty dictionary
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params,search_params)
matches = flann.knnMatch(desc1, desc2, k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img = cv2.drawMatchesKnn(rame1,kp1,frame2,kp2,matches,None,**draw_params)
cv2.imshow('demo',img)
def flann_matcher():
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
# FLANN parameters
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# Need to draw only good matches, so create a mask
matches_mask = [[0, 0] for _ in xrange(len(matches))]
# ratio test as per Lowe's paper
for i, (m, n) in enumerate(matches):
if m.distance < 0.7 * n.distance:
matches_mask[i] = [1, 0]
draw_params = dict(
matchColor=(0, 255, 0),
singlePointColor = (255, 0, 0),
matchesMask = matches_mask,
flags = 0
)
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, matches, None, **draw_params)
plt.imshow(img3,), plt.show()
def search(self):
if self.imageLink:
img1 = cv2.imread(self.imageLink)
img1 = imutils.resize(img1, width=1000)
img1 = cv2.cvtColor(img1, cv2.COLOR_RGBA2GRAY)
surf = cv2.xfeatures2d.SURF_create(2000,7,7)
kp1, des1 = surf.detectAndCompute(img1, None)
ans = {}
for imagePath in glob.glob("logo/**/*.png"):
img2 = cv2.imread(imagePath)
img2 = cv2.cvtColor(img2, cv2.COLOR_RGBA2GRAY)
img2 = imutils.resize(img2, width=500)
kp2, des2 = surf.detectAndCompute(img2, None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des2, des1, k=2)
good = []
for m,n in matches:
if m.distance < 0.7*n.distance:
good.append([m])
percent = len(good)
ans.update({imagePath:percent})
percent = str(round(percent, 2))
img3 = cv2.drawMatchesKnn(img2, kp2, img1, kp1, good, None, flags=2)
cv2.putText(img3, ("Good: " + str(len(good))), (10,400), 0, 1, (0,0,255),2)
cv2.imwrite("static/result/" + str(os.path.basename(imagePath)), img3)
if max(ans.values()) >= 20:
result = str(max(ans, key=ans.get))
else:
result = 'UNKNOWN'
return result
def ORB_Flann_Matching():
img1 = cv2.imread('box.png',0) # queryImage
img2 = cv2.imread('box_in_scene.png',0) # trainImage
# Initiate ORB detector
orb = cv2.ORB_create()
kp1, des1 = orb.detectAndCompute(img1,None)
kp2, des2 = orb.detectAndCompute(img2,None)
# FLANN parameters
FLANN_INDEX_LSH = 0
index_params= dict(algorithm = FLANN_INDEX_LSH, table_number = 6, key_size = 12,multi_probe_level = 1)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(np.asarray(des1,np.float32),np.asarray(des2,np.float32), k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]
# ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
plt.imshow(img3,),plt.show()
def SIFT_BF_Matching():
img1 = cv2.imread('box.png',0) # queryImage
img2 = cv2.imread('box_in_scene.png',0) # trainImage
# Initiate SIFT detector
sift = cv2.SIFT()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1,None)
kp2, des2 = sift.detectAndCompute(img2,None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1,des2, k=2)
# Apply ratio test
# 比值测试，首先获得与A距离最近的点B(最近)和点C(次近),只有当B/C小于阈值（0.75）时才被认为是匹配，因为假设匹配是一一对应的，真正的匹配理想距离为0
good = []
for m,n in matches:
if m.distance < 0.75*n.distance:
good.append([m])
# cv2.drawMatchesKnn expects list of lists as matches.
img3 = cv2.drawMatchesKnn(img1, kp1, img2,kp2,good,flags=2)
plt.imshow(img3),plt.show()
def _default_file_(self):
"""
Compute the default value for the field file_
This method runs a pattern recognition between all the chosen patterns
or, if only one is selected, between this one and all the others.
"""
# take active ids
ret = []
active_ids = self.env.context['active_ids']
# avoid templates without pattern
tpl = self.env['sponsorship.correspondence.template'].search(
[('id', 'in', active_ids), ('pattern_image', '!=', None)])
# loop over all the active templates
for t1 in tpl:
# if only one element check with all the other ones
if len(tpl) == 1:
tpl2 = self.env[
'sponsorship.correspondence.template'].search([
('pattern_image', '!=', None)])
# if more, do only the ones not done yet
else:
tpl2 = self.env[
'sponsorship.correspondence.template'].search([
('id', '>=', t1.id), ('pattern_image', '!=', None)])
# create the first pattern image
with tempfile.NamedTemporaryFile() as template_file:
template_file.write(base64.b64decode(
t1.pattern_image))
template_file.flush()
# Find the pattern inside the template image
img = cv2.imread(template_file.name)
# loop over second templates
for t2 in tpl2:
# create the second pattern image
with tempfile.NamedTemporaryFile() as template_file:
template_file.write(base64.b64decode(
t2.pattern_image))
template_file.flush()
# Find the pattern inside the template image
img2 = cv2.imread(template_file.name)
kp1, kp2, good = pr.patternRecognition(img, img2,
full_result=True)
img3 = cv2.drawMatchesKnn(img, kp1, img2,
kp2, good, None, flags=2)
name = t1.name + '-' + t2.name + '.png'
cv2.imwrite(name, img3)
with open(name, 'r') as f:
img3 = f.read()
remove(name)
image_id = self.env['crosscheck.image'].create({
'name': name,
'image': base64.b64encode(img3),
})
ret.append(image_id.id)
return [(6, 0, ret)]
def find_template(img, templates, test=False, threshold=0.8):
"""
Use pattern recognition to detect which template correponds to img.
:param img: Opencv Image to analyze
:param templates: Collection of all templates
:param bool test: Enable the test mode (return an image as the last \
parameter). If False, the image is None.
:param threshold: Ratio of the templates' keypoints requested
:returns: Detected template, center position of detected pattern,\
image showing the detected keypoints for all the template
:rtype: template, layout, None or np.array
"""
# number of keypoint related between the picture and the pattern
max_ratio_keypoints = 0.0
key_img = False
matching_template = None
if test:
test_img = []
else:
test_img = None
for template in templates:
# Crop the image to speedup detection and avoid false positives
crop_area = template.get_pattern_area()
if test:
recognition = patternRecognition(
img, template.pattern_image, crop_area, full_result=True)
with tempfile.NamedTemporaryFile() as temp:
temp.write(base64.b64decode(template.pattern_image))
temp.flush()
img2 = cv2.imread(temp.name)
(xmin, ymin), img1 = subsetImage(img, crop_area)
if recognition is not None:
kp1, kp2, good = recognition
img3 = cv2.drawMatchesKnn(img1, kp1, img2,
kp2, good, None, flags=2)
else:
img3 = img1
test_img.append(img3)
# try to recognize the pattern
tmp_key = patternRecognition(
img, template.pattern_image, crop_area)
# check if it is a better result than before
if (tmp_key is not None and
(threshold < float(len(tmp_key)) / float(
template.nber_keypoints) > max_ratio_keypoints)):
# save all the data if it is better
max_ratio_keypoints = float(
len(tmp_key))/float(template.nber_keypoints)
key_img = tmp_key
matching_template = template
return matching_template, keyPointCenter(key_img), test_img
def calculateSIFTMatch(track, detectedObject):
matcher = cv2.BFMatcher()
if (len(detectedObject.keypoints) > 0) and (len(track.currentKeypoints) > 0):
matches = matcher.knnMatch(track.currentDescriptor, detectedObject.descriptors, k=2)
# Keep a tally of ratio scores
ratio_sum = 0
# Apply Lowe's ratio test to determine a good match
good = []
for match in matches:
if len(match) != 2:
continue
m, n = match
ratio = m.distance / n.distance
if ratio <= RATIO_THRESHOLD:
ratio_sum += RATIO_THRESHOLD / ratio if ratio > 0 else 0.001 # Ratio of n vs. m with respect to RATIO_THRESHOLD
good.append(m)
goodMatches = []
if len(good) > 0:
# Using RANSAC to further improve the matching and eliminate wrong matches
# TODO Sometimes the homography transform results in a bounding box OUTSIDE the destination
src_pts = np.float32([track.currentKeypoints[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)
dst_pts = np.float32([detectedObject.keypoints[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
if mask is not None:
matchesMask = mask.ravel().tolist()
for index, match in enumerate(good):
if matchesMask[index]:
goodMatches.append([match])
if len(goodMatches) > MIN_PTS_THRESHOLD:
match_img = cv2.drawMatchesKnn(track.currentImage, track.currentKeypoints,
detectedObject.image, detectedObject.keypoints,
goodMatches, None, flags=2)
#cv2.imshow(str(track.id), match_img)
#cv2.imwrite(str(frame_number) + "-" + str(track.id) + ".png",match_img)
# TODO What's a better score here?
# If we can find a transform, we should have a very good match
return ratio_sum * (len(goodMatches) + 1)
# This should always be equal to 0
return ratio_sum
# Failure condition -- track or object had no features to match
return -1
def compute_sift_matches(im0g, im1g, y_th=3, good_ratio=0.75, verbose=False):
"""
Compute the SIFT matches given two images
:param im0: first image
:param im1: second image
:param y_th: allowed distance in y-direction of the matches
:param good_ratio: used to filter out low-response keypoints
:return: the sorted good matches (based on response)
"""
if int(cv2.__version__.split('.')[0])<3:
sift = cv2.SIFT(nOctaveLayers=7)
else:
sift = cv2.xfeatures2d.SIFT_create(nOctaveLayers=7)
kp0, des0 = sift.detectAndCompute(im0g, None)
kp1, des1 = sift.detectAndCompute(im1g, None)
bf_matcher = cv2.BFMatcher()
matches = bf_matcher.knnMatch(des0, des1, k=2)
# Apply ratio test
good = []
y_diffs = []
for m, n in matches:
if m.distance < good_ratio * n.distance:
y_diff = kp0[m.queryIdx].pt[1] - kp1[m.trainIdx].pt[1]
if np.abs(y_diff) < y_th:
y_diffs.append(y_diff)
good.append([m])
sorted_good = sorted(good, key=lambda x: kp0[x[0].queryIdx].response, reverse=False)
if verbose:
plt.figure(15)
im3 = cv2.drawKeypoints(im0g, kp0, im0g, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
plt.imshow(im3)
plt.title('im0 keypoints')
plt.pause(0.1)
plt.figure(17)
im4 = cv2.drawKeypoints(im1g, kp1, im1g, flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
plt.imshow(im4)
plt.title('im1 keypoints')
plt.pause(0.1)
im5 = cv2.drawMatchesKnn(im0g, kp0, im1g, kp1, sorted_good, im4, flags=2)
plt.figure(16)
plt.imshow(im5)
plt.title('Found ' + str(len(sorted_good)) )
plt.pause(0.1)
return sorted_good, y_diffs, kp0, kp1
def opencv_feature_match(png1, png2, feature_detector='SIFT', threshold=0.75):
"""Given two images in png format in memory, compare them and return the
number of matches and a third image.
:param feature_detector: "ORB", "FAST", "BRISK"
"""
img1 = opencvify_image(png1)
img2 = opencvify_image(png2)
detector = cv2.FeatureDetector_create(feature_detector)
kp1 = detector.detect(img1, None)
kp2 = detector.detect(img2, None)
sift = cv2.SIFT()
kp1, des1 = sift.compute(img1, kp1)
kp2, des2 = sift.compute(img2, kp2)
# create BFMatcher object
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
log.debug('{} matches found.'.format(len(matches)))
# sort matches in order of distance
matches = sorted(matches, key = lambda x:x.distance)
"""des1 = numpy.asarray(des1, dtype=numpy.float32)
des2 = numpy.asarray(des2, dtype=numpy.float32)
# flann settings
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks = 50)
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)"""
"""bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True) (FOR ORB)"""
good = []
for m,n in matches:
if m.distance < threshold*n.distance:
good.append([m])
log.debug('{} matches were within the threshold.'.format(len(good)))
# draw matches and output to a third image
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, good, flags=2)
return_value, image_analysis_array = cv2.imencode('.png', img3)
"""output = open('test.png', 'w')
output.write(image_analysis_array.tostring())
output.close()"""
return (len(matches), image_analysis_array.tostring())
def facialRecognition():
try:
img1 = cv2.VideoCapture(0)
img2 = cv2.imread("me.jpg",0)
# Initiate SIFT detector
sift = cv2.SIFT()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1,None)
kp2, des2 = sift.detectAndCompute(img2,None)
# FLANN parameters
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params,search_params)
matches = flann.knnMatch(des1,des2,k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]
# ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
plt.imshow(img3,),plt.show()
except KeyboardInterrupt:
toDo = raw_input("-"*45+"\n\n[Notice] | Script Paused...\n>" + "---"*13 + "<\n> Main Menu-------------(1)" + "\n> Continue Script-------(Any Other Key)\n>" + "---"*13 + "<\n\n> ")
if "1" in toDo:
cv2.destroyAllWindows()
main()
else:
pass
except Exception,e:
if "something@R" in str(e):
print "[Error] | Something Happaned."
else:
raw_input("[Error] | > " + str(e))
cv2.destroyAllWindows()
main()
def matchObjectTrack(detectedObject, track, matcher, MIN_PTS_THRESHOLD, frame_number):
if (len(detectedObject.keypoints) > 0) and (len(track.currentKeypoints) > 0):
matches = matcher.knnMatch(track.currentDescriptor, detectedObject.descriptors, k=2)
# Apply Lowe's ratio test to determine a good match
good = []
for match in matches:
if len(match) != 2:
continue
m, n = match
if m.distance <= RATIO_THRESHOLD * n.distance:
good.append(m)
goodMatches = []
if len(good) > 0:
# Using RANSAC to further improve the matching and eliminate wrong matches
src_pts = np.float32([track.currentKeypoints[m.queryIdx].pt for m in good]).reshape(-1, 1, 2)
dst_pts = np.float32([detectedObject.keypoints[m.trainIdx].pt for m in good]).reshape(-1, 1, 2)
mask = []
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
if mask is not None:
matchesMask = mask.ravel().tolist()
index = 0
# print len(good)
# print mask.shape
for match in good:
# print match
m = match
# print index
# print len(matchesMask)
if matchesMask[index]:
goodMatches.append([m])
index += 1
if len(goodMatches) > MIN_PTS_THRESHOLD:
match_img = cv2.drawMatchesKnn(
track.currentImage,
track.currentKeypoints,
detectedObject.image,
detectedObject.keypoints,
goodMatches,
None,
flags=2,
)
# cv2.imshow(str(track.id), match_img)
# cv2.imwrite(str(frame_number) + "-" + str(track.id) + ".png",match_img)
return True
return False
def create_panorama(self):
# initialize a surf detector with hessian as 400
surf = self.surf(400)
imgOne = cv2.imread(self.images[0])
imgTwo = cv2.imread(self.images[1])
grayOne = self.cvt_gray(imgOne)
grayTwo = self.cvt_gray(imgTwo)
# extract the keypoinst and descriptors for individaul images
kpOne, desOne = surf.detectAndCompute(grayOne, None)
kpTwo, desTwo = surf.detectAndCompute(grayTwo, None)
imgOneU = cv2.drawKeypoints(imgOne, kpOne, None, (0, 127,
0),
4)
imgTwoU = cv2.drawKeypoints(imgTwo, kpTwo, None, (0, 127,
0),
4)
# initialize flann matcher
flann = self.flann()
matches = flann.knnMatch(np.array(desOne), np.array(desTwo),
k=2)
# store all the good matches
good = []
for m, n in matches:
if m.distance < 0.7 * n.distance:
good.append(m)
src_pts = np.float32([kpOne[m.queryIdx].pt for m in good])
dst_pts = np.float32([kpTwo[m.trainIdx].pt for m in good])
M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,
5.0)
im_out = cv2.warpPerspective(imgOne, M, (
imgOne.shape[1] + imgTwo.shape[1],
imgOne.shape[0]))
im_out[0:imgTwo.shape[0], 0:imgTwo.shape[1]] = imgTwo
self.plot_img(self.m, self.n, imgOneU, "Keypoints 1")
self.plot_img(self.m, self.n, imgTwoU, "Keypoints 2")
img3 = cv2.drawMatchesKnn(imgOne, kpOne, imgTwo, kpTwo,
matches[:100], None,
matchColor=(0, 127, 255), flags=2)
self.plot_img(self.m, self.n, img3, "Matching Keypoints")
self.plot_img(self.m, self.n, im_out, "Panorama")
self.show_plot()
def function7():
img1 = cv2.imread('../a3.jpg',0)
img2 = cv2.imread('../a1.jpg',0)
sift = cv2.xfeatures2d.SIFT_create()
kypnt1, desc1 = sift.detectAndCompute(img1,None)
kypnt2, desc2 = sift.detectAndCompute(img2,None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(desc1,desc2, k=2)
good = []
for m,n in matches:
if m.distance < 0.75*n.distance:
good.append([m])
img3 = cv2.drawMatchesKnn(img1,kypnt1,img2,kypnt2,good,None,flags=2)
plt.imshow(img3)
plt.show()
def show_match(im_kp, image, raw_matches, ref_kp, reference_form_path):
reference = cv2.imread(reference_form_path, 0)
img_match = np.empty((max(reference.shape[0], image.shape[0]), reference.shape[1] + image.shape[1], 3),
dtype=np.uint8)
good = []
for m, n in raw_matches:
if m.distance < 0.75 * n.distance:
good.append([m])
# img3 = cv2.drawMatchesKnn(image, im_kp, reference, ref_kp, matches, None, **draw_params)
im_matches = cv2.drawMatchesKnn(image, im_kp, reference, ref_kp, good, outImg=img_match, matchColor=None,
singlePointColor=(255, 255, 255), flags=2)
factor = 0.5
im_matches_small = cv2.resize(im_matches, None, fx=factor, fy=factor)
cv2.imshow("match", im_matches_small)
cv2.waitKey(0)
def renderMatch(img1, kp1, img2, kp2, matches):
matchesMask = [[0,0] for i in xrange(len(matches))]
for i,x in enumerate(matches):
# print i, type(x), len(x)
# print
if x[0].distance < 0.75*x[1].distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
cv2.imwrite('test.JPG',img3)
plt.imshow(img3,),plt.show()
def getMatches(des1, des2, kp1=None, kp2=None, img1=None, img2=None, count=100, threshold=0.5):
'''
@param: descriptor, des1 -- queryIdx, des2 -- trainIdx
return: list of tuple as (queryIdx, trainIdx)
'''
# kp1, des1 = fE.getDescriptor(fid1,nfea=nfeatures)
# kp2, des2 = fE.getDescriptor(fid2,nfea=nfeatures)
# FLANN parameters
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks=50) # or pass empty dictionary
# flann = cv2.FlannBasedMatcher(index_params,search_params)
# matches = flann.knnMatch(des1,des2,k=2)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1,des2, k=2)
# print "Num of all matches are %d"%len(matches)
final_matches = []
# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]
# ratio test as per Lowe's paper
ratio = threshold
matches.sort(key=lambda m: m[0].distance)
for i,(m,n) in enumerate(matches):
if m.distance < ratio*n.distance:
matchesMask[i]=[1,0]
final_matches.append(m)
if (len(final_matches) > count):
break
if (kp1 is None):
return final_matches
for m in final_matches:
print m.distance
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
plt.imshow(img3),plt.show()
return final_matches
def flann_matcher(source1, source2):
"""
Question 1.3
Trace les mises en correspondance des caractéristiques de deux images selon la méthode de "Brute Force"
Problèmes sur Ubuntu et Mac, OpenCV 3.1.0. Il semblerait que ce soit un bug lié à OpenCV
https://github.com/Itseez/opencv/issues/5667
Parameters
----------
source1: la source de l'image de gauche
source2: la source de l'image de droite
"""
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(source1, None)
kp2, des2 = sift.detectAndCompute(source2, None)
# FLANN parameters
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0, 0] for i in xrange(len(matches))]
# ratio test as per Lowe's paper
for i, (m, n) in enumerate(matches):
if m.distance < 0.7 * n.distance:
matchesMask[i] = [1, 0]
draw_params = dict(matchColor=(0, 255, 0),
singlePointColor=(255, 0, 0),
matchesMask=matchesMask,
flags=0)
img3 = cv2.drawMatchesKnn(source1, kp1, source2, kp2, matches, None, **draw_params)
plt.imshow(img3, ), plt.show()
def book_opt_flow(n_stills):
for i in range(2, n_stills + 1):
#Loading images
img1 = cv2.imread('Motion_Image' + str(i-1) + '.png')
img2 = cv2.imread('Motion_Image' + str(i) + '.png')
#Detect keypoints in the left and right images
ffd = cv2.FastFeatureDetector_create()
left_kpts = ffd.detect(img1, None)
right_kpts = ffd.detect(img2,None)
left_pts = cv2.KeyPoint_convert(left_kpts)
#in the C++ code they establish an empty array here for right pts
prevgray = cv2.cvtColor(img1,cv2.COLOR_RGB2GRAY)
gray = cv2.cvtColor(img2,cv2.COLOR_RGB2GRAY)
right_pts, vstatus, verror = cv2.calcOpticalFlowPyrLK(prevgray, gray, left_pts, None)
right_points_to_find = np.array([])
right_points_to_find_back_index = np.array([])
right_features = np.array([])
for i in range(0,len(vstatus)):
if vstatus[i] and verror[i] < 12.0:
right_points_to_find_back_index = np.append(right_points_to_find_back_index, i)
right_points_to_find = np.append(right_points_to_find, right_pts[i])
else:
vstatus[i] = 0
right_features = np.append(right_features, cv2.KeyPoint_convert(right_kpts))
bf = cv2.BFMatcher()
# print type(right_points_to_find[0]), type(right_features[0])
matches = bf.knnMatch(right_points_to_find.astype('float32'),right_features.astype('float32'),k=2)
nearest_neighbors = []
for m,n in matches:
if m.distance < 0.7*n.distance:
nearest_neighbors.append([m])
img3 = cv2.drawMatchesKnn(img1,right_kpts,prevgray,left_kpts,nearest_neighbors,flags=2, outImg=None)
plt.imshow(img3),plt.show(
)
def sign_detect(matches, case, face, kp_case, kp, frame):
matchesMask = [[0,0] for i in range(len(matches))]
is_detected = 0
match_points = []
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
match_points.append([kp[m.trainIdx].pt[0],kp[m.trainIdx].pt[1]])
is_detected += 1
if Z_DEBUG:
draw_params = dict(matchColor = (0,0,255),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img_show = cv2.drawMatchesKnn(face,kp_case,frame,kp,matches,None,**draw_params)
#reject repeated points
if len(match_points) >=2:
match_points = np.unique(match_points, axis=0)
#reject outliers
if len(match_points) >= DETECT_POINT_THRESHOLD:
sd_x = 1.7
sd_y = 1.7
match_points = reject_outliers(match_points,sd_x,sd_y)
is_detected = len(match_points)
if Z_DEBUG:
for [x,y] in match_points:
cv2.circle(frame,(int(x),int(y)),4,(255,0,0),4)
print(case + " : " + str(is_detected))
cv2.imshow(case,img_show)
cv2.imshow(case + ' ',frame)
#buffer
PARKING_BUFFER[0:BUFFER_SIZE-1] = PARKING_BUFFER[1:BUFFER_SIZE]
PARKING_BUFFER[BUFFER_SIZE-1] = is_detected
if np.size(np.where(PARKING_BUFFER>=DETECT_POINT_THRESHOLD)) >= DETECT_THRESHOLD:
print("parking detected!")
'''
def feature_matching(img1, img2, savefig=False):
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
# FLANN parameters
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches2to1 = flann.knnMatch(des2, des1, k=2)
matchesMask_ratio = [[0, 0] for i in xrange(len(matches2to1))]
match_dict = {}
for i, (m, n) in enumerate(matches2to1):
if m.distance < 0.7 * n.distance:
matchesMask_ratio[i] = [1, 0]
match_dict[m.trainIdx] = m.queryIdx
good = []
recip_matches = flann.knnMatch(des1, des2, k=2)
matchesMask_ratio_recip = [[0, 0] for i in xrange(len(recip_matches))]
for i, (m, n) in enumerate(recip_matches):
if m.distance < 0.7 * n.distance: # ratio
if m.queryIdx in match_dict and match_dict[m.
queryIdx] == m.trainIdx: #reciprocal
good.append(m)
matchesMask_ratio_recip[i] = [1, 0]
if savefig:
draw_params = dict(
matchColor=(0, 255, 0),
singlePointColor=(255, 0, 0),
matchesMask=matchesMask_ratio_recip,
flags=0)
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, recip_matches, None,
**draw_params)
plt.figure(), plt.xticks([]), plt.yticks([])
plt.imshow(img3,)
plt.savefig("feature_matching.png", bbox_inches='tight')
return ([kp1[m.queryIdx].pt
for m in good], [kp2[m.trainIdx].pt for m in good])
def surf_matching(image_1,image_2):
# Load the images
image = cv2.imread('{}'.format(image_1))
# Convert the images to grayscale
gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Surf extration
surf = cv2.xfeatures2d.SURF_create(10000)
(kp1, desc1) = surf.detectAndCompute(gray_img, None)
# Setting up samples and responses for KNN
samples = np.array(desc1)
responses = np.arange(len(kp1), dtype = np.float32)
# KNN training
knn = cv2.ml.KNearest_create()
knn.train(samples,cv2.ml.ROW_SAMPLE, responses)
# Loading a template image and searching for similar keypoints
template = cv2.imread('{}'.format(image_2))
templateg = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
(kp2, desc2) = surf.detectAndCompute(templateg, None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(desc1,desc2, k=2)
matchesMask = [[0,0] for i in range(len(matches))]
# ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
# cv2.drawMatchesKnn expects list of lists as matches.
img3 = cv2.drawMatchesKnn(gray_img,kp1,template,kp2,matches,None,**draw_params)
plt.imshow(img3),plt.show
def display_matches(text1: str, text2: str, fontsize: int = 64) -> None:
img1 = create_image(text1, fontsize)
img2 = create_image(text2, fontsize)
sift = cv2.xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(img1,None)
print(len(kp1))
kp2, des2 = sift.detectAndCompute(img2,None)
img = np.array([])
img=cv2.drawKeypoints(img1,kp1,img)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1,des2, k=2)
good = []
for m,n in matches:
if m.distance < 100:
good.append([m])
img3 = np.array([])
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good,img3,flags=2)
plt.imshow(img3),plt.show()
def surf():
surf = cv2.xfeatures2d.SURF_create(400)
imgleft = cv2.imread('left_small.jpg',1) #256x256?
imgleft = cv2.GaussianBlur( imgleft, (5, 5), 0 )
imgleft = cv2.cvtColor(imgleft,cv2.COLOR_BGR2GRAY)
kp1, des1 = surf.detectAndCompute(imgleft,None)
image = frame.array
image = cv2.GaussianBlur( image, (5, 5), 0 )
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
# surf.upright = True
kp2, des2 = surf.detectAndCompute(image,None)
FLANN_INDEX_KDTREE = 0
# index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
# search_params = dict(checks=50) # or pass empty dictionary
# flann = cv2.FlannBasedMatcher(index_params,search_params)
# matches = flann.knnMatch(des1,des2,k=2)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]
# ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv2.drawMatchesKnn(imgleft,kp1,image,kp2,matches,None,**draw_params)
return img3
def do_feature_matching(img1, img2, detector, matcher):
gray_img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
gray_img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
keypoints_img1, descriptors_img1 = detector.detectAndCompute(gray_img1, None)
keypoints_img2, descriptors_img2 = detector.detectAndCompute(gray_img2, None)
cv2.imshow('img1', cv2.drawKeypoints(img1, keypoints_img1, None))
cv2.imshow('img2', cv2.drawKeypoints(img2, keypoints_img2, None))
matches = matcher.knnMatch(descriptors_img1, descriptors_img2, 2)
good = []
for m, n in matches:
if m.distance < 0.8 * n.distance:
good.append([m])
out_img = cv2.drawMatchesKnn(gray_img1, keypoints_img1, gray_img2, keypoints_img2, good, None, flags=2)
cv2.imshow('img', out_img)
cv2.waitKey()
def main():
stream=urllib.urlopen(CAM_URL)
bytes=''
ts=time.time()
while True:
bytes+=stream.read(2048)
a = bytes.find('\xff\xd8')
b = bytes.find('\xff\xd9')
if a==-1 or b==-1:
continue
# Frame available
rtimestamp=time.time()
jpg = bytes[a:b+2]
bytes= bytes[b+2:]
img = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.IMREAD_COLOR)
cv2.imshow('RAW',img)
#ORB to get corresponding points
kp, des = sift.detectAndCompute(img,None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des_ref,des,k=2)
m = []
for ma,na in matches:
if ma.distance < 0.75*na.distance:
m.append([ma])
img3 = cv2.drawMatchesKnn(img_ref,kp_ref,img,kp,m[:4], None,flags=2)
cv2.imshow('MatchesKnn',img3)
#pts_ref = np.float32([[kp_ref[m[0].queryIdx].pt[0],kp_ref[m[0].queryIdx].pt[1]],[kp_ref[m[1].queryIdx].pt[0],kp_ref[m[1].queryIdx].pt[1]],[kp_ref[m[2].queryIdx].pt[0],kp_ref[m[2].queryIdx].pt[1]],[kp_ref[m[3].queryIdx].pt[0],kp_ref[m[3].queryIdx].pt[1]]])
#pts = np.float32([[kp[m[0].trainIdx].pt[0],kp[m[0].trainIdx].pt[1]],[kp[m[1].trainIdx].pt[0],kp[m[1].trainIdx].pt[1]],[kp[m[2].trainIdx].pt[0],kp[m[2].trainIdx].pt[1]],[kp[m[3].trainIdx].pt[0],kp[m[3].trainIdx].pt[1]]])
# Perspective Transform
#M = cv2.getPerspectiveTransform(pts_ref,pts)
#dst = cv2.warpPerspective(img,M,(cols,rows))
#cv2.imshow('Perspective Transform',dst)
# Print lag
print(time.time()-ts)
ts=time.time()
if cv2.waitKey(1) == 27:
exit(0)
4.4 Set previous image to present
4.5 Save snapshot (Optional)
4.6 Alert if same_position_feature_count is more than config and save snapshot
4.7 (Optional) Save image for keypoint found
4.8 Clearing value for next frame
"""
# 4.1 Copy image frame to use
compared_feature_image = np.array(image_frame)
new_feature_detected_image = np.array(image_compare_model)
"""Show matches via feature list"""
# 4.2 Show newly found feature in present frame
try:
new_feature_detected_image = cv.drawMatchesKnn(img, kpSift, image_crop, present_kp, model_good_feature_list, image_compare_model,
singlePointColor = (255,0,0), matchColor = (0,255,0), flags=2)
cv.imshow("New feature detected", new_feature_detected_image)
except Exception as e:
print('error here model image', e)
error_log.append('error here model image' + str(e))
if present_good_feature_list == []:
print(' present_good_feature_list = null but nothing to worry')
# 4.3 Show feature from previous frame
try:
compared_feature_image = cv.drawMatchesKnn(img, kpSift, image_crop, present_kp, present_good_feature_list, image_frame,
singlePointColor = (255,0,0), matchColor = (0,255,255), flags=2)
cv.imshow("Tracking previous feature", compared_feature_image)
def FLANN():
connectdb = sqlite3.connect("results.db")
cursor = connectdb.cursor()
# img1 = cv2.imread("1.png")
# img11 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
img1 = cv2.imread('1.png', cv2.IMREAD_GRAYSCALE)
imageA = cv2.resize(img1, (450, 237))
database = os.listdir("db")
for image in database:
try:
img2 = cv2.imread("db/" + image)
imgprocess = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
imageB = cv2.resize(imgprocess, (450, 237))
matcheslist = ""
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(imageA, None)
kp2, des2 = sift.detectAndCompute(imageB, None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Apply ratio test
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append([m])
# cv.drawMatchesKnn expects list of lists as matches.
amount = len(good)
print('Comparing input image to ' + image + " using FLANN")
title = "Comparing"
fig = plt.figure(title)
cursor.execute(
"INSERT INTO flann (percentage, filename) VALUES (?, ?);",
(amount, image))
connectdb.commit()
except:
pass
percentages = list(connectdb.cursor().execute(
"SELECT * FROM flann order by percentage desc limit 10"))
print(percentages[0])
highest = percentages[0]
# getting number of matches
highestperct = round(highest[0], 2)
print(highestperct)
# getting file name of highest similarity
filename = highest[1]
print(filename)
image1 = cv2.imread('1.png', cv2.IMREAD_GRAYSCALE) # input image
img1 = cv2.resize(image1, (450, 237))
image2 = cv2.imread('db/' + filename,
cv2.IMREAD_GRAYSCALE) # closet image
img2 = cv2.resize(image2, (450, 237))
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
keypoints1, destination1 = sift.detectAndCompute(img1, None)
keypoints2, destination2 = sift.detectAndCompute(img2, None)
# FLANN parameters
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(destination1, destination2, k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0, 0] for i in range(len(matches))]
# ratio test as per Lowe's paper
for i, (m, n) in enumerate(matches):
if m.distance < 0.7 * n.distance:
matchesMask[i] = [1, 0]
draw_params = dict(matchColor=(0, 255, 0),
singlePointColor=(255, 0, 0),
matchesMask=matchesMask,
flags=cv2.DrawMatchesFlags_DEFAULT)
print(draw_params)
print(len(matches))
img3 = cv2.drawMatchesKnn(img1, keypoints1, img2, keypoints1,
matches, None, **draw_params)
plt.imshow(img3)
plt.suptitle("Amount of matches : " + str(highestperct) +
"\n Similarity Percentage : " + str(percent) + "%")
disease = filename[:7]
txt = "Results: \n - " + filename + "\n - " + disease + "\n - Analysis results are safe, no diseases found"
plt.text(0.40, 0.20, txt, transform=fig.transFigure, size=11)
plt.axis("off")
plt.show()
cursor.execute("DELETE FROM flann")
connectdb.commit()
import cv2
import numpy as np
import matplotlib.pyplot as plt
#%matplotlib inline
hacker = cv2.imread('./TCIA_pancreas_labels/label0011/000011-101.jpg', 0)
items = cv2.imread('./Pancreas-CT/PANCREAS_0011/000011-101.jpg', 0)
sift = cv2.xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(hacker, None)
kp2, des2 = sift.detectAndCompute(items, None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
good = []
for match1, match2 in matches:
if match1.distance < 0.75 * match2.distance:
good.append([match1])
sift_matches = cv2.drawMatchesKnn(hacker, kp1, items, kp2, good, None, flags=2)
display(sift_matches)
scr_pts = np.float32([keypoints1[m.queryIdx].pt
for m in good]).reshape(-1, 1, 2)
dst_pts = np.float32([keypoints2[m.trainIdx].pt
for m in good]).reshape(-1, 1, 2)
#Computamos la homografía con RANSAC
H, mask = cv2.findHomography(dst_pts, scr_pts, cv2.RANSAC, 5.0)
else:
print('No existen suficientes matchs')
#Aplicamos la transformación perspectiva H a la imagen 2
imgTrans = cv2.warpPerspective(img2, H, (600, 800))
#Mezclamos ambas imágenes
alpha = 0.5
blend = np.array(
imgTrans * alpha + img1 * (1 - alpha), dtype=np.uint8
) #Se mezclan las imágenes, en las zonas de coincidencia aumenta el brillo un 50%, en cambio, en las zonas de no coincidencia, el brillo baja un 50%.
img3 = cv2.drawMatchesKnn(
img1, keypoints1, img2, keypoints2, matches[:10], None, flags=0
) #La función cv2.drawMatchesKnn() nos ayuda a dibujar las coincidencias. Apila dos imágenes horizontalmente y dibuja líneas desde la primera imagen a la segunda, mostrando todas las k mejores coincidencias. Si k = 2, dibujará dos líneas de coincidencia para cada punto clave. Entonces tenemos que pasar una máscara si queremos dibujarla selectivamente.
#Mostramos los resultados obtenidos
cv2.imshow('Imagen 1', img1)
cv2.imshow('Imagen 2', img2)
cv2.imshow('Perspectiva', imgTrans)
cv2.imshow('Combinacion de imagenes', blend)
cv2.imshow('Matches', img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
# Initialize matches
flann = cv.FlannBasedMatcher(index_params, search_params)
# Find matches
matches = flann.knnMatch(des1, des2, k=2)
# Flags:
# cv.DRAW_MATCHES_FLAGS_DEFAULT
# cv.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG
# cv.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS
# cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
img3 = cv.drawMatchesKnn(
img1,
kp1,
img2,
kp2,
matches[:10],
None,
flags=cv.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS,
)
# Draw matches
cv.namedWindow("BRIEF BF Matcher", cv.WINDOW_NORMAL)
cv.imshow("BRIEF BF Matcher", img3)
# Calculate homography
# Consider point filtering
obj = []
scene = []
for match in matches:
# Consider testing match[0].distance to match[1].distance
matrix, mask = cv.findHomography(pts2, pts1, cv.RANSAC, 5.0)
return matrix
def image_stitch(image1, image2, homography):
image = cv.warpPerspective(image2, homography, (image2.shape[1] * 2, image2.shape[0]))
image[0:image1.shape[0], 0:image1.shape[1]] = image1
return image
if __name__ == '__main__':
# Load two images
img1 = cv.imread('data/qh1.jpg')
img2 = cv.imread('data/qh2.jpg')
# Find keypoints
keypoints1, descripters1 = keypoints_detect(img1)
keypoints2, descripters2 = keypoints_detect(img2)
# Calculate homography
matches = match(descripters1, descripters2)
M = homography(keypoints1, keypoints2, matches)
# Stitch images
img3 = image_stitch(img1, img2, M)
# Show Matches
img_match = cv.drawMatchesKnn(img1, keypoints1, img2, keypoints2,
matches[:50], outImg=np.array([]))
show([img_match, img3])
def drawMatches(self, setting, algorithm, crossCheck, file):
det = Detector(algorithm, crossCheck)
with open(file, "r") as json_file:
data = json.load(json_file)
for x in data:
if (x == "SOX14HET_131218_TiledIMGLeftThalamus_Slide18_Cropped.tif"
):
confocalDescriptor, confocalKeypoint, img1 = det.otherFunction(
False, (self.confocalFilePath + x), 20, setting) #
for y in data[x]:
print(y)
tissueCyteDescriptor, tissueCyteKeypoint, img2 = self.masker.otherFunction(
self.tissueCyteFilePath, setting, algorithm,
crossCheck, y[0]) #
if (algorithm != "orb"):
confocalDescriptor = np.asarray(
confocalDescriptor, np.float32)
tissueCyteDescriptor = np.asarray(
tissueCyteDescriptor, np.float32)
else:
confocalDescriptor = np.asarray(
confocalDescriptor, np.uint8)
tissueCyteDescriptor = np.asarray(
tissueCyteDescriptor, np.uint8)
if (algorithm == "sift"):
tissueCyteDescriptor = np.reshape(
tissueCyteDescriptor, (-1, 128))
confocalDescriptor = np.reshape(
confocalDescriptor, (-1, 128))
elif (algorithm == "surf"):
tissueCyteDescriptor = np.reshape(
tissueCyteDescriptor, (-1, 64))
confocalDescriptor = np.reshape(
confocalDescriptor, (-1, 64))
elif (algorithm == "orb"):
tissueCyteDescriptor = np.reshape(
tissueCyteDescriptor, (-1, 32))
confocalDescriptor = np.reshape(
confocalDescriptor, (-1, 32))
matches = det.otherMatchingFunction(
confocalDescriptor, tissueCyteDescriptor)
print(len(matches))
_, fileName = os.path.split(file)
if (crossCheck != True):
img3 = cv.drawMatchesKnn(img1,
confocalKeypoint,
img2,
tissueCyteKeypoint,
matches,
None,
flags=2)
else:
img3 = cv.drawMatches(img1,
confocalKeypoint,
img2,
tissueCyteKeypoint,
matches,
None,
flags=2)
cv.imwrite((
'/mnt/TissueCyte80TB/Marcus_ImageMatching/DrawMatches/'
+ fileName + '_' + y[0] + '_' + x + '_' +
'MatchesImage.jpg'), img3)
kp2, des2 = sift.detectAndCompute(img2_gray, None)
# 设置算法运行开始时间
# 4) Flann特征匹配
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# print(matches)
goodMatch = []
# 匹配优化
for m, n in matches:
if m.distance < 0.50 * n.distance:
goodMatch.append(m)
# 增加一个维度
goodMatch = np.expand_dims(goodMatch, 1)
flann_img_out = cv2.drawMatchesKnn(img1_rectified,
kp1,
img2_rectified,
kp2,
goodMatch,
None,
flags=2)
flann_time = (time.time() - start)
print("flann_time:", '% 4f' % (flann_time * 1000))
cv2.imshow('SIFT_match', flann_img_out) #展示图片
cv2.waitKey(0) #等待按键按下
cv2.destroyAllWindows() #清除所有窗口
if m.distance < 0.75 * n.distance:
good.append([m])
good_arr[i - 1] = good
num_match[i - 1] = len(good)
temp = num_match
print(num_match)
max_match = max(temp)
print(max_match)
indx = num_match.index(max_match)
print(indx)
#Draw first best matches.
img3 = cv2.drawMatchesKnn(query,
kp1,
img[indx],
kp2[indx],
good_arr[indx],
None,
flags=2)
'''if indx==0:
servomotor1()
if indx==1:
servomotor2()
if indx=2
servomotor3()
if indx=3
servomotor4()
'''
#plt.imshow(img3),plt.show()
#cv2.imwrite('ploting',img3)
cv2.imshow('image', img3)
match = cv2.BFMatcher()
matches = match.knnMatch(desr,desl,k=2)
print(matches)
good=[]
not_good = []
for m,n in matches:
if(m.distance < 0.75 * n.distance):
good.append([m])
else:
not_good.append(m)
draw_param = dict(matchColor = (0,255,0),flags=2)
img3 =cv2.drawMatchesKnn(imageRight,kpr,imageLeft,kpl,good,None,**draw_param)
#img4 =cv2.drawMatches(imageLeft,kpl,imageRight,kpr,matches,None,**draw_param)
cv2.imshow("Wow", img3)
def trim(frame):
#crop top
if not np.sum(frame[0]):
return trim(frame[1:])
#crop bottom
elif not np.sum(frame[-1]):
return trim(frame[:-2])
#crop left
elif not np.sum(frame[:,0]):
return trim(frame[:,1:])
image1_keypoint = cv2.drawKeypoints(image1,keypoint1,None)
image2_keypoint = cv2.drawKeypoints(image2,keypoint2,None)
# BFMatcher with default params
burteforce_matcher= cv2.BFMatcher()
total_matches = burteforce_matcher.knnMatch(d1,d2, k=2)
# Apply ratio test
good_points = []
for m,n in total_matches:
if m.distance < 0.75*n.distance:
good_points.append([m])
# cv2.drawMatchesKnn expects list of lists as matches.
image_knn = cv2.drawMatchesKnn(image1,keypoint1,image2,keypoint2,good_points,None,flags=2)
cv2.imwrite("task2_sift1.png", image1_keypoint)
cv2.imwrite("task2_sift2.png", image2_keypoint)
cv2.imwrite("task2_matches_knn.jpg",image_knn)
#task2 part3 selecting inlier matche pairs and computing epiline
# FLANN parameters
FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks=50)
flann = cv2.FlannBasedMatcher(index_params,search_params)
total_matches = flann.knnMatch(d1,d2,k=2)
points_good = []
import numpy as np
import cv2
from matplotlib import pyplot as plt
if __name__ == '__main__':
img1 = cv2.imread('../images/manowar_logo.png', 0)
img2 = cv2.imread('../images/manowar_single.jpg', 0)
orb = cv2.ORB_create()
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
img3 = cv2.drawMatches(img1, kp1, img2, kp2, matches[:25], img2, flags=2)
plt.figure(12)
plt.subplot(1, 2, 1)
plt.imshow(img3)
matches2 = bf.knnMatch(des1, des2, k=1)
img4 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, matches2, img2, flags=2)
plt.subplot(1, 2, 2)
plt.imshow(img4)
plt.show()
#to show only best matches, a mask is created
matchesMask = [[0,0] for i in xrange(len(matches))]
for i, (m,n) in enumerate(matches):
if m.distance < 0.9 * n.distance:
matchesMask[i] = [1,0]
#dictionary that describes drawing details when the result is displayed
draw_params = dict(matchColor = (0, 0, 255), singlePointColor = (255,0,0), matchesMask = matchesMask, flags = 0)
#creates final image
final = cv2.drawMatchesKnn(source, kp1, train, kp2, matches, final, **draw_params)
#cv2.imwrite("/Users/student_mac1/Desktop/matchoctagon2.jpeg", final)
#displays result
cv2.namedWindow("final", cv2.WINDOW_NORMAL)
cv2.imshow("final", final)
cv2.waitKey(0)
'''
mylist = [[5,4,7],[6,9,3],[6,3,8]]
for i,j,k in mylist:
print i
print j
for i,(m,n) in enumerate(matches3):
if m.distance < 0.7*n.distance:
matchesMask3[i]=[1,0]
draw_params1 = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask1 = matchesMask1,
flags = 0)
draw_params2 = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask2 = matchesMask2,
flags = 0)
draw_params3 = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask3 = matchesMask3,
flags = 0)
img5 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params1)
img6 = cv2.drawMatchesKnn(img1,kp1,img3,kp3,matches,None,**draw_params2)
img7 = cv2.drawMatchesKnn(img1,kp1,img4,kp4,matches,None,**draw_params3)
cv2.imshow('reference Image', img1)
cv2. waitKey()
plt.imshow(img5,),plt.show()
plt.imshow(img6,),plt.show()
plt.imshow(img7,),plt.show()
import numpy as np
import cv2
from matplotlib import pyplot as plt
img1 = cv2.imread('test_field.JPG',0) # queryImage
img2 = cv2.imread('star.PNG',0) # trainImage
# Initiate SIFT detector
sift = cv2.SIFT()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1,None)
kp2, des2 = sift.detectAndCompute(img2,None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1,des2, k=2)
# Apply ratio test
good = []
for m,n in matches:
if m.distance < 0.75*n.distance:
good.append([m])
# cv2.drawMatchesKnn expects list of lists as matches.
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,good,flags=2)
plt.imshow(img3)
def attach_homo(left_image, right_image):
left_image = np.array(left_image)
right_image = np.array(right_image)
# cv.imshow('src',left_image)
# cv.imshow('warp',right_image)
top, bot, left, right = 100, 100, 150, 150
srcImg = cv.copyMakeBorder(left_image,
top,
bot,
left,
right,
cv.BORDER_CONSTANT,
value=(0, 0, 0))
testImg = cv.copyMakeBorder(right_image,
top,
bot,
left,
right,
cv.BORDER_CONSTANT,
value=(0, 0, 0))
img1gray = cv.cvtColor(srcImg, cv.COLOR_BGR2GRAY)
img2gray = cv.cvtColor(testImg, cv.COLOR_BGR2GRAY)
img1gray = downsample_image(img1gray, 1)
img2gray = downsample_image(img2gray, 1)
sift = cv.xfeatures2d_SIFT().create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1gray, None)
kp2, des2 = sift.detectAndCompute(img2gray, None)
# FLANN parameters
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50)
flann = cv.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0, 0] for i in range(len(matches))]
good = []
pts1 = []
pts2 = []
# ratio test as per Lowe's paper
for i, (m, n) in enumerate(matches):
if m.distance < 0.5 * n.distance:
good.append(m)
pts2.append(kp2[m.trainIdx].pt)
pts1.append(kp1[m.queryIdx].pt)
matchesMask[i] = [1, 0]
draw_params = dict(matchColor=(0, 255, 0),
singlePointColor=(255, 0, 0),
matchesMask=matchesMask,
flags=0)
# print(matches)
img3 = cv.drawMatchesKnn(img1gray, kp1, img2gray, kp2, matches, None,
**draw_params)
# cv.imshow('drawmatch',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 = cv.findHomography(src_pts, dst_pts, cv.RANSAC, 5.0)
print(M)
np.save("zed_M", M)
def transform(videopath):
cap = cv2.VideoCapture(videopath)
n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
_, prev = cap.read()
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
# fourcc = cv2.VideoWriter_fourcc('I', '4', '2', '0')
fourcc = cv2.VideoWriter_fourcc('I', '4', '2',
'0') # （'I','4','2','0' 对应avi格式）
path2 = videopath[:-4] + "_S" + ".avi"
out = cv2.VideoWriter(path2, fourcc, 25, (w, h))
# Convert frame to grayscale
img1 = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
# Pre-define transformation-store array
transforms = np.zeros((n_frames - 1, 3), np.float32)
# scaleX_list = np.zeros((n_frames - 1, 1), np.float32)
# scaleY_list = np.zeros((n_frames - 1, 1), np.float32)
pose_matrixs = np.zeros((n_frames - 1, 3, 3), np.float32)
# transforms = []
# scaleY_list = []
# scaleX_list = []
for j in range(n_frames - 2):
success, img2 = cap.read()
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
if not success:
break
orb = cv.ORB_create(nlevels=8)
kp1 = orb.detect(img1, None)
# compute the descriptors with ORB
kp1, des1 = orb.compute(img1, kp1)
kp2 = orb.detect(img2, None)
# compute the descriptors with ORB
kp2, des2 = orb.compute(img2, kp2)
# get the LUT of pos For 2 imgs
LUT_queryImg1 = []
LUT_trainImg2 = []
for i, n in enumerate(kp1):
LUT_queryImg1.append((i, n.pt))
LUT_queryImg1 = dict(LUT_queryImg1)
# print('\nQUERY LUT', LUT_queryImg1)
for i, n in enumerate(kp2):
LUT_trainImg2.append((i, n.pt))
LUT_trainImg2 = dict(LUT_trainImg2)
# print('\nTRAIN LUT', LUT_trainImg2)
LUT_queryImg1_des = []
LUT_trainImg2_des = []
for i in range(np.shape(des1)[0]):
LUT_queryImg1_des.append((i, list(des1[i])))
LUT_queryImg1_des = dict(LUT_queryImg1_des)
# print('\nQUERY LUT of descriptor', LUT_queryImg1_des)
for i in range(np.shape(des2)[0]):
LUT_trainImg2_des.append((i, list(des2[i])))
LUT_trainImg2_des = dict(LUT_trainImg2_des)
# print('\ntrain LUT of descriptor', LUT_trainImg2_des)
index_params = dict(algorithm=6,
table_number=6,
key_size=12,
multi_probe_level=2)
search_params = {}
flann = cv.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# print('\nthe num of unfimaltered matched kp pairs :' + str(len(matches)))
# Need to draw only good matches, so create a mask
matchesMask = [[0, 0] for i in range(len(matches))]
# ratio test as per Lowe's paper
num_MP = 0
matched_idx = []
for i, (m, n) in enumerate(matches):
if m.distance < 0.2 * n.distance: # top two distances m n, a smaller parameter means a higher precision n less matching
matchesMask[i] = [
1, 0
] # this mask encode connect the best m or the second best n
num_MP += 1
matched_idx.append([m.queryIdx, m.trainIdx])
matched_idxNpos = []
prvs_pts = np.zeros((len(matched_idx), 1, 2))
next_pts = np.zeros((len(matched_idx), 1, 2))
k = 0
for i in matched_idx:
query_idx, train_idx = i[0], i[1]
prvs_pts[k] = np.array(LUT_queryImg1[query_idx])
next_pts[k] = np.array(LUT_trainImg2[train_idx])
k = k + 1
# print('\nthe index N pos for matched kp (query,train):', matched_idxNpos) # same query is ordered.
draw_params = dict(matchColor=(255, 218, 185),
singlePointColor=(255, 0, 0),
matchesMask=matchesMask,
flags=cv.DrawMatchesFlags_DEFAULT)
print("\n frame ID :", j)
print('the num of orb kp in query_img img1 :' + str(len(kp1)))
print('the num of orb kp in train_img img2 :' + str(len(kp2)))
print('the num of filtered matched kp pairs :' + str(num_MP))
img3 = cv.drawMatchesKnn(img1, kp1, img2, kp2, matches, None,
**draw_params)
cv.namedWindow('', 0) # so that the img will be clipped
cv.imshow('', img3)
cv.waitKey(1)
img1 = img2
km = prvs_pts.astype(np.float32)
km2 = next_pts.astype(np.float32)
if len(km) < 3:
print("Lost tracking! ")
break
# m = cv2.getAffineTransform(km, km2)
m = cv2.estimateRigidTransform(km, km2, fullAffine=False)
if m is None:
print("transform is Nonetype!")
break
# dx = m[0, 2]
# dy = m[1, 2]
# da = np.arctan2(m[1, 0], m[0, 0])
# scale_x = np.sqrt(m[0, 1] ** 2 + m[0, 0] ** 2)
# scale_y = np.sqrt(m[1, 1] ** 2 + m[1, 0] ** 2)
mat = np.zeros((3, 3))
mat[:2, :3] = m
if j == 37:
print()
dx = m[0, 2]
dy = m[1, 2]
da = np.arctan2(m[1, 0], m[0, 0])
transforms[j] = [dx, dy, da]
pose_matrixs[j] = mat.astype(np.float32)
transforms = -np.cumsum(transforms, axis=0)
pose_matrixs = cumdot(pose_matrixs).astype(np.float32)
# trajectory = np.cumsum(transforms, axis=0)
# cum_scale_X = np.cumprod(scaleX_list, axis=0)
# cum_scale_Y = np.cumprod(scaleY_list, axis=0)
# transforms = -trajectory
cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
# Write n_frames-1 transformed frames
for i in range(n_frames - 2):
# Read next frame
success, frame = cap.read()
if not success:
break
dx = transforms[i, 0]
dy = transforms[i, 1]
da = transforms[i, 2]
# if m is None:
# continue
m = np.zeros((2, 3))
m[0, 0] = np.cos(da)
m[0, 1] = -np.sin(da)
m[1, 0] = np.sin(da)
m[1, 1] = np.cos(da)
m[0, 2] = dx
m[1, 2] = dy
# Apply affine wrapping to the given frame
frame_stabilized = cv2.warpAffine(frame, m, (w, h))
frame_out = cv2.hconcat([frame, frame_stabilized])
cv2.imshow("Before and After", frame_out)
cv2.waitKey(0)
# cv2.imwrite(stable_path + str(i) + '.png', frame_stabilized)
out.write(frame_stabilized)
def main():
# Based on entered image path, it creates the pattern path using split and join
desired_img_path = ""
while not Path(desired_img_path).is_file():
desired_img_path = str(
input("Enter the image file path to find the camera pose for: "))
# Splits the desired img path and uses it to create the pattern.png path (both images should be in same directory)
desired_img_list = desired_img_path.split('/')
pattern_path_png = '/'.join(desired_img_list[:-1]) + "/pattern.png"
if not Path(pattern_path_png).is_file():
print(
"Could not find pattern.png inside of the path to the desired image."
)
return
# Convert pattern.png into a jpg if it doesn't exist
# pattern_path_jpg = pattern_path_png[:-3] + "jpg"
# if not Path(pattern_path_jpg).is_file():
# # Grabs the pattern.png and then write a new file converting it into a jpg
# pattern_img = cv2.imread(pattern_path_png)
# cv2.imwrite(pattern_path_jpg, pattern_img)
# Read in the new pattern.jpg (or pattern.png) and the desired image
# pattern_img = cv2.imread(pattern_path_jpg, 0)
pattern_img = cv2.imread(pattern_path_png, 0)
desired_img = cv2.imread(desired_img_path, 0)
# Print message start
print("Please wait, analyzing images...")
# Had a few options for finding KeyPoints between the pattern and the desired image
# Decided to use sift because it seemed a bit more accurate when getting KeyPoints from different orientations
# orb = cv2.ORB_create()
# surf = cv2.xfeatures2d.SURF_create()
sift = cv2.xfeatures2d.SIFT_create()
# Obtain the KeyPoints and Descriptors for the pattern and desired image
pattern_kp, pattern_des = sift.detectAndCompute(pattern_img, None)
desired_kp, desired_des = sift.detectAndCompute(desired_img, None)
# Get an array of matches between descriptors in both images and get good matches based off a threshold distance
matches = findDescriptorMatches(pattern_des, desired_des)
good_matches = getGoodMatchDescriptors(matches)
# Get the points of the pattern and points of the desired image
pattern_pts, desired_img_pts = getImagePoints(pattern_kp, desired_kp)
# Obtain the image constant c, rotation matrix, and translation matrix from the estimated pose
c, rotation_mat, translation_mat = getPoseMatrix(pattern_pts,
desired_img_pts,
desired_img)
print("\nScalar: " + str(c))
printMatrix("Rotation Matrix", rotation_mat)
printMatrix("Translation Matrix", translation_mat)
# Calculate the Euler Angles in radians based off of the rotation matrix
euler_angles_mat = rotationMatrixToEulerAngles(rotation_mat)
printAxisRotations("Axis Rotations (Degrees -180˚ to 180˚)",
euler_angles_mat)
# Calculate the coordinates of the image based off the translation matrix
printTranslations("Translations (X, Y, Z)", translation_mat[:, 0], c)
# Print message end
print("\nComplete.")
# Create the KeyPoint connected image (pattern and desired image) then plot it to display it
pattern_connected_img = cv2.drawMatchesKnn(pattern_img,
pattern_kp,
desired_img,
desired_kp,
good_matches,
None,
flags=2)
plt.imshow(pattern_connected_img), plt.show()
return
def visualize(left_path, right_path, f_mat, sqResultDir):
colors = [(255, 102, 102), (102, 255, 255), (125, 125, 125),
(204, 229, 255), (0, 0, 204)]
THRESHOLD = 0.2
sift = cv2.xfeatures2d.SIFT_create()
bf = cv2.BFMatcher()
f_mat = np.array(f_mat.reshape((3, 3)))
left_img = cv2.imread(left_path)
# -------
hl, wl = left_img.shape[0], left_img.shape[1]
left_img = left_img[int(hl / 2) - 128:int(hl / 2) + 128,
int(wl / 2) - 128:int(wl / 2) + 128]
# --------------------------
left_imgG = cv2.cvtColor(left_img.copy(), cv2.COLOR_BGR2GRAY)
left_img_line = left_img.copy()
right_img = cv2.imread(right_path)
# -------------------------------
hr, wr = right_img.shape[0], right_img.shape[1]
right_img = right_img[int(hr / 2) - 128:int(hr / 2) + 128,
int(wr / 2) - 128:int(wr / 2) + 128]
right_imgG = cv2.cvtColor(right_img.copy(), cv2.COLOR_BGR2GRAY)
right_img_line = right_img.copy()
(kps_left, descs_left) = sift.detectAndCompute(left_imgG, None)
(kps_right, descs_right) = sift.detectAndCompute(right_imgG, None)
matches = bf.knnMatch(descs_left, descs_right, k=2)
good = []
for m, n in matches:
if m.distance < THRESHOLD * n.distance:
good.append([m])
img3 = cv2.drawMatchesKnn(
right_imgG,
kps_left,
right_imgG,
kps_right,
good,
None,
flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)
cv2.imwrite(os.path.join(sqResultDir, 'feature_matching.png'), img3)
err_l = []
err_r = []
img_W = left_img.shape[1] - 1
# ---------------------------------------------------------------------
for color_idx, g in enumerate(good):
# get the ids of matching feature points
id_l, id_r = g[0].queryIdx, g[0].trainIdx
# x: column
# y: row
# get the feature points in both left and right images
x_l, y_l = kps_left[id_l].pt
x_r, y_r = kps_right[id_r].pt
'''Color for line'''
color = colors[color_idx % len(colors)]
'''Epi line on the left image'''
# epi line of right points on the left image
point_r = np.array([x_r, y_r, 1])
line_l = np.dot(f_mat.T, point_r)
# calculating 2 points on the line
y_0 = epipoline(0, line_l)
y_1 = epipoline(img_W, line_l)
# drawing the line and feature points on the left image
left_img_line = cv2.circle(left_img_line, (int(x_l), int(y_l)),
radius=4,
color=color)
left_img_line = cv2.line(left_img_line, (0, y_0), (img_W, y_1),
color=color,
lineType=cv2.LINE_AA)
# displaying just feature points
left_img = cv2.circle(left_img, (int(x_l), int(y_l)),
radius=4,
color=color)
'''Epi line on the right image'''
# epi line of left points on the right image
point_l = np.array([x_l, y_l, 1])
line_r = np.dot(f_mat, point_l)
# verifying points
err_R = verify_xfx(line_r, point_r)
err_r.append(err_R)
# verifying points
err_L = verify_xfx(line_l, point_l)
err_l.append(err_L)
# calculating 2 points on the line
y_0 = epipoline(0, line_r)
y_1 = epipoline(img_W, line_r)
# drawing the line on the right image
right_img_line = cv2.circle(right_img_line, (int(x_r), int(y_r)),
radius=4,
color=color)
right_img_line = cv2.line(right_img_line, (0, y_0), (img_W, y_1),
color=color,
lineType=cv2.LINE_AA)
# displaying just feature points
right_img = cv2.circle(right_img, (int(x_r), int(y_r)),
radius=4,
color=color)
l_avgErr = np.average(err_l) if err_l else 0
r_avgErr = np.average(err_r) if err_r else 0
vis = np.concatenate((left_img_line, right_img_line), axis=0)
font = cv2.FONT_HERSHEY_SIMPLEX
img_H = vis.shape[0]
x, y, w, h = 0, 0, 50, 25
# Draw black background rectangle
cv2.rectangle(vis, (7, 10), (w, h), (0, 0, 0), -1)
cv2.rectangle(vis, (7, img_H - 20), (w, img_H - 7), (0, 0, 0), -1)
cv2.putText(vis,
'{:.4f}'.format(float(l_avgErr)), (10, 20),
font,
0.3,
color=(255, 255, 255),
lineType=cv2.LINE_AA)
cv2.putText(vis,
'{:.4f}'.format(float(r_avgErr)), (10, img_H - 10),
font,
0.3,
color=(255, 255, 255),
lineType=cv2.LINE_AA)
if not os.path.exists(sqResultDir):
os.makedirs(sqResultDir)
print("Writing image ... " + 'epipoLine_sift.png')
cv2.imwrite(os.path.join(sqResultDir, 'epipoLine_sift.png'), vis)
sampleImage=cv2.imread(samplePath,0)
kp1, des1 = sift.detectAndCompute(sampleImage, None) #提取样本图片的特征
for parent,dirnames,filenames in os.walk(queryPath):
for p in filenames:
print(p)
p=queryPath+p
queryImage=cv2.imread(p,0)
kp2, des2 = sift.detectAndCompute(queryImage, None) #提取比对图片的特征
matches=flann.knnMatch(des1,des2,k=2) #匹配特征点，为了删选匹配点，指定k为2，这样对样本图的每个特征点，返回两个匹配
(matchNum,matchesMask)=getMatchNum(matches,0.9) #通过比率条件，计算出匹配程度
matchRatio=matchNum*100/len(matches)
print(matchRatio)
drawParams=dict(matchColor=(0,255,0),
singlePointColor=(255,0,0),
matchesMask=matchesMask,
flags=0)
comparisonImage=cv2.drawMatchesKnn(sampleImage,kp1,queryImage,kp2,matches,None,**drawParams)
comparisonImageList.append((comparisonImage,matchRatio)) #记录下结果
comparisonImageList.sort(key=lambda x:x[1],reverse=True) #按照匹配度排序
count=len(comparisonImageList)
column=4
row=math.ceil(count/column)
#绘图显示
figure,ax=plt.subplots(row,column)
for index,(image,ratio) in enumerate(comparisonImageList):
ax[int(index/column)][index%column].set_title('Similiarity %.2f%%' % ratio)
ax[int(index/column)][index%column].imshow(image)
plt.show()
import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# FLANN parameters
FLANN_INDEX_KDTREE = 1
index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
search_params = dict(checks=50) # or pass empty dictionary
flann = cv.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1, des2, k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0, 0] for i in range(len(matches))]
# ratio test as per Lowe's paper
for i, (m, n) in enumerate(matches):
if m.distance < 0.7 * n.distance:
matchesMask[i] = [1, 0]
draw_params = dict(matchColor=(0, 255, 0),
singlePointColor=(255, 0, 0),
matchesMask=matchesMask,
flags=cv.DrawMatchesFlags_DEFAULT)
img3 = cv.drawMatchesKnn(img1, kp1, img2, kp2, matches, None, **draw_params)
plt.imshow(img3, ), plt.show()
def calculate_ratio(self, cur_frame, old_frame):
# Detecting keypoints
#old_kp, old_des = self.detect_keypoints(old_frame)
cur_kp, cur_des = self.detect_keypoints(cur_frame)
# Match and filter keypoints
best = self.bf_matcher(self.old_kp, self.old_des, cur_kp, cur_des)
# Draw rectangle to represent margin
cur_frame = cv2.rectangle(cur_frame, (self.xmargin, self.ymargin),
(cur_frame.shape[1] - self.xmargin,
cur_frame.shape[0] - self.ymargin),
(0, 0, 255), 2)
# DEBUG: shows user the matches of the matcher
if self.show_matches:
gray1 = cv2.cvtColor(np.copy(old_frame), cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(np.copy(cur_frame), cv2.COLOR_BGR2GRAY)
img = cv2.drawMatchesKnn(gray1,
self.old_kp,
gray2,
cur_kp,
best,
None,
singlePointColor=(0, 0, 255))
cv2.imshow("Matches", img)
# If no hull is found stop here
if len(best) <= 3:
self.old_kp = cur_kp
self.old_des = cur_des
return -1, -1
# Calculate hull of previous frame
old_hull = self.calculate_hull(
self.kp_to_points(best, self.old_kp, False))
old_hull_size = self.hull_size(old_hull)
self.draw_hull(old_frame, old_hull)
# Calculate hull of current frame
cur_hull = self.calculate_hull(self.kp_to_points(best, cur_kp))
cur_hull_size = self.hull_size(cur_hull)
self.draw_hull(cur_frame, cur_hull)
#Calculate hull ratio
if cur_hull_size <= 0.0:
hull_ratio = 0.0
else:
hull_ratio = cur_hull_size / old_hull_size
# Calculate keypoint ratio
total = 0
best_cur_kp = []
for m in best:
prev_size = self.old_kp[m[0].queryIdx].size
cur_size = cur_kp[m[0].trainIdx].size
best_cur_kp.append(cur_kp[m[0].trainIdx])
total += cur_size / prev_size
kp_ratio = total / len(best)
#DEBUG: save max kp ratio and hull ratio to show at shutdown
if kp_ratio > self.max_kp_ratio and hull_ratio > self.max_hull_ratio:
self.max_kp_ratio = kp_ratio
self.max_hull_ratio = hull_ratio
self.max_previous = old_frame
self.max_current = cur_frame
self.old_kp = cur_kp
self.old_des = cur_des
if self.show_matches:
log.debug("Hull ratio: " + str(hull_ratio) + " KP ratio: " +
str(kp_ratio))
return hull_ratio, kp_ratio
matches = flann.knnMatch(des1,des2,k=2)
# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]
# ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]
draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)
img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)
plt.figure(figsize(10,10))
plt.imshow(img3,),plt.show()
# <markdowncell>
# However, sift contains position information and is comparatively slow, we'll use SURF instead. With invariant direction, only size as stars should look the same from any angle (obviously).
# <codecell>
surf = cv2.SURF(10)
surf.upright = True #Direction invariant
kp1, des1 = surf.detectAndCompute(img1,None)
kp2, des2 = surf.detectAndCompute(img2,None)
#for kps in kp1:
# print "x: " + str(kps.pt[0]) + " y: " + str(kps.pt[1]) + " Size: " + str(kps.size) + " Octave: " \
matches = flann.knnMatch(descriptors1, descriptors2, k=2)
matchesMask = [[0, 0] for i in range(len(matches))]
#Apply ratio test
good = []
good_pts = []
for i, (m, n) in enumerate(matches):
if m.distance < 0.75 * n.distance:
good.append([m])
good_pts.append(m)
featureMacthing = cv2.drawMatchesKnn(image1,
detected_points1,
image2,
detected_points2,
good,
None,
flags=2)
#=======================================part3==============================================================================
src_pts = np.float32([detected_points1[m.queryIdx].pt
for m in good_pts]).reshape(-1, 1, 2)
dst_pts = np.float32([detected_points2[m.trainIdx].pt
for m in good_pts]).reshape(-1, 1, 2)
print(src_pts.shape)
print(dst_pts.shape)
homography, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC)
#print(mask)
#=====================================part4================================================================================
inliner = []
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img1 = cv.imread('box.png', 0) # queryImage
img2 = cv.imread('boxinscene.png', 0) # trainImage
# Initiate SIFT detector
sift = cv.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
# BFMatcher with default params
bf = cv.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Apply ratio test
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append([m])
# cv.drawMatchesKnn expects list of lists as matches.
img3 = cv.drawMatchesKnn(img1, kp1, img2, kp2, good, None, flags=2)
plt.imshow(img3), plt.show()
def BFSIFT():
connectdb = sqlite3.connect("results.db")
cursor = connectdb.cursor()
# img1 = cv2.imread("1.png")
# img11 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
img1 = cv2.imread('1.png', cv2.IMREAD_GRAYSCALE)
imageA = cv2.resize(img1, (450, 237))
database = os.listdir("db")
for image in database:
img2 = cv2.imread("db/" + image)
imgprocess = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
imageB = cv2.resize(imgprocess, (450, 237))
matcheslist = ""
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(imageA, None)
kp2, des2 = sift.detectAndCompute(imageB, None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Apply ratio test
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append([m])
# cv.drawMatchesKnn expects list of lists as matches.
amount = len(good)
print('Comparing input image to ' + image + " using BFSIFT")
title = "Comparing"
fig = plt.figure(title)
cursor.execute(
"INSERT INTO BFSIFT (percentage, filename) VALUES (?, ?);",
(amount, image))
connectdb.commit()
percentages = list(connectdb.cursor().execute(
"SELECT * FROM BFSIFT order by percentage desc limit 10"))
print(percentages[0])
highest = percentages[0]
# getting number of matches
highestperct = round(highest[0], 2)
print(highestperct)
# getting file name of highest similarity
filename = highest[1]
print(filename)
img1 = cv2.imread('1.png', cv2.IMREAD_GRAYSCALE) # input image
img2 = cv2.imread('db/' + filename,
cv2.IMREAD_GRAYSCALE) # closet image
# Initiate SIFT detector
sift = cv2.xfeatures2d.SIFT_create()
# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Apply ratio test
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append([m])
# cv.drawMatchesKnn expects list of lists as matches.
print(good)
print(kp1)
print(kp2)
plt.suptitle("Amount of matches : " + str(highestperct))
disease = filename[:-4]
txt = "Results: \n - " + filename + "\n - " + disease
plt.text(0.40, 0.20, txt, transform=fig.transFigure, size=11)
drawmatches = cv2.drawMatchesKnn(img1,
kp1,
img2,
kp2,
good,
None,
flags=2)
plt.imshow(drawmatches), plt.axis("off"), plt.show()
cursor.execute("DELETE FROM BFSIFT")
connectdb.commit()
import cv2
import numpy as np
import random
image = cv2.imread('image.jpg')
image_rot = cv2.imread('image_rot.jpg')
gray= cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
gray_rot = cv2.cvtColor(image_rot,cv2.COLOR_BGR2GRAY)
surf = cv2.xfeatures2d.SURF_create()
kp, desc = surf.detectAndCompute(gray,None)
kp_rot, desc_rot = surf.detectAndCompute(gray_rot, None)
# BFMatcher with default params
bf = cv2.BFMatcher()
matches = bf.knnMatch(desc,desc_rot, k=2)
# Apply ratio test
good = []
for m,n in matches:
if m.distance < 0.4*n.distance:
good.append([m])
random.shuffle(good)
# cv2.drawMatchesKnn expects list of lists as matches.
image_match = cv2.drawMatchesKnn(image,kp,image_rot,kp_rot,good[:10],flags=2, outImg=None)
cv2.imwrite('surf_matches.jpg',image_match)
transform_par.trans_y = 0
transform_par.resize = 150
transform_par.trans_type = 2 #Options: 2 = Rotation, 3 = Resize
### Transformation1: Rotation
img2 = image_transformation(img1, transform_par) #Transformation de l'image
List_I1Coordinates, List_I2Coordinates, matches, pts1, pts2, gray1, gray2, good = calcul_keypoints(
img1, img2) #Calcul des point d'interets
list_qCoordinates = point_transformation(
img1, List_I1Coordinates,
transform_par) #Calcule la qualité de les appariements
quality_factor = calcule_quality(list_qCoordinates, List_I2Coordinates,
transform_par)
print("Qualité des appariements: %.2f%%" % (quality_factor))
# Affichage des appariements qui respectent le ratio test
draw_params = dict(matchColor=(0, 255, 0),
singlePointColor=(255, 0, 0),
flags=0)
img3 = cv2.drawMatchesKnn(gray1, pts1, gray2, pts2, good, None, **draw_params)
Nb_ok = len(good)
plt.imshow(img3), plt.title('%i appariements OK' % Nb_ok)
plt.show()
print('Le numero d appariements OK de l image tourné est %i' % Nb_ok)
print(
'Le rapport entre les appariements bons et le numero total d appariements est %f'
% (Nb_ok / len(matches)))
import cv2
img1 = cv2.imread(r'C:\Users\mueda\Documents\S__41476104.jpg')
img2 = cv2.imread(r'C:\Users\mueda\Documents\S__41476106.jpg')
sift = cv2.xfeatures2d.SIFT_create()
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
ratio = 0.5
good = []
for m, n in matches:
if m.distance < ratio * n.distance:
good.append([m])
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, good[:100], None, flags=2)
cv2.imshow('img', img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.imwrite('sift_matching.jpg', img3)
def main(args):
# Read the file containing the pairs used for testing
pairs = read_pairs(os.path.expanduser(args.lfw_pairs))
# Get the paths for the corresponding images
paths, actual_issame = get_paths(os.path.expanduser(args.patch_dir), pairs)
print(paths[0])
print(paths[1])
print(actual_issame[0])
img1 = cv2.imread(paths[0], cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread(paths[1], cv2.IMREAD_GRAYSCALE)
sift = cv2.xfeatures2d.SIFT_create()
# surf = cv2.xfeatures2d.SURF_create()
# create a mask image filled with zeros, the size of original image
mask = np.zeros(img1.shape[:2], dtype=np.uint8)
# draw your selected ROI on the mask image
cv2.rectangle(mask, (24, 24), (40, 40), (255), thickness=-1)
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Apply ratio test
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append([m])
print(good)
# cv2.drawMatchesKnn expects list of lists as matches.
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, good, None)
cv2.imshow("matches", img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(paths[400])
print(paths[401])
print(actual_issame[200])
img1 = cv2.imread(paths[400], cv2.IMREAD_GRAYSCALE)
img2 = cv2.imread(paths[401], cv2.IMREAD_GRAYSCALE)
sift = cv2.xfeatures2d.SIFT_create()
# surf = cv2.xfeatures2d.SURF_create()
kp1, des1 = sift.detectAndCompute(img1, None)
kp2, des2 = sift.detectAndCompute(img2, None)
bf = cv2.BFMatcher()
matches = bf.knnMatch(des1, des2, k=2)
# Apply ratio test
good = []
for m, n in matches:
if m.distance < 0.75 * n.distance:
good.append([m])
# cv2.drawMatchesKnn expects list of lists as matches.
img3 = cv2.drawMatchesKnn(img1, kp1, img2, kp2, good, img2)
cv2.imshow("dismatch", img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
pass
