Python API kurti, redaguoti ir konvertuoti 3D modelius

Pradžia su Aspose.3D for Python per .NET

Lengviausias būdas įdiegti Aspose.3D for Python via .NET stabilųjį leidimą yra naudojant pip. Prašome naudoti šią komandą sklandžiam diegimui.

pip install aspose-3d 

Generuoti ir įkelti 3D sceną per Python API

Aspose.3D for Python via .NET įtraukė visapusišką palaikymą kuriant naujas 3D scenas nuo nulio ir tada išsaugant jas bet kuriame palaikomame failo formate naudojant Python komandas. Biblioteka taip pat suteikia palaikymą skaityti esamas 3D scenas, atlikti pakeitimus esamoms 3D scenoms, išsaugoti 3D sceną PDF formatu, atverti esamas scenas iš slaptažodžiu apsaugoto PDF, nustatyti failo formatą, išgauti 3D turinį iš PDF failo, nustatyti įkėlimo parinktis prieš įkeliant 3D Obj failą ir daugelį kitų.

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 scenos atvaizdavimas per Python API

Aspose.3D for Python via .NET suteikia programinės įrangos kūrėjams galimybę įkelti ir atvaizduoti 3D scenas savo Python programose. Biblioteka palaiko aukštos kokybės 3D scenų atvaizdavimą, įskaitant anti‑aliasingą, gylio lauko efektą, judesio suliejimą ir kt. Ji taip pat palaiko įvairių 3D failų formatų importavimą ir eksportavimą, įskaitant FBX, OBJ, STL ir 3DS. Tai reiškia, kad galite lengvai importuoti esamus 3D modelius į savo sceną arba eksportuoti 3D sceną į suderinamą formatą. Biblioteka palaiko tokias funkcijas kaip šešėlių kritimas ir priėmimas 3D geometrijose, aparatūrinis 3D geometrijų atvaizdavimas, 3D vaizdo atvaizdavimas paveikslėlio formatu iš kameros, panoraminio 3D scenos vaizdo atvaizdavimas ir t.t. Toliau pateiktas kodo pavyzdys rodo, kaip programinės įrangos kūrėjai gali atvaizduoti panoraminį 3D scenos vaizdą ir išsaugoti jį paveikslėlio formatu.

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)

Darbas su animacija 3D dokumente

Aspose.3D for Python via .NET suteikia galimybę programinės įrangos kūrėjams kurti ir dirbti su animacijomis 3D dokumentuose naudojant Python biblioteką. Biblioteka apima daugybę funkcijų darbui su animacijomis, tokių kaip animuotos scenos atvaizdavimas, tikslinės kameros nustatymas 3D faile, skeletinių animacijų kūrimas, darbai su morfiniais tikslais ir kelių animacijų suliejimas. Žemiau pateiktas pavyzdys demonstruoja, kaip sukurti paprastą animaciją naudojant Python komandas.

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)

Darbas su daugiakampiais naudojant Python API

Aspose.3D for Python via .NET leidžia programinės įrangos kūrėjams pridėti ir valdyti poligonų tinklus savo 3D modeliuose Python programose. Biblioteka suteikia palaikymą įvairioms funkcijoms, susijusioms su poligonų tinklų valdymu, tokioms kaip poligonų tinklo įkėlimas iš failo, poligonų tinklo kūrimas, visų daugiakampių konvertavimas į trikampius 3D modelyje, poligonų tinklo eksportavimas į failą ir daugelis kitų. Žemiau pateiktas pavyzdys rodo, kaip naudotojai gali sukurti poligonų tinklą sukuriant Mesh objektą ir pridedant viršūnes bei veidus.

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