API de Python para Crear, Editar y Convertir Modelos 3D

Comenzando con Aspose.3D para Python a través de .NET

La forma más fácil de instalar Aspose.3D para Python a través de .NET en su versión estable es usando pip. Por favor, use el siguiente comando para una instalación sin problemas.

pip install aspose-3d 

Generar y cargar escena 3D mediante la API de Python

Aspose.3D para Python a través de .NET incluye soporte completo para crear nuevas escenas 3D desde cero y luego guardarlas en cualquier formato de archivo compatible usando comandos de Python. La biblioteca también brinda soporte para leer escenas 3D existentes, realizar cambios en 3D existente, guardar una escena 3D en PDF, abrir escenas existentes desde un PDF protegido con contraseña, detectar un formato de archivo, extraer contenido 3D de un archivo PDF, establecer opciones de carga antes de cargar un archivo Obj 3D y mucho más.

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)

Renderizado de escena 3D mediante la API de Python

Aspose.3D para Python a través de .NET permite a los desarrolladores de software cargar y renderizar escenas 3D dentro de sus propias aplicaciones Python. La biblioteca admite renderizado de alta calidad de escenas 3D, incluyendo anti-aliasing, profundidad de campo, desenfoque de movimiento y más. También admite la importación y exportación de varios formatos de archivo 3D, incluyendo FBX, OBJ, STL y 3DS. Esto significa que puedes importar fácilmente modelos 3D existentes a tu escena o exportar tu escena 3D a un formato compatible. Soporta características como sombras proyectadas y recibidas en geometrías 3D, renderizado basado en hardware de geometría 3D, renderizado de la vista 3D en formato de imagen desde la cámara, renderizado de una vista panorámica de la escena 3D, y así sucesivamente. El siguiente ejemplo de código muestra cómo los desarrolladores de software pueden renderizar una vista panorámica de una escena 3D y guardarla en formato de imagen.

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)

Trabajar con animación en documento 3D

Aspose.3D para Python a través de .NET permite a los desarrolladores de software crear y trabajar con animaciones dentro de documentos 3D utilizando la biblioteca de Python. La biblioteca incluye numerosas funciones para trabajar con animaciones, como renderizar la escena animada, configurar la cámara objetivo en un archivo 3D, crear animaciones esqueléticas, trabajar con objetivos de morfología y combinar múltiples animaciones. El siguiente ejemplo muestra cómo crear una animación simple usando comandos de 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)

Trabajar con polígonos usando la API de Python

Aspose.3D para Python a través de .NET permite a los desarrolladores de software agregar y gestionar mallas de polígonos en sus modelos 3D dentro de aplicaciones Python. La biblioteca incluye soporte para diversas funciones relacionadas con la gestión de mallas de polígonos, como cargar una malla de polígonos desde un archivo, crear una malla de polígonos, convertir todos los polígonos en triángulos en un modelo 3D, exportar la malla de polígonos a un archivo, entre otras. El siguiente ejemplo muestra cómo los usuarios pueden crear una malla de polígonos creando un objeto Mesh y añadiendo vértices y caras a ella.

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