Upload folder using huggingface_hub

.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

@@ -7,73 +7,23 @@ 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=$(awk -F, 'NR==2 { split($2,a,"/"); print a[1]; exit }' "$rgb_csv")
+rgb_dir="${camera_name}"
 rgb_path="${sequence_path}/${rgb_dir}"
 
-calibration_model=$(grep -oP '(?<=Camera0\.model:\s)[\w]+' "$calibration_yaml")
+read -r calibration_model more_ <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
 echo "        camera model : $calibration_model"
-
-# Reading settings from yaml file
-mapper_Mapper_min_num_matches=$(yq '.mapper.Mapper_min_num_matches // 15' $settings_yaml)
-mapper_Mapper_ignore_watermarks=$(yq '.mapper.Mapper_ignore_watermarks // 0' $settings_yaml)
-mapper_Mapper_multiple_models=$(yq '.mapper.Mapper_multiple_models // 1' $settings_yaml)
-mapper_Mapper_max_num_models=$(yq '.mapper.Mapper_max_num_models // 50' $settings_yaml)
-mapper_Mapper_max_model_overlap=$(yq '.mapper.Mapper_max_model_overlap // 20' $settings_yaml)
-mapper_Mapper_min_model_size=$(yq '.mapper.Mapper_min_model_size // 10' $settings_yaml)
-mapper_Mapper_init_image_id1=$(yq '.mapper.Mapper_init_image_id1 // -1' $settings_yaml)
-mapper_Mapper_init_image_id2=$(yq '.mapper.Mapper_init_image_id2 // -1' $settings_yaml)
-mapper_Mapper_init_num_trials=$(yq '.mapper.Mapper_init_num_trials // 200' $settings_yaml)
-mapper_Mapper_extract_colors=$(yq '.mapper.Mapper_extract_colors // 1' $settings_yaml)
-mapper_Mapper_num_threads=$(yq '.mapper.Mapper_num_threads // -1' $settings_yaml)
-mapper_Mapper_min_focal_length_ratio=$(yq '.mapper.Mapper_min_focal_length_ratio // 0.1' $settings_yaml)
-mapper_Mapper_max_focal_length_ratio=$(yq '.mapper.Mapper_max_focal_length_ratio // 10' $settings_yaml)
-mapper_Mapper_max_extra_param=$(yq '.mapper.Mapper_max_extra_param // 1' $settings_yaml)
-mapper_Mapper_ba_refine_focal_length=$(yq '.mapper.Mapper_ba_refine_focal_length // 1' $settings_yaml)
-mapper_Mapper_ba_refine_principal_point=$(yq '.mapper.Mapper_ba_refine_principal_point // 0' $settings_yaml)
-mapper_Mapper_ba_refine_extra_params=$(yq '.mapper.Mapper_ba_refine_extra_params // 1' $settings_yaml)
-mapper_Mapper_ba_local_num_images=$(yq '.mapper.Mapper_ba_local_num_images // 6' $settings_yaml)
-mapper_Mapper_ba_local_function_tolerance=$(yq '.mapper.Mapper_ba_local_function_tolerance // 0' $settings_yaml)
-mapper_Mapper_ba_local_max_num_iterations=$(yq '.mapper.Mapper_ba_local_max_num_iterations // 25' $settings_yaml)
-mapper_Mapper_ba_global_images_ratio=$(yq '.mapper.Mapper_ba_global_images_ratio // 1.1' $settings_yaml)
-mapper_Mapper_ba_global_points_ratio=$(yq '.mapper.Mapper_ba_global_points_ratio // 1.1' $settings_yaml)
-mapper_Mapper_ba_global_images_freq=$(yq '.mapper.Mapper_ba_global_images_freq // 500' $settings_yaml)
-mapper_Mapper_ba_global_points_freq=$(yq '.mapper.Mapper_ba_global_points_freq // 250000' $settings_yaml)
-mapper_Mapper_ba_global_function_tolerance=$(yq '.mapper.Mapper_ba_global_function_tolerance // 0' $settings_yaml)
-mapper_Mapper_ba_global_max_num_iterations=$(yq '.mapper.Mapper_ba_global_max_num_iterations // 50' $settings_yaml)
-mapper_Mapper_ba_global_max_refinements=$(yq '.mapper.Mapper_ba_global_max_refinements // 5' $settings_yaml)
-mapper_Mapper_ba_global_max_refinement_change=$(yq '.mapper.Mapper_ba_global_max_refinement_change // 0.0005' $settings_yaml)
-mapper_Mapper_ba_local_max_refinements=$(yq '.mapper.Mapper_ba_local_max_refinements // 2' $settings_yaml)
-mapper_Mapper_ba_local_max_refinement_change=$(yq '.mapper.Mapper_ba_local_max_refinement_change // 0.001' $settings_yaml)
-mapper_Mapper_ba_use_gpu=$(yq '.mapper.Mapper_ba_use_gpu // 0' $settings_yaml)
-mapper_Mapper_ba_gpu_index=$(yq '.mapper.Mapper_ba_gpu_index // -1' $settings_yaml)
-mapper_Mapper_ba_min_num_residuals_for_cpu_multi_threading=$(yq '.mapper.Mapper_ba_min_num_residuals_for_cpu_multi_threading // 50000' $settings_yaml)
-mapper_Mapper_snapshot_images_freq=$(yq '.mapper.Mapper_snapshot_images_freq // 0' $settings_yaml)
-mapper_Mapper_fix_existing_images=$(yq '.mapper.Mapper_fix_existing_images // 0' $settings_yaml)
-mapper_Mapper_init_min_num_inliers=$(yq '.mapper.Mapper_init_min_num_inliers // 100' $settings_yaml)
-mapper_Mapper_init_max_error=$(yq '.mapper.Mapper_init_max_error // 4' $settings_yaml)
-mapper_Mapper_init_max_forward_motion=$(yq '.mapper.Mapper_init_max_forward_motion // 0.95' $settings_yaml)
-mapper_Mapper_init_min_tri_angle=$(yq '.mapper.Mapper_init_min_tri_angle // 16' $settings_yaml)
-mapper_Mapper_init_max_reg_trials=$(yq '.mapper.Mapper_init_max_reg_trials // 2' $settings_yaml)
-mapper_Mapper_abs_pose_max_error=$(yq '.mapper.Mapper_abs_pose_max_error // 12' $settings_yaml)
-mapper_Mapper_abs_pose_min_num_inliers=$(yq '.mapper.Mapper_abs_pose_min_num_inliers // 30' $settings_yaml)
-mapper_Mapper_abs_pose_min_inlier_ratio=$(yq '.mapper.Mapper_abs_pose_min_inlier_ratio // 0.25' $settings_yaml)
-mapper_Mapper_filter_max_reproj_error=$(yq '.mapper.Mapper_filter_max_reproj_error // 4' $settings_yaml)
-mapper_Mapper_filter_min_tri_angle=$(yq '.mapper.Mapper_filter_min_tri_angle // 1.5' $settings_yaml)
-mapper_Mapper_max_reg_trials=$(yq '.mapper.Mapper_max_reg_trials // 3' $settings_yaml)
-mapper_Mapper_local_ba_min_tri_angle=$(yq '.mapper.Mapper_local_ba_min_tri_angle // 6' $settings_yaml)
-mapper_Mapper_tri_max_transitivity=$(yq '.mapper.Mapper_tri_max_transitivity // 1' $settings_yaml)
-mapper_Mapper_tri_create_max_angle_error=$(yq '.mapper.Mapper_tri_create_max_angle_error // 2' $settings_yaml)
-mapper_Mapper_tri_continue_max_angle_error=$(yq '.mapper.Mapper_tri_continue_max_angle_error // 2' $settings_yaml)
-mapper_Mapper_tri_merge_max_reproj_error=$(yq '.mapper.Mapper_tri_merge_max_reproj_error // 4' $settings_yaml)
-mapper_Mapper_tri_complete_max_reproj_error=$(yq '.mapper.Mapper_tri_complete_max_reproj_error // 4' $settings_yaml)
-mapper_Mapper_tri_complete_max_transitivity=$(yq '.mapper.Mapper_tri_complete_max_transitivity // 5' $settings_yaml)
-mapper_Mapper_tri_re_max_angle_error=$(yq '.mapper.Mapper_tri_re_max_angle_error // 5' $settings_yaml)
-mapper_Mapper_tri_re_min_ratio=$(yq '.mapper.Mapper_tri_re_min_ratio // 0.2' $settings_yaml)
-mapper_Mapper_tri_re_max_trials=$(yq '.mapper.Mapper_tri_re_max_trials // 1' $settings_yaml)
-mapper_Mapper_tri_min_angle=$(yq '.mapper.Mapper_tri_min_angle // 1.5' $settings_yaml)
-mapper_Mapper_tri_ignore_two_view_tracks=$(yq '.mapper.Mapper_tri_ignore_two_view_tracks // 1' $settings_yaml)
+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"
@@ -81,66 +31,10 @@ database="${exp_folder_colmap}/colmap_database.db"
 colmap mapper \
     --database_path ${database} \
     --image_path ${rgb_path} \
