Triangulating a Monotone Polygon

Intro

I really had a tough time with this algorithm. Firstly whenever I see someone talking about acute angles in algorithms I feel like puking. "interior cusps", "reflex chain", ... If you ever pull out an old geometry book and spend many hours reasoning in that stuff you may know where I am coming from, but as I spend a lot of time in algebra I came to the conclusion that often this geometric reasoning is humbug.

What I have done is implement the same algorithm from a more approachable and visually simpler perspective. I have verified that its the same algorithm by comparing my tessellation with the know algorithm tessellation of the same monotone polygon and they are an exact match, so I am confident that they are the same algorithm.

I did the algorithm tessellation by hand for the example polygon and produced the given table, which is viewed as columns of points which describe the algorithms tessellation state. When points are popped off the stack is where the triangles are being tessellated.

The ↑ and ↓ are the two ways the stack is processed. When a new point is added it is pushed to the front of the stack. The two previous points define a line. Choices are made on how to connect the new point depending whether the new point is visible to a previous line segment.

The coloring goes some way to explaining the computation because whenever two opposite are pushed onto the stack they are visible and then the greedy tessellation begins - the ↑ operation.

However you could have two points added on the same side(having the same color). 5o4o3* was an example where the last two points added where white. Again from the table the processing of the stack was in a certain way which I called ↓. What triggers this is a concept of a point being visible to the previous line segment.

For a line segment with two points the same color visibility is a vector pointing into the tessellation body. ie for a line on the right its the normal to that line pointing in the left direction. for a line on the left side its its normal pointing in the right direction.

Algorithms Tessellation

5o↓

6*↑

7o↑

8*↑

9o↑

10*↑

5,4,3

6,5,3

7,6,5

8,7,6

9,8,7

10,9,8

4o↑

4,3,2

4,2,1

4,1,0

9o	9o	9o	9o	9o	12*	12*	13o	13o	13o	13o
10*	10*	10*	12*	12*	13o	13o	14*	14*	14*	16*
	11*	11*		13o↑		14*↑		15*	15*
		12*↓		13,12,9		14,13,12			16*↓
		12,11,9							16,15,14
									16,14,13

13o	16*	16*	16*	16*	18o	18o	18o	18o
16*	17o	17o	18o	18o	19*	19*	20*	20*
17o↑		18o↓		19*↑		20*↓		21o↑
17,16,13		18,17,16		19,18,16		20,19,18		21,20,18

...

Table Key

Points on the right are colored black and have a star operator on the right. eg 15* says the point 15 is black colored. o indicates the point is white in color, and these points are on the left hand side.

4,3,2 represents a triangle tessellation, and occur below the arrow event.

Algorithm

Sort vertexes by y-coordinate.
Let v iterate from the highest point to the lowest point.
Initialize the stack p by pushing v twice to the front of the stack.

while $v \neq$ lowest vertex do

push point $v$ to front of stack $p$ .

Case 1: $p_{0}$ has the opposite color to $p_{1}$

Triangle fan about $p_{0}$ clearing and returning by pushing to the front of the stack $p_{1}$ and $p_{0}$ .

Case 2: $p_{0}$ has the same color as $p_{1}$

while $p_{0}$ is visible to $line (p_{1}, p_{2})$ do

Tessellate a triangle from $p_{0}$ , $p_{1}$ , $p_{2}$ .
Delete $p_{1}$

You will notice that there are two nested loops in the algorithm, yet the algorithm is known to be O(n). This is because the inner loop is constant in the sense that it iterates only as much as the outer loop. Since this multiplies by two its just a constant, and the complexity is still that of the outer loop O(n).

Algorithm from Computational Geometry in C

Sort vertexes by y-coordinate.
Initialize reflex chain to be two top vertexes.
Let $v$ be the third-highest vertex.

while $v \neq$ lowest vertex do

Case 1: $v$ is on chain opposite to reflex chain.

Draw diagonal from $v$ to top of reflex chain $v_{+}$ , and remove top of chain. If reflex chain is empty then advance $v$ .

Case 2: $v$ is adjacent to bottom of reflex chain.

Case 2a: $v_{+}$ is strictly convex.

Draw diagonal from $v$ to bottom of reflex chain, and remove bottom of chain. If reflex chain is empty then advance $v$ .

Case 2b: $v_{+}$ is reflex or flat.

Add $v$ to bottom of reflex chain. Advance $v$ .

See O'Rourke[1].

I have included this algorithm for the purposes of comparing it with my own. Two people can witness the same event but have very different perspectives about just what went on. What is reality?

I do not understand the above algorithm as given, and I do not think that I ever will. This lead me to an investigation which looked at the tessellation from the point of view of stacks.

References

O'Rourke Joseph (1994). Computational Geometry in C. ISBN 0-521-445922. Page 57.

<TODO>

Redocument the algorithm and replace the line sees with the half space.
Generalize the algorithm to 3D where the girth is a triangle. Compare with 2D where the girth is a straight line.