Duplicate from vslamlab/colmap-vslamlab

Co-authored-by: VSLAM-LAB <vslamlab@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

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

colmap_mapper.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+echo "Executing colmap_mapper.sh ..."
+
+sequence_path="$1" 
+exp_folder="$2" 
+exp_id="$3" 
+settings_yaml="$4"
+calibration_yaml="$5"
+rgb_csv="$6"
+camera_name="$7"
+
+exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
+rgb_dir="${camera_name}"
+rgb_path="${sequence_path}/${rgb_dir}"
+
+read -r calibration_model more_ <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+echo "        camera model : $calibration_model"
+ba_refine_focal_length="0"
+ba_refine_principal_point="0"
+ba_refine_extra_params="0"
+if [ "${calibration_model}" == "unknown" ]
+then
+  ba_refine_focal_length="1"
+  ba_refine_principal_point="1"
+  ba_refine_extra_params="1"
+fi
+
+echo "    colmap mapper ..."
+database="${exp_folder_colmap}/colmap_database.db"
+
+colmap mapper \
+    --database_path ${database} \
+    --image_path ${rgb_path} \
+    --output_path ${exp_folder_colmap} \
+    --Mapper.ba_refine_focal_length ${ba_refine_focal_length} \
+    --Mapper.ba_refine_principal_point ${ba_refine_principal_point} \
+    --Mapper.ba_refine_extra_params ${ba_refine_extra_params}
+
+echo "    colmap model_converter ..."
+colmap model_converter \
+	--input_path ${exp_folder_colmap}/0 --output_path ${exp_folder_colmap} --output_type TXT
+
+

