Python API til at oprette, redigere og konvertere 3D-modeller

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

Den nemmeste måde at installere Aspose.3D for Python via .NET stabil version er ved at bruge pip. Brug venligst følgende kommando for en problemfri installation.

pip install aspose-3d 

Generer & indlæs 3D-scene via Python API

Aspose.3D for Python via .NET har inkluderet fuld support til at oprette nye 3D-scener fra bunden og derefter gemme dem i ethvert understøttet filformat ved hjælp af Python-kommandoer. Biblioteket giver også support til at læse eksisterende 3D-scener, foretage ændringer i eksisterende 3D, gemme en 3D-scene i PDF, åbne eksisterende scener fra en adgangskodebeskyttet PDF, opdage et filformat, udtrække 3D-indhold fra en PDF-fil, indstille indlæsningsindstillinger før indlæsning af en 3D Obj-fil og meget mere.

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)

3D-scene rendering via Python API

Aspose.3D for Python via .NET gør det muligt for softwareudviklere at indlæse og gengive 3D-scener i deres egne Python-applikationer. Biblioteket understøtter høj kvalitet rendering af 3D-scener, herunder anti-aliasing, dybdeskarphed, bevægelsessløring og mere. Det understøtter også import og eksport af forskellige 3D-filformater, herunder FBX, OBJ, STL og 3DS. Det betyder, at du nemt kan importere eksisterende 3D-modeller til din scene eller eksportere din 3D-scene til et kompatibelt format. Det understøtter funktioner som kastende og modtagende skygger på 3D-geometrier, hardwarebaseret rendering af 3D-geometri, rendering af 3D-visning i billedformat fra kameraet, rendering af en panorama-visning af 3D-scenen osv. Følgende kodeeksempel viser, hvordan softwareudviklere kan gengive en panorama-visning af en 3D-scene og gemme den i billedformat.

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)

Arbejd med animation i 3D-dokument

Aspose.3D for Python via .NET giver softwareudviklere mulighed for at oprette og arbejde med animationer i 3D-dokumenter ved hjælp af Python-biblioteket. Biblioteket indeholder adskillige funktioner til at arbejde med animationer, såsom at gengive den animerede scene, opsætte mål‑kameraet i en 3D‑fil, oprette skeletanimationer, arbejde med morph‑mål og blande flere animationer. Følgende eksempel demonstrerer, hvordan man opretter en simpel animation ved hjælp af 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)

Arbejd med polygoner ved hjælp af Python API

Aspose.3D for Python via .NET gør det muligt for softwareudviklere at tilføje og administrere polygon‑meshes i deres 3D‑modeller i Python‑applikationer. Biblioteket indeholder understøttelse af forskellige funktioner relateret til håndtering af polygon‑meshes, såsom indlæsning af en polygon‑mesh fra en fil, oprettelse af en polygon‑mesh, konvertering af alle polygoner til trekanter i en 3D‑model, eksport af polygon‑meshen til en fil og meget mere. Følgende eksempel viser, hvordan brugere kan oprette en polygon‑mesh ved at oprette et Mesh‑objekt og tilføje vertex‑ og face‑data til 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)