Aspose.3D FOSS
Python
PolygonModifier

PolygonModifier — Aspose.3D Python API Reference

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 quàders i n‑gons en triangles mitjançant la tècnica d’ear‑clipping. Això és necessari abans d’exportar a formats que només accepten geometria de triangles (STL, alguns fluxos de treball glTF).

Methods

triangulate(arg) — triangula un Mesh

Retorna un nou Mesh en el qual cada polígon ha estat 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 triangular.

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()
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 quedaran polígons que no siguin triangles a l’escena.

@staticmethod
def triangulate(scene: Scene) -> None
MethodsMethodsMethods
sceneSceneL’escena les entitats de malla que 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 d’ala.

@staticmethod
def triangulate(
    control_points: list[Vector4],
    polygon: list[int],
) -> list[list[int]]
MethodsMethodsMethods
control_pointslist[Vector4]L’array complet de posicions de vèrtex.
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à