Updates

• 01/05/2026 — Update: Added example bounding volumes for Primal Adaptive Meshing and launch scripts for the NeRF Synthetic dataset.
• 07/04/2026 — Code Release: Initial release of the Gaussian Wrapping codebase.

Installation

git clone --recurse-submodules https://github.com/diego1401/GaussianWrapping
cd GaussianWrapping
conda create -n gaussian_wrapping python=3.9 -y
conda activate gaussian_wrapping

# Set CUDA paths (adjust version as needed)
CUDA_VERSION=12.1 # or 11.8 (12.1 is best for 4090RTX)

export CPATH=/usr/local/cuda-${CUDA_VERSION}/targets/x86_64-linux/include:$CPATH
export LD_LIBRARY_PATH=/usr/local/cuda-${CUDA_VERSION}/targets/x86_64-linux/lib:$LD_LIBRARY_PATH
export PATH=/usr/local/cuda-${CUDA_VERSION}/bin:$PATH

python install.py --cuda_version ${CUDA_VERSION}

Training & Mesh Extraction

Gaussian Wrapping expects a COLMAP-formatted dataset (images + sparse reconstruction). Use -s for the dataset root and -m for the output directory.

We provide two end-to-end scripts that run training followed by mesh extraction:

# RaDeGS rasterizer (Best looking meshes! A bit slower to train, script used for qualitative results on Mipnerf360)
python gaussian_wrapping/scripts/train_and_extract_gw_radegs.py \
    -s <PATH_TO_COLMAP_DATASET> \
    -m <OUTPUT_DIR>

# Our median-depth rasterizer (faster, better metrics)
python gaussian_wrapping/scripts/train_and_extract_gw_ours.py \
    -s <PATH_TO_COLMAP_DATASET> \
    -m <OUTPUT_DIR> \
    -r 2 # Flag added to remain comparable to heavier alternatives. This flag was used to obtain the metrics on the paper

Each script runs three steps in sequence: training, mesh extraction, and texture refinement. The refined mesh is saved alongside the extracted mesh with a _texture_refined suffix.

Key options

Primal Adaptive Meshing

An alternative mesh extraction method that samples candidate points from an existing mesh (e.g. extracted by the standard pipeline), refines them onto the Gaussian occupancy isosurface via gradient descent, and reconstructs the surface with a Delaunay-based approach.

python gaussian_wrapping/primal_adaptive_meshing_extraction.py \
    -s <PATH_TO_COLMAP_DATASET> \
    -m <OUTPUT_DIR> \
    --input_mesh <PATH_TO_INPUT_MESH> \
    --output_mesh <PATH_TO_OUTPUT_MESH.ply> \
    --max_points <NUMBER_OF_MESH_VERTICES>

Using the Provided Bounding Volumes

We provide ready-to-use bounding volume files for several scenes in assets/bounding_volumes_examples/. These can be used directly with PAM — no Blender setup required:

To run PAM with one of these bounding volumes:

python gaussian_wrapping/primal_adaptive_meshing_extraction.py \
    -s <PATH_TO_COLMAP_DATASET> \
    -m <OUTPUT_DIR> \
    --input_mesh <PATH_TO_INPUT_MESH> \
    --output_mesh <PATH_TO_OUTPUT_MESH.ply> \
    --bounding_box_method blender \
    --bounding_box_file assets/bounding_volumes_examples/Barn_bounding_volume.json

To create your own bounding volumes for other scenes, see the Blender add-on below.

Blender Bounding Volume Add-on

If you want to extract an object of your scene at abritary resolution easily we propose this blender-add on to easily define the section of the scene to extract.

Installation

Usage

1. Import your input mesh into Blender as a visual reference (e.g. File → Import → Stanford PLY and select the mesh you plan to pass to --input_mesh).

   

2. Create a bounding mesh — add any mesh (e.g. a Cube via Shift+A → Mesh → Cube) and transform (e.g edit mode → move vertices of cube) it so it encloses exactly the region of interest.

   

