Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh gemmer polygongeometri som en liste over kontrolpunkter (vertex‑positioner) og en liste over polygon‑flader. Hver polygon‑flade er en liste over nul‑baserede indekser i kontrolpunkts‑arrayet. Flader kan være trekanter, firkanter eller polygoner med højere aritet. Yderligere per‑vertex‑data; normaler, UV‑koordinater, vertex‑farver; er vedhæftet som VertexElement lag.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Byg et enkelt trekants‑mesh fra bunden:

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

Byg et firkant‑mesh og triangulér det inden eksport:

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, og vertex_elements er alle egenskaber; adgang til dem uden parenteser.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]læsVertex position array. Hver indgang er en Vector4(x, y, z, w) hvor w er 1.0 for positionsdata. Returnerer en kopi — tilføj ikke til den returnerede liste. Brug mesh._control_points.append(v) til at tilføje vertices (kendt begrænsning; offentligt mutations-API er endnu ikke tilgængeligt).
polygon_countintlæsAntal polygonflader defineret på dette mesh.
polygonslist[list[int]]læsAlle flade-definitioner som en liste af indekslister. Hver indre liste indeholder vertex-indekserne (i control_points) for én flade.
edgeslist[int]læsRå kantindeksdata. Primært til intern brug og avancerede topologi‑forespørgsler.
vertex_elementslist[VertexElement]læsAlle vertex‑elementlag, der i øjeblikket er knyttet til dette mesh (normals, UV’er, farver osv.).
visibleboollæs/skrivMethods False, mesh’en er skjult i visningsprogrammer, der respekterer synlighed.
cast_shadowsboollæs/skrivOm dette mesh kaster skygger i renderere, der understøtter skyggekort.
receive_shadowsboollæs/skrivOm dette mesh modtager skygger fra anden skyggekastende geometri.

Methods

create_polygon(*indices)

Definér en ny polygonflade ved at angive vertex‑indekserne i rækkefølge. Indekserne refererer til positioner i control_points. Accepterer tre eller flere indekser for trekanter, firkanter og n‑gons.

MethodsMethodsMethods
*indicesintVertex‑indeksargumenter i winding‑rækkefølge (typisk mod uret, når de ses udefra).

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

Returnér en ny Mesh hvor hver polygon er blevet opdelt i trekanter ved hjælp af fan triangulation. Det oprindelige mesh er ikke ændret. Nyttigt før eksport til formater, der kræver kun trekantgeometri (såsom STL eller nogle glTF pipelines).

Returnerer: Mesh; et nyt mesh, der kun indeholder trekanter.

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

Returner dette Mesh som en Mesh instans. For Mesh objekter er dette en identitetsoperation (returnerer self). Defineret på den Geometry basisklasse for at give en ensartet konverteringsgrænseflade, når man arbejder med generiske Geometry referencer.

Returnerer: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Tilføj en ny VertexElement lag af den angivne type til mesh’en. Brug dette til at vedhæfte normaler, tangenter, binormaler, vertexfarver og udjævningsgrupper.

MethodsMethodsMethods
element_typeVertexElementTypeDen type data, dette lag indeholder (f.eks.., VertexElementType.NORMAL).
mapping_modeMappingModeHvordan dataene kortlægges til geometri: CONTROL_POINT, POLYGON_VERTEX, POLYGON, osv.
reference_modeReferenceModeHvordan indekser bruges: DIRECT eller INDEX_TO_DIRECT.

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

Tilføj et UV-koordinatlag til mesh’en. Dette er den foretrukne metode til at vedhæfte teksturkoordinatdata.

MethodsMethodsMethods
uv_mappingTextureMappingUV-kanalens formål: DIFFUSE, SPECULAR, NORMAL, AMBIENT, osv.
mapping_modeMappingModeHvordan UV’er kortlægges til geometrieelementer.
reference_modeReferenceModeIndekseringstilstand: DIRECT eller INDEX_TO_DIRECT.

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

Se også

 Dansk