colmap_matcher.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+echo ""
+echo "Executing colmap_matcher.sh ..."
+
+sequence_path="$1"
+exp_folder="$2"
+exp_id="$3"
+settings_yaml="$4"
+calibration_yaml="$5"
+rgb_csv="$6"
+matcher_type="$7"
+use_gpu="$8"
+camera_name="$9"
+
+exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
+rgb_dir=$(awk -F, 'NR==2 { split($2,a,"/"); print a[1]; exit }' "$rgb_csv")
+rgb_path="${sequence_path}/${rgb_dir}"
+
+# Get calibration model
+read -r calibration_model more_ <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+
+# Create colmap image list
+colmap_image_list="${exp_folder_colmap}/colmap_image_list.txt"
+python3 Baselines/colmap/create_colmap_image_list.py "$rgb_csv" "$colmap_image_list" "$camera_name"
+
+# Create Colmap Database
+database="${exp_folder_colmap}/colmap_database.db"
+rm -rf ${database}
+colmap database_creator --database_path ${database}
+
+# Feature extractor
+echo "    colmap feature_extractor ..."
+
+if [ "${calibration_model}" == "unknown" ]
+then
+echo "        camera model : $calibration_model"
+colmap feature_extractor \
+   --database_path ${database} \
+   --image_path ${rgb_path} \
+   --image_list_path ${colmap_image_list} \
+   --ImageReader.camera_model SIMPLE_PINHOLE \
+   --ImageReader.single_camera 1 \
+   --ImageReader.single_camera_per_folder 1 \
+   --FeatureExtraction.use_gpu ${use_gpu}
+fi
+
+if [ "${calibration_model}" == "pinhole" ]
+then
+  read -r calibration_model fx fy cx cy <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+  echo "        camera model : $calibration_model"
+  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
+  colmap feature_extractor \
+	--database_path ${database} \
+	--image_path ${rgb_path} \
+	--image_list_path ${colmap_image_list} \
+	--ImageReader.camera_model PINHOLE \
+	--ImageReader.single_camera 1 \
+	--ImageReader.single_camera_per_folder 1 \
+	--FeatureExtraction.use_gpu ${use_gpu} \
+	--ImageReader.camera_params "${fx},${fy},${cx},${cy}"
+fi
+
+if [ "${calibration_model}" == "radtan4" ]
+then
+  read -r calibration_model fx fy cx cy k1 k2 p1 p2 <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+  echo "        camera model : $calibration_model"
+  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
+  echo "            k1: $k1 , k2: $k2 , p1: $p1 , p2: $p2"
+  colmap feature_extractor \
+	--database_path ${database} \
+	--image_path ${rgb_path} \
+	--image_list_path ${colmap_image_list} \
+	--ImageReader.camera_model "OPENCV" \
+	--ImageReader.single_camera 1 \
+  --ImageReader.single_camera_per_folder 0 \
+	--FeatureExtraction.use_gpu ${use_gpu} \
+  --ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${p1},${p2}"
+fi
+
+if [ "${calibration_model}" == "radtan5" ]
+then
+  read -r calibration_model fx fy cx cy k1 k2 p1 p2 k3 <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+  echo "        camera model : $calibration_model"
+  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
+  echo "            k1: $k1 , k2: $k2 , p1: $p1 , p2: $p2, k3: $k3"
+  colmap feature_extractor \
+	--database_path ${database} \
+	--image_path ${rgb_path} \
+	--image_list_path ${colmap_image_list} \
+	--ImageReader.camera_model "FULL_OPENCV" \
+	--ImageReader.single_camera 1 \
+  --ImageReader.single_camera_per_folder 1 \
+	--FeatureExtraction.use_gpu ${use_gpu} \
+  --ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${p1},${p2},${k3},0,0,0"
+fi
+
+if [ "${calibration_model}" == "equid4" ]
+then
+  read -r calibration_model fx fy cx cy k1 k2 k3 k4 <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+  echo "        camera model : $calibration_model"
+  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
+  echo "            k1: $k1 , k2: $k2 , k3: $k3 , k4: $k4"
+	colmap feature_extractor \
+	--database_path ${database} \
+	--image_path ${rgb_path} \
+	--image_list_path ${colmap_image_list} \
+	--ImageReader.camera_model "OPENCV_FISHEYE"\
+	--ImageReader.single_camera 1 \
+	--ImageReader.single_camera_per_folder 1 \
+	--FeatureExtraction.use_gpu ${use_gpu} \
+	--ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${k3},${k4}"
+fi
+
+# Exhaustive Feature Matcher
+if [ "${matcher_type}" == "exhaustive" ]
+then
+	echo "    colmap exhaustive_matcher ..."
+  colmap exhaustive_matcher \
+     --database_path ${database} \
+     --FeatureMatching.use_gpu ${use_gpu}
+fi
+
+# Sequential Feature Matcher
+if [ "${matcher_type}" == "sequential" ]
+then
+  num_rgb=$(( $(wc -l < "$rgb_csv") - 1 ))
+
+  # Pick vocabulary tree based on the number of images
+  vocabulary_tree="Baselines/colmap/vocab_tree_faiss_flickr100K_words32K.bin"
+  if [ "$num_rgb" -gt 1000 ]; then
+    vocabulary_tree="Baselines/colmap/vocab_tree_faiss_flickr100K_words256K.bin"
+  fi
+  if [ "$num_rgb" -gt 10000 ]; then
+    vocabulary_tree="Baselines/colmap/vocab_tree_faiss_flickr100K_words1M.bin"
+  fi
+
+  echo "    colmap sequential_matcher ..."
+  echo "        Vocabulary Tree: $vocabulary_tree"
+  colmap sequential_matcher \
+    --database_path "${database}" \
+    --SequentialMatching.loop_detection 1 \
+    --SequentialMatching.vocab_tree_path ${vocabulary_tree} \
+    --FeatureMatching.use_gpu "${use_gpu}"
+fi
+
+# LightGlue Feature Matcher
+if [ "${matcher_type}" == "custom" ]
+then
+  colmap exhaustive_matcher \
+      --database_path ${database} \
+      --FeatureMatching.use_gpu ${use_gpu}
+
+  pixi run -e lightglue python3 Baselines/colmap/feature_matcher.py --database ${database} --rgb_path ${rgb_path} --rgb_csv ${rgb_csv}
+fi
+