3. Open the GW Bounds tab in the N-panel:

   • Set Bounding Mesh to the object you just created.
   • Set Export Path to the .json file you want to write.
   • Click Export Bounding Volume.

4. Run the extraction script with:

python gaussian_wrapping/primal_adaptive_meshing_extraction.py \
    -s <PATH_TO_COLMAP_DATASET> \
    -m <OUTPUT_DIR> \
    --input_mesh <PATH_TO_INPUT_MESH> \
    --output_mesh <PATH_TO_OUTPUT_MESH.ply> \
    --bounding_box_method blender \
    --bounding_box_file <PATH_TO_EXPORTED.json>

5. Decimate the output mesh — the extracted mesh tends to be very dense. We recommend decimating it to reduce its size with no perceptible quality loss. This can be done via the script:

blender --background --python gaussian_wrapping/mesh_decimate.py -- \
    --in <PATH_TO_OUTPUT_MESH.ply> \
    --out <PATH_TO_DECIMATED_MESH.ply> \
    --ratio 0.3

Alternatively, you can decimate directly in Blender: import the mesh (File → Import → Stanford PLY), select it, go to the Properties panel → Modifier tab, add a Decimate modifier, set the Ratio (e.g. 0.3), and click Apply. Then export via File → Export → Stanford PLY.

Benchmarks

Tanks and Temples

# Ours rasterizer
python gaussian_wrapping/scripts/benchmark_tnt_gw_ours.py \
    --data_dir <PATH_TO_TNT_SCENES> \
    --gt_dir <PATH_TO_TNT_GT> \
    --output_dir <OUTPUT_DIR>

# RaDeGS rasterizer
python gaussian_wrapping/scripts/benchmark_tnt_gw_radegs.py \
    --data_dir <PATH_TO_TNT_SCENES> \
    --gt_dir <PATH_TO_TNT_GT> \
    --output_dir <OUTPUT_DIR>

python gaussian_wrapping/eval/TNTUniScanEvals/uniform_sampling_eval.py \
    --dataset-dir <path/to/scene_dir> \
    --traj-path <path/to/scene_dir>/<Scene>_COLMAP_SfM.log \
    --ply-path <path/to/mesh.ply> \
    --out-dir <output_dir>

python gaussian_wrapping/eval/TNTUniScanEvals/virtual_scan_sampling_eval.py \
    -s <path/to/colmap_dataset> \
    -r 2 \
    --dataset-dir <path/to/scene_dir> \
    --traj-path <path/to/scene_dir>/<Scene>_COLMAP_SfM.log \
    --ply-path <path/to/mesh.ply> \
    --out-dir <output_dir>

DTU

MipNeRF360

# Ours rasterizer
python gaussian_wrapping/scripts/benchmark_mip360_gw_ours.py \
    --data_dir <PATH_TO_MIP360_SCENES> \
    --output_dir <OUTPUT_DIR>

# RaDeGS rasterizer
python gaussian_wrapping/scripts/benchmark_mip360_gw_radegs.py \
    --data_dir <PATH_TO_MIP360_SCENES> \
    --output_dir <OUTPUT_DIR>

Mesh-Based Novel View Synthesis

NeRF Synthetic

python gaussian_wrapping/scripts/launch_nerf_synthetic.py \
    --data_dir "${DATA_DIR}" \
    --output_dir "${OUTPUT_DIR}" \
    --gpu_device "${GPU_DEVICE}"

Acknowledgements

We build this project based on Gaussian Splatting.

For rasterization and mesh extraction, we modified CUDA kernels from GGGS and SOF.

We also propose to use rasterization techniques from RaDe-GS.

We finally use Nvdiffrast for mesh rasterization.

We thank the authors of all the above projects for their great works!

Citation

@misc{gomez2026blobsspokeshighfidelitysurface,
      title={From Blobs to Spokes: High-Fidelity Surface Reconstruction via Oriented Gaussians}, 
      author={Diego Gomez and Antoine Guédon and Nissim Maruani and Bingchen Gong and Maks Ovsjanikov},
      year={2026},
      eprint={2604.07337},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2604.07337}, 
}