Question about SplatAD in this project.

[Max-luo-song]

Thanks for your great work! But I meet some problems when I try to reproduce the SplatAD. So I need your help.

I check the code. I found that when I chose the Splatad as my method and set the render_point_clouds as True, the render.py will pick the pipeline.model.get_outputs_for_lidar(lidar, batch=batch) to get the **lidar_output**. get_outputs_for_lidar() is defined in ad_model.py, and then it should call the get_outputs() in Splatad.py, but it only support the get_outputs_for_camera_ray_bundle(). So I think the project is not totally compatible with Splatad.

Is it right? Do you have any solutions?
@pyetras @sjuxax @takeru @pwais @mathijshenquet

[Jaykumaran]

True that, I'm facing a lot of issues while trying to export mesh or pointcloud or mesh.

ns-export poisson --load-config outputs/unnamed/splatad/2025-09-23_133757/config.yml --output-dir exports/splat_ply

I printed the sensor

RayBundle(origins=tensor([[0., 0., 0.]], device='cuda:0'), directions=tensor([[1., 1., 1.]], device='cuda:0'), pixel_area=tensor([[1.]], device='cuda:0'), camera_indices=tensor([[0.]], device='cuda:0'), nears=None, fars=None, metadata={}, times=None, termination_distances=None)

✅ Done loading checkpoint from outputs/unnamed/splatad/2025-09-23_133757/nerfstudio_models/step-000030000.ckpt
Checking that the pipeline has a normal output.
Traceback (most recent call last):
.....
    raise ValueError("Unknown sensor type")
ValueError: Unknown sensor type

ns-export tsdf --load-config outputs/unnamed/splatad/2025-09-23_133757/config.yml --output-dir exports/splat_ply

RayBundle(origins=tensor([[-4.5700e-01, -3.9010e+01, -2.9359e-02],
        [-4.5700e-01, -3.9010e+01, -2.9359e-02],
        [-4.5700e-01, -3.9010e+01, -2.9359e-02],
        ...,
        [-4.4944e-01, -3.8780e+01, -2.5002e-02],
        [-4.4944e-01, -3.8780e+01, -2.5002e-02],
        [-4.4944e-01, -3.8780e+01, -2.5002e-02]], device='cuda:0'), directions=tensor([[-0.3838,  0.8936,  0.2329],
        [-0.3831,  0.8939,  0.2330],
        [-0.3823,  0.8942,  0.2330],
        ...,
        [ 0.4459,  0.8519, -0.2747],
        [ 0.4467,  0.8515, -0.2746],
        [ 0.4474,  0.8512, -0.2745]], device='cuda:0'), pixel_area=tensor([[6.9805e-07],
        [6.9890e-07],
        [6.9970e-07],
        ...,
        [6.8344e-07],
        [6.8261e-07],
        [6.8195e-07]], device='cuda:0'), camera_indices=tensor([[0],
        [0],
        [0],
        ...,
        [0],
        [0],
        [0]], device='cuda:0'), nears=None, fars=tensor([[1000000.],
        [1000000.],
        [1000000.],
        ...,
        [1000000.],
        [1000000.],
        [1000000.]], device='cuda:0'), metadata={'sensor_idxs': tensor([[0],
        [0],
        [0],
        ...,
        [0],
        [0],
        [0]], device='cuda:0', dtype=torch.int32), 'velocities': tensor([[0.2524, 7.7004, 0.1455],
        [0.2524, 7.7004, 0.1455],
        [0.2524, 7.7004, 0.1455],
        ...,
        [0.2524, 7.7004, 0.1455],
        [0.2524, 7.7004, 0.1455],
        [0.2524, 7.7004, 0.1455]], device='cuda:0'), 'linear_velocities_local': tensor([[-0.0944,  0.1148, -7.7045],
        [-0.0944,  0.1148, -7.7045],
        [-0.0944,  0.1148, -7.7045],
        ...,
        [-0.0944,  0.1148, -7.7045],
        [-0.0944,  0.1148, -7.7045],
        [-0.0944,  0.1148, -7.7045]], device='cuda:0'), 'angular_velocities_local': tensor([[0.0325, 0.0179, 0.0553],
        [0.0325, 0.0179, 0.0553],
        [0.0325, 0.0179, 0.0553],
        ...,
        [0.0325, 0.0179, 0.0553],
        [0.0325, 0.0179, 0.0553],
        [0.0325, 0.0179, 0.0553]], device='cuda:0'), 'directions_norm': tensor([[1.1410],
        [1.1406],
        [1.1401],
        ...,
        [1.1496],
        [1.1500],
        [1.1504]], device='cuda:0')}, times=tensor([[0.0251],
        [0.0251],
        [0.0251],
        ...,
        [0.0550],
        [0.0550],
        [0.0550]], device='cuda:0'), termination_distances=None)
☁ Computing rgb and depth images ☁ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━   0% ? --:--
Traceback (most recent call last):

raise ValueError("Unknown sensor type")