-    --output_path ${exp_folder_colmap} #\
-    # --Mapper.min_num_matches ${mapper_Mapper_min_num_matches} \
-    # --Mapper.ignore_watermarks ${mapper_Mapper_ignore_watermarks} \
-    # --Mapper.multiple_models ${mapper_Mapper_multiple_models} \
-    # --Mapper.max_num_models ${mapper_Mapper_max_num_models} \
-    # --Mapper.max_model_overlap ${mapper_Mapper_max_model_overlap} \
-    # --Mapper.min_model_size ${mapper_Mapper_min_model_size} \
-    # --Mapper.init_image_id1 ${mapper_Mapper_init_image_id1} \
-    # --Mapper.init_image_id2 ${mapper_Mapper_init_image_id2} \
-    # --Mapper.init_num_trials ${mapper_Mapper_init_num_trials} \
-    # --Mapper.extract_colors ${mapper_Mapper_extract_colors} \
-    # --Mapper.num_threads ${mapper_Mapper_num_threads} \
-    # --Mapper.min_focal_length_ratio ${mapper_Mapper_min_focal_length_ratio} \
-    # --Mapper.max_focal_length_ratio ${mapper_Mapper_max_focal_length_ratio} \
-    # --Mapper.max_extra_param ${mapper_Mapper_max_extra_param} \
-    # --Mapper.ba_refine_focal_length ${mapper_Mapper_ba_refine_focal_length} \
-    # --Mapper.ba_refine_principal_point ${mapper_Mapper_ba_refine_principal_point} \
-    # --Mapper.ba_refine_extra_params ${mapper_Mapper_ba_refine_extra_params} \
-    # --Mapper.ba_local_num_images ${mapper_Mapper_ba_local_num_images} \
-    # --Mapper.ba_local_function_tolerance ${mapper_Mapper_ba_local_function_tolerance} \
-    # --Mapper.ba_local_max_num_iterations ${mapper_Mapper_ba_local_max_num_iterations} \
-    # --Mapper.ba_global_images_ratio ${mapper_Mapper_ba_global_images_ratio} \
-    # --Mapper.ba_global_points_ratio ${mapper_Mapper_ba_global_points_ratio} \
-    # --Mapper.ba_global_images_freq ${mapper_Mapper_ba_global_images_freq} \
-    # --Mapper.ba_global_points_freq ${mapper_Mapper_ba_global_points_freq} \
-    # --Mapper.ba_global_function_tolerance ${mapper_Mapper_ba_global_function_tolerance} \
-    # --Mapper.ba_global_max_num_iterations ${mapper_Mapper_ba_global_max_num_iterations} \
-    # --Mapper.ba_global_max_refinements ${mapper_Mapper_ba_global_max_refinements} \
-    # --Mapper.ba_global_max_refinement_change ${mapper_Mapper_ba_global_max_refinement_change} \
-    # --Mapper.ba_local_max_refinements ${mapper_Mapper_ba_local_max_refinements} \
-    # --Mapper.ba_local_max_refinement_change ${mapper_Mapper_ba_local_max_refinement_change} \
-    # --Mapper.ba_use_gpu ${mapper_Mapper_ba_use_gpu} \
-    # --Mapper.ba_gpu_index ${mapper_Mapper_ba_gpu_index} \
-    # --Mapper.ba_min_num_residuals_for_cpu_multi_threading ${mapper_Mapper_ba_min_num_residuals_for_cpu_multi_threading} \
-    # --Mapper.snapshot_images_freq ${mapper_Mapper_snapshot_images_freq} \
-    # --Mapper.fix_existing_images ${mapper_Mapper_fix_existing_images} \
-    # --Mapper.init_min_num_inliers ${mapper_Mapper_init_min_num_inliers} \
-    # --Mapper.init_max_error ${mapper_Mapper_init_max_error} \
-    # --Mapper.init_max_forward_motion ${mapper_Mapper_init_max_forward_motion} \
-    # --Mapper.init_min_tri_angle ${mapper_Mapper_init_min_tri_angle} \
-    # --Mapper.init_max_reg_trials ${mapper_Mapper_init_max_reg_trials} \
-    # --Mapper.abs_pose_max_error ${mapper_Mapper_abs_pose_max_error} \
-    # --Mapper.abs_pose_min_num_inliers ${mapper_Mapper_abs_pose_min_num_inliers} \
-    # --Mapper.abs_pose_min_inlier_ratio ${mapper_Mapper_abs_pose_min_inlier_ratio} \
-    # --Mapper.filter_max_reproj_error ${mapper_Mapper_filter_max_reproj_error} \
-    # --Mapper.filter_min_tri_angle ${mapper_Mapper_filter_min_tri_angle} \
-    # --Mapper.max_reg_trials ${mapper_Mapper_max_reg_trials} \
-    # --Mapper.local_ba_min_tri_angle ${mapper_Mapper_local_ba_min_tri_angle} \
-    # --Mapper.tri_max_transitivity ${mapper_Mapper_tri_max_transitivity} \
-    # --Mapper.tri_create_max_angle_error ${mapper_Mapper_tri_create_max_angle_error} \
-    # --Mapper.tri_continue_max_angle_error ${mapper_Mapper_tri_continue_max_angle_error} \
-    # --Mapper.tri_merge_max_reproj_error ${mapper_Mapper_tri_merge_max_reproj_error} \
-    # --Mapper.tri_complete_max_reproj_error ${mapper_Mapper_tri_complete_max_reproj_error} \
-    # --Mapper.tri_complete_max_transitivity ${mapper_Mapper_tri_complete_max_transitivity} \
-    # --Mapper.tri_re_max_angle_error ${mapper_Mapper_tri_re_max_angle_error} \
-    # --Mapper.tri_re_min_ratio ${mapper_Mapper_tri_re_min_ratio} \
-    # --Mapper.tri_re_max_trials ${mapper_Mapper_tri_re_max_trials} \
-    # --Mapper.tri_min_angle ${mapper_Mapper_tri_min_angle} \
-    # --Mapper.tri_ignore_two_view_tracks ${mapper_Mapper_tri_ignore_two_view_tracks}
-
+    --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 \

