Bernhard Kerbl*, Georgios Kopanas*, Thomas Leimkühler, George Drettakis (* indica contribuição igual)
| Página da Web | Artigo Completo | Vídeo | Outras Publicações GRAPHDECO | Página do projeto FUNGRAPH |
| T&T+DB COLMAP (650MB) | Modelos pré-treinados (14 GB) | Visualizadores para Windows (60MB) | Imagens de avaliação (7 GB) |
Este repositório contém a implementação oficial dos autores associada ao artigo "3D Gaussian Splatting for Real-Time Radiance Field Rendering", que pode ser encontrado aqui. Fornecemos ainda as imagens de referência usadas para criar as métricas de erro relatadas no artigo, bem como modelos pré-treinados recentemente criados.
Resumo: Os métodos Radiance Field revolucionaram recentemente a síntese de cenas capturadas com múltiplas fotos ou vídeos. No entanto, alcançar alta qualidade visual ainda requer redes neurais que são caras para treinar e renderizar, enquanto métodos recentes mais rápidos inevitavelmente trocam velocidade por qualidade. Para cenas completas e ilimitadas (em vez de objetos isolados) e renderização com resolução de 1080p, nenhum método atual pode atingir taxas de exibição em tempo real. Introduzimos três elementos-chave que nos permitem alcançar qualidade visual de última geração, mantendo tempos de treinamento competitivos e, o que é mais importante, permitem a síntese de visualizações inovadoras de alta qualidade em tempo real (≥ 30 fps) com resolução de 1080p. Primeiro, partindo de pontos esparsos produzidos durante a calibração da câmera, representamos a cena com Gaussianos 3D que preservam propriedades desejáveis de campos de radiação volumétrica contínua para otimização da cena, evitando cálculos desnecessários no espaço vazio; Em segundo lugar, realizamos otimização/controle de densidade intercalado dos Gaussianos 3D, otimizando notavelmente a covariância anisotrópica para obter uma representação precisa da cena; Terceiro, desenvolvemos um algoritmo de renderização rápido e com reconhecimento de visibilidade que suporta respingos anisotrópicos e acelera o treinamento e permite a renderização em tempo real. Demonstramos qualidade visual de última geração e renderização em tempo real em vários conjuntos de dados estabelecidos.
@Article{kerbl3Dgaussians,
author = {Kerbl, Bernhard and Kopanas, Georgios and Leimk{"u}hler, Thomas and Drettakis, George},
title = {3D Gaussian Splatting for Real-Time Radiance Field Rendering},
journal = {ACM Transactions on Graphics},
number = {4},
volume = {42},
month = {July},
year = {2023},
url = {https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/}
}Esta pesquisa foi financiada pela bolsa ERC Advanced FUNGRAPH No 788065. Os autores agradecem à Adobe pelas generosas doações, à infraestrutura OPAL da Université Côte d'Azur e aos recursos de HPC da GENCI – IDRIS (Grant 2022-AD011013409). Os autores agradecem aos revisores anônimos por seus valiosos comentários, a P. Hedman e A. Tewari pela revisão dos rascunhos anteriores e também a T. Müller, A. Yu e S. Fridovich-Keil por ajudarem nas comparações.
Temos recursos limitados para manter e atualizar o código. No entanto, adicionamos alguns novos recursos desde o lançamento original que são inspirados em alguns dos excelentes trabalhos que muitos outros pesquisadores têm feito em 3DGS. Estaremos adicionando outros recursos dentro da capacidade de nossos recursos.
Atualização de outubro de 2024 : Integramos a aceleração da velocidade de treinamento e a tornamos compatível com regularização de profundidade, anti-aliasing e compensação de exposição. Aprimoramos o visualizador em tempo real do SIBR corrigindo bugs e adicionando recursos no Top View que permitem a visualização das câmeras de entrada e do usuário.
Atualização da primavera de 2024 : Orange Labs gentilmente adicionou suporte OpenXR para visualização VR.
Jonathan Stephens fez um fantástico tutorial passo a passo para configurar o Gaussian Splatting em sua máquina, junto com instruções para criar conjuntos de dados utilizáveis a partir de vídeos. Se as instruções abaixo forem muito secas para você, vá em frente e confira aqui.
O usuário camenduru teve a gentileza de fornecer um modelo Colab que usa a fonte deste repositório (status: agosto de 2023!) para acesso rápido e fácil ao método. Por favor, confira aqui.
O repositório contém submódulos, portanto, verifique-o com
# SSHgit clone [email protected]:graphdeco-inria/gaussian-splatting.git --recursive
ou
# Clone HTTPSgit https://github.com/graphdeco-inria/gaussian-splatting --recursive
A base de código possui 4 componentes principais:
Um otimizador baseado em PyTorch para produzir um modelo gaussiano 3D a partir de entradas SfM
Um visualizador de rede que permite conectar e visualizar o processo de otimização
Um visualizador em tempo real baseado em OpenGL para renderizar modelos treinados em tempo real.
Um script para ajudá-lo a transformar suas próprias imagens em conjuntos de dados SfM prontos para otimização
Os componentes têm requisitos diferentes em relação ao hardware e ao software. Eles foram testados no Windows 10 e Ubuntu Linux 22.04. As instruções para configurar e executar cada um deles são encontradas nas seções abaixo.
O otimizador usa extensões PyTorch e CUDA em um ambiente Python para produzir modelos treinados.
GPU pronta para CUDA com capacidade de computação 7.0+
24 GB VRAM (para treinar a qualidade da avaliação em papel)
Consulte as perguntas frequentes para configurações de VRAM menores
Conda (recomendado para fácil configuração)
Compilador C++ para extensões PyTorch (usamos Visual Studio 2019 para Windows)
CUDA SDK 11 para extensões PyTorch, instale após o Visual Studio (usamos 11.8, problemas conhecidos com 11.6 )
O compilador C++ e o SDK CUDA devem ser compatíveis
Nosso método de instalação padrão fornecido é baseado no pacote Conda e no gerenciamento de ambiente:
SET DISTUTILS_USE_SDK = 1 # Somente Windowsconda env create --file ambiente.yml conda ativar gaussian_splatting
Observe que este processo pressupõe que você tenha o CUDA SDK 11 instalado, não o 12 . Para modificações, veja abaixo.
Dica: Baixar pacotes e criar um novo ambiente com Conda pode exigir uma quantidade significativa de espaço em disco. Por padrão, o Conda usará o disco rígido principal do sistema. Você pode evitar isso especificando um local de download de pacote diferente e um ambiente em uma unidade diferente:
conda config --add pkgs_dirs/ conda env create --file ambiente.yml --prefix / /gaussian_splatting conda ativar / /gaussian_splatting
Se você puder pagar pelo espaço em disco, recomendamos usar nossos arquivos de ambiente para configurar um ambiente de treinamento idêntico ao nosso. Se você quiser fazer modificações, observe que alterações importantes na versão podem afetar os resultados do nosso método. No entanto, nossos experimentos (limitados) sugerem que a base de código funciona bem em um ambiente mais atualizado (Python 3.8, PyTorch 2.0.0, CUDA 12). Certifique-se de criar um ambiente onde o PyTorch e sua versão de tempo de execução CUDA correspondam e o CUDA SDK instalado não tenha grande diferença de versão com a versão CUDA do PyTorch.
Alguns usuários enfrentam problemas ao criar submódulos no Windows ( cl.exe: File not found ou semelhante). Considere a solução alternativa para esse problema nas Perguntas frequentes.
Para executar o otimizador, basta usar
python train.py -s
Caminho para o diretório de origem que contém um conjunto de dados COLMAP ou Synthetic NeRF.
Caminho onde o modelo treinado deve ser armazenado ( output/ por padrão).
Subdiretório alternativo para imagens COLMAP ( images por padrão).
Adicione este sinalizador para usar uma divisão de treinamento/teste estilo MipNeRF360 para avaliação.
Especifica a resolução das imagens carregadas antes do treino. Se fornecido 1, 2, 4 ou 8 , usa resolução original, 1/2, 1/4 ou 1/8, respectivamente. Para todos os outros valores, redimensiona a largura para o número fornecido, mantendo o aspecto da imagem. Se não for definido e a largura da imagem de entrada exceder 1,6K pixels, as entradas serão automaticamente redimensionadas para esse destino.
Especifica onde colocar os dados da imagem de origem, cuda por padrão, recomendado para usar cpu se o treinamento em conjunto de dados grande/alta resolução reduzirá o consumo de VRAM, mas retardará um pouco o treinamento. Obrigado a HrsPythonix.
Adicione este sinalizador para usar fundo branco em vez de preto (padrão), por exemplo, para avaliação do conjunto de dados NeRF Synthetic.
Ordem dos harmônicos esféricos a serem usados (não maior que 3). 3 por padrão.
Sinalizador para fazer o pipeline calcular para frente e para trás de SHs com PyTorch em vez do nosso.
Sinalizador para fazer o pipeline calcular para frente e para trás a covariância 3D com PyTorch em vez da nossa.
Ativa o modo de depuração se você encontrar erros. Se o rasterizador falhar, será criado um arquivo dump que você poderá nos encaminhar em caso de problema para que possamos dar uma olhada.
A depuração é lenta . Você pode especificar uma iteração (começando em 0) após a qual a depuração acima se torna ativa.
Número total de iterações para treinar, 30_000 por padrão.
IP para iniciar o servidor GUI, 127.0.0.1 por padrão.
Porta a ser usada para servidor GUI, 6009 por padrão.
Iterações separadas por espaço nas quais o script de treinamento calcula L1 e PSNR no conjunto de teste, 7000 30000 por padrão.
Iterações separadas por espaço nas quais o script de treinamento salva o modelo gaussiano, 7000 30000 por padrão.
Iterações separadas por espaço nas quais armazenar um ponto de verificação para continuar mais tarde, salvas no diretório do modelo.
Caminho para um ponto de verificação salvo para continuar o treinamento.
Sinalizador para omitir qualquer texto escrito no tubo de saída padrão.
Os harmônicos esféricos apresentam taxa de aprendizagem, 0.0025 por padrão.
Taxa de aprendizado de opacidade, 0.05 por padrão.
Escalando a taxa de aprendizagem, 0.005 por padrão.
Taxa de aprendizado de rotação, 0.001 por padrão.
Número de etapas (de 0) em que a taxa de aprendizagem da posição vai do initial ao final . 30_000 por padrão.
Taxa inicial de aprendizagem da posição 3D, 0.00016 por padrão.
Taxa final de aprendizagem da posição 3D, 0.0000016 por padrão.
Multiplicador de taxa de aprendizagem de posição (cf. Plenoxels), 0.01 por padrão.
Iteração onde começa a densificação, 500 por padrão.
Iteração onde a densificação para, 15_000 por padrão.
Limite que decide se os pontos devem ser densificados com base no gradiente de posição 2D, 0.0002 por padrão.
Frequência de densificação, 100 (a cada 100 iterações) por padrão.
Com que frequência redefinir a opacidade, 3_000 por padrão.
Influência do SSIM na perda total de 0 a 1, 0.2 por padrão.
Porcentagem da extensão da cena (0--1) que um ponto deve exceder para ser densificado à força, 0.01 por padrão.
Observe que, semelhante ao MipNeRF360, direcionamos imagens em resoluções na faixa de 1 a 1,6K pixels. Por conveniência, entradas de tamanho arbitrário podem ser passadas e serão redimensionadas automaticamente se sua largura exceder 1600 pixels. Recomendamos manter esse comportamento, mas você pode forçar o treinamento a usar imagens de resolução mais alta configurando -r 1 .
As cenas do MipNeRF360 são hospedadas pelos autores do artigo aqui. Você pode encontrar nossos conjuntos de dados SfM para Tanks&Temples e Deep Blending aqui. Se você não fornecer um diretório de modelo de saída ( -m ), os modelos treinados serão gravados em pastas com nomes exclusivos aleatórios dentro do diretório output . Neste ponto, os modelos treinados podem ser visualizados com o visualizador em tempo real (veja mais abaixo).
Por padrão, os modelos treinados usam todas as imagens disponíveis no conjunto de dados. Para treiná-los enquanto retém um conjunto de testes para avaliação, use o sinalizador --eval . Dessa forma, você pode renderizar conjuntos de treinamento/teste e produzir métricas de erro da seguinte maneira:
python train.py -s--eval # Treine com trem/teste splitpython render.py -m # Gere renderingspython métricas.py -m # Calcular métricas de erro nas renderizações
Se quiser avaliar nossos modelos pré-treinados, você terá que baixar os conjuntos de dados de origem correspondentes e indicar sua localização para render.py com um sinalizador --source_path/-s adicional. Nota: Os modelos pré-treinados foram criados com a base de código de lançamento. Esta base de código foi limpa e inclui correções de bugs, portanto, as métricas obtidas ao avaliá-los serão diferentes daquelas do artigo.
python render.py -m-s pythonmetrics.py -m
Caminho para o diretório do modelo treinado para o qual você deseja criar renderizações.
Sinalizador para ignorar a renderização do conjunto de treinamento.
Sinalizador para ignorar a renderização do conjunto de testes.
Sinalizador para omitir qualquer texto escrito no tubo de saída padrão.
Os parâmetros abaixo serão lidos automaticamente do caminho do modelo, com base no que foi utilizado para o treinamento. No entanto, você pode substituí-los fornecendo-os explicitamente na linha de comando.
Caminho para o diretório de origem que contém um conjunto de dados COLMAP ou Synthetic NeRF.
Subdiretório alternativo para imagens COLMAP ( images por padrão).
Adicione este sinalizador para usar uma divisão de treinamento/teste estilo MipNeRF360 para avaliação.
Altera a resolução das imagens carregadas antes do treino. Se fornecido 1, 2, 4 ou 8 , usa resolução original, 1/2, 1/4 ou 1/8, respectivamente. Para todos os outros valores, redimensiona a largura para o número fornecido, mantendo o aspecto da imagem. 1 por padrão.
Adicione este sinalizador para usar fundo branco em vez de preto (padrão), por exemplo, para avaliação do conjunto de dados NeRF Synthetic.
Sinalizador para fazer a renderização do pipeline com SHs computados do PyTorch em vez dos nossos.
Sinalizador para fazer a renderização do pipeline com covariância 3D calculada do PyTorch em vez da nossa.
Lista separada por espaços de caminhos de modelo para os quais as métricas devem ser calculadas.
Fornecemos ainda o script full_eval.py . Este script especifica a rotina usada em nossa avaliação e demonstra o uso de alguns parâmetros adicionais, por exemplo, --images (-i) para definir diretórios de imagens alternativos dentro dos conjuntos de dados COLMAP. Se você baixou e extraiu todos os dados de treinamento, poderá executá-lo assim:
python full_eval.py -m360-tat -db
Na versão atual, esse processo leva cerca de 7h em nossa máquina de referência contendo um A6000. Se quiser fazer a avaliação completa de nossos modelos pré-treinados, você pode especificar o local de download e pular o treinamento.
python full_eval.py -o--skip_training -m360 -tat -db
Se quiser calcular as métricas nas imagens de avaliação do nosso artigo, você também pode pular a renderização. Neste caso não é necessário fornecer os conjuntos de dados de origem. Você pode calcular métricas para vários conjuntos de imagens ao mesmo tempo.
python full_eval.py -m/garden ... --skip_training --skip_rendering
Fornecemos dois visualizadores interativos para nosso método: remoto e em tempo real. Nossas soluções de visualização são baseadas na estrutura SIBR, desenvolvida pelo grupo GRAPHDECO para diversos projetos de síntese de novas visualizações.
GPU e drivers prontos para OpenGL 4.5 (ou software MESA mais recente)
4 GB de VRAM recomendado
GPU pronta para CUDA com capacidade de computação 7.0+ (somente para Real-Time Viewer)
Visual Studio ou g++, não Clang (usamos Visual Studio 2019 para Windows)
CUDA SDK 11, instale após o Visual Studio (usamos 11.8)
CMake (versão recente, usamos 3.24)
7zip (somente no Windows)
Fornecemos binários pré-construídos para Windows aqui. Recomendamos utilizá-los no Windows para uma configuração eficiente, pois a construção do SIBR envolve diversas dependências externas que devem ser baixadas e compiladas instantaneamente.
Se você clonou com submódulos (por exemplo, usando --recursive ), o código fonte dos visualizadores é encontrado em SIBR_viewers . O visualizador de rede é executado na estrutura SIBR para aplicativos de renderização baseados em imagens.
CMake deve cuidar de suas dependências.
CD SIBR_viewers cmake -Bbuild .cmake --build build --target install --config RelWithDebInfo
Você pode especificar uma configuração diferente, por exemplo, Debug se precisar de mais controle durante o desenvolvimento.
Você precisará instalar algumas dependências antes de executar a configuração do projeto.
# Dependenciessudo apt install -y libglew-dev libassimp-dev libboost-all-dev libgtk-3-dev libopencv-dev libglfw3-dev libavdevice-dev libavcodec-dev libeigen3-dev libxxf86vm-dev libembree-dev# Configuração do projetocd SIBR_viewers cmake -Bbuild. -DCMAKE_BUILD_TYPE=Lançamento # add -G Ninja para construir mais rápidocmake --build build -j24 --target install
A compatibilidade com versões anteriores do Focal Fossa não foi totalmente testada, mas a construção do SIBR com o CMake ainda deve funcionar após a invocação
git checkout fossa_compatibilidade
A interface SIBR fornece vários métodos de navegação na cena. Por padrão, você iniciará com um navegador FPS, que pode controlar com W, A, S, D, Q, E para translação da câmera e I, K, J, L, U, O para rotação. Como alternativa, você pode usar um navegador estilo Trackball (selecione no menu flutuante). Você também pode ajustar para uma câmera a partir do conjunto de dados com o botão Snap to ou encontrar a câmera mais próxima com Snap to closest . Os menus flutuantes também permitem alterar a velocidade de navegação. Você pode usar o Scaling Modifier para controlar o tamanho das gaussianas exibidas ou mostrar a nuvem de pontos inicial.
Depois de extrair ou instalar os visualizadores, você pode executar o aplicativo SIBR_remoteGaussian_app[_config] compilado em
.//bin/SIBR_remoteGaussian_app
O visualizador de rede permite que você se conecte a um processo de treinamento em execução na mesma máquina ou em uma máquina diferente. Se você estiver treinando na mesma máquina e sistema operacional, nenhum parâmetro de linha de comando deverá ser necessário: o otimizador comunica a localização dos dados de treinamento ao visualizador de rede. Por padrão, o otimizador e o visualizador de rede tentarão estabelecer uma conexão no host local na porta 6009 . Você pode alterar esse comportamento fornecendo parâmetros --ip e --port correspondentes ao otimizador e ao visualizador de rede. Se por algum motivo o caminho usado pelo otimizador para encontrar os dados de treinamento não for acessível pelo visualizador da rede (por exemplo, devido à execução deles em máquinas (virtuais) diferentes), você poderá especificar um local de substituição para o visualizador usando -s .
Argumento para substituir o caminho do modelo para o conjunto de dados de origem.
IP a ser usado para conexão a um script de treinamento em execução.
Porta a ser usada para conexão com um script de treinamento em execução.
São necessários dois números separados por espaço para definir a resolução na qual ocorre a renderização da rede, largura 1200 por padrão. Observe que para impor um aspecto diferente das imagens de entrada, você também precisa --force-aspect-ratio .
Sinalizador para carregar imagens do conjunto de dados de origem a serem exibidas na visualização superior de cada câmera.
Depois de extrair ou instalar os visualizadores, você pode executar o aplicativo SIBR_gaussianViewer_app[_config] compilado em
.//bin/SIBR_gaussianViewer_app -m
Deve ser suficiente fornecer o parâmetro -m apontando para um diretório de modelo treinado. Alternativamente, você pode especificar um local de substituição para dados de entrada de treinamento usando -s . Para usar uma resolução específica diferente da escolhida automaticamente, especifique --rendering-size . Combine-o com --force-aspect-ratio se desejar a resolução exata e não se importar com a distorção da imagem.
Para desbloquear a taxa de quadros total, desative o V-Sync em sua máquina e também no aplicativo (Menu → Display). Em um sistema multi-GPU (por exemplo, laptop), sua GPU OpenGL/Display deve ser igual à sua GPU CUDA (por exemplo, definindo a preferência de GPU do aplicativo no Windows, veja abaixo) para desempenho máximo. Além da nuvem de pontos inicial e dos splats, você também tem a opção de visualizar as gaussianas renderizando-as como elipsóides no menu flutuante. O SIBR possui muitas outras funcionalidades, consulte a documentação para mais detalhes sobre o visualizador, opções de navegação etc. Há também um Top View (disponível no menu) que mostra o posicionamento das câmeras de entrada e a nuvem de pontos SfM original; observe que o Top View retarda a renderização quando ativado. O visualizador em tempo real também usa seleção rápida e um pouco mais agressiva, que pode ser alternada no menu flutuante. Se você encontrar um problema que possa ser resolvido desativando a seleção rápida, informe-nos.
Nossos carregadores COLMAP esperam a seguinte estrutura de conjunto de dados no local do caminho de origem:
esta cena foi treinada usando 