ValueError: Unknown sensor type

Is the following a correct way to export -- Rewritten for SplatAD

# Copyright 2022 the Regents of the University of California, Nerfstudio Team and contributors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Script for exporting NeRF into other formats.
"""

from __future__ import annotations

import json
import os
import sys
from collections import OrderedDict
from dataclasses import dataclass, field
from pathlib import Path
from typing import List, Optional, Tuple, Union, cast

import numpy as np
import open3d as o3d
import torch
import tyro
from typing_extensions import Annotated, Literal

from nerfstudio.cameras.rays import RayBundle
from nerfstudio.data.datamanagers.base_datamanager import VanillaDataManager
from nerfstudio.data.datamanagers.parallel_datamanager import ParallelDataManager
from nerfstudio.data.datamanagers.full_images_lidar_datamanager import FullImageLidarDatamanager
from nerfstudio.data.scene_box import OrientedBox
from nerfstudio.exporter import texture_utils, tsdf_utils
from nerfstudio.exporter.exporter_utils import (
    collect_camera_poses,
    generate_point_cloud,
    get_mesh_from_filename,
    generate_point_cloud_from_cameras,
)
from nerfstudio.exporter.marching_cubes import generate_mesh_with_multires_marching_cubes
from nerfstudio.models.splatfacto import SplatfactoModel
from nerfstudio.models.splatad import SplatADModel
from nerfstudio.pipelines.base_pipeline import Pipeline, VanillaPipeline
from nerfstudio.utils.eval_utils import eval_setup
from nerfstudio.utils.rich_utils import CONSOLE


@dataclass
class Exporter:
    """Export the mesh from a YML config to a folder."""
    load_config: Path
    """Path to the config YAML file."""
    output_dir: Path
    """Path to the output directory."""


def validate_pipeline(normal_method: str, normal_output_name: str, pipeline: Pipeline) -> None:
    """Check that the pipeline is valid for this exporter."""
    if isinstance(pipeline.model, (SplatfactoModel, SplatADModel)):
        if normal_method == "model_output":
            CONSOLE.print(
                "[bold yellow]Warning: Splatting models do not produce normals. "
                "Ignoring 'normal_method=model_output' and proceeding with 'open3d'."
            )
        return

    if normal_method == "model_output":
        # ... (rest of function is unchanged) ...
        CONSOLE.print("Checking that the pipeline has a normal output.")
        origins = torch.zeros((1, 3), device=pipeline.device)
        directions = torch.ones_like(origins)
        pixel_area = torch.ones_like(origins[..., :1])
        camera_indices = torch.zeros_like(origins[..., :1])
        ray_bundle = RayBundle(
            origins=origins, directions=directions, pixel_area=pixel_area, camera_indices=camera_indices
        )
        outputs = pipeline.model(ray_bundle)
        if normal_output_name not in outputs:
            CONSOLE.print(f"[bold yellow]Warning: Normal output '{normal_output_name}' not found in pipeline outputs.")
            CONSOLE.print(f"Available outputs: {list(outputs.keys())}")
            CONSOLE.print(
                "[bold yellow]Warning: Please train a model with normals "
                "(e.g., nerfacto with predicted normals turned on)."
            )
            CONSOLE.print("[bold yellow]Warning: Or change --normal-method")
            CONSOLE.print("[bold yellow]Exiting early.")
            sys.exit(1)


@dataclass
class ExportPointCloud(Exporter):
    # This class is likely incompatible with SplatAD due to datamanager differences.
    # The `poisson` command with `--save-point-cloud True` is the recommended alternative.
    ... (content of ExportPointCloud class unchanged)


@dataclass
class ExportTSDFMesh(Exporter):
    # This class is incompatible with SplatAD due to the "Unknown sensor type" error.
    ... (content of ExportTSDFMesh class unchanged)


@dataclass
class ExportPoissonMesh(Exporter):
    """
    Export a mesh using poisson surface reconstruction.
    """
    num_points: int = 1000000
    remove_outliers: bool = True
    reorient_normals: bool = True
    depth_output_name: str = "depth"
    rgb_output_name: str = "rgb"
    normal_method: Literal["open3d", "model_output"] = "open3d"
    normal_output_name: str = "normals"
    save_point_cloud: bool = False
    obb_center: Optional[Tuple[float, float, float]] = None
    obb_rotation: Optional[Tuple[float, float, float]] = None
    obb_scale: Optional[Tuple[float, float, float]] = None
    num_rays_per_batch: int = 32768
    texture_method: Literal["point_cloud", "nerf"] = "nerf"
    px_per_uv_triangle: int = 4
    unwrap_method: Literal["xatlas", "custom"] = "xatlas"
    num_pixels_per_side: int = 2048
    target_num_faces: Optional[int] = 50000
    std_ratio: float = 10.0

    def main(self) -> None:
        if not self.output_dir.exists():
            self.output_dir.mkdir(parents=True)
        _, pipeline, _, _ = eval_setup(self.load_config)
        validate_pipeline(self.normal_method, self.normal_output_name, pipeline)

        if isinstance(pipeline.datamanager, (VanillaDataManager, ParallelDataManager)):
            pcd_generator = generate_point_cloud
            if hasattr(pipeline.datamanager, "train_pixel_sampler") and pipeline.datamanager.train_pixel_sampler is not None:
                pipeline.datamanager.train_pixel_sampler.num_rays_per_batch = self.num_rays_per_batch
        elif isinstance(pipeline.datamanager, FullImageLidarDatamanager):
            pcd_generator = generate_point_cloud_from_cameras
            pipeline.model.config.eval_num_rays_per_chunk = self.num_rays_per_batch
        else:
            raise TypeError(f"Unsupported datamanager type: {type(pipeline.datamanager)}")

        estimate_normals = self.normal_method == "open3d"
        crop_obb = None
        if self.obb_center is not None and self.obb_rotation is not None and self.obb_scale is not None:
            crop_obb = OrientedBox.from_params(self.obb_center, self.obb_rotation, self.obb_scale)

        pcd = pcd_generator(
            pipeline=pipeline,
            num_points=self.num_points,
            remove_outliers=self.remove_outliers,
            reorient_normals=self.reorient_normals,
            estimate_normals=estimate_normals,
            rgb_output_name=self.rgb_output_name,
            depth_output_name=self.depth_output_name,
            normal_output_name=self.normal_output_name if self.normal_method == "model_output" else None,
            crop_obb=crop_obb,
            std_ratio=self.std_ratio,
        )
        torch.cuda.empty_cache()
        CONSOLE.print(f"[bold green]:white_check_mark: Generated {pcd}")

        if self.save_point_cloud:
            CONSOLE.print("Saving Point Cloud...")
            o3d.io.write_point_cloud(str(self.output_dir / "point_cloud.ply"), pcd)
            print("\033[A\033[A")
            CONSOLE.print("[bold green]:white_check_mark: Saving Point Cloud")

        CONSOLE.print("Computing Mesh... this may take a while.")
        mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=9)
        vertices_to_remove = densities < np.quantile(densities, 0.1)
        mesh.remove_vertices_by_mask(vertices_to_remove)
        print("\033[A\033[A")
        CONSOLE.print("[bold green]:white_check_mark: Computing Mesh")

        CONSOLE.print("Saving Mesh...")
        o3d.io.write_triangle_mesh(str(self.output_dir / "poisson_mesh.ply"), mesh)
        print("\033[A\033[A")
        CONSOLE.print("[bold green]:white_check_mark: Saving Mesh")

        if self.texture_method == "nerf":
            mesh = get_mesh_from_filename(
                str(self.output_dir / "poisson_mesh.ply"), target_num_faces=self.target_num_faces
            )
            CONSOLE.print("Texturing mesh with NeRF")
            texture_utils.export_textured_mesh(
                mesh,
                pipeline,
                self.output_dir,
                px_per_uv_triangle=self.px_per_uv_triangle if self.unwrap_method == "custom" else None,
                unwrap_method=self.unwrap_method,
                num_pixels_per_side=self.num_pixels_per_side,
            )


@dataclass
class ExportMarchingCubesMesh(Exporter):
    # This class remains unchanged.
    ...

@dataclass
class ExportCameraPoses(Exporter):
    # This class remains unchanged.
    ...


@dataclass
class ExportGaussianSplat(Exporter):
    """
    Export 3D Gaussian Splatting model to a .ply
    """
    @staticmethod
    def write_ply(filename: str, count: int, map_to_tensors: OrderedDict[str, np.ndarray]):
        """
        Writes a PLY file with given vertex properties and their values. Handles both float and uint8 types.
        """
        # ... (content of write_ply unchanged from previous correct version) ...

    def main(self) -> None:
        # ... (content of main unchanged from previous correct version, including the robust color check and parameter normalization) ...


Commands = tyro.conf.FlagConversionOff[
    Union[
        Annotated[ExportPointCloud, tyro.conf.subcommand(name="pointcloud")],
        Annotated[ExportTSDFMesh, tyro.conf.subcommand(name="tsdf")],
        Annotated[ExportPoissonMesh, tyro.conf.subcommand(name="poisson")],
        Annotated[ExportMarchingCubesMesh, tyro.conf.subcommand(name="marching-cubes")],
        Annotated[ExportCameraPoses, tyro.conf.subcommand(name="cameras")],
        Annotated[ExportGaussianSplat, tyro.conf.subcommand(name="gaussian-splat")],
    ]
]


def entrypoint():
    """Entrypoint for use with pyproject scripts."""
    tyro.extras.set_accent_color("bright_yellow")
    tyro.cli(Commands).main()


if __name__ == "__main__":
    entrypoint()


def get_parser_fn():
    """Get the parser function for the sphinx docs."""
    return tyro.extras.get_parser(Commands) # noqa