API Python pour créer, éditer et convertir des modèles 3D

Commencer avec Aspose.3D pour Python via .NET

La façon la plus simple d'installer Aspose.3D pour Python via .NET version stable est d'utiliser pip. Veuillez utiliser la commande suivante pour une installation fluide.

pip install aspose-3d 

Générer et charger une scène 3D via l'API Python

Aspose.3D pour Python via .NET inclut une prise en charge complète de la création de nouvelles scènes 3D à partir de zéro, puis de leur sauvegarde dans n'importe quel format de fichier pris en charge à l'aide de commandes Python. La bibliothèque offre également la prise en charge de la lecture de scènes 3D existantes, de la modification de scènes 3D existantes, de l'enregistrement d'une scène 3D au format PDF, de l'ouverture de scènes existantes à partir d'un PDF protégé par mot de passe, de la détection d'un format de fichier, de l'extraction de contenus 3D d'un fichier PDF, de la définition des options de chargement avant de charger un fichier Obj 3D et bien plus encore.

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)

Rendu de scène 3D via l'API Python

Aspose.3D for Python via .NET permet aux développeurs de logiciels de charger et de rendre des scènes 3D dans leurs propres applications Python. La bibliothèque prend en charge le rendu de haute qualité des scènes 3D, y compris l'anti-aliasing, la profondeur de champ, le flou de mouvement et plus encore. Elle prend également en charge l'importation et l'exportation de divers formats de fichiers 3D, notamment FBX, OBJ, STL et 3DS. Cela signifie que vous pouvez facilement importer des modèles 3D existants dans votre scène ou exporter votre scène 3D vers un format compatible. Elle prend en charge des fonctionnalités telles que les ombres portées et reçues sur les géométries 3D, le rendu matériel des géométries 3D, le rendu d'une vue 3D au format image depuis la caméra, le rendu d'une vue Panorama de la scène 3D, etc. L'exemple de code suivant montre comment les développeurs de logiciels peuvent rendre une vue Panorama d'une scène 3D et l'enregistrer au format image.

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)

Travailler avec l'animation dans un document 3D

Aspose.3D pour Python via .NET permet aux développeurs de logiciels de créer et de travailler avec des animations dans des documents 3D en utilisant la bibliothèque Python. La bibliothèque comprend de nombreuses fonctionnalités pour travailler avec les animations, telles que le rendu de la scène animée, la configuration de la caméra cible dans un fichier 3D, la création d'animations squelettiques, le travail avec des cibles de morphing et le mélange de plusieurs animations. L'exemple suivant montre comment créer une animation simple en utilisant des commandes 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)

Travailler avec des polygones en utilisant l'API Python

Aspose.3D pour Python via .NET permet aux développeurs de logiciels d'ajouter et de gérer des maillages polygonaux dans leurs modèles 3D au sein d'applications Python. La bibliothèque inclut la prise en charge de diverses fonctionnalités liées à la gestion des maillages polygonaux, telles que le chargement d'un maillage polygonal à partir d'un fichier, la création d'un maillage polygonal, la conversion de tous les polygones en triangles dans un modèle 3D, l'exportation du maillage polygonal vers un fichier, et bien plus encore. L'exemple suivant montre comment les utilisateurs peuvent créer un maillage polygonal en créant un objet Mesh et en ajoutant des sommets et des faces.

# 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)