Aspose.3D FOSS
Python
PolygonModifier

PolygonModifier

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

PolygonModifier ist eine statische Hilfsklasse, die Polygon‑Tessellationsoperationen auf Mesh und Scene Objekten bereitstellt. 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()
# Use _control_points to mutate the backing list (control_points returns a copy)
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 bleiben im Szenen 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, liefert eine Liste von Dreieck‑Index‑Tripeln, die durch Fan‑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] Tripeln, von denen jedes ein Ausgabedreieck darstellt.

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 triangulate mit optionaler Normalenerzeugung

Batch-triangulate eine Liste von Polygon-Indexlisten. Optional Flächennormalen für jedes Ausgabedreieck berechnen 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 anhängen.
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