colmap_matcher.sh

@@ -10,50 +10,28 @@ 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}"
 
-calibration_model=$(grep -oP '(?<=Camera0\.model:\s)[\w]+' "$calibration_yaml")
-
-fx=$(grep -oP '(?<=Camera0\.fx:\s)-?\d+\.\d+' "$calibration_yaml")
-fy=$(grep -oP '(?<=Camera0\.fy:\s)-?\d+\.\d+' "$calibration_yaml")
-cx=$(grep -oP '(?<=Camera0\.cx:\s)-?\d+\.\d+' "$calibration_yaml")
-cy=$(grep -oP '(?<=Camera0\.cy:\s)-?\d+\.\d+' "$calibration_yaml")
-
-# Reading settings from yaml file
-feature_extractor_SiftExtraction_num_octaves=$(yq '.feature_extractor.SiftExtraction_num_octaves // 4.0' $settings_yaml)
-feature_extractor_SiftExtraction_octave_resolution=$(yq '.feature_extractor.SiftExtraction_octave_resolution // 3.0' $settings_yaml)
-feature_extractor_SiftExtraction_peak_threshold=$(yq '.feature_extractor.SiftExtraction_peak_threshold // 0.0066666666666666671' $settings_yaml)
-feature_extractor_SiftExtraction_edge_threshold=$(yq '.feature_extractor.SiftExtraction_edge_threshold // 10.0' $settings_yaml)
-feature_extractor_SiftExtraction_dsp_min_scale=$(yq '.feature_extractor.SiftExtraction_dsp_min_scale // 0.1666666666666666' $settings_yaml)
-feature_extractor_SiftExtraction_dsp_max_scale=$(yq '.feature_extractor.SiftExtraction_dsp_max_scale // 3.0' $settings_yaml)
-feature_extractor_SiftExtraction_dsp_num_scales=$(yq '.feature_extractor.SiftExtraction_dsp_num_scales // 10.0' $settings_yaml)
-
-matcher_SiftMatching_max_ratio=$(yq '.matcher.SiftMatching_max_ratio // 0.80000000000000004' $settings_yaml)
-matcher_SiftMatching_max_distance=$(yq '.matcher.SiftMatching_max_distance // 0.69999999999999996' $settings_yaml)
-matcher_TwoViewGeometry_min_num_inliers=$(yq '.matcher.TwoViewGeometry_min_num_inliers // 15.0' $settings_yaml)
-matcher_TwoViewGeometry_max_error=$(yq '.matcher.TwoViewGeometry_max_error // 4.0' $settings_yaml)
-matcher_TwoViewGeometry_confidence=$(yq '.matcher.TwoViewGeometry_confidence // 0.999' $settings_yaml)
-matcher_TwoViewGeometry_min_inlier_ratio=$(yq '.matcher.TwoViewGeometry_min_inlier_ratio // 0.25' $settings_yaml)
-matcher_SequentialMatching_overlap=$(yq '.matcher.SequentialMatching_overlap // 10.0' $settings_yaml)
-matcher_SequentialMatching_quadratic_overlap=$(yq '.matcher.SequentialMatching_quadratic_overlap // 1.0' $settings_yaml)
-matcher_ExhaustiveMatching_block_size=$(yq '.matcher.ExhaustiveMatching_block_size // 50.0' $settings_yaml)
+# 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"
-awk -F, 'NR>1 { split($2,a,"/"); print a[2] }' "$rgb_csv" > "$colmap_image_list"
+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}
+colmap database_creator --database_path ${database} 
 
 # Feature extractor
 echo "    colmap feature_extractor ..."
 
