API Python per Creare, Modificare e Convertire Modelli 3D

Iniziare con Aspose.3D per Python tramite .NET

Il modo più semplice per installare Aspose.3D per Python via .NET nella versione stabile è utilizzare pip. Utilizza il comando seguente per un'installazione senza problemi.

pip install aspose-3d 

Genera e carica una scena 3D tramite l'API Python

Aspose.3D per Python via .NET include il supporto completo per creare nuove scene 3D da zero e poi salvarle in qualsiasi formato di file supportato usando comandi Python. La libreria fornisce anche il supporto per leggere scene 3D esistenti, apportare modifiche a 3D esistenti, salvare una scena 3D in PDF, aprire scene esistenti da un PDF protetto da password, rilevare il formato di un file, estrarre contenuti 3D da un file PDF, impostare le opzioni di caricamento prima di caricare un file Obj 3D e molto altro.

import aspose.threed as a3d

# For complete examples and data files, please go to https://github.com/aspose-3d/Aspose.3D-for-.NET

# The path to the documents directory.

# Create an object of the Scene class

scene = a3d.Scene()

# Save 3D scene document

scene.Save("document.fbx", a3d.FileFormat.FBX7500ASCII)

Rendering di scene 3D tramite l'API Python

Aspose.3D per Python tramite .NET consente agli sviluppatori di software di caricare e renderizzare scene 3D all'interno delle proprie applicazioni Python. La libreria supporta il rendering di alta qualità di scene 3D, inclusi anti-aliasing, profondità di campo, motion blur e altro. Supporta inoltre l'importazione e l'esportazione di vari formati di file 3D, tra cui FBX, OBJ, STL e 3DS. Ciò significa che è possibile importare facilmente modelli 3D esistenti nella propria scena o esportare la scena 3D in un formato compatibile. Supporta funzionalità come ombre proiettate e ricevute su geometrie 3D, rendering basato su hardware della geometria 3D, rendering della vista 3D in formato immagine dalla fotocamera, rendering di una vista Panorama della scena 3D, e così via. Il seguente esempio di codice mostra come gli sviluppatori di software possono renderizzare una vista Panorama di una scena 3D e salvarla in formato immagine.

from aspose.pydrawing.imaging import ImageFormat
from aspose.pydrawing import Color
import aspose.threed as a3d

# load the scene

scene = Scene.from_file("vc.glb")

# create a camera for capturing the cube map

cam = a3d.entities.Camera(a3d.entities.ProjectionType.PERSPECTIVE)
cam.near_plane = 0.1
cam.far_plane = 200
cam.rotation_mode = a3d.entities.RotationMode.FIXED_DIRECTION
scene.root_node.create_child_node(cam).transform.set_translation(5, 6, 0);

# create two lights to illuminate the scene

