Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh memorizza la geometria del poligono come un elenco di punti di controllo (posizioni dei vertici) e un elenco di facce del poligono. Ogni faccia del poligono è un elenco di indici a base zero nell’array dei punti di controllo. Le facce possono essere triangoli, quadrilateri o poligoni di arità superiore. Dati aggiuntivi per vertice; normali, coordinate UV, colori dei vertici; è allegato come VertexElement livelli.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Costruisci una mesh triangolare singola da 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")

Costruisci una mesh a quadrilatero e triangolala prima dell’esportazione:

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 sono tutti proprietà; accedervi senza parentesi.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]leggiArray di posizioni dei vertici. Ogni voce è un Vector4(x, y, z, w) dove w è 1.0 per i dati di posizione. Restituisce una copia — non aggiungere alla lista restituita. Usa mesh._control_points.append(v) per aggiungere vertici (limite noto; l’API di mutazione pubblica non è ancora disponibile).
polygon_countintleggiNumero di facce poligonali definite su questa mesh.
polygonslist[list[int]]leggiTutte le definizioni delle facce come una lista di liste di indici. Ogni lista interna contiene gli indici dei vertici (into control_points) per una faccia.
edgeslist[int]letturaDati grezzi degli indici dei bordi. Principalmente per uso interno e query di topologia avanzata.
vertex_elementslist[VertexElement]letturaTutti i layer di elementi dei vertici attualmente collegati a questa mesh (normali, UV, colori, ecc.).
visibleboollettura/scritturaMethods False, la mesh è nascosta nei visualizzatori che rispettano la visibilità.
cast_shadowsboollettura/scritturaIndica se questa mesh proietta ombre nei renderer che supportano le shadow map.
receive_shadowsboollettura/scritturaIndica se questa mesh riceve ombre da altre geometrie che proiettano ombre.

Methods

create_polygon(*indices)

Definisci una nuova faccia poligonale fornendo gli indici dei vertici in ordine. Gli indici fanno riferimento alle posizioni in control_points. Accetta tre o più indici per triangoli, quadrilateri e n-goni.

MethodsMethodsMethods
*indicesintArgomenti di indice dei vertici in ordine di avvolgimento (tipicamente in senso antiorario quando visualizzato dall’esterno).

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

Restituisci un nuovo Mesh dove ogni poligono è stato suddiviso in triangoli usando la triangolazione a ventaglio. La mesh originale non viene modificata. Utile prima di esportare in formati che richiedono geometria solo a triangoli (come STL o alcune pipeline glTF).

Restituisce: Mesh; una nuova mesh contenente solo triangoli.

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

Restituisci questo Mesh come un Mesh istanza. Per Mesh gli oggetti questa è un’operazione di identità (restituisce self). Definito sulla Geometry classe base per fornire un’interfaccia di conversione uniforme quando si lavora con riferimenti generici Geometry riferimenti.

Restituisce: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Aggiungi un nuovo VertexElement livello del tipo specificato alla mesh. Usa questo per allegare normali, tangenti, binormali, colori dei vertici e gruppi di smoothing.

MethodsMethodsMethods
element_typeVertexElementTypeIl tipo di dati che questo livello contiene (ad es., VertexElementType.NORMAL).
mapping_modeMappingModeCome i dati vengono mappati alla geometria: CONTROL_POINT, POLYGON_VERTEX, POLYGON, ecc.
reference_modeReferenceModeCome vengono usati gli indici: DIRECT oppure INDEX_TO_DIRECT.

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

Aggiungi un livello di coordinate UV alla mesh. Questo è il metodo consigliato per collegare i dati delle coordinate di texture.

MethodsMethodsMethods
uv_mappingTextureMappingLo scopo del canale UV: DIFFUSE, SPECULAR, NORMAL, AMBIENT, ecc.
mapping_modeMappingModeCome le UV si mappano agli elementi della geometria.
reference_modeReferenceModeModalità di indicizzazione: DIRECT oppure INDEX_TO_DIRECT.

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

Vedi anche

 Italiano