def get_best_matches(img1, img2, num_matches):
kp1, des1 = get_sift_data(img1)
kp2, des2 = get_sift_data(img2)
kp1, kp2 = np.array(kp1), np.array(kp2)
# Find distance between descriptors in images
dist = scipy.spatial.distance.cdist(des1, des2, 'sqeuclidean')
# Write your code to get the matches according to dist
# <YOUR CODE>
# des 1 is in row
# des 2 is in col
min_row = np.argmin(dist, axis=1)
min_col = np.argmin(dist, axis=0)
#use below idx as input to min_row
match_row_idx = [
i for i in range(0, len(min_row)) if min_col[min_row[i]] == i
]
#match_row_idx has feature id from des1 and min_row has corresponding feature from des2
kp_1_loc = cv2.KeyPoint_convert(kp1[match_row_idx])
kp_2_loc = cv2.KeyPoint_convert(kp2[min_row[match_row_idx]])
data = np.concatenate((kp_1_loc, kp_2_loc), axis=1)
return data
def compute(
self, image: np.ndarray, keypoints: typing.List[cv2.KeyPoint]
) -> typing.Tuple[typing.List[cv2.KeyPoint], typing.List]:
a, b = np.load(
f"{os.path.dirname(__file__)}/{BriefDescriptorExtractor.PAIRS_FILENAME}"
)
kps = cv2.KeyPoint_convert(keypoints)
# Filter keypoints
#print(f"kps: {kps.shape}")
kps = kps[np.all(np.append(
kps >= np.array([0, 0]) + BriefDescriptorExtractor.PATCH_SIZE / 2,
kps < np.array(image.shape) - 1 -
BriefDescriptorExtractor.PATCH_SIZE / 2,
axis=1),
axis=1)]
#print(f"kps: {kps.shape}")
descs = np.empty((0, 256), dtype=np.bool)
for kp in kps:
avals = image[tuple((kp + a).astype(np.int32).T)]
bvals = image[tuple((kp + b).astype(np.int32).T)]
desc = np.greater(avals, bvals)
descs = np.append(descs, desc.reshape(1, 256), axis=0)
#print(f"{descs.shape}: \n{descs}")
keypoints = cv2.KeyPoint_convert(kps.reshape(-1, 1, 2))
#descs = [bitarray(list(desc)) for desc in descs]
return (keypoints, descs)
def process_frame_flann(frame, poster):
poster_offset = (frame.shape[1], frame.shape[0])
red = (0, 0, 255)
poster_resize = cv2.copyMakeBorder(poster, 0,
frame.shape[0] - poster.shape[0], 0, 0,
cv2.BORDER_CONSTANT)
poster_kp, poster_des = orb.detectAndCompute(poster, None)
frame_kp, frame_des = orb.detectAndCompute(frame, None)
poster_kp_vec = cv2.KeyPoint_convert(poster_kp)
frame_kp_vec = cv2.KeyPoint_convert(frame_kp)
results1 = get_neighbours_flann(np.float32(poster_des),
np.float32(frame_des))
results2 = get_neighbours_flann(np.float32(frame_des),
np.float32(poster_des))
combod = np.concatenate((frame, poster_resize), axis=1)
for frame_idx in range(len(results1)):
poster_idx = results1[frame_idx][0].trainIdx
back_ref = results2[poster_idx][0].trainIdx
if frame_idx == back_ref:
poster_kp_pos = poster_kp_vec[back_ref]
frame_kp_pos = frame_kp_vec[poster_idx]
poster_img_pos = (int(poster_kp_pos[0] + poster_offset[0]),
int(poster_kp_pos[1]))
frame_img_pos = (int(frame_kp_pos[0]), int(frame_kp_pos[1]))
cv2.line(combod, poster_img_pos, frame_img_pos, red, 1)
return combod
def perform_sift(image1, keypoints1, image2, keypoints2):
keypoint_pixels1 = cv.KeyPoint_convert(keypoints1)
keypoint_pixels2 = cv.KeyPoint_convert(keypoints2)
keypoint_histogram1 = []
keypoint_histogram2 = []
keypoint_descriptors1 = []
keypoint_descriptors2 = []
magnitudes1, orientations1 = calculate_image_gradients(image1)
magnitudes2, orientations2 = calculate_image_gradients(image2)
keypoint_descriptors1, keypoint_coords1 = create_descriptor(keypoint_descriptors1, keypoint_histogram1, keypoints1, orientations1)
keypoint_descriptors2, keypoint_coords2 = create_descriptor(keypoint_descriptors2, keypoint_histogram2, keypoints2, orientations2)
best_matches = []
for x in range(len(keypoint_descriptors1)):
ssds = []
best_match_index = 0
for y in range(len(keypoint_descriptors2)):
ssd = ((np.square(keypoint_descriptors1[x] - keypoint_descriptors2[y])).sum())
ssds.append(ssd)
if min(ssds) == ssd:
best_match_index = y
ssdmin = min(ssds)
ssds.remove(min(ssds))
ssdminprime = min(ssds)
ssds.remove(min(ssds))
ratio_distance = ssdmin / ssdminprime
if ratio_distance < 0.8:
best_matches.append(cv.DMatch(x, best_match_index, 0))
matched_image = cv.drawMatches(image1, keypoints1, image2, keypoints2, best_matches, image1, flags=2)
cv.imshow("Matches", matched_image)
def compute_homography(matched_kp1, matched_kp2):
matched_pts1 = cv2.KeyPoint_convert(matched_kp1)
matched_pts2 = cv2.KeyPoint_convert(matched_kp2)
# Estimate the homography between the matches using RANSAC
H, inliers = cv2.findHomography(matched_pts1[:, [1, 0]],
matched_pts2[:, [1, 0]], cv2.RANSAC)
inliers = inliers.flatten()
return H, inliers
def get_unique(mp):
sort = sort_mp(mp)
match = np.concatenate((cv2.KeyPoint_convert(
sort[..., 0]), cv2.KeyPoint_convert(sort[..., 1])),
axis=1)
match = pd.DataFrame(match).reset_index()
max01 = set(match.groupby([0, 1]).max()["index"])
max23 = set(match.groupby([2, 3]).max()["index"])
unique = match.loc[(max01 & max23)]
return unique.values[:, 1:]
def triangulate_points(pose_1, pose_2, kp_l, kp_r):
if len(kp_l) < len(kp_r):
kp_r = cv2.KeyPoint_convert(kp_r[:len(kp_l)])
kp_l = cv2.KeyPoint_convert(kp_l)
else:
kp_l = cv2.KeyPoint_convert(kp_l[:len(kp_r)])
kp_r = cv2.KeyPoint_convert(kp_r)
triangulated = cv2.triangulatePoints(pose_1[:3, :], pose_2[:3, :],
kp_l[:2], kp_r[:2])
return triangulated / triangulated[3]
def preprocess(roi):
detector_params = cv2.SimpleBlobDetector_Params()
detector_params.filterByArea = True
detector_params.maxArea = 500
detector_params.minArea = 50
detector = cv2.SimpleBlobDetector_create(detector_params)
while True:
threshold = 30
_, roi = cv2.threshold(roi, threshold, 255, cv2.THRESH_BINARY)
roi = cv2.erode(roi, None, iterations=2)
roi = cv2.dilate(roi, None, iterations=4)
roi = cv2.medianBlur(roi, 5)
keypoints = detector.detect(roi)
roi = cv2.drawKeypoints(roi, keypoints, roi)
cv2.namedWindow('roi_processed',cv2.WINDOW_NORMAL)
cv2.resizeWindow('roi_processed', 600,600)
cv2.imshow('roi_processed', roi)
pts = cv2.KeyPoint_convert(keypoints)
if len(pts) == 0:
continue
else:
return pts[0]
def ICAngles(image, keypoints, half_patch_size, u_max):
"""Calculate angles via Intensity Centroids
"""
kp_position = cv.KeyPoint_convert(keypoints)
ptsize = len(kp_position)
for ptidx in range(ptsize):
m_01 = 0
m_10 = 0
for u in range(-half_patch_size, half_patch_size + 1):
m_10 = m_10 + u * image[int(kp_position[ptidx, 1]),
int(kp_position[ptidx, 0]) + u]
for v in range(1, half_patch_size + 1):
v_sum = 0
d = u_max[v]
for u in range(-d, d - 1):
val_plus = int(image[int(kp_position[ptidx, 1]) + v,
int(kp_position[ptidx, 0]) + u])
val_minus = int(image[int(kp_position[ptidx, 1]) - v,
int(kp_position[ptidx, 0]) + u])
v_sum = v_sum + (val_plus - val_minus)
m_10 = m_10 + u * (val_plus + val_minus)
m_01 = m_01 + v * v_sum
keypoints[ptidx].angle = math.atan2(float(m_01), float(m_10))
def GetFingers(self, frame):
img = removeBG(frame)
img = img[0:250, 0:250]
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
kernel = np.ones((5, 5), np.uint8)
blur_process = cv2.erode(gray, kernel, iterations=1)
blur_process = cv2.GaussianBlur(blur_process, (blurValue, blurValue),
0)
ret, blur_mask = cv2.threshold(blur_process, 25, 255,
cv2.THRESH_BINARY_INV)
blur = cv2.bitwise_and(gray, gray, mask=blur_mask)
blur_mask = cv2.GaussianBlur(blur, (blurValue, blurValue), 0)
ret, blur_mask = cv2.threshold(blur_mask, 27, 255,
cv2.THRESH_BINARY_INV)
blur = cv2.bitwise_and(gray, gray, mask=blur_mask)
detector_params = cv2.SimpleBlobDetector_Params()
detector_params.filterByArea = True
detector_params.maxArea = 1000
detector_params.minArea = 30
detector = cv2.SimpleBlobDetector_create(detector_params)
keypoints = detector.detect(blur_mask)
blur_mask = cv2.drawKeypoints(blur_mask, keypoints, blur_mask)
pts = cv2.KeyPoint_convert(keypoints)
return pts, gray
def find_keypoints(Image, Mask, Tile_H, Tile_W, nFeatures):
featureEngine = cv2.FastFeatureDetector_create()
H, W = Image.shape
kp = []
for y in range(0, H, Tile_H):
for x in range(0, W, Tile_W):
Patch_Img = Image[y:y + Tile_H, x:x + Tile_W]
Patch_Mask = Mask[y:y + Tile_H, x:x + Tile_W]
keypoints = featureEngine.detect(\
Patch_Img,mask=Patch_Mask)
for pt in keypoints:
pt.pt = (pt.pt[0] + x, pt.pt[1] + y)
if (len(keypoints) > nFeatures):
keypoints = sorted(keypoints,\
key=lambda x: -x.response)
for kpt in keypoints[0:nFeatures]:
kp.append(kpt)
else:
for kpt in keypoints:
kp.append(kpt)
trackPts = cv2.KeyPoint_convert(kp)
trackPts = np.expand_dims(trackPts, axis=1)
global debug
if debug == 1:
print("# Points Tracked : " + str(len(trackPts)))
return trackPts
def whereToSpray(self, final_mask, final_image):
# Setup SimpleBlobDetector parameters.
params = cv2.SimpleBlobDetector_Params()
# Filter by colour.
params.filterByColor = True
params.blobColor = 255
# Filter by Area.
params.filterByArea = True
params.minArea = 200
# Filter by Circularity
params.filterByCircularity = False
# Filter by Convexity
params.filterByConvexity = False
# Filter by Inertia
params.filterByInertia = False
# Set up the detector with new parameters
detector = cv2.SimpleBlobDetector_create(params)
# Detect blobs.
keypoints = detector.detect(final_mask)
#print(keypoints[0])
points = cv2.KeyPoint_convert(keypoints)
#These will be points with int values
publishable_points = []
for point in points:
x = int(point[0])
y = int(point[1])
publishable_points.append([x, y])
final_image = cv2.circle(final_image, (x, y), 10,(200, 0, 200), thickness = -1)
cv2.imshow("Final Output. Red - weed belief mask, purple - points to spray.", final_image)
self.publishPointCloud(publishable_points)
def compute_mma(self, kp1, kp2, good, th=3):
kp1 = cv2.KeyPoint_convert(kp1)
kp2 = cv2.KeyPoint_convert(kp2)
src_pts = np.float32([kp1[m.queryIdx] for m in good]).reshape(-1, 2)
dst_pts = np.float32([kp2[m.trainIdx] for m in good]).reshape(-1, 2)
N1 = src_pts.shape[0]
N2 = dst_pts.shape[0]
matching_score = 0
if N2 != 0 and N1 != 0:
norm = np.linalg.norm(src_pts - dst_pts, ord=None, axis=1)
is_match = norm <= th
match_n = np.sum(is_match)
matching_score = match_n / len(norm)
return matching_score
def compute_repeatability(self, kp1, kp2, th=3):
kp1 = cv2.KeyPoint_convert(kp1)
kp2 = cv2.KeyPoint_convert(kp2)
repeatability = 0
N1 = len(kp1)
N2 = len(kp2)
if N2 != 0 and N1 != 0:
kp1 = np.expand_dims(kp1, 1)
kp2 = np.expand_dims(kp2, 0)
norm = np.linalg.norm(kp1 - kp2, ord=None, axis=-1)
cnt1 = np.sum(np.min(norm, axis=1) <= th)
cnt2 = np.sum(np.min(norm, axis=0) <= th)
repeatability = (cnt1 + cnt2) / (N1 + N2)
return repeatability
def local_extract(self, image):
img_zip = None
score = None
if (self.pose_ld==0) or (self.pose_ld==1):
image = self.grayscele_fn(image)
kps, desc = self.local_descriptor(image)
kps = cv2.KeyPoint_convert(kps)
elif (self.pose_ld==2) or (self.pose_ld==3):
feat = self.local_descriptor.extract(image)
kps = feat["keypoints"][:,:2]
desc = feat['descriptors']
elif self.pose_ld==4:
rescale_size = [1024,960]
im, inp, sc = ex.read_image(image, "cuda", rescale_size, 0, False)
feat = self.local_descriptor({'image': inp})
kps = feat['keypoints']
desc = feat['descriptors']
score = feat['scores']
img_zip = {'img_tensor' : inp, \
'scale_factor' : sc}
return kps, desc, score, img_zip
def __find_four_key_point(self):
if (self.key_points is None):
self.__find_key_points(min_circularity=0.5, min_convexity=0.3)
if (len(self.key_points) == 0):
return []
hulls = cv2.convexHull(cv2.KeyPoint_convert(self.key_points))
points = [
[self.working_image.shape[0], self.working_image.shape[1]],
[0, self.working_image.shape[1]],
[self.working_image.shape[0], 0],
[0, 0]
]
for hull in hulls:
if (hull[0][0] + hull[0][1] < points[0][0] + points[0][1]):
points[0] = hull[0]
if (hull[0][0] - hull[0][1] > points[1][0] - points[1][1]):
points[1] = hull[0]
if (hull[0][0] - hull[0][1] < points[2][0] - points[2][1]):
points[2] = hull[0]
if (hull[0][0] + hull[0][1] > points[3][0] + points[3][1]):
points[3] = hull[0]
# edited because of LJK bad format, which doesn't provide
# right-bottom dots.
points[3] = [points[1][0], points[2][1]]
return points
def filter_corner(self, kp):
pts = cv.KeyPoint_convert(kp)
if len(pts) > 0:
a = np.array(pts)
# print(f'points\n-------\n{a}\n')
# print(f'{a[:,0]} {a[:,1]}')
h = np.median(a[:, 0], axis=0)
w = np.median(a[:, 1], axis=0)
median = np.array([h, w]).astype(int)
# print(f'median: {median}')
remove_idxs = []
i = 0
for _ in a:
# print(a[i][0])
# print(a[i][1])
if not self.valid_keypoint(median, a[i]):
remove_idxs.append(i)
i += 1
# print(f'idx\'s to remove: {remove_idxs}')
if len(remove_idxs) < len(a):
a = np.delete(a, remove_idxs, axis=0)
# a = np.average(a, axis=0).astype(int)
h = np.median(a[:, 0], axis=0)
w = np.median(a[:, 1], axis=0)
a = np.array([h, w]).astype(int)
# print(f'corner guess: {a}')
return a
return None
def corners(img, keypoints):
zoom = 5
ret = []
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
win_size = (3, 3)
zero_zone = (-1, -1)
criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 100, 0.1)
points = cv.KeyPoint_convert(keypoints)
corners = points
cv.cornerSubPix(gray, corners, win_size, zero_zone, criteria)
indexes = random.sample(range(0, len(points) - 1), 3)
for index in indexes:
y, x = points[index].astype("uint32")
ry, rx = corners[index]
im = cv.resize(img, None, fx=zoom, fy=zoom)
im = cv.circle(im, (zoom * y, zoom * x), 2, (255, 0, 0))
im = cv.circle(im, (int(zoom * ry), int(zoom * rx)), 2, (0, 255, 0))
t = max(zoom * (x - 5), 0)
b = zoom * (x + 5)
l = max(zoom * (y - 5), 0)
r = zoom * (y + 5)
window = im[t:b, l:r]
ret.append(window)
return ret
def compute(image):
sift = cv2.xfeatures2d.SIFT_create()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
keypoints = sift.detect(gray, None)
descriptors = sift.compute(gray, keypoints)
location = cv2.KeyPoint_convert(keypoints)
return keypoints, descriptors, location
def get_matched_points(kp1, kp2, matches):
"""
Args:
- kp1: list of KeyPoints
- kp2: list of KeyPoinst
- matches: list of DMatch
Returns:
- out_kp1: 2d ndarray (coordinates of matched kp1)
- out_kp2: 2d ndarray (cooridnates of matched kp2)
"""
query_Idx = [match.queryIdx for match in matches]
train_Idx = [match.trainIdx for match in matches]
coords1 = cv2.KeyPoint_convert(kp1)
coords2 = cv2.KeyPoint_convert(kp2)
out_kp1 = coords1[query_Idx, :]
out_kp2 = coords2[train_Idx, :]
return out_kp1, out_kp2
def draw_matches(img1, img2, sel_matches, k1, k2):
h1, w1 = img1.shape[:2]
h2, w2 = img2.shape[:2]
view = sp.zeros((max(h1, h2), w1 + w2, 3), sp.uint8)
view[:h1, :w1, 0] = img1
view[:h2, w1:, 0] = img2
view[:, :, 1] = view[:, :, 0]
view[:, :, 2] = view[:, :, 0]
position = None
if (sel_matches is not None) and (k2 is not None):
#don't use in final production
for m in sel_matches:
# draw the keypoints matches
color = tuple([sp.random.randint(0, 255) for _ in iter(range(3))])
cv2.line(
view, (int(k1[m.queryIdx].pt[0]), int(k1[m.queryIdx].pt[1])),
(int(k2[m.trainIdx].pt[0] + w1), int(k2[m.trainIdx].pt[1])),
color)
kp2 = [k2[m.trainIdx] for m in sel_matches]
kp1 = [k1[m.queryIdx] for m in sel_matches]
p1 = cv2.KeyPoint_convert(kp1)
p2 = cv2.KeyPoint_convert(kp2)
if sum(1 for _ in sel_matches) >= 4:
H, status = cv2.findHomography(p1, p2, cv2.RANSAC, 5.0)
else:
H, status = None, None
if H is not None:
corners = sp.float32([[0, 0], [w1, 0], [w1, h1], [0, h1]])
position = cv2.perspectiveTransform(corners.reshape(1, -1, 2),
H).reshape(-1, 2)
area = computeArea(position)
print("Area : " + str(area))
if area > (w2 * h2 / 150) and area < (w2 * h2 / 1.4):
corners = sp.int32(position + (w1, 0))
cv2.polylines(view, [corners], True, (255, 255, 255))
else:
position = None
cv2.imshow("view", view)
return position
def getKeypoints(self, img):
"""Use a feature detector to get keypoints in an image
:param img: image to detect keypoints in
:return: detected keypoints as array of points
"""
points2f = self.detector.detect(img, None)
keypoints = cv2.KeyPoint_convert(points2f)
return keypoints
def __main__():
videoFile = cv2.VideoCapture(fileName)
ret, frameRef = videoFile.read()
while(ret != True):
ret, frameRef = videoFile.read()
frameRef_gray = cv2.cvtColor(frameRef, cv2.COLOR_BGR2GRAY)
# frameRef = filterFrame(frameRef)
frameCurr_gray = cv2.equalizeHist(frameRef_gray)
regularPoints, markedPoints_ref, counterArr, mask, numRows, numColumns = initialValuesLK(frameRef, pointStep)
while videoFile.isOpened():
ret, frameCurr = videoFile.read()
frameCurr_gray = cv2.cvtColor(frameCurr, cv2.COLOR_BGR2GRAY)
# frameCurr = filterFrame(frameCurr)
frameCurr_gray = cv2.equalizeHist(frameCurr_gray)
if ret:
interestingPointsTemp_curr, interestingPointsTemp_ref, counterArrTemp = \
calculateOpticalFlowRegular(frameCurr_gray, frameRef_gray,
regularPoints, lkparams, numRows, numColumns)
markedPoints_curr, markedPoints_ref, counterArr = \
calculateOpticalFlowMarked(frameCurr_gray, frameRef_gray, markedPoints_ref,
counterArr, lkparams, numRows, numColumns)
blobFrame = cv2.equalizeHist(frameCurr_gray)
keypoints = detector.detect(blobFrame)
sizes = [x.size for x in keypoints]
keypoints = cv2.KeyPoint_convert(keypoints)
for i in range(len(markedPoints_curr)):
if(findNeibouringBlob(markedPoints_curr[i][0], keypoints, sizes)):
new = markedPoints_curr[i]
old = markedPoints_ref[i]
a, b = new.ravel()
c, d = old.ravel()
mask = cv2.line(mask, (a, b), (c, d), [0, 255, 0], 1)
frameCurr = cv2.circle(frameCurr, (a, b), 10, [255, 0, 0], -1)
frameRef_gray = frameCurr_gray
markedPoints_ref = np.concatenate((markedPoints_curr, interestingPointsTemp_curr), axis=0)
counterArr = counterArr + counterArrTemp
frameCurr = cv2.add(frameCurr, mask)
cv2.imshow('frame', frameCurr)
if cv2.waitKey(25) & 0xFF == ord('q'):
break
videoFile.release()
cv2.destroyAllWindows()
print("Successfully Completed!")
def dst2kps(dst, max_kps):
"""converting dst to keypoints indices then to keypoints objects"""
threshold = 0.1
while True:
kps_idx = list(
map(lambda x: tuple([int(i) for i in x]),
np.argwhere(dst > (dst.max() * threshold))))
if max_kps < 0 or len(kps_idx) <= max_kps: break
threshold += 0.02
return cv2.KeyPoint_convert(kps_idx)
def SHITOMASI_brief():
img1 = cv2.imread("../imgReferencia/img00.jpg")
gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
corners11 = cv2.goodFeaturesToTrack(gray, 100, 0.01, 10)
corners1 = np.int0(corners11)
kp1 = cv2.KeyPoint_convert(corners1)
brief = cv2.xfeatures2d.BriefDescriptorExtractor_create()
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
kp1, des1 = brief.compute(img1, kp1)
img2 = cv2.imread("../imgTeste/img1.jpg", 0)
corners22 = cv2.goodFeaturesToTrack(img2, 100, 0.01, 10)
corners2 = np.int0(corners22)
kp2 = cv2.KeyPoint_convert(corners2)
kp2, des2 = brief.compute(img2, kp2)
matches = bf.match(des1, des2)
def SHITOMASI_brisk():
img1 = cv2.imread("../imgReferencia/img00.jpg", 0)
corners11 = cv2.goodFeaturesToTrack(img1, 100, 0.01, 10)
corners1 = np.int0(corners11)
kp1 = cv2.KeyPoint_convert(corners1)
brisk = cv2.BRISK_create()
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
kp1, des1 = brisk.compute(img1, kp1)
img2 = cv2.imread("../imgTeste/img1.jpg", 0)
corners22 = cv2.goodFeaturesToTrack(img2, 100, 0.01, 10)
corners2 = np.int0(corners22)
kp2 = cv2.KeyPoint_convert(corners2)
kp2, des2 = brisk.compute(img2, kp2)
matches = bf.match(des1, des2)
def get_keypoints(frame, mask, detector, detector_params):
if detector == 'good':
kps = cv.goodFeaturesToTrack(frame, mask=mask, **detector_params)
return kps
elif detector == 'sift':
detec = cv.xfeatures2d.SIFT_create(**detector_params)
elif detector == 'surf':
detec = cv.xfeatures2d.SURF_create(**detector_params)
kps = detec.detect(frame, mask=mask)
return cv.KeyPoint_convert(kps)
def computeQuery(self, queryfeatures, trainfeatures, matches_threshold = 52, querry_ROI = None, train_ROI = None):
if trainfeatures is None:
print("[INFO] missing trainfeatures. Please "
"supply trainfeatures to the computeQuery function")
elif queryfeatures is None:
print("[INFO] missing an image query. Please "
"supply an image to query")
else:
# print("detecting matching descriptors")
(kp1, des1) = queryfeatures
(kp2, des2) = trainfeatures
# compute homography of our points. If the match is good then there should be a GOOD homography transformation
# between our query and train images. Furthermore the homography can be used to display the result
M = self.matchKeypoints(kp1, kp2, des1, des2, ratio=0.95, reprojThresh=5.0)
matchesH, homography, status = None, None, None
totalSuccess = 0
if M is not None:
(matchesH, H, status) = M
for success in status:
if success == 1:
totalSuccess += 1
if querry_ROI is not None and train_ROI is not None:
print(totalSuccess) # a count of all the matches found with ransac
print("the query image resolution is :" + str(querry_ROI.shape[0])
+ " x " + str(querry_ROI.shape[1]))
print("the train image resolution is :" + str(train_ROI.shape[0])
+ " x " + str(train_ROI.shape[1]))
self.drawMatches(querry_ROI, train_ROI, cv2.KeyPoint_convert(kp1), cv2.KeyPoint_convert(kp2),
matchesH, status)
# LEFT IS TRAIN IMAGE AND RIGHT IS QUERY IMAGE
# if the match is None, then there aren't enough matched
# keypoints to create a panorama
if totalSuccess == 0:
# cv2.imshow("ImageA", querry_ROI)
# cv2.imshow("ImageB", train_ROI)
# cv2.waitKey(0)
# cv2.destroyWindow("ImageA")
# cv2.destroyWindow("ImageB")
return False, totalSuccess
elif totalSuccess < matches_threshold:
# print("\n[INFO] Failure to match image. RANSAC has found very few matches that compute a homography ")
# self.drawMatches(querry_ROI, train_ROI, cv2.KeyPoint_convert(kp1), cv2.KeyPoint_convert(kp2),
# matchesH, status)
return False,totalSuccess
else:
# print("\n[INFO] Success, a match was made. RANSAC found a homography that fits "
# + str(totalSuccess) + " feature points.")
return True,totalSuccess
def HARRIS_freak(img):
img1 = cv2.imread("../imgReferencia/img00.jpg", 0)
freak = cv2.xfeatures2d.FREAK_create()
imagem1 = np.float32(img1)
dst1 = cv2.cornerHarris(imagem1, 2, 3, 0.04)
dst1 = cv2.dilate(dst1, None)
ret1, dst1 = cv2.threshold(dst1, 0.01 * dst1.max(), 255, 0)
dst1 = np.uint8(dst1)
ret1, labels1, stats1, centroids1 = cv2.connectedComponentsWithStats(dst1)
criteria1 = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100,
0.001)
corners1 = cv2.cornerSubPix(imagem1, np.float32(centroids1), (5, 5),
(-1, -1), criteria1)
matriz1 = []
for variavel in corners1:
array = np.array([variavel])
matriz1.append(array)
kp1 = cv2.KeyPoint_convert(matriz1)
kp1, des1 = freak.compute(img1, kp1)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
img2 = cv2.imread("../imgTeste/img" + str(img) + ".jpg", 0)
imagem2 = np.float32(img2)
dst2 = cv2.cornerHarris(imagem2, 2, 3, 0.04)
dst2 = cv2.dilate(dst2, None)
ret2, dst2 = cv2.threshold(dst2, 0.01 * dst2.max(), 255, 0)
dst2 = np.uint8(dst2)
ret2, labels2, stats2, centroids2 = cv2.connectedComponentsWithStats(dst2)
criteria2 = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100,
0.001)
corners2 = cv2.cornerSubPix(imagem2, np.float32(centroids2), (5, 5),
(-1, -1), criteria2)
matriz2 = []
for variavel in corners2:
array = np.array([variavel])
matriz2.append(array)
kp2 = cv2.KeyPoint_convert(matriz2)
kp2, des2 = freak.compute(img2, kp2)
matches = bf.match(des1, des2)
def disparity_orb(left, right):
orb_detector = cv2.ORB_create()
BF_matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
kp1, des1 = orb_detector.detectAndCompute(left, None)
kp2, des2 = orb_detector.detectAndCompute(right, None)
matches = BF_matcher.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
kp1 = cv2.KeyPoint_convert(kp1)
kp2 = cv2.KeyPoint_convert(kp2)
matching_points_left = []
matching_points_right = []
for match in matches:
matching_points_left.append(
(kp2[match.trainIdx][0], kp2[match.trainIdx][1]))
matching_points_right.append(
(kp1[match.queryIdx][0], kp1[match.queryIdx][1]))
output_image_l = np.zeros(left.shape, np.uint8)
output_image_r = np.zeros(left.shape, np.uint8)
for temp in range(len(matching_points_right)):
output_image_l[int(matching_points_left[temp][1])][int(
matching_points_left[temp][0])] = np.abs(
matching_points_right[temp][0] - matching_points_left[temp][0])
output_image_r[int(matching_points_right[temp][1])][int(
matching_points_right[temp][0])] = np.abs(
matching_points_right[temp][0] - matching_points_left[temp][0])
output_image_l = cv2.normalize(output_image_l,
None,
alpha=0,
beta=255,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_8UC1)
output_image_r = cv2.normalize(output_image_r,
None,
alpha=0,
beta=255,
norm_type=cv2.NORM_MINMAX,
dtype=cv2.CV_8UC1)
return output_image_l + output_image_r
