lightglue matcher

.gitignore

@@ -1,3 +1,6 @@
 vocab_tree_flickr100K_words1M.bin
 vocab_tree_flickr100K_words256K.bin
-vocab_tree_flickr100K_words32K.bin
+vocab_tree_flickr100K_words32K.bin
+
+LightGlue/
+__pycache__/

colmap_matcher.sh

@@ -26,7 +26,7 @@ python3 Baselines/colmap/create_colmap_image_list.py "$rgb_csv" "$colmap_image_l
 # Create Colmap Database
 database="${exp_folder_colmap}/colmap_database.db"
 rm -rf ${database}
-colmap database_creator --database_path ${database}
+colmap database_creator --database_path ${database} 
 
 # Feature extractor
 echo "    colmap feature_extractor ..."
@@ -141,4 +141,15 @@ then
     --SequentialMatching.loop_detection 1 \
     --SequentialMatching.vocab_tree_path ${vocabulary_tree} \
     --FeatureMatching.use_gpu "${use_gpu}"
-fi
+fi
+
+# LightGlue Feature Matcher
+if [ "${matcher_type}" == "lightglue" ]
+then
+  pixi run -e colmap-sp python3 Baselines/colmap/lightglue_matcher.py 
+  colmap matches_importer \
+      --database_path ${database} \
+      --match_list_path "${exp_folder_colmap}/matches.txt" \
+      --match_type raw 
+fi
+

lightglue_matcher.py

