Python API om 3D-modellen te maken, bewerken en converteren

Aan de slag met Aspose.3D voor Python via .NET

De eenvoudigste manier om Aspose.3D voor Python via .NET stabiele release te installeren is met pip. Gebruik alstublieft de volgende opdracht voor een soepele installatie.

pip install aspose-3d 

Genereer & laad 3D-scène via Python API

Aspose.3D voor Python via .NET bevat volledige ondersteuning voor het maken van nieuwe 3D‑scènes vanaf nul en deze vervolgens op te slaan in elk ondersteund bestandsformaat met Python‑commando's. De bibliotheek biedt ook ondersteuning voor het lezen van bestaande 3D‑scènes, het aanbrengen van wijzigingen in bestaande 3D, het opslaan van een 3D‑scène in PDF, het openen van bestaande scènes uit een met wachtwoord beveiligde PDF, het detecteren van een bestandsformaat, het extraheren van 3D‑inhoud uit een PDF‑bestand, het instellen van laadopties vóór het laden van een 3D Obj‑bestand en nog veel meer.

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)

Weergave van 3D-scène via Python API

Aspose.3D voor Python via .NET stelt softwareontwikkelaars in staat om 3D‑scènes te laden en te renderen binnen hun eigen Python‑toepassingen. De bibliotheek ondersteunt hoogwaardige weergave van 3D‑scènes, inclusief anti‑aliasing, scherptediepte, bewegingsonscherpte en meer. Het ondersteunt ook het importeren en exporteren van verschillende 3D‑bestandsformaten, waaronder FBX, OBJ, STL en 3DS. Dit betekent dat u eenvoudig bestaande 3D‑modellen kunt importeren in uw scène of uw 3D‑scène kunt exporteren naar een compatibel formaat. Het ondersteunt functies zoals het werpen en ontvangen van schaduwen op 3D‑geometrieën, hardwaregebaseerde weergave van 3D‑geometrie, het renderen van een 3D‑weergave in afbeeldingsformaat vanuit de camera, het renderen van een panoramisch overzicht van de 3D‑scène, enzovoort. Het volgende codevoorbeeld laat zien hoe softwareontwikkelaars een panoramisch overzicht van een 3D‑scène kunnen renderen en opslaan in het afbeeldingsformaat.

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)

Werken met animatie in 3D-document

Aspose.3D voor Python via .NET biedt softwareontwikkelaars de mogelijkheid om animaties in 3D-documenten te maken en ermee te werken met behulp van de Python-bibliotheek. De bibliotheek bevat talrijke functies voor het werken met animaties, zoals het renderen van de geanimeerde scène, het instellen van de doelcamera in een 3D-bestand, het creëren van skeletanimaties, werken met morph-doelen en het mengen van meerdere animaties. Het volgende voorbeeld toont hoe je een eenvoudige animatie maakt met Python-commando's.

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)

Werken met polygonen met behulp van Python API

Aspose.3D voor Python via .NET stelt softwareontwikkelaars in staat om polygoonmesh toe te voegen en te beheren in hun 3D-modellen binnen Python-toepassingen. De bibliotheek biedt ondersteuning voor verschillende functies met betrekking tot het beheer van polygoonmesh, zoals het laden van een polygoonmesh uit een bestand, het creëren van een polygoonmesh, het converteren van alle polygonen naar driehoeken in een 3D-model, het exporteren van de polygoonmesh naar een bestand, en nog veel meer. Het volgende voorbeeld laat zien hoe gebruikers een polygoonmesh kunnen maken door een Mesh-object te creëren en er vertices en faces aan toe te voegen.

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