search

lfranke / TRIPS

https://lfranke.github.io/trips/
MIT License
518 stars 31 forks source link

readme

TRIPS: Trilinear Point Splatting for Real-Time Radiance Field Rendering

Linus Franke, Darius Rückert, Laura Fink, Marc Stamminger

Point-based radiance field rendering has demonstrated impressive results for novel view synthesis, offering a compelling blend of rendering quality and computational efficiency. However, also latest approaches in this domain are not without their shortcomings. 3D Gaussian Splatting [Kerbl and Kopanas et al. 2023] struggles when tasked with rendering highly detailed scenes, due to blurring and cloudy artifacts. On the other hand, ADOP [Rückert et al. 2022] can accommodate crisper images, but the neural reconstruction network decreases performance, it grapples with temporal instability and it is unable to effectively address large gaps in the point cloud. In this paper, we present TRIPS (Trilinear Point Splatting), an approach that combines ideas from both Gaussian Splatting and ADOP. The fundamental concept behind our novel technique involves rasterizing points into a screen-space image pyramid, with the selection of the pyramid layer determined by the projected point size. This approach allows rendering arbitrarily large points using a single trilinear write. A lightweight neural network is then used to reconstruct a hole-free image including detail beyond splat resolution. Importantly, our render pipeline is entirely differentiable, allowing for automatic optimization of both point sizes and positions. Our evaluation demonstrate that TRIPS surpasses existing state-of-the-art methods in terms of rendering quality while maintaining a real-time frame rate of 60 frames per second on readily available hardware. This performance extends to challenging scenarios, such as scenes featuring intricate geometry, expansive landscapes, and auto-exposed footage.

[Project Page] [Paper] [Youtube] [Supplemental Data]

Citation