@@ -0,0 +1,343 @@
+import sqlite3
+from utilities import lightglue_keypoints, lightglue_matching, unrotate_kps_W
+import os
+import torch
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import numpy as np
+import cv2
+import random
+
+# ==========================================
+# CONFIGURATION
+# ==========================================
+DB_PATH = "/home/alejandro/VSLAM-LAB-NEXT-ITERATION/VSLAM-LAB-Evaluation/demo/SESOKO/sskall-s01/colmap_00000/colmap_database.db"
+IMAGE_DIR = "/home/alejandro/VSLAM-LAB-NEXT-ITERATION/VSLAM-LAB-Benchmark/SESOKO/sskall-s01/rgb_0"
+FEATURE_TYPE = 'superpoint' 
+DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+matches_file_path = os.path.join(os.path.dirname(DB_PATH), "matches.txt")
+
+# ==========================================
+# ==========================================
+# DATABASE UTILITIES
+# ==========================================
+def load_colmap_db(db_path): 
+    if not os.path.exists(db_path):
+        raise FileNotFoundError(f"Database file not found: {db_path}")
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    return conn, cursor
+
+def create_pair_id(image_id1, image_id2):
+    if image_id1 > image_id2:
+        image_id1, image_id2 = image_id2, image_id1
+    return image_id1 * 2147483647 + image_id2
+
+def clean_database(cursor):
+    """Removes existing features and matches to ensure a clean overwrite."""
+    tables = ["keypoints", "descriptors"]#, "matches"], "two_view_geometry"]
+    for table in tables:
+        cursor.execute(f"DELETE FROM {table};")
+    print("Database cleaned (keypoints, descriptors, matches removed).")
+
+def insert_keypoints(cursor, image_id, keypoints, descriptors):
+    """
+    keypoints: (N, 2) numpy array, float32
+    descriptors: (N, D) numpy array, float32
+    """
+    keypoints_blob = keypoints.tobytes()
+    descriptors_blob = descriptors.tobytes()
+    
+    # Keypoints
+    cursor.execute(
+        "INSERT INTO keypoints(image_id, rows, cols, data) VALUES(?, ?, ?, ?)",
+        (image_id, keypoints.shape[0], keypoints.shape[1], keypoints_blob)
+    )
+    
+    # Descriptors (Optional but good practice)
+    cursor.execute(
+        "INSERT INTO descriptors(image_id, rows, cols, data) VALUES(?, ?, ?, ?)",
+        (image_id, descriptors.shape[0], descriptors.shape[1], descriptors_blob)
+    )
+
+def insert_matches(cursor, image_id1, image_id2, matches):
+    """
+    matches: (K, 2) numpy array, uint32. 
+             Col 0 is index in image1, Col 1 is index in image2
+    """
+    pair_id = create_pair_id(image_id1, image_id2)
+    matches_blob = matches.tobytes()
+    
+    cursor.execute(
+        "INSERT INTO matches(pair_id, rows, cols, data) VALUES(?, ?, ?, ?)",
+        (pair_id, matches.shape[0], matches.shape[1], matches_blob)
+    )
+
+def verify_matches_visual(cursor, image_id1, image_id2, image_dir):
+    """
+    Reads matches and keypoints from the COLMAP db and plots them.
+    
+    Args:
+        cursor: SQLite cursor connected to the database.
+        image_id1: ID of the first image.
+        image_id2: ID of the second image.
+        image_dir: Path to the directory containing the images.
+    """
+    
+    # 1. Helper to ensure image_id1 < image_id2 for pair_id calculation
+    if image_id1 > image_id2:
+        image_id1, image_id2 = image_id2, image_id1
+        swapped = True
+    else:
+        swapped = False
+        
+    pair_id = image_id1 * 2147483647 + image_id2
+
+    # 2. Fetch Matches
+    cursor.execute("SELECT data FROM matches WHERE pair_id = ?", (pair_id,))
+    match_row = cursor.fetchone()
+    
+    if match_row is None:
+        print(f"No matches found in DB for pair {image_id1}-{image_id2}")
+        return
+
+    # Decode Matches: UINT32 (N, 2)
+    matches = np.frombuffer(match_row[0], dtype=np.uint32).reshape(-1, 2)
+
+    # If we swapped inputs to generate pair_id, we must swap columns in matches
+    # so matches[:,0] corresponds to the requested image_id1
+    if swapped:
+        matches = matches[:, [1, 0]]
+
+    # 3. Fetch Keypoints for both images
+    def get_keypoints_and_name(img_id):
+        # Get Name
+        cursor.execute("SELECT name FROM images WHERE image_id = ?", (img_id,))
+        name = cursor.fetchone()[0]
+        
+        # Get Keypoints
+        cursor.execute("SELECT data FROM keypoints WHERE image_id = ?", (img_id,))
+        kp_row = cursor.fetchone()
+        # Decode Keypoints: FLOAT32 (N, 2)
+        kpts = np.frombuffer(kp_row[0], dtype=np.float32).reshape(-1, 2)
+        return name, kpts
+
+    name1, kpts1 = get_keypoints_and_name(image_id1)
+    name2, kpts2 = get_keypoints_and_name(image_id2)
+
+    # 4. Filter Keypoints using the Matches indices
+    # matches[:, 0] are indices into kpts1
+    # matches[:, 1] are indices into kpts2
+    valid_kpts1 = kpts1[matches[:, 0]]
+    valid_kpts2 = kpts2[matches[:, 1]]
+
+    # 5. Load Images
+    path1 = os.path.join(image_dir, name1)
+    path2 = os.path.join(image_dir, name2)
+    
+    img1 = cv2.imread(path1)
+    img2 = cv2.imread(path2)
+    
+    # Convert BGR (OpenCV) to RGB (Matplotlib)
+    img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
+    img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
+
+    # 6. Plotting
+    # Concatenate images side-by-side
+    h1, w1, _ = img1.shape
+    h2, w2, _ = img2.shape
+    
+    # Create a canvas large enough for both
+    height = max(h1, h2)
+    width = w1 + w2
+    canvas = np.zeros((height, width, 3), dtype=np.uint8)
+    
+    canvas[:h1, :w1, :] = img1
+    canvas[:h2, w1:w1+w2, :] = img2
+
+    plt.figure(figsize=(15, 10))
+    plt.imshow(canvas)
+    
+    # Plot lines
+    # Shift x-coordinates of image2 by w1
+    for (x1, y1), (x2, y2) in zip(valid_kpts1, valid_kpts2):
+        plt.plot([x1, x2 + w1], [y1, y2], 'c-', alpha=0.6, linewidth=0.5)
+        plt.plot(x1, y1, 'r.', markersize=2)
+        plt.plot(x2 + w1, y2, 'r.', markersize=2)
+
+    plt.title(f"DB Verification: {name1} (ID:{image_id1}) <-> {name2} (ID:{image_id2}) | Matches: {len(matches)}")
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import os
+import sqlite3
+
+def plot_matches_from_db(cursor, image_id1, image_id2, image_dir):
+    """
+    Reads matches and keypoints for a specific pair from the COLMAP DB and plots them.
+    
+    Args:
+        cursor: SQLite cursor.
+        image_id1, image_id2: The IDs of the two images to plot.
+        image_dir: Path to the directory containing the actual image files.
+    """
+    
+    # 1. Resolve Pair ID (Colmap requires id1 < id2 for unique pair_id)
+    if image_id1 > image_id2:
+        id_a, id_b = image_id2, image_id1
+        swapped = True
+    else:
+        id_a, id_b = image_id1, image_id2
+        swapped = False
+        
+    pair_id = id_a * 2147483647 + id_b
+
+    # 2. Fetch Matches
+    print(f"Fetching matches for pair {image_id1}-{image_id2} (PairID: {pair_id})...")
+    cursor.execute("SELECT data, rows, cols FROM matches WHERE pair_id = ?", (pair_id,))
+    match_row = cursor.fetchone()
+    
+    if match_row is None:
+        print(f"No matches found in database for Pair {image_id1}-{image_id2}")
+        return
+
+    # Decode Matches (UINT32)
+    # Blob is match_row[0], rows is [1], cols is [2]
+    matches_blob = match_row[0]
+    matches = np.frombuffer(matches_blob, dtype=np.uint32).reshape(-1, 2)
+    
+    # If inputs were swapped relative to how COLMAP stores them, swap the columns
+    # so matches[:,0] refers to image_id1 and matches[:,1] refers to image_id2
+    if swapped:
+        matches = matches[:, [1, 0]]
+
+    # 3. Fetch Keypoints & Image Names
+    def get_image_data(img_id):
+        cursor.execute("SELECT name FROM images WHERE image_id = ?", (img_id,))
+        res = cursor.fetchone()
+        if not res:
+            raise ValueError(f"Image ID {img_id} not found in 'images' table.")
+        name = res[0]
+        
+        cursor.execute("SELECT data FROM keypoints WHERE image_id = ?", (img_id,))
+        kp_res = cursor.fetchone()
+        if not kp_res:
+             raise ValueError(f"No keypoints found for Image ID {img_id}.")
+        
+        # Decode Keypoints (FLOAT32)
+        kpts = np.frombuffer(kp_res[0], dtype=np.float32).reshape(-1, 2)
+        return name, kpts
+
+    name1, kpts1 = get_image_data(image_id1)
+    name2, kpts2 = get_image_data(image_id2)
+
+    # 4. Filter Keypoints using Match Indices
+    valid_kpts1 = kpts1[matches[:, 0]]
+    valid_kpts2 = kpts2[matches[:, 1]]
+
+    # 5. Visualization
+    path1 = os.path.join(image_dir, name1)
+    path2 = os.path.join(image_dir, name2)
+    
+    if not os.path.exists(path1) or not os.path.exists(path2):
+        print(f"Error: Could not find image files at \n{path1}\n{path2}")
+        return
+
+    img1 = cv2.imread(path1)
+    img2 = cv2.imread(path2)
+    img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
+    img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
+
+    # Create canvas
+    h1, w1 = img1.shape[:2]
+    h2, w2 = img2.shape[:2]
+    height = max(h1, h2)
+    width = w1 + w2
+    canvas = np.zeros((height, width, 3), dtype=np.uint8)
+    canvas[:h1, :w1] = img1
+    canvas[:h2, w1:w1+w2] = img2
+
+    plt.figure(figsize=(20, 10))
+    plt.imshow(canvas)
+    
+    # Plot matches
+    # x2 coordinates need to be shifted by w1
+    for (x1, y1), (x2, y2) in zip(valid_kpts1, valid_kpts2):
+        plt.plot([x1, x2 + w1], [y1, y2], 'g-', alpha=0.5, linewidth=1.5)
+        plt.plot(x1, y1, 'r.', markersize=4)
+        plt.plot(x2 + w1, y2, 'r.', markersize=4)
+
+    plt.title(f"{name1} <-> {name2} | Total Matches: {len(matches)}")
+    plt.axis('off')
+    plt.tight_layout()
+    plt.show()
+
+if __name__ == "__main__":
+
+    conn, cursor = load_colmap_db(DB_PATH)
+    cursor.execute("SELECT image_id, name FROM images")
+    images_info = {row[0]: row[1] for row in cursor.fetchall()}
+    image_ids = sorted(images_info.keys())
+    h = 505
+    w = 607
+    # plot_matches_from_db(cursor, image_ids[0], image_ids[1], IMAGE_DIR)
+    # exit(0)
+
+    clean_database(cursor)
+    conn.commit() 
+
+    fts = {}
+    for i in tqdm(range(len(image_ids)), desc="Feature Extraction"):
+        id = image_ids[i]
+        fname = images_info[id]
+        path = os.path.join(IMAGE_DIR, fname)
+
+        feats_dict = lightglue_keypoints(path, features='superpoint')
+        
+        fts[id] = feats_dict
+
+        kpts = feats_dict['keypoints'].squeeze(0).cpu().numpy().astype(np.float32)
+        descs = feats_dict['descriptors'].squeeze(0).cpu().numpy().astype(np.float32)
+
+        kpts_rot = unrotate_kps_W(kpts, feats_dict['rotations'].squeeze(0).cpu().numpy().astype(np.float32), h, w)
+        insert_keypoints(cursor, id, kpts_rot, descs)
+
+    conn.commit() 
+    with open(matches_file_path, "w") as f_match:
+        for i in tqdm(range(len(image_ids)), desc="Feature Extraction"):
+            id1 = image_ids[i]
+            fname1 = images_info[id1]
+            path1 = os.path.join(IMAGE_DIR, fname1)
+
+            for j in range(i + 1, len(image_ids)):
+                if j == i:
+                    continue
+                id2 = image_ids[j]
+
+                fname2 = images_info[id2]
+                path2 = os.path.join(IMAGE_DIR, fname2)
+                matches_tensor = lightglue_matching(fts[id1], fts[id2], plot=False, features='superpoint', path_to_image0=path1, path_to_image1=path2) 
+
+                if matches_tensor is not None and len(matches_tensor) > 0:
+                    matches_np = matches_tensor.cpu().numpy().astype(np.uint32)
+                    #insert_matches(cursor, id1, id2, matches_np)
+                    
+                    f_match.write(f"{fname1} {fname2}\n")
+                    np.savetxt(f_match, matches_np, fmt="%d")
+                    f_match.write("\n")
+
+                    #verify_matches_visual(cursor, image_ids[i], image_ids[j], IMAGE_DIR)
+            #tqdm.write(f"Processed matches for Image ID {id1} in {duration:.2f} seconds.")
+                
+            #plt.show()
+    
+    conn.commit()
+
+    #plot_matches_from_db(cursor, image_ids[0], image_ids[1], IMAGE_DIR)
+
+    conn.close()
+    print("Database overwrite complete.")    

