Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh stocke la géométrie des polygones sous forme d’une liste de points de contrôle (positions des sommets) et d’une liste de faces de polygones. Chaque face de polygone est une liste d’indices zéro‑basés dans le tableau des points de contrôle. Les faces peuvent être des triangles, des quadrilatères ou des polygones d’arité supérieure. Des données supplémentaires par sommet ; normales, coordonnées UV, couleurs de sommet ; sont attachées sous forme de VertexElement couches.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Construire un maillage triangulaire unique à partir de zéro :

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

Construire un maillage en quadrilatères et le trianguler avant l’exportation :

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, et vertex_elements sont tous propriétés; accédez-y sans parenthèses.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]lireTableau des positions des sommets. Chaque entrée est un Vector4(x, y, z, w) où w est 1.0 pour les données de position. Retourne une copie — ne pas ajouter à la liste retournée. Utilisez mesh._control_points.append(v) pour ajouter des sommets (limitation connue ; l’API de mutation publique n’est pas encore disponible).
polygon_countintlectureNombre de faces polygonales définies sur ce maillage.
polygonslist[list[int]]lectureToutes les définitions de faces sous forme d’une liste de listes d’indices. Chaque liste interne contient les indices des sommets (dans control_points) pour une face.
edgeslist[int]lectureDonnées brutes d’index d’arêtes. Principalement destinées à un usage interne et à des requêtes de topologie avancées.
vertex_elementslist[VertexElement]lectureToutes les couches d’éléments de sommet actuellement attachées à ce maillage (normales, UVs, couleurs, etc.).
visibleboollecture/écritureMethods False, le maillage est caché dans les visionneuses qui respectent la visibilité.
cast_shadowsboollecture/écritureIndique si ce maillage projette des ombres dans les moteurs de rendu qui prennent en charge les cartes d’ombres.
receive_shadowsboollecture/écritureIndique si ce maillage reçoit des ombres provenant d’autres géométries qui projettent des ombres.

Methods

create_polygon(*indices)

Définissez une nouvelle face polygonale en fournissant les indices de sommet dans l’ordre. Les indices font référence aux positions dans control_points. Accepte trois indices ou plus pour les triangles, les quadrilatères et les n-gones.

MethodsMethodsMethods
*indicesintArguments d’index de sommet dans l’ordre de rotation (généralement dans le sens inverse des aiguilles d’une montre lorsqu’ils sont vus de l’extérieur).

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

Renvoie un nouveau Mesh où chaque polygone a été découpé en triangles à l’aide d’une triangulation en éventail. Le maillage original n’est pas modifié. Utile avant l’exportation vers des formats qui nécessitent une géométrie uniquement en triangles (comme STL ou certains pipelines glTF).

Renvoie : Mesh; un nouveau maillage ne contenant que des 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()

Renvoie ceci Mesh en tant que Mesh instance. Pour Mesh objets ceci est une opération d’identité (renvoie self). Définie sur le Geometry classe de base pour fournir une interface de conversion uniforme lors du travail avec des génériques Geometry références.

Retourne: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Ajouter un nouveau VertexElement couche du type spécifié au maillage. Utilisez ceci pour attacher les normales, tangentes, binormales, couleurs de sommet, et les groupes de lissage.

MethodsMethodsMethods
element_typeVertexElementTypeLe type de données que cette couche contient (p. ex., VertexElementType.NORMAL).
mapping_modeMappingModeComment les données sont mappées à la géométrie: CONTROL_POINT, POLYGON_VERTEX, POLYGON, etc.
reference_modeReferenceModeComment les indices sont utilisés : DIRECT ou INDEX_TO_DIRECT.

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

Ajoutez une couche de coordonnées UV au maillage. C’est la méthode préférée pour attacher les données de coordonnées de texture.

MethodsMethodsMethods
uv_mappingTextureMappingLe but du canal UV : DIFFUSE, SPECULAR, NORMAL, AMBIENT, etc.
mapping_modeMappingModeComment les UV se mappent aux éléments de géométrie.
reference_modeReferenceModeMode d’indexation : DIRECT ou INDEX_TO_DIRECT.

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

Voir aussi

 Français