Aspose.3D FOSS
Python
PolygonModifier

PolygonModifier — Aspose.3D Python API Reference

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

PolygonModifier er en statisk verktøyklasse som gir polygon-tessellasjonsoperasjoner på Mesh og Scene objekter. Alle metoder er klassemetoder; PolygonModifier instansieres aldri direkte.

from aspose.threed.entities import PolygonModifier

Hovedoperasjonen er triangulering: konvertering av firkanter og n‑goner til trekanter ved hjelp av ear‑clipping. Dette er nødvendig før eksport til formater som kun godtar trekantgeometri (STL, noen glTF‑pipelines).

triangulate(arg) — trianguler en Mesh

Returner en ny Mesh hvor hver polygon er konvertert til trekanter. Det opprinnelige mesh er ikke endret. Vertex element layers (normals, UVs, colours) kopieres til det nye mesh.

@staticmethod
def triangulate(mesh: Mesh) -> Mesh
meshMeshKildemeshen som skal trianguleres.

Returnerer: Mesh — et nytt mesh som kun inneholder trekantpolygoner.

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) — trianguler alle mesh i en Scene

Traverser hele scenegrafen og trianguler hver Mesh entitet på stedet. Etter dette kallet er det ingen ikke-trekant-polygoner igjen i scenen.

@staticmethod
def triangulate(scene: Scene) -> None
sceneSceneScenen hvis mesh-entiteter vil bli triangulert.

Returnerer: 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) — trianguler en enkelt polygon

Lavnivå‑overlasting: gitt en liste med kontrollpunkter og en liste med vertex‑indekser som danner én polygon, returneres en liste med trekant‑indeks‑tripletter produsert ved fan‑triangulering.

@staticmethod
def triangulate(
    control_points: list[Vector4],
    polygon: list[int],
) -> list[list[int]]
control_pointslist[Vector4]Den fullstendige vertex‑posisjonsarrayen.
polygonlist[int]Indekser til control_points som definerer polygonet som skal splittes.

Returnerer: list[list[int]] — en liste over [i, j, k] tripletter, hver som representerer en utdata‑triangel.

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‑triangulering med valgfri normalgenerering

Batch-trianguler en liste med polygon‑indeks‑lister. Beregn eventuelt flate‑normaler for hver utdata‑triangel og legg dem til 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]]
control_pointslist[Vector4]Vertex‑posisjonsarrayen.
polygonslist[list[int]]En liste med polygon‑definisjoner, hver en liste med vertex‑indekser.
generate_normalsbool
True, beregn en flate‑normal for hver utdata‑triangel.
normals_out`list[Vector3]None`

Returnerer: list[list[int]] — alle utdata‑triangeltripletter i rekkefølge.

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

Se også

 Norsk