Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh almacena la geometría del polígono como una lista de puntos de control (posiciones de vértices) y una lista de caras del polígono. Cada cara del polígono es una lista de índices basados en cero en el arreglo de puntos de control. Las caras pueden ser triángulos, cuádruples o polígonos de aridad superior. Los datos adicionales por vértice; normales, coordenadas UV, colores de vértice; se adjuntan como VertexElement capas.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Construye una malla de triángulo único desde cero:

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

Construye una malla de cuadrilátero y triangúlala antes de 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, y vertex_elements son todos propiedades; acceda a ellos sin paréntesis.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]leerMatriz de posiciones de vértices. Cada entrada es una Vector4(x, y, z, w) donde w es 1.0 para datos de posición. Devuelve una copia — no añadas a la lista devuelta. Usa mesh._control_points.append(v) para añadir vértices (limitación conocida; la API pública de mutación aún no está disponible).
polygon_countintlecturaNúmero de caras de polígono definidas en esta malla.
polygonslist[list[int]]lecturaTodas las definiciones de caras como una lista de listas de índices. Cada lista interna contiene los índices de los vértices (en control_points) para una cara.
edgeslist[int]lecturaDatos de índices de aristas sin procesar. Principalmente para uso interno y consultas avanzadas de topología.
vertex_elementslist[VertexElement]lecturaTodas las capas de elementos de vértices actualmente adjuntas a esta malla (normales, UVs, colores, etc.).
visibleboollectura/escrituraMethods False, la malla está oculta en visores que respetan la visibilidad.
cast_shadowsboollectura/escrituraSi esta malla proyecta sombras en renderizadores que admiten mapas de sombras.
receive_shadowsboollectura/escrituraSi esta malla recibe sombras de otra geometría que proyecta sombras.

Methods

create_polygon(*indices)

Define una nueva cara poligonal proporcionando los índices de vértices en orden. Los índices hacen referencia a posiciones en control_points. Acepta tres o más índices para triángulos, cuádruples y n-gonos.

MethodsMethodsMethods
*indicesintArgumentos de índice de vértice en orden de enrollado (normalmente en sentido antihorario cuando se ve desde el exterior).

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

Devuelve un nuevo Mesh donde cada polígono ha sido dividido en triángulos usando triangulación en abanico. La malla original no se modifica. Útil antes de exportar a formatos que requieren geometría solo de triángulos (como STL o algunas canalizaciones glTF).

Devuelve: Mesh; una nueva malla que contiene solo triángulos.

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

Devuelve esto Mesh como un Mesh instancia. Para Mesh objetos esta es una operación de identidad (devuelve self). Definido en el Geometry clase base para proporcionar una interfaz de conversión uniforme al trabajar con genéricos Geometry referencias.

Devuelve: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Añadir un nuevo VertexElement capa del tipo especificado a la malla. Use esto para adjuntar normales, tangentes, binormales, colores de vértice y grupos de suavizado.

MethodsMethodsMethods
element_typeVertexElementTypeEl tipo de datos que contiene esta capa (p.ej., VertexElementType.NORMAL).
mapping_modeMappingModeCómo se asignan los datos a la geometría: CONTROL_POINT, POLYGON_VERTEX, POLYGON, etc.
reference_modeReferenceModeCómo se utilizan los índices: DIRECT o INDEX_TO_DIRECT.

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

Añade una capa de coordenadas UV a la malla. Este es el método preferido para adjuntar datos de coordenadas de textura.

MethodsMethodsMethods
uv_mappingTextureMappingEl propósito del canal UV: DIFFUSE, SPECULAR, NORMAL, AMBIENT, etc.
mapping_modeMappingModeCómo se asignan los UV a los elementos de geometría.
reference_modeReferenceModeModo de indexado: DIRECT o INDEX_TO_DIRECT.

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

Ver también

 Español