mirror of
https://github.com/nerfstudio-project/nerfstudio.git
synced 2026-11-19 06:14:03 +08:00
Added aligning interface
This commit is contained in:
1 parent
b3e2a391fd
commit
3176d6a8f6
4 files changed
+411
-3
No files matched your search
@@ -0,0 +1,212 @@
|
||||
import cv2
|
||||
from matplotlib import pyplot as plt
|
||||
import numpy as np
|
||||
import os
|
||||
|
||||
class ContourTooSmallException(Exception):
|
||||
pass
|
||||
|
||||
class Image:
|
||||
def __init__(self, image, threshold = 5):
|
||||
self.image = image.copy()
|
||||
self.threshold = threshold
|
||||
self.gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
|
||||
_, self.thresholded = cv2.threshold(self.gray, threshold, 255, cv2.THRESH_BINARY)
|
||||
self.contours, _ = cv2.findContours(self.thresholded, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
|
||||
|
||||
class Contour:
|
||||
def __init__(self, contour, well_image_threshold_index = None, min_area = 50.0):
|
||||
self.contour = contour
|
||||
self.area = cv2.contourArea(contour)
|
||||
if self.area < min_area:
|
||||
raise ContourTooSmallException(f"Contour area {self.area} is too small.")
|
||||
self.centroid = np.mean(contour, axis=0)[0]
|
||||
self.relative_position = None
|
||||
self.match = None
|
||||
self.score = float('inf')
|
||||
self.well_image_threshold_index = well_image_threshold_index
|
||||
|
||||
def overlap(self, contour):
|
||||
image_shape = (960, 960)
|
||||
mask1 = np.zeros(image_shape, dtype=np.uint8)
|
||||
mask2 = np.zeros(image_shape, dtype=np.uint8)
|
||||
cv2.drawContours(mask1, [self.contour], -1, 255, thickness=cv2.FILLED)
|
||||
cv2.drawContours(mask2, [contour.contour], -1, 255, thickness=cv2.FILLED)
|
||||
overlap_mask = cv2.bitwise_and(mask1, mask2)
|
||||
overlap_area = np.sum(overlap_mask) / 255
|
||||
return overlap_area > 0
|
||||
|
||||
def get_matching_score(self, contour):
|
||||
dist_shape = cv2.matchShapes(self.contour, contour.contour, cv2.CONTOURS_MATCH_I2, 0.0)
|
||||
dist_spatial = np.linalg.norm(np.array(self.centroid) - np.array(contour.centroid))
|
||||
return 0.7 * dist_shape + 0.3 * dist_spatial
|
||||
|
||||
def match_contour(self, contour, score):
|
||||
self.match = contour
|
||||
self.score = score
|
||||
|
||||
def unmatch_contour(self):
|
||||
self.match = None
|
||||
self.score = float('inf')
|
||||
|
||||
def get_points(self):
|
||||
return self.contour[:, 0, :]
|
||||
|
||||
|
||||
class AlignImages:
|
||||
def __init__(self, well_image, fast_image):
|
||||
self.fast_image = Image(fast_image)
|
||||
self.fast_contours = []
|
||||
for contour in self.fast_image.contours:
|
||||
try:
|
||||
contour_obj = Contour(contour)
|
||||
self.fast_contours.append(contour_obj)
|
||||
except ContourTooSmallException as e:
|
||||
continue
|
||||
self.matched_well_contours = [None] * len(self.fast_contours)
|
||||
self.well_image = Image(well_image)
|
||||
self.well_images = []
|
||||
self.well_thresholds = (230, 235, 240, 245, 250)
|
||||
for threshold in self.well_thresholds:
|
||||
self.well_images.append(Image(well_image, threshold))
|
||||
self.image_height, self.image_width = self.fast_image.image.shape[:2]
|
||||
|
||||
def all_contours_matched(self):
|
||||
for contour in self.fast_contours:
|
||||
if contour.match == None:
|
||||
return False
|
||||
return True
|
||||
|
||||
def existing_contour_match(self, contour):
|
||||
for i, existing_contour in enumerate(self.matched_well_contours):
|
||||
if existing_contour != None and contour.overlap(existing_contour):
|
||||
return i, self.fast_contours[i]
|
||||
return None, None
|
||||
|
||||
def delete_unmatched_contours(self):
|
||||
for contour_index in range(len(self.fast_contours) -1, -1, -1):
|
||||
if self.fast_contours[contour_index].match == None or self.matched_well_contours[contour_index] == None:
|
||||
del self.fast_contours[contour_index]
|
||||
del self.matched_well_contours[contour_index]
|
||||
|
||||
def match_contours(self):
|
||||
iterations = 0
|
||||
while not self.all_contours_matched():
|
||||
if iterations >= 5:
|
||||
self.delete_unmatched_contours()
|
||||
break
|
||||
for contour_index, fast_contour in enumerate(self.fast_contours):
|
||||
for threshold_index, _ in enumerate(self.well_thresholds):
|
||||
for well_contour in self.well_images[threshold_index].contours:
|
||||
try:
|
||||
well_contour = Contour(well_contour, threshold_index)
|
||||
score = fast_contour.get_matching_score(well_contour)
|
||||
if score < fast_contour.score:
|
||||
if score >= 200:
|
||||
continue
|
||||
match_index, match = self.existing_contour_match(well_contour)
|
||||
if match != None:
|
||||
if score < match.score:
|
||||
match.unmatch_contour()
|
||||
self.matched_well_contours[match_index] = None
|
||||
fast_contour.match_contour(well_contour, score)
|
||||
self.matched_well_contours[contour_index] = well_contour
|
||||
else:
|
||||
continue
|
||||
else:
|
||||
fast_contour.match_contour(well_contour, score)
|
||||
self.matched_well_contours[contour_index] = well_contour
|
||||
except ContourTooSmallException as e:
|
||||
continue
|
||||
iterations += 1
|
||||
return list(zip(self.matched_well_contours, self.fast_contours))
|
||||
|
||||
def get_point_descriptors(self, points, image):
|
||||
sift = cv2.SIFT_create()
|
||||
keypoints = [cv2.KeyPoint(x=float(p[0]), y=float(p[1]), size=20) for p in points]
|
||||
keypoints, descriptors = sift.compute(image, keypoints)
|
||||
return descriptors
|
||||
|
||||
def match_points(self, well_contour, fast_contour):
|
||||
well_points = well_contour.get_points()
|
||||
fast_points = fast_contour.get_points()
|
||||
well_descriptors = self.get_point_descriptors(well_points, self.well_images[well_contour.well_image_threshold_index].thresholded)
|
||||
fast_descriptors = self.get_point_descriptors(fast_points, self.fast_image.thresholded)
|
||||
bf = cv2.BFMatcher()
|
||||
matches = bf.match(fast_descriptors, well_descriptors)
|
||||
matches = sorted(matches, key=lambda x: x.distance)
|
||||
fast_matched_points = [fast_points[m.queryIdx] for m in matches]
|
||||
well_matched_points = [well_points[m.trainIdx] for m in matches]
|
||||
return well_matched_points, fast_matched_points
|
||||
|
||||
def alignImages(self):
|
||||
matched_contours = self.match_contours()
|
||||
# show_contours(self.well_images[5].thresholded, self.well_images[4].thresholded, matched_contours)
|
||||
well_points_combined = []
|
||||
fast_points_combined = []
|
||||
for well_contour, fast_contour in matched_contours:
|
||||
well_matched_points, fast_matched_points = self.match_points(well_contour, fast_contour)
|
||||
well_points_combined.extend(well_matched_points)
|
||||
fast_points_combined.extend(fast_matched_points)
|
||||
# show_points(well_image, fast_image, well_points_combined, fast_points_combined)
|
||||
if len(well_points_combined) >= 4:
|
||||
well_points = np.float32(well_points_combined)
|
||||
fast_points = np.float32(fast_points_combined)
|
||||
H, mask = cv2.findHomography(fast_points, well_points, cv2.RANSAC, 5.0)
|
||||
warped_image = cv2.warpPerspective(self.fast_image.image, H, (self.image_width, self.image_height))
|
||||
else:
|
||||
print("Not enough points for homography.")
|
||||
return warped_image, H
|
||||
|
||||
def show_contours(well_image, fast_image, matched_contours):
|
||||
well_image_c = well_image.copy()
|
||||
fast_image_c = fast_image.copy()
|
||||
|
||||
for well_contour, fast_contour in matched_contours:
|
||||
color = tuple(np.random.randint(0, 256, 3).tolist())
|
||||
cv2.drawContours(well_image_c, well_contour.contour, -1, color, 2)
|
||||
cv2.drawContours(fast_image_c, fast_contour.contour, -1, color, 2)
|
||||
|
||||
fig, axes = plt.subplots(1, 2, figsize=(120, 120), gridspec_kw={'wspace': 0, 'hspace': 0})
|
||||
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
|
||||
axes[1].imshow(well_image_c)
|
||||
axes[1].axis('off')
|
||||
axes[0].imshow(fast_image_c)
|
||||
axes[0].axis('off')
|
||||
|
||||
fig.canvas.draw()
|
||||
plt.show()
|
||||
|
||||
def show_points(well_image, fast_image, well_points, fast_points):
|
||||
well_image_c = well_image.copy()
|
||||
fast_image_c = fast_image.copy()
|
||||
|
||||
for p1 in well_points:
|
||||
cv2.circle(well_image_c, tuple(p1), 2, (0, 255, 0), -1)
|
||||
|
||||
for p2 in fast_points:
|
||||
cv2.circle(fast_image_c, tuple(p2), 2, (0, 255, 0), -1)
|
||||
|
||||
fig, axes = plt.subplots(1, 2, figsize=(20, 10))
|
||||
axes[0].imshow(well_image_c)
|
||||
axes[0].axis('off')
|
||||
axes[0].set_title('Well-exposed Image with Points')
|
||||
axes[1].imshow(fast_image_c)
|
||||
axes[1].axis('off')
|
||||
axes[1].set_title('Aligned Fast-exposed Image')
|
||||
plt.show()
|
||||
|
||||
def align(well_image, fast_image):
|
||||
align_images = AlignImages(well_image, fast_image)
|
||||
return align_images.alignImages()
|
||||
|
||||
if __name__ == '__main__':
|
||||
index = 0
|
||||
path_well = '...'
|
||||
path_fast = '...'
|
||||
well_images = sorted(os.listdir(path_well))
|
||||
fast_images = sorted(os.listdir(path_fast))
|
||||
well_image = cv2.cvtColor(cv2.imread(os.path.join(path_well, well_images[index])), cv2.COLOR_BGR2RGB)
|
||||
fast_image = cv2.cvtColor(cv2.imread(os.path.join(path_fast, fast_images[index])), cv2.COLOR_BGR2RGB)
|
||||
|
||||
warped_image, H = align(well_image, fast_image)
|
||||
Reference in new issue
Block a user