API של Python ליצירה, עריכה והמרת מודלים תלת‑ממדיים

התחלה עם Aspose.3D עבור Python באמצעות .NET

הדרך הקלה ביותר להתקנת Aspose.3D for Python via .NET גרסה יציבה היא באמצעות pip. אנא השתמשו בפקודה הבאה להתקנה חלקה.

pip install aspose-3d 

יצירת וטעינת סצנת 3D באמצעות API של Python

Aspose.3D for Python via .NET כולל תמיכה מלאה ביצירת סצנות תלת‑ממד חדשות מאפס ולאחר מכן שמירתן בכל פורמט קובץ נתמך באמצעות פקודות Python. הספרייה גם מספקת תמיכה בקריאת סצנות תלת‑ממד קיימות, ביצוע שינויים בתלת‑ממד קיים, שמירת סצנת תלת‑ממד ב‑PDF, פתיחת סצנות קיימות מ‑PDF מוגן בסיסמה, זיהוי פורמט קובץ, חילוץ תוכן תלת‑ממד מקובץ PDF, הגדרת אפשרויות טעינה לפני טעינת קובץ Obj תלת‑ממד ועוד רבים.

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 באמצעות API של Python

Aspose.3D עבור Python דרך .NET מאפשר למפתחי תוכנה לטעון ולרנדר סצנות תלת‑ממד בתוך יישומי Python שלהם. הספרייה תומכת ברינדור באיכות גבוהה של סצנות תלת‑ממד, כולל אנטי‑אליאסינג, עומק שדה, טשטוש תנועה ועוד. היא גם תומכת בייבוא וייצוא של פורמטים שונים של קבצי תלת‑ממד, כולל FBX, OBJ, STL ו‑3DS. משמעות הדבר היא שניתן בקלות לייבא מודלים תלת‑ממדיים קיימים לסצנה שלך או לייצא את סצנת התלת‑ממד לפורמט תואם. היא תומכת בתכונות כגון הטלת וקבלת צללים על גאומטריות תלת‑ממד, רינדור מבוסס חומרה של גאומטריית תלת‑ממד, רינדור תצוגת תלת‑ממד בפורמט תמונה מהמצלמה, רינדור תצוגת פנורמה של סצנת התלת‑ממד, וכן הלאה. דוגמת הקוד שלהלן מראה כיצד מפתחי תוכנה יכולים לרנדר תצוגת פנורמה של סצנת תלת‑ממד ולשמור אותה בפורמט תמונה.

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)

עבודה עם אנימציה במסמך 3D

Aspose.3D עבור Python דרך .NET מאפשר למפתחים ליצור ולעבוד עם אנימציות בתוך מסמכי 3D באמצעות ספריית Python. הספרייה כוללת תכונות רבות לעבודה עם אנימציות, כגון רינדור הסצנה המונפשת, הגדרת מצלמת היעד בקובץ 3D, יצירת אנימציות שלד, עבודה עם מטרות מורף, וערבוב של כמה אנימציות. הדוגמה הבאה מציגה כיצד ליצור אנימציה פשוטה באמצעות פקודות 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)

עבודה עם פוליגונים באמצעות API של Python

Aspose.3D עבור Python דרך .NET מאפשר למפתחים להוסיף ולנהל רשתות פוליגון במודלים תלת‑ממדיים שלהם בתוך יישומי Python. הספרייה כוללת תמיכה במגוון תכונות הקשורות לניהול רשתות פוליגון, כגון טעינת רשת פוליגון מקובץ, יצירת רשת פוליגון, המרת כל הפוליגונים למשולשים במודל 3D, ייצוא רשת הפוליגון לקובץ, ועוד רבים. הדוגמה הבאה מציגה כיצד משתמשים יכולים ליצור רשת פוליגון על‑ידי יצירת אובייקט Mesh והוספת קודקודים ופאות אליו.

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