As animações de quadros‑chave definem como um valor muda ao longo do tempo. Por exemplo, você pode especificar onde um objeto deve estar no início de uma animação e para onde ele deve se mover a seguir, então calcular sua posição em qualquer ponto entre esses quadros‑chave. Isso é útil para inspecionar curvas de movimento, verificar o tempo da animação e exportar valores amostrados para análise adicional. Aspose.3D for Python via .NET permite que você amostre uma sequência de quadros‑chave em um timestamp especificado sem renderizar uma cena 3D. Neste tutorial, você criará uma animação simples de posição, avaliará seus valores interpolados a cada meio segundo e salvará os resultados em um arquivo CSV.

Instalar Aspose.3D para Python

Instale Aspose.3D for Python via .NET versão 26.10 usando pip:

pip install aspose-3d==26.10.0

Este exemplo usa apenas o módulo aspose.threed.animation e o módulo csv embutido do Python. Você não precisa de um arquivo GLB/GLTF ou de uma placa gráfica compatível com Vulkan, pois o código realiza cálculos de animação em vez de renderização de imagem.

Para informações sobre plataforma e instalação, consulte a documentação do Aspose.3D for Python.

Criar e avaliar uma animação de quadros‑chave em Python

O exemplo modela a posição X de um objeto. A posição começa em 0, atinge 10 unidades após dois segundos e retorna a 0 após cinco segundos.

Tempo (segundos)Posição XAção
00Iniciar
210Alcançar posição máxima
50Retornar ao início

Os valores entre esses quadros‑chave são calculados usando interpolação linear. O exemplo cria uma curva de animação numérica independente; ele não anexa a sequência a um objeto de cena real.

Exemplo completo de código Python

O script a seguir cria um KeyframeSequence, adiciona três quadros‑chave, avalia onze timestamps, valida os valores dos quadros‑chave e exporta os resultados para keyframe_animation.csv.

import csv

from aspose.threed.animation import (
    KeyframeSequence,
    Interpolation
)

OUTPUT_FILE = "keyframe_animation.csv"

# Create an animation curve
sequence = KeyframeSequence("PositionX")

# Define keyframes using linear interpolation
sequence.add(0.0, 0.0, Interpolation.LINEAR)
sequence.add(2.0, 10.0, Interpolation.LINEAR)
sequence.add(5.0, 0.0, Interpolation.LINEAR)

# Display the defined keyframes
print("Keyframes:")

for key in sequence.key_frames:
    print(
        f"Time: {key.time:.2f}s, "
        f"Value: {key.value:.2f}"
    )

# Evaluate the animation every 0.5 seconds
start_time = 0.0
end_time = 5.0
step = 0.5

records = []

print("\nEvaluated animation values:")
print("---------------------------")
print("Time (s) | X Position")

sample_count = int(
    round((end_time - start_time) / step)
) + 1

for i in range(sample_count):
    time = float(start_time + i * step)

# Evaluate the animation at this timestamp
    value = float(sequence.evaluate(time))

records.append([time, value])

print(f"{time:8.2f} | {value:10.3f}")

# Verify values at known timestamps
assert abs(sequence.evaluate(0.0) - 0.0) < 1e-5
assert abs(sequence.evaluate(2.0) - 10.0) < 1e-5
assert abs(sequence.evaluate(5.0) - 0.0) < 1e-5

# Export animation data to CSV
with open(
    OUTPUT_FILE,
    "w",
    newline="",
    encoding="utf-8"
) as file:

writer = csv.writer(file)

writer.writerow([
        "Time (seconds)",
        "X Position"
    ])

writer.writerows(records)

print(f"\nAnimation data saved to {OUTPUT_FILE}")
print("Keyframe validation passed.")

Entenda como a avaliação de keyframe funciona

Definir uma sequência de keyframes

A classe KeyframeSequence representa uma curva numérica com valores definidos em momentos específicos. Esta linha cria uma sequência chamada PositionX:

sequence = KeyframeSequence("PositionX")

O nome ajuda a identificar a sequência. Ele não vincula automaticamente a sequência a uma malha ou propriedade de nó. Para mais detalhes, veja a referência da API KeyframeSequence.

Adicionar quadros‑chave com interpolação linear

Cada chamada a add() fornece um timestamp, um valor e um tipo de interpolação:

sequence.add(0.0, 0.0, Interpolation.LINEAR)
sequence.add(2.0, 10.0, Interpolation.LINEAR)
sequence.add(5.0, 0.0, Interpolation.LINEAR)

Interpolation.LINEAR informa à sequência que calcule valores intermediários proporcionalmente entre os quadros‑chave. Como resultado, o valor aumenta de forma constante de 0 a 10 durante os primeiros dois segundos e diminui de forma constante de 10 a 0 durante os próximos três segundos.

