Aspose.3D FOSS
Python
PolygonModifier

PolygonModifier — Aspose.3D Python API Reference

Paket: aspose.threed.entities (aspose-3d-foss 26.1.0)

PolygonModifier ist eine statische Hilfsklasse, die Polygon‑Tessellationsoperationen auf Mesh und Scene Objekten. Alle Methoden sind Klassenmethoden; PolygonModifier wird nie direkt instanziiert.

from aspose.threed.entities import PolygonModifier

Die Hauptoperation ist die Triangulation: Umwandlung von Vierecken und N‑Gons in Dreiecke mittels Ear‑Clipping. Dies ist erforderlich, bevor in Formate exportiert wird, die nur Dreiecksgeometrie akzeptieren (STL, einige glTF‑Pipelines).

Methods

triangulate(arg) — trianguliere ein Mesh

Gibt ein neues Mesh in dem jedes Polygon in Dreiecke umgewandelt wurde. Das ursprüngliche Mesh wird nicht verändert. Vertex‑Elementebenen (Normalen, UVs, Farben) werden in das neue Mesh kopiert.

@staticmethod
def triangulate(mesh: Mesh) -> Mesh
MethodsMethodsMethods
meshMeshDas Quell‑Mesh, das trianguliert werden soll.

Rückgabe: Mesh — ein neues Mesh, das nur Dreiecks-Polygone enthält.

from aspose.threed.entities import Mesh, PolygonModifier
from aspose.threed.utilities import Vector4

mesh = Mesh()
for x, z in [(0, 0), (1, 0), (1, 1), (0, 1)]:
    mesh.control_points.append(Vector4(float(x), 0.0, float(z), 1.0))
mesh.create_polygon(0, 1, 2, 3)   # one quad

tri_mesh = PolygonModifier.triangulate(mesh)
print(tri_mesh.polygon_count)     # 2

triangulate(scene) — trianguliere alle Meshes in einem Scene

Durchlaufe den gesamten Szenengraphen und trianguliere jedes Mesh Entität an Ort und Stelle. Nach diesem Aufruf gibt es in der Szene keine Nicht-Dreiecks-Polygone mehr.

@staticmethod
def triangulate(scene: Scene) -> None
MethodsMethodsMethods
sceneSceneDie Szene, deren Mesh-Entitäten trianguliert werden.

Rückgabe: None

from aspose.threed import Scene
from aspose.threed.entities import PolygonModifier

scene = Scene.from_file("model_with_quads.obj")
PolygonModifier.triangulate(scene)
scene.save("model_triangulated.stl")

triangulate(control_points, polygon) — trianguliere ein einzelnes Polygon

Low‑Level‑Überladung: Gibt eine Liste von Kontrollpunkten und eine Liste von Vertex‑Indizes, die ein Polygon bilden, zurück und liefert eine Liste von Dreieck‑Index‑Tripeln, die durch Fächer‑Triangulation erzeugt werden.

@staticmethod
def triangulate(
    control_points: list[Vector4],
    polygon: list[int],
) -> list[list[int]]
MethodsMethodsMethods
control_pointslist[Vector4]Das vollständige Vertex-Positions-Array.
polygonlist[int]Indizes in control_points Definieren des zu teilenden Polygons.

Rückgabe: list[list[int]] — eine Liste von [i, j, k] Triplets, die jeweils ein Ausgabedreieck darstellen.

from aspose.threed.entities import PolygonModifier
from aspose.threed.utilities import Vector4

pts = [
    Vector4(0.0, 0.0, 0.0, 1.0),
    Vector4(1.0, 0.0, 0.0, 1.0),
    Vector4(1.0, 1.0, 0.0, 1.0),
    Vector4(0.0, 1.0, 0.0, 1.0),
]
quad_indices = [0, 1, 2, 3]
triangles = PolygonModifier.triangulate(pts, quad_indices)
print(triangles)   # e.g. [[0, 1, 2], [0, 2, 3]]

triangulate(control_points, polygons, generate_normals, normals_out) — Batch-Triangulation mit optionaler Normalenerzeugung

Batch-trianguliere eine Liste von Polygon-Indexlisten. Optional werden Flächennormalen für jedes Ausgabedreieck berechnet und an normals_out.

@staticmethod
def triangulate(
    control_points: list[Vector4],
    polygons: list[list[int]],
    generate_normals: bool = False,
    normals_out: list[Vector3] | None = None,
) -> list[list[int]]
MethodsMethodsMethods
control_pointslist[Vector4]das Vertex-Positionsarray angehängt.
polygonslist[list[int]]Eine Liste von Polygondefinitionen, jeweils eine Liste von Vertex-Indizes.
generate_normalsboolMethods True, berechne eine Flächennormale für jedes Ausgabedreieck.
normals_out`list[Vector3]None`

Rückgabe: list[list[int]] — alle ausgegebenen Dreieckstripletts in Reihenfolge.

from aspose.threed.entities import PolygonModifier
from aspose.threed.utilities import Vector4, Vector3

pts = [
    Vector4(0, 0, 0, 1), Vector4(1, 0, 0, 1),
    Vector4(1, 1, 0, 1), Vector4(0, 1, 0, 1),
]
polys = [[0, 1, 2, 3]]
normals: list[Vector3] = []
tris = PolygonModifier.triangulate(pts, polys, True, normals)
print(len(tris))     # 2
print(len(normals))  # 2

Siehe auch

 Deutsch