Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh armazena a geometria do polígono como uma lista de control points (vertex positions) e uma lista de polygon faces. Cada polygon face é uma lista de zero-based indices into the control points array. As faces podem ser triangles, quads, ou higher-arity polygons. Dados adicionais per-vertex; normals, UV coordinates, vertex colours; são anexados como VertexElement camadas.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Construa uma malha de triângulo único do 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")

Construa uma malha quad e triangule-a antes da exportação:

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, e vertex_elements são todos propriedades; acesse-os sem parênteses.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]leiaArray de posições dos vértices. Cada entrada é um Vector4(x, y, z, w) onde w é 1.0 para dados de posição. Retorna uma cópia — não adicione à lista retornada. Use mesh._control_points.append(v) para adicionar vértices (limitação conhecida; API pública de mutação ainda não disponível).
polygon_countintleituraNúmero de faces de polígonos definidas nesta malha.
polygonslist[list[int]]leituraTodas as definições de faces como uma lista de listas de índices. Cada lista interna contém os índices dos vértices (em control_points) para uma face.
edgeslist[int]leituraDados brutos de índice de arestas. Principalmente para uso interno e consultas avançadas de topologia.
vertex_elementslist[VertexElement]leituraTodas as camadas de elementos de vértice atualmente anexadas a esta malha (normais, UVs, cores, etc.).
visibleboolleitura/gravaçãoMethods False, a malha está oculta em visualizadores que respeitam a visibilidade.
cast_shadowsboolleitura/gravaçãoSe esta malha projeta sombras em renderizadores que suportam mapas de sombras.
receive_shadowsboolleitura/gravaçãoSe esta malha recebe sombras de outra geometria que projeta sombras.

Methods

create_polygon(*indices)

Defina uma nova face poligonal fornecendo os índices dos vértices em ordem. Os índices referenciam posições em control_points. Aceita três ou mais índices para triângulos, quadriláteros e n-gonos.

MethodsMethodsMethods
*indicesintArgumentos de índice de vértice em ordem de enrolamento (tipicamente no sentido anti-horário quando visto 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()

Retorne um novo Mesh onde cada polígono foi dividido em triângulos usando triangulação em fan. A malha original não é modificada. Útil antes de exportar para formatos que exigem geometria apenas de triângulos (como STL ou alguns pipelines glTF).

Retorna: Mesh; uma nova malha contendo apenas 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()

Retorne isto Mesh como um Mesh instância. Para Mesh objetos esta é uma operação identidade (retorna self). Definido na Geometry classe base para fornecer uma interface de conversão uniforme ao trabalhar com genéricos Geometry referências.

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)

Adicionar um novo VertexElement camada do tipo especificado à malha. Use isso para anexar normais, tangentes, binormais, cores de vértice e grupos de suavização.

MethodsMethodsMethods
element_typeVertexElementTypeO tipo de dados que esta camada contém (por exemplo,., VertexElementType.NORMAL).
mapping_modeMappingModeComo os dados são mapeados para a geometria: CONTROL_POINT, POLYGON_VERTEX, POLYGON, etc.
reference_modeReferenceModeComo os índices são usados: DIRECT ou 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)

Adicione uma camada de coordenadas UV à malha. Este é o método preferido para anexar dados de coordenadas de textura.

MethodsMethodsMethods
uv_mappingTextureMappingA finalidade do canal UV: DIFFUSE, SPECULAR, NORMAL, AMBIENT, etc.
mapping_modeMappingModeComo os UVs mapeiam os elementos de geometria.
reference_modeReferenceModeModo de indexação: DIRECT ou 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,
)

Veja Também

 Português