PolygonModifier

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

PolygonModifier est une classe utilitaire statique qui fournit des opérations de tessellation de polygones sur Mesh et Scene objets. Toutes les méthodes sont des méthodes de classe ; PolygonModifier n’est jamais instanciée directement.

from aspose.threed.entities import PolygonModifier

L’opération principale est la triangulation : convertir les quadrilatères et les n‑gones en triangles en utilisant la méthode de découpage par oreilles. Cela est nécessaire avant d’exporter vers des formats qui n’acceptent que de la géométrie triangulaire (STL, certains pipelines glTF).

Methods

triangulate(arg) — trianguler un Mesh

Renvoie un nouveau Mesh dans lequel chaque polygone a été converti en triangles. Le maillage original n’est pas modifié. Les couches d’éléments de sommet (normales, UV, couleurs) sont copiées dans le nouveau maillage.

@staticmethod
def triangulate(mesh: Mesh) -> Mesh

Renvoie : Mesh — un nouveau maillage contenant uniquement des polygones triangulaires.

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) — trianguler tous les maillages dans un Scene

Parcourir l’ensemble du graphe de scène et trianguler chaque Mesh entité sur place. Après cet appel, aucun polygone non triangulaire ne reste dans la scène.

@staticmethod
def triangulate(scene: Scene) -> None

Renvoie : 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 un seul polygone

Surcharge bas‑niveau : étant donné une liste de points de contrôle et une liste d’indices de sommets formant un polygone, renvoie une liste de triplets d’indices de triangles produits par triangulation en éventail.

@staticmethod
def triangulate(
    control_points: list[Vector4],
    polygon: list[int],
) -> list[list[int]]

Renvoie : list[list[int]] — une liste de [i, j, k] triplets, chacun représentant un triangle de sortie.

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) — triangulation par lots avec génération optionnelle de normales

Trianguler par lots une liste de listes d’indices de polygones. Optionnellement calculer les normales de face pour chaque triangle de sortie et les ajouter à 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]]

Renvoie: list[list[int]] — tous les triplets de triangles en sortie dans l’ordre.

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

Voir aussi

• Référence de la classe Mesh
• Référence de la classe Scene