colmap_reconstruction.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# Default values
+matcher_type="exhaustive"
+use_gpu="1"
+verbose="0"
+settings_yaml=""
+sequence_path=""
+exp_folder=""
+exp_id=""
+calibration_yaml=""
+rgb_csv=""
+camera_name="rgb_0"
+
+# Function to split key-value pairs and assign them to variables
+split_and_assign() {
+  local input=$1
+  local key=$(echo $input | cut -d':' -f1)
+  local value=$(echo $input | cut -d':' -f2-)
+  eval $key=$value
+}
+
+# Read Inputs
+for ((i=1; i<=$#; i++)); do
+    split_and_assign "${!i}"
+done
+
+exp_id=$(printf "%05d" ${exp_id})
+
+echo -e "\n================= Experiment Configuration ================="
+echo "  Sequence Path     : $sequence_path"
+echo "  Experiment Folder : $exp_folder"
+echo "  Experiment ID     : $exp_id"
+echo "  Verbose           : $verbose"
+echo "  Matcher Type      : $matcher_type"
+echo "  Use GPU           : $use_gpu"
+echo "  Settings YAML     : $settings_yaml"
+echo "  Calibration YAML  : $calibration_yaml"
+echo "  RGB CSV           : $rgb_csv"
+echo "  Camera Name       : $camera_name"
+echo "============================================================"
+
+# Create folder to save colmap files
+exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
+rm -rf "$exp_folder_colmap"
+mkdir "$exp_folder_colmap"
+
+# Run COLMAP scripts for matching and mapping
+export QT_QPA_PLATFORM_PLUGIN_PATH="$CONDA_PREFIX/plugins/platforms"
+colmap_args="$sequence_path $exp_folder $exp_id $settings_yaml $calibration_yaml $rgb_csv"
+./Baselines/colmap/colmap_matcher.sh $colmap_args $matcher_type $use_gpu $camera_name
+./Baselines/colmap/colmap_mapper.sh $colmap_args $camera_name
+
+# Convert COLMAP outputs to a format suitable for VSLAM-LAB
+python Baselines/colmap/colmap_to_vslamlab.py $sequence_path $exp_folder $exp_id $verbose $rgb_csv $camera_name
+
+# Visualization with colmap gui
+if [ "$verbose" -eq 1 ]; then
+  exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
+  rgb_dir=$(awk -F, 'NR==2 { split($2,a,"/"); print a[1]; exit }' "$rgb_csv")
+  rgb_path="${sequence_path}/${rgb_dir}"
+  database="${exp_folder_colmap}/colmap_database.db"
+  colmap gui --import_path "${exp_folder_colmap}/0" --database_path ${database} --image_path ${rgb_path}
+fi
+
+# # Remove colmap data
+# rm -rf ${exp_folder_colmap}
+
+

colmap_to_vslamlab.py

@@ -0,0 +1,102 @@
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+import sys
+import os
+import pandas as pd
+
+def get_colmap_keyframes(images_file, number_of_header_lines, verbose=False):
+    print(f"get_colmap_keyframes: {images_file}")
+    
+    image_id = []
+    q_wc_xyzw = []
+    t_wc = []
+
+    with open(f"{images_file}", 'r') as file:
+        # Skip the header lines
+        for _ in range(number_of_header_lines):
+            file.readline()
+        
+        while True:
+            line1 = file.readline()
+            if not line1:
+                break
+            elements = line1.split()
+            
+            IMAGE_ID = int(elements[0])
+            image_id.append(IMAGE_ID)
+            
+            QW = float(elements[1])
+            QX = float(elements[2])
+            QY = float(elements[3])
+            QZ = float(elements[4])
+            
+            TX = float(elements[5])
+            TY = float(elements[6])
+            TZ = float(elements[7])
+
+            t_cw_i = np.array([TX, TY, TZ])
+            q_wc_i = R.from_quat([QX, QY, QZ, QW]).inv()
+            R_wc_i = q_wc_i.as_matrix()
+            
+            q_wc_xyzw.append([q_wc_i.as_quat()[0], q_wc_i.as_quat()[1], q_wc_i.as_quat()[2], q_wc_i.as_quat()[3]])
+            t_wc.append(-R_wc_i @ t_cw_i)
+
+            file.readline()
+    
+    image_id = np.array(image_id)
+    q_wc_xyzw = np.array(q_wc_xyzw)
+    t_wc = np.array(t_wc)
+
+    sorted_indices = image_id.argsort()
+    image_id = image_id[sorted_indices]
+    q_wc_xyzw = q_wc_xyzw[sorted_indices]
+    t_wc = t_wc[sorted_indices]
+
+    q_wc_xyzw_corrected = q_wc_xyzw.copy()
+    for i in range(1, len(q_wc_xyzw_corrected)):
+        dot_product = np.dot(q_wc_xyzw_corrected[i - 1], q_wc_xyzw_corrected[i])
+        if dot_product < 0:
+            q_wc_xyzw_corrected[i] = -q_wc_xyzw_corrected[i]
+
+    return image_id, t_wc, q_wc_xyzw_corrected
+
+def write_trajectory_tum_format(file_name, image_ts, t_wc, q_wc_xyzw):
+    print(f"writeTrajectoryTUMformat: {file_name}")
+    
+    data = np.hstack((image_ts.reshape(-1, 1), t_wc, q_wc_xyzw))
+    data = data[data[:, 0].argsort()]
+
+    with open(file_name, 'w', newline='') as file:
+        file.write('ts (ns),tx (m),ty (m),tz (m),qx,qy,qz,qw\n')
+        for row in data:
+            file.write(','.join(f'{x:.15f}' for x in row) + '\n')
+
+def get_timestamps(files_path, rgb_file, camera_name):
+    print(f"getTimestamps: {os.path.join(files_path, rgb_file)}")
+    df = pd.read_csv(rgb_file)       
+    ts = df[f'ts_{camera_name} (ns)'].to_list()
+    return ts
+                
+if __name__ == "__main__":
+
+    sequence_path = sys.argv[1]
+    exp_folder = sys.argv[2]
+    exp_id = sys.argv[3]
+    verbose = bool(int(sys.argv[4]))
+    rgb_file = sys.argv[5]
+    camera_name = sys.argv[6]
+
+    images_file = os.path.join(exp_folder, f'colmap_{exp_id}', 'images.txt')
+
+    number_of_header_lines = 4
+    image_id, t_wc, q_wc_xyzw = get_colmap_keyframes(images_file, number_of_header_lines, verbose)
+
+    image_ts = np.array(get_timestamps(sequence_path, rgb_file, camera_name))
+    timestamps = []
+    for id in image_id:
+        timestamps.append(float(image_ts[id-1]))
+
+    timestamps = np.array(timestamps)
+
+    keyFrameTrajectory_txt = os.path.join(exp_folder, exp_id + '_KeyFrameTrajectory' + '.csv')
+    write_trajectory_tum_format(keyFrameTrajectory_txt, timestamps, t_wc, q_wc_xyzw)

create_colmap_image_list.py

@@ -0,0 +1,21 @@
+import argparse
+import pandas as pd
+import os
+def create_colmap_image_list(rgb_csv, colmap_image_list_txt, cam_name):
+
+    df = pd.read_csv(rgb_csv)       
+    image_list = df[f'path_{cam_name}'].to_list()
+
+    with open(colmap_image_list_txt, 'w') as f:
+        for name in image_list:
+            file_name = os.path.basename(name)
+            f.write(f"{file_name}\n")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("rgb_csv", help="Path to the rgb_csv")
+    parser.add_argument("colmap_image_list", help="Path to the colmap_image_list")
+    parser.add_argument("camera_name", help="camera_name")
+
+    args = parser.parse_args()
+    create_colmap_image_list(args.rgb_csv, args.colmap_image_list, args.camera_name)

feature_matcher.py

@@ -0,0 +1,457 @@
+import sqlite3
+from feature_matcher_utilities import extract_keypoints, feature_matching, unrotate_kps_W
+import os
+import torch
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import numpy as np
+import cv2
+import argparse
+from pathlib import Path
+
+from lightglue import LightGlue
+
+# ==========================================
+# ==========================================
+# 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()
+
+def load_sift_keypoints(cursor):
+    cursor.execute("""
+        SELECT image_id, rows, cols, data
+        FROM keypoints
+    """)
+
+    keypoints_dict = {}
+
+    for image_id, rows, cols, data in cursor.fetchall():
+        kpts = np.frombuffer(data, dtype=np.float32)
+        kpts = kpts.reshape((rows, cols))
+        keypoints_dict[image_id] = kpts
+
+    return keypoints_dict
+
+def load_sift_matches(cursor):
+    sift_matches = {}
+    cursor.execute("SELECT pair_id, data FROM matches")
+    for row in cursor.fetchall():
+        pair_id = row[0]
+        data = row[1]
+
+        if data is None:
+            # skip pairs with no matches
+            sift_matches[pair_id] = None
+            continue
+
+        # COLMAP stores matches as uint32 pairs
+        matches = np.frombuffer(data, dtype=np.uint32).reshape(-1, 2)
+        sift_matches[pair_id] = matches
+
+    return sift_matches
+
+def insert_all_inlier_two_view_geometry(cursor, image_id1, image_id2, matches):
+    """
+    Treats all matches as inliers and inserts dummy two-view geometry.
+    """
+    if image_id1 > image_id2:
+        image_id1, image_id2 = image_id2, image_id1
+        matches = matches[:, [1, 0]]
+
+    pair_id = image_id1 * 2147483647 + image_id2
+
+    # COLMAP expects uint32 indices
+    matches = matches.astype(np.uint32)
+
+    # Dummy geometry (not actually used by mapper)
+    dummy_F = np.eye(3, dtype=np.float64).tobytes()
+
+    cursor.execute("""
+        INSERT OR REPLACE INTO two_view_geometries
+        (pair_id, rows, cols, data, config)
+        VALUES (?, ?, ?, ?, ?)
+    """, (
+        pair_id,
+        matches.shape[0],
+        matches.shape[1],
+        matches.tobytes(),
+        2  # config=2 → "calibrated / essential matrix"
+    ))
+
+if __name__ == "__main__":
+
+    FEATURE_TYPE = 'superpoint'
+    MATCHER_TYPE = 'lightglue'
+    LG_MATCHES_THRESHOLD = 40
+
+
+    parser = argparse.ArgumentParser()
+    
+    parser.add_argument("--database", type=Path, required=True)
+    parser.add_argument("--rgb_path", type=Path, required=True)
+    parser.add_argument("--rgb_csv", type=Path, required=True)
+
+    args, _ = parser.parse_known_args()
+
+    DB_PATH = args.database
+    IMAGE_DIR = args.rgb_path
+    DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # Load colmap database
+    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())
+
+    # Load SIFT keypoints and matches from exhaustive matching
+    sift_keypoints = load_sift_keypoints(cursor)
+    sift_matches = load_sift_matches(cursor)
+
+    # Clean colmap database
+    clean_database(cursor)
+    conn.commit()
+
+    # Extract superpoint keypoints
+    fts_sp = {}
+    keypoints_sp = {}
+    rotations_sp = {}
+    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, feats_norot, h, w = extract_keypoints(path, features=FEATURE_TYPE)
+        fts_sp[id] = feats_norot
+
+        kpts_sp = feats_dict['keypoints'].squeeze(0).cpu().numpy().astype(np.float32)
+        descs = feats_dict['descriptors'].squeeze(0).cpu().numpy().astype(np.float32)
+
+        keypoints_sp[id] = kpts_sp
+        rotations_sp[id] = feats_dict['rotations'].squeeze(0).cpu().numpy().astype(np.float32)
+
+    # Combine superpoint and SIFT keypoints, insert into database
+    for i in tqdm(range(len(image_ids)), desc="Feature Extraction"):
+            id = image_ids[i]
+            kpts_sp = keypoints_sp[id]
+            rots_sp = rotations_sp[id]
+            kpts_rot = unrotate_kps_W(kpts_sp, rots_sp, h, w)
+            
+            N = kpts_rot.shape[0]
+
+            scales = np.ones((N, 1), dtype=np.float32)
+            oris   = np.zeros((N, 1), dtype=np.float32)
+            resp   = np.ones((N, 1), dtype=np.float32)
+            octave = np.zeros((N, 1), dtype=np.float32)
+
+            kpts_mod = np.hstack([
+                kpts_rot.astype(np.float32),  # (N, 2)
+                scales,
+                oris,
+                resp,
+                octave
+            ])
+
+            kpts_sift = sift_keypoints[id]
+
+            kpts = np.vstack([kpts_sift, kpts_mod])
+            descs = np.zeros((kpts.shape[0], 128), dtype=np.float32)
+                    
+            insert_keypoints(cursor, id, kpts, descs)
+
+    conn.commit()
+
+    # Feature Matching
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    matcher = LightGlue(features='superpoint', depth_confidence=-1, width_confidence=-1, flash=True).eval().to(device)
+
+    for i in tqdm(range(len(image_ids)), desc="Feature Matching"):
+        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)
+
+            # Get SIFT matches
+            pair_id = create_pair_id(id1, id2)
+            matches_sift = sift_matches[pair_id]
+            if matches_sift is None:
+                matches_sift = np.zeros((0, 2), dtype=np.uint32)
+
+            n_sift_kpts_1 = sift_keypoints[id1].shape[0]
+            n_sift_kpts_2 = sift_keypoints[id2].shape[0]
+
+            # Compute LightGlue matches
+            matches_lg = feature_matching(fts_sp[id1], fts_sp[id2], matcher=matcher, exhaustive=True) 
+
+            if matches_lg is not None and len(matches_lg) > LG_MATCHES_THRESHOLD:
+                matches_lg[:,0] += n_sift_kpts_1
+                matches_lg[:,1] += n_sift_kpts_2
+            else:
+                matches_lg = np.zeros((0, 2), dtype=np.uint32)
+            
+            # Combine superpoint and SIFT matches, insert into database
+            matches = np.vstack([matches_sift, matches_lg])               
+            insert_matches(cursor, id1, id2, matches)
+            insert_all_inlier_two_view_geometry(cursor, id1, id2, matches)
+ 
+    conn.commit()
+    conn.close()
+    print("Database overwrite complete.")    

