executables

colmap_mapper.sh

@@ -1,76 +1,145 @@
 #!/bin/bash
-echo "Executing glomapMapper.sh ..."
+echo "Executing colmap_mapper.sh ..."
 
 sequence_path="$1" 
 exp_folder="$2" 
 exp_id="$3" 
-verbose="$4"
-settings_yaml="$5"
-calibration_yaml="$6"
-rgb_txt="$7"
-
+settings_yaml="$4"
+calibration_yaml="$5"
+rgb_txt="$6"
 
 exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
 rgb_path="${sequence_path}/$(awk '{print $2}' "${rgb_txt}" | awk -F'/' 'NR==1 {print $1}')"
 
 calibration_model=$(grep -oP '(?<=Camera\.model:\s)[\w]+' "$calibration_yaml")
 echo "        camera model : $calibration_model"
-optimize_intrinsics="0"
-skip_view_graph_calibration="1"
-if [ "${calibration_model}" == "UNKNOWN" ]
-then
-  optimize_intrinsics="1"
-  skip_view_graph_calibration="0"
-fi
 
 # Reading settings from yaml file
-BundleAdjustment_thres_loss_function=$(yq '.BundleAdjustment.thres_loss_function // 1.0' $settings_yaml)
-RelPoseEstimation_max_epipolar_error=$(yq '.RelPoseEstimation.max_epipolar_error // 1.0' $settings_yaml)
-GlobalPositioning_thres_loss_function=$(yq '.GlobalPositioning.thres_loss_function // 0.10000000000000001' $settings_yaml)
-
-Triangulation_complete_max_reproj_error=$(yq '.Triangulation.complete_max_reproj_error // 15.0' $settings_yaml)
-Triangulation_merge_max_reproj_error=$(yq '.Triangulation.merge_max_reproj_error // 15.0' $settings_yaml)
-Triangulation_min_angle=$(yq '.Triangulation.min_angle // 1.0' $settings_yaml)
-Triangulation_min_num_matches=$(yq '.Triangulation.min_num_matches // 15.0' $settings_yaml)
-
-Thresholds_max_epipolar_error_E=$(yq '.Thresholds.max_epipolar_error_E // 1.0' $settings_yaml)
-Thresholds_max_epipolar_error_F=$(yq '.Thresholds.max_epipolar_error_F // 4.0' $settings_yaml)
-Thresholds_max_epipolar_error_H=$(yq '.Thresholds.max_epipolar_error_H // 4.0' $settings_yaml)
-
-Thresholds_min_inlier_num=$(yq '.Thresholds.min_inlier_num // 30.0' $settings_yaml)
-Thresholds_min_inlier_ratio=$(yq '.Thresholds.min_inlier_ratio // 0.25' $settings_yaml)
-Thresholds_max_rotation_error=$(yq '.Thresholds.max_rotation_error // 10.0' $settings_yaml)
+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)
 
-Thresholds_max_angle_error=$(yq '.Thresholds.max_angle_error // 1.0' $settings_yaml)
-Thresholds_max_reprojection_error=$(yq '.Thresholds.max_reprojection_error // 0.01' $settings_yaml)
-Thresholds_min_triangulation_angle=$(yq '.Thresholds.min_triangulation_angle // 1.0' $settings_yaml)
-
-
-echo "    glomap mapper ..."
+echo "    colmap mapper ..."
 database="${exp_folder_colmap}/colmap_database.db"
 
-glomap mapper \
+colmap mapper \
     --database_path ${database} \
     --image_path ${rgb_path} \
     --output_path ${exp_folder_colmap} \