-if [ "${calibration_model}" == "UNKNOWN" ]
+if [ "${calibration_model}" == "unknown" ]
 then
 echo "        camera model : $calibration_model"
 colmap feature_extractor \
@@ -64,18 +42,13 @@ colmap feature_extractor \
    --ImageReader.single_camera 1 \
    --ImageReader.single_camera_per_folder 1 \
    --FeatureExtraction.use_gpu ${use_gpu}
-  #  --SiftExtraction.num_octaves ${feature_extractor_SiftExtraction_num_octaves} \
-  #  --SiftExtraction.octave_resolution ${feature_extractor_SiftExtraction_octave_resolution} \
-  #  --SiftExtraction.peak_threshold ${feature_extractor_SiftExtraction_peak_threshold} \
-  #  --SiftExtraction.edge_threshold ${feature_extractor_SiftExtraction_edge_threshold} \
-  #  --SiftExtraction.dsp_min_scale ${feature_extractor_SiftExtraction_dsp_min_scale} \
-  #  --SiftExtraction.dsp_max_scale ${feature_extractor_SiftExtraction_dsp_max_scale} \
-  #  --SiftExtraction.dsp_num_scales ${feature_extractor_SiftExtraction_dsp_num_scales}
 fi
 
-if [ "${calibration_model}" == "Pinhole" ]
+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} \
@@ -84,69 +57,58 @@ then
 	--ImageReader.single_camera 1 \
 	--ImageReader.single_camera_per_folder 1 \
 	--FeatureExtraction.use_gpu ${use_gpu} \
