Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh speichert Polygongeometrie als eine Liste von Kontrollpunkten (Vertex‑Positionen) und eine Liste von Polygonflächen. Jede Polygonfläche ist eine Liste von nullbasierten Indizes in das Kontrollpunkte‑Array. Flächen können Dreiecke, Vierecke oder Polygone höherer Arität sein. Zusätzliche pro‑Vertex‑Daten; Normalen, UV‑Koordinaten, Vertex‑Farben; werden angehängt als VertexElement Schichten.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Erstelle ein einzelnes Dreiecks‑Mesh von Grund auf:

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

Erstelle ein Viereck‑Mesh und trianguliere es vor dem Export:

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, und vertex_elements sind alle Eigenschaften; greife darauf zu, ohne Klammern zu verwenden.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]lesenVertex-Positionsarray. Jeder Eintrag ist ein Vector4(x, y, z, w) wo w ist 1.0 für Positionsdaten. Gibt eine Kopie zurück — nicht an die zurückgegebene Liste anhängen. Verwenden Sie mesh._control_points.append(v) um Scheitelpunkte hinzuzufügen (bekannte Einschränkung; öffentliche Mutations-API noch nicht verfügbar).
polygon_countintlesenAnzahl der auf diesem Mesh definierten Polygonflächen.
polygonslist[list[int]]lesenAlle Flächendefinitionen als Liste von Indexlisten. Jede innere Liste enthält die Scheitelpunktindizes (in control_points) für eine Fläche.
edgeslist[int]lesenRohdaten der Kantennummern. Primär für den internen Gebrauch und erweiterte Topologie‑Abfragen.
vertex_elementslist[VertexElement]lesenAlle Vertex‑Element‑Ebenen, die derzeit an diesem Mesh angehängt sind (Normalen, UVs, Farben usw.).
visibleboollesen/schreibenMethods False, das Mesh ist in Viewern, die Sichtbarkeit respektieren, verborgen.
cast_shadowsboollesen/schreibenOb dieses Mesh Schatten wirft in Renderern, die Schattenkarten unterstützen.
receive_shadowsboollesen/schreibenOb dieses Mesh Schatten von anderer, Schatten erzeugender Geometrie empfängt.

Methods

create_polygon(*indices)

Definiere ein neues Polygon‑Face, indem du die Vertex‑Indizes in Reihenfolge angibst. Die Indizes verweisen auf Positionen in control_points. Akzeptiert drei oder mehr Indizes für Dreiecke, Vierecke und N‑Gons.

MethodsMethodsMethods
*indicesintVertex-Index-Argumente in Windungsreihenfolge (typischerweise gegen den Uhrzeigersinn, wenn von außen betrachtet).

Rückgabe: 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()

Gib ein neues Mesh bei dem jedes Polygon mit Fan-Triangulation in Dreiecke aufgeteilt wurde. Das ursprüngliche Mesh wird nicht verändert. Nützlich vor dem Export in Formate, die ausschließlich Dreiecksgeometrie erfordern (wie STL oder einige glTF-Pipelines).

Rückgabe: Mesh; ein neues Mesh, das nur Dreiecke enthält.

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

Gib dies zurück Mesh als ein Mesh Instanz. Für Mesh Objekte dies ist eine Identitätsoperation (gibt zurück self). Definiert auf der Geometry Basisklasse, um eine einheitliche Konvertierungsschnittstelle bereitzustellen, wenn mit generischen Geometry Referenzen.

Rückgabe: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Fügt ein neues VertexElement Ebene des angegebenen Typs zum Mesh hinzu. Verwenden Sie dies, um Normalen, Tangenten, Binormalen, Vertex-Farben und Glättungsgruppen anzuhängen.

MethodsMethodsMethods
element_typeVertexElementTypeDie Art der Daten, die diese Ebene enthält (z. B., VertexElementType.NORMAL).
mapping_modeMappingModeWie die Daten auf die Geometrie abgebildet werden: CONTROL_POINT, POLYGON_VERTEX, POLYGON, usw.
reference_modeReferenceModeWie Indizes verwendet werden: DIRECT oder INDEX_TO_DIRECT.

Rückgabe: 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)

Füge dem Mesh eine UV-Koordinatenebene hinzu. Dies ist die bevorzugte Methode, um Texturkoordinatendaten anzuhängen.

MethodsMethodsMethods
uv_mappingTextureMappingDer Zweck des UV-Kanals: DIFFUSE, SPECULAR, NORMAL, AMBIENT, usw.
mapping_modeMappingModeWie UVs auf Geometrieelemente abgebildet werden.
reference_modeReferenceModeIndexierungsmodus: DIRECT oder INDEX_TO_DIRECT.

Rückgabe: 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,
)

Siehe auch

 Deutsch