Skip to content

curvey.triangulation¤

triangulation ¤

Triangulation ¤

A set of triangles defined by vertex coordinates and connectivity array

Parameters:

Name Type Description Default
points PointsLike

(n_points, 2) array of vertex coordinates.

 required
faces TrisLike

(n_faces, 3) integer array of vertex indices.

 required
Source code in src\curvey\triangulation.py 
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
class Triangulation:
    """A set of triangles defined by vertex coordinates and connectivity array

    Parameters
    ----------
    points
        `(n_points, 2)` array of vertex coordinates.

    faces
        `(n_faces, 3)` integer array of vertex indices.

    """

    def __init__(self, points: PointsLike, faces: TrisLike):
        self.points: ndarray = asanyarray(points)
        """`(n_points, 2)` array of vertex coordinates."""

        self.faces: ndarray = asanyarray(faces)
        """`(n_faces, 3)` integer array of vertex indices."""

    @property
    def n_points(self) -> int:
        """Number of points"""
        return len(self.points)

    @property
    def n_faces(self) -> int:
        """Number of triangles"""
        return len(self.faces)

    @cached_property
    def edge(self) -> ndarray:
        """A `(n_tris, 2, 2)` array of edge vectors

        `self.edge[i, 0]` and `self.edge[i, 1]` are the unnormalized edge vectors of the first
        two edges in triangle `i`.
        """
        return diff(self.points[self.faces], axis=1)

    def reverse(self) -> Triangulation:
        """Reverse the orientation of each triangle"""
        return Triangulation(points=self.points, faces=self.faces[:, ::-1])

    @cached_property
    def signed_area(self) -> ndarray:
        """A length `n_tris` vector of signed triangle areas"""
        return cross(self.edge[:, 0], self.edge[:, 1]) / 2

    def plot_tris(self, ax: Axes | None = None, **kwargs) -> tuple[Line2D, Line2D]:
        """Plot the triangulation

        Parameters
        ----------
        ax
            Axes to plot in, default current axes.

        **kwargs
            Passed to `matplotlib.pyplot.triplot`
        """
        ax = _get_ax(ax)
        x, y = self.points.T
        return ax.triplot(x, y, self.faces, **kwargs)

    def to_edges(self) -> curvey.edges.Edges:
        """An edge soup

        Returns
        -------
        edges :
            An edge set with points `self.points` and `n_edges=3 * self.n_faces`

        """
        return curvey.edges.Edges(points=self.points, edges=self.edges)

    @cached_property
    def edges(self) -> ndarray:
        """A `(n_faces * 3, 2)` array of edge connectivity"""
        f = self.faces
        return concatenate(
            [
                f[:, [0, 1]],
                f[:, [1, 2]],
                f[:, [2, 0]],
            ],
            axis=0,
        )

    @cached_property
    def is_boundary_vertex(self) -> ndarray:
        """`(n_points,) vector of booleans True if the vertex is on the triangulation boundary"""
        return isin(arange(self.n_points), self.boundary_edges.edges)

    @cached_property
    def shapely(self) -> shapely.MultiPolygon:
        """A `shapely.MultiPolygon` of trangles"""
        return shapely.MultiPolygon([shapely.Polygon(self.points[tri]) for tri in self.faces])

    @cached_property
    def tree(self) -> shapely.STRtree:
        """A `shapely.STRtree` of the triangles"""
        return shapely.STRtree(self.shapely.geoms)

    def signed_distance(self, points: PointsLike) -> ndarray:
        """Signed distance from the boundary

        Signed distance is positive if the point is outside the triangulation, negative inside,
        and zero if the point is on the boundary.
        """
        points = asanyarray(points)
        if points.ndim == 1:
            points = points[newaxis]

        pts = shapely.MultiPoint(points).geoms
        (_pts_idx, _edge_idx), boundary_dist = self.boundary_edges.tree.query_nearest(
            pts, return_distance=True, all_matches=False
        )

        (_pts_idx, _tri_idx), tri_dist = self.tree.query_nearest(
            pts, return_distance=True, all_matches=False
        )
        boundary_dist[tri_dist == 0] *= -1
        return boundary_dist

    @cached_property
    def boundary_edges(self) -> curvey.edges.Edges:
        """Edges on the boundary of the triangulation

        Boundary edges are edges that only belong to one triangle.
        """
        # Border edges only appear once; internal edges twice; once in each orientation
        directed_edges = self.edges
        undirected_edges = np.sort(directed_edges, axis=1)
        _unq_edges, unq_idx, n = np.unique(
            undirected_edges, axis=0, return_index=True, return_counts=True
        )
        directed_border_edges = directed_edges[unq_idx[n == 1]]
        return curvey.edges.Edges(self.points, directed_border_edges)

    def boundary_loops(self, idx_name: str | None = None) -> Iterator[curvey.curve.Curve]:
        """Iterate over directed boundary loops

        Parameters
        ----------
        idx_name
            If supplied, the original point index is stored in the curve metadata parameter
            named `idx`.

        Yields
        ------
        loop :
            Boundary loop as a `curvey.curve.Curve`. Orientation is maintained.

        """
        g = nx.DiGraph()
        g.add_edges_from(self.boundary_edges.edges)
        for loop in nx.simple_cycles(g):
            c = curvey.curve.Curve(self.points[loop])
            if idx_name is not None:
                c = c.with_data(**{idx_name: array(loop)})
            yield c

