Astronomia

Como criar animação 3D da posição das partículas vs tempo em python?

Como criar animação 3D da posição das partículas vs tempo em python?


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.

Estou tentando fazer uma animação 3-D da posição das estrelas em relação ao tempo. Eu tenho as informações das coordenadas x, y e z das estrelas ao longo do tempo. Eu estava olhando para o exemplo do Matplotlib e entendi o que preciso fazer, mas não quero as linhas de conexão entre os tempos diferentes. Tudo que preciso é mostrar a posição das estrelas em momentos diferentes e fazer um filme disso. Este é o exemplo que eu estava vendo

https://matplotlib.org/gallery/animation/simple_3danim.html

Depois disso, quero complicar um pouco. Também tenho o tamanho e a massa das estrelas. Eu queria saber se posso alterar o tamanho dos círculos no gráfico de acordo com o raio e usar cores diferentes para diferentes faixas de massa?


Depois disso, quero complicar um pouco. Também tenho o tamanho e a massa das estrelas. Eu queria saber se posso alterar o tamanho dos círculos no gráfico de acordo com o raio e usar cores diferentes para diferentes faixas de massa?

Essa parte foi abordada em perguntas e respostas anteriores aqui, lembro-me de ter lido talvez um ano atrás (+/- 0,9 anos).


Aqui está algo que você pode achar útil reproduzido de minha resposta no Stack Overflow. É baseado na postagem do blog do astrônomo e cientista de dados Jake VanderPlas de 2013.

Para suas necessidades, mantenha os pontos, mas não as linhas. O que eu recomendo é que você comece assim e chegue o mais longe possível, depois faça uma pergunta no Stack Overflow mostrando o que você tentou e explicando o que você ainda precisa.

Aqui está o atrator Lorenz em 3D e animado. O script está no link a seguir (junto com muitas guloseimas) em Jake VanderPlas 'Pythonic Perambulations. Você pode aprender muito examinando linha por linha através do script - é um uso elegante dematplotlibobjetos.

https://jakevdp.github.io/blog/2013/02/16/animating-the-lorentz-system-in-3d/

Eu adicionei essas duas linhas um pouco antesRetornanoanimare então usei ImageJ para importar a "pilha de imagens" e salvar o "GIF animado":

fname = "Astro_Jake_" + str (i + 10000) [1:] fig.savefig (fname)

Observação: Para OSX, parece ser necessário definirblit = Falsedentroanimation.FuncAnimation.

Aqui está um exemplo simplificado mínimo de linhas de plotagem em 3D com base no acima:

def lorentz_deriv ((x, y, z), t0, sigma = 10., beta = 8/3, rho = 28,0): "" "Calcula a derivada de tempo de um sistema de Lorentz." "" return [sigma * (y - x), x * (rho - z) - y, x * y - beta * z] importar numpy como np importar matplotlib.pyplot como plt de mpl_toolkits.mplot3d importar Axes3D de scipy.integrate importar odeint como ODEint x = np.linspace (0, 20, 1000) y, z = 10. * np.cos (x), 10. * np.sin (x) # algo simples fig = plt.figure () ax = fig.add_subplot (1 , 2,1, projeção = '3d') ax.plot (x, y, z) # agora Lorentz vezes = np.linspace (0, 4, 1000) start_pts = 30. - 15. * np.random.random ( (20,3)) # 20 valores iniciais xyz aleatórios trajetórias = [] para start_pt em start_pts: trajetória = ODEint (lorentz_deriv, start_pt, times) trajetórias.append (trajetória) ax = fig.add_subplot (1,2,2, projeção = '3d') para trajetória em trajetórias: x, y, z = trajetória.T # transpor e desempacotar # x, y, z = zip (* trajetória) # isso também funciona! ax.plot (x, y, z) plt.show ()

Eu escrevi isso antes de saber do PIL. Aparentemente, você pode usar o PIL para gerar seus GIFs em vez de usar um programa externo como eu fiz.

Ver

e divirta-se!

Um exemplo de GIF com estrelas da primeira postagem do blog (Nyan Cat):


