This is the multi-page printable view of this section. Click here to print.
Welcome to the tutorials section.
This site currently features a complete guide for reconstructing real-world objects using 3D Gaussian Splatting. It walks you through image capture, camera pose estimation, model training, and post-processing — all using open-source tools on Windows.
More tutorials will be added in the future.
Real-world plush toy (left) and its reconstructed 3D Gaussian Splatting model (right).
This tutorial explains how to reconstruct a 3D scene from real-world photographs using Gaussian Splatting. The method was introduced in the paper 3D Gaussian Splatting for Real-Time Radiance Field Rendering (Kerbl et al., 2023).
Gaussian Splatting is a modern technique for novel view synthesis. It reconstructs scenes by placing thousands of small 3D Gaussians in space and optimizing their appearance to match the input images. This approach is particularly effective at capturing fine and soft details, such as fur or fabric textures, which are often difficult for traditional surface-based methods.
This tutorial demonstrates the complete pipeline using a real plush toy as the subject. It includes the following steps:
The example shows how to achieve reproducible results using only open-source tools configured for Windows.
This workflow is especially well-suited for scanning physical products or small real-world objects, making it useful for applications such as product visualization, object digitization, and 3D content creation.
This tutorial uses the gsplat repository for 3D Gaussian Splatting. Compared to the original implementation by the authors (graphdeco-inria/gaussian-splatting), gsplat provides several practical advantages:
COLMAP estimates camera poses and generates a sparse reconstruction from input images. These results are used to train the 3D Gaussian Splatting model. The Windows version of COLMAP includes both a graphical interface and command-line tools.
Note: gsplat is part of the Nerfstudio project, which includes a built-in COLMAP wrapper that runs with default parameters. This is often sufficient, but some datasets require custom settings for successful reconstruction. A later section explains how to adjust key parameters when the defaults do not work.
Note: Other tools such as RealityCapture, Agisoft Metashape, or Autodesk ReCap Pro can be used for similar pipelines. This tutorial focuses on free and reproducible workflows using COLMAP.
SuperSplat Editor is an open-source, browser-based tool for viewing, editing, and optimizing 3D Gaussian Splatting models. It supports the following tasks:
SuperSplat can also be installed as a Progressive Web App (PWA) for faster access and desktop integration.
This tutorial focuses on Windows because it is widely used by beginners, students, and general technical users. While many open-source tools are developed for Linux, Windows users often face additional setup challenges due to platform-specific differences.
Questions about installing and running COLMAP and gsplat on Windows are common in forums, GitHub issues, and online communities. This tutorial provides a clear, step-by-step workflow tailored to Windows to help make modern 3D reconstruction techniques more accessible.
This tutorial walks through the full pipeline for building a 3D Gaussian Splatting model from real-world images. The process includes four main stages:
Overview of the 3D Gaussian Splatting pipeline.
The following sections explain each step in detail. You can skip to a specific section if you’re interested only in training, visualization, or another part of the workflow.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
This tutorial was developed and tested on Windows 11. Most steps also work on Linux, with some differences that will be addressed in a separate guide.
For efficient training and reproducibility, use a system with the following configuration:
Hardware
Software
Note: Minor differences in software versions or CUDA drivers may require small adjustments.
Note: The CUDA Toolkit must be installed separately from the GPU driver to enable GPU acceleration. Without it, tools like PyTorch will not detect CUDA support. For instructions and compatibility details, see the CUDA Toolkit documentation.
This tutorial was verified using the following configuration:
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
Go to the official COLMAP GitHub releases page and download the ZIP archive for Windows:
https://github.com/colmap/colmap/releases
Extract the contents of the ZIP file to a convenient location, such as:
C:\Tools\colmap
This tutorial uses <COLMAP_PATH> as a placeholder for the COLMAP installation path. Replace it with the actual path you used.
You can start the COLMAP GUI using either of the following methods:
Option A
Double-click COLMAP.bat in the extracted folder.
Option B
Open Command Prompt and run:
<COLMAP_PATH>\COLMAP.bat gui
Replace <COLMAP_PATH> with the actual installation path.
Verify the installation If installed correctly, the COLMAP GUI should open without errors. You should see the main window, as shown below:
Figure 3. COLMAP GUI main window on startup.
Alternative installation methods This tutorial uses the precompiled Windows release. For other options, including building from source or using package managers on Linux or macOS, refer to the official guide: https://colmap.github.io/install.html
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
The Microsoft Build Tools for Visual Studio provide the C++ compiler and related tools required to build C++ projects on Windows. This setup is necessary to compile gsplat from source.
Download the Build Tools for Visual Studio 2022 from the official website:
https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022
During installation, select the following options:
Workload:
Individual components (ensure these are checked):
Figure 4. Required components selected during Visual Studio Build Tools installation.
You can verify that the build environment is configured correctly using either of the following methods.
Open the Start Menu and search for:
Developer Command Prompt for VS 2022
Run the following command:
cl
You should see output similar to:
Microsoft (R) C/C++ Optimizing Compiler Version 19.43.34809 for x86
usage: cl [ option... ] filename... [ /link linkoption... ]
vcvars64.bat from a regular Command Prompt
cmd)."C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Auxiliary\Build\vcvars64.bat"
Adjust the path if needed.
Then run:
cl
If the compiler is configured correctly, you will see the same output as in the previous option.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
Before installing PyTorch or building gsplat, verify that the CUDA Toolkit is installed and accessible. In Command Prompt, run:
nvcc --version
If installed correctly, you should see output similar to:
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2024 NVIDIA Corporation
Built on Fri_Jun_14_16:44:19_Pacific_Daylight_Time_2024
Cuda compilation tools, release 12.6, V12.6.20
Build cuda_12.6.r12.6/compiler.34431801_0
If the command is not recognized or no version is shown, install the CUDA Toolkit from the NVIDIA website. Older versions are available from the CUDA Toolkit archive.
To build gsplat, use a terminal with the Visual C++ environment initialized.
Option A: Developer Command Prompt
Option B: Use vcvars64.bat manually
"C:\Program Files (x86)\Microsoft Visual Studio\2022\BuildTools\VC\Auxiliary\Build\vcvars64.bat"
After running the script, the terminal will be configured with the necessary environment variables.
If not installed, download Miniconda or Anaconda.
Create and activate a new environment:
conda create -y -n gsplat python=3.10
conda activate gsplat
Visit the PyTorch installation page and choose the configuration matching your Python and CUDA version.
For CUDA 12.6, run:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126
Verify that PyTorch detects CUDA:
python -c "import torch; print(torch.cuda.is_available())"
Expected output:
True
git clone --recursive https://github.com/nerfstudio-project/gsplat.git
cd gsplat
Here’s your reviewed and formatted markdown section following the Google Developer Documentation style guide, avoiding em-dashes and using consistent formatting:
To build gsplat, run the following command:
set DISTUTILS_USE_SDK=1
pip install .
This sets the DISTUTILS_USE_SDK environment variable to avoid the following warning:
UserWarning: It seems that the VC environment is activated but DISTUTILS_USE_SDK is not set...
Navigate to the examples folder and install dependencies:
cd examples
pip install -r requirements.txt
Clone the dataset repository:
git clone <URL_TO_EXAMPLE_DATA>
Replace <DATA_PATH> and <OUTPUT_PATH> with your actual paths.
Start training with the following command:
python simple_trainer.py default ^
--eval_steps -1 ^
--disable_viewer ^
--data_factor 4 ^
--data_dir <DATA_PATH> ^
--result_dir <OUTPUT_PATH>
Replace <DATA_PATH> and <OUTPUT_PATH> with valid paths. If everything is set up correctly, the script should start and display a training progress bar.
On Windows, you might encounter the following error when running the training script:
Error with pycolmap:
...
num\_cameras = struct.unpack('L', f.read(8))\[0]
This error is caused by mismatched struct unpacking logic in the Windows version. As of this writing, the fix has not yet been merged into the official pycolmap repository. For details, see the related pull request: https://github.com/rmbrualla/pycolmap/pull/2
To work around the issue, uninstall the original package and install a patched version from a community fork:
pip uninstall pycolmap -y
pip install git+https://github.com/mathijshenquet/pycolmap
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
gsplat supports a variety of input formats using the data processing mechanisms provided by Nerfstudio. This tutorial uses a set of individually captured images as input.
Data capture practices may vary depending on the scene type. Outdoor environments, indoor spaces, human subjects, and small objects each benefit from different techniques. However, the following general guidelines apply in most scenarios and help improve the quality of 3D Gaussian Splatting results.
Use consistent, soft lighting
Illuminate the scene with even, diffuse light to reduce shadows and reflections. Avoid harsh directional light, which can create noise and degrade reconstruction quality.
Capture high-quality still images
Still photos typically produce better results than video frames due to reduced motion blur and more stable exposure. If using video, record at a high frame rate (at least 60 FPS) under steady lighting.
Maintain sufficient image overlap
Each image should overlap with adjacent views by about 20 to 30 percent. Overlap is essential for feature matching in Structure-from-Motion (SfM). Video often provides this overlap automatically.
Ensure parallax by moving the camera
Change the camera’s physical position between shots. Avoid rotating in place without translation, as this limits geometric information and may cause pose estimation to fail.
Keep camera settings fixed
Use manual focus and fixed focal length to keep camera intrinsics consistent. Disable zoom, autofocus, and auto exposure.
Prevent motion blur and distortion
Use a tripod or stabilizer. Avoid low-light conditions that require long exposures. Check that images are sharp and properly focused.
Include texture-rich surfaces
Scenes should have enough texture, edges, or detail to enable reliable feature detection. Flat, uniform, or glossy surfaces may reduce SfM effectiveness.
Keep the scene static
Do not allow movement during capture. Objects, people, or lighting changes can interfere with pose estimation.
Choose an appropriate image resolution
Higher resolutions improve detail but increase memory usage and training time. Choose a resolution that balances quality and performance.
Capture enough views
For small objects or scenes, 100 to 250 well-aligned images is a good starting point. Larger or full 360-degree models require more coverage. Make sure areas like the underside of objects are not missed.
Use multi-camera rigs when helpful
A multi-camera setup can speed up capture by recording multiple views at once. This is useful for dynamic scenes or time-limited sessions.
This tutorial uses 84 input images at 3000 × 2000 resolutioncaptured with a Canon M200 camera mounted on a tripod. The plush toy was placed on a chair covered with two stapled 50 × 70 cm sheets of white paper, forming a curved background. An extra sheet underneath allowed for easy rotation of the object during capture, while the camera remained fixed for each donut-shaped sweep.
Photos were taken indoors using only ambient light. Shadows and background elements are visible. This was intentional to simulate real-world conditions and show that good results are still possible without ideal lighting or studio setups. Lighting was uneven and no per-image post-processing was performed. This demonstrates how tools like SuperSplat can help correct brightness and color after training. The goal is to encourage hands-on learning, even with imperfect data.
Note: You can achieve similar results using a modern smartphone, as long as the lighting is adequate and the camera is held steadily.
Note: The plush toy is personally owned and is used here strictly for technical demonstration.
Selected input images used for 3D reconstruction.
Capture setup showing the plush toy, tripod-mounted camera, and curved paper background on a chair (left); live preview of the object on the camera screen during capture (right).
The plush toy was chosen to demonstrate one of the key strengths of 3D Gaussian Splatting: its ability to capture soft, detailed surfaces. Traditional mesh-based pipelines often struggle with materials like fur, resulting in unrealistic or incomplete geometry. In contrast, representing the scene as a set of 3D Gaussians helps preserve fine textures and subtle variations more effectively.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
COLMAP processes the input images to estimate camera intrinsics and extrinsics. It also generates a sparse point cloud, which serves as the geometric foundation for training a 3D Gaussian Splatting model.
In this tutorial, COLMAP is run directly from the command line to provide full control over feature extraction, matching, and triangulation. This approach allows you to inspect intermediate results and troubleshoot issues more easily.
The Nerfstudio CLI includes a wrapper for COLMAP through ns-process-data, but it uses default parameters defined in the pipeline’s codebase. These defaults work in many cases but often fail on real-world scenes that require parameter tuning.
For example, when the sample dataset was processed using the default wrapper, COLMAP registered only 2 images out of 84:
Starting with 84 images
Colmap matched 2 images
COLMAP only found poses for 2.38% of the images. This is low.
This can be caused by a variety of reasons, such as poor scene coverage,
blurry images, or large exposure changes.
Nerfstudio recommends increasing image overlap or improving capture quality. While these are valid suggestions, in many cases you can still get usable results by adjusting COLMAP parameters directly.
The following sections walk through the exact command-line steps used to produce a successful reconstruction for this dataset.
The COLMAP workflow includes three major stages:
Although these operations can be performed using the COLMAP GUI, the command-line interface is preferred in this tutorial for two reasons:
Below is an example of the dataset structure expected by COLMAP and gsplat:
<dataset_root>/
├── images/
│ ├── image_0001.jpg
│ ├── image_0002.jpg
│ └── ...
├── images_2/
│ ├── image_0001.jpg
│ └── ...
├── images_4/
│ ├── image_0001.jpg
│ └── ...
├── sparse/ # COLMAP sparse reconstruction outputs
│ └── 0/ # Default subfolder for the reconstructed scene
│ ├── cameras.bin
│ ├── images.bin
│ ├── points3D.bin
│ └── project.ini
└── colmap.db # COLMAP-generated database
image_0001.jpg are for illustration only. Consistent and sequential names are recommended for clarity, but there are no strict naming requirements.images_2 and images_4 contain 2× and 4× downsampled versions of the original images. These are used with --data_factor 2 or --data_factor 4 during training. Additional folders (such as images_8/) can be added as needed.sparse/0/ contains the output from COLMAP’s sparse reconstruction. If COLMAP produces more than one disconnected model from the input images, it creates additional subfolders such as sparse/1, sparse/2, and so on.colmap.db is the database generated during feature extraction and matching. It stores keypoints, matches, and camera intrinsics.A sample dataset that follows this structure is included in the repository: datasets/plush-dog. It can be used for testing or as a reference when preparing your own scenes.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
First, define the required environment variables and create the output folder:
set COLMAP_PATH=<Path to installed colmap.bat>
set DATA_PATH=<Path to dataset folder, e.g., plush-dog>
set IMAGE_PATH=%DATA_PATH%\images
set DB_PATH=%DATA_PATH%\colmap.db
set SPARSE_PATH=%DATA_PATH%\sparse
mkdir %SPARSE_PATH%
Use the following command to extract SIFT features from the input images:
%COLMAP_PATH% feature_extractor ^
--database_path %DB_PATH% ^
--image_path %IMAGE_PATH% ^
--ImageReader.single_camera 1 ^
--ImageReader.camera_model PINHOLE ^
--SiftExtraction.use_gpu 1
This command extracts SIFT features from the input images and stores them in the specified COLMAP database.
Parameter reference:
--database_path: Path to the SQLite file database where features will be stored--image_path: Path to the folder containing the input images--ImageReader.single_camera 1: Assumes all images are from a single camera--ImageReader.camera_model PINHOLE: Uses the pinhole camera model--SiftExtraction.use_gpu 1: Enables GPU acceleration for feature extractionSample output:
==============================================================================
Feature extraction
==============================================================================
Creating SIFT GPU feature extractor
Processed file [1/84]
Name: IMG_3496.jpg
Dimensions: 3000 x 2000
Camera: #1 - PINHOLE
Focal Length: 5515.70px (Prior)
Features: 2400
Processed file [2/84]
Name: IMG_3497.jpg
Dimensions: 3000 x 2000
Camera: #1 - PINHOLE
Focal Length: 5515.70px (Prior)
Features: 2416
...
After extracting features, run the exhaustive matcher to find correspondences between image pairs:
%COLMAP_PATH% exhaustive_matcher ^
--database_path %DB_PATH% ^
--SiftMatching.use_gpu 1
This command performs pairwise feature matching between all image pairs using default settings.
Parameter reference:
--database_path: Path to the COLMAP database with extracted features--SiftMatching.use_gpu 1: Enables GPU acceleration for matchingThe exhaustive matcher compares features between every possible image pair. It is best suited for small to medium-sized datasets (up to a few hundred images). For larger datasets, it becomes computationally expensive because the number of pairs grows quadratically.
COLMAP also supports other matching strategies that are better for large-scale datasets, including sequential, spatial, and vocab tree matching. See the COLMAP documentation for more details.
Sample output:
==============================================================================
Feature matching
==============================================================================
Creating SIFT GPU feature matcher
Generating exhaustive image pairs...
Matching block [1/2, 1/2]
...
Elapsed time: 0.044 [minutes]
After matching, run the COLMAP mapper to estimate camera poses and build a sparse 3D reconstruction:
%COLMAP_PATH% mapper ^
--database_path %DB_PATH% ^
--image_path %IMAGE_PATH% ^
--output_path %SPARSE_PATH%
Parameter reference:
--database_path: Path to the COLMAP database with features and matches--image_path: Path to the folder with input images--output_path: Path to save the reconstructed models. Each result will be stored in a numbered subfolder (for example, sparse/0)In some cases, including the example dataset in this tutorial, COLMAP may not succeed with the default settings. Feature matching might complete, but the reconstruction can fail during the incremental mapping stage.
A sample failure log looks like this:
Loading database
Loading cameras...
1 in 0.000s
Loading matches...
214 in 0.001s
Loading images...
84 in 0.008s (connected 84)
Loading pose priors...
0 in 0.000s
Building correspondence graph...
in 0.005s (ignored 0)
Elapsed time: 0.000 [minutes]
Finding good initial image pair
Initializing with image pair #57 and #83
Global bundle adjustment
Registering image #56 (3)
=> Image sees 52 / 299 points
Retriangulation and Global bundle adjustment
Registering image #84 (4)
=> Image sees 68 / 257 points
...
Registering image #43 (21)
=> Image sees 30 / 144 points
=> Could not register, trying another image.
Retriangulation and Global bundle adjustment
Finding good initial image pair
=> No good initial image pair found.
Finding good initial image pair
=> No good initial image pair found.
The repeated message "No good initial image pair found" indicates that COLMAP could not identify a geometrically valid pair of images to start the reconstruction. This can occur during initialization of the first 3D model or when attempting to begin a new model after failing to register additional images.
These failures are typically caused by weak, sparse, or unevenly distributed feature matches across the dataset. To improve initialization, try adjusting feature extraction and matching parameters to increase the quality of initial correspondences.
If tuning parameters is not sufficient, consider capturing more overlapping images or experimenting with alternative reconstruction tools.
The next section, Run COLMAP with Adjusted Parameters, demonstrates how to modify key settings to improve reconstruction results.
A sample batch script with all the commands used in this section is available at: scripts/run_colmap_default.bat
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
This section shows how adjusting COLMAP parameters can improve reconstruction results. The steps for setting paths and creating output folders are the same as in Run COLMAP with Default Parameters and are not repeated here.
The feature extraction command remains unchanged from the default configuration. It uses GPU acceleration and assumes a single pinhole camera model:
%COLMAP_PATH% feature_extractor ^
--database_path %DB_PATH% ^
--image_path %IMAGE_PATH% ^
--ImageReader.single_camera 1 ^
--ImageReader.camera_model PINHOLE ^
--SiftExtraction.use_gpu 1
This command should produce output similar to the default run, confirming that SIFT features were successfully extracted from each image.
Let me know if you prefer a more concise or more technical phrasing.
Use the following command to perform feature matching with modified settings:
%COLMAP_PATH% exhaustive_matcher ^
--database_path %DB_PATH% ^
--SiftMatching.use_gpu 1 ^
--SiftMatching.guided_matching 1
Compared to the default configuration, this version adds --SiftMatching.guided_matching 1, which enables guided matching. Guided matching applies geometric constraints based on two-view geometry to filter candidate correspondences. This helps reduce outlier matches and improves robustness, especially in scenes with weak textures or limited image overlap.
Sample output:
==============================================================================
Feature matching
==============================================================================
Creating SIFT GPU feature matcher
Generating exhaustive image pairs...
Matching block [1/2, 1/2]
in 1.112s
Matching block [1/2, 2/2]
in 0.435s
Matching block [2/2, 1/2]
in 0.987s
Matching block [2/2, 2/2]
in 0.952s
Elapsed time: 0.059 [minutes]
Loading database
Loading cameras...
1 in 0.001s
Loading matches...
213 in 0.001s
Loading images...
84 in 0.009s (connected 84)
Loading pose priors...
0 in 0.001s
Building correspondence graph...
in 0.009s (ignored 0)
Elapsed time: 0.000 [minutes]
To improve reconstruction robustness, use the following command with adjusted thresholds:
%COLMAP_PATH% mapper ^
--database_path %DB_PATH% ^
--image_path %IMAGE_PATH% ^
--output_path %SPARSE_PATH% ^
--Mapper.init_min_tri_angle 2 ^
--Mapper.init_min_num_inliers 4 ^
--Mapper.abs_pose_min_num_inliers 3 ^
--Mapper.abs_pose_max_error 8
These parameters relax several of COLMAP’s default thresholds:
--Mapper.init_min_tri_angle 2 (default: 16)
Sets the minimum triangulation angle (in degrees). Lower values allow more points but may reduce accuracy.
--Mapper.init_min_num_inliers 4 (default: 100)
Specifies the minimum number of verified matches needed to initialize the model.
--Mapper.abs_pose_min_num_inliers 3 (default: 30)
Sets the minimum number of 2D–3D correspondences required to register a new image.
--Mapper.abs_pose_max_error 8 (default: 12)
Increases the acceptable reprojection error (in pixels) during registration.
These settings can help reconstruct scenes where default thresholds are too strict. For the sample dataset in this tutorial, these adjustments allowed successful reconstruction. You may need different values for other datasets, depending on image quality and scene structure.
Note: These parameters were chosen specifically for the sample dataset used in this tutorial. They are not intended as general-purpose defaults. You may need to adjust the values based on your scene, image quality, and reconstruction goals.
If successful, COLMAP will show incremental image registration:
Finding good initial image pair
Initializing with image pair #20 and #39
Global bundle adjustment
Registering image #19 (3)
=> Image sees 110 / 618 points
Retriangulation and Global bundle adjustment
Registering image #1 (4)
=> Image sees 167 / 689 points
...
There should be no messages such as:
=> No good initial image pair found.
Additionally, the %SPARSE_PATH% folder (typically sparse/) should contain only one subfolder, usually named 0.
If multiple subfolders appear (such as 1 or 2), it means COLMAP reconstructed disconnected 3D scenes. This typically indicates that not all images were successfully registered into a single model.
After reconstruction completes, you can inspect the result in the COLMAP graphical interface:
%SPARSE_PATH%\0 folder (typically sparse/0).COLMAP will display the sparse point cloud and camera positions.
To improve visibility:
The status bar at the bottom should show a message like:
84 Images - 5863 Points
This means all 84 images were successfully registered, resulting in a sparse reconstruction with 5,863 3D points.
Figure 6. COLMAP GUI displaying the sparse point cloud and camera poses.
You can automate the entire COLMAP pipeline with a batch file. A sample .bat script containing all the commands described above is available at:
scripts/run_colmap_adjusted.bat
Before running the script, make sure to update the paths to match your local setup.
The reference COLMAP output, including the sparse point cloud and estimated camera poses, is available in the sample dataset repository: datasets/plush-dog.
Note: The parameters used in this tutorial were selected to produce reliable results for the sample dataset. They are not optimized for performance or accuracy and are not intended as general-purpose defaults. For other datasets, you may need to adjust the values based on your reconstruction goals, such as speed, completeness, or visual quality. Finding the right configuration often requires several iterations.
Advanced users can also bypass COLMAP’s internal feature extraction and matching by injecting custom features or correspondences directly into the COLMAP database. This allows you to integrate learned feature pipelines or third-party tools while still using COLMAP for mapping.
In some cases, collecting a more complete or higher-quality dataset is more effective than adjusting reconstruction parameters. However, this is not always possible. For example:
In such cases, parameter tuning becomes essential to compensate for limitations in the input data.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
To train the 3D Gaussian Splatting model, run the following commands:
conda activate gsplat
cd <GSPLAT_REPOSITORY_FOLDER>\examples
python simple_trainer.py default ^
--eval_steps -1 ^
--disable_viewer ^
--data_factor 4 ^
--save_ply ^
--ply_steps 30000 ^
--data_dir <DATA_PATH> ^
--result_dir <OUTPUT_PATH>
Replace <GSPLAT_REPOSITORY_FOLDER> with the path to your cloned gsplat repository.
Also update <DATA_PATH> and <OUTPUT_PATH> with the correct paths on your local system.
default: Uses the default configuration profile in simple_trainer.py--eval_steps -1: Disables evaluation during training--disable_viewer: Disables the built-in Nerfstudio viewer--data_factor 4: Downsamples input images by a factor of 4--save_ply: Enables saving the output model in PLY format--ply_steps 30000: Saves the .ply file at training step 30,000--data_dir: Path to the dataset directory (same as used in COLMAP)--result_dir: Output folder for training resultsIf training starts successfully, you will see a progress bar. Upon completion, the output will include a message like:
Step: 29999 {'mem': 0.2915501594543457, 'ellipse_time': 708.7276656627655, 'num_GS': 167459}
Saving ply to <OUTPUT_PATH>/ply/point_cloud_29999.ply
In the example above, training took approximately 12 minutes on the system described in the tested setup. The resulting model contains 167,459 Gaussians. The final .ply file is saved at:
<OUTPUT_PATH>\ply\point_cloud_29999.ply
You can download the model trained on the sample dataset (without any post-processing or artifact removal) from the repository: results/plush-dog/ply/point_cloud_29999.ply
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
To visualize the trained model using gsplat’s built-in viewer, run the following command:
python simple_viewer.py --ckpt <OUTPUT_PATH>\ckpts\ckpt_29999_rank0.pt --port 8081
This launches a local web server and displays a link like the following:
╭──────────────── viser ────────────────╮
│ ╷ │
│ HTTP │ http://localhost:8081 │
│ Websocket │ ws://localhost:8081 │
│ ╵ │
╰───────────────────────────────────────╯
Open the displayed link (for example, http://localhost:8081) in your web browser.
The viewer renders the trained Gaussian Splatting model. Floating artifacts often appear around the main object. The next section, Edit a 3D Gaussian Splatting Model in SuperSplat, shows how to clean and post-process the model for better visualization or downstream use.
Floating artifacts in the Gaussian Splatting model, rendered in the gsplat viewer. These artifacts typically surround the scene before cleanup.
The reconstructed plush toy appears at the center of the same scene when viewed up close.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
After training and exporting the .ply file, you can open the model in SuperSplat Editor for visual inspection and manual refinement.
Common editing tasks include:
For a complete list of tools and options, see the SuperSplat documentation.
.ply file (for example, point_cloud_29999.ply) onto the canvas
Model loaded in SuperSplat Editor.
The model will appear as a dense cluster of Gaussians, typically surrounded by floating artifacts.
Documentation for editing tools is available in the SuperSplat Editing Guide.
The following workflow shows a common sequence for model cleanup. You can adjust it based on your dataset and editing preferences.
Removing outer Gaussians using sphere selection and inversion.
Use the Brush, Lasso, or Polygon tools to clean up remaining floating points around the object.
These tools are useful for fine-tuning areas around edges or details of the object
Cleaning additional areas using brush selection.
Picker tool and Splat View Mode enabled for final cleanup.
Once editing is complete:
.ply file.ply file that reduces file size without sacrificing qualityThe exported model can be used for:
Final cleaned model after artifact removal in SuperSplat Editor.
Reference versions from the sample dataset are available in the repository:
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
The following suggestions can help improve reconstruction quality and workflow efficiency:
--data_factor values (for example, 4) during testing to reduce memory and speed up training. For best quality, train final models on high-resolution inputs.This tutorial’s dataset was captured mostly from dome-like camera angles, covering only the upper hemisphere of the object. As a result, the bottom of the model appears incomplete when viewed from below.
Model view from below, showing sparse Gaussians and an incomplete surface.
For many use cases, such as turntable demos or frontal visualizations, this coverage is sufficient.
However, for fully enclosed 3D models, you should capture additional images from lower angles.
If the object is rigid, consider placing it on its side to photograph the underside. Make sure there is sufficient overlap with other views to maintain alignment.
The table below summarizes typical time requirements for each stage in the pipeline:
| Step | Approximate Time |
|---|---|
| Capturing images | 20 minutes |
| Processing images in COLMAP | 1 minute |
| Training a model in gsplat | 12 minutes |
| Editing in SuperSplat | 10 minutes |
Note: COLMAP time reflects only a successful reconstruction run. Parameter tuning and retries can add significant time depending on the dataset.
Note: These answers apply primarily to object- or tabletop-scale capture, as demonstrated in this tutorial. Outdoor scenes or large-scale environments may require different tools, workflows, and parameter settings.
Yes. While this tutorial used an interchangeable-lens camera, modern smartphones can produce similar results if lighting is adequate and images are sharp and stable.
Photos are preferred due to better control over focus and exposure. Video can work if shot at 60 FPS or higher with minimal blur.
For small objects, 100–250 images is usually enough. Full 360° coverage may require more.
Try to avoid them. Use manual focus and a fixed focal length to maintain consistent camera intrinsics for more accurate pose estimation.
Not always. For turntable-style outputs, upper and side coverage may be enough. For full 360° models, also capture the underside.
Yes, ideally. Surfaces with visible patterns, edges, or textures improve feature matching. Flat, shiny, or textureless objects are harder to reconstruct.
Yes, but keep in mind:
Also see COLMAP’s FAQ on weakly textured surfaces.
© 2025 SmartDataScan.
This section is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.