Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh lagrer polygongeometri som en liste over kontrollpunkter (vertex‑posisjoner) og en liste over polygon‑flater. Hver polygon‑flate er en liste med null‑baserte indekser inn i kontrollpunkts‑arrayen. Flater kan være trekanter, firkanter eller polygoner med høyere aritet. Ekstra per‑vertex‑data; normaler, UV‑koordinater, vertex‑farger; er festet som VertexElement lag.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Bygg et enkelt trekant‑mesh fra bunnen av:

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

Bygg et firkant‑mesh og trianguler det før 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 egenskaper; få tilgang til dem uten parenteser.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]lesVertex‑posisjons‑array. Hvert element er en Vector4(x, y, z, w) hvor w er 1.0 for posisjonsdata. Returnerer en kopi — ikke legg til i den returnerte listen. Bruk mesh._control_points.append(v) for å legge til vertexer (kjent begrensning; offentlig mutasjons‑API er ennå ikke tilgjengelig).
polygon_countintlesAntall polygonflater definert på dette mesh-et.
polygonslist[list[int]]lesAlle flatedefinisjoner som en liste av indekslister. Hver indre liste inneholder vertex-indeksene (into control_points) for én flate.
edgeslist[int]lesRå kantindeksdata. Primært for intern bruk og avanserte topologi‑spørringer.
vertex_elementslist[VertexElement]lesAlle vertex‑elementlag som for øyeblikket er festet til dette nettet (normals, UVs, farger, osv.).
visibleboolles/skrivMethods False, nettet er skjult i visningsprogrammer som respekterer synlighet.
cast_shadowsboolles/skrivOm dette nettet kaster skygger i renderere som støtter skyggekart.
receive_shadowsboolles/skrivOm dette nettet mottar skygger fra annen skyggekastende geometri.

Methods

create_polygon(*indices)

Definer et nytt polygon‑ansikt ved å oppgi vertex‑indeksene i rekkefølge. Indeksene refererer til posisjoner i control_points. Aksepterer tre eller flere indekser for trekanter, firkanter og n‑gons.

MethodsMethodsMethods
*indicesintVertex‑indeksargumenter i viklingsrekkefølge (vanligvis mot klokken når de ses fra utsiden).

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

Returner en ny Mesh hvor hver polygon er blitt delt inn i trekanter ved bruk av fan triangulation. Det opprinnelige nettet er ikke endret. Nyttig før eksport til formater som krever kun trekantgeometri (som STL eller noen glTF‑pipelines).

Returnerer: Mesh; et nytt mesh som kun inneholder 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 identitetsoperasjon (returnerer self). Definert på den Geometry basisklasse for å tilby et ensartet konverteringsgrensesnitt når man arbeider med generiske Geometry referanser.

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)

Legg til en ny VertexElement lag av den angitte typen til mesh-et. Bruk dette for å legge til normaler, tangenter, binormaler, vertex-farger, og glatthetsgrupper.

MethodsMethodsMethods
element_typeVertexElementTypeTypen data dette laget inneholder (f.eks., VertexElementType.NORMAL).
mapping_modeMappingModeHvordan dataene kartlegges til geometri: CONTROL_POINT, POLYGON_VERTEX, POLYGON, osv.
reference_modeReferenceModeHvordan indekser brukes: 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)

Legg til et UV-koordinatlag til nettet. Dette er den foretrukne metoden for å feste teksturkoordinatdata.

MethodsMethodsMethods
uv_mappingTextureMappingFormålet med UV-kanalen: DIFFUSE, SPECULAR, NORMAL, AMBIENT, osv.
mapping_modeMappingModeHvordan UV-er kartlegger til geometrielementer.
reference_modeReferenceModeIndekseringsmodus: 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å

 Norsk