Upload folder using huggingface_hub

colmap_mapper.sh

@@ -1,18 +1,22 @@
 #!/bin/bash
 echo "Executing colmap_mapper.sh ..."
 
-sequence_path="$1" 
-exp_folder="$2" 
-exp_id="$3" 
+sequence_path="$1"
+exp_folder="$2"
+exp_id="$3"
 settings_yaml="$4"
 calibration_yaml="$5"
 rgb_csv="$6"
 camera_name="$7"
+mapper_type="$8"
 
 exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
 rgb_dir="${camera_name}"
 rgb_path="${sequence_path}/${rgb_dir}"
 
+# Sets use_gpu, gpu_index_list, num_threads
+source "$(dirname "$0")/detect_gpus.sh"
+
 read -r calibration_model more_ <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
 echo "        camera model : $calibration_model"
 ba_refine_focal_length="0"
@@ -25,19 +29,37 @@ then
   ba_refine_extra_params="1"
 fi
 
-echo "    colmap mapper ..."
 database="${exp_folder_colmap}/colmap_database.db"
 
-colmap mapper \
-    --database_path ${database} \
-    --image_path ${rgb_path} \
-    --output_path ${exp_folder_colmap} \
-    --Mapper.ba_refine_focal_length ${ba_refine_focal_length} \
-    --Mapper.ba_refine_principal_point ${ba_refine_principal_point} \
-    --Mapper.ba_refine_extra_params ${ba_refine_extra_params}
+if [ "${mapper_type}" == "glomap" ]
+then
+    echo "    global mapper (GLOMAP) ..."
+    colmap global_mapper \
+        --database_path ${database} \
+        --image_path ${rgb_path} \
+        --output_path ${exp_folder_colmap} \
+        --GlobalMapper.ba_refine_focal_length ${ba_refine_focal_length} \
+        --GlobalMapper.ba_refine_principal_point ${ba_refine_principal_point} \
+        --GlobalMapper.ba_refine_extra_params ${ba_refine_extra_params} \
+        --GlobalMapper.ba_ceres_use_gpu ${use_gpu} \
+        --GlobalMapper.ba_ceres_gpu_index "${gpu_index_list}" \
+        --GlobalMapper.gp_use_gpu ${use_gpu} \
+        --GlobalMapper.gp_gpu_index "${gpu_index_list}" \
+        --GlobalMapper.num_threads "${num_threads}"
+else
+    echo "    colmap mapper (COLMAP) ..."
+    colmap mapper \
+        --database_path ${database} \
+        --image_path ${rgb_path} \
+        --output_path ${exp_folder_colmap} \
+        --Mapper.ba_refine_focal_length ${ba_refine_focal_length} \
+        --Mapper.ba_refine_principal_point ${ba_refine_principal_point} \
+        --Mapper.ba_refine_extra_params ${ba_refine_extra_params} \
+        --Mapper.ba_use_gpu ${use_gpu} \
+        --Mapper.ba_gpu_index "${gpu_index_list}" \
+        --Mapper.num_threads "${num_threads}"
+fi
 
 echo "    colmap model_converter ..."
 colmap model_converter \
-	--input_path ${exp_folder_colmap}/0 --output_path ${exp_folder_colmap} --output_type TXT
-
-
+	--input_path ${exp_folder_colmap}/0 --output_path ${exp_folder_colmap} --output_type TXT

colmap_matcher.sh

@@ -3,21 +3,78 @@ echo ""
 echo "Executing colmap_matcher.sh ..."
 
 sequence_path="$1"
-exp_folder="$2" 
-exp_id="$3" 
+exp_folder="$2"
+exp_id="$3"
 settings_yaml="$4"
 calibration_yaml="$5"
 rgb_csv="$6"
 matcher_type="$7"
-use_gpu="$8"
-camera_name="$9"
+camera_name="$8"
+matching_type="$9"
 
 exp_folder_colmap="${exp_folder}/colmap_${exp_id}"
 rgb_dir=$(awk -F, 'NR==2 { split($2,a,"/"); print a[1]; exit }' "$rgb_csv")
 rgb_path="${sequence_path}/${rgb_dir}"
 
