renderização gráfico usando a aceleração 3D

https://stackoverflow.com/questions/219872

03-07-2019
|

Pergunta

Nós gerar gráficos para enormes conjuntos de dados. Estamos a falar de 4096 amostras por segundo, e 10 minutos por gráfico. Um simples cálculo torna para 4096 * 60 * 10 = 2457600 amostras por linegraph. Cada amostra é um duplo (8 bytes) FP precisão. Além disso, prestamos vários linegraphs em uma tela, até cerca de uma centena. Isso faz com que prestamos sobre amostras de 25M em uma única tela. Usando o senso comum e truques simples, podemos obter esse código de performance usando o CPU desenho isso em uma tela 2D. Performant, que é o render vezes caem abaixo de um minuto. Como se trata de dados científicos, não podemos omitir quaisquer amostras. Sério, isso não é uma opção. Nem sequer começar a pensar sobre isso.

Naturalmente, queremos melhorar a tornar vezes usando todas as técnicas disponíveis. Multicore, pré-processamento, armazenamento em cache são bastante interessante, mas não cortá-la. Queremos 30FPS renderização com esses conjuntos de dados no mínimo, 60FPS preferido. Agora esta é uma meta ambiciosa.

Uma maneira natural para descarregar renderização de gráficos está usando a GPU do sistema. GPU são feitos para trabalhar com grandes conjuntos de dados e processá-los parrallel. Alguns testes simples do HelloWorld nos mostrou uma diferença de dia e de noite na prestação de velocidade, usando a GPU.

Agora, o problema é: GPU da API, como OpenGL, DirectX e XNA são feitos para 3D cenas em mente. Assim, usando-os para tornar linegraphs 2D é possível, mas não é o ideal. Na prova de conceitos que desenvolvemos, encontramos o que precisamos para transformar o mundo 2D em um mundo 3D. Suddnely temos de trabalhar e XYZ sistema com polígonos, vértices e mais da bondade de coordenadas. Isso está longe de ser ideal a partir de uma perspectiva de desenvolvimento. Código fica ilegível, a manutenção é um pesadelo, e mais problemas ferver.

Qual seria a sua sugestão ou ideia ser a este em 3D? É a única maneira de fazer isso para realmente converter os dois sistemas (2D coordenadas contra coordenadas 3D e entidades)? Ou há uma maneira mais elegante para conseguir isso?

-Por que é usefull para tornar várias amostras de um pixel? Uma vez que representa o conjunto de dados melhor. Digamos que em um pixel, você tem os valores 2, 5 e 8. Devido a alguns amostra omitindo algoritmo, somente a 5 é desenhado. A linha só iria para 5, e não a 8, portanto, os dados são distorcidos. Você pode argumentar o oposto também, mas o fato da questão é que as primeiras contagens de argumento para os conjuntos de dados com que trabalhamos. Esta é exatamente a razão pela qual não podemos amostras omitir.

Solução

Um kit de ferramentas realmente popular para visualização científica é VTK , e eu acho que se adapte às suas necessidades:

É uma API de alto nível, assim você não terá que usar OpenGL (VTK é construído em cima do OpenGL). Existem interfaces para C ++, Python, Java e Tcl. Eu acho que isso iria manter sua base de código muito limpo.
Você pode importar todos os tipos de conjuntos de dados em VTK (há toneladas de exemplos de imagens médicas a dados financeiros).
VTK é muito rápido, e você pode distribuir VTK gráficos gasodutos em várias máquinas, se você quer fazer muito grandes visualizações.
Em relação a:

Isso faz com que prestamos sobre amostras de 25M em uma única tela.

[...]

Como se trata de dados científicos, não podemos omitir quaisquer amostras. Sério, isso não é uma opção. Nem sequer começar a pensar nisso.

Você pode processar grandes conjuntos de dados em VTK por amostragem e usando modelos de LOD. Ou seja, você tem um modelo onde você ver uma versão de baixa resolução de longe, mas se você aumentar o zoom, você veria uma versão de alta resolução. Isto é como um monte de grande prestação conjunto de dados é feito.

Você não precisa eliminar os pontos do conjunto de dados real, mas você pode certamente incrementalmente refiná-lo quando os zooms de usuários no. Ele faz você não é bom para renderizar 25 milhões de pontos para uma única tela quando o usuário não pode possivelmente processar todos esses dados. Eu recomendaria que você dê uma olhada em ambos a biblioteca VTK e o guia de usuário VTK, como há algumas informações de valor inestimável lá em formas de visualizar grandes conjuntos de dados.

