def findFiducial():
# load fiducial with greyscale flag
tag = cv2.imread('Frame.png', 0)
# tag = cv2.imread('Tags/Tag36h9.png', 0)
real_width = 51.5 # mm (measure these!!!!)
h, w = tag.shape # h and w of fiducial
# load in one of our "distorted" images with greyscale flag
img = cv2.imread('CalibrationImages/Fiducial/Fiducial1.jpg')
#img = cv2.imread('photo.jpg') # trainImage
#img, timestamp = freenect.sync_get_video() #(possibly take an image)
#img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Load previously saved data about the camera - generated with the chessboard photos
dist = np.load('CalibrationImages/Caliboutput/dist.npy')
Cam_Mat = np.load('CalibrationImages/Caliboutput/mtx1.npy')
'''
# undistort the image!
ph, pw = img.shape[:2]
newcameramtx, roi=cv2.getOptimalNewCameraMatrix(Cam_Mat, dist, (pw, ph), 1, (pw, ph))
img = cv2.undistort(img, Cam_Mat, dist, None, newcameramtx)
'''
# Initiate ORB detector
orb = cv2.ORB()
# find the keypoints and descriptors with ORB:
# fiducial
tag_kp = orb.detect(tag, None)
tag_kp, tag_des = orb.compute(tag, tag_kp)
# photo
img_kp = orb.detect(img, None)
img_kp, img_des = orb.compute(img, img_kp)
# find the fiducial
print("finding fiducial")
M = find(tag_des, tag_kp, img_des, img_kp)
draw_outline(M, h, w, img)
# write out full size image
cv2.imwrite('found.jpg', img)
# show the image
cv2.imshow('found', img)
cv2.waitKey()
cv2.destroyAllWindows()
def _sift(raw_image):
'''
Args:
raw_image (Image)
Returns:
(list): containing all sift keypoints
'''
orb = cv2.ORB()
numpy_image = raw_image.getNumpyCv2()
# APPLY FEATURES HERE
all_keypoints, des1 = orb.detectAndCompute(numpy_image,
None) # Finds sift keypoints
keypoints = [all_keypoints[i].pt for i in range(len(all_keypoints))]
return keypoints
def processing_part3(flann, gray_roi, gray_img):
orb = cv2.ORB(nfeatures=100, nlevels=4, scaleFactor=1.3)
key_points, query_descriptors = orb.detectAndCompute(gray_roi, None)
matches = flann.knnMatch(np.uint8(query_descriptors), k=6)
vote_array = np.zeros((gray_img.shape[0] / 10, gray_img.shape[1] / 10),
dtype=np.uint8)
for match in matches:
for index in match:
vectorx = (
key_points[index.queryIdx].size *
key_points_math_array[index.trainIdx].distance[0] *
scipy.cos(key_points_math_array[index.trainIdx].distance[2] +
key_points[index.queryIdx].distance[2] -
key_points_math_array[index.trainIdx].distance[2])
) / key_points_math_array[index.trainIdx].size
vectory = (
key_points[index.queryIdx].size *
key_points_math_array[index.trainIdx].distance[0] *
scipy.sin(key_points_math_array[index.trainIdx].distance[2] +
key_points[index.imgIdx].distance[2] -
key_points_math_array[index.trainIdx].distance[2])
) / key_points_math_array[index.trainIdx].size
kpx = int(
scipy.divide(key_points[index.imgIdx].pt[0] + vectorx, 10))
kpy = int(
scipy.divide(key_points[index.imgIdx].pt[1] + vectory, 10))
if (kpx > 0 and kpy > 0) and (kpx < vote_array.shape[1]
and kpy < vote_array.shape[0]):
vote_array[kpy, kpx] += 1
vote_array = cv2.resize(vote_array,
None,
fx=10,
fy=10,
interpolation=cv2.INTER_NEAREST)
max_index = np.unravel_index(vote_array.argmax(), vote_array.shape)
position = (max_index[0], max_index[1])
cv2.circle(gray_img,
position,
gray_img.shape[1] / 33, (0, 0, 255),
thickness=2)
return gray_img
def get_useful_picture(self, img):
orb = cv2.ORB()
# sift = cv2.SIFT()
# kp1, des1 = sift.detectAndCompute(img, None)
result_list = []
bf = cv2.BFMatcher(cv2.NORM_L2)
kpa, desa = orb.detectAndCompute(img, None)
self.storDir_num = self.get_future_num_color(img)
StorDir = "static/" + "Picture_new/" + self.storDir_num
if not os.path.exists(StorDir):
return result_list
for filename in os.listdir(StorDir):
try:
stor = StorDir + "/" + str(filename)
img1 = cv2.imread(stor)
kpi, desi = orb.detectAndCompute(img1, None)
if desi == None:
continue
else:
matches = bf.knnMatch(desa, desi, k=2)
sub_matchpointnum = 0
for m, n in matches:
if m.distance < 0.82 * n.distance:
sub_matchpointnum += 1
if sub_matchpointnum > 20:
# kp2, des2 = sift.detectAndCompute(img1, None)
# FLANN_INDEX_KDTREE = 0
# index_params = dict(algorithm = FLANN_INDEX_KDTREE , tree = 5)
# seacher_params = dict (checks = 50)
# flann = cv2.FlannBasedMatcher(index_params , seacher_params)
# matches1 = flann.knnMatch(des1 , des2 , k =2 )
# sub_matchpointnum1 = 0
# for m , n in matches1 :
# if m.distance < 0.80*n.distance:
# sub_matchpointnum1 += 1
# if sub_matchpointnum1 > 20 :
uty, uid = self.analyse(stor)
result = []
stor_new = '/' + stor
result.append(stor_new)
result.append(uty)
result.append(uid)
result_list.append(result)
except Exception as e:
print("Failed in read picture:", e)
return result_list
def ORB(input_image, stored_image):
gray = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)
orb_detector = cv2.ORB(1600, 1.3)
(keypoints_1, descriptor_1) = orb_detector.detectAndCompute(gray, None)
(keypoints_2,
descriptor_2) = orb_detector.detectAndCompute(stored_image, None)
brute_force = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches_found = brute_force.match(descriptor_1, descriptor_2)
matches_found = sorted(matches_found, key=lambda val: val.distance)
return len(matches_found)
def detect(img1, img2):
global DEVX
global DEVY
# SIFT generally produces better results, but it is not FOSS, so chose the feature detector
# that suits the needs of your project. ORB does OK
use_sift = False
if use_sift:
detector = cv2.SURF()
else:
detector = cv2.ORB(1000)
# keypoints as kp, descriptors as desc
kp1, des1 = detector.detectAndCompute(img1, None)
kp2, des2 = detector.detectAndCompute(img2, None)
if use_sift:
if len(kp2) < 5000:
print "bad pic"
return
bf = cv2.BFMatcher()
# This returns the top two matches for each feature point (list of list)
pairMatches = bf.knnMatch(des1, des2, k=2)
rawMatches = []
for m, n in pairMatches:
if m.distance < 0.6 * n.distance:
rawMatches.append(m)
else:
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
rawMatches = bf.match(des1, des2)
sortMatches = sorted(rawMatches, key=lambda x: x.distance)
matches = sortMatches[0:300]
U1 = []
U2 = []
if len(matches) >= 3:
for mat in matches:
U1.append(kp1[mat.queryIdx].pt)
U2.append(kp2[mat.trainIdx].pt)
return np.asarray(U1), np.asarray(U2)
else:
print len(matches)
print "match failed,pass"
return
def checkForBattery(self):
image = cv2.cvtColor(self.raw_image, cv2.COLOR_BGR2GRAY)
#laplacian = cv2.Laplacian(image,cv2.CV_32F)
#cv2.imshow("Laplacian", laplacian)
for model in self.batteryTemplates:
#model = cv2.Laplacian(model,cv2.CV_32F)
w, h = model.shape[::-1]
########################## Trying ORB ###############################
#res = cv2.matchTemplate(image, model, cv2.TM_CCOEFF_NORMED)
#(_, maxValue, minLoc, maxLoc) = cv2.minMaxLoc(res)
#mask = np.zeros(image.shape, dtype="uint8")
#cv2.imshow("Lap", model)
#loc = np.where( res >= threshold)
match = False
orb = cv2.ORB()
kp = orb.detect(model, None)
kp, des = orb.compute(model, kp)
kp1 = orb.detect(image, None)
kp1, des1 = orb.compute(image, kp1)
bf = cv2.BFMatcher(cv2.NORM_L1, crossCheck=True)
clusters = np.array([des])
bf.add(clusters)
matches = bf.match(des, des1)
#thres = (sum(dist)/len(dist))*0.5
image2 = cv2.drawKeypoints(image, kp1, color=(0, 255, 0), flags=0)
cv2.imshow("Battery Detection", image2)
threshold = 1100 # max distance
if len(matches) > 100: # minimum number of matches
# Sort them in the order of their distance.
matches = sorted(matches, key=lambda x: x.distance)
if matches[10].distance < threshold: # filter bad matches
print("Found battery")
print(kp1[matches[0].queryIdx].pt) # pixel pos
return True
#for pt in zip(*loc[::-1]):
# print("I've found the battery!!")
# match=True
return match
def __init__(self, camera):
picamera.array.PiMotionAnalysis.__init__(self, camera)
self.obj_pose_pub = rospy.Publisher('/pidrone/desired/pose',
Pose,
queue_size=1)
self.detector = cv2.ORB(nfeatures=150, scoreType=cv2.ORB_FAST_SCORE)
self.curr_obj_coordinates = None
self.error = None
self.track_object = False
self.prev_img = None
self.alpha = 0.70
self.z = 0.16
def clusterFaces():
#desList will store descriptor for each frame
desList = []
#labeledFrames will help to keep a track of frames for which descriptors were found successfully
labeledFrames = []
print "\n\n.........Running k-means clustering on the faces......"
#Detecting keypoints and descriptors. I use ORB since it is free to use
orb = cv2.ORB()
for (counter, img) in enumerate(imageFaces):
kp = orb.detect(img, None)
kp, des = orb.compute(img, kp)
if des is not None:
desList.append(np.float32(des[0]))
labeledFrames.append(counter)
#z will store the descriptors as a numpy array. z will have the features for k-means clustering for 6 labels
z = np.asarray(desList)
k_means = cluster.KMeans(6)
k_means.fit(z)
print "\nThe following is the result of the analysis: \n"
#frameLabelDic will be a dictionary to map a frame to an actor
frameLabelDic = {}
#labelCount will give the total number of frames mapped to one actor. 6 mappings in total
labelCount = {}
for label in range(6):
labelCount.update({label: 0})
for x in range(len(labeledFrames)):
frameLabelDic.update({labeledFrames[x]: k_means.labels_[x]})
labelCount[k_means.labels_[x]] += 1
#pprint(frameLabelDic)
pprint(labelCount)
#Now storing faces in directories
print "\n.........Storing faces \nIn directories: faceData/0 ... faceData/5\n"
makeDirectoryStructure()
for faceFrame in frameLabelDic.keys():
cv2.imwrite(
faceDataDir + "/%s/%s.jpg" % (frameLabelDic[faceFrame], faceFrame),
imageFaces[faceFrame])
def __init__(self):
self.demo_on = False
self.node_name = "walle_recognizer"
rospy.init_node(self.node_name)
# What we do during shutdown
rospy.on_shutdown(self.cleanup)
# Create the OpenCV display window for the RGB image
self.cv_window_name = self.node_name
cv.NamedWindow("RGB Image", cv.CV_WINDOW_NORMAL)
cv.MoveWindow("RGB Image", 25, 75)
# And one for the depth image
cv.NamedWindow("Depth Image", cv.CV_WINDOW_NORMAL)
cv.MoveWindow("Depth Image", 25, 350)
self.known_objects = []
self.sift = cv2.ORB()
self.current_depth = None
# self.current_color = None
self.current_stage = None
# Create the cv_bridge object
self.bridge = CvBridge()
self.pub = rospy.Publisher("/walle/recognizer/publish", String)
self.rate = rospy.Rate(10) # 10hz
self.last_recognized = None
# Subscribe to the camera image and depth topics and set
# the appropriate callbacks
self.image_sub = rospy.Subscriber("/camera/rgb/image_color", Image,
self.image_callback)
self.depth_sub = rospy.Subscriber("/camera/depth/image_raw", Image,
self.depth_callback)
rospy.Subscriber("/walle/recognizer/listen",
String,
self.receive,
queue_size=1)
rospy.loginfo("Waiting for image topics...")
def auto_label_image(image_id, klass):
results = []
img = get_image(image_id)
# Initiate STAR detector
orb = cv2.ORB()
# find the keypoints with ORB
kp = orb.detect(img, None)
# compute the descriptors with ORB
kp, des = orb.compute(img, kp)
for index, keypoint in enumerate(kp):
descriptor = des[index]
vector = kp_des2vector(klass, image_id, kp[index], descriptor)
results.append(vector)
return results
def process_image(imageName, maskName, resultName):
img = cv2.imread(imageName, cv2.CV_LOAD_IMAGE_GRAYSCALE)
if maskName is not None:
mask = cv2.imread(maskName, cv2.CV_LOAD_IMAGE_GRAYSCALE)
img[np.where((mask > 128))] = 0
if not os.path.isfile(resultName + ".key_surf"):
# SURF
surf = cv2.SURF()
k_surf, des_surf = surf.detectAndCompute(img, None)
# img_surf = cv2.drawKeypoints(img, k_surf)
# cv2.imwrite(resultName + "_keypoints_SURF.jpeg", img_surf)
points_surf = pickle_keypoints(k_surf, des_surf)
saveKeypointsDatabase(points_surf, resultName + ".key_surf")
if not os.path.isfile(resultName + ".key_sift"):
# SIFT
sift = cv2.SIFT()
k_sift, des_sift = sift.detectAndCompute(img, None)
# img_sift = cv2.drawKeypoints(img, k_sift)
# cv2.imwrite(resultName + "_keypoints_SIFT.jpeg", img_sift)
points_sift = pickle_keypoints(k_sift, des_sift)
saveKeypointsDatabase(points_sift, resultName + ".key_sift")
if not os.path.isfile(resultName + ".key_orb"):
# ORB
orb = cv2.ORB()
k_orb, des_orb = orb.detectAndCompute(img, None)
# img_orb = cv2.drawKeypoints(img, k_orb)
# cv2.imwrite(resultName + "_keypoints_ORB.jpeg", img_orb)
points_orb = pickle_keypoints(k_orb, des_orb)
saveKeypointsDatabase(points_orb, resultName + ".key_orb")
def esix():
MIN_MATCH_COUNT = 10
img1 = cv2.imread('/Users/larken/class/computer-vision/a5/box.png',
0) # queryImage
img2 = cv2.imread(
'/Users/larken/class/computer-vision/a5/box_in_scene.png',
0) # trainImage
orb = cv2.ORB()
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)
# # create BFMatcher object
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
# Match descriptors.
matches = bf.match(des1, des2)
def training_part1():
os.chdir("./training")
orb = cv2.ORB(nfeatures=100, nlevels=4, scaleFactor=1.3)
# FLANN_INDEX_KDTREE = 1 - OK, FLANN_INDEX_LSH = 6 - error.
flann = cv2.FlannBasedMatcher(dict(algorithm=6), searchParams=dict())
for img in glob.glob("*.jpg"):
gray = cv2.imread(img, 0)
key_points, descriptors = orb.detectAndCompute(gray, None)
flann.add([np.uint8(descriptors)])
flann.train()
for kp in key_points:
distance_center = calc_center(kp, gray)
key_point = KeyPoint(kp.angle, distance_center, kp.size, kp.pt)
key_points_math_array.append(key_point)
return flann
def findMatchesBetweenImages(image_1, image_2):
# return the top 10 list of matches between two input images sorted by distance
matches = None
image_1_kp = None
image_1_desc = None
image_2_kp = None
image_2_desc = None
# SIFT/ORB object to find keypoints/desc to be used for matches
sift = cv2.SIFT()
orb = cv2.ORB()
image_1_kp, image_1_desc = orb.detectAndCompute(image_1, None)
image_2_kp, image_2_desc = orb.detectAndCompute(image_2, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(image_1_desc, image_2_desc)
matches = sorted(matches, key=lambda x: x.distance)
matches = matches[:10]
return image_1_kp, image_2_kp, matches
def featureMatch(self, current, previous):
orb = cv2.ORB_create()
orb = cv2.ORB()
cv2.ocl.setUseOpenCL(False)
kp1, des1 = orb.detectAndCompute(current, None)
kp2, des2 = orb.detectAndCompute(previous, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
res = cv2.drawMatches(current,
kp1,
previous,
kp2,
matches[:],
None,
flags=2)
res = cv2.resize(res, (320, 240))
return (res)
def test_orb(cls):
img = cv.imread("../lib/images/face.png", 1)
img_gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
# in opencv2.4, and there is something wrong in opencv3.1.0
orb = cv.ORB() # cv.ORB_create() in opencv 3.1.0
kp = orb.detect(img, None)
kp, des = orb.compute(img_gray, kp)
cv.drawKeypoints(img,
kp,
img,
color=(0, 255, 0),
flags=cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv.imshow("img", img)
cv.waitKey(0)
def main():
try:
img = cv2.imread('img18.png', cv2.IMREAD_COLOR)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
sift = cv2.ORB()
kps, descriptors = sift.detectAndCompute(gray, None)
cv2.drawKeypoints(img, kps, img, (51, 163, 236),
cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv2.namedWindow('sift_keypoints', cv2.WINDOW_KEEPRATIO)
cv2.imshow('sift_keypoints', img)
cv2.waitKey()
except NameError:
print("Error found")
pass
def corner(path):
if path == '0':
path = 0
cap = cv2.VideoCapture(path)
while (cap.isOpened()):
_, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = np.float32(gray)
# Harris corner detector scale variant
#dst = cv2.cornerHarris(gray,3,3,0.03)
#dst = cv2.dilate(dst,None)
#frame[dst>0.01*dst.max()]=[0,0,255]
# Some other guy scale variant
#corners = cv2.goodFeaturesToTrack(gray,25,0.01,10);
#for i in corners:
# x,y = i.ravel()
# cv2.circle(frame,(x,y),3,255,-1)
#Non maximal suppression with fast detector
#fast = cv2.FastFeatureDetector()
#kp = fast.detect(frame,None)
#frame = cv2.drawKeypoints(frame, kp, color=(255,0,0))
# CeNsuRe detector with Brief
#star = cv2.FeatureDetector_create("STAR")
#brief = cv2.DescriptorExtractor_create("BRIEF")
#kp = star.detect(frame,None)
#kp, des = brief.compute(frame, kp)
#frame = cv2.drawKeypoints(frame, kp, color=(255,0,0))
#ORB FAST PLUSE BRIEF
orb = cv2.ORB()
kp = orb.detect(frame, None)
kp, des = orb.compute(frame, kp)
frame = cv2.drawKeypoints(frame, kp, color=(255, 0, 0))
cv2.imshow('morph', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def __init__(self, video, shot=None, height=200, min_match=20, lookahead=5,
verbose=False):
"""
Parameters
----------
shot : iterable, optional
Segment iterator.
"""
super(Thread, self).__init__()
self.video = video
self.height = height
# estimate new size from video size and target height
w, h = self.video._size
self._resize = (int(self.height), int(w * self.height / h))
self.lookahead = lookahead
if shot is None:
shot = Shot(video)
self.shot = shot
self.verbose = verbose
# ORB (non-patented SIFT alternative) extraction
if OPENCV == 2:
self._orb = cv2.ORB()
elif OPENCV == 3:
self._orb = cv2.ORB_create()
# # brute-force ORB matching
# self._bfmatcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
# fast approximate nearest neighbord
FLANN_INDEX_LSH = 6
index_params = dict(algorithm=FLANN_INDEX_LSH,
table_number=6,
key_size=12,
multi_probe_level=1)
search_params = dict(checks=50)
self._flann = cv2.FlannBasedMatcher(index_params, search_params)
self.min_match = min_match
def findMatchesBetweenImages(image_1, image_2):
""" Return the top 10 list of matches between two input images.
This function detects and computes SIFT (or ORB) from the input images, and
returns the best matches using the normalized Hamming Distance.
Args:
image_1 (numpy.ndarray): The first image (grayscale).
image_2 (numpy.ndarray): The second image. (grayscale).
Returns:
image_1_kp (list): The image_1 keypoints, the elements are of type
cv2.KeyPoint.
image_2_kp (list): The image_2 keypoints, the elements are of type
cv2.KeyPoint.
matches (list): A list of matches, length 10. Each item in the list is of
type cv2.DMatch.
"""
# matches - type: list of cv2.DMath
matches = None
# image_1_kp - type: list of cv2.KeyPoint items.
image_1_kp = None
# image_1_desc - type: numpy.ndarray of numpy.uint8 values.
image_1_desc = None
# image_2_kp - type: list of cv2.KeyPoint items.
image_2_kp = None
# image_2_desc - type: numpy.ndarray of numpy.uint8 values.
image_2_desc = None
orb = cv2.ORB()
image_1_kp = orb.detect(image_1, None)
image_1_kp, image_1_desc = orb.compute(image_1, image_1_kp)
image_2_kp = orb.detect(image_2, None)
image_2_kp, image_2_desc = orb.compute(image_2, image_2_kp)
bfMatch = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bfMatch.match(image_1_desc, image_2_desc)
matches = sorted(matches, key=lambda x: x.distance)
matches = matches[:10]
image = drawMatches(image_1, image_1_kp, image_2, image_2_kp, matches)
return image_1_kp, image_2_kp, matches
def calculate(self, resource):
""" Append descriptors to ORB h5 table """
(image_url, mask_url, gobject_url) = resource
if image_url is '':
raise FeatureExtractionError(resource, 400,
'Image resource is required')
if mask_url is not '':
raise FeatureExtractionError(resource, 400,
'Mask resource is not accepted')
#image_url = BQServer().prepare_url(image_url, remap='display')
im = image2numpy(image_url, remap='display')
im = np.uint8(im)
if gobject_url is '':
fs = cv2.ORB().detect(im)
if gobject_url:
(x, y, size) = gobject2keypoint(gobject_url)
fs = [cv2.KeyPoint(x, y, size)] # keypoints
descriptor_extractor = cv2.DescriptorExtractor_create("ORB")
(kpts, descriptors) = descriptor_extractor.compute(im, fs)
if descriptors == None: #no feature was returned
raise FeatureExtractionError(resource, 500,
'No feature was calculated')
x = []
y = []
response = []
size = []
angle = []
octave = []
for k in kpts[:500]:
x.append(k.pt[0])
y.append(k.pt[1])
response.append(k.response)
size.append(k.size)
angle.append(k.angle)
octave.append(k.octave)
return (descriptors, x, y, response, size, angle, octave)
def test_372(self):
# 37.2对ORB描述符进行蛮力匹配
# 在本例中我们
# 有一个查询图像和一个目标图像。我们要使用特征匹配的方法在目标图像中寻
# 找查询图像的位置
img1 = cv2.imread('box.png', 0) # queryImage
img2 = cv2.imread('box_in_scene.png', 0) # trainImage
# Initiate SIFT detector
orb = cv2.ORB()
# find the keypoints and descriptors with SIFT
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)
# create BFMatcher object
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)
print("")
def findMatchesBetweenImages(image_1, image_2, num_matches):
"""
Return the top list of matches between two input images.
NOTE: You will not be graded for this function. This function is almost
identical to the function in Assignment 7 (we just parametrized the
number of matches). We expect you to use the function you wrote in
A7 here.
Args:
----------
image_1 : numpy.ndarray
The first image (can be a grayscale or color image)
image_2 : numpy.ndarray
The second image (can be a grayscale or color image)
num_matches : int
The number of desired matches. If there are not enough, return
as many matches as you can.
Returns:
----------
image_1_kp : list[cv2.KeyPoint]
A list of keypoint descriptors in the first image
image_2_kp : list[cv2.KeyPoint]
A list of keypoint descriptors in the second image
matches : list[cv2.DMatch]
A list of matches between the keypoint descriptor lists of
length no greater than num_matches
"""
orb = cv2.ORB()
kp1, des1 = orb.detectAndCompute(image_1, None)
kp2, des2 = orb.detectAndCompute(image_2, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key = lambda x:x.distance)
return kp1, kp2, matches[:num_matches]
def orbnav(inDir):
result = None
orb = cv2.ORB()
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
img1, kp1, des1 = None, None, None
for name in os.listdir(inDir):
print name
img2 = cv2.imread(os.path.join(inDir, name))
kp2, des2 = orb.detectAndCompute(img2, None)
print len(kp2)
if img1 is not None:
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
img3 = drawMatches(gray1, kp1, gray2, kp2, matches[:10])
cv2.imwrite("tmp.jpg", img3)
img1, kp1, des1 = img2, kp2, des2
def orb_keypoint_matching(img1, img2):
# initialize orb detector
orb = cv2.ORB()
# detect and compute function
# generates list of keypoints
kp1, des1 = orb.detectAndCompute(img1, None)
# detect and compute function
# generates list of keypoints
kp2, des2 = orb.detectAndCompute(img2, None)
# create bfmatcher object with defined parameters
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
# gen matches with bf matcher
matches = bf.match(des1, des2)
# the matches are sorted by their distance
matches = sorted(matches, key=lambda x: x.distance)
# draw list of first matches
img3 = drawMatches(img1, kp1, img2, kp2, matches)
# return adjacent images with matching lines
return img3
def __check_change_orb__(self, image, last_image):
"""
Computes ORB fetures on last saved slide and given image.
Tries to match features of these images and calculates ratio
of matched features with all found features in last saved slide
Args:
image(numpy.ndarray): Image from which to get features
last_image(numpy.ndarray): Image which we want to compare
Returns:
float: Similararity between last saved image and given image
"""
orb = cv.ORB()
kp1, ds1 = orb.detectAndCompute(self.last_image, None)
kp2, ds2 = orb.detectAndCompute(image, None)
bf = cv.BFMatcher(cv.NORM_HAMMING, crossCheck=True)
matches = bf.match(ds1, ds2)
return float(len(matches)) / len(kp1)
def image_local_features(image):
#llegim la imatge:
#img = cv2.imread(image)
#Cambiem la mida de la imatge:
if not image is None:
#linea que soluciona un bug de opencv a python3
#cv2.ocl.setUseOpenCL(False)
# Creem l'objecte ORB que tindrà 200k keypoints. (Perametre que podem modificar per no saturar el programa)
orb = cv2.ORB(200000)
# Detectem els keypoints:
kp_o = orb.detect(image, None)
# Calculem els descriptors amb els keypoints trobats.
kp, des = orb.compute(image, kp_o)
return des
def __init__(self, camera, bridge):
picamera.array.PiMotionAnalysis.__init__(self, camera)
self.bridge = bridge
self.br = tf.TransformBroadcaster()
self.posepub = rospy.Publisher('/pidrone/picamera/pose',
PoseStamped,
queue_size=1)
self.first_image_pub = rospy.Publisher("/pidrone/picamera/first_image",
Image,
queue_size=1,
latch=True)
self.detector = cv2.ORB(nfeatures=NUM_FEATURES,
scoreType=cv2.ORB_FAST_SCORE)
map_grid_kp, map_grid_des = create_map('map.jpg')
self.estimator = LocalizationParticleFilter(map_grid_kp, map_grid_des)
# [x, y, z, yaw]
self.pos = [0, 0, 0, 0]
self.posemsg = PoseStamped()
self.angle_x = 0.0
self.angle_y = 0.0
# localization does not estimate z
self.z = 0.0
self.first_locate = True
self.locate_position = False
self.prev_img = None
self.prev_kp = None
self.prev_des = None
self.prev_time = None
self.prev_rostime = None
self.map_counter = 0
self.max_map_counter = 0
# constant
self.alpha_yaw = 0.1 # perceived yaw smoothing alpha
self.hybrid_alpha = 0.3 # blend position with first frame and int
def __init__(self,
topic_name,
is_depth=False,
skip_frame=1,
directory_name='./',
bag_file=''):
rospy.logwarn("INIT IMAGE ORB SERIALIZER")
super(ImageORBSerializer, self).__init__(topic_name, skip_frame,
directory_name, bag_file)
self.file_ext = ".png"
self.orb_filename_base = self.dir_name + bag_file.split("/")[-1][:-4] + "/" + \
topic_name[1:].replace("/", "_") + "_orb/{:08d}"
self.orb_file_ext = ""
self.is_depth = is_depth
rospy.Subscriber(topic_name, Image, self.callback)
self.orb_descriptor = cv2.ORB()