-# Get calibration model
-read -r calibration_model more_ <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+# matching_type: FeatureExtraction.type + FeatureMatching.type
+feature_matching_type=""
+feature_extraction_type="SIFT"
+
+case "${matching_type}" in
+    sift_bruteforce)
+        feature_extraction_type="SIFT"
+        feature_matching_type="SIFT_BRUTEFORCE"
+        ;;
+    sift_lightglue)
+        feature_extraction_type="SIFT"
+        feature_matching_type="SIFT_LIGHTGLUE"
+        ;;
+    aliked_bruteforce)
+        feature_extraction_type="ALIKED_N16ROT"
+        feature_matching_type="ALIKED_BRUTEFORCE"
+        ;;
+    aliked_lightglue)
+        feature_extraction_type="ALIKED_N16ROT"
+        feature_matching_type="ALIKED_LIGHTGLUE"
+        ;;
+    *)
+        echo "Unknown matching_type: ${matching_type}"
+        exit 1
+        ;;
+esac
+
+# Sets use_gpu, gpu_index_list, num_threads
+source "$(dirname "$0")/detect_gpus.sh"
+
+# Get calibration model and parameters
+read -r calibration_model params <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
+
+case "${calibration_model}" in
+    unknown)
+        colmap_camera_model="OPENCV"
+        camera_params=""
+        ;;
+    pinhole)
+        colmap_camera_model="PINHOLE"
+        camera_params="${params// /,}"
+        ;;
+    radtan4)
+        colmap_camera_model="OPENCV"
+        camera_params="${params// /,}"
+        ;;
+    radtan5)
+        colmap_camera_model="FULL_OPENCV"
+        camera_params="${params// /,},0,0,0"
+        ;;
+    equid4)
+        colmap_camera_model="OPENCV_FISHEYE"
+        camera_params="${params// /,}"
+        ;;
+    *)
+        echo "Unknown calibration_model: ${calibration_model}"
+        exit 1
+        ;;
+esac
 
 # Create colmap image list
 colmap_image_list="${exp_folder_colmap}/colmap_image_list.txt"
@@ -26,98 +83,41 @@ python3 Baselines/colmap/create_colmap_image_list.py "$rgb_csv" "$colmap_image_l
 # Create Colmap Database
 database="${exp_folder_colmap}/colmap_database.db"
 rm -rf ${database}
-colmap database_creator --database_path ${database} 
+colmap database_creator --database_path ${database}
 
 # Feature extractor
-echo "    colmap feature_extractor ..."
+echo "    colmap feature_extractor (${feature_extraction_type}) ..."
+echo "        gpu_index: ${gpu_index_list}"
+echo "        camera model : ${calibration_model} (colmap: ${colmap_camera_model})"
+[ -n "${camera_params}" ] && echo "        camera params: ${camera_params}"
 
-if [ "${calibration_model}" == "unknown" ]
-then
-echo "        camera model : $calibration_model"
-colmap feature_extractor \
-   --database_path ${database} \
-   --image_path ${rgb_path} \
-   --image_list_path ${colmap_image_list} \
-   --ImageReader.camera_model SIMPLE_PINHOLE \
-   --ImageReader.single_camera 1 \
-   --ImageReader.single_camera_per_folder 1 \
-   --FeatureExtraction.use_gpu ${use_gpu}
-fi
-
-if [ "${calibration_model}" == "pinhole" ]
-then
-  read -r calibration_model fx fy cx cy <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
-  echo "        camera model : $calibration_model"
-  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
-  colmap feature_extractor \
-	--database_path ${database} \
-	--image_path ${rgb_path} \
-	--image_list_path ${colmap_image_list} \
-	--ImageReader.camera_model PINHOLE \
-	--ImageReader.single_camera 1 \
-	--ImageReader.single_camera_per_folder 1 \
-	--FeatureExtraction.use_gpu ${use_gpu} \
-	--ImageReader.camera_params "${fx},${fy},${cx},${cy}"
-fi
-
-if [ "${calibration_model}" == "radtan4" ]
-then
-  read -r calibration_model fx fy cx cy k1 k2 p1 p2 <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
-  echo "        camera model : $calibration_model"
-  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
-  echo "            k1: $k1 , k2: $k2 , p1: $p1 , p2: $p2"
-  colmap feature_extractor \
-	--database_path ${database} \
-	--image_path ${rgb_path} \
-	--image_list_path ${colmap_image_list} \
-	--ImageReader.camera_model "OPENCV" \
-	--ImageReader.single_camera 1 \
-  --ImageReader.single_camera_per_folder 1 \
-	--FeatureExtraction.use_gpu ${use_gpu} \
-  --ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${p1},${p2}"
-fi
-
-if [ "${calibration_model}" == "radtan5" ]
-then
-  read -r calibration_model fx fy cx cy k1 k2 p1 p2 k3 <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
-  echo "        camera model : $calibration_model"
-  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
-  echo "            k1: $k1 , k2: $k2 , p1: $p1 , p2: $p2, k3: $k3"
-  colmap feature_extractor \
-	--database_path ${database} \
-	--image_path ${rgb_path} \
-	--image_list_path ${colmap_image_list} \
-	--ImageReader.camera_model "FULL_OPENCV" \
-	--ImageReader.single_camera 1 \
-  --ImageReader.single_camera_per_folder 1 \
-	--FeatureExtraction.use_gpu ${use_gpu} \
-  --ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${p1},${p2},${k3},0,0,0"
-fi
+camera_params_args=()
+[ -n "${camera_params}" ] && camera_params_args=(--ImageReader.camera_params "${camera_params}")
 