Olá, consegui escrever o código. Aqui está o que eu fiz

import numpy as np import matplotlib.pyplot as plt import mpl_toolkits.mplot3d.axes3d as p3 import matplotlib.animation as animações import pandas as pd df1 = pd.read_pickle ("properties.csv") x = np.array (df1 ['x ']) * 3.24078e-17 y = np.array (df1 [' y ']) * 3.24078e-17 z = np.array (df1 [' z ']) * 3.24078e-17 dados = [] para i no intervalo (len (x)): em branco = [] para j no intervalo (len (x [i])): dummy = [] dummy.append (x [i] [j]) dummy.append (y [i ] [j]) dummy.append (z [i] [j]) blank.append ((dummy)) data.append (np.array (blank)) def animate_scatters (iteration, data, scatters): para i no intervalo (dados [0] .shape [0]): scatters [i] ._ offsets3d = (dados [iteração] [i, 0: 1], dados [iteração] [i, 1: 2], dados [iteração] [i , 2:]) return scatters def main (data, save = False): fig = plt.figure () ax = p3.Axes3D (fig) # Initialize scatters scatters = [ax.scatter (data [0] [i, 0 : 1], dados [0] [i, 1: 2], dados [0] [i, 2:]) para i no intervalo (dados [0] .shape [0])] # Número de iterações iterações = len (dados) # Configurando as propriedades dos eixos ax.set_xlim3d ([- 10, 10]) ax.set_xlabel ('X') ax.set _ylim3d ([- 10, 10]) ax.set_ylabel ('Y') ax.set_zlim3d ([- 10, 10]) ax.set_zlabel ('Z') ax.set_title ('Nuclear Star Cluster') # Fornece o ângulo inicial para a vista. ax.view_init (25, 10) ani = animation.FuncAnimation (fig, animate_scatters, iterations, fargs = (data, scatters), interval = 50, blit = False, repeat = True) se salvar: Writer = animation.writers [' ffmpeg '] writer = Writer (fps = 30, metadata = dict (artist =' Me '), bitrate = 1800, extra_args = [' - vcodec ',' libx264 ']) ani.save (' 3d-scattered-animated. mp4 ', writer = writer) plt.show () #print data [1] main (data, save = True)

Agora, meu problema é que a forma dos meus dados está mudando com o tempo, o número de partículas está diminuindo. Como faço para incorporar isso ao código?


Como renderizar 3D em tela 2D

Como estávamos explorando opções sobre a melhor forma de ilustrar a história de uma marca recentemente, criamos um protótipo bem interessante: uma animação de várias etapas que começa com um globo giratório cheio de partículas.

Do ponto de vista técnico, esse primeiro passo foi definitivamente o mais interessante. Como todas as etapas de animação a seguir eram 2D ​​simples, não pude usar um renderizador 3D como o Three.js. E então eu tive que descobrir como renderizar uma forma 3D usando apenas a API 2D do Canvas.

Neste artigo, vou mostrar como eu finalmente fiz isso. Explicarei primeiro como renderizar uma forma básica de uma cena 3D usando a API JavaScript Canvas 2D. Então, na segunda parte deste post, vou mostrar como deixar tudo um pouco mais sofisticado com algumas texturas e volumes 3D.


Os nós de objeto representam objetos na cena, como partes de personagens, objetos de geometria, luzes, câmeras e assim por diante.

Nós de geometria vivem dentro de objetos Geo e geram geometria.

Os nós de dinâmica definem as condições e regras para simulações de dinâmica.

Os nós VOP permitem definir um programa (como um sombreador) conectando nós. Houdini então compila a rede de nós em código VEX executável.

Os nós LOP geram USD descrevendo personagens, adereços, iluminação e renderização.

Os nós de renderização renderizam a cena ou configuram redes de dependência de renderização.

Os nós do canal criam, filtram e manipulam os dados do canal.

Nós compostos criam, filtram e manipulam dados de imagem.

Os nós TOP definem um fluxo de trabalho onde os dados são alimentados na rede, transformados em "itens de trabalho" e manipulados por nós diferentes. Muitos nós representam processos externos que podem ser executados na máquina local ou em um farm de servidores.


