Aspose.3D FOSS
Python
PolygonModifier

PolygonModifier

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

PolygonModifier és una classe d’utilitat estàtica que proporciona operacions de tessellació de polígons sobre Mesh i Scene objectes. Tots els mètodes són mètodes de classe; PolygonModifier mai s’instancia directament.

from aspose.threed.entities import PolygonModifier

L’operació principal és la triangulació: convertir quads i n‑gons en triangles mitjançant el mètode ear‑clipping. Això és necessari abans d’exportar a formats que accepten només geometria triangular (STL, algunes pipelines glTF).

Methods

triangulate(arg) — triangula un Mesh

Retorna un nou Mesh en què cada polígon s’ha convertit en triangles. La malla original no es modifica. Les capes d’elements de vèrtex (normals, UVs, colors) es copien a la nova malla.

@staticmethod
def triangulate(mesh: Mesh) -> Mesh
MethodsMethodsMethods
meshMeshLa malla d’origen a tessellar.

Retorna: Mesh — una nova malla que conté només polígons triangulars.

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) — triangula totes les malles en una Scene

Recorre tot el graf de l’escena i triangula cada Mesh entitat in situ. Després d’aquesta crida, no queden polígons que no siguin triangles a l’escena.

@staticmethod
def triangulate(scene: Scene) -> None
MethodsMethodsMethods
sceneSceneL’escena les entitats de malla de la qual seran triangulades.

Retorna: 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) — triangula un únic polígon

Sobrecàrrega de baix nivell: donada una llista de punts de control i una llista d’índexs de vèrtex que formen un polígon, retorna una llista de tríades d’índexs de triangles produïda per la triangulació en forma de fan.

@staticmethod
def triangulate(
    control_points: list[Vector4],
    polygon: list[int],
) -> list[list[int]]
MethodsMethodsMethods
control_pointslist[Vector4]La matriu completa de posicions dels vèrtexs.
polygonlist[int]Índexs a control_points definint el polígon a dividir.

Retorna: list[list[int]] — una llista de [i, j, k] triplets, cadascuna representant un triangle de sortida.

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ó per lots amb generació opcional de normals

Triangula per lots una llista de llistes d’índexs de polígon. Opcionalment calcula les normals de cara per a cada triangle de sortida i les afegeix 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]]
MethodsMethodsMethods
control_pointslist[Vector4]L’array de posicions dels vèrtexs.
polygonslist[list[int]]Una llista de definicions de polígon, cada una una llista d’índexs de vèrtex.
generate_normalsboolMethods True, calcula una normal de cara per a cada triangle de sortida.
normals_out`list[Vector3]None`

Retorna: list[list[int]] — tots els triplets de triangle de sortida en 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

Vegeu també

 Català