-    --skip_view_graph_calibration "${skip_view_graph_calibration}" \
-    --RelPoseEstimation.max_epipolar_error "${RelPoseEstimation_max_epipolar_error}" \
-    --GlobalPositioning.thres_loss_function "${GlobalPositioning_thres_loss_function}" \
-    --BundleAdjustment.optimize_intrinsics "$optimize_intrinsics" #\
-    # --BundleAdjustment.thres_loss_function "${BundleAdjustment_thres_loss_function}" \
-    # --Thresholds.max_epipolar_error_E "${Thresholds_max_epipolar_error_E}" \
-    # --Thresholds.max_epipolar_error_F "${Thresholds_max_epipolar_error_F}" \
-    # --Thresholds.max_epipolar_error_H "${Thresholds_max_epipolar_error_H}" \
-    # --Thresholds.min_inlier_num "${Thresholds_min_inlier_num}" \
-    # --Thresholds.min_inlier_ratio "${Thresholds_min_inlier_ratio}" \
-    # --Thresholds.max_rotation_error "${Thresholds_max_rotation_error}" \
-    # --Thresholds.max_angle_error "${Thresholds_max_angle_error}" \
-    # --Thresholds.max_reprojection_error "${Thresholds_max_reprojection_error}" \
-    # --Thresholds.min_triangulation_angle "${Thresholds_min_triangulation_angle}" \
-    # --Triangulation.complete_max_reproj_error "${Triangulation_complete_max_reproj_error}" \
-    # --Triangulation.merge_max_reproj_error "${Triangulation_merge_max_reproj_error}" \
-    # --Triangulation.min_angle "${Triangulation_min_angle}" \
-    # --Triangulation.min_num_matches "${Triangulation_min_num_matches}"
+    --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}
+
 
 echo "    colmap model_converter ..."
 colmap model_converter \

colmap_matcher.sh

@@ -1,15 +1,15 @@
 #!/bin/bash
 echo ""
-echo "Executing colmapMatcher.sh ..."
+echo "Executing colmap_matcher.sh ..."
 
 sequence_path="$1"
 exp_folder="$2" 
 exp_id="$3" 
-matcher_type="$4" # Options: exhaustive, sequential
-use_gpu="$5"
-settings_yaml="$6"
-calibration_yaml="$7"
-rgb_txt="$8"
+settings_yaml="$4"
+calibration_yaml="$5"
+rgb_txt="$6"
+matcher_type="$7"
+use_gpu="$8"
 
 exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
 rgb_path="${sequence_path}/$(awk '{print $2}' "${rgb_txt}" | awk -F'/' 'NR==1 {print $1}')"
@@ -58,7 +58,7 @@ database="${exp_folder_colmap}/colmap_database.db"
 rm -rf ${database}
 colmap database_creator --database_path ${database}
 
-################################################################################
+# Feature extractor
 echo "    colmap feature_extractor ..."
 
 if [ "${calibration_model}" == "UNKNOWN" ]
@@ -81,9 +81,6 @@ colmap feature_extractor \
    --SiftExtraction.dsp_num_scales ${feature_extractor_SiftExtraction_dsp_num_scales}
 fi
 
-feature_extractor_SiftExtraction_dsp_num_scales=$(yq '.feature_extractor.SiftExtraction_dsp_num_scales // 10.0' $settings_yaml)
-
-
 if [ "${calibration_model}" == "PINHOLE" ]
 then
   echo "        camera model : $calibration_model"
@@ -147,7 +144,7 @@ then
   --SiftExtraction.dsp_num_scales ${feature_extractor_SiftExtraction_dsp_num_scales}
 fi
 
-################################################################################
+# Exhaustive Feature Matcher
 if [ "${matcher_type}" == "exhaustive" ]
 then
 	echo "    colmap exhaustive_matcher ..."
@@ -164,17 +161,18 @@ then
 
 fi
 
+# Sequential Feature Matcher
 if [ "${matcher_type}" == "sequential" ]
 then
   num_rgb=$(wc -l < ${rgb_txt})
 
   # Pick vocabulary tree based on the number of images
-  vocabulary_tree="Baselines/glomap/vocab_tree_flickr100K_words32K.bin"
+  vocabulary_tree="Baselines/colmap/vocab_tree_flickr100K_words32K.bin"
   if [ "$num_rgb" -gt 1000 ]; then
-    vocabulary_tree="Baselines/glomap/vocab_tree_flickr100K_words256K.bin"
+    vocabulary_tree="Baselines/colmap/vocab_tree_flickr100K_words256K.bin"
   fi
   if [ "$num_rgb" -gt 10000 ]; then
-    vocabulary_tree="Baselines/glomap/vocab_tree_flickr100K_words1M.bin"
+    vocabulary_tree="Baselines/colmap/vocab_tree_flickr100K_words1M.bin"
   fi
 
   echo "    colmap sequential_matcher ..."

colmap_reconstruction.sh

@@ -1,11 +1,17 @@
 #!/bin/bash
 
-# Function to split key-value pairs and assign them to variables
+# Default values
 matcher_type="exhaustive"
 use_gpu="1"
 verbose="0"
 settings_yaml=""
+sequence_path=""
+exp_folder=""
+exp_id=""
+calibration_yaml=""
+rgb_txt=""
 