Aplicações de alinhamento de imagem

O alinhamento de imagens tem inúmeras aplicações.

Em muitos aplicativos de processamento de documentos, a primeira etapa é alinhar o documento digitalizado ou fotografado a um modelo. Por exemplo, se você deseja escrever um leitor de formulário automático, é uma boa ideia primeiro alinhar o formulário ao seu modelo e, em seguida, ler os campos com base em um local fixo no modelo.

Em algumas aplicações médicas, várias varreduras de um tecido podem ser feitas em momentos ligeiramente diferentes e as duas imagens são registradas usando uma combinação de técnicas descritas neste tutorial e no anterior.

A aplicação mais interessante de alinhamento de imagem talvez seja a criação de panoramas. Neste caso, as duas imagens não são de um plano, mas de uma cena 3D. Em geral, o alinhamento 3D requer informações de profundidade. Porém, quando as duas imagens são tiradas girando a câmera em torno de seu eixo óptico (como no caso dos panoramas), podemos usar a técnica descrita neste tutorial para alinhar duas imagens de um panorama.


3. Simulação de Dinâmica de Partículas

Existem muitos métodos para resolver EDOs. A ODE de segunda ordem é transformada no sistema de duas ODEs de primeira ordem da seguinte maneira:

Usamos uma aproximação de diferença finita que chega a um algoritmo de Euler direto simples:

Aqui, discretizamos o tempo t com o passo de tempo $ dt $, então $ t_ = t_n + dt $ e $ r_ = r (t_n) $, $ v_ = v (t_n) $, onde $ n $ é o número do passo de tempo. Usando este método, a dinâmica da computação é direta.

Exemplo 3.1. Simulação de um projétil na Terra.

Queremos saber a dinâmica de uma maçã verde ($ m = 0,3 $ kg) lançada horizontalmente a uma velocidade de 10 cm / s do topo da Torre CN de Toronto (553 m) durante os primeiros 10 segundos.

Vamos visualizar a dinâmica usando HTML incorporado. É interativo e você pode reproduzir um filme passo a passo:

Quando um sistema fechado de partículas está interagindo por meio de potenciais de pares, a força em cada partícula $ i $ depende de sua posição em relação a todas as outras partículas $ j $:

onde $ r_ = sqrt <(x_i - x_j) ^ 2 + (y_i - y_j) ^ 2 + (z_i - z_j) ^ 2> $ é a distância entre a partícula $ i $ e $ j $, e $ i, j in ( 1, N) $.

Exemplo 3.2. Simulação do problema de 3 corpos com a lei de Hooke:

Queremos saber a dinâmica de 3 partículas $ m = 1 $ kg conectadas umas às outras com molas invisíveis com $ K_s = 5 $ N / m, e $ r_0 = 1 $ m inicialmente localizadas em (0, 2), (2 , 0) e (-1, 0) no plano 2D durante os primeiros 10 segundos de seu movimento.

Dica: O potencial dos pares é (Lei de Hooke): (U (r_) = frac<2> (r_ - r_0) ^ 2 )

O gradiente negativo do potencial é uma força de $ j $ -ésima sobre $ i $ -ésima:

[ mathbf<>> = - nabla_i<>)> = - K_s (r_ - r_0) nabla_i r_ = - K_s (r_ - r_0) mathbf<>> / r_]

Novamente, olhando para a representação da trajetória em tempo real:

Embora agora tenhamos um conhecimento básico do propósito e metodologia das simulações, ainda precisamos entender o que são proteínas e por que são importantes.


Gerenciar notificações.

Se você deseja adicionar um novo, renomear ou remover Notificações de esqueleto existentes, você pode fazer isso a partir do Gerenciar notificações opção ao clicar com o botão direito no Notifica acompanhar.

O Notificações de animação janela aparecerá e exibirá todos os Notificações que você criou.

Clique com o botão direito para criar novos Notificações ou clique com o botão direito em um Notificar para renomeá-lo ou excluí-lo.