feature_matcher_utilities.py

@@ -0,0 +1,192 @@
+import torch
+import numpy as np
+import cv2
+from lightglue import LightGlue
+from lightglue.utils import rbd
+from lightglue import  SuperPoint, SIFT
+from lightglue.utils import load_image
+
+
+def unrotate_kps_W(kps_rot, k, H, W):
+    # 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 extract_keypoints(path_to_image0, features='superpoint', rotations = [0,1,2,3]):
+    # --- Models on GPU ---
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    
+    # --- Load images as Torch tensors (3,H,W) in [0,1] ---
+    timg = load_image(path_to_image0).to(device)
+    _, h, w = timg.shape
+
+    if features == 'sift':
+        extractor = SIFT(max_num_keypoints=2048).eval().to(device)
+        feats = extractor.extract(timg)
+        return feats , h, w
+    
+    if features == 'superpoint':
+        extractor = SuperPoint(max_num_keypoints=2048).eval().to(device)
+
+    # --- 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)
+    #feats_merged['scales'] = torch.tensor([w, h], device=device).unsqueeze(0)
+
+    # for f in feats_merged:
+    #     if 'scales' not in f:
+    #         f['scales'] = torch.ones(all_keypoints.shape[:-1], device=device)
+    #     if 'oris' not in f:
+    #         f['oris'] = torch.zeros(all_keypoints.shape[:-1], device=device)
+
+    return feats_merged , feats, h, w
+
+def lightglue_matching(feats0, feats1, matcher = None):
+    if matcher is None:
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        matcher = LightGlue(features='superpoint').eval().to(device)
+    
+    out_k = matcher({'image0': feats0, 'image1': feats1})
+    _, _, out_k = [rbd(x) for x in [feats0, feats1, out_k]]   # remove batch dim
+    return out_k['matches'] 
+
+def feature_matching(feats0, feats1, matcher = None, exhaustive = True):
+    best_rot = 0
+    best_num_matches = 0
+    matches_tensor = None
+ 
+    # Find the best rotation alignment
+    for rot in [0,1,2,3]:
+        matches_tensor_rot = lightglue_matching(feats0[0], feats1[rot], matcher = matcher)
+        if (len(matches_tensor_rot) > best_num_matches):
+            best_num_matches = len(matches_tensor_rot)
+            best_rot = rot
+            matches_tensor = matches_tensor_rot
+
+    if matches_tensor is not None and len(matches_tensor) > 0:
+        matches_np = matches_tensor.cpu().numpy().astype(np.uint32)
+    else:
+        return None
+
+    # Adjust matches to account for rotations
+    for k in range(best_rot):
+        matches_np[:,1] += feats1[k]['keypoints'].shape[1]
+    all_matches = [matches_np]  
+
+    if not exhaustive:
+        return matches_np
+    
+    # Find the other rotation combinations
+    rots = []
+    for rot in [1, 2, 3]:
+        rot_i = best_rot + rot
+        if rot_i >=4:
+            rot_i = rot_i -4
+        rots.append(rot_i)
+
+    # Compute matches for the other rotation combinations
+    for rot_i in [1,2,3]:
+        rot_j = rots[rot_i-1]
+
+        matches_tensor_rot = lightglue_matching(feats0[rot_i], feats1[rot_j], matcher = matcher)
+        matches_np_i = matches_tensor_rot.cpu().numpy().astype(np.uint32)
+        if rot_i > 0:
+            for k in range(rot_i):
+                matches_np_i[:,0] += feats0[k]['keypoints'].shape[1]
+        if rot_j > 0:
+            for k in range(rot_j):
+                matches_np_i[:,1] += feats1[k]['keypoints'].shape[1]
+
+        all_matches.append(matches_np_i)
+        print(f"Rotation {rot_i} vs {rot_j}: {len(matches_tensor_rot)} matches")
+
+    # Stack all matches together
+    matches_stacked = (
+        np.vstack(all_matches) if len(all_matches) and all_matches[0].size else
+        np.empty((0, 2), dtype=np.uint32)
+    )
+    
+    # if best_rot > 0:
+    #     for k in range(best_rot):
+    #         print(f"Adjusting for rotation {k}")
+    #         matches_np[:,1] += feats1[k]['keypoints'].shape[1]
+
+    # return matches_np
+    return matches_stacked
+           
+
+              