+# Function to split key-value pairs and assign them to variables
 split_and_assign() {
   local input=$1
   local key=$(echo $input | cut -d':' -f1)
@@ -13,52 +19,40 @@ split_and_assign() {
   eval $key=$value
 }
 
-# Split the input string into individual components
+# Read Inputs
 for ((i=1; i<=$#; i++)); do
     split_and_assign "${!i}"
 done
 
 exp_id=$(printf "%05d" ${exp_id})
 
-echo "Sequence Path: $sequence_path"
-echo "Experiment Folder: $exp_folder"
-echo "Experiment ID: $exp_id"
-echo "Verbose: $verbose"
-echo "matcher_type: $matcher_type"
-echo "use_gpu: $use_gpu"
-echo "settings_yaml: $settings_yaml"
-echo "calibration_yaml: $calibration_yaml"
-echo "rgb_txt: $rgb_txt"
+echo -e "\n================= Experiment Configuration ================="
+echo "  Sequence Path     : $sequence_path"
+echo "  Experiment Folder : $exp_folder"
+echo "  Experiment ID     : $exp_id"
+echo "  Verbose           : $verbose"
+echo "  Matcher Type      : $matcher_type"
+echo "  Use GPU           : $use_gpu"
+echo "  Settings YAML     : $settings_yaml"
+echo "  Calibration YAML  : $calibration_yaml"
+echo "  RGB TXT           : $rgb_txt"
+echo "============================================================"
 
+# Create folder to save colmap files
 exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
 rm -rf "$exp_folder_colmap"
 mkdir "$exp_folder_colmap"
 
-export QT_QPA_PLATFORM_PLUGIN_PATH="$CONDA_PREFIX/plugins/platforms"
-
 # Run COLMAP scripts for matching and mapping
-./Baselines/glomap/colmap_matcher.sh $sequence_path $exp_folder $exp_id $matcher_type $use_gpu ${settings_yaml} ${calibration_yaml} ${rgb_txt}
-./Baselines/glomap/glomap_mapper.sh $sequence_path $exp_folder $exp_id ${verbose} ${settings_yaml} ${calibration_yaml} ${rgb_txt}
-
-# Convert COLMAP outputs to a format suitable for VSLAM-Lab
-python Baselines/glomap/colmap_to_vslamlab.py $sequence_path $exp_folder $exp_id $verbose $rgb_txt
+export QT_QPA_PLATFORM_PLUGIN_PATH="$CONDA_PREFIX/plugins/platforms"
+colmap_args="$sequence_path $exp_folder $exp_id $settings_yaml $calibration_yaml $rgb_txt"
+./Baselines/colmap/colmap_matcher.sh $colmap_args $matcher_type $use_gpu
+./Baselines/colmap/colmap_mapper.sh $colmap_args 
 
-# Get colmap stats
-colmap_stats_csv="${exp_folder}/${exp_id}_colmap_stats.csv"
-if [[ ! -f "$colmap_stats_csv" ]]; then
-  echo "File,Cameras,Images,Registered Images,Points,Observations,Mean Track Length,Mean Observations per Image,Mean Reprojection Error" > "$colmap_stats_csv"
-fi
-colmap_stats=$(pixi run -e colmap colmap model_analyzer --path "$exp_folder_colmap" 2>&1)
-cameras=$(echo "$colmap_stats" | grep -oP "(?<=Cameras: )\d+")
-images=$(echo "$colmap_stats" | grep -oP "(?<=Images: )\d+")
-registered_images=$(echo "$colmap_stats" | grep -oP "(?<=Registered images: )\d+")
-points=$(echo "$colmap_stats" | grep -oP "(?<=Points: )\d+")
-observations=$(echo "$colmap_stats" | grep -oP "(?<=Observations: )\d+")
-mean_track_length=$(echo "$colmap_stats" | grep -oP "(?<=Mean track length: )\d+\.\d+")
-mean_observations_per_image=$(echo "$colmap_stats" | grep -oP "(?<=Mean observations per image: )\d+\.\d+")
-mean_reprojection_error=$(echo "$colmap_stats" | grep -oP "(?<=Mean reprojection error: )\d+\.\d+")
-echo "$exp_folder_colmap,${cameras:-0},${images:-0},${registered_images:-0},${points:-0},${observations:-0},${mean_track_length:-0},${mean_observations_per_image:-0},${mean_reprojection_error:-0}" >> "$colmap_stats_csv"
+# 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_txt
 
+# Visualization with colmap gui
 if [ "$verbose" -eq 1 ]; then
   exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
   rgb_path="${sequence_path}/$(awk '{print $2}' "${rgb_txt}" | awk -F'/' 'NR==1 {print $1}')"
@@ -66,8 +60,7 @@ if [ "$verbose" -eq 1 ]; then
   colmap gui --import_path "${exp_folder_colmap}/0" --database_path ${database} --image_path ${rgb_path}
 fi
 
-
-# Remove colmap data
-rm -rf ${exp_folder_colmap}
+# # Remove colmap data
+# rm -rf ${exp_folder_colmap}
 
 

colmap_to_vslamlab.py

@@ -0,0 +1,106 @@
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+import sys
+import os
+
+def get_colmap_keyframes(images_file, number_of_header_lines, verbose=False):
+    print(f"get_colmap_keyframes: {images_file}")
+    
+    image_id = []
+    q_wc_xyzw = []
+    t_wc = []
+
+    with open(f"{images_file}", 'r') as file:
+        # Skip the header lines
+        for _ in range(number_of_header_lines):
+            file.readline()
+        
+        while True:
+            line1 = file.readline()
+            if not line1:
+                break
+            elements = line1.split()
+            
+            IMAGE_ID = int(elements[0])
+            image_id.append(IMAGE_ID)
+            
+            QW = float(elements[1])
+            QX = float(elements[2])
+            QY = float(elements[3])
+            QZ = float(elements[4])
+            
+            TX = float(elements[5])
+            TY = float(elements[6])
+            TZ = float(elements[7])
+
+            t_cw_i = np.array([TX, TY, TZ])
+            q_wc_i = R.from_quat([QX, QY, QZ, QW]).inv()
+            R_wc_i = q_wc_i.as_matrix()
+            
+            q_wc_xyzw.append([q_wc_i.as_quat()[0], q_wc_i.as_quat()[1], q_wc_i.as_quat()[2], q_wc_i.as_quat()[3]])
+            t_wc.append(-R_wc_i @ t_cw_i)
+
+            file.readline()
+    
+    image_id = np.array(image_id)
+    q_wc_xyzw = np.array(q_wc_xyzw)
+    t_wc = np.array(t_wc)
+
+    sorted_indices = image_id.argsort()
+    image_id = image_id[sorted_indices]
+    q_wc_xyzw = q_wc_xyzw[sorted_indices]
+    t_wc = t_wc[sorted_indices]
+
+    q_wc_xyzw_corrected = q_wc_xyzw.copy()
+    for i in range(1, len(q_wc_xyzw_corrected)):
+        dot_product = np.dot(q_wc_xyzw_corrected[i - 1], q_wc_xyzw_corrected[i])
+        if dot_product < 0:
+            q_wc_xyzw_corrected[i] = -q_wc_xyzw_corrected[i]
+
+    return image_id, t_wc, q_wc_xyzw_corrected
+
+def write_trajectory_tum_format(file_name, image_ts, t_wc, q_wc_xyzw):
+    print(f"writeTrajectoryTUMformat: {file_name}")
+    
+    data = np.hstack((image_ts.reshape(-1, 1), t_wc, q_wc_xyzw))
+    data = data[data[:, 0].argsort()]
+
+    with open(file_name, 'w') as file:
+        for row in data:
+            # Format the row with the appropriate precision
+            file.write(' '.join(f'{x:.15f}' for x in row) + '\n')
+
+def get_timestamps(files_path, rgb_file):
+    print(f"getTimestamps: {os.path.join(files_path, rgb_file)}")
+    
+    ts = []
+    
+    with open(os.path.join(files_path, rgb_file), 'r') as file:
+        for line in file:
+            parts = line.split()
+            ts.append(float(parts[0]))  # Assuming the first part is the timestamp
+    
+    return ts
+                
+if __name__ == "__main__":
+
+    sequence_path = sys.argv[1]
+    exp_folder = sys.argv[2]
+    exp_id = sys.argv[3]
+    verbose = bool(int(sys.argv[4]))
+    rgb_file = sys.argv[5]
+
+    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))
+    timestamps = []
+    for id in image_id:
+        timestamps.append(float(image_ts[id-1]))
+
+    timestamps = np.array(timestamps)
+
+    keyFrameTrajectory_txt = os.path.join(exp_folder, exp_id + '_KeyFrameTrajectory' + '.txt')
+    write_trajectory_tum_format(keyFrameTrajectory_txt, timestamps, t_wc, q_wc_xyzw)

vslamlab_colmap_settings.yaml

@@ -1,29 +1,3 @@
-BundleAdjustment:
-  thres_loss_function: 1.0
-
-RelPoseEstimation:
-  max_epipolar_error: 1.0
-
-GlobalPositioning:
-  thres_loss_function: 0.10000000000000001
-
-Triangulation:
-  complete_max_reproj_error: 15.0
-  merge_max_reproj_error: 15.0  
-  min_angle: 1.0
-  min_num_matches: 15
-    
-Thresholds:
-  max_angle_error: 1.0
-  max_reprojection_error: 0.01
-  min_triangulation_angle: 1.0
-  min_inlier_num: 30.0
-  min_inlier_ratio: 0.25
-  max_rotation_error: 10.0
-  max_epipolar_error_E: 1.0
-  max_epipolar_error_F: 4.0
-  max_epipolar_error_H: 4.0
-
 feature_extractor:
   SiftExtraction_num_octaves: 4
   SiftExtraction_octave_resolution: 3
@@ -43,3 +17,63 @@ matcher:
   SequentialMatching_overlap: 10
   SequentialMatching_quadratic_overlap: 1 
   ExhaustiveMatching_block_size: 50
+
+mapper:
+  Mapper_min_num_matches: 15
+  Mapper_ignore_watermarks: 0
+  Mapper_multiple_models: 1
+  Mapper_max_num_models: 50
+  Mapper_max_model_overlap: 20
+  Mapper_min_model_size: 10
+  Mapper_init_image_id1: -1
+  Mapper_init_image_id2: -1
+  Mapper_init_num_trials: 200
+  Mapper_extract_colors: 1
+  Mapper_num_threads: -1
+  Mapper_min_focal_length_ratio: 0.10000000000000001
+  Mapper_max_focal_length_ratio: 10
+  Mapper_max_extra_param: 1
+  Mapper_ba_refine_focal_length: 1
+  Mapper_ba_refine_principal_point: 0
+  Mapper_ba_refine_extra_params: 1
+  Mapper_ba_local_num_images: 6
+  Mapper_ba_local_function_tolerance: 0
+  Mapper_ba_local_max_num_iterations: 25
+  Mapper_ba_global_images_ratio: 1.1000000000000001
+  Mapper_ba_global_points_ratio: 1.1000000000000001
+  Mapper_ba_global_images_freq: 500
+  Mapper_ba_global_points_freq: 250000
+  Mapper_ba_global_function_tolerance: 0
+  Mapper_ba_global_max_num_iterations: 50
+  Mapper_ba_global_max_refinements: 5
+  Mapper_ba_global_max_refinement_change: 0.00050000000000000001
+  Mapper_ba_local_max_refinements: 2
+  Mapper_ba_local_max_refinement_change: 0.001
+  Mapper_ba_use_gpu: 0
+  Mapper_ba_gpu_index: -1
+  Mapper_ba_min_num_residuals_for_cpu_multi_threading: 50000
+  Mapper_snapshot_images_freq: 0
+  Mapper_fix_existing_images: 0
+  Mapper_init_min_num_inliers: 100
+  Mapper_init_max_error: 4
+  Mapper_init_max_forward_motion: 0.94999999999999996
+  Mapper_init_min_tri_angle: 16
+  Mapper_init_max_reg_trials: 2
+  Mapper_abs_pose_max_error: 12
+  Mapper_abs_pose_min_num_inliers: 30
+  Mapper_abs_pose_min_inlier_ratio: 0.25
+  Mapper_filter_max_reproj_error: 4
+  Mapper_filter_min_tri_angle: 1.5
+  Mapper_max_reg_trials: 3
+  Mapper_local_ba_min_tri_angle: 6
+  Mapper_tri_max_transitivity: 1
+  Mapper_tri_create_max_angle_error: 2
+  Mapper_tri_continue_max_angle_error: 2
+  Mapper_tri_merge_max_reproj_error: 4
+  Mapper_tri_complete_max_reproj_error: 4
+  Mapper_tri_complete_max_transitivity: 5
+  Mapper_tri_re_max_angle_error: 5
+  Mapper_tri_re_min_ratio: 0.20000000000000001
+  Mapper_tri_re_max_trials: 1
+  Mapper_tri_min_angle: 1.5
+  Mapper_tri_ignore_two_view_tracks: 1