Merge remote-tracking branch 'refs/remotes/upstream/SRIF' into SRIF

Author: gperda

scripts/keypoint_density_evaluation.py

@@ -18,6 +18,8 @@ def ProjectionsOfTriangulatedTiePoints(
 
     image_projections = {}
     reconstruction = pycolmap.Reconstruction(model_path)
+    average_tie_points = []
+    average_tie_points_also_not_triangulated = []
 
     for image in tqdm(reconstruction.images.values(), desc="Find projections that have a corresponding 3D tie points"):
         camera_id = image.camera_id
@@ -26,19 +28,27 @@ def ProjectionsOfTriangulatedTiePoints(
         height = camera.height
 
         projections = []
+        tot_tie_points = 0
+        tot_tie_points_also_not_triangulated = 0
         for feature_idx, point2D in enumerate(image.points2D):
             #if point2D.has_point3D:
             if point2D.point3D_id < 1000000:
                 #print(point2D.point3D_id);quit()
                 #print(point2D.has_point3D.__getattribute__)
                 #print(type(point2D.has_point3D))
                 #quit()
+                tot_tie_points += 1
+                tot_tie_points_also_not_triangulated += 1
                 x, y = point2D.xy
                 x, y = x, (height-y)
                 projections.append((image.image_id, (x,y), width, height))
+            else:
+                tot_tie_points_also_not_triangulated += 1
         image_projections[image] = projections
+        average_tie_points.append(tot_tie_points)
+        average_tie_points_also_not_triangulated.append(tot_tie_points_also_not_triangulated)
 
-    return image_projections
+    return image_projections, np.mean(average_tie_points), np.mean(average_tie_points_also_not_triangulated)
 
 def ComupteMetrics(
         output_dir: Path,
@@ -75,11 +85,11 @@ def ComupteMetrics(
     transform = from_origin(xmin, ymax, resolution, resolution)
 
     zero_cells = np.count_nonzero(density_grid == 0)
-    print(f"Image: {image_name}")
-    print(f"Number of cells with zero density: {zero_cells}")
-    print(f"Total number of cells: {rows * cols}")
+    #print(f"Image: {image_name}")
+    #print(f"Number of cells with zero density: {zero_cells}")
+    #print(f"Total number of cells: {rows * cols}")
     covered_area = ((rows * cols)-zero_cells) / (rows * cols) * 100
-    print(f"Percentage of cells with non zero density: {covered_area}%")
+    #print(f"Percentage of cells with non zero density: {covered_area}%")
 
     density_grid_normalized = zoom(
         density_grid_normalized, 
@@ -107,20 +117,25 @@ def ComupteMetrics(
     parser = argparse.ArgumentParser(
         description="Export pairs in a txt file from a COLMAP database."
     )
-    parser.add_argument("-d", "--database", type=Path, required=True, help="Path to COLMAP database.")
-    parser.add_argument("-m", "--min_n_matches", type=int, required=True, help="Min number of matches that a pair should have after geometric verification.")
-    parser.add_argument("-o", "--output", type=Path, required=True, help="Path to output folder.")
+    #parser.add_argument("-d", "--database", type=Path, required=True, help="Path to COLMAP database.")
+    #parser.add_argument("-m", "--min_n_matches", type=int, required=True, help="Min number of matches that a pair should have after geometric verification.")
+    #parser.add_argument("-o", "--output", type=Path, required=True, help="Path to output folder.")
     parser.add_argument("-l", "--model", type=Path, required=True, help="Path to model folder.")
     args = parser.parse_args()
 
-    image_projections = ProjectionsOfTriangulatedTiePoints(model_path=args.model)
+    image_projections, mean_tie_points, mean_tie_points_also_not_triangulated = ProjectionsOfTriangulatedTiePoints(model_path=args.model)
+    print('Mean number of tie points per image:', mean_tie_points)
+    print('Mean number of tie points per image also not triangulated:', mean_tie_points_also_not_triangulated)
+    print(f"Inlier ratio: {mean_tie_points / mean_tie_points_also_not_triangulated}")
 
     results = {}
+    output_dir = Path(args.model) / "tie_points_density"
+    output_dir.mkdir(parents=True, exist_ok=True)
 
     for image in tqdm(image_projections, desc="Compute metrics"):
         #print(f"Image: {image.name} - Number of projections: {len(image_projections[image])}")
         image_name, covered_area = ComupteMetrics(
-                                        output_dir=Path(args.output),
+                                        output_dir=output_dir,
                                         image_name=image.name,
                                         projections=image_projections[image],
                                         scale_max_value=1,

scripts/mount_video.py

@@ -4,6 +4,7 @@
 # Function to create video from images in a folder
 def images_to_video(image_folder, output_video_path, frame_duration=0.5):
     images = [img for img in os.listdir(image_folder) if img.endswith(".png")]
+    #images.sort(key=lambda x: int(x.split('_')[0]))
     frame = cv2.imread(os.path.join(image_folder, images[0]))
 
     # Get image dimensions

scripts/resize_images.py

@@ -10,7 +10,7 @@ def resize_images(input_folder, output_folder, new_resolution):
 
     # Loop through all files in the input folder
     for filename in os.listdir(input_folder):
-        if filename.endswith((".jpg", ".jpeg", ".png", ".gif")):
+        if filename.endswith((".jpg", ".jpeg", ".png", ".gif", ".tif")):
             input_path = os.path.join(input_folder, filename)
             output_path = os.path.join(output_folder, filename)
 

scripts/show_matches.py

@@ -105,11 +105,11 @@ def LoadDatabase(self):
                         (int(pair_id[0]), int(pair_id[1]))
                     ] = blob_to_array(data, np.uint32, (-1, 2))
 
-    def ShowMatches(self):
+    def ShowMatches(self, plot_config: dict):
         if self.db_type == "colmap":
-            self.ShowColmapMatches()
+            self.ShowColmapMatches(plot_config)
 
-    def ShowColmapMatches(self):
+    def ShowColmapMatches(self, plot_config: dict):
         print("Showing matches..")
         if self.imgs_dict["type"] == "ids":
             id0 = int(self.imgs_dict["data"][0])
@@ -133,7 +133,7 @@ def ShowColmapMatches(self):
         try:
             print("verified matches shape", np.shape(self.two_views_matches[(id0, id1)]))
         except:
-            pass
+            self.two_views_matches[(id0, id1)] = []
 
         img0_path = self.imgs_dir / self.imgs[id0]
         img1_path = self.imgs_dir / self.imgs[id1]
@@ -146,6 +146,7 @@ def ShowColmapMatches(self):
             keypoints0,
             keypoints1,
             self.two_views_matches[(id0, id1)],
+            plot_config,
         )
 
     def GeneratePlot(
@@ -155,7 +156,14 @@ def GeneratePlot(
         kpts0: np.ndarray,
         kpts1: np.ndarray,
         matches: np.ndarray,
+        plot_config: dict,
     ):
+        
+        show_keypoints = plot_config["show_keypoints"]
+        radius = plot_config["radius"]
+        thickness = plot_config["thickness"]
+        space_between_images = plot_config["space_between_images"]
+
         # Load images
         img0 = cv2.imread(str(img0_path))
         img1 = cv2.imread(str(img1_path))
@@ -166,32 +174,34 @@ def GeneratePlot(
 
         # Create a new image to draw matches
         img_matches = np.zeros(
-            (max(img0.shape[0], img1.shape[0]), img0.shape[1] + img1.shape[1], 3),
+            (max(img0.shape[0], img1.shape[0]), img0.shape[1] + img1.shape[1] + space_between_images, 3),
             dtype=np.uint8,
         )
         img_matches[: img0.shape[0], : img0.shape[1]] = img0
-        img_matches[: img1.shape[0], img0.shape[1] :] = img1
+        img_matches[: img1.shape[0], img0.shape[1]+space_between_images :] = img1
+        img_matches[: img1.shape[0], img0.shape[1] : img0.shape[1]+space_between_images] = (255,255,255)
 
-        # Show keypoints
-        for kpt in kpts0_int:
-            kpt = tuple(kpt)
-            cv2.circle(img_matches, kpt, 3, (0, 0, 255), -1)
+        if show_keypoints:
+            # Show keypoints
+            for kpt in kpts0_int:
+                kpt = tuple(kpt)
+                cv2.circle(img_matches, kpt, radius, (0, 0, 255), thickness)
 
-        for kpt in kpts1_int:
-            kpt = tuple(kpt + np.array([img0.shape[1], 0]))
-            cv2.circle(img_matches, kpt, 3, (0, 0, 255), -1)
+            for kpt in kpts1_int:
+                kpt = tuple(kpt + np.array([img0.shape[1], 0]))
+                cv2.circle(img_matches, kpt, radius, (0, 0, 255), thickness)
 
         # Draw lines and circles for matches
         for match in matches:
             pt1 = tuple(kpts0_int[match[0]])
             pt2 = tuple(np.array(kpts1_int[match[1]]) + np.array([img0.shape[1], 0]))
 
             # Draw a line connecting the keypoints
-            cv2.line(img_matches, pt1, pt2, (0, 255, 0), 1)
+            cv2.line(img_matches, pt1, pt2, (0, 255, 0), thickness)
 
             # Draw circles around keypoints
-            cv2.circle(img_matches, pt1, 3, (255, 0, 0), -1)
-            cv2.circle(img_matches, pt2, 3, (255, 0, 0), -1)
+            cv2.circle(img_matches, pt1, radius, (255, 0, 0), thickness)
+            cv2.circle(img_matches, pt2, radius, (255, 0, 0), thickness)
 
         img_matches_resized = self.resize_image(img_matches, self.max_out_img_size)
 
@@ -256,6 +266,13 @@ def parse_args():
 
 
 def main():
+    plot_config = {
+        "show_keypoints": True,
+        "radius": 5,
+        "thickness": 2,
+        "space_between_images": 0,
+    }
+    
     args = parse_args()
     database_path = Path(args.database)
     out_dir = Path(args.output)
@@ -283,7 +300,7 @@ def main():
         )
 
         show_pair_matches.LoadDatabase()
-        show_pair_matches.ShowMatches()
+        show_pair_matches.ShowMatches(plot_config)
 
     else:
         pairs = generate_pairs(imgs_dir, method="bruteforce", database_path=database_path)
@@ -306,9 +323,10 @@ def main():
             )
 
             show_pair_matches.LoadDatabase()
+            #show_pair_matches.ShowMatches(plot_config);quit()
 
             try:
-                show_pair_matches.ShowMatches()
+                show_pair_matches.ShowMatches(plot_config)
             except:
                 print("No verified matches found")
 

src/deep_image_matching/config.py

@@ -45,11 +45,11 @@
     #   GeometricVerification.MAGSAC (use opencv MAGSAC),
     #   Other methods: RANSAC, LMEDS, RHO, USAC_DEFAULT, USAC_PARALLEL, USAC_FM_8PTS, USAC_FAST, USAC_ACCURATE, USAC_PROSAC, USAC_MAGSAC
     "geom_verification": GeometricVerification.MAGSAC,
-    "gv_threshold": 1,
+    "gv_threshold": 4,
     "gv_confidence": 0.99999,
     # Minimum number of inliers matches and minumum inlier ratio per pair
     "min_inliers_per_pair": 15,
-    "min_inlier_ratio_per_pair": 0.25,
+    "min_inlier_ratio_per_pair": 0.15,
     # Even if the features are extracted by tiles, you can try to match the features of the entire image first (if the number of features is not too high and they can fit into memory). Default is False.
     "try_match_full_images": False,
     "preselection_pipeline": "superpoint+lightglue",
@@ -66,7 +66,7 @@
             "name": "superpoint",
             "nms_radius": 3,
             "keypoint_threshold": 0.0005,
-            "max_keypoints": 4096,
+            "max_keypoints": 2048,
         },
         "matcher": {
             # Refer to https://github.com/cvg/LightGlue/tree/main for the meaning of the parameters
@@ -156,6 +156,11 @@
     "sift+kornia_matcher": {
         "extractor": {
             "name": "sift",
+            "n_features": 2048,
+            "nOctaveLayers": 3,
+            "contrastThreshold": 0.0004,
+            "edgeThreshold": 10,
+            "sigma": 1.6,
         },
         "matcher": {"name": "kornia_matcher", "match_mode": "smnn", "th": 0.85},
     },

src/deep_image_matching/matchers/srif.py

@@ -124,7 +124,7 @@ def _match_pairs(
             F, inlMask = pydegensac.findFundamentalMatrix(
                 mkpts0,
                 mkpts1,
-                px_th=1.0,
+                px_th=4.0,
                 conf=0.99,
                 max_iters=10000,
             )