Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh stochează geometria poligonului ca o listă de puncte de control (poziții ale vârfurilor) și o listă de fețe ale poligonului. Fiecare față a poligonului este o listă de indici zero‑bazati în matricea de puncte de control. Fețele pot fi triunghiuri, cvadrilaterale sau poligoane cu aritate mai mare. Date suplimentare pe vârf; normale, coordonate UV, culori ale vârfurilor; sunt atașate ca VertexElement straturi.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Construiește un mesh de triunghi unic de la zero:

from aspose.threed import Scene
from aspose.threed.entities import Mesh
from aspose.threed.utilities import Vector4

# Create the mesh and add three vertex positions
# IMPORTANT: control_points returns a copy of the internal list.
# Append to _control_points directly — appending to control_points discards the vertex.
# This is a known library limitation; a public mutation API does not yet exist.
mesh = Mesh()
mesh._control_points.append(Vector4(0.0, 0.0, 0.0, 1.0))   # vertex 0
mesh._control_points.append(Vector4(1.0, 0.0, 0.0, 1.0))   # vertex 1
mesh._control_points.append(Vector4(0.5, 1.0, 0.0, 1.0))   # vertex 2

# Define one triangle face using vertex indices
mesh.create_polygon(0, 1, 2)

# Attach to a scene and save
scene = Scene()
scene.root_node.create_child_node("triangle", mesh)
scene.save("triangle.stl")

Construiește un mesh de cvadrilaterale și triangulează-l înainte de export:

from aspose.threed import Scene
from aspose.threed.entities import Mesh
from aspose.threed.utilities import Vector4

mesh = Mesh()
# Four corners of a unit square in the XZ plane
# 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))

# One quad face
mesh.create_polygon(0, 1, 2, 3)
print(f"Polygons before triangulate: {mesh.polygon_count}")  # 1

triangulated = mesh.triangulate()
print(f"Polygons after triangulate: {triangulated.polygon_count}")  # 2

scene = Scene()
scene.root_node.create_child_node("quad", triangulated)
scene.save("quad.glb")

Methods

control_points, polygon_count, polygons, edges, și vertex_elements sunt toate proprietăți; accesați-le fără paranteze.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]citițiVector de poziții ale vârfului. Fiecare intrare este un Vector4(x, y, z, w) unde w este 1.0 pentru datele de poziție. Returnează o copie — nu adăuga la lista returnată. Folosește mesh._control_points.append(v) pentru a adăuga vârfuri (limitare cunoscută; API-ul public de mutație nu este încă disponibil).
polygon_countintcitireNumărul de fețe poligonale definite pe această plasă.
polygonslist[list[int]]citireToate definițiile fețelor ca o listă de liste de indici. Fiecare listă internă conține indicii vârfurilor (în control_points) pentru o față.
edgeslist[int]citireDate brute de indexare a muchiilor. În principal pentru utilizare internă și interogări avansate de topologie.
vertex_elementslist[VertexElement]citireToate straturile de elemente ale vârfurilor atașate în prezent acestui mesh (normale, UV-uri, culori etc.).
visibleboolcitire/scriereMethods False, mesh-ul este ascuns în vizualizatoare care respectă vizibilitatea.
cast_shadowsboolcitire/scriereDacă acest mesh proiectează umbre în randerele care suportă hărți de umbre.
receive_shadowsboolcitire/scriereDacă acest mesh primește umbre de la alte geometrii care proiectează umbre.

Methods

create_polygon(*indices)

Definește o nouă față poligonală furnizând indicii vârfurilor în ordine. Indicii fac referire la pozițiile în control_points. Acceptă trei sau mai mulți indici pentru triunghiuri, cvadrilaturi și n-gonuri.

MethodsMethodsMethods
*indicesintArgumentele de indexare a vârfurilor în ordine de înfășurare (de obicei în sens trigonometric când sunt privite din exterior).

Returnează: None

mesh = Mesh()
# ... populate control_points ...
mesh.create_polygon(0, 1, 2)       # triangle
mesh.create_polygon(0, 1, 2, 3)    # quad
print(mesh.polygon_count)          # 2

triangulate()

Returnează un nou Mesh unde fiecare poligon a fost împărțit în triunghiuri folosind triangulația tip fan. Mesh-ul original nu este modificat. Util înainte de exportarea în formate care necesită geometrie exclusiv triunghiulară (cum ar fi STL sau unele fluxuri glTF).

Returnează: Mesh; un mesh nou care conține doar triunghiuri.

from aspose.threed.entities import Mesh
from aspose.threed.utilities import Vector4

mesh = Mesh()
# Use _control_points to mutate the backing list (control_points returns a copy)
for v in [(0,0,0), (1,0,0), (1,1,0), (0,1,0)]:
    mesh._control_points.append(Vector4(*v, 1.0))
mesh.create_polygon(0, 1, 2, 3)   # one quad

tri_mesh = mesh.triangulate()
print(tri_mesh.polygon_count)      # 2

to_mesh()

Returnează acest Mesh ca un Mesh instanță. Pentru Mesh obiecte aceasta este o operație de identitate (returnează self). Definit pe Geometry clasa de bază pentru a oferi o interfață uniformă de conversie atunci când se lucrează cu generic Geometry referințe.

Returnează: Mesh

from aspose.threed.entities import Geometry

def ensure_mesh(geom: Geometry):
    return geom.to_mesh()

create_element(element_type, mapping_mode, reference_mode)

Adaugă un nou VertexElement strat de tipul specificat la mesh. Folosește-l pentru a atașa normale, tangente, binormale, culori de vârf și grupuri de netezire.

MethodsMethodsMethods
element_typeVertexElementTypeTipul de date pe care le conține acest strat (de exemplu,., VertexElementType.NORMAL).
mapping_modeMappingModeCum se mapază datele pe geometrie: CONTROL_POINT, POLYGON_VERTEX, POLYGON, etc.
reference_modeReferenceModeCum sunt utilizate indecșii: DIRECT sau INDEX_TO_DIRECT.

Returnează: VertexElement

from aspose.threed.entities import Mesh, VertexElementType, MappingMode, ReferenceMode
from aspose.threed.utilities import Vector4

mesh = Mesh()
# Use _control_points to mutate the backing list (control_points returns a copy)
mesh._control_points.append(Vector4(0, 0, 0, 1))
mesh._control_points.append(Vector4(1, 0, 0, 1))
mesh._control_points.append(Vector4(0.5, 1, 0, 1))
mesh.create_polygon(0, 1, 2)

normal_element = mesh.create_element(
    VertexElementType.NORMAL,
    MappingMode.CONTROL_POINT,
    ReferenceMode.DIRECT,
)

create_element_uv(uv_mapping, mapping_mode, reference_mode)

Adaugă un strat de coordonate UV la mesh. Aceasta este metoda preferată pentru atașarea datelor de coordonate de textură.

MethodsMethodsMethods
uv_mappingTextureMappingScopul canalului UV: DIFFUSE, SPECULAR, NORMAL, AMBIENT, etc.
mapping_modeMappingModeCum se mapă UV-urile la elementele geometrice.
reference_modeReferenceModeMod de indexare: DIRECT sau INDEX_TO_DIRECT.

Returnează: VertexElementUV

from aspose.threed.entities import Mesh, TextureMapping, MappingMode, ReferenceMode

mesh = Mesh()
# ... define control_points and polygons ...
uv_element = mesh.create_element_uv(
    TextureMapping.DIFFUSE,
    MappingMode.POLYGON_VERTEX,
    ReferenceMode.INDEX_TO_DIRECT,
)

Vezi și

 Română