voronoi | Now on gitlab | Canvas library

You can pass linewidth=0 to plt.fill() to get rid of the lines.

Something like this could work:

Using the first code block from the question that shows filling the simpler graph, I constructed an example network. The edges are listed below:

I believe that your best bet is to use some kind of multiple polygon intersection algorithm using the cell vertices to describe the polygons.

You can whittle down the number of polygons by discarding those whose rightmost vertex is left of the blue rectangle, those whose leftmost vertex is to the right, and so on for up and down. This leaves you with the yellow polygons only.

You can also quickly eliminate (only, in this case you mark them as "intersecting") all those whose center or vertex lies inside the rectangle. This also is very quick.

In this example this is enough to locate all cells.

In other cases (for example, in the figure below, if the bottom-left yellow cell was shifted slightly upwards) you will have cells that have all vertices and the Delaunay center outside the rectangle, and yet one edge crosses it, so there is an intersection. To recognize those, you can exploit the fact that a rectangle is a convex figure, and check whether, among the cells you've left, there is one that contains at least one of the rectangle's corners. This is a slightly more complex check ("whether a point lies inside a convex polygon"), but not too complex since the cell is also convex and can be trivially decomposed in triangles.

The pseudo algorithm would be:

• for all Voronoi cells:
  • get list of vertices.
  • are they all left/below/above/right of the rectangle?
  • YES: this cell does not intersect. Continue.
  • for all the vertices plus the cell center:
    • is this point inside the rectangle?
    • YES: we have intersection. Report this cell and continue.
  • decompose the cell in a list of triangles with vertex in the Delaunay center, taking ordered vertex pairs.
  • for each triangle
    • for each vertex of the rectangle
      • is the vertex inside the triangle?
      • YES: we have intersection. Report and continue
  • this cell does not intersect the rectangle.

scipy says it uses QHull to compute voronoi diagrams, and they have this in their documentation:

The furthest-site Voronoi diagram is the furthest-neighbor map for a set of points. Each region contains those points that are further from one input site than any other input site.

Furthest (or "farthest")-site diagrams are described in plenty of other places, including example diagrams; for example, in other stackexchange posts: 1, 2.

Your plot looks odd because your pointset is somewhat degenerate; only the four corner points ever serve as the furthest reference point.

You should create a fig, ax object, and pass the ax argument to the voronoi_plot_2d as suggested in the comments by @Jody Klymak, like:

vor.ridge_points is a Nx2 array containing all the Delaunay edges. The values are the indices into the input array points. For example, one edge goes from point number vor.ridge_points[0,0] to point number vor.ridge_points[0,1].

In 2D, regions are separated by a single line segment, thus always 2 points per ridge. In 3D and up, regions separation "plane segments" are typically triangular, but they can have 4+ edges, too.

For sceletonization purposes, one approach would be to show the outline of the separation region, skipping virtual (-1) points. So, [3, 0, -1] would translate to one line between points 3 and 0. [1, 0, 3, 2] will generate segments 1-0, 0-3, 3-2, 2-1. As an additional improvement, ridges with 4+ points can be further split into trianges, so in case of [1, 0, 3, 2] another segment would be 0-2 or 1-3.

I am still not sure if I got the question right, let me know if I didn't

Here is a possible converted code. Notice that you can easily connect the DOM API with Observablehq abstractions, losing the reactivity from the Observablehq runtime.