Através de Gerenciar notificações você também pode ver quais animações estão usando atualmente o Notify selecionado do Detalhes painel clicando no Varredura botão.

Todas as animações que usam o Notify selecionado serão exibidas no Detalhes painel.


Iniciando o Panda3D¶

Para iniciar o Panda3D, crie um arquivo de texto e salve-o com a extensão .py. PYPE, SPE e IDLE são editores de texto específicos do Python, mas qualquer editor de texto funcionará. Insira o seguinte texto em seu arquivo Python:

Aqui, tornamos nossa classe principal herdada de ShowBase. Esta classe carrega a maioria dos outros módulos do Panda3D e faz com que a janela 3D apareça. O método run () contém o loop principal do Panda3D. Ele renderiza um quadro, lida com as tarefas em segundo plano e, em seguida, repete. Normalmente não retorna, portanto, precisa ser chamado apenas uma vez e deve ser a última linha em seu script. Neste exemplo específico, não haverá nada para renderizar, então você deve esperar uma janela contendo uma área cinza vazia.


Plotagem Tridimensional em Matplotlib

Matplotlib foi inicialmente projetado com apenas plotagem bidimensional em mente. Na época do lançamento 1.0, alguns utilitários de plotagem tridimensional foram construídos sobre a exibição bidimensional do Matplotlib e o resultado é um conjunto conveniente (embora limitado) de ferramentas para visualização de dados tridimensionais. os gráficos tridimensionais são ativados importando o kit de ferramentas mplot3d, incluído na instalação principal do Matplotlib:

Uma vez que este submódulo é importado, eixos tridimensionais podem ser criados passando a palavra-chave projection = '3d' para qualquer uma das rotinas normais de criação de eixos:

Com esses eixos tridimensionais ativados, agora podemos plotar uma variedade de tipos de plotagens tridimensionais. A plotagem tridimensional é uma das funcionalidades que se beneficiam imensamente da visualização de figuras interativamente em vez de estaticamente no notebook. Lembre-se de que, para usar figuras interativas, você pode usar% matplotlib notebook em vez de% matplotlib inline ao executar este código.


Como criar animação 3D da posição das partículas vs tempo em python? - Astronomia


Uma variedade de recursos de plotagem. (retirado de example / Plotting.py)
Análise de imagens com corte automatizado de dados.


Gráficos 3D: renderização volumétrica, gráficos de superfície, gráficos de dispersão e isosuperfícies.


Uma variedade de tipos de ROI. Cada ROI seleciona dados da imagem subjacente e os exibe novamente abaixo. (retirado de examples / test_ROItypes.py)


Fluxogramas programáveis ​​para prototipagem rápida.

