PolygonModifier — Aspose.3D Python API Reference

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

PolygonModifier es una clase de utilidad estática que proporciona operaciones de teselado de polígonos en Mesh y Scene objetos. Todos los métodos son métodos de clase; PolygonModifier nunca se instancia directamente.

from aspose.threed.entities import PolygonModifier

La operación principal es la triangulación: convertir cuádruplos y n‑gones en triángulos utilizando ear‑clipping. Esto es necesario antes de exportar a formatos que aceptan solo geometría triangular (STL, algunas canalizaciones glTF).

triangulate(arg) — triangular un Mesh

Devuelve un nuevo Mesh en el que cada polígono ha sido convertido en triángulos. La malla original no se modifica. Las capas de elementos de vértice (normales, UVs, colores) se copian a la nueva malla.

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

Devuelve: Mesh — una malla nueva que contiene solo polígonos triangulares.

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) — triangular todas las mallas en una Scene

Recorre todo el grafo de escena y triangula cada Mesh entidad en su lugar. Después de esta llamada, no quedan polígonos que no sean triángulos en la escena.

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

Devuelve: 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) — triangular un único polígono

Sobrecarga de bajo nivel: dado una lista de puntos de control y una lista de índices de vértices que forman un polígono, devuelve una lista de tríos de índices de triángulos producidos por triangulación en abanico.

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

Devuelve: list[list[int]] — una lista de [i, j, k] tripletes, cada uno representando un triángulo de salida.

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) — triangulación por lotes con generación opcional de normales

Triangular por lotes una lista de listas de índices de polígonos. Opcionalmente calcula normales de cara para cada triángulo de salida y los agrega a 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]]

Devuelve: list[list[int]] — todos los tripletes de triángulo de salida en orden.

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

Ver también

• Referencia de la clase Mesh
• Referencia de la clase Scene
• Referencia de la clase VertexElement