Aspose.3D FOSS
Python
Mesh

Mesh

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

Mesh przechowuje geometrię wielokątów jako listę punktów kontrolnych (pozycji wierzchołków) oraz listę ścian wielokątów. Każda ściana wielokąta jest listą indeksów zerobazowych do tablicy punktów kontrolnych. Ściany mogą być trójkątami, czworokątami lub wielokątami o wyższej arności. Dodatkowe dane per‑wierzchołkowe; normalne, współrzędne UV, kolory wierzchołków; są dołączane jako VertexElement warstwy.

class Mesh(Geometry):

Methods

A3DObject → SceneObject → Entity → Geometry → Mesh

Methods

Zbuduj pojedynczą siatkę trójkątów od podstaw:

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

Zbuduj siatkę czworokątów i podziel ją na trójkąty przed eksportem:

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, oraz vertex_elements są wszystkie właściwości; uzyskaj do nich dostęp bez nawiasów.

MethodsMethodsMethodsMethods
control_pointslist[Vector4]odczytajTablica pozycji wierzchołków. Każdy wpis jest Vector4(x, y, z, w) gdzie w jest 1.0 dla danych pozycyjnych. Zwraca kopię — nie dodawaj do zwróconej listy. Użyj mesh._control_points.append(v) aby dodać wierzchołki (znane ograniczenie; publiczne API mutacji nie jest jeszcze dostępne).
polygon_countintodczytLiczba ścian wielokątów zdefiniowanych w tej siatce.
polygonslist[list[int]]odczytWszystkie definicje ścian jako lista list indeksów. Każda wewnętrzna lista zawiera indeksy wierzchołków (do control_points) dla jednej ściany.
edgeslist[int]odczytSurowe dane indeksów krawędzi. Przede wszystkim do użytku wewnętrznego i zaawansowanych zapytań topologicznych.
vertex_elementslist[VertexElement]odczytWszystkie warstwy elementów wierzchołków aktualnie dołączone do tej siatki (normale, UV, kolory itp.).
visibleboolodczyt/zapisMethods False, siatka jest ukryta w przeglądarkach, które respektują widoczność.
cast_shadowsboolodczyt/zapisCzy ta siatka rzuca cienie w rendererach obsługujących mapy cieni.
receive_shadowsboolodczyt/zapisCzy ta siatka odbiera cienie od innej geometrii rzucającej cienie.

Methods

create_polygon(*indices)

Zdefiniuj nową powierzchnię wielokąta, podając indeksy wierzchołków w kolejności. Indeksy odwołują się do pozycji w control_points. Akceptuje trzy lub więcej indeksów dla trójkątów, czworokątów i n‑kątów.

MethodsMethodsMethods
*indicesintArgumenty indeksów wierzchołków w kolejności wirowania (zazwyczaj przeciwnie do ruchu wskazówek zegara, gdy patrzy się z zewnątrz).

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

Zwróć nowy Mesh gdzie każdy wielokąt został podzielony na trójkąty przy użyciu triangulacji wachlarzowej. Oryginalna siatka nie jest modyfikowana. Przydatne przed eksportem do formatów wymagających wyłącznie geometrii trójkątnej (takich jak STL lub niektóre potoki glTF).

Zwraca: Mesh; nowa siatka zawierająca wyłącznie trójkąty.

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

Zwróć to Mesh jako Mesh instancję. Dla Mesh obiekty to operacja tożsamościowa (zwraca self). Zdefiniowane na Geometry klasie bazowej, aby zapewnić jednolity interfejs konwersji przy pracy z ogólnymi Geometry referencjami.

Zwraca: Mesh

from aspose.threed.entities import Geometry

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

create_element(element_type, mapping_mode, reference_mode)

Dodaj nowy VertexElement warstwę określonego typu do siatki. Użyj tego, aby dołączyć wektory normalne, tangensy, binormale, kolory wierzchołków oraz grupy wygładzania.

MethodsMethodsMethods
element_typeVertexElementTypeRodzaj danych przechowywanych w tej warstwie (np., VertexElementType.NORMAL).
mapping_modeMappingModeJak dane mapują się na geometrię: CONTROL_POINT, POLYGON_VERTEX, POLYGON, itp.
reference_modeReferenceModeJak używane są indeksy: DIRECT lub INDEX_TO_DIRECT.

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

Dodaj warstwę współrzędnych UV do siatki. Jest to preferowana metoda dołączania danych współrzędnych tekstury.

MethodsMethodsMethods
uv_mappingTextureMappingCel kanału UV: DIFFUSE, SPECULAR, NORMAL, AMBIENT, itd.
mapping_modeMappingModeJak UV są mapowane na elementy geometrii.
reference_modeReferenceModeTryb indeksowania: DIRECT lub INDEX_TO_DIRECT.

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

Zobacz także

 Polski