lightglue_matcher_utilities.py

@@ -0,0 +1,266 @@
+import torch
+import numpy as np
+import cv2
+from lightglue import LightGlue
+from lightglue.utils import rbd
+
+def unrotate_kps_W(kps_rot, k, H, W):
+    import numpy as np
+    
+    # Ensure inputs are Numpy
+    if hasattr(kps_rot, 'cpu'): kps_rot = kps_rot.cpu().numpy()
+    if hasattr(k, 'cpu'): k = k.cpu().numpy()
+    
+    # Squeeze if necessary
+    if k.ndim > 1: k = k.squeeze()
+    if kps_rot.ndim > 2: kps_rot = kps_rot.squeeze()
+
+    x_r = kps_rot[:, 0]
+    y_r = kps_rot[:, 1]
+    
+    x = np.zeros_like(x_r)
+    y = np.zeros_like(y_r)
+    
+    mask0 = (k == 0)
+    x[mask0], y[mask0] = x_r[mask0], y_r[mask0]
+    
+    mask1 = (k == 1)
+    x[mask1], y[mask1] = (W - 1) - y_r[mask1], x_r[mask1]
+    
+    mask2 = (k == 2)
+    x[mask2], y[mask2] = (W - 1) - x_r[mask2], (H - 1) - y_r[mask2]
+    
+    mask3 = (k == 3)
+    x[mask3], y[mask3] = y_r[mask3], (H - 1) - x_r[mask3]
+    
+    return np.stack([x, y], axis=-1)
+
+def unrotate_kps(kps_rot, k, H, W):
+    import torch
+    # k is how many times you rotated CCW by 90° to create the rotated image
+    x_r, y_r = kps_rot[:, 0].clone(), kps_rot[:, 1].clone()
+    if k == 0:
+        x, y = x_r, y_r
+    elif k == 1:   # 90° CCW
+        x = (W - 1) - y_r
+        y = x_r
+    elif k == 2:   # 180°
+        x = (W - 1) - x_r
+        y = (H - 1) - y_r
+    elif k == 3:   # 270° CCW
+        x = y_r
+        y = (H - 1) - x_r
+    else:
+        raise ValueError("k must be 0..3")
+    return torch.stack([x, y], dim=-1)
+
+# def lightglue_matching(path_to_image0, path_to_image1, plot=False, features='superpoint'):
+#     from lightglue import LightGlue, SuperPoint, SIFT
+#     from lightglue.utils import load_image, rbd
+#     from lightglue import viz2d
+#     import torch
+
+#     # --- Models on GPU ---
+#     device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+#     if features == 'superpoint':
+#         extractor = SuperPoint(max_num_keypoints=2048).eval().to(device)
+#     if features == 'sift':
+#         extractor = SIFT(max_num_keypoints=2048).eval().to(device)
+
+#     matcher = LightGlue(features=features).eval().to(device)
+
+#     # --- Load images as Torch tensors (3,H,W) in [0,1] ---
+#     timg0 = load_image(path_to_image0).to(device)
+#     timg1 = load_image(path_to_image1).to(device)
+
+#     # --- Extract local features ---
+#     feats0 = extractor.extract(timg0)   # auto-resize inside
+
+#     max_num_matches = -1
+#     best_k = 0
+#     best_feats0 = None
+#     best_feats1 = None
+#     for k in range(4):
+#         timg1_rotated = torch.rot90(timg1, k, dims=(1, 2))
+#         feats1_k = extractor.extract(timg1_rotated)
+#         out_k = matcher({'image0': feats0, 'image1': feats1_k})
+#         feats0_k, feats1_k, out_k = [rbd(x) for x in [feats0, feats1_k, out_k]]   # remove batch dim
+#         matches_k = out_k['matches']   # (K,2) long
+#         num_k = len(matches_k)
+#         if num_k > max_num_matches:
+#             max_num_matches = num_k
+#             matches = matches_k
+#             best_feats0 = feats0_k
+#             best_feats1 = feats1_k
+#             best_k = k
+    
+#     # --- Keypoints in matched order (Torch tensors on CPU) ---
+#     H1, W1 = timg1.shape[-2], timg1.shape[-1]
+
+#     kpts0 = best_feats0['keypoints'][matches[:, 0]]
+#     kpts1 = best_feats1['keypoints'][matches[:, 1]]
+#     kpts1 = unrotate_kps(kpts1, best_k, H1, W1)             # (K,2) mapped to original image1 coords
+
+#     desc0 = best_feats0['descriptors'][matches[:, 0]]
+#     desc1 = best_feats1['descriptors'][matches[:, 1]]
+
+#     if plot:
+#         if len(kpts0) == 0 or len(kpts1) == 0:
+#             print("No matches found.")
+#             return None, None
+#         ax = viz2d.plot_images([timg0.cpu(), timg1.cpu()])
+#         viz2d.plot_matches(kpts0.cpu(), kpts1.cpu(), color=None, lw=0.8, axes=ax)
+#         #ax0 = ax[0] if isinstance(ax, (list, tuple, np.ndarray)) else ax
+#         #fig = ax0.figure
+
+#         #return kpts0, kpts1 #, fig, ax
+        
+
+#     return kpts0, kpts1, desc0, desc1
+
+def lightglue_keypoints(path_to_image0, features='superpoint', rotations = [0,1,2,3]):
+    from lightglue import LightGlue, SuperPoint, SIFT
+    from lightglue.utils import load_image, rbd
+    from lightglue import viz2d
+    import torch
+
+    # --- Models on GPU ---
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    if features == 'superpoint':
+        extractor = SuperPoint(max_num_keypoints=2048).eval().to(device)
+    if features == 'sift':
+        extractor = SIFT(max_num_keypoints=2048).eval().to(device)
+
+    # --- Load images as Torch tensors (3,H,W) in [0,1] ---
+    timg = load_image(path_to_image0).to(device)
+    _, h, w = timg.shape
+
+    
+    # --- Extract local features ---
+    feats = {}
+    for k in (rotations):
+        timg_rotated = torch.rot90(timg, k, dims=(1, 2))
+        feats[k] = extractor.extract(timg_rotated)
+        print(f"Extracted {feats[k]['keypoints'].shape[1]} keypoints for rotation {k}")
+
+    # --- Merge features back to original coordinate system ---
+    all_keypoints = []
+    all_scores = []
+    all_descriptors = []
+    all_rotations = []
+    for k, feat in feats.items():
+        kpts = feat['keypoints']  # Shape (1, N, 2)
+        num_kpts = kpts.shape[1]
+        if k == 0:
+            kpts_corrected = kpts
+        elif k == 1:
+            kpts_corrected = torch.stack(
+                [w - 1 - kpts[..., 1], kpts[..., 0]], dim=-1
+            )
+        elif k == 2:
+            kpts_corrected = torch.stack(
+                [w - 1 - kpts[..., 0], h - 1 - kpts[..., 1]], dim=-1
+            )
+        elif k == 3:
+            kpts_corrected = torch.stack(
+                [kpts[..., 1], h - 1 - kpts[..., 0]], dim=-1
+            )
+
+        rot_indices = torch.full((1, num_kpts), k, dtype=torch.long, device=device)
+        all_keypoints.append(feat['keypoints'])
+        all_scores.append(feat['keypoint_scores'])
+        all_descriptors.append(feat['descriptors'])
+        all_rotations.append(rot_indices)
+
+    # Concatenate all features along the keypoint dimension (dim=1)
+    feats_merged = {
+        'keypoints': torch.cat(all_keypoints, dim=1),
+        'keypoint_scores': torch.cat(all_scores, dim=1),
+        'descriptors': torch.cat(all_descriptors, dim=1),
+        'rotations': torch.cat(all_rotations, dim=1)
+    }
+    
+    num_kpts = feats_merged['keypoints'].shape[1]
+    # perm = torch.randperm(num_kpts, device=device)
+
+    # feats_merged['keypoints'] = feats_merged['keypoints'][:, perm, :]
+    # feats_merged['keypoint_scores'] = feats_merged['keypoint_scores'][:, perm]
+    # feats_merged['descriptors'] = feats_merged['descriptors'][:, perm, :]
+
+    # Optional: If you want to retain other keys like 'shape' or 'image_size'
+    feats_merged['image_size'] = torch.tensor([w, h], device=device).unsqueeze(0)
+    return feats_merged
+
+def lightglue_matching(feats0, feats1, plot=False, features='superpoint', path_to_image0=None, path_to_image1=None):
+    from lightglue import LightGlue, SuperPoint, SIFT
+    from lightglue.utils import load_image, rbd
+    from lightglue import viz2d
+    import torch
+
+    # --- Models on GPU ---
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    matcher = LightGlue(features=features).eval().to(device)
+
+    # --- Load images as Torch tensors (3,H,W) in [0,1] ---
+    if plot:
+        timg0 = load_image(path_to_image0).to(device)
+        timg1 = load_image(path_to_image1).to(device)
+
+    # --- Extract local features ---
+
+    max_num_matches = -1
+    best_k = 0
+    best_feats0 = None
+    best_feats1 = None
+    for k in range(1):
+        #timg1_rotated = torch.rot90(timg1, k, dims=(1, 2))
+        feats1_k = feats1 #extractor.extract(timg1_rotated)
+        out_k = matcher({'image0': feats0, 'image1': feats1_k})
+        feats0_k, feats1_k, out_k = [rbd(x) for x in [feats0, feats1_k, out_k]]   # remove batch dim
+        matches_k = out_k['matches']   # (K,2) long
+        num_k = len(matches_k)
+        if num_k > max_num_matches:
+            max_num_matches = num_k
+            matches = matches_k
+            best_feats0 = feats0_k
+            best_feats1 = feats1_k
+            best_k = k
+    print(f"LightGlue found {len(matches)} matches.")
+    # --- Keypoints in matched order (Torch tensors on CPU) ---
+    #H1, W1 = timg1.shape[-2], timg1.shape[-1]
+
+    # kpts0 = best_feats0['keypoints'][matches[:, 0]]
+    # kpts1 = best_feats1['keypoints'][matches[:, 1]]
+    # #kpts1 = unrotate_kps(kpts1, best_k, H1, W1)             # (K,2) mapped to original image1 coords
+
+    # desc0 = best_feats0['descriptors'][matches[:, 0]]
+    # desc1 = best_feats1['descriptors'][matches[:, 1]]
+
+    # pts0 = kpts0.detach().cpu().numpy().astype(np.float32)  # (K,2)
+    # pts1 = kpts1.detach().cpu().numpy().astype(np.float32)  # (K,2)
+    # H, inliers = cv2.findHomography(pts0, pts1, cv2.RANSAC, 5.0)
+
+    # if inliers is not None:
+    #     mask = inliers.ravel() == 1
+    #     mask_tensor = torch.from_numpy(mask).to(matches.device)
+    #     matches = matches[mask_tensor]
+    # else:
+    #     # If geometry check failed completely, return no matches
+    #     return None
+    
+    # if plot:
+    #     if len(kpts0) == 0 or len(kpts1) == 0:
+    #         print("No matches found.")
+    #         return None, None
+    #     ax = viz2d.plot_images([timg0.cpu(), timg1.cpu()])
+    #     viz2d.plot_matches(kpts0.cpu(), kpts1.cpu(), color=None, lw=0.8, axes=ax)
+    #     #ax0 = ax[0] if isinstance(ax, (list, tuple, np.ndarray)) else ax
+    #     #fig = ax0.figure
+
+    #     #return kpts0, kpts1 #, fig, ax
+        
+
+    return matches