Outras dicas

Eu gostaria de comentar sobre sua afirmação de que você não pode omitir amostras, na parte de trás da resposta de tgamblin.

Você deve pensar dos dados que você está desenhando para a tela como um problema de amostragem. Você está falando de 2.4M pontos de dados, e você está tentando tirar isso para uma tela que é apenas alguns milhares de pontos de diâmetro (pelo menos eu supondo que ele é, desde que você está preocupado com 30fps taxas de atualização)

Assim que significa que para cada pixel no eixo x você está renderização na ordem dos 1000 pontos que você não precisa. Mesmo se você percorrer o caminho de utilizar o seu GPU (ex., Através da utilização do OpenGL), que é ainda uma grande quantidade de trabalho que as necessidades GPU para fazer por linhas que não estão indo para ser visível.

Uma técnica que eu usei para apresentar os dados da amostra é gerar um conjunto de dados que é um subconjunto de todo o conjunto, apenas para renderização. Para um dado pixel no eixo x (ou seja, uma determinada tela eixo x coordenadas.), Você precisa prestar absoluta máximo de 4 pontos - que é o mínimo y, máximo y, mais à esquerda y e y mais à direita . Que irá processar todas as informações que podem ser utilmente prestados. Você ainda pode ver os mínimos e máximos, e você manter o relacionamento com os pixels vizinhos.

Com isto em mente, você pode trabalhar com o número de amostras que vão cair na mesma pixel no eixo x (pense neles como dados "caixas"). Dentro de um determinado bin, você pode, então, determinar as amostras particulares para máximos, mínimos etc.

Para reiterar, este é apenas um subconjunto que serve para a exibição - e só é adequada até que a mudança de parâmetros de exibição. por exemplo. se o usuário rola o gráfico ou zooms, você precisa recalcular o subconjunto render.

Você pode fazer isso se você estiver usando OpenGL, mas desde que usa OpenGL um normalizada sistema de coordenadas (e você estiver interessado em coordenadas de tela do mundo real), você terá que trabalhar um pouco mais difícil de determinar com precisão as suas caixas de dados. Isso será mais fácil sem o uso de OpenGL, mas então você não obter todos os benefícios do seu hardware gráfico.

Você realmente não precisa se preocupar com o eixo Z se você não quiser. Em OpenGL (por exemplo), você pode especificar vértices XY (com Z implícita = 0), vire do zbuffer, usar uma projeção de matriz não-projetiva, e hey presto você está em 2D.

Mark Bessey mencionado isso, que você pode não ter os pixels para mostrar o gráfico. Mas dado as suas explicações, eu suponho que você sabe o que está fazendo.

OpenGL tem um modo ortogonal que tem uma coordenada z interior (0; 1). Não há projeção em perspectiva, os polígonos que você desenhar será planar para a área de recorte de tela.

DirectX terá similar. Em OpenGL, ele é chamado gluOrtho2d ().

OpenGL está feliz para prestar 2D se você configurar a projeção para ser Ortho (sem z). Também você deve dizimar seus dados. Tornando o mesmo pixel 1000 vezes é um desperdício de GPU. Passe o seu upfront tempo com um dizimador performat multi-thread. O ser certeza para explodir grandes matrizes na GPU usando matrizes vértice ou objetos de buffer de vértice (claramente que eu sou um OpenGL tipo de cara)

Isso faz com que prestamos sobre amostras de 25M em uma única tela.

Não, você não, a não ser que você tem um realmente muito grande tela. Dado que a resolução da tela é provavelmente mais como 1.000 - 2.000 pixels de largura, você realmente deve considerar dizimando os dados antes de você gráfico lo. Representação gráfica de uma centena de linhas em 1.000 pontos por linha provavelmente não será um grande problema, desempenho sábio.

Se o seu código fica ilegível porque você está lidando com o material 3D diretamente, você precisa escrever uma camada fina adaptador que encapsula todas as coisas 3D OpenGL, e leva em 2D de dados em uma forma conveniente para a sua aplicação.

Perdoe-me se eu perdi alguma coisa, e estou pregando projeto básico orientada a objeto para o coro. Apenas sayin' ...