scene.root_node.create_child_node(a3d.entities.Light("", a3d.entities.LightType.POINT).transform.set_translation(-10, 7, -10)
light = a3d.entities.Light()
light.color = Color.cadet_blue
scene.root_node.create_child_node(light).transform.set_translation(49, 0, 49)

# create a renderer

# Create a cube map render target with depth texture, depth is required when rendering a scene.

rt = renderer.render_factory.create_cube_render_texture(a3d.render.RenderParameters(False), 512, 512)

# create a 2D texture render target with no depth texture used for image processing
final = renderer.render_factory.CreateRenderTexture(a3d.render.RenderParameters(False, 32, 0, 0), 1024 * 3 , 1024)

# a viewport is required on the render target

rt.create_viewport(cam, a3d.utilities.RelativeRectangle.from_scale(0, 0, 1, 1))
renderer.render(rt)

# execute the equirectangular projection post-processing with the previous rendered cube map as input

equirectangular = renderer.get_post_processing("equirectangular")

# Specify the cube map rendered from the scene as this post processing's input

equirectangular.input = rt.targets[0]

# Execute the post processing effect and save the result to render target final

renderer.execute(equirectangular, final)

# save the texture into disk

final.targets[0].save("panorama.png", ImageFormat.PNG)

Lavorare con l'animazione in un documento 3D

Aspose.3D per Python tramite .NET consente agli sviluppatori di software di creare e gestire animazioni all'interno di documenti 3D utilizzando la libreria Python. La libreria include numerose funzionalità per lavorare con le animazioni, come il rendering della scena animata, la configurazione della telecamera di destinazione in un file 3D, la creazione di animazioni scheletriche, la gestione dei morph target e la fusione di più animazioni. L'esempio seguente dimostra come creare una semplice animazione utilizzando i comandi Python.

import clr
clr.AddReference("Aspose.3D")
from Aspose.ThreeD import *

# create a new scene
scene = Scene()

# create a new camera
camera = Camera()
camera.Name = "Camera"
scene.RootNode.CreateChildNode(camera)

# create a new mesh
mesh = Mesh()
mesh.Name = "Mesh"
vertices = Vector3[]
vertices.append(Vector3(0, 0, 0))
vertices.append(Vector3(0, 1, 0))
vertices.append(Vector3(1, 1, 0))
vertices.append(Vector3(1, 0, 0))
mesh.Vertices = vertices
mesh.Triangles = [0, 1, 2, 0, 2, 3]

# create a new node for the mesh
meshNode = Node()
meshNode.Name = "MeshNode"
meshNode.Translation = Vector3(0, 0, 0)
meshNode.CreateChildNode(mesh)

# add the mesh node to the scene
scene.RootNode.CreateChildNode(meshNode)

# create a new animation track for the mesh node
track = AnimationTrack(meshNode, AnimationTargetType.Translation)

# create a new keyframe at time 0
keyframe1 = Keyframe()
keyframe1.Time = 0
keyframe1.Value = Vector3(0, 0, 0)
track.Keyframes.Add(keyframe1)

# create a new keyframe at time 1
keyframe2 = Keyframe()
keyframe2.Time = 1
keyframe2.Value = Vector3(0, 0, 5)
track.Keyframes.Add(keyframe2)

# create a new animation clip
clip = AnimationClip("Clip")
clip.Duration = 1
clip.Tracks.Add(track)

# add the animation clip to the scene
scene.Animations.Add(clip)

# save the scene to a file
scene.Save("animation.fbx", FileFormat.FBX7400ASCII)

Lavorare con i poligoni usando l'API Python

Aspose.3D per Python tramite .NET consente agli sviluppatori di software di aggiungere e gestire mesh poligonali nei loro modelli 3D all'interno di applicazioni Python. La libreria include il supporto per varie funzionalità relative alla gestione delle mesh poligonali, come il caricamento di una mesh poligonale da un file, la creazione di una mesh poligonale, la conversione di tutti i poligoni in triangoli in un modello 3D, l'esportazione della mesh poligonale in un file e molto altro. L'esempio seguente mostra come gli utenti possano creare una mesh poligonale creando un oggetto Mesh e aggiungendo vertici e facce a essa.

# Create a mesh
mesh = Mesh()

# Add vertices
mesh.Vertices.Add(Vector3(0, 0, 0))
mesh.Vertices.Add(Vector3(0, 0, 1))
mesh.Vertices.Add(Vector3(0, 1, 0))
mesh.Vertices.Add(Vector3(1, 0, 0))

# Add faces
mesh.Faces.AddPolygonFace(0, 1, 2)
mesh.Faces.AddPolygonFace(0, 1, 3)
mesh.Faces.AddPolygonFace(0, 2, 3)
mesh.Faces.AddPolygonFace(1, 2, 3)

# Export the polygon mesh to a file

# Create a scene and add the mesh to it
scene = Scene()
scene.RootNode.CreateChildNode(mesh)

# Save the scene to a file
scene.Save("mesh.obj", FileFormat.WavefrontOBJ)