CityGaussian: renderização em tempo real de grandes cenas com alta qualidade usando Gaussianas
(dekuliutesla.github.io)- CityGaussian (CityGS) é um método da ECCV 2024 que estende o 3D Gaussian Splatting (3DGS) para cenas em escala urbana, buscando ao mesmo tempo eficiência de treinamento e qualidade de exploração em tempo real
- A limitação de ser difícil lidar com cenas de grande escala de uma só vez é resolvida ao dividir o problema entre treinamento por divisão e conquista e uma estratégia de nível de detalhe (LoD)
- Usando informações prévias globais da cena e seleção adaptativa de dados de treinamento, os resultados de treinamento por bloco são alinhados com mais eficiência e fundidos de forma suave
- Os Gaussian primitives fundidos são comprimidos para criar múltiplos níveis de detalhe, e na renderização o nível adequado é selecionado e agregado por bloco
- Sem LoD, representar MatrixCity com 25 milhões de Gaussianas fica limitado a 18 FPS em uma A100, mas o CityGS com LoD atinge renderização em tempo real com média de 36 FPS
Estrutura de treinamento e renderização para 3DGS em grande escala
- O 3D Gaussian Splatting (3DGS) mostrou força em reconstrução de cenas 3D em tempo real e síntese de novas visualizações, mas o treinamento de cenas em grande escala e a renderização em tempo real em diferentes escalas ainda têm alto custo
- O CityGaussian trata esse problema em duas etapas
- Treinamento por divisão e conquista: divide cenas de grande escala em blocos para treiná-las com eficiência
- Estratégia LoD: usa apenas o nível de detalhe necessário de acordo com a escala de observação para aumentar a velocidade de renderização
- Informações prévias globais da cena e seleção adaptativa de dados de treinamento aumentam a eficiência do treinamento e ajudam a fundir os fragmentos separados da cena de forma mais natural
- Os Gaussian primitives fundidos passam por um processo de compressão para formar vários níveis de detalhe
- Na etapa de renderização, usa-se uma estratégia de seleção e agregação de nível de detalhe por bloco, permitindo geração rápida de imagem em múltiplas escalas
Desempenho e materiais públicos
- Sem aplicar LoD, a cena MatrixCity é representada por 25 milhões de Gaussianas e mede 18 FPS em uma A100
- Essa velocidade é considerada insuficiente para oferecer uma experiência de navegação confortável
- O CityGS com LoD aplicado permite renderização em tempo real mesmo em escalas muito diferentes, com média de 36 FPS em uma A100
- Em experimentos com cenas de grande escala, o CityGS mostra qualidade de renderização de nível state-of-the-art e oferece renderização em tempo real consistente em cenas grandes com várias escalas
- Materiais públicos
1 comentários
Opiniões do Hacker News
Pelo nome do dataset do vídeo ser Matrix city, é bem provável que tenha sido extraído da demo Matrix do Unreal Engine 5, divulgada alguns anos atrás
Os pontos de vista são muito parecidos, então há um realismo fotográfico, mas não parece ter vindo de fotos reais
Pesquisando mais, era isso mesmo: https://city-super.github.io/matrixcity/
Curiosamente, nesse caso o post original estaria reconstruindo de novo algo que já era uma reconstrução de objetos reais
O mapa MatrixCity é diferente, mas é até certo ponto parecido com o mapa de Matrix Awakens. Isso também pode ser visto na análise de design desta página [3], escrita pelo tech lead do projeto Matrix Awakens
Indo mais fundo, na seção MatrixPlugin da codebase no GitHub [4], está explicitado que foi usado o projeto city-sample
[1] https://www.unrealengine.com/marketplace/en-US/product/city-...
[2] https://www.unrealengine.com/marketplace/en-US/learn/city-sa...
[3] https://quentinmarmier.artstation.com/projects/xYeKNO
[4] https://github.com/city-super/MatrixCity
Por isso, o treinamento de NeRF ou Gaussian splatting fica um pouco mais fácil, já que não há erro de otimização da pose da câmera
É pelo mesmo motivo que os primeiros artigos de NeRF usavam a famosa escavadeira Lego amarela renderizada no Blender
Para uma cena como Matrix city, não parece necessário gastar muito tempo treinando para reproduzir os dados
No fim de semana, combinei uma malha de tiles 3D do Google Maps com Gaussian splats; não é exatamente a mesma coisa, mas o efeito ficou bem parecido e útil
Exemplo 1 com código linkado: https://twitter.com/kfarr/status/1773934700878561396
Exemplo 2: https://twitter.com/3dstreetapp/status/1775203540442697782
No primeiro link, aparece um erro no DevTools
Uncaught (in promise) Error: Failed to fetch resource [https://tile.googleapis.com/v1/3dti](<https://tile.googleapis.com/v1/3dti>;)...Pretendo dar uma olhada no aframe-loader-3dtiles-component
“A velocidade média é de 36 FPS (testado em uma A100)”; então parece significar que é em tempo real se você tiver uma GPU de US$ 8 mil
Quando um artigo de computação gráfica diz que atingiu velocidade em tempo real, sempre é preciso verificar de novo se é realmente tempo real ou se é “640x480 a 20 fps no hardware mais caro que o dinheiro pode comprar”
Se baixar o padrão o suficiente, qualquer coisa pode ser tempo real
Pode acabar sendo útil em casos como produção virtual, mas não parece algo para mobile
https://www.techpowerup.com/forums/attachments/all-cards-png...
Se quiser algo que rode até em um notebook de 10 anos, ou mesmo sem GPU, veja https://github.com/pierotofy/OpenSplat. Fui eu que fiz
Então não parece um problema intransponível
Alguém consegue me convencer de que 3D Gaussian Splatting não é um beco sem saída?
A renderização é lenta demais por um fator de um dígito, e os dados também são grandes demais por um fator de um dígito. Dá a sensação de ver de novo o embate entre rasterização e ray tracing.
A rasterização sempre será mais rápida que o ray tracing, e, se o ray tracing ficar 10 vezes mais rápido, a rasterização também ficará 10 vezes mais rápida.
Gerar geometria e materiais tradicionais a partir de uma nuvem de pontos gaussianos pode ser interessante. Mas a fotogrametria já existe há bastante tempo.
Tentar renderizar uma cidade gigantesca em splats em tempo real não parece “a direção certa”.
É legal, divertido e interessante, mas não tenho certeza se vai se tornar realmente útil. Não sou especialista, então estou perguntando a sério.
A maior parte das pesquisas atuais não foca em desempenho, e ainda nem há consenso sobre um formato unificado, incluindo compressão.
As possibilidades de otimização são muito claras, e também é fácil ajustar para vários dispositivos. É parecido com LOD em nuvens de pontos ou culling de malhas.
O desempenho de splats pode virar uma vantagem competitiva temporária de um visualizador, mas, assim como a descompressão de vídeo ou outros padrões 3D se disseminaram como open source, é provável que, em poucos anos, visualizar splats em alta qualidade e alta taxa de quadros na maioria dos dispositivos se torne um requisito básico.
A próxima pergunta é onde usar isso.
Mais de 100 fps no navegador: https://current-exhibition.com/laboratorio31/
900 fps: https://m-niemeyer.github.io/radsplat/
Os motores tradicionais têm 30 anos de pesquisa e desenvolvimento acumulados, então vai levar tempo para as ferramentas e otimizações alcançarem esse nível.
Mas, olhando de onde vêm os artigos, há muitos da Apple e da Meta, e parece uma tecnologia para impulsionar a era do metaverso/computação espacial que as duas empresas estão promovendo.
A capacidade de levar conteúdo de custo de produção muito baixo, como vídeos de iPhone, para ambientes 3D vai deslocar muita pesquisa e desenvolvimento dos métodos tradicionais.
Também é muito difícil capturar detalhes finos, como estruturas delgadas ou cabelos. 3DGS é forte nessas áreas.
Também há pesquisas em andamento para melhorar as fraquezas atuais, incluindo métodos de extração de malhas que possam ser usados em pipelines gráficos tradicionais.
A fotogrametria só funciona bem quando os dados de superfície são limpos, mas Gaussian splats são fortes em dados semivolumétricos, como pelos, vegetação, partículas e superfícies rugosas.
Também se adaptam bem a superfícies brilhantes/refletivas, volumes com fortes propriedades de superfícies subdivididas e materiais com grande dependência do ponto de vista.
Para um uso equivalente a uma fotografia 3D completa, é bem legal e um caso de uso bastante justificado.
Para motores de jogos 3D, acho difícil manipular dinamicamente os primitivos básicos da forma que um motor de jogo exige. As tentativas vão continuar, mas, desse ponto de vista, os gaussianos parecem mais um formato final de renderização do que uma representação intermediária útil.
Para uso prático em engines, algo mais precisa ser inventado para preencher esse intervalo, e ainda há muitas perguntas em aberto.
Não sei quanto a outros usos, mas o mundo não é feito só de jogos 3D e efeitos visuais.
Há tantas coisas com o nome de Gauss, e, vendo que continuam surgindo novas como Gaussian splatting, é curioso perceber de novo quanto Gauss influenciou muitas áreas.
Ele não inventou isso diretamente, mas contribuiu muito para a matemática por trás.
https://en.wikipedia.org/wiki/Monte_Carlo_(disambiguation)
Só a seção “Science and Technology” já tem 8 itens.
Estou curioso para ver com qual licença isso será lançado.
Quero ver um jogo open source usando isso.
Há muitos casos na história que pareciam promissores como alternativa a malhas triangulares e depois desapareceram ao se perceber que não havia uma forma eficiente de animá-los.
Os objetos dentro da nuvem de pontos não têm metadados inerentes como “cadeira, mesa, pessoa”, então qualquer interação fica muito difícil.
Não é impossível, mas hoje não é prático.
Além disso, nem é tão otimizado para renderização em tempo real. Mesmo que muitos pontos tenham sido podados, usar uma malha de baixa resolução é muito mais eficiente.
Isso não parece muito melhor do que algo como Cities: Skylines.
Não há zoom in nem zoom out, e sempre mostram apenas quadros muito limitados. Será que estou deixando passar alguma coisa?
O artigo cita repetidamente MatrixCity, e https://city-super.github.io/matrixcity/, que outra pessoa encontrou acima, também afirma ser dados totalmente sintéticos.
Pelo que entendi, foi extraído da Unreal Engine.
Estou aprendendo com pygame e fico curioso sobre como colocar motion blur em um jogo
Por exemplo, ao fazer Mario com pygame, eu gostaria que ele parecesse borrado quando pulasse
Eu poderia criar uma versão borrada do Mario fazendo a média de 9 pixels, mas não sei se outros jogos costumam fazer isso assim
Muitos jogos também são bem nítidos, sem motion blur, então fico curioso se isso é usado de fato
No cinema, é um elemento bem importante, e também me vem à cabeça que, para obter motion blur cinematográfico, é preciso filmar a 25 fps
Ou seja, calcular a velocidade de cada objeto, renderizá-la como cor e depois usá-la na etapa de pós-processamento para definir a intensidade e a direção do efeito de blur
Talvez seja necessário o movimento em relação à câmera. No caso do Mario, provavelmente não, mas em um FPS você vai querer que as bordas da tela fiquem borradas quando a câmera se move para a frente
Material relacionado: https://city-super.github.io/octree-gs/
É uma abordagem bastante avançada para renderizar cenas maiores com 3D Gaussians, então quero testar rapidamente assim que o código sair