get_calibration.py

@@ -0,0 +1,33 @@
+import yaml
+import sys
+import argparse
+import numpy as np
+
+def get_camera_intrinsics(calibration_yaml, cam_name):
+    with open(calibration_yaml, 'r') as file:
+        data = yaml.safe_load(file)
+    cameras = data.get('cameras', [])
+    for cam_ in cameras:
+        if cam_['cam_name'] == cam_name:
+            cam = cam_;
+            break;
+  
+    has_dist = ('distortion_type' in cam) and ('distortion_coefficients' in cam)
+    K = np.array([[cam['focal_length'][0], 0,  cam['principal_point'][0]],
+                  [0,  cam['focal_length'][1], cam['principal_point'][1]],
+                  [0,  0,   1]], dtype=np.float32)
+    
+    if has_dist:
+        dist= " ".join(map(str, cam['distortion_coefficients']))
+        print(f"{cam['distortion_type']} {K[0,0]} {K[1,1]} {K[0,2]} {K[1,2]} {dist}")
+    else:
+        print(f"{cam['cam_model']} {K[0,0]} {K[1,1]} {K[0,2]} {K[1,2]}")
+        
+    
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("calibration_yaml", help="Path to the calibration YAML")
+    parser.add_argument("camera_name", help="camera_name")
+    args = parser.parse_args()
+    
+    get_camera_intrinsics(args.calibration_yaml, args.camera_name)