-if [ "${calibration_model}" == "equid4" ] 
-then
-  read -r calibration_model fx fy cx cy k1 k2 k3 k4 <<< $(python3 Baselines/colmap/get_calibration.py "$calibration_yaml" "$camera_name")
-  echo "        camera model : $calibration_model"
-  echo "            fx: $fx , fy: $fy , cx: $cx , cy: $cy"
-  echo "            k1: $k1 , k2: $k2 , k3: $k3 , k4: $k4"
-	colmap feature_extractor \
-	--database_path ${database} \
-	--image_path ${rgb_path} \
-	--image_list_path ${colmap_image_list} \
-	--ImageReader.camera_model "OPENCV_FISHEYE"\
-	--ImageReader.single_camera 1 \
-	--ImageReader.single_camera_per_folder 1 \
-	--FeatureExtraction.use_gpu ${use_gpu} \
-	--ImageReader.camera_params "${fx},${fy},${cx},${cy},${k1},${k2},${k3},${k4}"
-fi
+colmap feature_extractor \
+    --database_path ${database} \
+    --image_path ${rgb_path} \
+    --image_list_path ${colmap_image_list} \
+    --ImageReader.camera_model "${colmap_camera_model}" \
+    --ImageReader.single_camera 1 \
+    --ImageReader.single_camera_per_folder 1 \
+    --FeatureExtraction.type ${feature_extraction_type} \
+    --FeatureExtraction.use_gpu ${use_gpu} \
+    --FeatureExtraction.gpu_index "${gpu_index_list}" \
+    --FeatureExtraction.num_threads "${num_threads}" \
+    "${camera_params_args[@]}"
 
 # Exhaustive Feature Matcher
-if [ "${matcher_type}" == "exhaustive" ]
+if [ "${matcher_type}" == "exhaustive" ];
 then
-	echo "    colmap exhaustive_matcher ..."
+  echo "    colmap exhaustive_matcher (${feature_matching_type}) ..."
+  echo "        gpu_index: ${gpu_index_list}"
   colmap exhaustive_matcher \
-     --database_path ${database} \
-     --FeatureMatching.use_gpu ${use_gpu}
+    --database_path "${database}" \
+    --FeatureMatching.type "${feature_matching_type}" \
+    --FeatureMatching.use_gpu "${use_gpu}" \
+    --FeatureMatching.gpu_index "${gpu_index_list}" \
+    --FeatureMatching.num_threads "${num_threads}"
 fi
 
 # Sequential Feature Matcher
@@ -134,22 +134,15 @@ then
     vocabulary_tree="Baselines/colmap/vocab_tree_flickr100K_words1M.bin"
   fi
 
-  echo "    colmap sequential_matcher ..."
+  echo "    colmap sequential_matcher (${feature_matching_type}) ..."
   echo "        Vocabulary Tree: $vocabulary_tree"
+  echo "        gpu_index: ${gpu_index_list}"
   colmap sequential_matcher \
     --database_path "${database}" \
     --SequentialMatching.loop_detection 1 \
     --SequentialMatching.vocab_tree_path ${vocabulary_tree} \
-    --FeatureMatching.use_gpu "${use_gpu}"
-fi
-
-# LightGlue Feature Matcher
-if [ "${matcher_type}" == "custom" ]
-then
-  colmap exhaustive_matcher \
-      --database_path ${database} \
-      --FeatureMatching.use_gpu ${use_gpu} 
-  
-  pixi run -e lightglue python3 Baselines/colmap/feature_matcher.py --database ${database} --rgb_path ${rgb_path} --rgb_csv ${rgb_csv}
-fi
-
+    --FeatureMatching.type "${feature_matching_type}" \
+    --FeatureMatching.use_gpu "${use_gpu}" \
+    --FeatureMatching.gpu_index "${gpu_index_list}" \
+    --FeatureMatching.num_threads "${num_threads}"
+fi

colmap_reconstruction.sh

@@ -2,7 +2,8 @@
 
 # Default values
 matcher_type="exhaustive"
-use_gpu="1"
+matching_type="sift_bruteforce"
+mapper_type="colmap"
 verbose="0"
 settings_yaml=""
 sequence_path=""
