Algorithm to convert a collection of edges into collection of triangles

Question

I have implemented a polygon triangulation algorithm into my program. The algorithm first takes a simple polygon , described as 2D points/vertices, and splits it into y-monotone pieces . After this is done, the algorithm then takes each monotone polygon piece and splits it into triangular pieces.

The input to the algorithm I need help with is an array of vertices outlining a y-monotonic polygon in clockwise or counter-clockwise order. The output is a collection of all edges, both from the original polygon but also the new ones added by the triangulation algorithm in order to split this y-monotonic piece into triangular pieces. This works great if I only want to paint the result as it's possible to just draw each edge.

However, there is no particular order to this collection of edges, and I need the output to be an array of type triangle strip or an array where each triangle is simply described by it's 3 vertices (Example: [a1,a2,a3,b1,b2,b3] as we have triangle a and triangle b ).

Is there any conventional algorithm or any other way which can help me solve this? Speed is not of extreme importance but I'd prefer a fast solution.

Here is a pseudocode example of the program used in order to give a better understanding of my question:

class Vertex {
 var point;
 var index;
 init(x,y,index){
   point = (x,y)
   self.index = index
 }
}

class Edge {
 var from; // of type Vertex
 var to; // of type Vertex
 init(from, to){
  self.from = from
  self.to = to
 }
}

A call to a function getMonotonePiecesOfPolygon(polygon) could generate one of many monotonic polygon pieces that would have these vertices and edges:

var vertex0 = Vertex(x0,y0,0)
var vertex1 = Vertex(x1,y1,1)
var vertex2 = Vertex(x2,y2,2)
var vertex3 = Vertex(x3,y3,3)

var edge0 = Edge(vertex0, vertex1)
var edge1 = Edge(vertex1, vertex2)
var edge2 = Edge(vertex2, vertex3)
var edge3 = Edge(vertex3, vertex4)

This could correspond to a rectangle like this:

         edge0
       0------1
       |      |
 edge3 |      | edge1
       |      |
       3------2 
         edge2

Then, we can supply these edges in an array and divide the polygon into triangles with the a triangulation method 'makeMonotonePolygonIntoTrianglePieces()'

var edgesArray = [edge0,edge1,edge2,edge3]  
var edgesArray = makePolygonIntoTrianglePieces(edgesArray)

Now the edgesArray could look like this:

edgesArray == [edge0,edge1,edge2,edge3,newEdge1]

where

newEdge1.from == vertex0
newEdge1.to == vertex2

which would correspond to a polygon like this if we were to draw each edge:

         edge0
       0------1
       |\     |
 edge3 |  \   | edge1
       |    \ |
       3------2 
         edge2

Now here is the part of what my question is seeking to solve. I need an array which would look like this:

var triangles = [
                 vertex0,vertex3,vertex2, 
                 vertex0,vertex2,vertex1
                ]

or using triangle strips (each triangle described by one new vertex and two vertices from the previous triangle):

var triangles = [
                 vertex3, vertex2, vertex0,
                 vertex1
                ]  

Answer 1

In Chapter 2 of the book you refer to in one of the comments, they present a data structure called Doubly-Connected Edge List (DCEL). DCEL:s are used to store planar subdivisions such as triangulations. From what you write, I think it could be what you are looking for.

https://en.wikipedia.org/wiki/Doubly_connected_edge_list