Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh emmagatzema la geometria del polígon com una llista de punts de control (posicions dels vèrtex) i una llista de cares del polígon. Cada cara del polígon és una llista d’índexs basats en zero cap a la matriu de punts de control. Les cares poden ser triangles, quàders o polígons d’aritat superior. Dades addicionals per vèrtex; normals, coordenades UV, colors de vèrtex; s’adjunten com a VertexElement capes.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Construeix una malla de triangle única des de 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")

Construeix una malla de quàders i triangula-la abans d’exportar:

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 són tots propietats; accediu-hi sense parèntesis.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]llegirMatriu de posicions de vèrtex. Cada entrada és una Vector4(x, y, z, w) on w és 1.0 per a dades de posició. Retorna una còpia — no afegeixis a la llista retornada. Utilitza mesh._control_points.append(v) per afegir vèrtexs (limitació coneguda; l’API pública de mutació encara no està disponible).
polygon_countintlecturaNombre de cares de polígon definides en aquesta malla.
polygonslist[list[int]]lecturaTotes les definicions de cares com una llista de llistes d’índexs. Cada llista interna conté els índexs dels vèrtexs (a control_points) per a una cara.
edgeslist[int]lecturaDades d’índex d’aresta en brut. Principalment per a ús intern i consultes avançades de topologia.
vertex_elementslist[VertexElement]lecturaTotes les capes d’elements de vèrtex actualment adjuntades a aquesta malla (normals, UVs, colors, etc.).
visibleboollectura/escripturaMethods False, la malla està oculta en visualitzadors que respecten la visibilitat.
cast_shadowsboollectura/escripturaIndica si aquesta malla projecta ombres en renderitzadors que admeten mapes d’ombres.
receive_shadowsboollectura/escripturaIndica si aquesta malla rep ombres d’altres geometries que projecten ombres.

Methods

create_polygon(*indices)

Defineu una nova cara de polígon proporcionant els índexs de vèrtex en ordre. Els índexs fan referència a posicions a control_points. Accepta tres o més índexs per a triangles, quàders i n-gons.

MethodsMethodsMethods
*indicesintArguments d’índex de vèrtex en ordre d’enrotllament (normalment en sentit antihorari quan es veu des de fora).

Retorna: 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()

Retorna un nou Mesh on cada polígon s’ha dividit en triangles mitjançant triangulació en forma d’abanico. La malla original no es modifica. Útil abans d’exportar a formats que requereixen geometria només de triangles (com STL o algunes pipelines glTF).

Retorna: Mesh; una nova malla que conté només triangles.

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()

Retorna aquest Mesh com a Mesh instància. Per Mesh objectes aquesta és una operació d’identitat (retorna self). Definida a la Geometry classe base per proporcionar una interfície de conversió uniforme quan es treballa amb genèrics Geometry referències.

Retorna: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Afegeix un nou VertexElement capa del tipus especificat a la malla. Utilitza-la per adjuntar normals, tangents, binormals, colors de vèrtex i grups d’allisat.

MethodsMethodsMethods
element_typeVertexElementTypeEl tipus de dades que aquesta capa conté (p. ex., VertexElementType.NORMAL).
mapping_modeMappingModeCom les dades s’associen a la geometria: CONTROL_POINT, POLYGON_VERTEX, POLYGON, etc.
reference_modeReferenceModeCom s’utilitzen els índexs: DIRECT o INDEX_TO_DIRECT.

Retorna: 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)

Afegeix una capa de coordenades UV a la malla. Aquest és el mètode preferit per adjuntar dades de coordenades de textura.

MethodsMethodsMethods
uv_mappingTextureMappingLa finalitat del canal UV: DIFFUSE, SPECULAR, NORMAL, AMBIENT, etc.
mapping_modeMappingModeCom es mapen els UVs als elements de geometria.
reference_modeReferenceModeMode d’indexació: DIRECT o INDEX_TO_DIRECT.

Retorna: 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,
)

Vegeu també

 Català