Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh slaat polygon geometry op als een lijst van control points (vertex positions) en een lijst van polygon faces. Elke polygon face is een lijst van zero-based indices in de control points array. Faces kunnen triangles, quads, of higher-arity polygons zijn. Additional per-vertex data; normals, UV coordinates, vertex colours; wordt toegevoegd als VertexElement lagen.

class Mesh(Geometry):

Properties

A3DObject → SceneObject → Entity → Geometry → Mesh

Properties

Bouw een enkel driehoekmesh vanaf nul:

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
# control_points is a property (list): append to it directly
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")

Bouw een quad‑mesh en trianguleer deze vóór 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
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")

Properties

control_points, polygon_count, polygons, edges, en vertex_elements zijn allemaal eigenschappen; benader ze zonder haakjes.

PropertiesPropertiesPropertiesProperties
control_pointslist[Vector4]lezenVertex-positie-array. Elke invoer is een Vector4(x, y, z, w) waar w is 1.0 voor positiedata. Voeg toe aan deze lijst om vertices toe te voegen.
polygon_countintlezenAantal veelhoekvlakken gedefinieerd op dit mesh.
polygonslist[list[int]]lezenAlle vlakdefinities als een lijst van indexlijsten. Elke interne lijst bevat de vertex-indexen (in control_points) voor één vlak.
edgeslist[int]lezenRuwe randindexgegevens. Voornamelijk voor intern gebruik en geavanceerde topologie‑query’s.
vertex_elementslist[VertexElement]lezenAlle vertex-elementlagen die momenteel aan dit mesh zijn gekoppeld (normals, UV’s, kleuren, enz.).
visibleboollezen/schrijvenProperties False, het mesh wordt verborgen in viewers die zichtbaarheid respecteren.
cast_shadowsboollezen/schrijvenOf dit mesh schaduwen werpt in renderers die schaduwkaarten ondersteunen.
receive_shadowsboollezen/schrijvenOf dit mesh schaduwen ontvangt van andere schaduwwerpend geometrie.

Properties

create_polygon(*indices)

Definieer een nieuw polygonale vlak door de vertex-indexen in volgorde op te geven. De indexen verwijzen naar posities in control_points. Accepteert drie of meer indexen voor driehoeken, quads en n-gons.

PropertiesPropertiesProperties
*indicesintVertex-indexargumenten in windingvolgorde (meestal tegen de klok in wanneer bekeken van buiten).

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

Retourneer een nieuw Mesh waar elk polygon is opgesplitst in driehoeken met behulp van fan-triangulatie. Het originele mesh wordt niet aangepast. Handig vóór het exporteren naar formaten die alleen driehoekige geometrie vereisen (zoals STL of sommige glTF-pijplijnen).

Retourneert: Mesh; een nieuw mesh dat alleen driehoeken bevat.

from aspose.threed.entities import Mesh
from aspose.threed.utilities import Vector4

mesh = Mesh()
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()

Retourneer dit Mesh als een Mesh instantie. Voor Mesh objecten is dit een identiteitsoperatie (geeft terug self). Defined on the Geometry basisklasse om een uniforme conversie‑interface te bieden bij het werken met generieke Geometry referenties.

Retourneert: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Voeg een nieuwe toe VertexElement laag van het opgegeven type toe aan het mesh. Gebruik dit om normalen, tangenten, binormalen, vertexkleuren en smoothing‑groepen toe te voegen.

PropertiesPropertiesProperties
element_typeVertexElementTypeHet type gegevens dat deze laag bevat (bijv., VertexElementType.NORMAL).
mapping_modeMappingModeHoe de gegevens worden gemapt op geometrie: CONTROL_POINT, POLYGON_VERTEX, POLYGON, enz.
reference_modeReferenceModeHoe indexen worden gebruikt: DIRECT of INDEX_TO_DIRECT.

Retourneert: VertexElement

from aspose.threed.entities import Mesh, VertexElementType, MappingMode, ReferenceMode
from aspose.threed.utilities import Vector4

mesh = Mesh()
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)

Voeg een UV-coördinatenlaag toe aan het mesh. Dit is de voorkeursmethode om textuurcoördinaatgegevens toe te voegen.

PropertiesPropertiesProperties
uv_mappingTextureMappingHet doel van het UV-kanaal: DIFFUSE, SPECULAR, NORMAL, AMBIENT, enz.
mapping_modeMappingModeHoe UV’s worden toegewezen aan geometrie‑elementen.
reference_modeReferenceModeIndexeringsmodus: DIRECT of INDEX_TO_DIRECT.

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

Zie ook

 Nederlands