@@ -33,7 +34,8 @@ echo "  Experiment Folder : $exp_folder"
 echo "  Experiment ID     : $exp_id"
 echo "  Verbose           : $verbose"
 echo "  Matcher Type      : $matcher_type"
-echo "  Use GPU           : $use_gpu"
+echo "  Matching Type     : $matching_type"
+echo "  Mapper Type       : $mapper_type"
 echo "  Settings YAML     : $settings_yaml"
 echo "  Calibration YAML  : $calibration_yaml"
 echo "  RGB CSV           : $rgb_csv"
@@ -48,8 +50,8 @@ mkdir "$exp_folder_colmap"
 # Run COLMAP scripts for matching and mapping
 export QT_QPA_PLATFORM_PLUGIN_PATH="$CONDA_PREFIX/plugins/platforms"
 colmap_args="$sequence_path $exp_folder $exp_id $settings_yaml $calibration_yaml $rgb_csv"
-./Baselines/colmap/colmap_matcher.sh $colmap_args $matcher_type $use_gpu $camera_name
-./Baselines/colmap/colmap_mapper.sh $colmap_args $camera_name
+./Baselines/colmap/colmap_matcher.sh $colmap_args $matcher_type $camera_name $matching_type
+./Baselines/colmap/colmap_mapper.sh $colmap_args $camera_name $mapper_type
 
 # Convert COLMAP outputs to a format suitable for VSLAM-LAB
 python Baselines/colmap/colmap_to_vslamlab.py $sequence_path $exp_folder $exp_id $verbose $rgb_csv $camera_name
@@ -64,6 +66,4 @@ if [ "$verbose" -eq 1 ]; then
 fi
 
 # # Remove colmap data
-# rm -rf ${exp_folder_colmap}
-
-
+# rm -rf ${exp_folder_colmap}

detect_gpus.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# Sourced by colmap_matcher.sh / colmap_mapper.sh (not executed directly).
+# Sets: use_gpu (1 if any GPU detected, 0 otherwise), gpu_index_list
+# (comma-separated ordinals for colmap's *_gpu_index options), num_threads.
+
+# Detect usable GPUs: extraction/matching/mapping run as a single job across
+# all of them, since COLMAP spawns one worker per listed GPU index and splits
+# the per-image / per-block workload internally.
+echo "    detecting GPUs ..."
+echo "        nvidia-smi -L:"
+nvidia-smi -L 2>&1 | sed 's/^/            /'
+echo "        nvidia-smi --query-gpu=index,name,uuid --format=csv:"
+nvidia-smi --query-gpu=index,name,uuid --format=csv 2>&1 | sed 's/^/            /'
+echo "        CUDA_VISIBLE_DEVICES: ${CUDA_VISIBLE_DEVICES}"
+
+if [ -n "${CUDA_VISIBLE_DEVICES}" ]; then
+  # The scheduler already restricted this job to a specific device set (often
+  # MIG slice UUIDs on HPC, which `nvidia-smi --query-gpu=index` does not
+  # enumerate - it lists the whole node's GPUs, not what's gated to this job).
+  # CUDA remaps whatever's listed here to ordinals 0..N-1 inside the process,
+  # and COLMAP's gpu_index just calls cudaSetDevice(ordinal), so address by
+  # ordinal count rather than trying to resolve real indices/UUIDs ourselves.
+  num_gpus=$(echo "${CUDA_VISIBLE_DEVICES}" | tr ',' '\n' | grep -c .)
+  gpu_ids=($(seq 0 $((num_gpus - 1))))
+else
+  gpu_ids=($(nvidia-smi --query-gpu=index --format=csv,noheader 2>/dev/null))
+fi
+
+use_gpu="1"
+if [ "${#gpu_ids[@]}" -lt 1 ]; then
+  use_gpu="0"
+  gpu_ids=(0)
+fi
+gpu_index_list=$(IFS=,; echo "${gpu_ids[*]}")
+echo "        use_gpu: ${use_gpu}"
+echo "        detected gpu_ids: ${gpu_ids[*]}"
+echo "        gpu_index_list passed to colmap: ${gpu_index_list}"
+
+# Bound CPU thread count too: num_threads=-1 (COLMAP's default) auto-detects
+# via APIs that on cgroup-limited HPC nodes often report the physical node's
+# total core count rather than what's actually allocated to this job. `nproc`
+# (not `nproc --all`) reports the affinity-restricted count instead, so it
+# respects whatever the scheduler's cgroup actually granted.
+num_threads=$(nproc)
+echo "        num_threads: ${num_threads}"