-	--ImageReader.camera_params "${fx}, ${fy}, ${cx}, ${cy}" \
-  --SiftExtraction.num_octaves ${feature_extractor_SiftExtraction_num_octaves} \
-  --SiftExtraction.octave_resolution ${feature_extractor_SiftExtraction_octave_resolution} \
-  --SiftExtraction.peak_threshold ${feature_extractor_SiftExtraction_peak_threshold} \
-  --SiftExtraction.edge_threshold ${feature_extractor_SiftExtraction_edge_threshold} \
-  --SiftExtraction.dsp_min_scale ${feature_extractor_SiftExtraction_dsp_min_scale} \
-  --SiftExtraction.dsp_max_scale ${feature_extractor_SiftExtraction_dsp_max_scale} \
-  --SiftExtraction.dsp_num_scales ${feature_extractor_SiftExtraction_dsp_num_scales}
+	--ImageReader.camera_params "${fx},${fy},${cx},${cy}"
 fi
 
-if [ "${calibration_model}" == "OPENCV" ]
+if [ "${calibration_model}" == "radtan4" ]
 then
-
-  k1=$(grep -oP '(?<=Camera0\.k1:\s)-?\d+\.\d+' "$calibration_yaml")
-  k2=$(grep -oP '(?<=Camera0\.k2:\s)-?\d+\.\d+' "$calibration_yaml")
-  p1=$(grep -oP '(?<=Camera0\.p1:\s)-?\d+\.\d+' "$calibration_yaml")
-  p2=$(grep -oP '(?<=Camera0\.p2:\s)-?\d+\.\d+' "$calibration_yaml")
-  k3=$(grep -oP '(?<=Camera0\.k3:\s)-?\d+\.\d+' "$calibration_yaml")
-
+  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 ${calibration_model} \
+	--ImageReader.camera_model "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}" \
-  --SiftExtraction.num_octaves ${feature_extractor_SiftExtraction_num_octaves} \
-  --SiftExtraction.octave_resolution ${feature_extractor_SiftExtraction_octave_resolution} \
-  --SiftExtraction.peak_threshold ${feature_extractor_SiftExtraction_peak_threshold} \
-  --SiftExtraction.edge_threshold ${feature_extractor_SiftExtraction_edge_threshold} \
-  --SiftExtraction.dsp_min_scale ${feature_extractor_SiftExtraction_dsp_min_scale} \
-  --SiftExtraction.dsp_max_scale ${feature_extractor_SiftExtraction_dsp_max_scale} \
-  --SiftExtraction.dsp_num_scales ${feature_extractor_SiftExtraction_dsp_num_scales}
+  --ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${p1},${p2}"
 fi
 
