Python‑API for å opprette, redigere og konvertere 3D‑modeller

Kom i gang med Aspose.3D for Python via .NET

Den enkleste måten å installere Aspose.3D for Python via .NET stabil versjon på er å bruke pip. Vennligst bruk følgende kommando for en smidig installasjon.

pip install aspose-3d 

Generer og last inn 3D-scene via Python API

Aspose.3D for Python via .NET har inkludert full støtte for å lage nye 3D‑scener fra bunnen av og deretter lagre dem i ethvert støttet filformat ved hjelp av Python‑kommandoer. Biblioteket gir også støtte for å lese eksisterende 3D‑scener, gjøre endringer i eksisterende 3D, lagre en 3D‑scene i PDF, åpne eksisterende scener fra en passordbeskyttet PDF, oppdage filformat, hente ut 3D‑innhold fra en PDF‑fil, sette innlastingsalternativer før innlasting av en 3D‑Obj‑fil og mye mer.

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 av 3D-scene via Python API

Aspose.3D for Python via .NET gjør det mulig for programvareutviklere å laste inn og gjengi 3D‑scener i sine egne Python‑applikasjoner. Biblioteket støtter høy‑kvalitets rendering av 3D‑scener, inkludert anti‑aliasing, dybdeskarphet, bevegelsesuskarphet og mer. Det støtter også import og eksport av ulike 3D‑filformater, inkludert FBX, OBJ, STL og 3DS. Dette betyr at du enkelt kan importere eksisterende 3D‑modeller inn i scenen din eller eksportere 3D‑scenen til et kompatibelt format. Det støtter funksjoner som kast‑ og mottaksskygger på 3D‑geometrier, maskinvarebasert rendering av 3D‑geometri, rendering av 3D‑visning i bildeformat fra kameraet, rendering av et panoramabilde av 3D‑scenen, og så videre. Følgende kodeeksempel viser hvordan programvareutviklere kan gjengi et panoramabilde av en 3D‑scene og lagre det i bildeformat.

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)

Arbeid med animasjon i 3D-dokument

Aspose.3D for Python via .NET gjør det mulig for programvareutviklere å opprette og arbeide med animasjoner i 3D-dokumenter ved hjelp av Python-biblioteket. Biblioteket inneholder mange funksjoner for å jobbe med animasjoner, som å gjengi den animerte scenen, sette opp mål‑kameraet i en 3D‑fil, lage skjelettanimasjoner, arbeide med morph‑mål og blande flere animasjoner. Følgende eksempel viser hvordan du kan lage en enkel animasjon ved hjelp av Python‑kommandoer.

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)

Arbeid med polygoner ved hjelp av Python API

Aspose.3D for Python via .NET gjør det mulig for programvareutviklere å legge til og administrere polygonnett i sine 3D-modeller i Python‑applikasjoner. Biblioteket har støtte for ulike funksjoner knyttet til håndtering av polygonnett, som å laste inn et polygonnett fra en fil, opprette et polygonnett, konvertere alle polygoner til trekanter i en 3D‑modell, eksportere polygonnettet til en fil, og mye mer. Følgende eksempel viser hvordan brukere kan opprette et polygonnett ved å opprette et Mesh‑objekt og legge til vertikser og flater i det.

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