Python API för att skapa, redigera och konvertera 3D-modeller

Komma igång med Aspose.3D för Python via .NET

Det enklaste sättet att installera Aspose.3D för Python via .NET stabil version är att använda pip. Använd följande kommando för en smidig installation.

pip install aspose-3d 

Generera och ladda 3D-scen via Python API

Aspose.3D för Python via .NET har inkluderat fullständigt stöd för att skapa nya 3D-scener från grunden och sedan spara dem i vilket stödformat som helst med Python-kommandon. Biblioteket erbjuder också stöd för att läsa befintliga 3D-scener, göra ändringar i befintliga 3D, spara en 3D-scen i PDF, öppna befintliga scener från ett lösenordsskyddat PDF, upptäcka ett filformat, extrahera 3D-innehåll från en PDF-fil, ställa in laddningsalternativ innan en 3D Obj-fil laddas och mycket 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-scen via Python API

Aspose.3D för Python via .NET gör det möjligt för mjukvaruutvecklare att ladda och rendera 3D-scener i sina egna Python-applikationer. Biblioteket stödjer högkvalitativ rendering av 3D-scener, inklusive kantutjämning, skärpedjup, rörelseoskärpa och mer. Det stödjer också import och export av olika 3D-filformat, inklusive FBX, OBJ, STL och 3DS. Detta innebär att du enkelt kan importera befintliga 3D-modeller till din scen eller exportera din 3D-scen till ett kompatibelt format. Det stödjer funktioner som kastande och mottagande skuggor på 3D-geometrier, hårdvarubaserad rendering av 3D-geometri, rendering av 3D-vy i bildformat från kameran, rendering av ett Panorama‑vy av 3D-scenen, och så vidare. Följande kodexempel visar hur mjukvaruutvecklare kan rendera ett Panorama‑vy av en 3D-scen och spara i bildformat.

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)

Arbeta med animation i 3D-dokument

Aspose.3D för Python via .NET möjliggör för mjukvaruutvecklare att skapa och arbeta med animationer i 3D-dokument med hjälp av Python-biblioteket. Biblioteket innehåller många funktioner för att arbeta med animationer, såsom rendering av den animerade scenen, konfigurering av målkameran i en 3D-fil, skapande av skelettanimationer, arbete med morph-mål och blandning av flera animationer. Följande exempel visar hur man skapar en enkel animation med Python-kommandon.

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)

Arbeta med polygoner med Python API

Aspose.3D för Python via .NET gör det möjligt för mjukvaruutvecklare att lägga till och hantera polygonnät i sina 3D-modeller i Python-applikationer. Biblioteket har stöd för olika funktioner relaterade till hantering av polygonnät, såsom att läsa in ett polygonnät från en fil, skapa ett polygonnät, konvertera alla polygoner till trianglar i en 3D-modell, exportera polygonnätet till en fil och mycket mer. Följande exempel visar hur användare kan skapa ett polygonnät genom att skapa ett Mesh-objekt och lägga till vertexar och ytor 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)