Para obter um exemplo de pyqtgraph em uso (e mais capturas de tela), consulte ACQ4

  • Plotagem 2D básica em caixas de visualização interativas
    • Gráficos de linha e dispersão
    • Os dados podem ser movidos / dimensionados pelo mouse
    • Desenho rápido para exibição e interação de dados em tempo real
    • Exibe a maioria dos tipos de dados (int ou flutuar em qualquer profundidade de bit RGB, RGBA ou luminância)
    • Funções para fatiar imagens multidimensionais em ângulos arbitrários (ótimo para dados de ressonância magnética)
    • Atualização rápida para exibição de vídeo ou interação em tempo real
    • Renderização de dados volumétricos
    • Superfície 3D e gráficos de dispersão
    • Renderização de malha com geração de isosuperfície
    • Portas de visualização interativas giram / ampliam com o mouse
    • Scenegraph 3D básico para uma programação mais fácil
    • Marque interativamente localizações e regiões verticais / horizontais nos gráficos
    • Widgets para selecionar regiões arbitrárias de imagens e fatiar dados automaticamente para corresponder
    • Os gráficos 2D usam a estrutura GraphicsView do Qt, que é altamente capaz e madura.
    • Gráficos 3D usam OpenGL
    • Todos os gráficos usam um cenário gráfico para gerenciar itens novos itens gráficos são simples de criar.
    • Widget de fluxograma para prototipagem interativa.
      Interface semelhante ao LabView (nós conectados por fios).
    • Widget de árvore de parâmetros para exibir / editar hierarquias de parâmetros
      (semelhantes aos usados ​​pela maioria dos aplicativos de design de GUI).
    • Console python interativo com captura de exceção.
      Ótimo para depuração / introspecção, bem como interação avançada do usuário.
    • Controle de multiprocessos permitindo plotagem remota, conexão de sinal Qt entre processos e paralelização em linha muito simples.
    • Sistema de encaixe que permite ao usuário reorganizar os componentes da GUI.
      Semelhante ao sistema dock do Qt, mas um pouco mais flexível e programável.
    • Editor de gradiente de cor
    • SpinBox com display da unidade SI e escalonamento logarítmico
    • Python 3+
    • PyQt 5, PyQt6, PySide2, ou PySide6
    • NumPy
    • SciPy é opcional para alguns procedimentos numéricos
    • python-opengl ligações são necessárias para gráficos 3D

    Embalagem para distribuição:

    • Publique relatórios de bugs e solicitações de recursos no rastreador de problemas do GitHub.
    • Para dúvidas, existem várias opções:

      Matplotlib é mais ou menos a biblioteca de plotagem padrão de fato para python. Se você está iniciando um novo projeto e não precisa de nenhum dos recursos especificamente fornecidos pelo pyqtgraph, você deve começar com matplotlib. É muito mais maduro, tem uma enorme comunidade de usuários e produz gráficos com qualidade de publicação muito bons.


    Iluminação, renderização e composição

    Solaris é o nome genérico para as ferramentas de construção, layout, iluminação e renderização de cenas de Houdini com base na estrutura Universal Scene Description (USD).

    Como renderizar imagens e animações da cena 3D.

    HQueue é o gerenciador de simulação e renderização distribuída gratuitamente de Houdini.

    Como atribuir materiais e criar materiais personalizados para sombreamento.

    As redes de composição de Houdini permitem criar e manipular imagens como renderizações.


    Seu primeiro jogo 3D¶

    Nesta série de tutoriais passo a passo, você criará seu primeiro jogo 3D completo com Godot. Ao final da série, você terá um projeto simples, mas concluído, como o GIF animado abaixo.

    O jogo que codificaremos aqui é semelhante ao Seu primeiro jogo 2D, com uma diferença: agora você pode pular e seu objetivo é esmagar os arrepios. Desta forma, você vai ambos reconhecer padrões você aprendeu no tutorial anterior e construir sobre eles com novo código e recursos.

    Trabalhe com coordenadas 3D com um mecânico de salto.

    Use corpos cinemáticos para mover personagens 3D e detectar quando e como eles colidem.

    Use camadas físicas e um grupo para detectar interações com entidades específicas.

    Codifique a jogabilidade de procedimento básico instalando monstros em intervalos de tempo regulares.

    Projete uma animação de movimento e mude sua velocidade em tempo de execução.

    Desenhe uma interface simples em um jogo 3D.

    Este tutorial é para iniciantes que seguiram a série de primeiros passos completa. Começaremos devagar com instruções detalhadas e as encurtamos à medida que executamos etapas semelhantes. Se você for um programador experiente, poderá navegar pelo código-fonte completo da demonstração aqui: Squash the Creep source code.

    Você pode acompanhar esta série sem ter feito a 2D. No entanto, se você é novo no desenvolvimento de jogos, recomendamos que comece com 2D. O código do jogo 3D é sempre mais complexo e a série 2D lhe dará as bases para seguir adiante com mais conforto.

    Preparamos alguns recursos do jogo para que possamos ir direto ao código. Você pode baixá-los aqui: recursos do Squash the Creeps.

    Vamos primeiro trabalhar em um protótipo básico para o movimento do jogador. Em seguida, adicionaremos os monstros que geraremos aleatoriamente pela tela. Depois disso, implementaremos a mecânica de salto e esmagamento antes de refinar o jogo com uma boa animação. Vamos encerrar com a pontuação e a tela de nova tentativa.