@article{franke2024trips,
    title={TRIPS: Trilinear Point Splatting for Real-Time Radiance Field Rendering},
    author={Linus Franke and Darius R{\"u}ckert and Laura Fink and Marc Stamminger},
    year = {2024},
    journal = {Computer Graphics Forum},
    volume = {43},
    number = {2},
    doi = {https://doi.org/10.1111/cgf.15012}
}

Install Requirements

Supported Operating Systems: Ubuntu 22.04, Windows

Nvidia GPU (lowest we tested was an RTX2070)

Supported Compiler: g++-9 (Linux), MSVC (Windows, we used 19.31.31105.0)

Software Requirement: Conda (Anaconda/Miniconda)

Install Instructions Linux

Install Ubuntu Dependancies

sudo apt install git build-essential gcc-9 g++-9

For the viewer, also install:

sudo apt install xorg-dev

(There exists a headless mode without window management meant for training on a cluster, see below)

Clone Repo

git clone git@github.com:lfranke/TRIPS.git
cd TRIPS/
git submodule update --init --recursive --jobs 0

Create Conda Environment

cd TRIPS
./create_environment.sh

Install Pytorch

cd TRIPS
./install_pytorch_precompiled.sh

Install CuDNN

Either download the latest version and add it to the conda environment (where CUDA 11.8 was installed, this article is a useful resource) or install via conda:

conda activate trips
conda install -y -c conda-forge cudnn=8.9.2

For our experiments, we used CuDNN 8.9.5, however the conda installed version (8.9.2) should also work fine.

Compile TRIPS

cd TRIPS

conda activate trips

export CONDA=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
export CC=gcc-9
export CXX=g++-9
export CUDAHOSTCXX=g++-9

unset CUDA_HOME

mkdir build
cd build

cmake -DCMAKE_PREFIX_PATH="./External/libtorch/;${CONDA}" ..

make -j10

make can take a long time, especially for some CUDA files.

If you get a undefined reference to ...@GLIBCXX_3.4.30' error during linking, most likely your linker fails to resolve the global and conda version of the c++ standard library.

Consider removing the libstdc++ lib from the conda environment:

cd TRIPS

conda activate trips

export CONDA=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}

rm $CONDA/lib/libstdc++.so*

Install Instructions Windows

Software Requirements

Install CuDNN

Download the latest version and add it to the CUDA 11.8 installation (this article is a useful resource).

We used CuDNN 8.9.7, however similar versions should also work fine.

Clone Repo

git clone git@github.com:lfranke/TRIPS.git
cd TRIPS/
git submodule update --init --recursive --jobs 8

Setup Environment

conda update -n base -c defaults conda

conda create -y -n trips python=3.9.7

conda activate trips

conda install -y cmake=3.26.4
conda install -y -c intel mkl=2024.0.0
conda install -y -c intel mkl-static=2024.0.0
conda install openmp=8.0.1 -c conda-forge

Install libtorch

Folder structure should look like:

TRIPS/
    External/
        libtorch/
            bin/
            cmake/
            include/
            lib/
            ...
        saiga/
        ...
    src/
    ...

Compile TRIPS

Configure (if you use the conda prompt shell):

cmake -Bbuild -DCMAKE_CUDA_COMPILER="%CUDA_PATH%\bin\nvcc.exe" -DCMAKE_PREFIX_PATH=".\External\libtorch" -DCONDA_P_PATH="%CONDA_PREFIX%" -DCUDA_P_PATH="%CUDA_PATH%" -DCMAKE_BUILD_TYPE=RelWithDebInfo .

OR: Configure (if you use the conda powershell):

cmake -Bbuild -DCMAKE_CUDA_COMPILER="$ENV:CUDA_PATH\bin\nvcc.exe" -DCMAKE_PREFIX_PATH=".\External\libtorch" -DCONDA_P_PATH="$ENV:CONDA_PREFIX" -DCUDA_P_PATH="$ENV:CUDA_PATH" -DCMAKE_BUILD_TYPE=RelWithDebInfo .

Compile (both shells):

cmake --build build --config RelWithDebInfo -j

The last cmake build call can take a lot of time.

Install Instructions Docker

Thanks to user abecadel for providing these Docker instructions.

Install Docker

Make sure to have docker installed with gpu support enables

Clone Repo

git clone git@github.com:lfranke/TRIPS.git
cd TRIPS/
git submodule update --init --recursive --jobs 0

Build docker image

docker build -t trips .

Running training

docker run -v {data_path}:/data -it trips /bin/bash
./train --config configs/train_normalnet.ini

Running viewer (Linux only)

First enable X forwarding from docker

sudo xhost +local:docker

Now you can run the viewer

docker run --device /dev/dri/ -v `pwd`/tt_scenes/:/scenes --rm -it --gpus all --net=host --env DISPLAY=$DISPLAY trips viewer --scene_dir /scenes/tnt_scenes/tt_train

Running on pretrained models

Supplemental materials link: https://zenodo.org/records/10664666

After a successful compilation, the best way to get started is to run viewer on the tanks and temples scenes using our pretrained models. First, download the scenes (tt_scenes.zip) and extract them into scenes/. Now, download the model checkpoints (tt_checkpoints.zip) and extract them into experiments/. Your folder structure should look like this:

TRIPS/
    build/
        ...
    experiments/
        checkpoint_train
        checkpoint_playground
        ...
    scenes/
        tt_train/
        tt_playground/
        ...
    ...

The supplemental data also includes data for the boat (checkpoint and scene combined in one zip), mipnerf360 scenes (in the resolutions used in the paper) and mipnerf360 checkpoints.

Viewer

Your working directory should be the trips root directory.

Linux

Start the viewer with

conda activate trips
export CONDA=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA/lib
./build/bin/viewer --scene_dir scenes/tt_train

(note that tt_train is the scene name of the Tanks&Temples locomotive scene)

Windows

./build/bin/RelWithDebInfo/viewer.exe  --scene_dir scenes/tt_train

(depending on the used shell, the full path C:\....\TRIPS\build\bin\... may have to be used)

The path is different to the Linux path, the compile configuration is added (RelWithDebInfo)!

(note that tt_train is the scene name of the Tanks&Temples locomotive scene)

Viewer Controls

The most important keyboard shortcuts are:

By default, TRIPS is compiled with a reduced GUI. If you want all GUI buttons present, you can add a -DMINIMAL_GUI=OFF to the first cmake call to compile this in.

Scene Description

Training

The pipeline is fitted to your scenes by the train executable. All training parameters are stored in a separate config file. The basic syntax is:

Linux:

conda activate trips
export CONDA=${CONDA_PREFIX:-"$(dirname $(which conda))/../"}
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA/lib

./build/bin/train --config configs/train_normalnet.ini

Windows:

./build/bin/RelWithDebInfo/train.exe --config configs/train_normalnet.ini

(depending on the shell, the full path C:\....\TRIPS\build\bin\... may have to be used)

Make again sure that the working directory is the root. Otherwise, the loss models will not be found.

Two configs are given for the two networks used in the paper: train_normalnet.ini and train_sphericalnet.ini You can override the options in these configs easily via the command line.

./build/bin/train --config configs/train_normalnet.ini --TrainParams.scene_names tt_train --TrainParams.name new_name_for_this_training

(note that tt_train is the scene name of the Tanks&Temples locomotive scene)

For scenes with extensive environments, consider adding an environment map with:

--PipelineParams.enable_environment_map true

If GPU memory is sparse, consider lowering batch_size (standard is 4), inner_batch_size (standard is 4) or train_crop_size (standard is 512) with for example,

--TrainParams.batch_size 1
--TrainParams.inner_batch_size 2
--TrainParams.train_crop_size 256

(however this may impact quality).

By default, every 8th image is removed during training and used as a test image. If you want to change this split, consider overriding which percentage of images should be kept out of training with:

--TrainParams.train_factor 0.1

default is 0.125 (so 1/8).

Live Viewer during Training

An experimental live viewer is implemented which shows the fitting process during training in an OpenGL window. If headless mode is not required (see below) you can add a -DLIVE_TRAIN_VIEWER=ON to the first cmake call to compile this version in.

Note: This will have an impact on training speed, as intermediate (full) images will we rendered during training.

Headless Mode

If you do not want the viewer application, consider calling cmake with an additional -DHEADLESS=ON. This is usually done for training on remote machines.

Troubleshooting