padne.mesh

Attributes

index_type
PolyBoundaryDistanceMap
CGALPolygon

Exceptions

MeshingException

Exception raised when CGAL mesh generation fails due to invalid geometry.

Classes

HasIndex	Base class for protocol classes.
Vector
Point
Vertex
HalfEdge
Face
IndexStore	A simple class that stores objects with indices.
Mesh
ZeroForm
OneForm	A discrete 1-form defined on the (h)edges of a mesh.
TwoForm	A discrete 2-form defined on the faces of a mesh.
Mesher	This class is responsible for generating a mesh from a Shapely polygon.

Module Contents

padne.mesh.index_type

class padne.mesh.HasIndex

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

i: index_type

class padne.mesh.Vector

dx: float

dy: float

dot(other: Vector) → float

class padne.mesh.Point

x: float

y: float

distance(other: Point) → float

to_shapely() → shapely.geometry.Point

Convert this Point to a shapely.geometry.Point.

Returns:

A shapely Point with the same coordinates

class padne.mesh.Vertex

p: Point

out: HalfEdge | None = None

i: index_type

orbit() → Iterator[HalfEdge]

class padne.mesh.HalfEdge

origin: Vertex

twin: HalfEdge | None = None

next: HalfEdge | None = None

prev: HalfEdge | None = None

face: Face | None = None

i: index_type

property is_boundary: bool

static connect(e1: HalfEdge, e2: HalfEdge) → None

walk() → Iterator[HalfEdge]

cotan() → float

Compute the cotangent weight for this half-edge.

class padne.mesh.Face

edge: HalfEdge = None

is_boundary: bool = False

i: index_type

property edges

property vertices

property centroid: Point

Compute the centroid of the face using the average of vertex coordinates.

property area: float

Compute the area using the shoelace formula. Returns the absolute value to ensure positive area regardless of vertex order.

class padne.mesh.IndexStore[T: HasIndex]

A simple class that stores objects with indices.

property next_index: index_type

Get the next available index without adding an object.

add(obj: T) → None

to_index(obj: T) → index_type

Get the index of an object. This is for backwards compatibility, otherwise use obj.i directly.

to_object(idx: int | index_type) → T

Get the object at a given index.

items() → Iterator[tuple[index_type, T]]

class padne.mesh.Mesh

vertices

halfedges

faces

boundaries

make_vertex(p: Point) → Vertex

connect_vertices(v1: Vertex, v2: Vertex) → HalfEdge

Return a half-edge between the two vertices v1 and v2. If the half edge does not exist, create it. The twin half-edge is also created.

euler_characteristic() → int

classmethod from_triangle_soup(points: list[Point], triangles: list[tuple[int, int, int]]) → Mesh

class padne.mesh.ZeroForm

mesh: Mesh

values: numpy.ndarray

d() → OneForm

Compute the exterior derivative (gradient) of this 0-form.

For a function f on vertices, the exterior derivative df is a 1-form where: (df)[edge] = f(target_vertex) - f(source_vertex)

Returns:

A OneForm representing the gradient of this function

class padne.mesh.OneForm

A discrete 1-form defined on the (h)edges of a mesh.

mesh: Mesh

values: numpy.ndarray

class padne.mesh.TwoForm

A discrete 2-form defined on the faces of a mesh.

mesh: Mesh

values: numpy.ndarray

padne.mesh.PolyBoundaryDistanceMap

padne.mesh.CGALPolygon

exception padne.mesh.MeshingException

Bases: RuntimeError

Exception raised when CGAL mesh generation fails due to invalid geometry.

This includes cases such as: - Self-intersecting polygons with unauthorized constraint intersections - Degenerate edges that are too short (near-duplicate vertices) - Other geometric degeneracies that prevent mesh generation

With CGAL_DEBUG enabled, these issues are detected early through CGAL’s internal precondition checking, preventing crashes and providing clear error messages.

class padne.mesh.Mesher(config: Mesher | None = None)

This class is responsible for generating a mesh from a Shapely polygon. Works through the triangle library.

class Config

Configuration parameters for mesh generation.

minimum_angle: float = 20.0

maximum_size: float = 0.6

variable_density_min_distance: float = 0.5

variable_density_max_distance: float = 3.0

variable_size_maximum_factor: float = 3.0

distance_map_quantization: float = 1.0

RELAXED = None

property is_variable_density: bool

Return True if variable density meshing is enabled.

config

poly_to_mesh(poly: shapely.geometry.Polygon, seed_points: list[Point] = []) → Mesh

Convert a Shapely polygon to a triangular mesh.

Args:

poly: A Shapely polygon, potentially with holes

Returns:

A Mesh object representing the triangulated polygon