-if [ "${calibration_model}" == "OPENCV_FISHEYE" ] 
+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
 
-  k1=$(grep -oP '(?<=Camera0\.k1:\s)-?\d+\.\d+' "$calibration_yaml")
-  k2=$(grep -oP '(?<=Camera0\.k2:\s)-?\d+\.\d+' "$calibration_yaml")
-  k3=$(grep -oP '(?<=Camera0\.k3:\s)-?\d+\.\d+' "$calibration_yaml")
-  k4=$(grep -oP '(?<=Camera0\.k4:\s)-?\d+\.\d+' "$calibration_yaml")
-
+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 ${calibration_model} \
+	--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}" \
-  --SiftExtraction.num_octaves ${feature_extractor_SiftExtraction_num_octaves} \
-  --SiftExtraction.octave_resolution ${feature_extractor_SiftExtraction_octave_resolution} \
-  --SiftExtraction.peak_threshold ${feature_extractor_SiftExtraction_peak_threshold} \
-  --SiftExtraction.edge_threshold ${feature_extractor_SiftExtraction_edge_threshold} \
-  --SiftExtraction.dsp_min_scale ${feature_extractor_SiftExtraction_dsp_min_scale} \
-  --SiftExtraction.dsp_max_scale ${feature_extractor_SiftExtraction_dsp_max_scale} \
-  --SiftExtraction.dsp_num_scales ${feature_extractor_SiftExtraction_dsp_num_scales}
+	--ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${k3},${k4}"
 fi
 
 # Exhaustive Feature Matcher
@@ -155,15 +117,7 @@ then
 	echo "    colmap exhaustive_matcher ..."
   colmap exhaustive_matcher \
      --database_path ${database} \
-     --FeatureMatching.use_gpu ${use_gpu} \
-     --SiftMatching.max_ratio "${matcher_SiftMatching_max_ratio}" \
-     --SiftMatching.max_distance "${matcher_SiftMatching_max_distance}" \
-     --TwoViewGeometry.min_num_inliers "${matcher_TwoViewGeometry_min_num_inliers}" \
-     --TwoViewGeometry.max_error "${matcher_TwoViewGeometry_max_error}" \
-     --TwoViewGeometry.confidence "${matcher_TwoViewGeometry_confidence}" \
-     --TwoViewGeometry.min_inlier_ratio "${matcher_TwoViewGeometry_min_inlier_ratio}" \
-     --ExhaustiveMatching.block_size "${matcher_ExhaustiveMatching_block_size}"
-
+     --FeatureMatching.use_gpu ${use_gpu}
 fi
 
 # Sequential Feature Matcher
@@ -186,13 +140,16 @@ then
     --database_path "${database}" \
     --SequentialMatching.loop_detection 1 \
     --SequentialMatching.vocab_tree_path ${vocabulary_tree} \
-    --FeatureMatching.use_gpu "${use_gpu}" \
-    --SiftMatching.max_ratio "${matcher_SiftMatching_max_ratio}" \
-    --SiftMatching.max_distance "${matcher_SiftMatching_max_distance}" \
-    --TwoViewGeometry.min_num_inliers "${matcher_TwoViewGeometry_min_num_inliers}" \
-    --TwoViewGeometry.max_error "${matcher_TwoViewGeometry_max_error}" \
-    --TwoViewGeometry.confidence "${matcher_TwoViewGeometry_confidence}" \
-    --TwoViewGeometry.min_inlier_ratio "${matcher_TwoViewGeometry_min_inlier_ratio}" \
-    --SequentialMatching.overlap "${matcher_SequentialMatching_overlap}" \
-    --SequentialMatching.quadratic_overlap "${matcher_SequentialMatching_quadratic_overlap}"
-fi
+    --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