boundary_edges: curvey.edges.Edges cached property ¤

Edges on the boundary of the triangulation

Boundary edges are edges that only belong to one triangle.

edge: ndarray cached property ¤

A (n_tris, 2, 2) array of edge vectors

self.edge[i, 0] and self.edge[i, 1] are the unnormalized edge vectors of the first two edges in triangle i.

edges: ndarray cached property ¤

A (n_faces * 3, 2) array of edge connectivity

faces: ndarray = asanyarray(faces) instance-attribute ¤

(n_faces, 3) integer array of vertex indices.

is_boundary_vertex: ndarray cached property ¤

`(n_points,) vector of booleans True if the vertex is on the triangulation boundary

n_faces: int property ¤

Number of triangles

n_points: int property ¤

Number of points

points: ndarray = asanyarray(points) instance-attribute ¤

(n_points, 2) array of vertex coordinates.

shapely: shapely.MultiPolygon cached property ¤

A shapely.MultiPolygon of trangles

signed_area: ndarray cached property ¤

A length n_tris vector of signed triangle areas

tree: shapely.STRtree cached property ¤

A shapely.STRtree of the triangles

boundary_loops(idx_name: str | None = None) -> Iterator[curvey.curve.Curve] ¤

Iterate over directed boundary loops

Parameters:

Name Type Description Default
idx_name str | None

If supplied, the original point index is stored in the curve metadata parameter named idx.

 None

Yields:

Name Type Description
loop Curve

Boundary loop as a curvey.curve.Curve. Orientation is maintained.
Source code in src\curvey\triangulation.py 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
def boundary_loops(self, idx_name: str | None = None) -> Iterator[curvey.curve.Curve]:
    """Iterate over directed boundary loops

    Parameters
    ----------
    idx_name
        If supplied, the original point index is stored in the curve metadata parameter
        named `idx`.

    Yields
    ------
    loop :
        Boundary loop as a `curvey.curve.Curve`. Orientation is maintained.

    """
    g = nx.DiGraph()
    g.add_edges_from(self.boundary_edges.edges)
    for loop in nx.simple_cycles(g):
        c = curvey.curve.Curve(self.points[loop])
        if idx_name is not None:
            c = c.with_data(**{idx_name: array(loop)})
        yield c

plot_tris(ax: Axes | None = None, **kwargs) -> tuple[Line2D, Line2D] ¤

Plot the triangulation

Parameters:

Name Type Description Default
ax Axes | None

Axes to plot in, default current axes.

 None
**kwargs

Passed to matplotlib.pyplot.triplot

 {}
Source code in src\curvey\triangulation.py 
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def plot_tris(self, ax: Axes | None = None, **kwargs) -> tuple[Line2D, Line2D]:
    """Plot the triangulation

    Parameters
    ----------
    ax
        Axes to plot in, default current axes.

    **kwargs
        Passed to `matplotlib.pyplot.triplot`
    """
    ax = _get_ax(ax)
    x, y = self.points.T
    return ax.triplot(x, y, self.faces, **kwargs)

reverse() -> Triangulation ¤

Reverse the orientation of each triangle

Source code in src\curvey\triangulation.py 
57
58
59
def reverse(self) -> Triangulation:
    """Reverse the orientation of each triangle"""
    return Triangulation(points=self.points, faces=self.faces[:, ::-1])

signed_distance(points: PointsLike) -> ndarray ¤

Signed distance from the boundary

Signed distance is positive if the point is outside the triangulation, negative inside, and zero if the point is on the boundary.

Source code in src\curvey\triangulation.py 
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
def signed_distance(self, points: PointsLike) -> ndarray:
    """Signed distance from the boundary

    Signed distance is positive if the point is outside the triangulation, negative inside,
    and zero if the point is on the boundary.
    """
    points = asanyarray(points)
    if points.ndim == 1:
        points = points[newaxis]

    pts = shapely.MultiPoint(points).geoms
    (_pts_idx, _edge_idx), boundary_dist = self.boundary_edges.tree.query_nearest(
        pts, return_distance=True, all_matches=False
    )

    (_pts_idx, _tri_idx), tri_dist = self.tree.query_nearest(
        pts, return_distance=True, all_matches=False
    )
    boundary_dist[tri_dist == 0] *= -1
    return boundary_dist

to_edges() -> curvey.edges.Edges ¤

An edge soup

Returns:

Name Type Description
edges Edges

An edge set with points self.points and n_edges=3 * self.n_faces
Source code in src\curvey\triangulation.py 
81
82
83
84
85
86
87
88
89
90
def to_edges(self) -> curvey.edges.Edges:
    """An edge soup

    Returns
    -------
    edges :
        An edge set with points `self.points` and `n_edges=3 * self.n_faces`

    """
    return curvey.edges.Edges(points=self.points, edges=self.edges)