Calcular um valor em um timestamp

A operação principal é:

value = sequence.evaluate(1.5)

Para este exemplo, o resultado esperado em 1.5 segundos é 7.5. A interpolação linear segue esta fórmula:

[ v(t) = v_0 + \frac{t - t_0}{t_1 - t_0}(v_1 - v_0) ]

Aqui, t é o timestamp solicitado, t0 e t1 são os tempos dos quadros‑chave circundantes, e v0 e v1 são seus respectivos valores.

Entre os dois primeiros quadros‑chave, avaliando em 1,5 segundos, obtém‑se:

[ v(1.5) = 0 + \frac{1.5 - 0}{2 - 0}(10 - 0) = 7.5 ]

Você não precisa implementar esta fórmula você mesmo. KeyframeSequence.evaluate() realiza o cálculo de acordo com as configurações de interpolação da sequência.

Verifique os valores avaliados

Para os keyframes de exemplo, a saída é:

Keyframes:
Time: 0.00s, Value: 0.00
Time: 2.00s, Value: 10.00
Time: 5.00s, Value: 0.00

Evaluated animation values:
---------------------------
Time (s) | X Position
    0.00 |      0.000
    0.50 |      2.500
    1.00 |      5.000
    1.50 |      7.500
    2.00 |     10.000
    2.50 |      8.333
    3.00 |      6.667
    3.50 |      5.000
    4.00 |      3.333
    4.50 |      1.667
    5.00 |      0.000

Animation data saved to keyframe_animation.csv
Keyframe validation passed.

As instruções assert verificam os valores nos três timestamps de keyframe definidos. Elas utilizam uma pequena tolerância em vez de igualdade direta de ponto flutuante.

Os valores que mudam entre os quadros‑chave confirmam que a sequência está sendo amostrada ao longo de sua faixa de tempo.

Exportar valores de keyframe para CSV

Depois de avaliar a sequência, o script grava o tempo e a posição X calculada em keyframe_animation.csv usando o módulo csv do Python. O arquivo começa com:

Time (seconds),X Position
0.0,0.0
0.5,2.5
1.0,5.0
1.5,7.5
2.0,10.0

Você pode abrir este CSV em um aplicativo de planilha, plotar a curva de movimento resultante ou lê‑lo de volta no Python para análise. Para obter resultados mais granulares, reduza step de 0.5 para um intervalo menor e ajuste o intervalo de tempo desejado.

Considerações práticas

Amostra apenas dentro do intervalo de tempo pretendido. Este tutorial avalia tempos de 0 a 5 segundos. Valores fora dos quadros‑chave definidos são governados pelo comportamento de extrapolação pré‑ e pós‑, que é separado da interpolação entre quadros‑chave.

Escolha a interpolação deliberadamente. A interpolação linear produz mudanças constantes dentro de cada segmento. Outros estilos de interpolação podem criar diferentes características de movimento e podem exigir configurações adicionais de quadros‑chave. Consulte a referência da API de animação antes de alterar o modo de interpolação.

Distinga a avaliação de animação da animação de cena. O código avalia apenas uma curva numérica. Ele não atualiza a posição X de um nó da cena nem cria uma animação renderizada. Para mover um objeto 3D, a sequência deve ser conectada a uma propriedade animada apropriada em uma cena.

A renderização por GPU não é necessária. Nenhuma chamada para Scene.render() ou um backend de renderização é feita. Isso torna o exemplo adequado para trabalhar com valores de animação em máquinas sem uma GPU compatível com Vulkan.

Obtenha uma Licença Temporária Gratuita

Você pode solicitar uma licença temporária gratuita de 30 dias para avaliar Aspose.3D for Python via .NET sem limitações de avaliação. Siga o guia de licenciamento do Aspose.3D para aplicar a licença ao seu aplicativo.

Recursos de Aprendizagem Gratuitos

Explore esses recursos para continuar trabalhando com animação 3D e fluxos de trabalho de processamento de arquivos em Python:

Conclusão

Você pode usar KeyframeSequence.evaluate() em Aspose.3D for Python via .NET para calcular valores de animação em momentos específicos sem renderizar um modelo. Neste exemplo, três quadros‑chave definem uma curva de posição X, enquanto o avaliador calcula posições intermediárias e as exporta para CSV. Para adaptar o exemplo, altere os valores dos quadros‑chave ou o intervalo de amostragem. Para animação ao nível do modelo, o próximo passo é vincular curvas de animação às propriedades da cena e aplicá‑las aos objetos.

Leia Mais