Python‑API 3D‑mallien luomiseen, muokkaamiseen ja muuntamiseen

Aloittaminen Aspose.3D for Python via .NET

Helpoin tapa asentaa Aspose.3D for Python via .NET vakaa julkaisu on käyttää pipiä. Käytä seuraavaa komentoa sujuvaa asennusta varten.

pip install aspose-3d 

Luo ja lataa 3D‑kohtaus Python‑API:n avulla

Aspose.3D for Python via .NET on sisällyttänyt täyden tuen uusien 3D‑kohtauksien luomiseen alusta alkaen ja niiden tallentamiseen mihin tahansa tuettuun tiedostomuotoon Python‑komentojen avulla. Kirjasto tarjoaa myös tuen olemassa olevien 3D‑kohtauksien lukemiseen, muutosten tekemiseen olemassa olevaan 3D‑sisältöön, 3D‑kohtauksen tallentamiseen PDF‑tiedostoon, salasanasuojattujen PDF‑tiedostojen olemassa olevien kohtauksien avaamiseen, tiedostomuodon tunnistamiseen, 3D‑sisällön poimimiseen PDF‑tiedostosta, latausasetusten asettamiseen ennen 3D‑Obj‑tiedoston lataamista ja moniin muihin toimintoihin.

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‑kohtauksen renderöinti Python‑API:n avulla

Aspose.3D for Python via .NET mahdollistaa ohjelmistokehittäjille 3D‑kohtauksien lataamisen ja renderöinnin omissa Python‑sovelluksissa. Kirjasto tukee korkealaatuista 3D‑kohtauksien renderöintiä, mukaan lukien anti‑aliasointi, syväterävyys, liike‑epäterävyys ja paljon muuta. Se tukee myös erilaisten 3D‑tiedostomuotojen tuontia ja vientiä, kuten FBX, OBJ, STL ja 3DS. Tämä tarkoittaa, että voit helposti tuoda olemassa olevia 3D‑malleja kohtaukseesi tai viedä 3D‑kohtauksesi yhteensopivaan formaattiin. Se tukee ominaisuuksia kuten varjojen heittäminen ja vastaanottaminen 3D‑geometriassa, laitteistopohjaista 3D‑geometrian renderöintiä, 3D‑näkymän renderöintiä kuvatiedostona kamerasta, 3D‑kohtauksen panoramaanäkymän renderöintiä jne. Seuraava koodiesimerkki näyttää, miten ohjelmistokehittäjät voivat renderöidä 3D‑kohtauksen panoramaanäkymän ja tallentaa sen kuvatiedostona.

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)

Työskentele animaation kanssa 3D-dokumentissa

Aspose.3D for Python via .NET mahdollistaa ohjelmistokehittäjien luoda ja työskennellä animaatioiden kanssa 3D-dokumenteissa Python-kirjaston avulla. Kirjasto sisältää lukuisia ominaisuuksia animaatioiden käsittelyyn, kuten animoidun kohtauksen renderöinnin, kohdekameran asettamisen 3D-tiedostossa, luurankoanimaatioiden luomisen, morph-tavoitteiden kanssa työskentelyn ja useiden animaatioiden sekoittamisen. Seuraava esimerkki näyttää, miten luodaan yksinkertainen animaatio Python-komentoja käyttäen.

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)

Työskentele monikulmioiden kanssa Python‑API:n avulla

Aspose.3D for Python via .NET mahdollistaa ohjelmistokehittäjien lisätä ja hallita polygoniverkkoja 3D-malleissaan Python-sovelluksissa. Kirjasto tukee erilaisia ominaisuuksia, jotka liittyvät polygoniverkkojen hallintaan, kuten polygoniverkon lataamista tiedostosta, polygoniverkon luomista, kaikkien polygonien muuntamista kolmioiksi 3D-mallissa, polygoniverkon viemistä tiedostoon ja monia muita. Seuraava esimerkki näyttää, miten käyttäjät voivat luoda polygoniverkon luomalla Mesh-objektin ja lisäämällä siihen kärkiä ja pintoja.

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