lightglue_matcher.py

@@ -0,0 +1,351 @@
+import sqlite3
+from lightglue_matcher_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 argparse
+from pathlib import Path
+
+# ==========================================
+# ==========================================
+# 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__":
+
+    parser = argparse.ArgumentParser()
+    
+    #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")
+
+    parser.add_argument("--database", type=Path, required=True)
+    parser.add_argument("--rgb_path", type=Path, required=True)
+    parser.add_argument("--feature", type=str, required=True)
+
+    args, _ = parser.parse_known_args()
+
+    DB_PATH = args.database
+    IMAGE_DIR = args.rgb_path
+    FEATURE_TYPE = args.feature
+    DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+    matches_file_path = os.path.join(os.path.dirname(DB_PATH), "matches.txt")
+
+    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())
+
+    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, h, w = 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 , h, w
+
+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

vslamlab_colmap_settings.yaml

@@ -0,0 +1,79 @@
+feature_extractor:
+  SiftExtraction_num_octaves: 4
+  SiftExtraction_octave_resolution: 3
+  SiftExtraction_peak_threshold: 0.0066666666666666671
+  SiftExtraction_edge_threshold: 10.0
+  SiftExtraction_dsp_min_scale: 0.1666666666666666
+  SiftExtraction_dsp_max_scale: 3.0
+  SiftExtraction_dsp_num_scales: 10
+
+matcher:
+  SiftMatching_max_ratio: 0.80000000000000004
+  SiftMatching_max_distance: 0.69999999999999996
+  TwoViewGeometry_min_num_inliers: 15
+  TwoViewGeometry_max_error: 4.0
+  TwoViewGeometry_confidence: 0.999
+  TwoViewGeometry_min_inlier_ratio: 0.25
+  SequentialMatching_overlap: 10
+  SequentialMatching_quadratic_overlap: 1 
+  ExhaustiveMatching_block_size: 50
+
+mapper:
+  Mapper_min_num_matches: 15
+  Mapper_ignore_watermarks: 0
+  Mapper_multiple_models: 1
+  Mapper_max_num_models: 50
+  Mapper_max_model_overlap: 20
+  Mapper_min_model_size: 10
+  Mapper_init_image_id1: -1
+  Mapper_init_image_id2: -1
+  Mapper_init_num_trials: 200
+  Mapper_extract_colors: 1
+  Mapper_num_threads: -1
+  Mapper_min_focal_length_ratio: 0.10000000000000001
+  Mapper_max_focal_length_ratio: 10
+  Mapper_max_extra_param: 1
+  Mapper_ba_refine_focal_length: 1
+  Mapper_ba_refine_principal_point: 0
+  Mapper_ba_refine_extra_params: 1
+  Mapper_ba_local_num_images: 6
+  Mapper_ba_local_function_tolerance: 0
+  Mapper_ba_local_max_num_iterations: 25
+  Mapper_ba_global_images_ratio: 1.1000000000000001
+  Mapper_ba_global_points_ratio: 1.1000000000000001
+  Mapper_ba_global_images_freq: 500
+  Mapper_ba_global_points_freq: 250000
+  Mapper_ba_global_function_tolerance: 0
+  Mapper_ba_global_max_num_iterations: 50
+  Mapper_ba_global_max_refinements: 5
+  Mapper_ba_global_max_refinement_change: 0.00050000000000000001
+  Mapper_ba_local_max_refinements: 2
+  Mapper_ba_local_max_refinement_change: 0.001
+  Mapper_ba_use_gpu: 0
+  Mapper_ba_gpu_index: -1
+  Mapper_ba_min_num_residuals_for_cpu_multi_threading: 50000
+  Mapper_snapshot_images_freq: 0
+  Mapper_fix_existing_images: 0
+  Mapper_init_min_num_inliers: 100
+  Mapper_init_max_error: 4
+  Mapper_init_max_forward_motion: 0.94999999999999996
+  Mapper_init_min_tri_angle: 16
+  Mapper_init_max_reg_trials: 2
+  Mapper_abs_pose_max_error: 12
+  Mapper_abs_pose_min_num_inliers: 30
+  Mapper_abs_pose_min_inlier_ratio: 0.25
+  Mapper_filter_max_reproj_error: 4
+  Mapper_filter_min_tri_angle: 1.5
+  Mapper_max_reg_trials: 3
+  Mapper_local_ba_min_tri_angle: 6
+  Mapper_tri_max_transitivity: 1
+  Mapper_tri_create_max_angle_error: 2
+  Mapper_tri_continue_max_angle_error: 2
+  Mapper_tri_merge_max_reproj_error: 4
+  Mapper_tri_complete_max_reproj_error: 4
+  Mapper_tri_complete_max_transitivity: 5
+  Mapper_tri_re_max_angle_error: 5
+  Mapper_tri_re_min_ratio: 0.20000000000000001
+  Mapper_tri_re_max_trials: 1
+  Mapper_tri_min_angle: 1.5
+  Mapper_tri_ignore_two_view_tracks: 1