API Python chun Cruthú, Eagarthóireacht & Tiontú Modail 3D

Ag tosú le Aspose.3D le haghaidh Python trí .NET

Is é an bealach is éasca chun Aspose.3D do Python trí .NET le scaoileadh cobhsaí a shuiteáil ná trí pip. Úsáid an t-ordú seo a leanas le haghaidh suiteála réidh.

pip install aspose-3d 

Gin & Luchtaigh Radharc 3D trí API Python

Aspose.3D do Python trí .NET tá tacaíocht iomlán ar fáil chun radhairc 3D nua a chruthú ón tús agus iad a shábháil i ngach formáid comhaid a dtacaítear leis trí orduithe Python. Soláthraíonn an leabharlann tacaíocht freisin chun radhairc 3D atá ann cheana a léamh, athruithe a dhéanamh ar 3D atá ann cheana, radharc 3D a shábháil sa PDF, radhairc atá ann cheana a oscailt ó PDF atá cosanta le pasfhocal, formáid comhaid a bhrath, ábhar 3D a bhaint as comhad PDF, roghanna luchtaithe a shocrú sula ndéantar comhad Obj 3D a luchtú agus go leor eile.

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)

Rindreáil Radharc 3D trí API Python

Aspose.3D do Python trí .NET cuireann sé ar chumas forbróirí bogearraí luchtú agus rindreáil radhairc 3D laistigh dá n-iarratais Python féin. Tacaíonn an leabharlann le rindreáil ardchaighdeáin de radhairc 3D, lena n-áirítear frith-ailias, doimhneacht réimse, smúit gluaiseachta, agus níos mó. Tacaíonn sé freisin le hiompórtáil agus easpórtáil formáidí comhad 3D éagsúla, lena n-áirítear FBX, OBJ, STL, agus 3DS. Ciallaíonn sé seo gur féidir leat modailí 3D atá ann cheana a iompórtáil go héasca isteach i do radharc nó do radharc 3D a easpórtáil go formáid comhoiriúnach. Tacaíonn sé le gnéithe mar scáthanna caite agus faighte ar gheometríochtaí 3D, rindreáil crua-earraí de gheometríocht 3D, rindreáil radhairc 3D i bhformáid íomhá ón cheamara, rindreáil radhairc Panorama den radharc 3D, agus mar sin de. Taispeánann an sampla cód thíos conas is féidir le forbróirí bogearraí rindreáil radharc Panorama de radharc 3D agus é a shábháil san fhormáid íomhá.

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)

Oibriú le Beochan i dCáipéis 3D

Aspose.3D do Python trí .NET cuireann ar chumas forbróirí bogearraí cruthú agus obair le beochan laistigh de cháipéisí 3D ag baint úsáide as an leabharlann Python. Tá neart gnéithe sa leabharlann le haghaidh oibriú le beochan, mar shampla rindreáil an radhairc bheo, socrú an cheamara sprioc i gcomhad 3D, cruthú beochan cnámharacha, obair le spriocanna morf, agus meascadh iomaí beochan. Léiríonn an sampla thíos conas beochan shimplí a chruthú ag baint úsáide as orduithe Python.

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)

Oibriú le Polagáin ag baint úsáide as API Python

Aspose.3D do Python trí .NET cumasaíonn sé forbróirí bogearraí polagáin a chur leis agus a bhainistiú ina mhiotais polagán ina mhúnlaí 3D laistigh de fheidhmchláir Python. Tá tacaíocht sa leabharlann le haghaidh gnéithe éagsúla a bhaineann le bainistíocht mhíotach polagán, mar shampla luchtú míotach polagán ó chomhad, cruthú míotach polagán, tiontú gach polagán go triantáin i mhúnla 3D, easpórtáil an mhíotach polagán go comhad, agus go leor eile. Léiríonn an sampla thíos conas is féidir le húsáideoirí míotach polagán a chruthú trí réad Mesh a chruthú agus nódanna agus aghaidh a chur leis.

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