The task of triangulation can be completed in logarithmic time, based on the amount of regions and how many nodes each region contains. However, it is not
uncommon for regions to contain many segments that lie on the same line. When this is the case, often times the region can be split into multiple smaller
regions. The benefit of doing so is that there are less triangles that are generated, and each region can be triangulated in parallel, for a bonus speed
increase. The downside is that splitting a region in the most optimal method can be quite costly. It would take polynomial time based on the number of
nodes in order to find the combination of regions that would decrease triangle count the most. However, it can be argued that for certain region shapes
which may occur frequently such as the topology of connected Minecraft blocks, it may be worth the investment if time is less of an issue, and memory
usage matters more.

Ideal time: O(n) or O(nlog(n))

For each point:
- Find all intersecting edges
  - Easy check, see which side both ends of each segment are on
    - If different sides, then it intersects with the line
- Find all other segments on the same line
  - Easy check, find all lines with the same slope and intersection point or something
  - Need to check if segment can be connected to
    - This means checking all intersecting edges
  - Also need to check for individual points
    - A segment and a point results in 1 less triangle
    - Two segments results in 2 less triangles
- Find all intersections with potential segments
  - For each potential segment, check for intersection with each other
  - Count how many it intersects with
  - Greedy method... Add lines with least amount of intersections first?
    - According to the rule of mutual crosses, the total amount of intersections is always even
    
The overall algorithm can be broken down into 3 parts:
- Finding all possible segments between 3 or more points
- Removing all connections that intersect with the polygon edges
- Determining how many other possible segments intersect with each other
The first two are both O(n^2) time, which is unfortunate. It is unknown if it could
be made into O(logn) or better.
The last part is O(logn)

Obviously, one can determine which points are visible from one point by iterating
over every edge and building a depth field. Then, all potential connecting segments
can be found by checking each visible point.
Alternatively, one can check each point to see if it lies on the same segment?
A logical structure to hold a segment would be the two endpoints, and any points that are
contained by the...