@@ -10,6 +10,7 @@ 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() {
@@ -36,6 +37,7 @@ 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
@@ -46,11 +48,11 @@ 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
-./Baselines/colmap/colmap_mapper.sh $colmap_args 
+./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
+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

colmap_to_vslamlab.py

@@ -67,14 +67,14 @@ def write_trajectory_tum_format(file_name, image_ts, t_wc, q_wc_xyzw):
     data = data[data[:, 0].argsort()]
 
     with open(file_name, 'w', newline='') as file:
-        file.write('timestamp,tx,ty,tz,qx,qy,qz,qw\n')
+        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):
+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['ts_rgb0 (s)'].to_list()
+    ts = df[f'ts_{camera_name} (ns)'].to_list()
     return ts
                 
 if __name__ == "__main__":
@@ -84,13 +84,14 @@ if __name__ == "__main__":
     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))
+    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]))

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_batch.py

@@ -0,0 +1,465 @@
+import sqlite3
+import time
+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 PIL import Image
+import torchvision.transforms.functional as TF
+
+from lightglue import LightGlue
+from lightglue.utils import rbd
+from lightglue import  SuperPoint, SIFT
+from lightglue.utils import load_image
+
+# ==========================================
+# ==========================================
+# 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()
+    
+    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)
+    parser.add_argument("--matcher", type=str, required=True)
+
+    args, _ = parser.parse_known_args()
+
+    DB_PATH = args.database
+    IMAGE_DIR = args.rgb_path
+    FEATURE_TYPE = args.feature
+    MATCHER_TYPE = args.matcher
+    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() 
+
+    # Keypoint Extraction
+    extractor = SuperPoint(max_num_keypoints=128, detection_threshold=0.0).eval().cuda()
+    matcher = LightGlue(width_confidence=-1).eval().cuda()
+
+    total_time = 0.0
+    with open(matches_file_path, "w") as f_match:
+        for i, id_i in enumerate(tqdm(image_ids, desc="Outer Loop")):
+            fname_i = images_info[id_i]
+            path_i = os.path.join(IMAGE_DIR, fname_i)
+            img_i = Image.open(path_i).convert("RGB")
+            t_i = TF.to_tensor(img_i)   
+            imgs_i = []
+            imgs_j = []
+            ids_j =  []
+            for j, id_j in enumerate(tqdm(image_ids[i+1:], desc="Inner Loop", leave=False), start=i+1):
+                fname_j = images_info[id_j]
+                path_j = os.path.join(IMAGE_DIR, fname_j)
+                img_j = Image.open(path_j).convert("RGB")
+                t_j = TF.to_tensor(img_j)   
+                imgs_j.append(t_j)
+                imgs_i.append(t_i)
+                ids_j.append(id_j)
+
+            if len(imgs_j) == 0:
+                continue
+            print(f"Processing batch: Image {fname_i} with {len(imgs_j)} images.")
+            batch_i = torch.stack(imgs_i, dim=0).to(DEVICE)  # (B,3,H,W)
+            batch_j = torch.stack(imgs_j, dim=0).to(DEVICE)  # (B,3,H,W)
+
+            with torch.no_grad():
+                feats_i = extractor({"image": batch_i})
+                feats_j = extractor({"image": batch_j})
+                
+            kpts = feats_i['keypoints'][0].squeeze(0).cpu().numpy().astype(np.float32)
+            descs = feats_i['descriptors'][0].squeeze(0).cpu().numpy().astype(np.float32)
+            insert_keypoints(cursor, id_i, kpts, descs)
+
+            data = {}
+            data['image0'] = {}
+            data['image1'] = {}
+            data['image0']['keypoints'] = feats_i['keypoints']
+            data['image0']['descriptors'] = feats_i['descriptors']
+            data['image1']['keypoints'] = feats_j['keypoints']
+            data['image1']['descriptors'] = feats_j['descriptors']
+            # data['image0']['image'] = batch_i
+            # data['image1']['image'] = batch_j
+
+            t0 = time.perf_counter()
+            matches01 = matcher(data)
+            t1 = time.perf_counter()
+            elapsed = t1 - t0
+            print(f"Matching took {elapsed:.4f} seconds")
+            total_time += elapsed
+            
+            for k in range(len(matches01["matches0"])):
+                m0 = matches01["matches0"][k]         
+                valid = m0 > -1
+                if valid.any():
+                    fname_j = images_info[ids_j[k]]
+                    f_match.write(f"{fname_i} {fname_j}\n")
+                    idx0 = torch.nonzero(valid, as_tuple=False).squeeze(1)
+                    idx1 = m0[valid].long()
+                    matches_np = torch.stack([idx0, idx1], dim=1).cpu().numpy().astype(int)
+                    np.savetxt(f_match, matches_np, fmt="%d")
+                    f_match.write("\n")
+
+            del batch_i, batch_j, feats_i, feats_j, data, matches01, imgs_i, imgs_j
+            torch.cuda.synchronize()
+            torch.cuda.empty_cache()
+            import gc
+            gc.collect()
+
+    conn.commit()
+
+    #plot_matches_from_db(cursor, image_ids[0], image_ids[1], IMAGE_DIR)
+
+    conn.close()
+    print("Database overwrite complete.")    
+    print(f"Total matching time: {total_time:.2f} seconds.")
+
+    # B = len(image_ids)
+    # print("matches01 keys:", list(matches01.keys()))
+    # B0, N0 = matches01["matches0"].shape
+    # B1, N1 = matches01["matches1"].shape
+    # print(f"Batch size: {B0}, Num keypoints image0: {N0}")
+    # print(f"Batch size: {B1}, Num keypoints image1: {N1}")
+    # print(matches01["matches"][0].shape)
+    # print(matches01["matches"][0].shape)
+    # saved_images = set()
+
+    # with open(matches_file_path, "w") as f_match:
+    #     for i in range(B):
+    #         for j in range(i + 1, B):
+    #             fname1 = images_info[image_ids[i]]
+    #             fname2 = images_info[image_ids[j]]
+
+    #             if "matches" in matches01 and matches01["matches"] is not None:
+    #                 m = matches01["matches"]
+    #                 # Handle (1, M, 2) or (M, 2)
+    #                 if m.dim() == 3:
+    #                     m = m[0]
+    #                 matches_np = m.detach().cpu().numpy().astype(int)
+
+    #             # Fallback: build pairs from matches0
+    #             else:
+    #                 m0 = matches01["matches0"][0]          # (N0,)
+    #                 valid = m0 > -1
+    #                 if valid.any():
+    #                     idx0 = torch.nonzero(valid, as_tuple=False).squeeze(1)
+    #                     idx1 = m0[valid].long()
+    #                     matches_np = torch.stack([idx0, idx1], dim=1).cpu().numpy().astype(int)
+    #                 else:
+    #                     matches_np = np.empty((0, 2), dtype=int)
+    #             f_match.write(f"{fname1} {fname2}\n")
+    #             np.savetxt(f_match, matches_np, fmt="%d")
+    #             f_match.write("\n")
+
+    # with open(matches_file_path, "w") as f_match:
+    #     for i in range(B):
+    #         for j in range(i + 1, B):
+    #     fname1 = ""
+    #     fname2 = ""
+    #     matches_np = np.array([])
+    #     f_match.write(f"{fname1} {fname2}\n")
+    #     np.savetxt(f_match, matches_np, fmt="%d")
+    #     f_match.write("\n")
+
+    # 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 = feature_matching(fts[id1], fts[id2], matcher=matcher, features=FEATURE_TYPE, matcher_type=MATCHER_TYPE) 
+
+    #             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)                
+    #         #plt.show()
+    
+    # conn.commit()
+
+    # #plot_matches_from_db(cursor, image_ids[0], image_ids[1], IMAGE_DIR)
+
+    # 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

test.py

@@ -0,0 +1,19 @@
+        
+import torch
+from feature_matcher_utilities import extract_keypoints, feature_matching
+from lightglue import LightGlue
+
+path_0 = "/media/alejandro/E45B-3EBD/FOR ALEX/8312297.jpg"
+path_1 = "/media/alejandro/E45B-3EBD/FOR ALEX/8315088.jpg"
+
+feats_dict0, h0, w0 = extract_keypoints(path_0, features="superpoint", rotations=[0])
+feats_dict1, h1, w1 = extract_keypoints(path_1, features="superpoint", rotations=[1])
+
+
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+matcher = LightGlue(features='superpoint', depth_confidence=-1, width_confidence=-1, flash=True).eval().to(device)
+  
+matches_tensor = feature_matching(feats_dict0, feats_dict1, matcher=matcher, features="superpoint", matcher_type="lightglue") 
+
+print(len(matches_tensor))