Python-API zum Erstellen, Bearbeiten & Konvertieren von 3D-Modellen

Erste Schritte mit Aspose.3D für Python via .NET

Der einfachste Weg, Aspose.3D für Python via .NET stabile Version zu installieren, ist die Verwendung von pip. Bitte verwenden Sie den folgenden Befehl für eine reibungslose Installation.

pip install aspose-3d 

Erzeugen & Laden einer 3D-Szene via Python-API

Aspose.3D für Python via .NET enthält vollständige Unterstützung für das Erstellen neuer 3D‑Szenen von Grund auf und das anschließende Speichern in jedem unterstützten Dateiformat mittels Python‑Befehlen. Die Bibliothek bietet zudem Unterstützung für das Lesen vorhandener 3D‑Szenen, das Ändern bestehender 3D‑Objekte, das Speichern einer 3D‑Szene im PDF, das Öffnen vorhandener Szenen aus einem passwortgeschützten PDF, das Erkennen eines Dateiformats, das Extrahieren von 3D‑Inhalten aus einer PDF‑Datei, das Festlegen von Ladeoptionen vor dem Laden einer 3D‑Obj‑Datei und vieles mehr.

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 von 3D-Szenen via Python-API

Aspose.3D für Python über .NET ermöglicht Softwareentwicklern das Laden und Rendern von 3D‑Szenen in ihren eigenen Python‑Anwendungen. Die Bibliothek unterstützt die hochwertige Darstellung von 3D‑Szenen, einschließlich Antialiasing, Tiefenschärfe, Bewegungsunschärfe und mehr. Sie unterstützt zudem das Importieren und Exportieren verschiedener 3D‑Dateiformate, darunter FBX, OBJ, STL und 3DS. Das bedeutet, dass Sie problemlos vorhandene 3D‑Modelle in Ihre Szene importieren oder Ihre 3D‑Szene in ein kompatibles Format exportieren können. Sie bietet Funktionen wie das Werfen und Empfangen von Schatten auf 3D‑Geometrien, hardwarebasiertes Rendering von 3D‑Geometrie, das Rendern einer 3D‑Ansicht im Bildformat aus der Kamera, das Rendern einer Panorama‑Ansicht der 3D‑Szene usw. Das folgende Codebeispiel zeigt, wie Softwareentwickler eine Panorama‑Ansicht einer 3D‑Szene rendern und im Bildformat speichern können.

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)

Arbeiten mit Animation in 3D-Dokumenten

Aspose.3D für Python über .NET ermöglicht Softwareentwicklern das Erstellen und Arbeiten mit Animationen in 3D-Dokumenten mithilfe der Python-Bibliothek. Die Bibliothek enthält zahlreiche Funktionen für die Arbeit mit Animationen, wie das Rendern der animierten Szene, das Einrichten der Zielkamera in einer 3D-Datei, das Erstellen von Skelettanimationen, das Arbeiten mit Morph-Zielen und das Mischen mehrerer Animationen. Das folgende Beispiel zeigt, wie man mit Python-Befehlen eine einfache Animation erstellt.

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)

Arbeiten mit Polygonen mittels Python-API

Aspose.3D für Python über .NET ermöglicht Softwareentwicklern das Hinzufügen und Verwalten von Polygonnetzen in ihren 3D-Modellen innerhalb von Python-Anwendungen. Die Bibliothek bietet Unterstützung für verschiedene Funktionen im Zusammenhang mit der Verwaltung von Polygonnetzen, wie das Laden eines Polygonnetzes aus einer Datei, das Erstellen eines Polygonnetzes, das Konvertieren aller Polygone in Dreiecke in einem 3D-Modell, das Exportieren des Polygonnetzes in eine Datei und vieles mehr. Das folgende Beispiel zeigt, wie Benutzer ein Polygonnetz erstellen können, indem sie ein Mesh-Objekt erzeugen und diesem Scheitelpunkte und Flächen hinzufügen.

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