delaunay-triangulation | C version the delaunay triangulation | Learning library

The Delaunay triangulation is a mathematically defined triangulation that does not involve the concept of a maximum segment length. If you want to constrain the maximum length of the segments in the triangulation, then it's not a Delaunay triangulation any more, and the algorithm for computing the Delaunay triangulation is not applicable.

You will have to specify what you want to happen when you impose a limit on the segment length. Should the algorithm just delete the edges which are too long? Delete the triangles that have an edge which is too long? If you delete stuff then the result is no longer a triangulation of the original points. Do you want to produce a different triangulation?

If X is your point pattern, then

In OpenCV, I do not believe that there is any readily available function to do that. You would have to loop over each pixel in the image and compute the barycentric (area) interpolation. See for example, https://codeplea.com/triangular-interpolation

However, in Python/Wand (based upon ImageMagick), you can do it as follows:

The problem in these symmetric configuration is that the Delaunay triangulation is not uniquely defined: whenever there are four vertices on a common circle, the Voronoi diagram does not specify how it should be triangulated. So opposite points may or may not be connected in the triangulation.

Here is an exaggerated picture of the Voronoi diagram with inflated the zero length edges in the Voronoi diagram.

The red circled edge in the Voronoi diagram is actually zero length and may or may not actually appear and correspond to an edge in the Delaunay triangulation.

You probably want to just ignore neighbors associated with these degenerate Voronoi edges (so that the neighbors of all vertices are those in your image here). However, scipy .spatial.Voronoi doesn't make this really easy: you can find short Voronoi edges but not the corresponding neighboring Voronoi sites. In the Delaunay triangulation, you can look at the two triangles connected to an edge: between those two trianlges, there are four vertices. If all four vertices are cocircular (or very nearly cocircular), then the associated Voronoi edge is degenerate and that neighbor can be ignored.

Here is some code that separates large edges from small:

Your code is quite sub-optimal, but that doesn't matter now (you're learning, right?. I'll focus on triangulation issues.

EDITED: You initialize yMin and yMax members of Triangulation at sort() and use them later for the "big enclosing" triangle. If you decide not to use "sort()" you'll use initialized values. Put some defaults on it.

Sorting the points is not needed for building the triangulation. You use it just to find the BB, too much effort, and at the end shuffle them, again too much effort.

The main issue (in your first post, before you edited it) I see is the way of finding if a point is inside a triangle, on its boundary, or outside of it.
Triangle::isOnTriangle() is horrible. You calculate several crossproducts and return '0' (inside triangle) is none of them equals '0'.
You may argue that you know in advance that the point is not outside because you tested it before by Triangle::contains(), but this function is also horrible, not that much though.

The best (or at least easiest and most used) way to find the relative position of a point to a line is

Some helpers:

Since it's rare to have a vertex in a Delaunay triangulation have much more than 6 edges, you can use brute force: there are only 20+15+6 ways to select 3, 4, or 5 edges out of 6 (respectively), so try all of them. For each of the 41 (up to 336 for degree 9) small trees (the root and a few edges) thus created, run either Kruskal's algorithm or Prim's algorithm starting with that tree already "found" to be part of the MST. (Ignore the root's other edges so as not to increase its degree further.) Then just pick the best one (including the cost of the seed tree).

As for the general neighbor information problem, it seems you just need to build a standard graph representation first. For example, you can make an adjacency list by scanning over all your Edge objects and storing each endpoint in a list associated with the other (in a map,vector>> or an equivalent based on whatever identifiers for your vertices).

Based on the reference manual (https://cran.r-project.org/web/packages/deldir/index.html), the output of the deldir function is a list. One of the list element, summary, is a data frame, which contains a column called dir.area. This is the the area of the Dirichlet tile surrounding the point, which could be what you are looking for.

Below I am using the example from the reference manual. Use $ to access the summary data frame.