Você não precisa eliminar os pontos do conjunto de dados real, mas você pode certamente incrementalmente refiná-lo quando os zooms de usuários no. Ele faz você não é bom para renderizar 25 milhões de pontos para uma única tela quando o usuário não pode possivelmente processar todos esses dados. Eu recomendaria que você dê uma olhada em ambos a biblioteca VTK e o guia de usuário VTK, como há algumas informações de valor inestimável lá em formas de visualizar grandes conjuntos de dados.

Muito obrigado. Este é exatamente o que eu estava procurando. Parece VTK usa hardware para descarregar este tipo de processamento, também. Btw, eu acho que você quer dizer valiosa ;). Em segundo lugar, o usuário faz obter informações do exemplo que dei. No entanto não é realmente concisa, a visão geral dos dados pode realmente ser ouro puro para o cientista. Não é sobre o processamento de todos os dados para o usuário, é sobre a obtenção de informações valiosas para fora da renderização. Os usuários parecem fazer isso, mesmo na representação muito 'zoom out' do conjunto de dados.

Qualquer mais sugestões?

Eu queria salientar que, além de usar VTK diretamente, existem dois outros produtos construídos em VTK que possam ser de seu interesse.

1) Paraview (paraview.org) é uma interface de usuário construída em cima de VTK que faz produtos de visualização científica muito mais fácil. Você pode processar todos os dados que deseja desde que tenha o hardware para lidar com isso, e suporta MPI para vários processadores / núcleos / grupos. É extensível através de usuário criado plugins e usos ferramentas automatizadas para a construção do projeto e compilar.

2) ParaViewGeo (paraviewgeo.mirarco.org) é um derivado de mineração e geologia exploração de Paraview produzido pela empresa trabalho para. Ele foi construído com suporte para leitura de formatos de arquivo que Paraview não, como GOCAD, Datamine, Geosoft, SGems, e outros. Mais importante, que muitas vezes fazer o trabalho com outros grupos que têm interesse em saber científico com uma entrega frouxamente laços-to-mineração, tais como a nossa recente trabalho com um grupo fazendo Finite / modelagem de elementos discretos. Pode valer a pena conferir.

Em ambos os casos (PV e PVG) seus dados é considerado separado de sua visão de que os dados e, como tal, você nunca vai "render" todos os seus dados (desde que você provavelmente não tem um monitor grande o suficiente para fazê-lo), mas a certeza de que tudo vai "estar lá" processado a partir de seu conjunto de dados como o esperado. Se você executar filtros adicionais em seus dados, apenas o que pode ser visto será "traduzida", mas os filtros irá calcular em todos os seus dados, que, embora não pode ser tudo visíveis ao mesmo tempo, tudo vai existir na memória.

Se você está à procura de números, hoje eu computados três grades regulares de 8 milhões de células em PVG. Uma continha uma propriedade vector de 7-tupla (7x 8000000 valores duplos), os outros dois continham cada uma propriedade escalar (1x 8000000 valores duplos, cada um) para um total de 72 milhões de valores duplos em memória. Eu acredito que o consumo de memória estava perto de 500 MB, mas eu também tinha um conjunto 400.000 ponto em cada ponto tinha uma propriedade vector 7-tupla e alguns outros dados diversos disponíveis também.

Não sei se isso é útil, mas você poderia usar o tempo como um dimenion? isto é, um quadro é uma z? Isso pode tornar as coisas mais claras, talvez? Então talvez você poderia ser efetivamente aplicar deltas para construir (ou seja no eixo z) a imagem?

Não, você não, a não ser que você tem uma tela realmente grande. Dado que a resolução da tela é provavelmente mais como 1.000 - 2.000 pixels de largura, você realmente deve considerar dizimando os dados antes de você gráfico lo. Representação gráfica de uma centena de linhas em 1.000 pontos por linha provavelmente não será um grande problema, desempenho sábio.

Em primeiro lugar, não podemos omitir quaisquer amostras ao renderizar. Isto é impossível. Isto significaria a prestação não é precisa com os dados do gráfico se baseia. Isso realmente é uma área de no-go. Período.

Em segundo lugar, são renderização todas as amostras. Pode ser que várias amostras de acabar no mesmo pixel. Mas, ainda assim, estamos tornando-o. Os dados de amostra é convertido no ecrã. Assim, ela é processada. Pode-se duvidar da usefullness destes dados visualizados, byt cientistas (nossos clientes) estão realmente exigindo que nós fazê-lo desta forma. E eles têm um ponto bom, IMHO.

Enrole a biblioteca em um, mais amável biblioteca suave 2D com o Z e rotações tudo pronto para 0.

-Adam

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow