Merge branch 'master' into doc_objectlist

blitz.mod/blitz_array.c

@@ -215,6 +215,10 @@ BBArray *bbArrayNew1D( const char *type,int length ){
 	return arr;
 }
 
+BBArray *bbArrayNew1DNoInit( const char *type,int length ){
+	return allocateArray( type,1,&length, 0 );
+}
+
 BBArray *bbArrayNew1DStruct( const char *type,int length, unsigned short data_size, BBArrayStructInit init ){
 
 	BBArray *arr=allocateArray( type,1,&length, data_size );

blitz.mod/blitz_array.h

@@ -79,6 +79,7 @@ BBArray*	bbArrayNewStruct( const char *type,unsigned short data_size, BBArrayStr
 BBArray*	bbArrayFromDataStruct( const char *type,int length,void *data, unsigned short data_size );
 BBArray*	bbArraySliceStruct( const char *type,BBArray *inarr,int beg,int end, unsigned short data_size, BBArrayStructInit structInit );
 BBArray*	bbArrayFromDataSize( const char *type,int length,void *data, unsigned short data_size );
+BBArray*	bbArrayNew1DNoInit( const char *type,int length );
 
 void bbArrayCopy(BBArray * srcArr, int srcPos, BBArray * dstArr, int dstPos, int length);
 

d3d7max2d.mod/d3d7max2d.bmx

@@ -391,7 +391,7 @@ Type TD3D7Max2DDriver Extends TMax2DDriver
 		device.DrawPrimitive(D3DPT_TRIANGLEFAN,D3DFVF_XYZ|D3DFVF_DIFFUSE,vrts,segs,0)
 	End Method
 
-	Method DrawPoly( xy#[],handlex#,handley#,tx#,ty# )
+	Method DrawPoly( xy#[],handlex#,handley#,tx#,ty#, indices:Int[] )
 		If Not IsValid() Return
 
 		If xy.length<6 Or (xy.length&1) Return

d3d9max2d.mod/d3d9max2d.bmx

@@ -1047,7 +1047,7 @@ Type TD3D9Max2DDriver Extends TMax2dDriver
 		_d3dDev.DrawPrimitiveUP D3DPT_TRIANGLEFAN,segs-2,fverts,24
 	End Method
 	
-	Method DrawPoly( verts#[],handlex#,handley#,tx#,ty# ) Override
+	Method DrawPoly( verts#[],handlex#,handley#,tx#,ty#, indices:Int[] ) Override
 		If verts.length<6 Or (verts.length&1) Return
 		Local segs:Int=verts.length/2
 		Local fverts#[segs*6]

glmax2d.mod/glmax2d.bmx

@@ -786,7 +786,7 @@ Type TGLMax2DDriver Extends TMax2DDriver
 		
 	End Method
 	
-	Method DrawPoly( xy#[],handle_x#,handle_y#,origin_x#,origin_y# ) Override
+	Method DrawPoly( xy#[],handle_x#,handle_y#,origin_x#,origin_y#, indices:Int[] ) Override
 		If xy.length<6 Or (xy.length&1) Return
 		
 		DisableTex

map.mod/map.bmx

@@ -138,17 +138,10 @@ End Type
 
 Type TNodeEnumerator
 	Method HasNext:Int()
-		Local has:Int = _node<>nil
-		If Not has Then
-			_map = Null
-		End If
-		Return has
+		Return _node<>nil
 	End Method
 	
 	Method NextObject:Object()
-?ngcmod
-		Assert _expectedModCount = _map._modCount, "TMap Concurrent Modification"
-?
 		Local node:TNode=_node
 		_node=_node.NextNode()
 		Return node
@@ -157,16 +150,10 @@ Type TNodeEnumerator
 	'***** PRIVATE *****
 		
 	Field _node:TNode
-	
-	Field _map:TMap
-	Field _expectedModCount:Int
 End Type
 
 Type TKeyEnumerator Extends TNodeEnumerator
 	Method NextObject:Object() Override
-?ngcmod
-		Assert _expectedModCount = _map._modCount, "TMap Concurrent Modification"
-?
 		Local node:TNode=_node
 		_node=_node.NextNode()
 		Return node._key
@@ -175,9 +162,6 @@ End Type
 
 Type TValueEnumerator Extends TNodeEnumerator
 	Method NextObject:Object() Override
-?ngcmod
-		Assert _expectedModCount = _map._modCount, "TMap Concurrent Modification"
-?
 		Local node:TNode=_node
 		_node=_node.NextNode()
 		Return node._value
@@ -211,9 +195,6 @@ Type TMap
 		If _root=nil Return
 		_root.Clear
 		_root=nil
-?ngcmod
-		_modCount :+ 1
-?
 	End Method
 	
 	Rem
@@ -253,10 +234,6 @@ Type TMap
 		node._color=RED
 		node._parent=parent
 
-?ngcmod
-		_modCount :+ 1
-?
-		
 		If parent=nil
 			_root=node
 			Return
@@ -295,10 +272,7 @@ Type TMap
 	Method Remove:Int( key:Object )
 		Local node:TNode=_FindNode( key )
 		If node=nil Return 0
-		 _RemoveNode node
-?ngcmod
-		_modCount :+ 1
-?
+		_RemoveNode node
 		Return 1
 	End Method
 	
@@ -312,10 +286,6 @@ Type TMap
 		nodeenum._node=_FirstNode()
 		Local mapenum:TMapEnumerator=New TMapEnumerator
 		mapenum._enumerator=nodeenum
-		nodeenum._map = Self
-?ngcmod
-		nodeenum._expectedModCount = _modCount
-?
 		Return mapenum
 	End Method
 	
@@ -329,10 +299,6 @@ Type TMap
 		nodeenum._node=_FirstNode()
 		Local mapenum:TMapEnumerator=New TMapEnumerator
 		mapenum._enumerator=nodeenum
-		nodeenum._map = Self
-?ngcmod
-		nodeenum._expectedModCount = _modCount
-?
 		Return mapenum
 	End Method
 	
@@ -355,10 +321,6 @@ Type TMap
 	Method ObjectEnumerator:TNodeEnumerator()
 		Local nodeenum:TNodeEnumerator=New TNodeEnumerator
 		nodeenum._node=_FirstNode()
-		nodeenum._map = Self
-?ngcmod
-		nodeenum._expectedModCount = _modCount
-?
 		Return nodeenum
 	End Method
 	
@@ -592,10 +554,6 @@ Type TMap
 	Const RED:Int=-1,BLACK:Int=1
 	
 	Field _root:TNode=nil
-	
-?ngcmod
-	Field _modCount:Int
-?
 End Type
 
 Rem

max2d.mod/driver.bmx

@@ -57,7 +57,7 @@ Type TMax2DDriver Extends TGraphicsDriver
 	Method DrawLine( x0#,y0#,x1#,y1#,tx#,ty# ) Abstract
 	Method DrawRect( x0#,y0#,x1#,y1#,tx#,ty# ) Abstract
 	Method DrawOval( x0#,y0#,x1#,y1#,tx#,ty# ) Abstract
-	Method DrawPoly( xy#[],handlex#,handley#,originx#,originy# ) Abstract
+	Method DrawPoly( xy#[],handlex#,handley#,originx#,originy#, indices:Int[] ) Abstract
 		
 	Method DrawPixmap( pixmap:TPixmap,x:Int,y:Int ) Abstract
 	Method GrabPixmap:TPixmap( x:Int,y:Int,width:Int,height:Int ) Abstract

max2d.mod/max2d.bmx

@@ -441,10 +441,10 @@ about:
 BlitzMax commands that affect the drawing of polygons include #SetColor, #SetHandle, 
 #SetScale, #SetRotation, #SetOrigin, #SetViewPort, #SetBlend and #SetAlpha.
 End Rem
-Function DrawPoly( xy#[] )
+Function DrawPoly( xy:Float[], indices:Int[] = Null )
 	_max2dDriver.DrawPoly xy,..
 	gc.handle_x,gc.handle_y,..
-	gc.origin_x,gc.origin_y
+	gc.origin_x,gc.origin_y, indices
 End Function
 
 Rem

objectlist.mod/doc/intro.bbdoc

@@ -7,4 +7,4 @@ In most cases it is faster than the namend alternatives but of course it
 depends on the way you are using it in your code. So make sure to
 benchmark according to your individual use case.
 
-Object lists can replace #TList easily when used in OOP-style as they share method names.
+Object lists can replace #TList easily when used in OOP-style as they share method names.

objectlist.mod/objectlist.bmx

@@ -5,10 +5,12 @@ bbdoc: Data structures/Array-backed Object Lists
 End Rem
 Module BRL.ObjectList
 
-ModuleInfo "Version: 1.00"
+ModuleInfo "Version: 1.01"
 ModuleInfo "Author: Bruce A Henderson"
 ModuleInfo "License: zlib/libpng"
 
+ModuleInfo "History: 1.01"
+ModuleInfo "History: Implemented Swap()."
 ModuleInfo "History: 1.00"
 ModuleInfo "History: Initial Release."
 
@@ -55,6 +57,7 @@ Type TObjectList
 	bbdoc: Adds an object to the start of the list
 	End Rem
 	Method AddFirst(value:Object)
+		Assert value Else "Can't insert Null object into list"
 		Compact()
 		
 		If size Then
@@ -71,6 +74,7 @@ Type TObjectList
 	bbdoc: Adds an object to the end of the list
 	End Rem
 	Method AddLast(value:Object)
+		Assert value Else "Can't insert Null object into list"
 		Compact()
 		
 		_ensureCapacity(size + 1)
@@ -232,8 +236,27 @@ Type TObjectList
 		End If
 	End Method
 	
+	Rem
+	bbdoc: Swaps content of two lists while keeping list references intact.
+	End Rem
 	Method Swap(list:TObjectList)
+		If Not list Then
+			Return
+		End If
+		Local tmpVersion:Int = list.version
+		Local tmpData:Object[] = list.data
+		Local tmpSize:int = list.size
+		Local tmpDirty:int = list.dirty
+		
+		list.version = self.version
+		list.data = self.data
+		list.size = self.size
+		list.dirty = self.dirty
 		
+		self.version = tmpVersion
+		self.data = tmpData
+		self.size = tmpSize
+		self.dirty = tmpDirty
 	End Method
 
 	Rem

polygon.mod/common.bmx

@@ -0,0 +1,30 @@
+' ISC License
+' 
+' Copyright (c) 2023, Bruce A Henderson
+' 
+' Permission to use, copy, modify, and/or distribute this software for any purpose
+' with or without fee is hereby granted, provided that the above copyright notice
+' and this permission notice appear in all copies.
+' 
+' THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+' REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+' FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+' INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+' OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+' TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+' THIS SOFTWARE.
+'
+SuperStrict
+
+Import BRL.Vector
+
+Import "earcut/include/*.h"
+
+Import "glue.cpp"
+
+Extern
+
+	Function bmx_polygon_tri_svec2i:Int[](poly:SVec2I Ptr, size:Int)
+	Function bmx_polygon_tri_svec2f:Int[](poly:SVec2F Ptr, size:Int)
+
+End Extern

polygon.mod/earcut/CHANGELOG.md

@@ -0,0 +1,27 @@
+## Earcut.hpp changelog
+
+### master
+
+ - Fixed a bunch of rare edge cases that led to bad triangulation (parity with Earcut v2.2.2)
+ - Removed use of deprecated `std::allocator::construct`
+ - Fixed a minor z-order hashing bug
+ - Improved visualization app, better docs
+
+### v0.12.4
+
+ - Fixed a crash in Crash in Earcut::findHoleBridge
+ - Added coverage checks
+ - Added macOS, MinGW builds
+
+### v0.12.3
+
+ - Fixed -Wunused-lambda-capture
+
+### v0.12.2
+
+ - Fixed potential division by zero
+ - Fixed -fsanitize=integer warning
+
+### v0.12.1
+
+ - Fixed cast precision warning

polygon.mod/earcut/CMakeLists.txt

@@ -0,0 +1,151 @@
+cmake_minimum_required(VERSION 3.2)
+project(earcut_hpp LANGUAGES CXX C)
+
+option(EARCUT_BUILD_TESTS "Build the earcut test program" ON)
+option(EARCUT_BUILD_BENCH "Build the earcut benchmark program" ON)
+option(EARCUT_BUILD_VIZ "Build the earcut visualizer program" ON)
+option(EARCUT_WARNING_IS_ERROR "Treat warnings as errors" OFF)
+
+if (NOT CMAKE_BUILD_TYPE AND NOT GENERATOR_IS_MULTI_CONFIG)
+    message(STATUS "No build type specified. Setting to 'Release'")
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "The type of build." FORCE)
+endif()
+
+
+include(GNUInstallDirs)
+
+add_library(earcut_hpp INTERFACE)
+add_library(earcut_hpp::earcut_hpp ALIAS earcut_hpp)
+
+target_include_directories(earcut_hpp INTERFACE
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+set(CMAKE_CXX_STANDARD 11)
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 3.7)
+    # Allow C++11 requirements to propagate when using recent CMake versions
+    target_compile_features(earcut_hpp INTERFACE cxx_std_11)
+endif()
+
+file(GLOB FIXTURE_SOURCE_FILES test/fixtures/*.cpp test/fixtures/*.hpp)
+source_group(fixtures FILES ${FIXTURE_SOURCE_FILES})
+add_library(fixtures OBJECT ${FIXTURE_SOURCE_FILES})
+target_compile_options(fixtures PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/Od>)
+
+# In CMake 3.12, use target_link_libraries(fixtures PUBLIC earcut_hpp libtess2).
+# Since we support down to CMake 3.2, we need to manually propagate usage requirements of earcut_hpp
+target_include_directories(fixtures PRIVATE "$<TARGET_PROPERTY:earcut_hpp,INTERFACE_INCLUDE_DIRECTORIES>")
+target_compile_features(fixtures PRIVATE "$<TARGET_PROPERTY:earcut_hpp,INTERFACE_COMPILE_FEATURES>")
+
+
+file(GLOB COMPARISON_SOURCE_FILES test/comparison/*.cpp test/comparison/*.hpp)
+source_group(comparison FILES ${COMPARISON_SOURCE_FILES})
+# this is interface since there is no cpp files in the comparison directory
+add_library(comparison INTERFACE)
+
+
+file(GLOB LIBTESS2_SOURCE_FILES test/comparison/libtess2/*.c test/comparison/libtess2/*.h)
+source_group(comparison/libtess2 FILES ${LIBTESS2_SOURCE_FILES})
+add_library(libtess2 ${LIBTESS2_SOURCE_FILES})
+target_compile_options(libtess2 PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:/wd4244 /wd4267>
+    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-w>
+)
+
+add_library(common INTERFACE)
+target_link_libraries(common INTERFACE libtess2 comparison)
+
+# optional: -march=native (builds with the optimizations available on the build machine (only for local use!))
+target_compile_options(common INTERFACE
+    $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pipe -Wall -Wextra -Wconversion -Wpedantic>
+)
+
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang$" OR CMAKE_COMPILER_IS_GNUCXX)
+    if ("${CMAKE_CXX_FLAGS}" MATCHES "--coverage")
+        # We disable debug code for the coverage so it won't see assertion and other things only enabled for debugging
+        target_compile_definitions(common INTERFACE NDEBUG)
+    else()
+        # Here we enable the undefined behavior sanitizer for the tests, benchmarks and the viz
+        include(CheckCXXCompilerFlag)
+        check_cxx_compiler_flag("-fsanitize=undefined" HAVE_FLAG_SANITIZE_UNDEFINED)
+        if(HAVE_FLAG_SANITIZE_UNDEFINED)
+            target_compile_options(common INTERFACE $<$<CONFIG:Debug>:-fsanitize=undefined>)
+            # TODO: Replace with target link option once we support CMake 3.13 
+            target_link_libraries(common INTERFACE $<$<CONFIG:Debug>:-fsanitize=undefined>)
+        endif()
+    endif()
+endif()
+
+if (EARCUT_WARNING_IS_ERROR)
+    target_compile_options(common INTERFACE
+        $<$<CXX_COMPILER_ID:MSVC>:/WX>
+        $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Werror>
+    )
+endif()
+
+if (EARCUT_BUILD_TESTS)
+    enable_testing()
+    add_executable(tests test/tap.cpp test/tap.hpp test/test.cpp $<TARGET_OBJECTS:fixtures>)
+    target_link_libraries(tests PRIVATE earcut_hpp common)
+    add_test(NAME earcut_tests COMMAND tests)
+endif()
+if (EARCUT_BUILD_BENCH)
+    add_executable(bench test/bench.cpp $<TARGET_OBJECTS:fixtures>)
+    target_link_libraries(bench PRIVATE earcut_hpp common)
+endif()
+if (EARCUT_BUILD_VIZ)
+    add_executable(viz test/viz.cpp $<TARGET_OBJECTS:fixtures>)
+
+    # Setup viz target
+    # OpenGL
+    # linux: xorg-dev libgl1-mesa-glx libgl1-mesa-dev
+    # windows: in the windows sdk
+    find_package(OpenGL REQUIRED)
+
+    # GLFW3
+    find_package(glfw3 QUIET) # try to use the system default
+    if (NOT glfw3_FOUND)
+        if(EXISTS "${PROJECT_SOURCE_DIR}/.gitmodules")
+            find_package(Git REQUIRED)
+            execute_process(
+                    COMMAND             ${GIT_EXECUTABLE} submodule update --init --recursive
+                    WORKING_DIRECTORY   ${PROJECT_SOURCE_DIR}
+                    OUTPUT_QUIET
+                    ERROR_QUIET
+            )
+        endif()
+
+        set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "Build the GLFW example programs" FORCE)
+        set(GLFW_BUILD_TESTS OFF CACHE BOOL "Build the GLFW test programs" FORCE)
+        set(GLFW_BUILD_DOCS OFF CACHE BOOL "Build the GLFW documentation" FORCE)
+        set(GLFW_INSTALL OFF CACHE BOOL "Generate installation target" FORCE)
+        add_subdirectory(glfw)
+    endif()
+    
+    target_compile_definitions(viz PRIVATE GL_SILENCE_DEPRECATION)
+    
+    # TODO: Using old variables for OpenGL package since they were added in CMake 3.8
+    target_link_libraries(viz PRIVATE earcut_hpp common glfw ${OPENGL_LIBRARIES})
+    target_include_directories(viz PRIVATE ${OPENGL_INCLUDE_DIR})
+endif()
+
+install(
+  DIRECTORY include/mapbox
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.hpp"
+)
+
+install(TARGETS earcut_hpp EXPORT earcut_hpp-config)
+
+# Since there is two projects, we need to export into the parent directory
+export(
+  TARGETS earcut_hpp
+  NAMESPACE earcut_hpp::
+  FILE "${PROJECT_BINARY_DIR}/earcut_hpp-config.cmake"
+)
+
+install(EXPORT earcut_hpp-config
+  DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/earcut_hpp"
+  NAMESPACE earcut_hpp::
+)

polygon.mod/earcut/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

polygon.mod/earcut/README.md

@@ -0,0 +1,131 @@
+## Earcut
+
+A C++ port of [earcut.js](https://github.com/mapbox/earcut), a fast, [header-only](https://github.com/mapbox/earcut.hpp/blob/master/include/mapbox/earcut.hpp) polygon triangulation library.
+
+[![Travis](https://img.shields.io/travis/com/mapbox/earcut.hpp.svg)](https://travis-ci.com/github/mapbox/earcut.hpp)
+[![AppVeyor](https://ci.appveyor.com/api/projects/status/a1ysrqd69mqn7coo/branch/master?svg=true)](https://ci.appveyor.com/project/Mapbox/earcut-hpp-8wm4o/branch/master)
+[![Coverage](https://img.shields.io/coveralls/github/mapbox/earcut.hpp.svg)](https://coveralls.io/github/mapbox/earcut.hpp)
+[![Coverity Scan](https://img.shields.io/coverity/scan/14000.svg)](https://scan.coverity.com/projects/14000)
+[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/mapbox/earcut.hpp.svg)](http://isitmaintained.com/project/mapbox/earcut.hpp "Average time to resolve an issue")
+[![Percentage of issues still open](http://isitmaintained.com/badge/open/mapbox/earcut.hpp.svg)](http://isitmaintained.com/project/mapbox/earcut.hpp "Percentage of issues still open")
+[![Mourner](https://img.shields.io/badge/simply-awesome-brightgreen.svg)](https://github.com/mourner/projects)
+
+The library implements a modified ear slicing algorithm, optimized by [z-order curve](http://en.wikipedia.org/wiki/Z-order_curve) hashing and extended to handle holes, twisted polygons, degeneracies and self-intersections in a way that doesn't _guarantee_ correctness of triangulation, but attempts to always produce acceptable results for practical data like geographical shapes.
+
+It's based on ideas from [FIST: Fast Industrial-Strength Triangulation of Polygons](http://www.cosy.sbg.ac.at/~held/projects/triang/triang.html) by Martin Held and [Triangulation by Ear Clipping](http://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf) by David Eberly.
+
+## Usage
+
+```cpp
+#include <earcut.hpp>
+```
+```cpp
+// The number type to use for tessellation
+using Coord = double;
+
+// The index type. Defaults to uint32_t, but you can also pass uint16_t if you know that your
+// data won't have more than 65536 vertices.
+using N = uint32_t;
+
+// Create array
+using Point = std::array<Coord, 2>;
+std::vector<std::vector<Point>> polygon;
+
+// Fill polygon structure with actual data. Any winding order works.
+// The first polyline defines the main polygon.
+polygon.push_back({{100, 0}, {100, 100}, {0, 100}, {0, 0}});
+// Following polylines define holes.
+polygon.push_back({{75, 25}, {75, 75}, {25, 75}, {25, 25}});
+
+// Run tessellation
+// Returns array of indices that refer to the vertices of the input polygon.
+// e.g: the index 6 would refer to {25, 75} in this example.
+// Three subsequent indices form a triangle. Output triangles are clockwise.
+std::vector<N> indices = mapbox::earcut<N>(polygon);
+```
+
+Earcut can triangulate a simple, planar polygon of any winding order including holes. It will even return a robust, acceptable solution for non-simple poygons. Earcut works on a 2D plane. If you have three or more dimensions, you can project them onto a 2D surface before triangulation, or use a more suitable library for the task (e.g [CGAL](https://doc.cgal.org/latest/Triangulation_3/index.html)).
+
+
+It is also possible to use your custom point type as input. There are default accessors defined for `std::tuple`, `std::pair`, and `std::array`. For a custom type (like Clipper's `IntPoint` type), do this:
+
+```cpp
+// struct IntPoint {
+//     int64_t X, Y;
+// };
+
+namespace mapbox {
+namespace util {
+
+template <>
+struct nth<0, IntPoint> {
+    inline static auto get(const IntPoint &t) {
+        return t.X;
+    };
+};
+template <>
+struct nth<1, IntPoint> {
+    inline static auto get(const IntPoint &t) {
+        return t.Y;
+    };
+};
+
+} // namespace util
+} // namespace mapbox
+```
+
+You can also use a custom container type for your polygon. Similar to std::vector<T>, it has to meet the requirements of [Container](https://en.cppreference.com/w/cpp/named_req/Container), in particular `size()`, `empty()` and `operator[]`.
+
+<p align="center">
+  <img src="https://camo.githubusercontent.com/01836f8ba21af844c93d8d3145f4e9976025a696/68747470733a2f2f692e696d6775722e636f6d2f67314e704c54712e706e67" alt="example triangulation"/>
+</p>
+
+## Additional build instructions
+In case you just want to use the earcut triangulation library; copy and include the header file [`<earcut.hpp>`](https://github.com/mapbox/earcut.hpp/blob/master/include/mapbox/earcut.hpp) in your project and follow the steps documented in the section [Usage](#usage).
+
+If you want to build the test, benchmark and visualization programs instead, follow these instructions:
+
+### Dependencies
+
+Before you continue, make sure to have the following tools and libraries installed:
+ * git ([Ubuntu](https://help.ubuntu.com/lts/serverguide/git.html)/[Windows/macOS](http://git-scm.com/downloads))
+ * cmake 3.2+ ([Ubuntu](https://launchpad.net/~george-edison55/+archive/ubuntu/cmake-3.x)/[Windows/macOS](https://cmake.org/download/))
+ * OpenGL SDK ([Ubuntu](http://packages.ubuntu.com/de/trusty/libgl1-mesa-dev)/[Windows](https://dev.windows.com/en-us/downloads/windows-10-sdk)/[macOS](https://developer.apple.com/opengl/))
+ * Compiler such as [GCC 4.9+, Clang 3.4+](https://launchpad.net/~ubuntu-toolchain-r/+archive/ubuntu/test), [MSVC12+](https://www.visualstudio.com/)
+
+Note: On some operating systems such as Windows, manual steps are required to add cmake and [git](http://blog.countableset.ch/2012/06/07/adding-git-to-windows-7-path/) to your PATH environment variable.
+
+### Manual compilation
+
+```bash
+git clone --recursive https://github.com/mapbox/earcut.hpp.git
+cd earcut.hpp
+mkdir build
+cd build
+cmake ..
+make
+# ./tests
+# ./bench
+# ./viz
+```
+
+### [Visual Studio](https://www.visualstudio.com/), [Eclipse](https://eclipse.org/), [XCode](https://developer.apple.com/xcode/), ...
+
+```batch
+git clone --recursive https://github.com/mapbox/earcut.hpp.git
+cd earcut.hpp
+mkdir project
+cd project
+cmake .. -G "Visual Studio 14 2015"
+::you can also generate projects for "Visual Studio 12 2013", "XCode", "Eclipse CDT4 - Unix Makefiles"
+```
+After completion, open the generated project with your IDE.
+
+
+### [CLion](https://www.jetbrains.com/clion/), [Visual Studio 2017+](https://www.visualstudio.com/)
+
+Import the project from https://github.com/mapbox/earcut.hpp.git and you should be good to go!
+
+## Status
+
+This is currently based on [earcut 2.2.4](https://github.com/mapbox/earcut#224-jul-5-2022).

polygon.mod/earcut/appveyor.yml

@@ -0,0 +1,33 @@
+os: Visual Studio 2017
+
+configuration:
+  #- Debug
+  - Release
+
+environment:
+  matrix:
+    - GENERATOR: "MinGW Makefiles"
+      CXX_PATH: 'C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin'
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - GENERATOR: "Visual Studio 12 2013 Win64"
+    - GENERATOR: "Visual Studio 14 2015 Win64"
+    - GENERATOR: "Visual Studio 15 2017 Win64"
+    - GENERATOR: "Visual Studio 15 2017"
+
+matrix:
+  fast_finish: true
+
+install:
+  - git submodule update --init
+  - if "%GENERATOR%"=="MinGW Makefiles" (set "PATH=%PATH:C:\Program Files\Git\usr\bin;=%")
+  - if not "%CXX_PATH%"=="" (set "PATH=%PATH%;%CXX_PATH%")
+
+build_script:
+  - cmake -H. -Bbuild -G"%GENERATOR%" -DEARCUT_WARNING_IS_ERROR=ON
+  - cmake --build build --config %configuration%
+
+test_script:
+  - cd build
+  - if exist %configuration% (cd "%configuration%") 
+  - call "tests.exe"
+  - call "bench.exe"

polygon.mod/earcut/include/mapbox/earcut.hpp

@@ -0,0 +1,816 @@
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace mapbox {
+
+namespace util {
+
+template <std::size_t I, typename T> struct nth {
+    inline static typename std::tuple_element<I, T>::type
+    get(const T& t) { return std::get<I>(t); };
+};
+
+}
+
+namespace detail {
+
+template <typename N = uint32_t>
+class Earcut {
+public:
+    std::vector<N> indices;
+    std::size_t vertices = 0;
+
+    template <typename Polygon>
+    void operator()(const Polygon& points);
+
+private:
+    struct Node {
+        Node(N index, double x_, double y_) : i(index), x(x_), y(y_) {}
+        Node(const Node&) = delete;
+        Node& operator=(const Node&) = delete;
+        Node(Node&&) = delete;
+        Node& operator=(Node&&) = delete;
+
+        const N i;
+        const double x;
+        const double y;
+
+        // previous and next vertice nodes in a polygon ring
+        Node* prev = nullptr;
+        Node* next = nullptr;
+
+        // z-order curve value
+        int32_t z = 0;
+
+        // previous and next nodes in z-order
+        Node* prevZ = nullptr;
+        Node* nextZ = nullptr;
+
+        // indicates whether this is a steiner point
+        bool steiner = false;
+    };
+
+    template <typename Ring> Node* linkedList(const Ring& points, const bool clockwise);
+    Node* filterPoints(Node* start, Node* end = nullptr);
+    void earcutLinked(Node* ear, int pass = 0);
+    bool isEar(Node* ear);
+    bool isEarHashed(Node* ear);
+    Node* cureLocalIntersections(Node* start);
+    void splitEarcut(Node* start);
+    template <typename Polygon> Node* eliminateHoles(const Polygon& points, Node* outerNode);
+    Node* eliminateHole(Node* hole, Node* outerNode);
+    Node* findHoleBridge(Node* hole, Node* outerNode);
+    bool sectorContainsSector(const Node* m, const Node* p);
+    void indexCurve(Node* start);
+    Node* sortLinked(Node* list);
+    int32_t zOrder(const double x_, const double y_);
+    Node* getLeftmost(Node* start);
+    bool pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const;
+    bool isValidDiagonal(Node* a, Node* b);
+    double area(const Node* p, const Node* q, const Node* r) const;
+    bool equals(const Node* p1, const Node* p2);
+    bool intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2);
+    bool onSegment(const Node* p, const Node* q, const Node* r);
+    int sign(double val);
+    bool intersectsPolygon(const Node* a, const Node* b);
+    bool locallyInside(const Node* a, const Node* b);
+    bool middleInside(const Node* a, const Node* b);
+    Node* splitPolygon(Node* a, Node* b);
+    template <typename Point> Node* insertNode(std::size_t i, const Point& p, Node* last);
+    void removeNode(Node* p);
+
+    bool hashing;
+    double minX, maxX;
+    double minY, maxY;
+    double inv_size = 0;
+
+    template <typename T, typename Alloc = std::allocator<T>>
+    class ObjectPool {
+    public:
+        ObjectPool() { }
+        ObjectPool(std::size_t blockSize_) {
+            reset(blockSize_);
+        }
+        ~ObjectPool() {
+            clear();
+        }
+        template <typename... Args>
+        T* construct(Args&&... args) {
+            if (currentIndex >= blockSize) {
+                currentBlock = alloc_traits::allocate(alloc, blockSize);
+                allocations.emplace_back(currentBlock);
+                currentIndex = 0;
+            }
+            T* object = &currentBlock[currentIndex++];
+            alloc_traits::construct(alloc, object, std::forward<Args>(args)...);
+            return object;
+        }
+        void reset(std::size_t newBlockSize) {
+            for (auto allocation : allocations) {
+                alloc_traits::deallocate(alloc, allocation, blockSize);
+            }
+            allocations.clear();
+            blockSize = std::max<std::size_t>(1, newBlockSize);
+            currentBlock = nullptr;
+            currentIndex = blockSize;
+        }
+        void clear() { reset(blockSize); }
+    private:
+        T* currentBlock = nullptr;
+        std::size_t currentIndex = 1;
+        std::size_t blockSize = 1;
+        std::vector<T*> allocations;
+        Alloc alloc;
+        typedef typename std::allocator_traits<Alloc> alloc_traits;
+    };
+    ObjectPool<Node> nodes;
+};
+
+template <typename N> template <typename Polygon>
+void Earcut<N>::operator()(const Polygon& points) {
+    // reset
+    indices.clear();
+    vertices = 0;
+
+    if (points.empty()) return;
+
+    double x;
+    double y;
+    int threshold = 80;
+    std::size_t len = 0;
+
+    for (size_t i = 0; threshold >= 0 && i < points.size(); i++) {
+        threshold -= static_cast<int>(points[i].size());
+        len += points[i].size();
+    }
+
+    //estimate size of nodes and indices
+    nodes.reset(len * 3 / 2);
+    indices.reserve(len + points[0].size());
+
+    Node* outerNode = linkedList(points[0], true);
+    if (!outerNode || outerNode->prev == outerNode->next) return;
+
+    if (points.size() > 1) outerNode = eliminateHoles(points, outerNode);
+
+    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+    hashing = threshold < 0;
+    if (hashing) {
+        Node* p = outerNode->next;
+        minX = maxX = outerNode->x;
+        minY = maxY = outerNode->y;
+        do {
+            x = p->x;
+            y = p->y;
+            minX = std::min<double>(minX, x);
+            minY = std::min<double>(minY, y);
+            maxX = std::max<double>(maxX, x);
+            maxY = std::max<double>(maxY, y);
+            p = p->next;
+        } while (p != outerNode);
+
+        // minX, minY and inv_size are later used to transform coords into integers for z-order calculation
+        inv_size = std::max<double>(maxX - minX, maxY - minY);
+        inv_size = inv_size != .0 ? (32767. / inv_size) : .0;
+    }
+
+    earcutLinked(outerNode);
+
+    nodes.clear();
+}
+
+// create a circular doubly linked list from polygon points in the specified winding order
+template <typename N> template <typename Ring>
+typename Earcut<N>::Node*
+Earcut<N>::linkedList(const Ring& points, const bool clockwise) {
+    using Point = typename Ring::value_type;
+    double sum = 0;
+    const std::size_t len = points.size();
+    std::size_t i, j;
+    Node* last = nullptr;
+
+    // calculate original winding order of a polygon ring
+    for (i = 0, j = len > 0 ? len - 1 : 0; i < len; j = i++) {
+        const auto& p1 = points[i];
+        const auto& p2 = points[j];
+        const double p20 = util::nth<0, Point>::get(p2);
+        const double p10 = util::nth<0, Point>::get(p1);
+        const double p11 = util::nth<1, Point>::get(p1);
+        const double p21 = util::nth<1, Point>::get(p2);
+        sum += (p20 - p10) * (p11 + p21);
+    }
+
+    // link points into circular doubly-linked list in the specified winding order
+    if (clockwise == (sum > 0)) {
+        for (i = 0; i < len; i++) last = insertNode(vertices + i, points[i], last);
+    } else {
+        for (i = len; i-- > 0;) last = insertNode(vertices + i, points[i], last);
+    }
+
+    if (last && equals(last, last->next)) {
+        removeNode(last);
+        last = last->next;
+    }
+
+    vertices += len;
+
+    return last;
+}
+
+// eliminate colinear or duplicate points
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::filterPoints(Node* start, Node* end) {
+    if (!end) end = start;
+
+    Node* p = start;
+    bool again;
+    do {
+        again = false;
+
+        if (!p->steiner && (equals(p, p->next) || area(p->prev, p, p->next) == 0)) {
+            removeNode(p);
+            p = end = p->prev;
+
+            if (p == p->next) break;
+            again = true;
+
+        } else {
+            p = p->next;
+        }
+    } while (again || p != end);
+
+    return end;
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+template <typename N>
+void Earcut<N>::earcutLinked(Node* ear, int pass) {
+    if (!ear) return;
+
+    // interlink polygon nodes in z-order
+    if (!pass && hashing) indexCurve(ear);
+
+    Node* stop = ear;
+    Node* prev;
+    Node* next;
+
+    int iterations = 0;
+
+    // iterate through ears, slicing them one by one
+    while (ear->prev != ear->next) {
+        iterations++;
+        prev = ear->prev;
+        next = ear->next;
+
+        if (hashing ? isEarHashed(ear) : isEar(ear)) {
+            // cut off the triangle
+            indices.emplace_back(prev->i);
+            indices.emplace_back(ear->i);
+            indices.emplace_back(next->i);
+
+            removeNode(ear);
+
+            // skipping the next vertice leads to less sliver triangles
+            ear = next->next;
+            stop = next->next;
+
+            continue;
+        }
+
+        ear = next;
+
+        // if we looped through the whole remaining polygon and can't find any more ears
+        if (ear == stop) {
+            // try filtering points and slicing again
+            if (!pass) earcutLinked(filterPoints(ear), 1);
+
+            // if this didn't work, try curing all small self-intersections locally
+            else if (pass == 1) {
+                ear = cureLocalIntersections(filterPoints(ear));
+                earcutLinked(ear, 2);
+
+            // as a last resort, try splitting the remaining polygon into two
+            } else if (pass == 2) splitEarcut(ear);
+
+            break;
+        }
+    }
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+template <typename N>
+bool Earcut<N>::isEar(Node* ear) {
+    const Node* a = ear->prev;
+    const Node* b = ear;
+    const Node* c = ear->next;
+
+    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+    // now make sure we don't have other points inside the potential ear
+    Node* p = ear->next->next;
+
+    while (p != ear->prev) {
+        if (pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->next;
+    }
+
+    return true;
+}
+
+template <typename N>
+bool Earcut<N>::isEarHashed(Node* ear) {
+    const Node* a = ear->prev;
+    const Node* b = ear;
+    const Node* c = ear->next;
+
+    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+    // triangle bbox; min & max are calculated like this for speed
+    const double minTX = std::min<double>(a->x, std::min<double>(b->x, c->x));
+    const double minTY = std::min<double>(a->y, std::min<double>(b->y, c->y));
+    const double maxTX = std::max<double>(a->x, std::max<double>(b->x, c->x));
+    const double maxTY = std::max<double>(a->y, std::max<double>(b->y, c->y));
+
+    // z-order range for the current triangle bbox;
+    const int32_t minZ = zOrder(minTX, minTY);
+    const int32_t maxZ = zOrder(maxTX, maxTY);
+
+    // first look for points inside the triangle in increasing z-order
+    Node* p = ear->nextZ;
+
+    while (p && p->z <= maxZ) {
+        if (p != ear->prev && p != ear->next &&
+            pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->nextZ;
+    }
+
+    // then look for points in decreasing z-order
+    p = ear->prevZ;
+
+    while (p && p->z >= minZ) {
+        if (p != ear->prev && p != ear->next &&
+            pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
+            area(p->prev, p, p->next) >= 0) return false;
+        p = p->prevZ;
+    }
+
+    return true;
+}
+
+// go through all polygon nodes and cure small local self-intersections
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::cureLocalIntersections(Node* start) {
+    Node* p = start;
+    do {
+        Node* a = p->prev;
+        Node* b = p->next->next;
+
+        // a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])
+        if (!equals(a, b) && intersects(a, p, p->next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+            indices.emplace_back(a->i);
+            indices.emplace_back(p->i);
+            indices.emplace_back(b->i);
+
+            // remove two nodes involved
+            removeNode(p);
+            removeNode(p->next);
+
+            p = start = b;
+        }
+        p = p->next;
+    } while (p != start);
+
+    return filterPoints(p);
+}
+
+// try splitting polygon into two and triangulate them independently
+template <typename N>
+void Earcut<N>::splitEarcut(Node* start) {
+    // look for a valid diagonal that divides the polygon into two
+    Node* a = start;
+    do {
+        Node* b = a->next->next;
+        while (b != a->prev) {
+            if (a->i != b->i && isValidDiagonal(a, b)) {
+                // split the polygon in two by the diagonal
+                Node* c = splitPolygon(a, b);
+
+                // filter colinear points around the cuts
+                a = filterPoints(a, a->next);
+                c = filterPoints(c, c->next);
+
+                // run earcut on each half
+                earcutLinked(a);
+                earcutLinked(c);
+                return;
+            }
+            b = b->next;
+        }
+        a = a->next;
+    } while (a != start);
+}
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+template <typename N> template <typename Polygon>
+typename Earcut<N>::Node*
+Earcut<N>::eliminateHoles(const Polygon& points, Node* outerNode) {
+    const size_t len = points.size();
+
+    std::vector<Node*> queue;
+    for (size_t i = 1; i < len; i++) {
+        Node* list = linkedList(points[i], false);
+        if (list) {
+            if (list == list->next) list->steiner = true;
+            queue.push_back(getLeftmost(list));
+        }
+    }
+    std::sort(queue.begin(), queue.end(), [](const Node* a, const Node* b) {
+        return a->x < b->x;
+    });
+
+    // process holes from left to right
+    for (size_t i = 0; i < queue.size(); i++) {
+        outerNode = eliminateHole(queue[i], outerNode);
+    }
+
+    return outerNode;
+}
+
+// find a bridge between vertices that connects hole with an outer ring and and link it
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::eliminateHole(Node* hole, Node* outerNode) {
+    Node* bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+        return outerNode;
+    }
+
+    Node* bridgeReverse = splitPolygon(bridge, hole);
+
+    // filter collinear points around the cuts
+    filterPoints(bridgeReverse, bridgeReverse->next);
+
+    // Check if input node was removed by the filtering
+    return filterPoints(bridge, bridge->next);
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::findHoleBridge(Node* hole, Node* outerNode) {
+    Node* p = outerNode;
+    double hx = hole->x;
+    double hy = hole->y;
+    double qx = -std::numeric_limits<double>::infinity();
+    Node* m = nullptr;
+
+    // find a segment intersected by a ray from the hole's leftmost Vertex to the left;
+    // segment's endpoint with lesser x will be potential connection Vertex
+    do {
+        if (hy <= p->y && hy >= p->next->y && p->next->y != p->y) {
+          double x = p->x + (hy - p->y) * (p->next->x - p->x) / (p->next->y - p->y);
+          if (x <= hx && x > qx) {
+            qx = x;
+            m = p->x < p->next->x ? p : p->next;
+            if (x == hx) return m; // hole touches outer segment; pick leftmost endpoint
+          }
+        }
+        p = p->next;
+    } while (p != outerNode);
+
+    if (!m) return 0;
+
+    // look for points inside the triangle of hole Vertex, segment intersection and endpoint;
+    // if there are no points found, we have a valid connection;
+    // otherwise choose the Vertex of the minimum angle with the ray as connection Vertex
+
+    const Node* stop = m;
+    double tanMin = std::numeric_limits<double>::infinity();
+    double tanCur = 0;
+
+    p = m;
+    double mx = m->x;
+    double my = m->y;
+
+    do {
+        if (hx >= p->x && p->x >= mx && hx != p->x &&
+            pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p->x, p->y)) {
+
+            tanCur = std::abs(hy - p->y) / (hx - p->x); // tangential
+
+            if (locallyInside(p, hole) &&
+                (tanCur < tanMin || (tanCur == tanMin && (p->x > m->x || sectorContainsSector(m, p))))) {
+                m = p;
+                tanMin = tanCur;
+            }
+        }
+
+        p = p->next;
+    } while (p != stop);
+
+    return m;
+}
+
+// whether sector in vertex m contains sector in vertex p in the same coordinates
+template <typename N>
+bool Earcut<N>::sectorContainsSector(const Node* m, const Node* p) {
+    return area(m->prev, m, p->prev) < 0 && area(p->next, m, m->next) < 0;
+}
+
+// interlink polygon nodes in z-order
+template <typename N>
+void Earcut<N>::indexCurve(Node* start) {
+    assert(start);
+    Node* p = start;
+
+    do {
+        p->z = p->z ? p->z : zOrder(p->x, p->y);
+        p->prevZ = p->prev;
+        p->nextZ = p->next;
+        p = p->next;
+    } while (p != start);
+
+    p->prevZ->nextZ = nullptr;
+    p->prevZ = nullptr;
+
+    sortLinked(p);
+}
+
+// Simon Tatham's linked list merge sort algorithm
+// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::sortLinked(Node* list) {
+    assert(list);
+    Node* p;
+    Node* q;
+    Node* e;
+    Node* tail;
+    int i, numMerges, pSize, qSize;
+    int inSize = 1;
+
+    for (;;) {
+        p = list;
+        list = nullptr;
+        tail = nullptr;
+        numMerges = 0;
+
+        while (p) {
+            numMerges++;
+            q = p;
+            pSize = 0;
+            for (i = 0; i < inSize; i++) {
+                pSize++;
+                q = q->nextZ;
+                if (!q) break;
+            }
+
+            qSize = inSize;
+
+            while (pSize > 0 || (qSize > 0 && q)) {
+
+                if (pSize == 0) {
+                    e = q;
+                    q = q->nextZ;
+                    qSize--;
+                } else if (qSize == 0 || !q) {
+                    e = p;
+                    p = p->nextZ;
+                    pSize--;
+                } else if (p->z <= q->z) {
+                    e = p;
+                    p = p->nextZ;
+                    pSize--;
+                } else {
+                    e = q;
+                    q = q->nextZ;
+                    qSize--;
+                }
+
+                if (tail) tail->nextZ = e;
+                else list = e;
+
+                e->prevZ = tail;
+                tail = e;
+            }
+
+            p = q;
+        }
+
+        tail->nextZ = nullptr;
+
+        if (numMerges <= 1) return list;
+
+        inSize *= 2;
+    }
+}
+
+// z-order of a Vertex given coords and size of the data bounding box
+template <typename N>
+int32_t Earcut<N>::zOrder(const double x_, const double y_) {
+    // coords are transformed into non-negative 15-bit integer range
+    int32_t x = static_cast<int32_t>((x_ - minX) * inv_size);
+    int32_t y = static_cast<int32_t>((y_ - minY) * inv_size);
+
+    x = (x | (x << 8)) & 0x00FF00FF;
+    x = (x | (x << 4)) & 0x0F0F0F0F;
+    x = (x | (x << 2)) & 0x33333333;
+    x = (x | (x << 1)) & 0x55555555;
+
+    y = (y | (y << 8)) & 0x00FF00FF;
+    y = (y | (y << 4)) & 0x0F0F0F0F;
+    y = (y | (y << 2)) & 0x33333333;
+    y = (y | (y << 1)) & 0x55555555;
+
+    return x | (y << 1);
+}
+
+// find the leftmost node of a polygon ring
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::getLeftmost(Node* start) {
+    Node* p = start;
+    Node* leftmost = start;
+    do {
+        if (p->x < leftmost->x || (p->x == leftmost->x && p->y < leftmost->y))
+            leftmost = p;
+        p = p->next;
+    } while (p != start);
+
+    return leftmost;
+}
+
+// check if a point lies within a convex triangle
+template <typename N>
+bool Earcut<N>::pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const {
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
+           (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
+           (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+
+// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+template <typename N>
+bool Earcut<N>::isValidDiagonal(Node* a, Node* b) {
+    return a->next->i != b->i && a->prev->i != b->i && !intersectsPolygon(a, b) && // dones't intersect other edges
+           ((locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+            (area(a->prev, a, b->prev) != 0.0 || area(a, b->prev, b) != 0.0)) || // does not create opposite-facing sectors
+            (equals(a, b) && area(a->prev, a, a->next) > 0 && area(b->prev, b, b->next) > 0)); // special zero-length case
+}
+
+// signed area of a triangle
+template <typename N>
+double Earcut<N>::area(const Node* p, const Node* q, const Node* r) const {
+    return (q->y - p->y) * (r->x - q->x) - (q->x - p->x) * (r->y - q->y);
+}
+
+// check if two points are equal
+template <typename N>
+bool Earcut<N>::equals(const Node* p1, const Node* p2) {
+    return p1->x == p2->x && p1->y == p2->y;
+}
+
+// check if two segments intersect
+template <typename N>
+bool Earcut<N>::intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2) {
+    int o1 = sign(area(p1, q1, p2));
+    int o2 = sign(area(p1, q1, q2));
+    int o3 = sign(area(p2, q2, p1));
+    int o4 = sign(area(p2, q2, q1));
+
+    if (o1 != o2 && o3 != o4) return true; // general case
+
+    if (o1 == 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
+    if (o2 == 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
+    if (o3 == 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
+    if (o4 == 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
+
+    return false;
+}
+
+// for collinear points p, q, r, check if point q lies on segment pr
+template <typename N>
+bool Earcut<N>::onSegment(const Node* p, const Node* q, const Node* r) {
+    return q->x <= std::max<double>(p->x, r->x) &&
+        q->x >= std::min<double>(p->x, r->x) &&
+        q->y <= std::max<double>(p->y, r->y) &&
+        q->y >= std::min<double>(p->y, r->y);
+}
+
+template <typename N>
+int Earcut<N>::sign(double val) {
+    return (0.0 < val) - (val < 0.0);
+}
+
+// check if a polygon diagonal intersects any polygon segments
+template <typename N>
+bool Earcut<N>::intersectsPolygon(const Node* a, const Node* b) {
+    const Node* p = a;
+    do {
+        if (p->i != a->i && p->next->i != a->i && p->i != b->i && p->next->i != b->i &&
+                intersects(p, p->next, a, b)) return true;
+        p = p->next;
+    } while (p != a);
+
+    return false;
+}
+
+// check if a polygon diagonal is locally inside the polygon
+template <typename N>
+bool Earcut<N>::locallyInside(const Node* a, const Node* b) {
+    return area(a->prev, a, a->next) < 0 ?
+        area(a, b, a->next) >= 0 && area(a, a->prev, b) >= 0 :
+        area(a, b, a->prev) < 0 || area(a, a->next, b) < 0;
+}
+
+// check if the middle Vertex of a polygon diagonal is inside the polygon
+template <typename N>
+bool Earcut<N>::middleInside(const Node* a, const Node* b) {
+    const Node* p = a;
+    bool inside = false;
+    double px = (a->x + b->x) / 2;
+    double py = (a->y + b->y) / 2;
+    do {
+        if (((p->y > py) != (p->next->y > py)) && p->next->y != p->y &&
+                (px < (p->next->x - p->x) * (py - p->y) / (p->next->y - p->y) + p->x))
+            inside = !inside;
+        p = p->next;
+    } while (p != a);
+
+    return inside;
+}
+
+// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits
+// polygon into two; if one belongs to the outer ring and another to a hole, it merges it into a
+// single ring
+template <typename N>
+typename Earcut<N>::Node*
+Earcut<N>::splitPolygon(Node* a, Node* b) {
+    Node* a2 = nodes.construct(a->i, a->x, a->y);
+    Node* b2 = nodes.construct(b->i, b->x, b->y);
+    Node* an = a->next;
+    Node* bp = b->prev;
+
+    a->next = b;
+    b->prev = a;
+
+    a2->next = an;
+    an->prev = a2;
+
+    b2->next = a2;
+    a2->prev = b2;
+
+    bp->next = b2;
+    b2->prev = bp;
+
+    return b2;
+}
+
+// create a node and util::optionally link it with previous one (in a circular doubly linked list)
+template <typename N> template <typename Point>
+typename Earcut<N>::Node*
+Earcut<N>::insertNode(std::size_t i, const Point& pt, Node* last) {
+    Node* p = nodes.construct(static_cast<N>(i), util::nth<0, Point>::get(pt), util::nth<1, Point>::get(pt));
+
+    if (!last) {
+        p->prev = p;
+        p->next = p;
+
+    } else {
+        assert(last);
+        p->next = last->next;
+        p->prev = last;
+        last->next->prev = p;
+        last->next = p;
+    }
+    return p;
+}
+
+template <typename N>
+void Earcut<N>::removeNode(Node* p) {
+    p->next->prev = p->prev;
+    p->prev->next = p->next;
+
+    if (p->prevZ) p->prevZ->nextZ = p->nextZ;
+    if (p->nextZ) p->nextZ->prevZ = p->prevZ;
+}
+}
+
+template <typename N = uint32_t, typename Polygon>
+std::vector<N> earcut(const Polygon& poly) {
+    mapbox::detail::Earcut<N> earcut;
+    earcut(poly);
+    return std::move(earcut.indices);
+}
+}

polygon.mod/earcut/test/bench.cpp

@@ -0,0 +1,82 @@
+#include "fixtures/geometries.hpp"
+
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <chrono>
+#include <set>
+
+template<typename Proc>
+double bench(Proc&& procedure) {
+    int64_t runs = -10;
+    int64_t total = 0;
+
+    while (total < 2000000000ll || runs < 100) {
+        const auto started = std::chrono::high_resolution_clock::now();
+        procedure();
+        const auto finished = std::chrono::high_resolution_clock::now();
+
+        // Don't count the first couple of iterations.
+        if (++runs > 0) {
+            total += std::chrono::duration_cast<std::chrono::nanoseconds>(finished - started).count();
+        }
+    }
+
+    return double(runs) / (double(total) / 1e9);
+}
+
+void report(mapbox::fixtures::FixtureTester* fixture, const int cols[]) {
+    std::ios::fmtflags flags(std::cerr.flags());
+    const char filling = std::cerr.fill();
+    std::cerr << std::setfill(' ');
+    std::cerr << "| " << std::left << std::setw(cols[0]) << fixture->name << " | ";
+    auto earcut = bench([&]{ fixture->earcut(); });
+    std::cerr << std::right << std::setw(cols[1] - 6) << std::fixed << std::setprecision(0) << earcut << " ops/s | ";
+    auto libtess2 = bench([&]{ fixture->libtess(); });
+    std::cerr << std::setw(cols[2] - 6) << std::setprecision(0) << libtess2 << " ops/s |" << std::endl;
+    std::cerr << std::setfill(filling);
+    std::cerr.flags(flags);
+}
+
+void separator(const int cols[]) {
+    std::ios::fmtflags flags(std::cerr.flags());
+    const char filling = std::cerr.fill();
+    std::cerr << std::setfill('-');
+    for (int i = 0; cols[i]; i++) {
+        std::cerr << "+" << std::setw(cols[i]+2) << std::cerr.fill();
+    }
+    std::cerr << std::setfill(filling);
+    std::cerr << "+" << std::endl;
+    std::cerr.flags(flags);
+}
+
+int main() {
+    std::cerr.imbue(std::locale(""));
+    const int cols[] = { 14, 18, 18, 0 };
+
+    separator(cols);
+
+    std::ios::fmtflags flags(std::cerr.flags());
+    std::cerr << "|" << std::left
+        << std::setw(cols[0]+1) << " Polygon" << " |"
+        << std::setw(cols[1]+1) << " earcut" << " |"
+        << std::setw(cols[2]+1) << " libtess2" << " |"
+        << std::endl;
+    std::cerr.flags(flags);
+
+    separator(cols);
+
+    auto& fixtures = mapbox::fixtures::FixtureTester::collection();
+    std::set<std::string> bench_whitelist = {
+        "bad_hole", "building", "degenerate", "dude", "empty_square", "water_huge",
+        "water_huge2", "water", "water2", "water3", "water3b", "water4"
+    };
+    for (auto fixture : fixtures) {
+        if (bench_whitelist.find(fixture->name) != bench_whitelist.end()) {
+            report(fixture, cols);
+        }
+    }
+
+    separator(cols);
+    return 0;
+}

polygon.mod/earcut/test/comparison/earcut.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <mapbox/earcut.hpp>
+
+#include <array>
+#include <memory>
+#include <vector>
+
+template <typename Coord, typename Polygon>
+class EarcutTesselator {
+public:
+    using Vertex = std::array<Coord, 2>;
+    using Vertices = std::vector<Vertex>;
+
+    EarcutTesselator(const Polygon &polygon_)
+        : polygon(polygon_)
+    {
+        for (const auto& ring : polygon_) {
+            for (const auto& vertex : ring) {
+                vertices_.emplace_back(Vertex {{ Coord(std::get<0>(vertex)),
+                                                 Coord(std::get<1>(vertex)) }});
+            }
+        }
+    }
+
+    EarcutTesselator & operator=(const EarcutTesselator&) = delete;
+
+    void run() {
+        indices_ = mapbox::earcut(polygon);
+    }
+
+    std::vector<uint32_t> const& indices() const {
+        return indices_;
+    }
+
+    Vertices const& vertices() const {
+        return vertices_;
+    }
+
+private:
+    const Polygon &polygon;
+    Vertices vertices_;
+    std::vector<uint32_t> indices_;
+};

polygon.mod/earcut/test/comparison/libtess2.hpp

@@ -0,0 +1,105 @@
+#pragma once
+#ifdef __GNUC__
+#pragma GCC diagnostic push 
+#pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+#include "libtess2/tesselator.h"
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#include <memory>
+#include <vector>
+#include <array>
+#include <stdexcept>
+
+template <typename Coord, typename Polygon>
+class Libtess2Tesselator {
+    using Vertex = std::array<Coord, 2>;
+    using Triangles = std::vector<Vertex>;
+    using Vertices = std::vector<Vertex>;
+    using Indices = std::vector<uint32_t>;
+
+public:
+    Libtess2Tesselator(const Polygon &polygon)
+        : tess(std::unique_ptr<TESStesselator, tessDeleter>(tessNewTess(nullptr)))
+    {
+        // Convert the polygon to Libtess2 format.
+        for (const auto &ring : polygon) {
+            std::vector<TESSreal> tessRing;
+            for (const auto &pt : ring) {
+                tessRing.push_back(static_cast<TESSreal>(pt.first));
+                tessRing.push_back(static_cast<TESSreal>(pt.second));
+            }
+            tessPolygon.push_back(tessRing);
+        }
+    }
+
+    void run() {
+        dirty = true;
+
+        // Add polygon data
+        for (const auto &tessRing : tessPolygon) {
+            tessAddContour(tess.get(), vertexSize, tessRing.data(), stride, (int)tessRing.size() / vertexSize);
+        }
+
+        int status = tessTesselate(tess.get(), TESS_WINDING_POSITIVE, TESS_POLYGONS, verticesPerTriangle, vertexSize, 0);
+        if (!status) {
+#if defined(__cpp_exceptions) || defined(__EXCEPTIONS)
+            throw std::runtime_error("tesselation failed");
+#else
+            assert(false && "tesselation failed");
+#endif
+        }
+    }
+
+    auto indices() -> const Indices & {
+        if (dirty) {
+            indexData.clear();
+            const auto elements = tessGetElements(tess.get());
+            const auto elementCount = tessGetElementCount(tess.get());
+
+             for (int i = 0; i < elementCount; i++) {
+                const TESSindex *group = &elements[i * verticesPerTriangle];
+                if (group[0] != TESS_UNDEF && group[1] != TESS_UNDEF && group[2] != TESS_UNDEF) {
+                    indexData.push_back(static_cast<uint32_t>(group[0]));
+                    indexData.push_back(static_cast<uint32_t>(group[1]));
+                    indexData.push_back(static_cast<uint32_t>(group[2]));
+                }
+            }
+        }
+
+        return indexData;
+    }
+
+    auto vertices() -> const Vertices & {
+        if (dirty) {
+            vertexData.clear();
+
+            const auto vertices = tessGetVertices(tess.get());
+            const auto vertexCount = tessGetVertexCount(tess.get());
+            for (int i = 0; i < vertexCount; i++) {
+                vertexData.emplace_back(Vertex{{ Coord(vertices[i * vertexSize]),
+                                                 Coord(vertices[i * vertexSize + 1]) }});
+            }
+        }
+
+        return vertexData;
+    }
+
+private:
+    static const int vertexSize = 2;
+    static const int stride = sizeof(TESSreal) * vertexSize;
+    static const int verticesPerTriangle = 3;
+
+    struct tessDeleter {
+        void operator()(TESStesselator *t) const { tessDeleteTess(t); }
+    };
+
+    std::vector<std::vector<TESSreal>> tessPolygon;
+    const std::unique_ptr<TESStesselator, tessDeleter> tess;
+
+    bool dirty = true;
+    Vertices vertexData;
+    Indices indexData;
+};

polygon.mod/earcut/test/comparison/libtess2/LICENSE.txt

@@ -0,0 +1,25 @@
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) 
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+** 
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software. 
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+** 
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.

polygon.mod/earcut/test/comparison/libtess2/bucketalloc.c

@@ -0,0 +1,191 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Mikko Mononen, July 2009.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "tesselator.h"
+
+//#define CHECK_BOUNDS
+
+typedef struct BucketAlloc BucketAlloc;
+typedef struct Bucket Bucket;
+
+struct Bucket
+{
+	Bucket *next;
+};
+
+struct BucketAlloc
+{
+	void *freelist;
+	Bucket *buckets;
+	unsigned int itemSize;
+	unsigned int bucketSize;
+	const char *name;
+	TESSalloc* alloc;
+};
+
+static int CreateBucket( struct BucketAlloc* ba )
+{
+	size_t size;
+	Bucket* bucket;
+	void* freelist;
+	unsigned char* head;
+	unsigned char* it;
+
+	// Allocate memory for the bucket
+	size = sizeof(Bucket) + ba->itemSize * ba->bucketSize;
+	bucket = (Bucket*)ba->alloc->memalloc( ba->alloc->userData, size );
+	if ( !bucket )
+		return 0;
+	bucket->next = 0;
+
+	// Add the bucket into the list of buckets.
+	bucket->next = ba->buckets;
+	ba->buckets = bucket;
+
+	// Add new items to the free list.
+	freelist = ba->freelist;
+	head = (unsigned char*)bucket + sizeof(Bucket);
+	it = head + ba->itemSize * ba->bucketSize;
+	do
+	{
+		it -= ba->itemSize;
+		// Store pointer to next free item.
+		*((void**)it) = freelist;
+		// Pointer to next location containing a free item.
+		freelist = (void*)it;
+	}
+	while ( it != head );
+	// Update pointer to next location containing a free item.
+	ba->freelist = (void*)it;
+
+	return 1;
+}
+
+static void *NextFreeItem( struct BucketAlloc *ba )
+{
+	return *(void**)ba->freelist;
+}
+
+struct BucketAlloc* createBucketAlloc( TESSalloc* alloc, const char* name,
+									  unsigned int itemSize, unsigned int bucketSize )
+{
+	BucketAlloc* ba = (BucketAlloc*)alloc->memalloc( alloc->userData, sizeof(BucketAlloc) );
+
+	ba->alloc = alloc;
+	ba->name = name;
+	ba->itemSize = itemSize;
+	if ( ba->itemSize < sizeof(void*) )
+		ba->itemSize = sizeof(void*);
+	ba->bucketSize = bucketSize;
+	ba->freelist = 0;
+	ba->buckets = 0;
+
+	if ( !CreateBucket( ba ) )
+	{
+		alloc->memfree( alloc->userData, ba );
+		return 0;
+	}
+
+	return ba;
+}
+
+void* bucketAlloc( struct BucketAlloc *ba )
+{
+	void *it;
+
+	// If running out of memory, allocate new bucket and update the freelist.
+	if ( !ba->freelist || !NextFreeItem( ba ) )
+	{
+		if ( !CreateBucket( ba ) )
+			return 0;
+	}
+
+	// Pop item from in front of the free list.
+	it = ba->freelist;
+	ba->freelist = NextFreeItem( ba );
+
+	return it;
+}
+
+void bucketFree( struct BucketAlloc *ba, void *ptr )
+{
+#ifdef CHECK_BOUNDS
+	int inBounds = 0;
+	Bucket *bucket;
+
+	// Check that the pointer is allocated with this allocator.
+	bucket = ba->buckets;
+	while ( bucket )
+	{
+		void *bucketMin = (void*)((unsigned char*)bucket + sizeof(Bucket));
+		void *bucketMax = (void*)((unsigned char*)bucket + sizeof(Bucket) + ba->itemSize * ba->bucketSize);
+		if ( ptr >= bucketMin && ptr < bucketMax )
+		{
+			inBounds = 1;
+			break;
+		}
+		bucket = bucket->next;
+	}
+
+	if ( inBounds )
+	{
+		// Add the node in front of the free list.
+		*(void**)ptr = ba->freelist;
+		ba->freelist = ptr;
+	}
+	else
+	{
+		printf("ERROR! pointer 0x%p does not belong to allocator '%s'\n", ba->name);
+	}
+#else
+	// Add the node in front of the free list.
+	*(void**)ptr = ba->freelist;
+	ba->freelist = ptr;
+#endif
+}
+
+void deleteBucketAlloc( struct BucketAlloc *ba )
+{
+	TESSalloc* alloc = ba->alloc;
+	Bucket *bucket = ba->buckets;
+	Bucket *next;
+	while ( bucket )
+	{
+		next = bucket->next;
+		alloc->memfree( alloc->userData, bucket );
+		bucket = next;
+	}
+	ba->freelist = 0;
+	ba->buckets = 0;
+	alloc->memfree( alloc->userData, ba );
+}

polygon.mod/earcut/test/comparison/libtess2/bucketalloc.h

@@ -0,0 +1,51 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Mikko Mononen, July 2009.
+*/
+
+#ifndef MEMALLOC_H
+#define MEMALLOC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tesselator.h"
+
+struct BucketAlloc *createBucketAlloc( TESSalloc* alloc, const char *name,
+									  unsigned int itemSize, unsigned int bucketSize );
+void *bucketAlloc( struct BucketAlloc *ba);
+void bucketFree( struct BucketAlloc *ba, void *ptr );
+void deleteBucketAlloc( struct BucketAlloc *ba );
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/dict.c

@@ -0,0 +1,109 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#include <stddef.h>
+#include "tesselator.h"
+#include "bucketalloc.h"
+#include "dict.h"
+
+/* really tessDictListNewDict */
+Dict *dictNewDict( TESSalloc* alloc, void *frame, int (*leq)(void *frame, DictKey key1, DictKey key2) )
+{
+	Dict *dict = (Dict *)alloc->memalloc( alloc->userData, sizeof( Dict ));
+	DictNode *head;
+
+	if (dict == NULL) return NULL;
+
+	head = &dict->head;
+
+	head->key = NULL;
+	head->next = head;
+	head->prev = head;
+
+	dict->frame = frame;
+	dict->leq = leq;
+
+	if (alloc->dictNodeBucketSize < 16)
+		alloc->dictNodeBucketSize = 16;
+	if (alloc->dictNodeBucketSize > 4096)
+		alloc->dictNodeBucketSize = 4096;
+	dict->nodePool = createBucketAlloc( alloc, "Dict", sizeof(DictNode), alloc->dictNodeBucketSize );
+
+	return dict;
+}
+
+/* really tessDictListDeleteDict */
+void dictDeleteDict( TESSalloc* alloc, Dict *dict )
+{
+	deleteBucketAlloc( dict->nodePool );
+	alloc->memfree( alloc->userData, dict );
+}
+
+/* really tessDictListInsertBefore */
+DictNode *dictInsertBefore( Dict *dict, DictNode *node, DictKey key )
+{
+	DictNode *newNode;
+
+	do {
+		node = node->prev;
+	} while( node->key != NULL && ! (*dict->leq)(dict->frame, node->key, key));
+
+	newNode = (DictNode *)bucketAlloc( dict->nodePool );
+	if (newNode == NULL) return NULL;
+
+	newNode->key = key;
+	newNode->next = node->next;
+	node->next->prev = newNode;
+	newNode->prev = node;
+	node->next = newNode;
+
+	return newNode;
+}
+
+/* really tessDictListDelete */
+void dictDelete( Dict *dict, DictNode *node ) /*ARGSUSED*/
+{
+	node->next->prev = node->prev;
+	node->prev->next = node->next;
+	bucketFree( dict->nodePool, node );
+}
+
+/* really tessDictListSearch */
+DictNode *dictSearch( Dict *dict, DictKey key )
+{
+	DictNode *node = &dict->head;
+
+	do {
+		node = node->next;
+	} while( node->key != NULL && ! (*dict->leq)(dict->frame, key, node->key));
+
+	return node;
+}

polygon.mod/earcut/test/comparison/libtess2/dict.h

@@ -0,0 +1,74 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#ifndef DICT_LIST_H
+#define DICT_LIST_H
+
+typedef void *DictKey;
+typedef struct Dict Dict;
+typedef struct DictNode DictNode;
+
+Dict *dictNewDict( TESSalloc* alloc, void *frame, int (*leq)(void *frame, DictKey key1, DictKey key2) );
+
+void dictDeleteDict( TESSalloc* alloc, Dict *dict );
+
+/* Search returns the node with the smallest key greater than or equal
+* to the given key.  If there is no such key, returns a node whose
+* key is NULL.  Similarly, Succ(Max(d)) has a NULL key, etc.
+*/
+DictNode *dictSearch( Dict *dict, DictKey key );
+DictNode *dictInsertBefore( Dict *dict, DictNode *node, DictKey key );
+void dictDelete( Dict *dict, DictNode *node );
+
+#define dictKey(n)	((n)->key)
+#define dictSucc(n)	((n)->next)
+#define dictPred(n)	((n)->prev)
+#define dictMin(d)	((d)->head.next)
+#define dictMax(d)	((d)->head.prev)
+#define dictInsert(d,k) (dictInsertBefore((d),&(d)->head,(k)))
+
+
+/*** Private data structures ***/
+
+struct DictNode {
+	DictKey	key;
+	DictNode *next;
+	DictNode *prev;
+};
+
+struct Dict {
+	DictNode head;
+	void *frame;
+	struct BucketAlloc *nodePool;
+	int (*leq)(void *frame, DictKey key1, DictKey key2);
+};
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/geom.c

@@ -0,0 +1,261 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+//#include "tesos.h"
+#include <assert.h>
+#include "mesh.h"
+#include "geom.h"
+
+int tesvertLeq( TESSvertex *u, TESSvertex *v )
+{
+	/* Returns TRUE if u is lexicographically <= v. */
+
+	return VertLeq( u, v );
+}
+
+TESSreal tesedgeEval( TESSvertex *u, TESSvertex *v, TESSvertex *w )
+{
+	/* Given three vertices u,v,w such that VertLeq(u,v) && VertLeq(v,w),
+	* evaluates the t-coord of the edge uw at the s-coord of the vertex v.
+	* Returns v->t - (uw)(v->s), ie. the signed distance from uw to v.
+	* If uw is vertical (and thus passes thru v), the result is zero.
+	*
+	* The calculation is extremely accurate and stable, even when v
+	* is very close to u or w.  In particular if we set v->t = 0 and
+	* let r be the negated result (this evaluates (uw)(v->s)), then
+	* r is guaranteed to satisfy MIN(u->t,w->t) <= r <= MAX(u->t,w->t).
+	*/
+	TESSreal gapL, gapR;
+
+	assert( VertLeq( u, v ) && VertLeq( v, w ));
+
+	gapL = v->s - u->s;
+	gapR = w->s - v->s;
+
+	if( gapL + gapR > 0 ) {
+		if( gapL < gapR ) {
+			return (v->t - u->t) + (u->t - w->t) * (gapL / (gapL + gapR));
+		} else {
+			return (v->t - w->t) + (w->t - u->t) * (gapR / (gapL + gapR));
+		}
+	}
+	/* vertical line */
+	return 0;
+}
+
+TESSreal tesedgeSign( TESSvertex *u, TESSvertex *v, TESSvertex *w )
+{
+	/* Returns a number whose sign matches EdgeEval(u,v,w) but which
+	* is cheaper to evaluate.  Returns > 0, == 0 , or < 0
+	* as v is above, on, or below the edge uw.
+	*/
+	TESSreal gapL, gapR;
+
+	assert( VertLeq( u, v ) && VertLeq( v, w ));
+
+	gapL = v->s - u->s;
+	gapR = w->s - v->s;
+
+	if( gapL + gapR > 0 ) {
+		return (v->t - w->t) * gapL + (v->t - u->t) * gapR;
+	}
+	/* vertical line */
+	return 0;
+}
+
+
+/***********************************************************************
+* Define versions of EdgeSign, EdgeEval with s and t transposed.
+*/
+
+TESSreal testransEval( TESSvertex *u, TESSvertex *v, TESSvertex *w )
+{
+	/* Given three vertices u,v,w such that TransLeq(u,v) && TransLeq(v,w),
+	* evaluates the t-coord of the edge uw at the s-coord of the vertex v.
+	* Returns v->s - (uw)(v->t), ie. the signed distance from uw to v.
+	* If uw is vertical (and thus passes thru v), the result is zero.
+	*
+	* The calculation is extremely accurate and stable, even when v
+	* is very close to u or w.  In particular if we set v->s = 0 and
+	* let r be the negated result (this evaluates (uw)(v->t)), then
+	* r is guaranteed to satisfy MIN(u->s,w->s) <= r <= MAX(u->s,w->s).
+	*/
+	TESSreal gapL, gapR;
+
+	assert( TransLeq( u, v ) && TransLeq( v, w ));
+
+	gapL = v->t - u->t;
+	gapR = w->t - v->t;
+
+	if( gapL + gapR > 0 ) {
+		if( gapL < gapR ) {
+			return (v->s - u->s) + (u->s - w->s) * (gapL / (gapL + gapR));
+		} else {
+			return (v->s - w->s) + (w->s - u->s) * (gapR / (gapL + gapR));
+		}
+	}
+	/* vertical line */
+	return 0;
+}
+
+TESSreal testransSign( TESSvertex *u, TESSvertex *v, TESSvertex *w )
+{
+	/* Returns a number whose sign matches TransEval(u,v,w) but which
+	* is cheaper to evaluate.  Returns > 0, == 0 , or < 0
+	* as v is above, on, or below the edge uw.
+	*/
+	TESSreal gapL, gapR;
+
+	assert( TransLeq( u, v ) && TransLeq( v, w ));
+
+	gapL = v->t - u->t;
+	gapR = w->t - v->t;
+
+	if( gapL + gapR > 0 ) {
+		return (v->s - w->s) * gapL + (v->s - u->s) * gapR;
+	}
+	/* vertical line */
+	return 0;
+}
+
+
+int tesvertCCW( TESSvertex *u, TESSvertex *v, TESSvertex *w )
+{
+	/* For almost-degenerate situations, the results are not reliable.
+	* Unless the floating-point arithmetic can be performed without
+	* rounding errors, *any* implementation will give incorrect results
+	* on some degenerate inputs, so the client must have some way to
+	* handle this situation.
+	*/
+	return (u->s*(v->t - w->t) + v->s*(w->t - u->t) + w->s*(u->t - v->t)) >= 0;
+}
+
+/* Given parameters a,x,b,y returns the value (b*x+a*y)/(a+b),
+* or (x+y)/2 if a==b==0.  It requires that a,b >= 0, and enforces
+* this in the rare case that one argument is slightly negative.
+* The implementation is extremely stable numerically.
+* In particular it guarantees that the result r satisfies
+* MIN(x,y) <= r <= MAX(x,y), and the results are very accurate
+* even when a and b differ greatly in magnitude.
+*/
+#define RealInterpolate(a,x,b,y)			\
+	(a = (a < 0) ? 0 : a, b = (b < 0) ? 0 : b,		\
+	((a <= b) ? ((b == 0) ? ((x+y) / 2)			\
+	: (x + (y-x) * (a/(a+b))))	\
+	: (y + (x-y) * (b/(a+b)))))
+
+#ifndef FOR_TRITE_TEST_PROGRAM
+#define Interpolate(a,x,b,y)	RealInterpolate(a,x,b,y)
+#else
+
+/* Claim: the ONLY property the sweep algorithm relies on is that
+* MIN(x,y) <= r <= MAX(x,y).  This is a nasty way to test that.
+*/
+#include <stdlib.h>
+extern int RandomInterpolate;
+
+double Interpolate( double a, double x, double b, double y)
+{
+	printf("*********************%d\n",RandomInterpolate);
+	if( RandomInterpolate ) {
+		a = 1.2 * drand48() - 0.1;
+		a = (a < 0) ? 0 : ((a > 1) ? 1 : a);
+		b = 1.0 - a;
+	}
+	return RealInterpolate(a,x,b,y);
+}
+
+#endif
+
+#define Swap(a,b)	if (1) { TESSvertex *t = a; a = b; b = t; } else
+
+void tesedgeIntersect( TESSvertex *o1, TESSvertex *d1,
+					  TESSvertex *o2, TESSvertex *d2,
+					  TESSvertex *v )
+					  /* Given edges (o1,d1) and (o2,d2), compute their point of intersection.
+					  * The computed point is guaranteed to lie in the intersection of the
+					  * bounding rectangles defined by each edge.
+					  */
+{
+	TESSreal z1, z2;
+
+	/* This is certainly not the most efficient way to find the intersection
+	* of two line segments, but it is very numerically stable.
+	*
+	* Strategy: find the two middle vertices in the VertLeq ordering,
+	* and interpolate the intersection s-value from these.  Then repeat
+	* using the TransLeq ordering to find the intersection t-value.
+	*/
+
+	if( ! VertLeq( o1, d1 )) { Swap( o1, d1 ); }
+	if( ! VertLeq( o2, d2 )) { Swap( o2, d2 ); }
+	if( ! VertLeq( o1, o2 )) { Swap( o1, o2 ); Swap( d1, d2 ); }
+
+	if( ! VertLeq( o2, d1 )) {
+		/* Technically, no intersection -- do our best */
+		v->s = (o2->s + d1->s) / 2;
+	} else if( VertLeq( d1, d2 )) {
+		/* Interpolate between o2 and d1 */
+		z1 = EdgeEval( o1, o2, d1 );
+		z2 = EdgeEval( o2, d1, d2 );
+		if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
+		v->s = Interpolate( z1, o2->s, z2, d1->s );
+	} else {
+		/* Interpolate between o2 and d2 */
+		z1 = EdgeSign( o1, o2, d1 );
+		z2 = -EdgeSign( o1, d2, d1 );
+		if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
+		v->s = Interpolate( z1, o2->s, z2, d2->s );
+	}
+
+	/* Now repeat the process for t */
+
+	if( ! TransLeq( o1, d1 )) { Swap( o1, d1 ); }
+	if( ! TransLeq( o2, d2 )) { Swap( o2, d2 ); }
+	if( ! TransLeq( o1, o2 )) { Swap( o1, o2 ); Swap( d1, d2 ); }
+
+	if( ! TransLeq( o2, d1 )) {
+		/* Technically, no intersection -- do our best */
+		v->t = (o2->t + d1->t) / 2;
+	} else if( TransLeq( d1, d2 )) {
+		/* Interpolate between o2 and d1 */
+		z1 = TransEval( o1, o2, d1 );
+		z2 = TransEval( o2, d1, d2 );
+		if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
+		v->t = Interpolate( z1, o2->t, z2, d1->t );
+	} else {
+		/* Interpolate between o2 and d2 */
+		z1 = TransSign( o1, o2, d1 );
+		z2 = -TransSign( o1, d2, d1 );
+		if( z1+z2 < 0 ) { z1 = -z1; z2 = -z2; }
+		v->t = Interpolate( z1, o2->t, z2, d2->t );
+	}
+}

polygon.mod/earcut/test/comparison/libtess2/geom.h

@@ -0,0 +1,76 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#ifndef GEOM_H
+#define GEOM_H
+
+#include "mesh.h"
+
+#ifdef NO_BRANCH_CONDITIONS
+/* MIPS architecture has special instructions to evaluate boolean
+* conditions -- more efficient than branching, IF you can get the
+* compiler to generate the right instructions (SGI compiler doesn't)
+*/
+#define VertEq(u,v)	(((u)->s == (v)->s) & ((u)->t == (v)->t))
+#define VertLeq(u,v)	(((u)->s < (v)->s) | \
+	((u)->s == (v)->s & (u)->t <= (v)->t))
+#else
+#define VertEq(u,v) ((u)->s == (v)->s && (u)->t == (v)->t)
+#define VertLeq(u,v) (((u)->s < (v)->s) || ((u)->s == (v)->s && (u)->t <= (v)->t))
+#endif
+
+#define EdgeEval(u,v,w)	tesedgeEval(u,v,w)
+#define EdgeSign(u,v,w)	tesedgeSign(u,v,w)
+
+/* Versions of VertLeq, EdgeSign, EdgeEval with s and t transposed. */
+
+#define TransLeq(u,v) (((u)->t < (v)->t) || ((u)->t == (v)->t && (u)->s <= (v)->s))
+#define TransEval(u,v,w) testransEval(u,v,w)
+#define TransSign(u,v,w) testransSign(u,v,w)
+
+
+#define EdgeGoesLeft(e) VertLeq( (e)->Dst, (e)->Org )
+#define EdgeGoesRight(e) VertLeq( (e)->Org, (e)->Dst )
+
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+#define VertL1dist(u,v) (ABS(u->s - v->s) + ABS(u->t - v->t))
+
+#define VertCCW(u,v,w) tesvertCCW(u,v,w)
+
+int tesvertLeq( TESSvertex *u, TESSvertex *v );
+TESSreal	tesedgeEval( TESSvertex *u, TESSvertex *v, TESSvertex *w );
+TESSreal	tesedgeSign( TESSvertex *u, TESSvertex *v, TESSvertex *w );
+TESSreal	testransEval( TESSvertex *u, TESSvertex *v, TESSvertex *w );
+TESSreal	testransSign( TESSvertex *u, TESSvertex *v, TESSvertex *w );
+int tesvertCCW( TESSvertex *u, TESSvertex *v, TESSvertex *w );
+void tesedgeIntersect( TESSvertex *o1, TESSvertex *d1, TESSvertex *o2, TESSvertex *d2, TESSvertex *v );
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/mesh.c

@@ -0,0 +1,843 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+//#include "tesos.h"
+#include <stddef.h>
+#include <assert.h>
+#include "mesh.h"
+#include "geom.h"
+#include "bucketalloc.h"
+
+#define TRUE 1
+#define FALSE 0
+
+/************************ Utility Routines ************************/
+
+/* Allocate and free half-edges in pairs for efficiency.
+* The *only* place that should use this fact is allocation/free.
+*/
+typedef struct { TESShalfEdge e, eSym; } EdgePair;
+
+/* MakeEdge creates a new pair of half-edges which form their own loop.
+* No vertex or face structures are allocated, but these must be assigned
+* before the current edge operation is completed.
+*/
+static TESShalfEdge *MakeEdge( TESSmesh* mesh, TESShalfEdge *eNext )
+{
+	TESShalfEdge *e;
+	TESShalfEdge *eSym;
+	TESShalfEdge *ePrev;
+	EdgePair *pair = (EdgePair *)bucketAlloc( mesh->edgeBucket );
+	if (pair == NULL) return NULL;
+
+	e = &pair->e;
+	eSym = &pair->eSym;
+
+	/* Make sure eNext points to the first edge of the edge pair */
+	if( eNext->Sym < eNext ) { eNext = eNext->Sym; }
+
+	/* Insert in circular doubly-linked list before eNext.
+	* Note that the prev pointer is stored in Sym->next.
+	*/
+	ePrev = eNext->Sym->next;
+	eSym->next = ePrev;
+	ePrev->Sym->next = e;
+	e->next = eNext;
+	eNext->Sym->next = eSym;
+
+	e->Sym = eSym;
+	e->Onext = e;
+	e->Lnext = eSym;
+	e->Org = NULL;
+	e->Lface = NULL;
+	e->winding = 0;
+	e->activeRegion = NULL;
+
+	eSym->Sym = e;
+	eSym->Onext = eSym;
+	eSym->Lnext = e;
+	eSym->Org = NULL;
+	eSym->Lface = NULL;
+	eSym->winding = 0;
+	eSym->activeRegion = NULL;
+
+	return e;
+}
+
+/* Splice( a, b ) is best described by the Guibas/Stolfi paper or the
+* CS348a notes (see mesh.h).  Basically it modifies the mesh so that
+* a->Onext and b->Onext are exchanged.  This can have various effects
+* depending on whether a and b belong to different face or vertex rings.
+* For more explanation see tessMeshSplice() below.
+*/
+static void Splice( TESShalfEdge *a, TESShalfEdge *b )
+{
+	TESShalfEdge *aOnext = a->Onext;
+	TESShalfEdge *bOnext = b->Onext;
+
+	aOnext->Sym->Lnext = b;
+	bOnext->Sym->Lnext = a;
+	a->Onext = bOnext;
+	b->Onext = aOnext;
+}
+
+/* MakeVertex( newVertex, eOrig, vNext ) attaches a new vertex and makes it the
+* origin of all edges in the vertex loop to which eOrig belongs. "vNext" gives
+* a place to insert the new vertex in the global vertex list.  We insert
+* the new vertex *before* vNext so that algorithms which walk the vertex
+* list will not see the newly created vertices.
+*/
+static void MakeVertex( TESSvertex *newVertex,
+					   TESShalfEdge *eOrig, TESSvertex *vNext )
+{
+	TESShalfEdge *e;
+	TESSvertex *vPrev;
+	TESSvertex *vNew = newVertex;
+
+	assert(vNew != NULL);
+
+	/* insert in circular doubly-linked list before vNext */
+	vPrev = vNext->prev;
+	vNew->prev = vPrev;
+	vPrev->next = vNew;
+	vNew->next = vNext;
+	vNext->prev = vNew;
+
+	vNew->anEdge = eOrig;
+	/* leave coords, s, t undefined */
+
+	/* fix other edges on this vertex loop */
+	e = eOrig;
+	do {
+		e->Org = vNew;
+		e = e->Onext;
+	} while( e != eOrig );
+}
+
+/* MakeFace( newFace, eOrig, fNext ) attaches a new face and makes it the left
+* face of all edges in the face loop to which eOrig belongs.  "fNext" gives
+* a place to insert the new face in the global face list.  We insert
+* the new face *before* fNext so that algorithms which walk the face
+* list will not see the newly created faces.
+*/
+static void MakeFace( TESSface *newFace, TESShalfEdge *eOrig, TESSface *fNext )
+{
+	TESShalfEdge *e;
+	TESSface *fPrev;
+	TESSface *fNew = newFace;
+
+	assert(fNew != NULL);
+
+	/* insert in circular doubly-linked list before fNext */
+	fPrev = fNext->prev;
+	fNew->prev = fPrev;
+	fPrev->next = fNew;
+	fNew->next = fNext;
+	fNext->prev = fNew;
+
+	fNew->anEdge = eOrig;
+	fNew->trail = NULL;
+	fNew->marked = FALSE;
+
+	/* The new face is marked "inside" if the old one was.  This is a
+	* convenience for the common case where a face has been split in two.
+	*/
+	fNew->inside = fNext->inside;
+
+	/* fix other edges on this face loop */
+	e = eOrig;
+	do {
+		e->Lface = fNew;
+		e = e->Lnext;
+	} while( e != eOrig );
+}
+
+/* KillEdge( eDel ) destroys an edge (the half-edges eDel and eDel->Sym),
+* and removes from the global edge list.
+*/
+static void KillEdge( TESSmesh *mesh, TESShalfEdge *eDel )
+{
+	TESShalfEdge *ePrev, *eNext;
+
+	/* Half-edges are allocated in pairs, see EdgePair above */
+	if( eDel->Sym < eDel ) { eDel = eDel->Sym; }
+
+	/* delete from circular doubly-linked list */
+	eNext = eDel->next;
+	ePrev = eDel->Sym->next;
+	eNext->Sym->next = ePrev;
+	ePrev->Sym->next = eNext;
+
+	bucketFree( mesh->edgeBucket, eDel );
+}
+
+
+/* KillVertex( vDel ) destroys a vertex and removes it from the global
+* vertex list.  It updates the vertex loop to point to a given new vertex.
+*/
+static void KillVertex( TESSmesh *mesh, TESSvertex *vDel, TESSvertex *newOrg )
+{
+	TESShalfEdge *e, *eStart = vDel->anEdge;
+	TESSvertex *vPrev, *vNext;
+
+	/* change the origin of all affected edges */
+	e = eStart;
+	do {
+		e->Org = newOrg;
+		e = e->Onext;
+	} while( e != eStart );
+
+	/* delete from circular doubly-linked list */
+	vPrev = vDel->prev;
+	vNext = vDel->next;
+	vNext->prev = vPrev;
+	vPrev->next = vNext;
+
+	bucketFree( mesh->vertexBucket, vDel );
+}
+
+/* KillFace( fDel ) destroys a face and removes it from the global face
+* list.  It updates the face loop to point to a given new face.
+*/
+static void KillFace( TESSmesh *mesh, TESSface *fDel, TESSface *newLface )
+{
+	TESShalfEdge *e, *eStart = fDel->anEdge;
+	TESSface *fPrev, *fNext;
+
+	/* change the left face of all affected edges */
+	e = eStart;
+	do {
+		e->Lface = newLface;
+		e = e->Lnext;
+	} while( e != eStart );
+
+	/* delete from circular doubly-linked list */
+	fPrev = fDel->prev;
+	fNext = fDel->next;
+	fNext->prev = fPrev;
+	fPrev->next = fNext;
+
+	bucketFree( mesh->faceBucket, fDel );
+}
+
+
+/****************** Basic Edge Operations **********************/
+
+/* tessMeshMakeEdge creates one edge, two vertices, and a loop (face).
+* The loop consists of the two new half-edges.
+*/
+TESShalfEdge *tessMeshMakeEdge( TESSmesh *mesh )
+{
+	TESSvertex *newVertex1 = (TESSvertex*)bucketAlloc(mesh->vertexBucket);
+	TESSvertex *newVertex2 = (TESSvertex*)bucketAlloc(mesh->vertexBucket);
+	TESSface *newFace = (TESSface*)bucketAlloc(mesh->faceBucket);
+	TESShalfEdge *e;
+
+	/* if any one is null then all get freed */
+	if (newVertex1 == NULL || newVertex2 == NULL || newFace == NULL) {
+		if (newVertex1 != NULL) bucketFree( mesh->vertexBucket, newVertex1 );
+		if (newVertex2 != NULL) bucketFree( mesh->vertexBucket, newVertex2 );
+		if (newFace != NULL) bucketFree( mesh->faceBucket, newFace );
+		return NULL;
+	}
+
+	e = MakeEdge( mesh, &mesh->eHead );
+	if (e == NULL) return NULL;
+
+	MakeVertex( newVertex1, e, &mesh->vHead );
+	MakeVertex( newVertex2, e->Sym, &mesh->vHead );
+	MakeFace( newFace, e, &mesh->fHead );
+	return e;
+}
+
+
+/* tessMeshSplice( eOrg, eDst ) is the basic operation for changing the
+* mesh connectivity and topology.  It changes the mesh so that
+*	eOrg->Onext <- OLD( eDst->Onext )
+*	eDst->Onext <- OLD( eOrg->Onext )
+* where OLD(...) means the value before the meshSplice operation.
+*
+* This can have two effects on the vertex structure:
+*  - if eOrg->Org != eDst->Org, the two vertices are merged together
+*  - if eOrg->Org == eDst->Org, the origin is split into two vertices
+* In both cases, eDst->Org is changed and eOrg->Org is untouched.
+*
+* Similarly (and independently) for the face structure,
+*  - if eOrg->Lface == eDst->Lface, one loop is split into two
+*  - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one
+* In both cases, eDst->Lface is changed and eOrg->Lface is unaffected.
+*
+* Some special cases:
+* If eDst == eOrg, the operation has no effect.
+* If eDst == eOrg->Lnext, the new face will have a single edge.
+* If eDst == eOrg->Lprev, the old face will have a single edge.
+* If eDst == eOrg->Onext, the new vertex will have a single edge.
+* If eDst == eOrg->Oprev, the old vertex will have a single edge.
+*/
+int tessMeshSplice( TESSmesh* mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst )
+{
+	int joiningLoops = FALSE;
+	int joiningVertices = FALSE;
+
+	if( eOrg == eDst ) return 1;
+
+	if( eDst->Org != eOrg->Org ) {
+		/* We are merging two disjoint vertices -- destroy eDst->Org */
+		joiningVertices = TRUE;
+		KillVertex( mesh, eDst->Org, eOrg->Org );
+	}
+	if( eDst->Lface != eOrg->Lface ) {
+		/* We are connecting two disjoint loops -- destroy eDst->Lface */
+		joiningLoops = TRUE;
+		KillFace( mesh, eDst->Lface, eOrg->Lface );
+	}
+
+	/* Change the edge structure */
+	Splice( eDst, eOrg );
+
+	if( ! joiningVertices ) {
+		TESSvertex *newVertex = (TESSvertex*)bucketAlloc( mesh->vertexBucket );
+		if (newVertex == NULL) return 0;
+
+		/* We split one vertex into two -- the new vertex is eDst->Org.
+		* Make sure the old vertex points to a valid half-edge.
+		*/
+		MakeVertex( newVertex, eDst, eOrg->Org );
+		eOrg->Org->anEdge = eOrg;
+	}
+	if( ! joiningLoops ) {
+		TESSface *newFace = (TESSface*)bucketAlloc( mesh->faceBucket );
+		if (newFace == NULL) return 0;
+
+		/* We split one loop into two -- the new loop is eDst->Lface.
+		* Make sure the old face points to a valid half-edge.
+		*/
+		MakeFace( newFace, eDst, eOrg->Lface );
+		eOrg->Lface->anEdge = eOrg;
+	}
+
+	return 1;
+}
+
+
+/* tessMeshDelete( eDel ) removes the edge eDel.  There are several cases:
+* if (eDel->Lface != eDel->Rface), we join two loops into one; the loop
+* eDel->Lface is deleted.  Otherwise, we are splitting one loop into two;
+* the newly created loop will contain eDel->Dst.  If the deletion of eDel
+* would create isolated vertices, those are deleted as well.
+*
+* This function could be implemented as two calls to tessMeshSplice
+* plus a few calls to memFree, but this would allocate and delete
+* unnecessary vertices and faces.
+*/
+int tessMeshDelete( TESSmesh *mesh, TESShalfEdge *eDel )
+{
+	TESShalfEdge *eDelSym = eDel->Sym;
+	int joiningLoops = FALSE;
+
+	/* First step: disconnect the origin vertex eDel->Org.  We make all
+	* changes to get a consistent mesh in this "intermediate" state.
+	*/
+	if( eDel->Lface != eDel->Rface ) {
+		/* We are joining two loops into one -- remove the left face */
+		joiningLoops = TRUE;
+		KillFace( mesh, eDel->Lface, eDel->Rface );
+	}
+
+	if( eDel->Onext == eDel ) {
+		KillVertex( mesh, eDel->Org, NULL );
+	} else {
+		/* Make sure that eDel->Org and eDel->Rface point to valid half-edges */
+		eDel->Rface->anEdge = eDel->Oprev;
+		eDel->Org->anEdge = eDel->Onext;
+
+		Splice( eDel, eDel->Oprev );
+		if( ! joiningLoops ) {
+			TESSface *newFace= (TESSface*)bucketAlloc( mesh->faceBucket );
+			if (newFace == NULL) return 0;
+
+			/* We are splitting one loop into two -- create a new loop for eDel. */
+			MakeFace( newFace, eDel, eDel->Lface );
+		}
+	}
+
+	/* Claim: the mesh is now in a consistent state, except that eDel->Org
+	* may have been deleted.  Now we disconnect eDel->Dst.
+	*/
+	if( eDelSym->Onext == eDelSym ) {
+		KillVertex( mesh, eDelSym->Org, NULL );
+		KillFace( mesh, eDelSym->Lface, NULL );
+	} else {
+		/* Make sure that eDel->Dst and eDel->Lface point to valid half-edges */
+		eDel->Lface->anEdge = eDelSym->Oprev;
+		eDelSym->Org->anEdge = eDelSym->Onext;
+		Splice( eDelSym, eDelSym->Oprev );
+	}
+
+	/* Any isolated vertices or faces have already been freed. */
+	KillEdge( mesh, eDel );
+
+	return 1;
+}
+
+
+/******************** Other Edge Operations **********************/
+
+/* All these routines can be implemented with the basic edge
+* operations above.  They are provided for convenience and efficiency.
+*/
+
+
+/* tessMeshAddEdgeVertex( eOrg ) creates a new edge eNew such that
+* eNew == eOrg->Lnext, and eNew->Dst is a newly created vertex.
+* eOrg and eNew will have the same left face.
+*/
+TESShalfEdge *tessMeshAddEdgeVertex( TESSmesh *mesh, TESShalfEdge *eOrg )
+{
+	TESShalfEdge *eNewSym;
+	TESShalfEdge *eNew = MakeEdge( mesh, eOrg );
+	if (eNew == NULL) return NULL;
+
+	eNewSym = eNew->Sym;
+
+	/* Connect the new edge appropriately */
+	Splice( eNew, eOrg->Lnext );
+
+	/* Set the vertex and face information */
+	eNew->Org = eOrg->Dst;
+	{
+		TESSvertex *newVertex= (TESSvertex*)bucketAlloc( mesh->vertexBucket );
+		if (newVertex == NULL) return NULL;
+
+		MakeVertex( newVertex, eNewSym, eNew->Org );
+	}
+	eNew->Lface = eNewSym->Lface = eOrg->Lface;
+
+	return eNew;
+}
+
+
+/* tessMeshSplitEdge( eOrg ) splits eOrg into two edges eOrg and eNew,
+* such that eNew == eOrg->Lnext.  The new vertex is eOrg->Dst == eNew->Org.
+* eOrg and eNew will have the same left face.
+*/
+TESShalfEdge *tessMeshSplitEdge( TESSmesh *mesh, TESShalfEdge *eOrg )
+{
+	TESShalfEdge *eNew;
+	TESShalfEdge *tempHalfEdge= tessMeshAddEdgeVertex( mesh, eOrg );
+	if (tempHalfEdge == NULL) return NULL;
+
+	eNew = tempHalfEdge->Sym;
+
+	/* Disconnect eOrg from eOrg->Dst and connect it to eNew->Org */
+	Splice( eOrg->Sym, eOrg->Sym->Oprev );
+	Splice( eOrg->Sym, eNew );
+
+	/* Set the vertex and face information */
+	eOrg->Dst = eNew->Org;
+	eNew->Dst->anEdge = eNew->Sym;	/* may have pointed to eOrg->Sym */
+	eNew->Rface = eOrg->Rface;
+	eNew->winding = eOrg->winding;	/* copy old winding information */
+	eNew->Sym->winding = eOrg->Sym->winding;
+
+	return eNew;
+}
+
+
+/* tessMeshConnect( eOrg, eDst ) creates a new edge from eOrg->Dst
+* to eDst->Org, and returns the corresponding half-edge eNew.
+* If eOrg->Lface == eDst->Lface, this splits one loop into two,
+* and the newly created loop is eNew->Lface.  Otherwise, two disjoint
+* loops are merged into one, and the loop eDst->Lface is destroyed.
+*
+* If (eOrg == eDst), the new face will have only two edges.
+* If (eOrg->Lnext == eDst), the old face is reduced to a single edge.
+* If (eOrg->Lnext->Lnext == eDst), the old face is reduced to two edges.
+*/
+TESShalfEdge *tessMeshConnect( TESSmesh *mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst )
+{
+	TESShalfEdge *eNewSym;
+	int joiningLoops = FALSE;
+	TESShalfEdge *eNew = MakeEdge( mesh, eOrg );
+	if (eNew == NULL) return NULL;
+
+	eNewSym = eNew->Sym;
+
+	if( eDst->Lface != eOrg->Lface ) {
+		/* We are connecting two disjoint loops -- destroy eDst->Lface */
+		joiningLoops = TRUE;
+		KillFace( mesh, eDst->Lface, eOrg->Lface );
+	}
+
+	/* Connect the new edge appropriately */
+	Splice( eNew, eOrg->Lnext );
+	Splice( eNewSym, eDst );
+
+	/* Set the vertex and face information */
+	eNew->Org = eOrg->Dst;
+	eNewSym->Org = eDst->Org;
+	eNew->Lface = eNewSym->Lface = eOrg->Lface;
+
+	/* Make sure the old face points to a valid half-edge */
+	eOrg->Lface->anEdge = eNewSym;
+
+	if( ! joiningLoops ) {
+		TESSface *newFace= (TESSface*)bucketAlloc( mesh->faceBucket );
+		if (newFace == NULL) return NULL;
+
+		/* We split one loop into two -- the new loop is eNew->Lface */
+		MakeFace( newFace, eNew, eOrg->Lface );
+	}
+	return eNew;
+}
+
+
+/******************** Other Operations **********************/
+
+/* tessMeshZapFace( fZap ) destroys a face and removes it from the
+* global face list.  All edges of fZap will have a NULL pointer as their
+* left face.  Any edges which also have a NULL pointer as their right face
+* are deleted entirely (along with any isolated vertices this produces).
+* An entire mesh can be deleted by zapping its faces, one at a time,
+* in any order.  Zapped faces cannot be used in further mesh operations!
+*/
+void tessMeshZapFace( TESSmesh *mesh, TESSface *fZap )
+{
+	TESShalfEdge *eStart = fZap->anEdge;
+	TESShalfEdge *e, *eNext, *eSym;
+	TESSface *fPrev, *fNext;
+
+	/* walk around face, deleting edges whose right face is also NULL */
+	eNext = eStart->Lnext;
+	do {
+		e = eNext;
+		eNext = e->Lnext;
+
+		e->Lface = NULL;
+		if( e->Rface == NULL ) {
+			/* delete the edge -- see TESSmeshDelete above */
+
+			if( e->Onext == e ) {
+				KillVertex( mesh, e->Org, NULL );
+			} else {
+				/* Make sure that e->Org points to a valid half-edge */
+				e->Org->anEdge = e->Onext;
+				Splice( e, e->Oprev );
+			}
+			eSym = e->Sym;
+			if( eSym->Onext == eSym ) {
+				KillVertex( mesh, eSym->Org, NULL );
+			} else {
+				/* Make sure that eSym->Org points to a valid half-edge */
+				eSym->Org->anEdge = eSym->Onext;
+				Splice( eSym, eSym->Oprev );
+			}
+			KillEdge( mesh, e );
+		}
+	} while( e != eStart );
+
+	/* delete from circular doubly-linked list */
+	fPrev = fZap->prev;
+	fNext = fZap->next;
+	fNext->prev = fPrev;
+	fPrev->next = fNext;
+
+	bucketFree( mesh->faceBucket, fZap );
+}
+
+
+/* tessMeshNewMesh() creates a new mesh with no edges, no vertices,
+* and no loops (what we usually call a "face").
+*/
+TESSmesh *tessMeshNewMesh( TESSalloc* alloc )
+{
+	TESSvertex *v;
+	TESSface *f;
+	TESShalfEdge *e;
+	TESShalfEdge *eSym;
+	TESSmesh *mesh = (TESSmesh *)alloc->memalloc( alloc->userData, sizeof( TESSmesh ));
+	if (mesh == NULL) {
+		return NULL;
+	}
+
+	if (alloc->meshEdgeBucketSize < 16)
+		alloc->meshEdgeBucketSize = 16;
+	if (alloc->meshEdgeBucketSize > 4096)
+		alloc->meshEdgeBucketSize = 4096;
+
+	if (alloc->meshVertexBucketSize < 16)
+		alloc->meshVertexBucketSize = 16;
+	if (alloc->meshVertexBucketSize > 4096)
+		alloc->meshVertexBucketSize = 4096;
+
+	if (alloc->meshFaceBucketSize < 16)
+		alloc->meshFaceBucketSize = 16;
+	if (alloc->meshFaceBucketSize > 4096)
+		alloc->meshFaceBucketSize = 4096;
+
+	mesh->edgeBucket = createBucketAlloc( alloc, "Mesh Edges", sizeof(EdgePair), alloc->meshEdgeBucketSize );
+	mesh->vertexBucket = createBucketAlloc( alloc, "Mesh Vertices", sizeof(TESSvertex), alloc->meshVertexBucketSize );
+	mesh->faceBucket = createBucketAlloc( alloc, "Mesh Faces", sizeof(TESSface), alloc->meshFaceBucketSize );
+
+	v = &mesh->vHead;
+	f = &mesh->fHead;
+	e = &mesh->eHead;
+	eSym = &mesh->eHeadSym;
+
+	v->next = v->prev = v;
+	v->anEdge = NULL;
+
+	f->next = f->prev = f;
+	f->anEdge = NULL;
+	f->trail = NULL;
+	f->marked = FALSE;
+	f->inside = FALSE;
+
+	e->next = e;
+	e->Sym = eSym;
+	e->Onext = NULL;
+	e->Lnext = NULL;
+	e->Org = NULL;
+	e->Lface = NULL;
+	e->winding = 0;
+	e->activeRegion = NULL;
+
+	eSym->next = eSym;
+	eSym->Sym = e;
+	eSym->Onext = NULL;
+	eSym->Lnext = NULL;
+	eSym->Org = NULL;
+	eSym->Lface = NULL;
+	eSym->winding = 0;
+	eSym->activeRegion = NULL;
+
+	return mesh;
+}
+
+
+/* tessMeshUnion( mesh1, mesh2 ) forms the union of all structures in
+* both meshes, and returns the new mesh (the old meshes are destroyed).
+*/
+TESSmesh *tessMeshUnion( TESSalloc* alloc, TESSmesh *mesh1, TESSmesh *mesh2 )
+{
+	TESSface *f1 = &mesh1->fHead;
+	TESSvertex *v1 = &mesh1->vHead;
+	TESShalfEdge *e1 = &mesh1->eHead;
+	TESSface *f2 = &mesh2->fHead;
+	TESSvertex *v2 = &mesh2->vHead;
+	TESShalfEdge *e2 = &mesh2->eHead;
+
+	/* Add the faces, vertices, and edges of mesh2 to those of mesh1 */
+	if( f2->next != f2 ) {
+		f1->prev->next = f2->next;
+		f2->next->prev = f1->prev;
+		f2->prev->next = f1;
+		f1->prev = f2->prev;
+	}
+
+	if( v2->next != v2 ) {
+		v1->prev->next = v2->next;
+		v2->next->prev = v1->prev;
+		v2->prev->next = v1;
+		v1->prev = v2->prev;
+	}
+
+	if( e2->next != e2 ) {
+		e1->Sym->next->Sym->next = e2->next;
+		e2->next->Sym->next = e1->Sym->next;
+		e2->Sym->next->Sym->next = e1;
+		e1->Sym->next = e2->Sym->next;
+	}
+
+	alloc->memfree( alloc->userData, mesh2 );
+	return mesh1;
+}
+
+
+static int CountFaceVerts( TESSface *f )
+{
+	TESShalfEdge *eCur = f->anEdge;
+	int n = 0;
+	do
+	{
+		n++;
+		eCur = eCur->Lnext;
+	}
+	while (eCur != f->anEdge);
+	return n;
+}
+
+int tessMeshMergeConvexFaces( TESSmesh *mesh, int maxVertsPerFace )
+{
+	TESSface *f;
+	TESShalfEdge *eCur, *eNext, *eSym;
+	TESSvertex *vStart;
+	int curNv, symNv;
+
+	for( f = mesh->fHead.next; f != &mesh->fHead; f = f->next )
+	{
+		// Skip faces which are outside the result.
+		if( !f->inside )
+			continue;
+
+		eCur = f->anEdge;
+		vStart = eCur->Org;
+
+		while (1)
+		{
+			eNext = eCur->Lnext;
+			eSym = eCur->Sym;
+
+			// Try to merge if the neighbour face is valid.
+			if( eSym && eSym->Lface && eSym->Lface->inside )
+			{
+				// Try to merge the neighbour faces if the resulting polygons
+				// does not exceed maximum number of vertices.
+				curNv = CountFaceVerts( f );
+				symNv = CountFaceVerts( eSym->Lface );
+				if( (curNv+symNv-2) <= maxVertsPerFace )
+				{
+					// Merge if the resulting poly is convex.
+					if( VertCCW( eCur->Lprev->Org, eCur->Org, eSym->Lnext->Lnext->Org ) &&
+						VertCCW( eSym->Lprev->Org, eSym->Org, eCur->Lnext->Lnext->Org ) )
+					{
+						eNext = eSym->Lnext;
+						if( !tessMeshDelete( mesh, eSym ) )
+							return 0;
+						eCur = 0;
+					}
+				}
+			}
+
+			if( eCur && eCur->Lnext->Org == vStart )
+				break;
+
+			// Continue to next edge.
+			eCur = eNext;
+		}
+	}
+
+	return 1;
+}
+
+
+#ifdef DELETE_BY_ZAPPING
+
+/* tessMeshDeleteMesh( mesh ) will free all storage for any valid mesh.
+*/
+void tessMeshDeleteMesh( TESSalloc* alloc, TESSmesh *mesh )
+{
+	TESSface *fHead = &mesh->fHead;
+
+	while( fHead->next != fHead ) {
+		tessMeshZapFace( fHead->next );
+	}
+	assert( mesh->vHead.next == &mesh->vHead );
+
+	alloc->memfree( alloc->userData, mesh );
+}
+
+#else
+
+/* tessMeshDeleteMesh( mesh ) will free all storage for any valid mesh.
+*/
+void tessMeshDeleteMesh( TESSalloc* alloc, TESSmesh *mesh )
+{
+	deleteBucketAlloc(mesh->edgeBucket);
+	deleteBucketAlloc(mesh->vertexBucket);
+	deleteBucketAlloc(mesh->faceBucket);
+
+	alloc->memfree( alloc->userData, mesh );
+}
+
+#endif
+
+#ifndef NDEBUG
+
+/* tessMeshCheckMesh( mesh ) checks a mesh for self-consistency.
+*/
+void tessMeshCheckMesh( TESSmesh *mesh )
+{
+	TESSface *fHead = &mesh->fHead;
+	TESSvertex *vHead = &mesh->vHead;
+	TESShalfEdge *eHead = &mesh->eHead;
+	TESSface *f, *fPrev;
+	TESSvertex *v, *vPrev;
+	TESShalfEdge *e, *ePrev;
+
+	fPrev = fHead;
+	for( fPrev = fHead ; (f = fPrev->next) != fHead; fPrev = f) {
+		assert( f->prev == fPrev );
+		e = f->anEdge;
+		do {
+			assert( e->Sym != e );
+			assert( e->Sym->Sym == e );
+			assert( e->Lnext->Onext->Sym == e );
+			assert( e->Onext->Sym->Lnext == e );
+			assert( e->Lface == f );
+			e = e->Lnext;
+		} while( e != f->anEdge );
+	}
+	assert( f->prev == fPrev && f->anEdge == NULL );
+
+	vPrev = vHead;
+	for( vPrev = vHead ; (v = vPrev->next) != vHead; vPrev = v) {
+		assert( v->prev == vPrev );
+		e = v->anEdge;
+		do {
+			assert( e->Sym != e );
+			assert( e->Sym->Sym == e );
+			assert( e->Lnext->Onext->Sym == e );
+			assert( e->Onext->Sym->Lnext == e );
+			assert( e->Org == v );
+			e = e->Onext;
+		} while( e != v->anEdge );
+	}
+	assert( v->prev == vPrev && v->anEdge == NULL );
+
+	ePrev = eHead;
+	for( ePrev = eHead ; (e = ePrev->next) != eHead; ePrev = e) {
+		assert( e->Sym->next == ePrev->Sym );
+		assert( e->Sym != e );
+		assert( e->Sym->Sym == e );
+		assert( e->Org != NULL );
+		assert( e->Dst != NULL );
+		assert( e->Lnext->Onext->Sym == e );
+		assert( e->Onext->Sym->Lnext == e );
+	}
+	assert( e->Sym->next == ePrev->Sym
+		&& e->Sym == &mesh->eHeadSym
+		&& e->Sym->Sym == e
+		&& e->Org == NULL && e->Dst == NULL
+		&& e->Lface == NULL && e->Rface == NULL );
+}
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/mesh.h

@@ -0,0 +1,267 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#ifndef MESH_H
+#define MESH_H
+
+#include "tesselator.h"
+
+typedef struct TESSmesh TESSmesh;
+typedef struct TESSvertex TESSvertex;
+typedef struct TESSface TESSface;
+typedef struct TESShalfEdge TESShalfEdge;
+typedef struct ActiveRegion ActiveRegion;
+
+/* The mesh structure is similar in spirit, notation, and operations
+* to the "quad-edge" structure (see L. Guibas and J. Stolfi, Primitives
+* for the manipulation of general subdivisions and the computation of
+* Voronoi diagrams, ACM Transactions on Graphics, 4(2):74-123, April 1985).
+* For a simplified description, see the course notes for CS348a,
+* "Mathematical Foundations of Computer Graphics", available at the
+* Stanford bookstore (and taught during the fall quarter).
+* The implementation also borrows a tiny subset of the graph-based approach
+* use in Mantyla's Geometric Work Bench (see M. Mantyla, An Introduction
+* to Sold Modeling, Computer Science Press, Rockville, Maryland, 1988).
+*
+* The fundamental data structure is the "half-edge".  Two half-edges
+* go together to make an edge, but they point in opposite directions.
+* Each half-edge has a pointer to its mate (the "symmetric" half-edge Sym),
+* its origin vertex (Org), the face on its left side (Lface), and the
+* adjacent half-edges in the CCW direction around the origin vertex
+* (Onext) and around the left face (Lnext).  There is also a "next"
+* pointer for the global edge list (see below).
+*
+* The notation used for mesh navigation:
+*  Sym   = the mate of a half-edge (same edge, but opposite direction)
+*  Onext = edge CCW around origin vertex (keep same origin)
+*  Dnext = edge CCW around destination vertex (keep same dest)
+*  Lnext = edge CCW around left face (dest becomes new origin)
+*  Rnext = edge CCW around right face (origin becomes new dest)
+*
+* "prev" means to substitute CW for CCW in the definitions above.
+*
+* The mesh keeps global lists of all vertices, faces, and edges,
+* stored as doubly-linked circular lists with a dummy header node.
+* The mesh stores pointers to these dummy headers (vHead, fHead, eHead).
+*
+* The circular edge list is special; since half-edges always occur
+* in pairs (e and e->Sym), each half-edge stores a pointer in only
+* one direction.  Starting at eHead and following the e->next pointers
+* will visit each *edge* once (ie. e or e->Sym, but not both).
+* e->Sym stores a pointer in the opposite direction, thus it is
+* always true that e->Sym->next->Sym->next == e.
+*
+* Each vertex has a pointer to next and previous vertices in the
+* circular list, and a pointer to a half-edge with this vertex as
+* the origin (NULL if this is the dummy header).  There is also a
+* field "data" for client data.
+*
+* Each face has a pointer to the next and previous faces in the
+* circular list, and a pointer to a half-edge with this face as
+* the left face (NULL if this is the dummy header).  There is also
+* a field "data" for client data.
+*
+* Note that what we call a "face" is really a loop; faces may consist
+* of more than one loop (ie. not simply connected), but there is no
+* record of this in the data structure.  The mesh may consist of
+* several disconnected regions, so it may not be possible to visit
+* the entire mesh by starting at a half-edge and traversing the edge
+* structure.
+*
+* The mesh does NOT support isolated vertices; a vertex is deleted along
+* with its last edge.  Similarly when two faces are merged, one of the
+* faces is deleted (see tessMeshDelete below).  For mesh operations,
+* all face (loop) and vertex pointers must not be NULL.  However, once
+* mesh manipulation is finished, TESSmeshZapFace can be used to delete
+* faces of the mesh, one at a time.  All external faces can be "zapped"
+* before the mesh is returned to the client; then a NULL face indicates
+* a region which is not part of the output polygon.
+*/
+
+struct TESSvertex {
+	TESSvertex *next;      /* next vertex (never NULL) */
+	TESSvertex *prev;      /* previous vertex (never NULL) */
+	TESShalfEdge *anEdge;    /* a half-edge with this origin */
+
+	/* Internal data (keep hidden) */
+	TESSreal coords[3];  /* vertex location in 3D */
+	TESSreal s, t;       /* projection onto the sweep plane */
+	int pqHandle;   /* to allow deletion from priority queue */
+	TESSindex n;			/* to allow identify unique vertices */
+	TESSindex idx;			/* to allow map result to original verts */
+};
+
+struct TESSface {
+	TESSface *next;      /* next face (never NULL) */
+	TESSface *prev;      /* previous face (never NULL) */
+	TESShalfEdge *anEdge;    /* a half edge with this left face */
+
+	/* Internal data (keep hidden) */
+	TESSface *trail;     /* "stack" for conversion to strips */
+	TESSindex n;		/* to allow identiy unique faces */
+	char marked;     /* flag for conversion to strips */
+	char inside;     /* this face is in the polygon interior */
+};
+
+struct TESShalfEdge {
+	TESShalfEdge *next;      /* doubly-linked list (prev==Sym->next) */
+	TESShalfEdge *Sym;       /* same edge, opposite direction */
+	TESShalfEdge *Onext;     /* next edge CCW around origin */
+	TESShalfEdge *Lnext;     /* next edge CCW around left face */
+	TESSvertex *Org;       /* origin vertex (Overtex too long) */
+	TESSface *Lface;     /* left face */
+
+	/* Internal data (keep hidden) */
+	ActiveRegion *activeRegion;  /* a region with this upper edge (sweep.c) */
+	int winding;    /* change in winding number when crossing
+						  from the right face to the left face */
+};
+
+#define Rface   Sym->Lface
+#define Dst Sym->Org
+
+#define Oprev   Sym->Lnext
+#define Lprev   Onext->Sym
+#define Dprev   Lnext->Sym
+#define Rprev   Sym->Onext
+#define Dnext   Rprev->Sym  /* 3 pointers */
+#define Rnext   Oprev->Sym  /* 3 pointers */
+
+
+struct TESSmesh {
+	TESSvertex vHead;      /* dummy header for vertex list */
+	TESSface fHead;      /* dummy header for face list */
+	TESShalfEdge eHead;      /* dummy header for edge list */
+	TESShalfEdge eHeadSym;   /* and its symmetric counterpart */
+
+	struct BucketAlloc* edgeBucket;
+	struct BucketAlloc* vertexBucket;
+	struct BucketAlloc* faceBucket;
+};
+
+/* The mesh operations below have three motivations: completeness,
+* convenience, and efficiency.  The basic mesh operations are MakeEdge,
+* Splice, and Delete.  All the other edge operations can be implemented
+* in terms of these.  The other operations are provided for convenience
+* and/or efficiency.
+*
+* When a face is split or a vertex is added, they are inserted into the
+* global list *before* the existing vertex or face (ie. e->Org or e->Lface).
+* This makes it easier to process all vertices or faces in the global lists
+* without worrying about processing the same data twice.  As a convenience,
+* when a face is split, the "inside" flag is copied from the old face.
+* Other internal data (v->data, v->activeRegion, f->data, f->marked,
+* f->trail, e->winding) is set to zero.
+*
+* ********************** Basic Edge Operations **************************
+*
+* tessMeshMakeEdge( mesh ) creates one edge, two vertices, and a loop.
+* The loop (face) consists of the two new half-edges.
+*
+* tessMeshSplice( eOrg, eDst ) is the basic operation for changing the
+* mesh connectivity and topology.  It changes the mesh so that
+*  eOrg->Onext <- OLD( eDst->Onext )
+*  eDst->Onext <- OLD( eOrg->Onext )
+* where OLD(...) means the value before the meshSplice operation.
+*
+* This can have two effects on the vertex structure:
+*  - if eOrg->Org != eDst->Org, the two vertices are merged together
+*  - if eOrg->Org == eDst->Org, the origin is split into two vertices
+* In both cases, eDst->Org is changed and eOrg->Org is untouched.
+*
+* Similarly (and independently) for the face structure,
+*  - if eOrg->Lface == eDst->Lface, one loop is split into two
+*  - if eOrg->Lface != eDst->Lface, two distinct loops are joined into one
+* In both cases, eDst->Lface is changed and eOrg->Lface is unaffected.
+*
+* tessMeshDelete( eDel ) removes the edge eDel.  There are several cases:
+* if (eDel->Lface != eDel->Rface), we join two loops into one; the loop
+* eDel->Lface is deleted.  Otherwise, we are splitting one loop into two;
+* the newly created loop will contain eDel->Dst.  If the deletion of eDel
+* would create isolated vertices, those are deleted as well.
+*
+* ********************** Other Edge Operations **************************
+*
+* tessMeshAddEdgeVertex( eOrg ) creates a new edge eNew such that
+* eNew == eOrg->Lnext, and eNew->Dst is a newly created vertex.
+* eOrg and eNew will have the same left face.
+*
+* tessMeshSplitEdge( eOrg ) splits eOrg into two edges eOrg and eNew,
+* such that eNew == eOrg->Lnext.  The new vertex is eOrg->Dst == eNew->Org.
+* eOrg and eNew will have the same left face.
+*
+* tessMeshConnect( eOrg, eDst ) creates a new edge from eOrg->Dst
+* to eDst->Org, and returns the corresponding half-edge eNew.
+* If eOrg->Lface == eDst->Lface, this splits one loop into two,
+* and the newly created loop is eNew->Lface.  Otherwise, two disjoint
+* loops are merged into one, and the loop eDst->Lface is destroyed.
+*
+* ************************ Other Operations *****************************
+*
+* tessMeshNewMesh() creates a new mesh with no edges, no vertices,
+* and no loops (what we usually call a "face").
+*
+* tessMeshUnion( mesh1, mesh2 ) forms the union of all structures in
+* both meshes, and returns the new mesh (the old meshes are destroyed).
+*
+* tessMeshDeleteMesh( mesh ) will free all storage for any valid mesh.
+*
+* tessMeshZapFace( fZap ) destroys a face and removes it from the
+* global face list.  All edges of fZap will have a NULL pointer as their
+* left face.  Any edges which also have a NULL pointer as their right face
+* are deleted entirely (along with any isolated vertices this produces).
+* An entire mesh can be deleted by zapping its faces, one at a time,
+* in any order.  Zapped faces cannot be used in further mesh operations!
+*
+* tessMeshCheckMesh( mesh ) checks a mesh for self-consistency.
+*/
+
+TESShalfEdge *tessMeshMakeEdge( TESSmesh *mesh );
+int tessMeshSplice( TESSmesh *mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst );
+int tessMeshDelete( TESSmesh *mesh, TESShalfEdge *eDel );
+
+TESShalfEdge *tessMeshAddEdgeVertex( TESSmesh *mesh, TESShalfEdge *eOrg );
+TESShalfEdge *tessMeshSplitEdge( TESSmesh *mesh, TESShalfEdge *eOrg );
+TESShalfEdge *tessMeshConnect( TESSmesh *mesh, TESShalfEdge *eOrg, TESShalfEdge *eDst );
+
+TESSmesh *tessMeshNewMesh( TESSalloc* alloc );
+TESSmesh *tessMeshUnion( TESSalloc* alloc, TESSmesh *mesh1, TESSmesh *mesh2 );
+int tessMeshMergeConvexFaces( TESSmesh *mesh, int maxVertsPerFace );
+void tessMeshDeleteMesh( TESSalloc* alloc, TESSmesh *mesh );
+void tessMeshZapFace( TESSmesh *mesh, TESSface *fZap );
+
+#ifdef NDEBUG
+#define tessMeshCheckMesh( mesh )
+#else
+void tessMeshCheckMesh( TESSmesh *mesh );
+#endif
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/priorityq.c

@@ -0,0 +1,514 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+//#include "tesos.h"
+#include <stddef.h>
+#include <assert.h>
+#include "tesselator.h"
+#include "priorityq.h"
+
+
+#define INIT_SIZE	32
+
+#define TRUE 1
+#define FALSE 0
+
+#ifdef FOR_TRITE_TEST_PROGRAM
+#define LEQ(x,y)	(*pq->leq)(x,y)
+#else
+/* Violates modularity, but a little faster */
+#include "geom.h"
+#define LEQ(x,y)	VertLeq((TESSvertex *)x, (TESSvertex *)y)
+#endif
+
+
+/* Include all the code for the regular heap-based queue here. */
+
+/* The basic operations are insertion of a new key (pqInsert),
+* and examination/extraction of a key whose value is minimum
+* (pqMinimum/pqExtractMin).  Deletion is also allowed (pqDelete);
+* for this purpose pqInsert returns a "handle" which is supplied
+* as the argument.
+*
+* An initial heap may be created efficiently by calling pqInsert
+* repeatedly, then calling pqInit.  In any case pqInit must be called
+* before any operations other than pqInsert are used.
+*
+* If the heap is empty, pqMinimum/pqExtractMin will return a NULL key.
+* This may also be tested with pqIsEmpty.
+*/
+
+
+/* Since we support deletion the data structure is a little more
+* complicated than an ordinary heap.  "nodes" is the heap itself;
+* active nodes are stored in the range 1..pq->size.  When the
+* heap exceeds its allocated size (pq->max), its size doubles.
+* The children of node i are nodes 2i and 2i+1.
+*
+* Each node stores an index into an array "handles".  Each handle
+* stores a key, plus a pointer back to the node which currently
+* represents that key (ie. nodes[handles[i].node].handle == i).
+*/
+
+
+#define pqHeapMinimum(pq)	((pq)->handles[(pq)->nodes[1].handle].key)
+#define pqHeapIsEmpty(pq)	((pq)->size == 0)
+
+
+
+/* really pqHeapNewPriorityQHeap */
+PriorityQHeap *pqHeapNewPriorityQ( TESSalloc* alloc, int size, int (*leq)(PQkey key1, PQkey key2) )
+{
+	PriorityQHeap *pq = (PriorityQHeap *)alloc->memalloc( alloc->userData, sizeof( PriorityQHeap ));
+	if (pq == NULL) return NULL;
+
+	pq->size = 0;
+	pq->max = size;
+	pq->nodes = (PQnode *)alloc->memalloc( alloc->userData, (size + 1) * sizeof(pq->nodes[0]) );
+	if (pq->nodes == NULL) {
+		alloc->memfree( alloc->userData, pq );
+		return NULL;
+	}
+
+	pq->handles = (PQhandleElem *)alloc->memalloc( alloc->userData, (size + 1) * sizeof(pq->handles[0]) );
+	if (pq->handles == NULL) {
+		alloc->memfree( alloc->userData, pq->nodes );
+		alloc->memfree( alloc->userData, pq );
+		return NULL;
+	}
+
+	pq->initialized = FALSE;
+	pq->freeList = 0;
+	pq->leq = leq;
+
+	pq->nodes[1].handle = 1;	/* so that Minimum() returns NULL */
+	pq->handles[1].key = NULL;
+	return pq;
+}
+
+/* really pqHeapDeletePriorityQHeap */
+void pqHeapDeletePriorityQ( TESSalloc* alloc, PriorityQHeap *pq )
+{
+	alloc->memfree( alloc->userData, pq->handles );
+	alloc->memfree( alloc->userData, pq->nodes );
+	alloc->memfree( alloc->userData, pq );
+}
+
+
+static void FloatDown( PriorityQHeap *pq, int curr )
+{
+	PQnode *n = pq->nodes;
+	PQhandleElem *h = pq->handles;
+	PQhandle hCurr, hChild;
+	int child;
+
+	hCurr = n[curr].handle;
+	for( ;; ) {
+		child = curr << 1;
+		if( child < pq->size && LEQ( h[n[child+1].handle].key,
+			h[n[child].handle].key )) {
+				++child;
+		}
+
+		assert(child <= pq->max);
+
+		hChild = n[child].handle;
+		if( child > pq->size || LEQ( h[hCurr].key, h[hChild].key )) {
+			n[curr].handle = hCurr;
+			h[hCurr].node = curr;
+			break;
+		}
+		n[curr].handle = hChild;
+		h[hChild].node = curr;
+		curr = child;
+	}
+}
+
+
+static void FloatUp( PriorityQHeap *pq, int curr )
+{
+	PQnode *n = pq->nodes;
+	PQhandleElem *h = pq->handles;
+	PQhandle hCurr, hParent;
+	int parent;
+
+	hCurr = n[curr].handle;
+	for( ;; ) {
+		parent = curr >> 1;
+		hParent = n[parent].handle;
+		if( parent == 0 || LEQ( h[hParent].key, h[hCurr].key )) {
+			n[curr].handle = hCurr;
+			h[hCurr].node = curr;
+			break;
+		}
+		n[curr].handle = hParent;
+		h[hParent].node = curr;
+		curr = parent;
+	}
+}
+
+/* really pqHeapInit */
+void pqHeapInit( PriorityQHeap *pq )
+{
+	int i;
+
+	/* This method of building a heap is O(n), rather than O(n lg n). */
+
+	for( i = pq->size; i >= 1; --i ) {
+		FloatDown( pq, i );
+	}
+	pq->initialized = TRUE;
+}
+
+/* really pqHeapInsert */
+/* returns INV_HANDLE iff out of memory */
+PQhandle pqHeapInsert( TESSalloc* alloc, PriorityQHeap *pq, PQkey keyNew )
+{
+	int curr;
+	PQhandle free;
+
+	curr = ++ pq->size;
+	if( (curr*2) > pq->max ) {
+		if (!alloc->memrealloc)
+		{
+			return INV_HANDLE;
+		}
+		else
+		{
+			PQnode *saveNodes= pq->nodes;
+			PQhandleElem *saveHandles= pq->handles;
+
+			// If the heap overflows, double its size.
+			pq->max <<= 1;
+			pq->nodes = (PQnode *)alloc->memrealloc( alloc->userData, pq->nodes,
+				(size_t)((pq->max + 1) * sizeof( pq->nodes[0] )));
+			if (pq->nodes == NULL) {
+				pq->nodes = saveNodes;	// restore ptr to free upon return
+				return INV_HANDLE;
+			}
+			pq->handles = (PQhandleElem *)alloc->memrealloc( alloc->userData, pq->handles,
+				(size_t) ((pq->max + 1) * sizeof( pq->handles[0] )));
+			if (pq->handles == NULL) {
+				pq->handles = saveHandles; // restore ptr to free upon return
+				return INV_HANDLE;
+			}
+		}
+	}
+
+	if( pq->freeList == 0 ) {
+		free = curr;
+	} else {
+		free = pq->freeList;
+		pq->freeList = pq->handles[free].node;
+	}
+
+	pq->nodes[curr].handle = free;
+	pq->handles[free].node = curr;
+	pq->handles[free].key = keyNew;
+
+	if( pq->initialized ) {
+		FloatUp( pq, curr );
+	}
+	assert(free != INV_HANDLE);
+	return free;
+}
+
+/* really pqHeapExtractMin */
+PQkey pqHeapExtractMin( PriorityQHeap *pq )
+{
+	PQnode *n = pq->nodes;
+	PQhandleElem *h = pq->handles;
+	PQhandle hMin = n[1].handle;
+	PQkey min = h[hMin].key;
+
+	if( pq->size > 0 ) {
+		n[1].handle = n[pq->size].handle;
+		h[n[1].handle].node = 1;
+
+		h[hMin].key = NULL;
+		h[hMin].node = pq->freeList;
+		pq->freeList = hMin;
+
+		if( -- pq->size > 0 ) {
+			FloatDown( pq, 1 );
+		}
+	}
+	return min;
+}
+
+/* really pqHeapDelete */
+void pqHeapDelete( PriorityQHeap *pq, PQhandle hCurr )
+{
+	PQnode *n = pq->nodes;
+	PQhandleElem *h = pq->handles;
+	int curr;
+
+	assert( hCurr >= 1 && hCurr <= pq->max && h[hCurr].key != NULL );
+
+	curr = h[hCurr].node;
+	n[curr].handle = n[pq->size].handle;
+	h[n[curr].handle].node = curr;
+
+	if( curr <= -- pq->size ) {
+		if( curr <= 1 || LEQ( h[n[curr>>1].handle].key, h[n[curr].handle].key )) {
+			FloatDown( pq, curr );
+		} else {
+			FloatUp( pq, curr );
+		}
+	}
+	h[hCurr].key = NULL;
+	h[hCurr].node = pq->freeList;
+	pq->freeList = hCurr;
+}
+
+
+
+/* Now redefine all the function names to map to their "Sort" versions. */
+
+/* really tessPqSortNewPriorityQ */
+PriorityQ *pqNewPriorityQ( TESSalloc* alloc, int size, int (*leq)(PQkey key1, PQkey key2) )
+{
+	PriorityQ *pq = (PriorityQ *)alloc->memalloc( alloc->userData, sizeof( PriorityQ ));
+	if (pq == NULL) return NULL;
+
+	pq->heap = pqHeapNewPriorityQ( alloc, size, leq );
+	if (pq->heap == NULL) {
+		alloc->memfree( alloc->userData, pq );
+		return NULL;
+	}
+
+//	pq->keys = (PQkey *)memAlloc( INIT_SIZE * sizeof(pq->keys[0]) );
+	pq->keys = (PQkey *)alloc->memalloc( alloc->userData, size * sizeof(pq->keys[0]) );
+	if (pq->keys == NULL) {
+		pqHeapDeletePriorityQ( alloc, pq->heap );
+		alloc->memfree( alloc->userData, pq );
+		return NULL;
+	}
+
+	pq->size = 0;
+	pq->max = size; //INIT_SIZE;
+	pq->initialized = FALSE;
+	pq->leq = leq;
+
+	return pq;
+}
+
+/* really tessPqSortDeletePriorityQ */
+void pqDeletePriorityQ( TESSalloc* alloc, PriorityQ *pq )
+{
+	assert(pq != NULL);
+	if (pq->heap != NULL) pqHeapDeletePriorityQ( alloc, pq->heap );
+	if (pq->order != NULL) alloc->memfree( alloc->userData, pq->order );
+	if (pq->keys != NULL) alloc->memfree( alloc->userData, pq->keys );
+	alloc->memfree( alloc->userData, pq );
+}
+
+
+#define LT(x,y)     (! LEQ(y,x))
+#define GT(x,y)     (! LEQ(x,y))
+#define Swap(a,b)   if(1){PQkey *tmp = *a; *a = *b; *b = tmp;}else
+
+/* really tessPqSortInit */
+int pqInit( TESSalloc* alloc, PriorityQ *pq )
+{
+	PQkey **p, **r, **i, **j, *piv;
+	struct { PQkey **p, **r; } Stack[50], *top = Stack;
+	unsigned int seed = 2016473283;
+
+	/* Create an array of indirect pointers to the keys, so that we
+	* the handles we have returned are still valid.
+	*/
+	/*
+	pq->order = (PQkey **)memAlloc( (size_t)
+	(pq->size * sizeof(pq->order[0])) );
+	*/
+	pq->order = (PQkey **)alloc->memalloc( alloc->userData,
+										  (size_t)((pq->size+1) * sizeof(pq->order[0])) );
+	/* the previous line is a patch to compensate for the fact that IBM */
+	/* machines return a null on a malloc of zero bytes (unlike SGI),   */
+	/* so we have to put in this defense to guard against a memory      */
+	/* fault four lines down. from [email protected].               */
+	if (pq->order == NULL) return 0;
+
+	p = pq->order;
+	r = p + pq->size - 1;
+	for( piv = pq->keys, i = p; i <= r; ++piv, ++i ) {
+		*i = piv;
+	}
+
+	/* Sort the indirect pointers in descending order,
+	* using randomized Quicksort
+	*/
+	top->p = p; top->r = r; ++top;
+	while( --top >= Stack ) {
+		p = top->p;
+		r = top->r;
+		while( r > p + 10 ) {
+			seed = seed * 1539415821 + 1;
+			i = p + seed % (r - p + 1);
+			piv = *i;
+			*i = *p;
+			*p = piv;
+			i = p - 1;
+			j = r + 1;
+			do {
+				do { ++i; } while( GT( **i, *piv ));
+				do { --j; } while( LT( **j, *piv ));
+				Swap( i, j );
+			} while( i < j );
+			Swap( i, j ); /* Undo last swap */
+			if( i - p < r - j ) {
+				top->p = j+1; top->r = r; ++top;
+				r = i-1;
+			} else {
+				top->p = p; top->r = i-1; ++top;
+				p = j+1;
+			}
+		}
+		/* Insertion sort small lists */
+		for( i = p+1; i <= r; ++i ) {
+			piv = *i;
+			for( j = i; j > p && LT( **(j-1), *piv ); --j ) {
+				*j = *(j-1);
+			}
+			*j = piv;
+		}
+	}
+	pq->max = pq->size;
+	pq->initialized = TRUE;
+	pqHeapInit( pq->heap );  /* always succeeds */
+
+#ifndef NDEBUG
+	p = pq->order;
+	r = p + pq->size - 1;
+	for( i = p; i < r; ++i ) {
+		assert( LEQ( **(i+1), **i ));
+	}
+#endif
+
+	return 1;
+}
+
+/* really tessPqSortInsert */
+/* returns INV_HANDLE iff out of memory */
+PQhandle pqInsert( TESSalloc* alloc, PriorityQ *pq, PQkey keyNew )
+{
+	int curr;
+
+	if( pq->initialized ) {
+		return pqHeapInsert( alloc, pq->heap, keyNew );
+	}
+	curr = pq->size;
+	if( ++ pq->size >= pq->max ) {
+		if (!alloc->memrealloc)
+		{
+			return INV_HANDLE;
+		}
+		else
+		{
+			PQkey *saveKey= pq->keys;
+			// If the heap overflows, double its size.
+			pq->max <<= 1;
+			pq->keys = (PQkey *)alloc->memrealloc( alloc->userData, pq->keys,
+				(size_t)(pq->max * sizeof( pq->keys[0] )));
+			if (pq->keys == NULL) {
+				pq->keys = saveKey;  // restore ptr to free upon return
+				return INV_HANDLE;
+			}
+		}
+	}
+	assert(curr != INV_HANDLE);
+	pq->keys[curr] = keyNew;
+
+	/* Negative handles index the sorted array. */
+	return -(curr+1);
+}
+
+/* really tessPqSortExtractMin */
+PQkey pqExtractMin( PriorityQ *pq )
+{
+	PQkey sortMin, heapMin;
+
+	if( pq->size == 0 ) {
+		return pqHeapExtractMin( pq->heap );
+	}
+	sortMin = *(pq->order[pq->size-1]);
+	if( ! pqHeapIsEmpty( pq->heap )) {
+		heapMin = pqHeapMinimum( pq->heap );
+		if( LEQ( heapMin, sortMin )) {
+			return pqHeapExtractMin( pq->heap );
+		}
+	}
+	do {
+		-- pq->size;
+	} while( pq->size > 0 && *(pq->order[pq->size-1]) == NULL );
+	return sortMin;
+}
+
+/* really tessPqSortMinimum */
+PQkey pqMinimum( PriorityQ *pq )
+{
+	PQkey sortMin, heapMin;
+
+	if( pq->size == 0 ) {
+		return pqHeapMinimum( pq->heap );
+	}
+	sortMin = *(pq->order[pq->size-1]);
+	if( ! pqHeapIsEmpty( pq->heap )) {
+		heapMin = pqHeapMinimum( pq->heap );
+		if( LEQ( heapMin, sortMin )) {
+			return heapMin;
+		}
+	}
+	return sortMin;
+}
+
+/* really tessPqSortIsEmpty */
+int pqIsEmpty( PriorityQ *pq )
+{
+	return (pq->size == 0) && pqHeapIsEmpty( pq->heap );
+}
+
+/* really tessPqSortDelete */
+void pqDelete( PriorityQ *pq, PQhandle curr )
+{
+	if( curr >= 0 ) {
+		pqHeapDelete( pq->heap, curr );
+		return;
+	}
+	curr = -(curr+1);
+	assert( curr < pq->max && pq->keys[curr] != NULL );
+
+	pq->keys[curr] = NULL;
+	while( pq->size > 0 && *(pq->order[pq->size-1]) == NULL ) {
+		-- pq->size;
+	}
+}

polygon.mod/earcut/test/comparison/libtess2/priorityq.h

@@ -0,0 +1,104 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#ifndef PRIORITYQ_H
+#define PRIORITYQ_H
+
+/* The basic operations are insertion of a new key (pqInsert),
+* and examination/extraction of a key whose value is minimum
+* (pqMinimum/pqExtractMin).  Deletion is also allowed (pqDelete);
+* for this purpose pqInsert returns a "handle" which is supplied
+* as the argument.
+*
+* An initial heap may be created efficiently by calling pqInsert
+* repeatedly, then calling pqInit.  In any case pqInit must be called
+* before any operations other than pqInsert are used.
+*
+* If the heap is empty, pqMinimum/pqExtractMin will return a NULL key.
+* This may also be tested with pqIsEmpty.
+*/
+
+/* Since we support deletion the data structure is a little more
+* complicated than an ordinary heap.  "nodes" is the heap itself;
+* active nodes are stored in the range 1..pq->size.  When the
+* heap exceeds its allocated size (pq->max), its size doubles.
+* The children of node i are nodes 2i and 2i+1.
+*
+* Each node stores an index into an array "handles".  Each handle
+* stores a key, plus a pointer back to the node which currently
+* represents that key (ie. nodes[handles[i].node].handle == i).
+*/
+
+typedef void *PQkey;
+typedef int PQhandle;
+typedef struct PriorityQHeap PriorityQHeap;
+
+#define INV_HANDLE 0x0fffffff
+
+typedef struct { PQhandle handle; } PQnode;
+typedef struct { PQkey key; PQhandle node; } PQhandleElem;
+
+struct PriorityQHeap {
+
+	PQnode *nodes;
+	PQhandleElem *handles;
+	int size, max;
+	PQhandle freeList;
+	int initialized;
+
+	int (*leq)(PQkey key1, PQkey key2);
+};
+
+typedef struct PriorityQ PriorityQ;
+
+struct PriorityQ {
+	PriorityQHeap *heap;
+
+	PQkey *keys;
+	PQkey **order;
+	PQhandle size, max;
+	int initialized;
+
+	int (*leq)(PQkey key1, PQkey key2);
+};
+
+PriorityQ *pqNewPriorityQ( TESSalloc* alloc, int size, int (*leq)(PQkey key1, PQkey key2) );
+void pqDeletePriorityQ( TESSalloc* alloc, PriorityQ *pq );
+
+int pqInit( TESSalloc* alloc, PriorityQ *pq );
+PQhandle pqInsert( TESSalloc* alloc, PriorityQ *pq, PQkey key );
+PQkey pqExtractMin( PriorityQ *pq );
+void pqDelete( PriorityQ *pq, PQhandle handle );
+
+PQkey pqMinimum( PriorityQ *pq );
+int pqIsEmpty( PriorityQ *pq );
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/sweep.c

@@ -0,0 +1,1326 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#include <assert.h>
+#include <stddef.h>
+#include <setjmp.h>		/* longjmp */
+
+#include "mesh.h"
+#include "geom.h"
+#include "tess.h"
+#include "dict.h"
+#include "priorityq.h"
+#include "bucketalloc.h"
+#include "sweep.h"
+
+#define TRUE 1
+#define FALSE 0
+
+#ifdef FOR_TRITE_TEST_PROGRAM
+extern void DebugEvent( TESStesselator *tess );
+#else
+#define DebugEvent( tess )
+#endif
+
+/*
+* Invariants for the Edge Dictionary.
+* - each pair of adjacent edges e2=Succ(e1) satisfies EdgeLeq(e1,e2)
+*   at any valid location of the sweep event
+* - if EdgeLeq(e2,e1) as well (at any valid sweep event), then e1 and e2
+*   share a common endpoint
+* - for each e, e->Dst has been processed, but not e->Org
+* - each edge e satisfies VertLeq(e->Dst,event) && VertLeq(event,e->Org)
+*   where "event" is the current sweep line event.
+* - no edge e has zero length
+*
+* Invariants for the Mesh (the processed portion).
+* - the portion of the mesh left of the sweep line is a planar graph,
+*   ie. there is *some* way to embed it in the plane
+* - no processed edge has zero length
+* - no two processed vertices have identical coordinates
+* - each "inside" region is monotone, ie. can be broken into two chains
+*   of monotonically increasing vertices according to VertLeq(v1,v2)
+*   - a non-invariant: these chains may intersect (very slightly)
+*
+* Invariants for the Sweep.
+* - if none of the edges incident to the event vertex have an activeRegion
+*   (ie. none of these edges are in the edge dictionary), then the vertex
+*   has only right-going edges.
+* - if an edge is marked "fixUpperEdge" (it is a temporary edge introduced
+*   by ConnectRightVertex), then it is the only right-going edge from
+*   its associated vertex.  (This says that these edges exist only
+*   when it is necessary.)
+*/
+
+#define MAX(x,y)	((x) >= (y) ? (x) : (y))
+#define MIN(x,y)	((x) <= (y) ? (x) : (y))
+
+/* When we merge two edges into one, we need to compute the combined
+* winding of the new edge.
+*/
+#define AddWinding(eDst,eSrc)	(eDst->winding += eSrc->winding, \
+	eDst->Sym->winding += eSrc->Sym->winding)
+
+static void SweepEvent( TESStesselator *tess, TESSvertex *vEvent );
+static void WalkDirtyRegions( TESStesselator *tess, ActiveRegion *regUp );
+static int CheckForRightSplice( TESStesselator *tess, ActiveRegion *regUp );
+
+static int EdgeLeq( TESStesselator *tess, ActiveRegion *reg1, ActiveRegion *reg2 )
+/*
+* Both edges must be directed from right to left (this is the canonical
+* direction for the upper edge of each region).
+*
+* The strategy is to evaluate a "t" value for each edge at the
+* current sweep line position, given by tess->event.  The calculations
+* are designed to be very stable, but of course they are not perfect.
+*
+* Special case: if both edge destinations are at the sweep event,
+* we sort the edges by slope (they would otherwise compare equally).
+*/
+{
+	TESSvertex *event = tess->event;
+	TESShalfEdge *e1, *e2;
+	TESSreal t1, t2;
+
+	e1 = reg1->eUp;
+	e2 = reg2->eUp;
+
+	if( e1->Dst == event ) {
+		if( e2->Dst == event ) {
+			/* Two edges right of the sweep line which meet at the sweep event.
+			* Sort them by slope.
+			*/
+			if( VertLeq( e1->Org, e2->Org )) {
+				return EdgeSign( e2->Dst, e1->Org, e2->Org ) <= 0;
+			}
+			return EdgeSign( e1->Dst, e2->Org, e1->Org ) >= 0;
+		}
+		return EdgeSign( e2->Dst, event, e2->Org ) <= 0;
+	}
+	if( e2->Dst == event ) {
+		return EdgeSign( e1->Dst, event, e1->Org ) >= 0;
+	}
+
+	/* General case - compute signed distance *from* e1, e2 to event */
+	t1 = EdgeEval( e1->Dst, event, e1->Org );
+	t2 = EdgeEval( e2->Dst, event, e2->Org );
+	return (t1 >= t2);
+}
+
+
+static void DeleteRegion( TESStesselator *tess, ActiveRegion *reg )
+{
+	if( reg->fixUpperEdge ) {
+		/* It was created with zero winding number, so it better be
+		* deleted with zero winding number (ie. it better not get merged
+		* with a real edge).
+		*/
+		assert( reg->eUp->winding == 0 );
+	}
+	reg->eUp->activeRegion = NULL;
+	dictDelete( tess->dict, reg->nodeUp );
+	bucketFree( tess->regionPool, reg );
+}
+
+
+static int FixUpperEdge( TESStesselator *tess, ActiveRegion *reg, TESShalfEdge *newEdge )
+/*
+* Replace an upper edge which needs fixing (see ConnectRightVertex).
+*/
+{
+	assert( reg->fixUpperEdge );
+	if ( !tessMeshDelete( tess->mesh, reg->eUp ) ) return 0;
+	reg->fixUpperEdge = FALSE;
+	reg->eUp = newEdge;
+	newEdge->activeRegion = reg;
+
+	return 1;
+}
+
+static ActiveRegion *TopLeftRegion( TESStesselator *tess, ActiveRegion *reg )
+{
+	TESSvertex *org = reg->eUp->Org;
+	TESShalfEdge *e;
+
+	/* Find the region above the uppermost edge with the same origin */
+	do {
+		reg = RegionAbove( reg );
+	} while( reg->eUp->Org == org );
+
+	/* If the edge above was a temporary edge introduced by ConnectRightVertex,
+	* now is the time to fix it.
+	*/
+	if( reg->fixUpperEdge ) {
+		e = tessMeshConnect( tess->mesh, RegionBelow(reg)->eUp->Sym, reg->eUp->Lnext );
+		if (e == NULL) return NULL;
+		if ( !FixUpperEdge( tess, reg, e ) ) return NULL;
+		reg = RegionAbove( reg );
+	}
+	return reg;
+}
+
+static ActiveRegion *TopRightRegion( ActiveRegion *reg )
+{
+	TESSvertex *dst = reg->eUp->Dst;
+
+	/* Find the region above the uppermost edge with the same destination */
+	do {
+		reg = RegionAbove( reg );
+	} while( reg->eUp->Dst == dst );
+	return reg;
+}
+
+static ActiveRegion *AddRegionBelow( TESStesselator *tess,
+									ActiveRegion *regAbove,
+									TESShalfEdge *eNewUp )
+/*
+* Add a new active region to the sweep line, *somewhere* below "regAbove"
+* (according to where the new edge belongs in the sweep-line dictionary).
+* The upper edge of the new region will be "eNewUp".
+* Winding number and "inside" flag are not updated.
+*/
+{
+	ActiveRegion *regNew = (ActiveRegion *)bucketAlloc( tess->regionPool );
+	if (regNew == NULL) longjmp(tess->env,1);
+
+	regNew->eUp = eNewUp;
+	regNew->nodeUp = dictInsertBefore( tess->dict, regAbove->nodeUp, regNew );
+	if (regNew->nodeUp == NULL) longjmp(tess->env,1);
+	regNew->fixUpperEdge = FALSE;
+	regNew->sentinel = FALSE;
+	regNew->dirty = FALSE;
+
+	eNewUp->activeRegion = regNew;
+	return regNew;
+}
+
+static int IsWindingInside( TESStesselator *tess, int n )
+{
+	switch( tess->windingRule ) {
+		case TESS_WINDING_ODD:
+			return (n & 1);
+		case TESS_WINDING_NONZERO:
+			return (n != 0);
+		case TESS_WINDING_POSITIVE:
+			return (n > 0);
+		case TESS_WINDING_NEGATIVE:
+			return (n < 0);
+		case TESS_WINDING_ABS_GEQ_TWO:
+			return (n >= 2) || (n <= -2);
+	}
+	/*LINTED*/
+	assert( FALSE );
+	/*NOTREACHED*/
+
+	return( FALSE );
+}
+
+
+static void ComputeWinding( TESStesselator *tess, ActiveRegion *reg )
+{
+	reg->windingNumber = RegionAbove(reg)->windingNumber + reg->eUp->winding;
+	reg->inside = IsWindingInside( tess, reg->windingNumber );
+}
+
+
+static void FinishRegion( TESStesselator *tess, ActiveRegion *reg )
+/*
+* Delete a region from the sweep line.  This happens when the upper
+* and lower chains of a region meet (at a vertex on the sweep line).
+* The "inside" flag is copied to the appropriate mesh face (we could
+* not do this before -- since the structure of the mesh is always
+* changing, this face may not have even existed until now).
+*/
+{
+	TESShalfEdge *e = reg->eUp;
+	TESSface *f = e->Lface;
+
+	f->inside = reg->inside;
+	f->anEdge = e;   /* optimization for tessMeshTessellateMonoRegion() */
+	DeleteRegion( tess, reg );
+}
+
+
+static TESShalfEdge *FinishLeftRegions( TESStesselator *tess,
+									  ActiveRegion *regFirst, ActiveRegion *regLast )
+/*
+* We are given a vertex with one or more left-going edges.  All affected
+* edges should be in the edge dictionary.  Starting at regFirst->eUp,
+* we walk down deleting all regions where both edges have the same
+* origin vOrg.  At the same time we copy the "inside" flag from the
+* active region to the face, since at this point each face will belong
+* to at most one region (this was not necessarily true until this point
+* in the sweep).  The walk stops at the region above regLast; if regLast
+* is NULL we walk as far as possible.  At the same time we relink the
+* mesh if necessary, so that the ordering of edges around vOrg is the
+* same as in the dictionary.
+*/
+{
+	ActiveRegion *reg, *regPrev;
+	TESShalfEdge *e, *ePrev;
+
+	regPrev = regFirst;
+	ePrev = regFirst->eUp;
+	while( regPrev != regLast ) {
+		regPrev->fixUpperEdge = FALSE;	/* placement was OK */
+		reg = RegionBelow( regPrev );
+		e = reg->eUp;
+		if( e->Org != ePrev->Org ) {
+			if( ! reg->fixUpperEdge ) {
+				/* Remove the last left-going edge.  Even though there are no further
+				* edges in the dictionary with this origin, there may be further
+				* such edges in the mesh (if we are adding left edges to a vertex
+				* that has already been processed).  Thus it is important to call
+				* FinishRegion rather than just DeleteRegion.
+				*/
+				FinishRegion( tess, regPrev );
+				break;
+			}
+			/* If the edge below was a temporary edge introduced by
+			* ConnectRightVertex, now is the time to fix it.
+			*/
+			e = tessMeshConnect( tess->mesh, ePrev->Lprev, e->Sym );
+			if (e == NULL) longjmp(tess->env,1);
+			if ( !FixUpperEdge( tess, reg, e ) ) longjmp(tess->env,1);
+		}
+
+		/* Relink edges so that ePrev->Onext == e */
+		if( ePrev->Onext != e ) {
+			if ( !tessMeshSplice( tess->mesh, e->Oprev, e ) ) longjmp(tess->env,1);
+			if ( !tessMeshSplice( tess->mesh, ePrev, e ) ) longjmp(tess->env,1);
+		}
+		FinishRegion( tess, regPrev );	/* may change reg->eUp */
+		ePrev = reg->eUp;
+		regPrev = reg;
+	}
+	return ePrev;
+}
+
+
+static void AddRightEdges( TESStesselator *tess, ActiveRegion *regUp,
+						  TESShalfEdge *eFirst, TESShalfEdge *eLast, TESShalfEdge *eTopLeft,
+						  int cleanUp )
+/*
+* Purpose: insert right-going edges into the edge dictionary, and update
+* winding numbers and mesh connectivity appropriately.  All right-going
+* edges share a common origin vOrg.  Edges are inserted CCW starting at
+* eFirst; the last edge inserted is eLast->Oprev.  If vOrg has any
+* left-going edges already processed, then eTopLeft must be the edge
+* such that an imaginary upward vertical segment from vOrg would be
+* contained between eTopLeft->Oprev and eTopLeft; otherwise eTopLeft
+* should be NULL.
+*/
+{
+	ActiveRegion *reg, *regPrev;
+	TESShalfEdge *e, *ePrev;
+	int firstTime = TRUE;
+
+	/* Insert the new right-going edges in the dictionary */
+	e = eFirst;
+	do {
+		assert( VertLeq( e->Org, e->Dst ));
+		AddRegionBelow( tess, regUp, e->Sym );
+		e = e->Onext;
+	} while ( e != eLast );
+
+	/* Walk *all* right-going edges from e->Org, in the dictionary order,
+	* updating the winding numbers of each region, and re-linking the mesh
+	* edges to match the dictionary ordering (if necessary).
+	*/
+	if( eTopLeft == NULL ) {
+		eTopLeft = RegionBelow( regUp )->eUp->Rprev;
+	}
+	regPrev = regUp;
+	ePrev = eTopLeft;
+	for( ;; ) {
+		reg = RegionBelow( regPrev );
+		e = reg->eUp->Sym;
+		if( e->Org != ePrev->Org ) break;
+
+		if( e->Onext != ePrev ) {
+			/* Unlink e from its current position, and relink below ePrev */
+			if ( !tessMeshSplice( tess->mesh, e->Oprev, e ) ) longjmp(tess->env,1);
+			if ( !tessMeshSplice( tess->mesh, ePrev->Oprev, e ) ) longjmp(tess->env,1);
+		}
+		/* Compute the winding number and "inside" flag for the new regions */
+		reg->windingNumber = regPrev->windingNumber - e->winding;
+		reg->inside = IsWindingInside( tess, reg->windingNumber );
+
+		/* Check for two outgoing edges with same slope -- process these
+		* before any intersection tests (see example in tessComputeInterior).
+		*/
+		regPrev->dirty = TRUE;
+		if( ! firstTime && CheckForRightSplice( tess, regPrev )) {
+			AddWinding( e, ePrev );
+			DeleteRegion( tess, regPrev );
+			if ( !tessMeshDelete( tess->mesh, ePrev ) ) longjmp(tess->env,1);
+		}
+		firstTime = FALSE;
+		regPrev = reg;
+		ePrev = e;
+	}
+	regPrev->dirty = TRUE;
+	assert( regPrev->windingNumber - e->winding == reg->windingNumber );
+
+	if( cleanUp ) {
+		/* Check for intersections between newly adjacent edges. */
+		WalkDirtyRegions( tess, regPrev );
+	}
+}
+
+
+static void SpliceMergeVertices( TESStesselator *tess, TESShalfEdge *e1,
+								TESShalfEdge *e2 )
+/*
+* Two vertices with idential coordinates are combined into one.
+* e1->Org is kept, while e2->Org is discarded.
+*/
+{
+	if ( !tessMeshSplice( tess->mesh, e1, e2 ) ) longjmp(tess->env,1);
+}
+
+static void VertexWeights( TESSvertex *isect, TESSvertex *org, TESSvertex *dst,
+						  TESSreal *weights )
+/*
+* Find some weights which describe how the intersection vertex is
+* a linear combination of "org" and "dest".  Each of the two edges
+* which generated "isect" is allocated 50% of the weight; each edge
+* splits the weight between its org and dst according to the
+* relative distance to "isect".
+*/
+{
+	TESSreal t1 = VertL1dist( org, isect );
+	TESSreal t2 = VertL1dist( dst, isect );
+
+	weights[0] = (TESSreal)0.5 * t2 / (t1 + t2);
+	weights[1] = (TESSreal)0.5 * t1 / (t1 + t2);
+	isect->coords[0] += weights[0]*org->coords[0] + weights[1]*dst->coords[0];
+	isect->coords[1] += weights[0]*org->coords[1] + weights[1]*dst->coords[1];
+	isect->coords[2] += weights[0]*org->coords[2] + weights[1]*dst->coords[2];
+}
+
+
+static void GetIntersectData( TESStesselator *tess, TESSvertex *isect,
+							 TESSvertex *orgUp, TESSvertex *dstUp,
+							 TESSvertex *orgLo, TESSvertex *dstLo )
+ /*
+ * We've computed a new intersection point, now we need a "data" pointer
+ * from the user so that we can refer to this new vertex in the
+ * rendering callbacks.
+ */
+{
+	TESSreal weights[4];
+	TESS_NOTUSED( tess );
+
+	isect->coords[0] = isect->coords[1] = isect->coords[2] = 0;
+	isect->idx = TESS_UNDEF;
+	VertexWeights( isect, orgUp, dstUp, &weights[0] );
+	VertexWeights( isect, orgLo, dstLo, &weights[2] );
+}
+
+static int CheckForRightSplice( TESStesselator *tess, ActiveRegion *regUp )
+/*
+* Check the upper and lower edge of "regUp", to make sure that the
+* eUp->Org is above eLo, or eLo->Org is below eUp (depending on which
+* origin is leftmost).
+*
+* The main purpose is to splice right-going edges with the same
+* dest vertex and nearly identical slopes (ie. we can't distinguish
+* the slopes numerically).  However the splicing can also help us
+* to recover from numerical errors.  For example, suppose at one
+* point we checked eUp and eLo, and decided that eUp->Org is barely
+* above eLo.  Then later, we split eLo into two edges (eg. from
+* a splice operation like this one).  This can change the result of
+* our test so that now eUp->Org is incident to eLo, or barely below it.
+* We must correct this condition to maintain the dictionary invariants.
+*
+* One possibility is to check these edges for intersection again
+* (ie. CheckForIntersect).  This is what we do if possible.  However
+* CheckForIntersect requires that tess->event lies between eUp and eLo,
+* so that it has something to fall back on when the intersection
+* calculation gives us an unusable answer.  So, for those cases where
+* we can't check for intersection, this routine fixes the problem
+* by just splicing the offending vertex into the other edge.
+* This is a guaranteed solution, no matter how degenerate things get.
+* Basically this is a combinatorial solution to a numerical problem.
+*/
+{
+	ActiveRegion *regLo = RegionBelow(regUp);
+	TESShalfEdge *eUp = regUp->eUp;
+	TESShalfEdge *eLo = regLo->eUp;
+
+	if( VertLeq( eUp->Org, eLo->Org )) {
+		if( EdgeSign( eLo->Dst, eUp->Org, eLo->Org ) > 0 ) return FALSE;
+
+		/* eUp->Org appears to be below eLo */
+		if( ! VertEq( eUp->Org, eLo->Org )) {
+			/* Splice eUp->Org into eLo */
+			if ( tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1);
+			if ( !tessMeshSplice( tess->mesh, eUp, eLo->Oprev ) ) longjmp(tess->env,1);
+			regUp->dirty = regLo->dirty = TRUE;
+
+		} else if( eUp->Org != eLo->Org ) {
+			/* merge the two vertices, discarding eUp->Org */
+			pqDelete( tess->pq, eUp->Org->pqHandle );
+			SpliceMergeVertices( tess, eLo->Oprev, eUp );
+		}
+	} else {
+		if( EdgeSign( eUp->Dst, eLo->Org, eUp->Org ) < 0 ) return FALSE;
+
+		/* eLo->Org appears to be above eUp, so splice eLo->Org into eUp */
+		RegionAbove(regUp)->dirty = regUp->dirty = TRUE;
+		if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1);
+		if ( !tessMeshSplice( tess->mesh, eLo->Oprev, eUp ) ) longjmp(tess->env,1);
+	}
+	return TRUE;
+}
+
+static int CheckForLeftSplice( TESStesselator *tess, ActiveRegion *regUp )
+/*
+* Check the upper and lower edge of "regUp", to make sure that the
+* eUp->Dst is above eLo, or eLo->Dst is below eUp (depending on which
+* destination is rightmost).
+*
+* Theoretically, this should always be true.  However, splitting an edge
+* into two pieces can change the results of previous tests.  For example,
+* suppose at one point we checked eUp and eLo, and decided that eUp->Dst
+* is barely above eLo.  Then later, we split eLo into two edges (eg. from
+* a splice operation like this one).  This can change the result of
+* the test so that now eUp->Dst is incident to eLo, or barely below it.
+* We must correct this condition to maintain the dictionary invariants
+* (otherwise new edges might get inserted in the wrong place in the
+* dictionary, and bad stuff will happen).
+*
+* We fix the problem by just splicing the offending vertex into the
+* other edge.
+*/
+{
+	ActiveRegion *regLo = RegionBelow(regUp);
+	TESShalfEdge *eUp = regUp->eUp;
+	TESShalfEdge *eLo = regLo->eUp;
+	TESShalfEdge *e;
+
+	assert( ! VertEq( eUp->Dst, eLo->Dst ));
+
+	if( VertLeq( eUp->Dst, eLo->Dst )) {
+		if( EdgeSign( eUp->Dst, eLo->Dst, eUp->Org ) < 0 ) return FALSE;
+
+		/* eLo->Dst is above eUp, so splice eLo->Dst into eUp */
+		RegionAbove(regUp)->dirty = regUp->dirty = TRUE;
+		e = tessMeshSplitEdge( tess->mesh, eUp );
+		if (e == NULL) longjmp(tess->env,1);
+		if ( !tessMeshSplice( tess->mesh, eLo->Sym, e ) ) longjmp(tess->env,1);
+		e->Lface->inside = regUp->inside;
+	} else {
+		if( EdgeSign( eLo->Dst, eUp->Dst, eLo->Org ) > 0 ) return FALSE;
+
+		/* eUp->Dst is below eLo, so splice eUp->Dst into eLo */
+		regUp->dirty = regLo->dirty = TRUE;
+		e = tessMeshSplitEdge( tess->mesh, eLo );
+		if (e == NULL) longjmp(tess->env,1);
+		if ( !tessMeshSplice( tess->mesh, eUp->Lnext, eLo->Sym ) ) longjmp(tess->env,1);
+		e->Rface->inside = regUp->inside;
+	}
+	return TRUE;
+}
+
+
+static int CheckForIntersect( TESStesselator *tess, ActiveRegion *regUp )
+/*
+* Check the upper and lower edges of the given region to see if
+* they intersect.  If so, create the intersection and add it
+* to the data structures.
+*
+* Returns TRUE if adding the new intersection resulted in a recursive
+* call to AddRightEdges(); in this case all "dirty" regions have been
+* checked for intersections, and possibly regUp has been deleted.
+*/
+{
+	ActiveRegion *regLo = RegionBelow(regUp);
+	TESShalfEdge *eUp = regUp->eUp;
+	TESShalfEdge *eLo = regLo->eUp;
+	TESSvertex *orgUp = eUp->Org;
+	TESSvertex *orgLo = eLo->Org;
+	TESSvertex *dstUp = eUp->Dst;
+	TESSvertex *dstLo = eLo->Dst;
+	TESSreal tMinUp, tMaxLo;
+	TESSvertex isect, *orgMin;
+	TESShalfEdge *e;
+
+	assert( ! VertEq( dstLo, dstUp ));
+	assert( EdgeSign( dstUp, tess->event, orgUp ) <= 0 );
+	assert( EdgeSign( dstLo, tess->event, orgLo ) >= 0 );
+	assert( orgUp != tess->event && orgLo != tess->event );
+	assert( ! regUp->fixUpperEdge && ! regLo->fixUpperEdge );
+
+	if( orgUp == orgLo ) return FALSE;	/* right endpoints are the same */
+
+	tMinUp = MIN( orgUp->t, dstUp->t );
+	tMaxLo = MAX( orgLo->t, dstLo->t );
+	if( tMinUp > tMaxLo ) return FALSE;	/* t ranges do not overlap */
+
+	if( VertLeq( orgUp, orgLo )) {
+		if( EdgeSign( dstLo, orgUp, orgLo ) > 0 ) return FALSE;
+	} else {
+		if( EdgeSign( dstUp, orgLo, orgUp ) < 0 ) return FALSE;
+	}
+
+	/* At this point the edges intersect, at least marginally */
+	DebugEvent( tess );
+
+	tesedgeIntersect( dstUp, orgUp, dstLo, orgLo, &isect );
+	/* The following properties are guaranteed: */
+	assert( MIN( orgUp->t, dstUp->t ) <= isect.t );
+	assert( isect.t <= MAX( orgLo->t, dstLo->t ));
+	assert( MIN( dstLo->s, dstUp->s ) <= isect.s );
+	assert( isect.s <= MAX( orgLo->s, orgUp->s ));
+
+	if( VertLeq( &isect, tess->event )) {
+		/* The intersection point lies slightly to the left of the sweep line,
+		* so move it until it''s slightly to the right of the sweep line.
+		* (If we had perfect numerical precision, this would never happen
+		* in the first place).  The easiest and safest thing to do is
+		* replace the intersection by tess->event.
+		*/
+		isect.s = tess->event->s;
+		isect.t = tess->event->t;
+	}
+	/* Similarly, if the computed intersection lies to the right of the
+	* rightmost origin (which should rarely happen), it can cause
+	* unbelievable inefficiency on sufficiently degenerate inputs.
+	* (If you have the test program, try running test54.d with the
+	* "X zoom" option turned on).
+	*/
+	orgMin = VertLeq( orgUp, orgLo ) ? orgUp : orgLo;
+	if( VertLeq( orgMin, &isect )) {
+		isect.s = orgMin->s;
+		isect.t = orgMin->t;
+	}
+
+	if( VertEq( &isect, orgUp ) || VertEq( &isect, orgLo )) {
+		/* Easy case -- intersection at one of the right endpoints */
+		(void) CheckForRightSplice( tess, regUp );
+		return FALSE;
+	}
+
+	if(    (! VertEq( dstUp, tess->event )
+		&& EdgeSign( dstUp, tess->event, &isect ) >= 0)
+		|| (! VertEq( dstLo, tess->event )
+		&& EdgeSign( dstLo, tess->event, &isect ) <= 0 ))
+	{
+		/* Very unusual -- the new upper or lower edge would pass on the
+		* wrong side of the sweep event, or through it.  This can happen
+		* due to very small numerical errors in the intersection calculation.
+		*/
+		if( dstLo == tess->event ) {
+			/* Splice dstLo into eUp, and process the new region(s) */
+			if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1);
+			if ( !tessMeshSplice( tess->mesh, eLo->Sym, eUp ) ) longjmp(tess->env,1);
+			regUp = TopLeftRegion( tess, regUp );
+			if (regUp == NULL) longjmp(tess->env,1);
+			eUp = RegionBelow(regUp)->eUp;
+			FinishLeftRegions( tess, RegionBelow(regUp), regLo );
+			AddRightEdges( tess, regUp, eUp->Oprev, eUp, eUp, TRUE );
+			return TRUE;
+		}
+		if( dstUp == tess->event ) {
+			/* Splice dstUp into eLo, and process the new region(s) */
+			if (tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1);
+			if ( !tessMeshSplice( tess->mesh, eUp->Lnext, eLo->Oprev ) ) longjmp(tess->env,1);
+			regLo = regUp;
+			regUp = TopRightRegion( regUp );
+			e = RegionBelow(regUp)->eUp->Rprev;
+			regLo->eUp = eLo->Oprev;
+			eLo = FinishLeftRegions( tess, regLo, NULL );
+			AddRightEdges( tess, regUp, eLo->Onext, eUp->Rprev, e, TRUE );
+			return TRUE;
+		}
+		/* Special case: called from ConnectRightVertex.  If either
+		* edge passes on the wrong side of tess->event, split it
+		* (and wait for ConnectRightVertex to splice it appropriately).
+		*/
+		if( EdgeSign( dstUp, tess->event, &isect ) >= 0 ) {
+			RegionAbove(regUp)->dirty = regUp->dirty = TRUE;
+			if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1);
+			eUp->Org->s = tess->event->s;
+			eUp->Org->t = tess->event->t;
+		}
+		if( EdgeSign( dstLo, tess->event, &isect ) <= 0 ) {
+			regUp->dirty = regLo->dirty = TRUE;
+			if (tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1);
+			eLo->Org->s = tess->event->s;
+			eLo->Org->t = tess->event->t;
+		}
+		/* leave the rest for ConnectRightVertex */
+		return FALSE;
+	}
+
+	/* General case -- split both edges, splice into new vertex.
+	* When we do the splice operation, the order of the arguments is
+	* arbitrary as far as correctness goes.  However, when the operation
+	* creates a new face, the work done is proportional to the size of
+	* the new face.  We expect the faces in the processed part of
+	* the mesh (ie. eUp->Lface) to be smaller than the faces in the
+	* unprocessed original contours (which will be eLo->Oprev->Lface).
+	*/
+	if (tessMeshSplitEdge( tess->mesh, eUp->Sym ) == NULL) longjmp(tess->env,1);
+	if (tessMeshSplitEdge( tess->mesh, eLo->Sym ) == NULL) longjmp(tess->env,1);
+	if ( !tessMeshSplice( tess->mesh, eLo->Oprev, eUp ) ) longjmp(tess->env,1);
+	eUp->Org->s = isect.s;
+	eUp->Org->t = isect.t;
+	eUp->Org->pqHandle = pqInsert( &tess->alloc, tess->pq, eUp->Org );
+	if (eUp->Org->pqHandle == INV_HANDLE) {
+		pqDeletePriorityQ( &tess->alloc, tess->pq );
+		tess->pq = NULL;
+		longjmp(tess->env,1);
+	}
+	GetIntersectData( tess, eUp->Org, orgUp, dstUp, orgLo, dstLo );
+	RegionAbove(regUp)->dirty = regUp->dirty = regLo->dirty = TRUE;
+	return FALSE;
+}
+
+static void WalkDirtyRegions( TESStesselator *tess, ActiveRegion *regUp )
+/*
+* When the upper or lower edge of any region changes, the region is
+* marked "dirty".  This routine walks through all the dirty regions
+* and makes sure that the dictionary invariants are satisfied
+* (see the comments at the beginning of this file).  Of course
+* new dirty regions can be created as we make changes to restore
+* the invariants.
+*/
+{
+	ActiveRegion *regLo = RegionBelow(regUp);
+	TESShalfEdge *eUp, *eLo;
+
+	for( ;; ) {
+		/* Find the lowest dirty region (we walk from the bottom up). */
+		while( regLo->dirty ) {
+			regUp = regLo;
+			regLo = RegionBelow(regLo);
+		}
+		if( ! regUp->dirty ) {
+			regLo = regUp;
+			regUp = RegionAbove( regUp );
+			if( regUp == NULL || ! regUp->dirty ) {
+				/* We've walked all the dirty regions */
+				return;
+			}
+		}
+		regUp->dirty = FALSE;
+		eUp = regUp->eUp;
+		eLo = regLo->eUp;
+
+		if( eUp->Dst != eLo->Dst ) {
+			/* Check that the edge ordering is obeyed at the Dst vertices. */
+			if( CheckForLeftSplice( tess, regUp )) {
+
+				/* If the upper or lower edge was marked fixUpperEdge, then
+				* we no longer need it (since these edges are needed only for
+				* vertices which otherwise have no right-going edges).
+				*/
+				if( regLo->fixUpperEdge ) {
+					DeleteRegion( tess, regLo );
+					if ( !tessMeshDelete( tess->mesh, eLo ) ) longjmp(tess->env,1);
+					regLo = RegionBelow( regUp );
+					eLo = regLo->eUp;
+				} else if( regUp->fixUpperEdge ) {
+					DeleteRegion( tess, regUp );
+					if ( !tessMeshDelete( tess->mesh, eUp ) ) longjmp(tess->env,1);
+					regUp = RegionAbove( regLo );
+					eUp = regUp->eUp;
+				}
+			}
+		}
+		if( eUp->Org != eLo->Org ) {
+			if(    eUp->Dst != eLo->Dst
+				&& ! regUp->fixUpperEdge && ! regLo->fixUpperEdge
+				&& (eUp->Dst == tess->event || eLo->Dst == tess->event) )
+			{
+				/* When all else fails in CheckForIntersect(), it uses tess->event
+				* as the intersection location.  To make this possible, it requires
+				* that tess->event lie between the upper and lower edges, and also
+				* that neither of these is marked fixUpperEdge (since in the worst
+				* case it might splice one of these edges into tess->event, and
+				* violate the invariant that fixable edges are the only right-going
+				* edge from their associated vertex).
+				*/
+				if( CheckForIntersect( tess, regUp )) {
+					/* WalkDirtyRegions() was called recursively; we're done */
+					return;
+				}
+			} else {
+				/* Even though we can't use CheckForIntersect(), the Org vertices
+				* may violate the dictionary edge ordering.  Check and correct this.
+				*/
+				(void) CheckForRightSplice( tess, regUp );
+			}
+		}
+		if( eUp->Org == eLo->Org && eUp->Dst == eLo->Dst ) {
+			/* A degenerate loop consisting of only two edges -- delete it. */
+			AddWinding( eLo, eUp );
+			DeleteRegion( tess, regUp );
+			if ( !tessMeshDelete( tess->mesh, eUp ) ) longjmp(tess->env,1);
+			regUp = RegionAbove( regLo );
+		}
+	}
+}
+
+
+static void ConnectRightVertex( TESStesselator *tess, ActiveRegion *regUp,
+							   TESShalfEdge *eBottomLeft )
+/*
+* Purpose: connect a "right" vertex vEvent (one where all edges go left)
+* to the unprocessed portion of the mesh.  Since there are no right-going
+* edges, two regions (one above vEvent and one below) are being merged
+* into one.  "regUp" is the upper of these two regions.
+*
+* There are two reasons for doing this (adding a right-going edge):
+*  - if the two regions being merged are "inside", we must add an edge
+*    to keep them separated (the combined region would not be monotone).
+*  - in any case, we must leave some record of vEvent in the dictionary,
+*    so that we can merge vEvent with features that we have not seen yet.
+*    For example, maybe there is a vertical edge which passes just to
+*    the right of vEvent; we would like to splice vEvent into this edge.
+*
+* However, we don't want to connect vEvent to just any vertex.  We don''t
+* want the new edge to cross any other edges; otherwise we will create
+* intersection vertices even when the input data had no self-intersections.
+* (This is a bad thing; if the user's input data has no intersections,
+* we don't want to generate any false intersections ourselves.)
+*
+* Our eventual goal is to connect vEvent to the leftmost unprocessed
+* vertex of the combined region (the union of regUp and regLo).
+* But because of unseen vertices with all right-going edges, and also
+* new vertices which may be created by edge intersections, we don''t
+* know where that leftmost unprocessed vertex is.  In the meantime, we
+* connect vEvent to the closest vertex of either chain, and mark the region
+* as "fixUpperEdge".  This flag says to delete and reconnect this edge
+* to the next processed vertex on the boundary of the combined region.
+* Quite possibly the vertex we connected to will turn out to be the
+* closest one, in which case we won''t need to make any changes.
+*/
+{
+	TESShalfEdge *eNew;
+	TESShalfEdge *eTopLeft = eBottomLeft->Onext;
+	ActiveRegion *regLo = RegionBelow(regUp);
+	TESShalfEdge *eUp = regUp->eUp;
+	TESShalfEdge *eLo = regLo->eUp;
+	int degenerate = FALSE;
+
+	if( eUp->Dst != eLo->Dst ) {
+		(void) CheckForIntersect( tess, regUp );
+	}
+
+	/* Possible new degeneracies: upper or lower edge of regUp may pass
+	* through vEvent, or may coincide with new intersection vertex
+	*/
+	if( VertEq( eUp->Org, tess->event )) {
+		if ( !tessMeshSplice( tess->mesh, eTopLeft->Oprev, eUp ) ) longjmp(tess->env,1);
+		regUp = TopLeftRegion( tess, regUp );
+		if (regUp == NULL) longjmp(tess->env,1);
+		eTopLeft = RegionBelow( regUp )->eUp;
+		FinishLeftRegions( tess, RegionBelow(regUp), regLo );
+		degenerate = TRUE;
+	}
+	if( VertEq( eLo->Org, tess->event )) {
+		if ( !tessMeshSplice( tess->mesh, eBottomLeft, eLo->Oprev ) ) longjmp(tess->env,1);
+		eBottomLeft = FinishLeftRegions( tess, regLo, NULL );
+		degenerate = TRUE;
+	}
+	if( degenerate ) {
+		AddRightEdges( tess, regUp, eBottomLeft->Onext, eTopLeft, eTopLeft, TRUE );
+		return;
+	}
+
+	/* Non-degenerate situation -- need to add a temporary, fixable edge.
+	* Connect to the closer of eLo->Org, eUp->Org.
+	*/
+	if( VertLeq( eLo->Org, eUp->Org )) {
+		eNew = eLo->Oprev;
+	} else {
+		eNew = eUp;
+	}
+	eNew = tessMeshConnect( tess->mesh, eBottomLeft->Lprev, eNew );
+	if (eNew == NULL) longjmp(tess->env,1);
+
+	/* Prevent cleanup, otherwise eNew might disappear before we've even
+	* had a chance to mark it as a temporary edge.
+	*/
+	AddRightEdges( tess, regUp, eNew, eNew->Onext, eNew->Onext, FALSE );
+	eNew->Sym->activeRegion->fixUpperEdge = TRUE;
+	WalkDirtyRegions( tess, regUp );
+}
+
+/* Because vertices at exactly the same location are merged together
+* before we process the sweep event, some degenerate cases can't occur.
+* However if someone eventually makes the modifications required to
+* merge features which are close together, the cases below marked
+* TOLERANCE_NONZERO will be useful.  They were debugged before the
+* code to merge identical vertices in the main loop was added.
+*/
+#define TOLERANCE_NONZERO	FALSE
+
+static void ConnectLeftDegenerate( TESStesselator *tess,
+								  ActiveRegion *regUp, TESSvertex *vEvent )
+/*
+* The event vertex lies exacty on an already-processed edge or vertex.
+* Adding the new vertex involves splicing it into the already-processed
+* part of the mesh.
+*/
+{
+	TESShalfEdge *e, *eTopLeft, *eTopRight, *eLast;
+	ActiveRegion *reg;
+
+	e = regUp->eUp;
+	if( VertEq( e->Org, vEvent )) {
+		/* e->Org is an unprocessed vertex - just combine them, and wait
+		* for e->Org to be pulled from the queue
+		*/
+		assert( TOLERANCE_NONZERO );
+		SpliceMergeVertices( tess, e, vEvent->anEdge );
+		return;
+	}
+
+	if( ! VertEq( e->Dst, vEvent )) {
+		/* General case -- splice vEvent into edge e which passes through it */
+		if (tessMeshSplitEdge( tess->mesh, e->Sym ) == NULL) longjmp(tess->env,1);
+		if( regUp->fixUpperEdge ) {
+			/* This edge was fixable -- delete unused portion of original edge */
+			if ( !tessMeshDelete( tess->mesh, e->Onext ) ) longjmp(tess->env,1);
+			regUp->fixUpperEdge = FALSE;
+		}
+		if ( !tessMeshSplice( tess->mesh, vEvent->anEdge, e ) ) longjmp(tess->env,1);
+		SweepEvent( tess, vEvent );	/* recurse */
+		return;
+	}
+
+	/* vEvent coincides with e->Dst, which has already been processed.
+	* Splice in the additional right-going edges.
+	*/
+	assert( TOLERANCE_NONZERO );
+	regUp = TopRightRegion( regUp );
+	reg = RegionBelow( regUp );
+	eTopRight = reg->eUp->Sym;
+	eTopLeft = eLast = eTopRight->Onext;
+	if( reg->fixUpperEdge ) {
+		/* Here e->Dst has only a single fixable edge going right.
+		* We can delete it since now we have some real right-going edges.
+		*/
+		assert( eTopLeft != eTopRight );   /* there are some left edges too */
+		DeleteRegion( tess, reg );
+		if ( !tessMeshDelete( tess->mesh, eTopRight ) ) longjmp(tess->env,1);
+		eTopRight = eTopLeft->Oprev;
+	}
+	if ( !tessMeshSplice( tess->mesh, vEvent->anEdge, eTopRight ) ) longjmp(tess->env,1);
+	if( ! EdgeGoesLeft( eTopLeft )) {
+		/* e->Dst had no left-going edges -- indicate this to AddRightEdges() */
+		eTopLeft = NULL;
+	}
+	AddRightEdges( tess, regUp, eTopRight->Onext, eLast, eTopLeft, TRUE );
+}
+
+
+static void ConnectLeftVertex( TESStesselator *tess, TESSvertex *vEvent )
+/*
+* Purpose: connect a "left" vertex (one where both edges go right)
+* to the processed portion of the mesh.  Let R be the active region
+* containing vEvent, and let U and L be the upper and lower edge
+* chains of R.  There are two possibilities:
+*
+* - the normal case: split R into two regions, by connecting vEvent to
+*   the rightmost vertex of U or L lying to the left of the sweep line
+*
+* - the degenerate case: if vEvent is close enough to U or L, we
+*   merge vEvent into that edge chain.  The subcases are:
+*	- merging with the rightmost vertex of U or L
+*	- merging with the active edge of U or L
+*	- merging with an already-processed portion of U or L
+*/
+{
+	ActiveRegion *regUp, *regLo, *reg;
+	TESShalfEdge *eUp, *eLo, *eNew;
+	ActiveRegion tmp;
+
+	/* assert( vEvent->anEdge->Onext->Onext == vEvent->anEdge ); */
+
+	/* Get a pointer to the active region containing vEvent */
+	tmp.eUp = vEvent->anEdge->Sym;
+	/* __GL_DICTLISTKEY */ /* tessDictListSearch */
+	regUp = (ActiveRegion *)dictKey( dictSearch( tess->dict, &tmp ));
+	regLo = RegionBelow( regUp );
+	if( !regLo ) {
+		// This may happen if the input polygon is coplanar.
+		return;
+	}
+	eUp = regUp->eUp;
+	eLo = regLo->eUp;
+
+	/* Try merging with U or L first */
+	if( EdgeSign( eUp->Dst, vEvent, eUp->Org ) == 0 ) {
+		ConnectLeftDegenerate( tess, regUp, vEvent );
+		return;
+	}
+
+	/* Connect vEvent to rightmost processed vertex of either chain.
+	* e->Dst is the vertex that we will connect to vEvent.
+	*/
+	reg = VertLeq( eLo->Dst, eUp->Dst ) ? regUp : regLo;
+
+	if( regUp->inside || reg->fixUpperEdge) {
+		if( reg == regUp ) {
+			eNew = tessMeshConnect( tess->mesh, vEvent->anEdge->Sym, eUp->Lnext );
+			if (eNew == NULL) longjmp(tess->env,1);
+		} else {
+			TESShalfEdge *tempHalfEdge= tessMeshConnect( tess->mesh, eLo->Dnext, vEvent->anEdge);
+			if (tempHalfEdge == NULL) longjmp(tess->env,1);
+
+			eNew = tempHalfEdge->Sym;
+		}
+		if( reg->fixUpperEdge ) {
+			if ( !FixUpperEdge( tess, reg, eNew ) ) longjmp(tess->env,1);
+		} else {
+			ComputeWinding( tess, AddRegionBelow( tess, regUp, eNew ));
+		}
+		SweepEvent( tess, vEvent );
+	} else {
+		/* The new vertex is in a region which does not belong to the polygon.
+		* We don''t need to connect this vertex to the rest of the mesh.
+		*/
+		AddRightEdges( tess, regUp, vEvent->anEdge, vEvent->anEdge, NULL, TRUE );
+	}
+}
+
+
+static void SweepEvent( TESStesselator *tess, TESSvertex *vEvent )
+/*
+* Does everything necessary when the sweep line crosses a vertex.
+* Updates the mesh and the edge dictionary.
+*/
+{
+	ActiveRegion *regUp, *reg;
+	TESShalfEdge *e, *eTopLeft, *eBottomLeft;
+
+	tess->event = vEvent;		/* for access in EdgeLeq() */
+	DebugEvent( tess );
+
+	/* Check if this vertex is the right endpoint of an edge that is
+	* already in the dictionary.  In this case we don't need to waste
+	* time searching for the location to insert new edges.
+	*/
+	e = vEvent->anEdge;
+	while( e->activeRegion == NULL ) {
+		e = e->Onext;
+		if( e == vEvent->anEdge ) {
+			/* All edges go right -- not incident to any processed edges */
+			ConnectLeftVertex( tess, vEvent );
+			return;
+		}
+	}
+
+	/* Processing consists of two phases: first we "finish" all the
+	* active regions where both the upper and lower edges terminate
+	* at vEvent (ie. vEvent is closing off these regions).
+	* We mark these faces "inside" or "outside" the polygon according
+	* to their winding number, and delete the edges from the dictionary.
+	* This takes care of all the left-going edges from vEvent.
+	*/
+	regUp = TopLeftRegion( tess, e->activeRegion );
+	if (regUp == NULL) longjmp(tess->env,1);
+	reg = RegionBelow( regUp );
+	eTopLeft = reg->eUp;
+	eBottomLeft = FinishLeftRegions( tess, reg, NULL );
+
+	/* Next we process all the right-going edges from vEvent.  This
+	* involves adding the edges to the dictionary, and creating the
+	* associated "active regions" which record information about the
+	* regions between adjacent dictionary edges.
+	*/
+	if( eBottomLeft->Onext == eTopLeft ) {
+		/* No right-going edges -- add a temporary "fixable" edge */
+		ConnectRightVertex( tess, regUp, eBottomLeft );
+	} else {
+		AddRightEdges( tess, regUp, eBottomLeft->Onext, eTopLeft, eTopLeft, TRUE );
+	}
+}
+
+
+/* Make the sentinel coordinates big enough that they will never be
+* merged with real input features.
+*/
+
+static void AddSentinel( TESStesselator *tess, TESSreal smin, TESSreal smax, TESSreal t )
+/*
+* We add two sentinel edges above and below all other edges,
+* to avoid special cases at the top and bottom.
+*/
+{
+	TESShalfEdge *e;
+	ActiveRegion *reg = (ActiveRegion *)bucketAlloc( tess->regionPool );
+	if (reg == NULL) longjmp(tess->env,1);
+
+	e = tessMeshMakeEdge( tess->mesh );
+	if (e == NULL) longjmp(tess->env,1);
+
+	e->Org->s = smax;
+	e->Org->t = t;
+	e->Dst->s = smin;
+	e->Dst->t = t;
+	tess->event = e->Dst;		/* initialize it */
+
+	reg->eUp = e;
+	reg->windingNumber = 0;
+	reg->inside = FALSE;
+	reg->fixUpperEdge = FALSE;
+	reg->sentinel = TRUE;
+	reg->dirty = FALSE;
+	reg->nodeUp = dictInsert( tess->dict, reg );
+	if (reg->nodeUp == NULL) longjmp(tess->env,1);
+}
+
+
+static void InitEdgeDict( TESStesselator *tess )
+/*
+* We maintain an ordering of edge intersections with the sweep line.
+* This order is maintained in a dynamic dictionary.
+*/
+{
+	TESSreal w, h;
+	TESSreal smin, smax, tmin, tmax;
+
+	tess->dict = dictNewDict( &tess->alloc, tess, (int (*)(void *, DictKey, DictKey)) EdgeLeq );
+	if (tess->dict == NULL) longjmp(tess->env,1);
+
+	w = (tess->bmax[0] - tess->bmin[0]);
+	h = (tess->bmax[1] - tess->bmin[1]);
+
+        /* If the bbox is empty, ensure that sentinels are not coincident by
+           slightly enlarging it. */
+	smin = tess->bmin[0] - (w > 0 ? w : 0.01);
+        smax = tess->bmax[0] + (w > 0 ? w : 0.01);
+        tmin = tess->bmin[1] - (h > 0 ? h : 0.01);
+        tmax = tess->bmax[1] + (h > 0 ? h : 0.01);
+
+	AddSentinel( tess, smin, smax, tmin );
+	AddSentinel( tess, smin, smax, tmax );
+}
+
+
+static void DoneEdgeDict( TESStesselator *tess )
+{
+	ActiveRegion *reg;
+	int fixedEdges = 0;
+	(void)fixedEdges;
+
+	while( (reg = (ActiveRegion *)dictKey( dictMin( tess->dict ))) != NULL ) {
+		/*
+		* At the end of all processing, the dictionary should contain
+		* only the two sentinel edges, plus at most one "fixable" edge
+		* created by ConnectRightVertex().
+		*/
+		if( ! reg->sentinel ) {
+			assert( reg->fixUpperEdge );
+			assert( ++fixedEdges == 1 );
+		}
+		assert( reg->windingNumber == 0 );
+		DeleteRegion( tess, reg );
+		/*    tessMeshDelete( reg->eUp );*/
+	}
+	dictDeleteDict( &tess->alloc, tess->dict );
+}
+
+
+static void RemoveDegenerateEdges( TESStesselator *tess )
+/*
+* Remove zero-length edges, and contours with fewer than 3 vertices.
+*/
+{
+	TESShalfEdge *e, *eNext, *eLnext;
+	TESShalfEdge *eHead = &tess->mesh->eHead;
+
+	/*LINTED*/
+	for( e = eHead->next; e != eHead; e = eNext ) {
+		eNext = e->next;
+		eLnext = e->Lnext;
+
+		if( VertEq( e->Org, e->Dst ) && e->Lnext->Lnext != e ) {
+			/* Zero-length edge, contour has at least 3 edges */
+
+			SpliceMergeVertices( tess, eLnext, e );	/* deletes e->Org */
+			if ( !tessMeshDelete( tess->mesh, e ) ) longjmp(tess->env,1); /* e is a self-loop */
+			e = eLnext;
+			eLnext = e->Lnext;
+		}
+		if( eLnext->Lnext == e ) {
+			/* Degenerate contour (one or two edges) */
+
+			if( eLnext != e ) {
+				if( eLnext == eNext || eLnext == eNext->Sym ) { eNext = eNext->next; }
+				if ( !tessMeshDelete( tess->mesh, eLnext ) ) longjmp(tess->env,1);
+			}
+			if( e == eNext || e == eNext->Sym ) { eNext = eNext->next; }
+			if ( !tessMeshDelete( tess->mesh, e ) ) longjmp(tess->env,1);
+		}
+	}
+}
+
+static int InitPriorityQ( TESStesselator *tess )
+/*
+* Insert all vertices into the priority queue which determines the
+* order in which vertices cross the sweep line.
+*/
+{
+	PriorityQ *pq;
+	TESSvertex *v, *vHead;
+	int vertexCount = 0;
+
+	vHead = &tess->mesh->vHead;
+	for( v = vHead->next; v != vHead; v = v->next ) {
+		vertexCount++;
+	}
+	/* Make sure there is enough space for sentinels. */
+	vertexCount += MAX( 8, tess->alloc.extraVertices );
+
+	pq = tess->pq = pqNewPriorityQ( &tess->alloc, vertexCount, (int (*)(PQkey, PQkey)) tesvertLeq );
+	if (pq == NULL) return 0;
+
+	vHead = &tess->mesh->vHead;
+	for( v = vHead->next; v != vHead; v = v->next ) {
+		v->pqHandle = pqInsert( &tess->alloc, pq, v );
+		if (v->pqHandle == INV_HANDLE)
+			break;
+	}
+	if (v != vHead || !pqInit( &tess->alloc, pq ) ) {
+		pqDeletePriorityQ( &tess->alloc, tess->pq );
+		tess->pq = NULL;
+		return 0;
+	}
+
+	return 1;
+}
+
+
+static void DonePriorityQ( TESStesselator *tess )
+{
+	pqDeletePriorityQ( &tess->alloc, tess->pq );
+}
+
+
+static int RemoveDegenerateFaces( TESStesselator *tess, TESSmesh *mesh )
+/*
+* Delete any degenerate faces with only two edges.  WalkDirtyRegions()
+* will catch almost all of these, but it won't catch degenerate faces
+* produced by splice operations on already-processed edges.
+* The two places this can happen are in FinishLeftRegions(), when
+* we splice in a "temporary" edge produced by ConnectRightVertex(),
+* and in CheckForLeftSplice(), where we splice already-processed
+* edges to ensure that our dictionary invariants are not violated
+* by numerical errors.
+*
+* In both these cases it is *very* dangerous to delete the offending
+* edge at the time, since one of the routines further up the stack
+* will sometimes be keeping a pointer to that edge.
+*/
+{
+	TESSface *f, *fNext;
+	TESShalfEdge *e;
+
+	/*LINTED*/
+	for( f = mesh->fHead.next; f != &mesh->fHead; f = fNext ) {
+		fNext = f->next;
+		e = f->anEdge;
+		assert( e->Lnext != e );
+
+		if( e->Lnext->Lnext == e ) {
+			/* A face with only two edges */
+			AddWinding( e->Onext, e );
+			if ( !tessMeshDelete( tess->mesh, e ) ) return 0;
+		}
+	}
+	return 1;
+}
+
+int tessComputeInterior( TESStesselator *tess )
+/*
+* tessComputeInterior( tess ) computes the planar arrangement specified
+* by the given contours, and further subdivides this arrangement
+* into regions.  Each region is marked "inside" if it belongs
+* to the polygon, according to the rule given by tess->windingRule.
+* Each interior region is guaranteed be monotone.
+*/
+{
+	TESSvertex *v, *vNext;
+
+	/* Each vertex defines an event for our sweep line.  Start by inserting
+	* all the vertices in a priority queue.  Events are processed in
+	* lexicographic order, ie.
+	*
+	*	e1 < e2  iff  e1.x < e2.x || (e1.x == e2.x && e1.y < e2.y)
+	*/
+	RemoveDegenerateEdges( tess );
+	if ( !InitPriorityQ( tess ) ) return 0; /* if error */
+	InitEdgeDict( tess );
+
+	while( (v = (TESSvertex *)pqExtractMin( tess->pq )) != NULL ) {
+		for( ;; ) {
+			vNext = (TESSvertex *)pqMinimum( tess->pq );
+			if( vNext == NULL || ! VertEq( vNext, v )) break;
+
+			/* Merge together all vertices at exactly the same location.
+			* This is more efficient than processing them one at a time,
+			* simplifies the code (see ConnectLeftDegenerate), and is also
+			* important for correct handling of certain degenerate cases.
+			* For example, suppose there are two identical edges A and B
+			* that belong to different contours (so without this code they would
+			* be processed by separate sweep events).  Suppose another edge C
+			* crosses A and B from above.  When A is processed, we split it
+			* at its intersection point with C.  However this also splits C,
+			* so when we insert B we may compute a slightly different
+			* intersection point.  This might leave two edges with a small
+			* gap between them.  This kind of error is especially obvious
+			* when using boundary extraction (TESS_BOUNDARY_ONLY).
+			*/
+			vNext = (TESSvertex *)pqExtractMin( tess->pq );
+			SpliceMergeVertices( tess, v->anEdge, vNext->anEdge );
+		}
+		SweepEvent( tess, v );
+	}
+
+	/* Set tess->event for debugging purposes */
+	tess->event = ((ActiveRegion *) dictKey( dictMin( tess->dict )))->eUp->Org;
+	DebugEvent( tess );
+	DoneEdgeDict( tess );
+	DonePriorityQ( tess );
+
+	if ( !RemoveDegenerateFaces( tess, tess->mesh ) ) return 0;
+	tessMeshCheckMesh( tess->mesh );
+
+	return 1;
+}

polygon.mod/earcut/test/comparison/libtess2/sweep.h

@@ -0,0 +1,74 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#ifndef SWEEP_H
+#define SWEEP_H
+
+#include "mesh.h"
+
+/* tessComputeInterior( tess ) computes the planar arrangement specified
+* by the given contours, and further subdivides this arrangement
+* into regions.  Each region is marked "inside" if it belongs
+* to the polygon, according to the rule given by tess->windingRule.
+* Each interior region is guaranteed be monotone.
+*/
+int tessComputeInterior( TESStesselator *tess );
+
+
+/* The following is here *only* for access by debugging routines */
+
+#include "dict.h"
+
+/* For each pair of adjacent edges crossing the sweep line, there is
+* an ActiveRegion to represent the region between them.  The active
+* regions are kept in sorted order in a dynamic dictionary.  As the
+* sweep line crosses each vertex, we update the affected regions.
+*/
+
+struct ActiveRegion {
+	TESShalfEdge *eUp;		/* upper edge, directed right to left */
+	DictNode *nodeUp;	/* dictionary node corresponding to eUp */
+	int windingNumber;	/* used to determine which regions are
+							* inside the polygon */
+	int inside;		/* is this region inside the polygon? */
+	int sentinel;	/* marks fake edges at t = +/-infinity */
+	int dirty;		/* marks regions where the upper or lower
+					* edge has changed, but we haven't checked
+					* whether they intersect yet */
+	int fixUpperEdge;	/* marks temporary edges introduced when
+						* we process a "right vertex" (one without
+						* any edges leaving to the right) */
+};
+
+#define RegionBelow(r) ((ActiveRegion *) dictKey(dictPred((r)->nodeUp)))
+#define RegionAbove(r) ((ActiveRegion *) dictKey(dictSucc((r)->nodeUp)))
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/tess.c

@@ -0,0 +1,982 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#include <stddef.h>
+#include <assert.h>
+#include <setjmp.h>
+#include "bucketalloc.h"
+#include "tess.h"
+#include "mesh.h"
+#include "sweep.h"
+#include "geom.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TRUE 1
+#define FALSE 0
+
+#define Dot(u,v)	(u[0]*v[0] + u[1]*v[1] + u[2]*v[2])
+
+#if defined(FOR_TRITE_TEST_PROGRAM) || defined(TRUE_PROJECT)
+static void Normalize( TESSreal v[3] )
+{
+	TESSreal len = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+
+	assert( len > 0 );
+	len = sqrtf( len );
+	v[0] /= len;
+	v[1] /= len;
+	v[2] /= len;
+}
+#endif
+
+#define ABS(x)	((x) < 0 ? -(x) : (x))
+
+static int LongAxis( TESSreal v[3] )
+{
+	int i = 0;
+
+	if( ABS(v[1]) > ABS(v[0]) ) { i = 1; }
+	if( ABS(v[2]) > ABS(v[i]) ) { i = 2; }
+	return i;
+}
+
+static int ShortAxis( TESSreal v[3] )
+{
+	int i = 0;
+
+	if( ABS(v[1]) < ABS(v[0]) ) { i = 1; }
+	if( ABS(v[2]) < ABS(v[i]) ) { i = 2; }
+	return i;
+}
+
+static void ComputeNormal( TESStesselator *tess, TESSreal norm[3] )
+{
+	TESSvertex *v, *v1, *v2;
+	TESSreal c, tLen2, maxLen2;
+	TESSreal maxVal[3], minVal[3], d1[3], d2[3], tNorm[3];
+	TESSvertex *maxVert[3], *minVert[3];
+	TESSvertex *vHead = &tess->mesh->vHead;
+	int i;
+
+	v = vHead->next;
+	for( i = 0; i < 3; ++i ) {
+		c = v->coords[i];
+		minVal[i] = c;
+		minVert[i] = v;
+		maxVal[i] = c;
+		maxVert[i] = v;
+	}
+
+	for( v = vHead->next; v != vHead; v = v->next ) {
+		for( i = 0; i < 3; ++i ) {
+			c = v->coords[i];
+			if( c < minVal[i] ) { minVal[i] = c; minVert[i] = v; }
+			if( c > maxVal[i] ) { maxVal[i] = c; maxVert[i] = v; }
+		}
+	}
+
+	/* Find two vertices separated by at least 1/sqrt(3) of the maximum
+	* distance between any two vertices
+	*/
+	i = 0;
+	if( maxVal[1] - minVal[1] > maxVal[0] - minVal[0] ) { i = 1; }
+	if( maxVal[2] - minVal[2] > maxVal[i] - minVal[i] ) { i = 2; }
+	if( minVal[i] >= maxVal[i] ) {
+		/* All vertices are the same -- normal doesn't matter */
+		norm[0] = 0; norm[1] = 0; norm[2] = 1;
+		return;
+	}
+
+	/* Look for a third vertex which forms the triangle with maximum area
+	* (Length of normal == twice the triangle area)
+	*/
+	maxLen2 = 0;
+	v1 = minVert[i];
+	v2 = maxVert[i];
+	d1[0] = v1->coords[0] - v2->coords[0];
+	d1[1] = v1->coords[1] - v2->coords[1];
+	d1[2] = v1->coords[2] - v2->coords[2];
+	for( v = vHead->next; v != vHead; v = v->next ) {
+		d2[0] = v->coords[0] - v2->coords[0];
+		d2[1] = v->coords[1] - v2->coords[1];
+		d2[2] = v->coords[2] - v2->coords[2];
+		tNorm[0] = d1[1]*d2[2] - d1[2]*d2[1];
+		tNorm[1] = d1[2]*d2[0] - d1[0]*d2[2];
+		tNorm[2] = d1[0]*d2[1] - d1[1]*d2[0];
+		tLen2 = tNorm[0]*tNorm[0] + tNorm[1]*tNorm[1] + tNorm[2]*tNorm[2];
+		if( tLen2 > maxLen2 ) {
+			maxLen2 = tLen2;
+			norm[0] = tNorm[0];
+			norm[1] = tNorm[1];
+			norm[2] = tNorm[2];
+		}
+	}
+
+	if( maxLen2 <= 0 ) {
+		/* All points lie on a single line -- any decent normal will do */
+		norm[0] = norm[1] = norm[2] = 0;
+		norm[ShortAxis(d1)] = 1;
+	}
+}
+
+
+static void CheckOrientation( TESStesselator *tess )
+{
+	TESSreal area;
+	TESSface *f, *fHead = &tess->mesh->fHead;
+	TESSvertex *v, *vHead = &tess->mesh->vHead;
+	TESShalfEdge *e;
+
+	/* When we compute the normal automatically, we choose the orientation
+	* so that the the sum of the signed areas of all contours is non-negative.
+	*/
+	area = 0;
+	for( f = fHead->next; f != fHead; f = f->next ) {
+		e = f->anEdge;
+		if( e->winding <= 0 ) continue;
+		do {
+			area += (e->Org->s - e->Dst->s) * (e->Org->t + e->Dst->t);
+			e = e->Lnext;
+		} while( e != f->anEdge );
+	}
+	if( area < 0 ) {
+		/* Reverse the orientation by flipping all the t-coordinates */
+		for( v = vHead->next; v != vHead; v = v->next ) {
+			v->t = - v->t;
+		}
+		tess->tUnit[0] = - tess->tUnit[0];
+		tess->tUnit[1] = - tess->tUnit[1];
+		tess->tUnit[2] = - tess->tUnit[2];
+	}
+}
+
+#ifdef FOR_TRITE_TEST_PROGRAM
+#include <stdlib.h>
+extern int RandomSweep;
+#define S_UNIT_X	(RandomSweep ? (2*drand48()-1) : 1.0)
+#define S_UNIT_Y	(RandomSweep ? (2*drand48()-1) : 0.0)
+#else
+#if defined(SLANTED_SWEEP)
+/* The "feature merging" is not intended to be complete.  There are
+* special cases where edges are nearly parallel to the sweep line
+* which are not implemented.  The algorithm should still behave
+* robustly (ie. produce a reasonable tesselation) in the presence
+* of such edges, however it may miss features which could have been
+* merged.  We could minimize this effect by choosing the sweep line
+* direction to be something unusual (ie. not parallel to one of the
+* coordinate axes).
+*/
+#define S_UNIT_X	(TESSreal)0.50941539564955385	/* Pre-normalized */
+#define S_UNIT_Y	(TESSreal)0.86052074622010633
+#else
+#define S_UNIT_X	(TESSreal)1.0
+#define S_UNIT_Y	(TESSreal)0.0
+#endif
+#endif
+
+/* Determine the polygon normal and project vertices onto the plane
+* of the polygon.
+*/
+void tessProjectPolygon( TESStesselator *tess )
+{
+	TESSvertex *v, *vHead = &tess->mesh->vHead;
+	TESSreal norm[3];
+	TESSreal *sUnit, *tUnit;
+	int i, first, computedNormal = FALSE;
+
+	norm[0] = tess->normal[0];
+	norm[1] = tess->normal[1];
+	norm[2] = tess->normal[2];
+	if( norm[0] == 0 && norm[1] == 0 && norm[2] == 0 ) {
+		ComputeNormal( tess, norm );
+		computedNormal = TRUE;
+	}
+	sUnit = tess->sUnit;
+	tUnit = tess->tUnit;
+	i = LongAxis( norm );
+
+#if defined(FOR_TRITE_TEST_PROGRAM) || defined(TRUE_PROJECT)
+	/* Choose the initial sUnit vector to be approximately perpendicular
+	* to the normal.
+	*/
+	Normalize( norm );
+
+	sUnit[i] = 0;
+	sUnit[(i+1)%3] = S_UNIT_X;
+	sUnit[(i+2)%3] = S_UNIT_Y;
+
+	/* Now make it exactly perpendicular */
+	w = Dot( sUnit, norm );
+	sUnit[0] -= w * norm[0];
+	sUnit[1] -= w * norm[1];
+	sUnit[2] -= w * norm[2];
+	Normalize( sUnit );
+
+	/* Choose tUnit so that (sUnit,tUnit,norm) form a right-handed frame */
+	tUnit[0] = norm[1]*sUnit[2] - norm[2]*sUnit[1];
+	tUnit[1] = norm[2]*sUnit[0] - norm[0]*sUnit[2];
+	tUnit[2] = norm[0]*sUnit[1] - norm[1]*sUnit[0];
+	Normalize( tUnit );
+#else
+	/* Project perpendicular to a coordinate axis -- better numerically */
+	sUnit[i] = 0;
+	sUnit[(i+1)%3] = S_UNIT_X;
+	sUnit[(i+2)%3] = S_UNIT_Y;
+
+	tUnit[i] = 0;
+	tUnit[(i+1)%3] = (norm[i] > 0) ? -S_UNIT_Y : S_UNIT_Y;
+	tUnit[(i+2)%3] = (norm[i] > 0) ? S_UNIT_X : -S_UNIT_X;
+#endif
+
+	/* Project the vertices onto the sweep plane */
+	for( v = vHead->next; v != vHead; v = v->next )
+	{
+		v->s = Dot( v->coords, sUnit );
+		v->t = Dot( v->coords, tUnit );
+	}
+	if( computedNormal ) {
+		CheckOrientation( tess );
+	}
+
+	/* Compute ST bounds. */
+	first = 1;
+	for( v = vHead->next; v != vHead; v = v->next )
+	{
+		if (first)
+		{
+			tess->bmin[0] = tess->bmax[0] = v->s;
+			tess->bmin[1] = tess->bmax[1] = v->t;
+			first = 0;
+		}
+		else
+		{
+			if (v->s < tess->bmin[0]) tess->bmin[0] = v->s;
+			if (v->s > tess->bmax[0]) tess->bmax[0] = v->s;
+			if (v->t < tess->bmin[1]) tess->bmin[1] = v->t;
+			if (v->t > tess->bmax[1]) tess->bmax[1] = v->t;
+		}
+	}
+}
+
+#define AddWinding(eDst,eSrc)	(eDst->winding += eSrc->winding, \
+	eDst->Sym->winding += eSrc->Sym->winding)
+
+/* tessMeshTessellateMonoRegion( face ) tessellates a monotone region
+* (what else would it do??)  The region must consist of a single
+* loop of half-edges (see mesh.h) oriented CCW.  "Monotone" in this
+* case means that any vertical line intersects the interior of the
+* region in a single interval.
+*
+* Tessellation consists of adding interior edges (actually pairs of
+* half-edges), to split the region into non-overlapping triangles.
+*
+* The basic idea is explained in Preparata and Shamos (which I don''t
+* have handy right now), although their implementation is more
+* complicated than this one.  The are two edge chains, an upper chain
+* and a lower chain.  We process all vertices from both chains in order,
+* from right to left.
+*
+* The algorithm ensures that the following invariant holds after each
+* vertex is processed: the untessellated region consists of two
+* chains, where one chain (say the upper) is a single edge, and
+* the other chain is concave.  The left vertex of the single edge
+* is always to the left of all vertices in the concave chain.
+*
+* Each step consists of adding the rightmost unprocessed vertex to one
+* of the two chains, and forming a fan of triangles from the rightmost
+* of two chain endpoints.  Determining whether we can add each triangle
+* to the fan is a simple orientation test.  By making the fan as large
+* as possible, we restore the invariant (check it yourself).
+*/
+int tessMeshTessellateMonoRegion( TESSmesh *mesh, TESSface *face )
+{
+	TESShalfEdge *up, *lo;
+
+	/* All edges are oriented CCW around the boundary of the region.
+	* First, find the half-edge whose origin vertex is rightmost.
+	* Since the sweep goes from left to right, face->anEdge should
+	* be close to the edge we want.
+	*/
+	up = face->anEdge;
+	assert( up->Lnext != up && up->Lnext->Lnext != up );
+
+	for( ; VertLeq( up->Dst, up->Org ); up = up->Lprev )
+		;
+	for( ; VertLeq( up->Org, up->Dst ); up = up->Lnext )
+		;
+	lo = up->Lprev;
+
+	while( up->Lnext != lo ) {
+		if( VertLeq( up->Dst, lo->Org )) {
+			/* up->Dst is on the left.  It is safe to form triangles from lo->Org.
+			* The EdgeGoesLeft test guarantees progress even when some triangles
+			* are CW, given that the upper and lower chains are truly monotone.
+			*/
+			while( lo->Lnext != up && (EdgeGoesLeft( lo->Lnext )
+				|| EdgeSign( lo->Org, lo->Dst, lo->Lnext->Dst ) <= 0 )) {
+					TESShalfEdge *tempHalfEdge= tessMeshConnect( mesh, lo->Lnext, lo );
+					if (tempHalfEdge == NULL) return 0;
+					lo = tempHalfEdge->Sym;
+			}
+			lo = lo->Lprev;
+		} else {
+			/* lo->Org is on the left.  We can make CCW triangles from up->Dst. */
+			while( lo->Lnext != up && (EdgeGoesRight( up->Lprev )
+				|| EdgeSign( up->Dst, up->Org, up->Lprev->Org ) >= 0 )) {
+					TESShalfEdge *tempHalfEdge= tessMeshConnect( mesh, up, up->Lprev );
+					if (tempHalfEdge == NULL) return 0;
+					up = tempHalfEdge->Sym;
+			}
+			up = up->Lnext;
+		}
+	}
+
+	/* Now lo->Org == up->Dst == the leftmost vertex.  The remaining region
+	* can be tessellated in a fan from this leftmost vertex.
+	*/
+	assert( lo->Lnext != up );
+	while( lo->Lnext->Lnext != up ) {
+		TESShalfEdge *tempHalfEdge= tessMeshConnect( mesh, lo->Lnext, lo );
+		if (tempHalfEdge == NULL) return 0;
+		lo = tempHalfEdge->Sym;
+	}
+
+	return 1;
+}
+
+
+/* tessMeshTessellateInterior( mesh ) tessellates each region of
+* the mesh which is marked "inside" the polygon.  Each such region
+* must be monotone.
+*/
+int tessMeshTessellateInterior( TESSmesh *mesh )
+{
+	TESSface *f, *next;
+
+	/*LINTED*/
+	for( f = mesh->fHead.next; f != &mesh->fHead; f = next ) {
+		/* Make sure we don''t try to tessellate the new triangles. */
+		next = f->next;
+		if( f->inside ) {
+			if ( !tessMeshTessellateMonoRegion( mesh, f ) ) return 0;
+		}
+	}
+
+	return 1;
+}
+
+
+/* tessMeshDiscardExterior( mesh ) zaps (ie. sets to NULL) all faces
+* which are not marked "inside" the polygon.  Since further mesh operations
+* on NULL faces are not allowed, the main purpose is to clean up the
+* mesh so that exterior loops are not represented in the data structure.
+*/
+void tessMeshDiscardExterior( TESSmesh *mesh )
+{
+	TESSface *f, *next;
+
+	/*LINTED*/
+	for( f = mesh->fHead.next; f != &mesh->fHead; f = next ) {
+		/* Since f will be destroyed, save its next pointer. */
+		next = f->next;
+		if( ! f->inside ) {
+			tessMeshZapFace( mesh, f );
+		}
+	}
+}
+
+/* tessMeshSetWindingNumber( mesh, value, keepOnlyBoundary ) resets the
+* winding numbers on all edges so that regions marked "inside" the
+* polygon have a winding number of "value", and regions outside
+* have a winding number of 0.
+*
+* If keepOnlyBoundary is TRUE, it also deletes all edges which do not
+* separate an interior region from an exterior one.
+*/
+int tessMeshSetWindingNumber( TESSmesh *mesh, int value,
+							 int keepOnlyBoundary )
+{
+	TESShalfEdge *e, *eNext;
+
+	for( e = mesh->eHead.next; e != &mesh->eHead; e = eNext ) {
+		eNext = e->next;
+		if( e->Rface->inside != e->Lface->inside ) {
+
+			/* This is a boundary edge (one side is interior, one is exterior). */
+			e->winding = (e->Lface->inside) ? value : -value;
+		} else {
+
+			/* Both regions are interior, or both are exterior. */
+			if( ! keepOnlyBoundary ) {
+				e->winding = 0;
+			} else {
+				if ( !tessMeshDelete( mesh, e ) ) return 0;
+			}
+		}
+	}
+	return 1;
+}
+
+void* heapAlloc( void* userData, unsigned int size )
+{
+	TESS_NOTUSED( userData );
+	return malloc( size );
+}
+
+void* heapRealloc( void *userData, void* ptr, unsigned int size )
+{
+	TESS_NOTUSED( userData );
+	return realloc( ptr, size );
+}
+
+void heapFree( void* userData, void* ptr )
+{
+	TESS_NOTUSED( userData );
+	free( ptr );
+}
+
+static TESSalloc defaulAlloc =
+{
+	heapAlloc,
+	heapRealloc,
+	heapFree,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+};
+
+TESStesselator* tessNewTess( TESSalloc* alloc )
+{
+	TESStesselator* tess;
+
+	if (alloc == NULL)
+		alloc = &defaulAlloc;
+
+	/* Only initialize fields which can be changed by the api.  Other fields
+	* are initialized where they are used.
+	*/
+
+	tess = (TESStesselator *)alloc->memalloc( alloc->userData, sizeof( TESStesselator ));
+	if ( tess == NULL ) {
+		return 0;          /* out of memory */
+	}
+	tess->alloc = *alloc;
+	/* Check and set defaults. */
+	if (tess->alloc.meshEdgeBucketSize == 0)
+		tess->alloc.meshEdgeBucketSize = 512;
+	if (tess->alloc.meshVertexBucketSize == 0)
+		tess->alloc.meshVertexBucketSize = 512;
+	if (tess->alloc.meshFaceBucketSize == 0)
+		tess->alloc.meshFaceBucketSize = 256;
+	if (tess->alloc.dictNodeBucketSize == 0)
+		tess->alloc.dictNodeBucketSize = 512;
+	if (tess->alloc.regionBucketSize == 0)
+		tess->alloc.regionBucketSize = 256;
+
+	tess->normal[0] = 0;
+	tess->normal[1] = 0;
+	tess->normal[2] = 0;
+
+	tess->bmin[0] = 0;
+	tess->bmin[1] = 0;
+	tess->bmax[0] = 0;
+	tess->bmax[1] = 0;
+
+	tess->windingRule = TESS_WINDING_ODD;
+
+	if (tess->alloc.regionBucketSize < 16)
+		tess->alloc.regionBucketSize = 16;
+	if (tess->alloc.regionBucketSize > 4096)
+		tess->alloc.regionBucketSize = 4096;
+	tess->regionPool = createBucketAlloc( &tess->alloc, "Regions",
+										 sizeof(ActiveRegion), tess->alloc.regionBucketSize );
+
+	// Initialize to begin polygon.
+	tess->mesh = NULL;
+
+	tess->outOfMemory = 0;
+	tess->vertexIndexCounter = 0;
+
+	tess->vertices = 0;
+	tess->vertexIndices = 0;
+	tess->vertexCount = 0;
+	tess->elements = 0;
+	tess->elementCount = 0;
+
+	return tess;
+}
+
+void tessDeleteTess( TESStesselator *tess )
+{
+
+	struct TESSalloc alloc = tess->alloc;
+
+	deleteBucketAlloc( tess->regionPool );
+
+	if( tess->mesh != NULL ) {
+		tessMeshDeleteMesh( &alloc, tess->mesh );
+		tess->mesh = NULL;
+	}
+	if (tess->vertices != NULL) {
+		alloc.memfree( alloc.userData, tess->vertices );
+		tess->vertices = 0;
+	}
+	if (tess->vertexIndices != NULL) {
+		alloc.memfree( alloc.userData, tess->vertexIndices );
+		tess->vertexIndices = 0;
+	}
+	if (tess->elements != NULL) {
+		alloc.memfree( alloc.userData, tess->elements );
+		tess->elements = 0;
+	}
+
+	alloc.memfree( alloc.userData, tess );
+}
+
+
+static TESSindex GetNeighbourFace(TESShalfEdge* edge)
+{
+	if (!edge->Rface)
+		return TESS_UNDEF;
+	if (!edge->Rface->inside)
+		return TESS_UNDEF;
+	return edge->Rface->n;
+}
+
+void OutputPolymesh( TESStesselator *tess, TESSmesh *mesh, int elementType, int polySize, int vertexSize )
+{
+	TESSvertex* v = 0;
+	TESSface* f = 0;
+	TESShalfEdge* edge = 0;
+	int maxFaceCount = 0;
+	int maxVertexCount = 0;
+	int faceVerts, i;
+	TESSindex *elements = 0;
+	TESSreal *vert;
+
+	// Assume that the input data is triangles now.
+	// Try to merge as many polygons as possible
+	if (polySize > 3)
+	{
+		if (!tessMeshMergeConvexFaces( mesh, polySize ))
+		{
+			tess->outOfMemory = 1;
+			return;
+		}
+	}
+
+	// Mark unused
+	for ( v = mesh->vHead.next; v != &mesh->vHead; v = v->next )
+		v->n = TESS_UNDEF;
+
+	// Create unique IDs for all vertices and faces.
+	for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next )
+	{
+		f->n = TESS_UNDEF;
+		if( !f->inside ) continue;
+
+		edge = f->anEdge;
+		faceVerts = 0;
+		do
+		{
+			v = edge->Org;
+			if ( v->n == TESS_UNDEF )
+			{
+				v->n = maxVertexCount;
+				maxVertexCount++;
+			}
+			faceVerts++;
+			edge = edge->Lnext;
+		}
+		while (edge != f->anEdge);
+
+		assert( faceVerts <= polySize );
+
+		f->n = maxFaceCount;
+		++maxFaceCount;
+	}
+
+	tess->elementCount = maxFaceCount;
+	if (elementType == TESS_CONNECTED_POLYGONS)
+		maxFaceCount *= 2;
+	tess->elements = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData,
+													  sizeof(TESSindex) * maxFaceCount * polySize );
+	if (!tess->elements)
+	{
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	tess->vertexCount = maxVertexCount;
+	tess->vertices = (TESSreal*)tess->alloc.memalloc( tess->alloc.userData,
+													 sizeof(TESSreal) * tess->vertexCount * vertexSize );
+	if (!tess->vertices)
+	{
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	tess->vertexIndices = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData,
+														    sizeof(TESSindex) * tess->vertexCount );
+	if (!tess->vertexIndices)
+	{
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	// Output vertices.
+	for ( v = mesh->vHead.next; v != &mesh->vHead; v = v->next )
+	{
+		if ( v->n != TESS_UNDEF )
+		{
+			// Store coordinate
+			vert = &tess->vertices[v->n*vertexSize];
+			vert[0] = v->coords[0];
+			vert[1] = v->coords[1];
+			if ( vertexSize > 2 )
+				vert[2] = v->coords[2];
+			// Store vertex index.
+			tess->vertexIndices[v->n] = v->idx;
+		}
+	}
+
+	// Output indices.
+	elements = tess->elements;
+	for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next )
+	{
+		if ( !f->inside ) continue;
+
+		// Store polygon
+		edge = f->anEdge;
+		faceVerts = 0;
+		do
+		{
+			v = edge->Org;
+			*elements++ = v->n;
+			faceVerts++;
+			edge = edge->Lnext;
+		}
+		while (edge != f->anEdge);
+		// Fill unused.
+		for (i = faceVerts; i < polySize; ++i)
+			*elements++ = TESS_UNDEF;
+
+		// Store polygon connectivity
+		if ( elementType == TESS_CONNECTED_POLYGONS )
+		{
+			edge = f->anEdge;
+			do
+			{
+				*elements++ = GetNeighbourFace( edge );
+				edge = edge->Lnext;
+			}
+			while (edge != f->anEdge);
+			// Fill unused.
+			for (i = faceVerts; i < polySize; ++i)
+				*elements++ = TESS_UNDEF;
+		}
+	}
+}
+
+void OutputContours( TESStesselator *tess, TESSmesh *mesh, int vertexSize )
+{
+	TESSface *f = 0;
+	TESShalfEdge *edge = 0;
+	TESShalfEdge *start = 0;
+	TESSreal *verts = 0;
+	TESSindex *elements = 0;
+	TESSindex *vertInds = 0;
+	int startVert = 0;
+	int vertCount = 0;
+
+	tess->vertexCount = 0;
+	tess->elementCount = 0;
+
+	for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next )
+	{
+		if ( !f->inside ) continue;
+
+		start = edge = f->anEdge;
+		do
+		{
+			++tess->vertexCount;
+			edge = edge->Lnext;
+		}
+		while ( edge != start );
+
+		++tess->elementCount;
+	}
+
+	tess->elements = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData,
+													  sizeof(TESSindex) * tess->elementCount * 2 );
+	if (!tess->elements)
+	{
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	tess->vertices = (TESSreal*)tess->alloc.memalloc( tess->alloc.userData,
+													  sizeof(TESSreal) * tess->vertexCount * vertexSize );
+	if (!tess->vertices)
+	{
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	tess->vertexIndices = (TESSindex*)tess->alloc.memalloc( tess->alloc.userData,
+														    sizeof(TESSindex) * tess->vertexCount );
+	if (!tess->vertexIndices)
+	{
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	verts = tess->vertices;
+	elements = tess->elements;
+	vertInds = tess->vertexIndices;
+
+	startVert = 0;
+
+	for ( f = mesh->fHead.next; f != &mesh->fHead; f = f->next )
+	{
+		if ( !f->inside ) continue;
+
+		vertCount = 0;
+		start = edge = f->anEdge;
+		do
+		{
+			*verts++ = edge->Org->coords[0];
+			*verts++ = edge->Org->coords[1];
+			if ( vertexSize > 2 )
+				*verts++ = edge->Org->coords[2];
+			*vertInds++ = edge->Org->idx;
+			++vertCount;
+			edge = edge->Lnext;
+		}
+		while ( edge != start );
+
+		elements[0] = startVert;
+		elements[1] = vertCount;
+		elements += 2;
+
+		startVert += vertCount;
+	}
+}
+
+void tessAddContour( TESStesselator *tess, int size, const void* vertices,
+					int stride, int numVertices )
+{
+	const unsigned char *src = (const unsigned char*)vertices;
+	TESShalfEdge *e;
+	int i;
+
+	if ( tess->mesh == NULL )
+	  	tess->mesh = tessMeshNewMesh( &tess->alloc );
+ 	if ( tess->mesh == NULL ) {
+		tess->outOfMemory = 1;
+		return;
+	}
+
+	if ( size < 2 )
+		size = 2;
+	if ( size > 3 )
+		size = 3;
+
+	e = NULL;
+
+	for( i = 0; i < numVertices; ++i )
+	{
+		const TESSreal* coords = (const TESSreal*)src;
+		src += stride;
+
+		if( e == NULL ) {
+			/* Make a self-loop (one vertex, one edge). */
+			e = tessMeshMakeEdge( tess->mesh );
+			if ( e == NULL ) {
+				tess->outOfMemory = 1;
+				return;
+			}
+			if ( !tessMeshSplice( tess->mesh, e, e->Sym ) ) {
+				tess->outOfMemory = 1;
+				return;
+			}
+		} else {
+			/* Create a new vertex and edge which immediately follow e
+			* in the ordering around the left face.
+			*/
+			if ( tessMeshSplitEdge( tess->mesh, e ) == NULL ) {
+				tess->outOfMemory = 1;
+				return;
+			}
+			e = e->Lnext;
+		}
+
+		/* The new vertex is now e->Org. */
+		e->Org->coords[0] = coords[0];
+		e->Org->coords[1] = coords[1];
+		if ( size > 2 )
+			e->Org->coords[2] = coords[2];
+		else
+			e->Org->coords[2] = 0;
+		/* Store the insertion number so that the vertex can be later recognized. */
+		e->Org->idx = tess->vertexIndexCounter++;
+
+		/* The winding of an edge says how the winding number changes as we
+		* cross from the edge''s right face to its left face.  We add the
+		* vertices in such an order that a CCW contour will add +1 to
+		* the winding number of the region inside the contour.
+		*/
+		e->winding = 1;
+		e->Sym->winding = -1;
+	}
+}
+
+int tessTesselate( TESStesselator *tess, int windingRule, int elementType,
+				  int polySize, int vertexSize, const TESSreal* normal )
+{
+	TESSmesh *mesh;
+	int rc = 1;
+
+	if (tess->vertices != NULL) {
+		tess->alloc.memfree( tess->alloc.userData, tess->vertices );
+		tess->vertices = 0;
+	}
+	if (tess->elements != NULL) {
+		tess->alloc.memfree( tess->alloc.userData, tess->elements );
+		tess->elements = 0;
+	}
+	if (tess->vertexIndices != NULL) {
+		tess->alloc.memfree( tess->alloc.userData, tess->vertexIndices );
+		tess->vertexIndices = 0;
+	}
+
+	tess->vertexIndexCounter = 0;
+
+	if (normal)
+	{
+		tess->normal[0] = normal[0];
+		tess->normal[1] = normal[1];
+		tess->normal[2] = normal[2];
+	}
+
+	tess->windingRule = windingRule;
+
+	if (vertexSize < 2)
+		vertexSize = 2;
+	if (vertexSize > 3)
+		vertexSize = 3;
+
+	if (setjmp(tess->env) != 0) {
+		/* come back here if out of memory */
+		return 0;
+	}
+
+	if (!tess->mesh)
+	{
+		return 0;
+	}
+
+	/* Determine the polygon normal and project vertices onto the plane
+	* of the polygon.
+	*/
+	tessProjectPolygon( tess );
+
+	/* tessComputeInterior( tess ) computes the planar arrangement specified
+	* by the given contours, and further subdivides this arrangement
+	* into regions.  Each region is marked "inside" if it belongs
+	* to the polygon, according to the rule given by tess->windingRule.
+	* Each interior region is guaranteed be monotone.
+	*/
+	if ( !tessComputeInterior( tess ) ) {
+		longjmp(tess->env,1);  /* could've used a label */
+	}
+
+	mesh = tess->mesh;
+
+	/* If the user wants only the boundary contours, we throw away all edges
+	* except those which separate the interior from the exterior.
+	* Otherwise we tessellate all the regions marked "inside".
+	*/
+	if (elementType == TESS_BOUNDARY_CONTOURS) {
+		rc = tessMeshSetWindingNumber( mesh, 1, TRUE );
+	} else {
+		rc = tessMeshTessellateInterior( mesh );
+	}
+	if (rc == 0) longjmp(tess->env,1);  /* could've used a label */
+
+	tessMeshCheckMesh( mesh );
+
+	if (elementType == TESS_BOUNDARY_CONTOURS) {
+		OutputContours( tess, mesh, vertexSize );     /* output contours */
+	}
+	else
+	{
+		OutputPolymesh( tess, mesh, elementType, polySize, vertexSize );     /* output polygons */
+	}
+
+	tessMeshDeleteMesh( &tess->alloc, mesh );
+	tess->mesh = NULL;
+
+	if (tess->outOfMemory)
+		return 0;
+	return 1;
+}
+
+int tessGetVertexCount( TESStesselator *tess )
+{
+	return tess->vertexCount;
+}
+
+const TESSreal* tessGetVertices( TESStesselator *tess )
+{
+	return tess->vertices;
+}
+
+const TESSindex* tessGetVertexIndices( TESStesselator *tess )
+{
+	return tess->vertexIndices;
+}
+
+int tessGetElementCount( TESStesselator *tess )
+{
+	return tess->elementCount;
+}
+
+const int* tessGetElements( TESStesselator *tess )
+{
+	return tess->elements;
+}

polygon.mod/earcut/test/comparison/libtess2/tess.h

@@ -0,0 +1,90 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Eric Veach, July 1994.
+*/
+
+#ifndef TESS_H
+#define TESS_H
+
+#include <setjmp.h>
+#include "bucketalloc.h"
+#include "mesh.h"
+#include "dict.h"
+#include "priorityq.h"
+#include "tesselator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//typedef struct TESStesselator TESStesselator;
+
+struct TESStesselator {
+
+	/*** state needed for collecting the input data ***/
+	TESSmesh	*mesh;		/* stores the input contours, and eventually
+						the tessellation itself */
+	int outOfMemory;
+
+	/*** state needed for projecting onto the sweep plane ***/
+
+	TESSreal normal[3];	/* user-specified normal (if provided) */
+	TESSreal sUnit[3];	/* unit vector in s-direction (debugging) */
+	TESSreal tUnit[3];	/* unit vector in t-direction (debugging) */
+
+	TESSreal bmin[2];
+	TESSreal bmax[2];
+
+	/*** state needed for the line sweep ***/
+	int	windingRule;	/* rule for determining polygon interior */
+
+	Dict *dict;		/* edge dictionary for sweep line */
+	PriorityQ *pq;		/* priority queue of vertex events */
+	TESSvertex *event;		/* current sweep event being processed */
+
+	struct BucketAlloc* regionPool;
+
+	TESSindex vertexIndexCounter;
+
+	TESSreal *vertices;
+	TESSindex *vertexIndices;
+	int vertexCount;
+	TESSindex *elements;
+	int elementCount;
+
+	TESSalloc alloc;
+
+	jmp_buf env;			/* place to jump to when memAllocs fail */
+};
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

polygon.mod/earcut/test/comparison/libtess2/tesselator.h

@@ -0,0 +1,221 @@
+/*
+** SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
+** Copyright (C) [dates of first publication] Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+** of the Software, and to permit persons to whom the Software is furnished to do so,
+** subject to the following conditions:
+**
+** The above copyright notice including the dates of first publication and either this
+** permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+** INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+** PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC.
+** BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+** OR OTHER DEALINGS IN THE SOFTWARE.
+**
+** Except as contained in this notice, the name of Silicon Graphics, Inc. shall not
+** be used in advertising or otherwise to promote the sale, use or other dealings in
+** this Software without prior written authorization from Silicon Graphics, Inc.
+*/
+/*
+** Author: Mikko Mononen, July 2009.
+*/
+
+#ifndef TESSELATOR_H
+#define TESSELATOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// See OpenGL Red Book for description of the winding rules
+// http://www.glprogramming.com/red/chapter11.html
+enum TessWindingRule
+{
+	TESS_WINDING_ODD,
+	TESS_WINDING_NONZERO,
+	TESS_WINDING_POSITIVE,
+	TESS_WINDING_NEGATIVE,
+	TESS_WINDING_ABS_GEQ_TWO,
+};
+
+// The contents of the tessGetElements() depends on element type being passed to tessTesselate().
+// Tesselation result element types:
+// TESS_POLYGONS
+//   Each element in the element array is polygon defined as 'polySize' number of vertex indices.
+//   If a polygon has than 'polySize' vertices, the remaining indices are stored as TESS_UNDEF.
+//   Example, drawing a polygon:
+//     const int nelems = tessGetElementCount(tess);
+//     const TESSindex* elems = tessGetElements(tess);
+//     for (int i = 0; i < nelems; i++) {
+//         const TESSindex* poly = &elems[i * polySize];
+//         glBegin(GL_POLYGON);
+//         for (int j = 0; j < polySize; j++) {
+//             if (poly[j] == TESS_UNDEF) break;
+//             glVertex2fv(&verts[poly[j]*vertexSize]);
+//         }
+//         glEnd();
+//     }
+//
+// TESS_CONNECTED_POLYGONS
+//   Each element in the element array is polygon defined as 'polySize' number of vertex indices,
+//   followed by 'polySize' indices to neighour polygons, that is each element is 'polySize' * 2 indices.
+//   If a polygon has than 'polySize' vertices, the remaining indices are stored as TESS_UNDEF.
+//   If a polygon edge is a boundary, that is, not connected to another polygon, the neighbour index is TESS_UNDEF.
+//   Example, flood fill based on seed polygon:
+//     const int nelems = tessGetElementCount(tess);
+//     const TESSindex* elems = tessGetElements(tess);
+//     unsigned char* visited = (unsigned char*)calloc(nelems);
+//     TESSindex stack[50];
+//     int nstack = 0;
+//     stack[nstack++] = seedPoly;
+//     visited[startPoly] = 1;
+//     while (nstack > 0) {
+//         TESSindex idx = stack[--nstack];
+//			const TESSindex* poly = &elems[idx * polySize * 2];
+//			const TESSindex* nei = &poly[polySize];
+//          for (int i = 0; i < polySize; i++) {
+//              if (poly[i] == TESS_UNDEF) break;
+//              if (nei[i] != TESS_UNDEF && !visited[nei[i]])
+//	                stack[nstack++] = nei[i];
+//                  visited[nei[i]] = 1;
+//              }
+//          }
+//     }
+//
+// TESS_BOUNDARY_CONTOURS
+//   Each element in the element array is [base index, count] pair defining a range of vertices for a contour.
+//   The first value is index to first vertex in contour and the second value is number of vertices in the contour.
+//   Example, drawing contours:
+//     const int nelems = tessGetElementCount(tess);
+//     const TESSindex* elems = tessGetElements(tess);
+//     for (int i = 0; i < nelems; i++) {
+//         const TESSindex base = elems[i * 2];
+//         const TESSindex count = elems[i * 2 + 1];
+//         glBegin(GL_LINE_LOOP);
+//         for (int j = 0; j < count; j++) {
+//             glVertex2fv(&verts[(base+j) * vertexSize]);
+//         }
+//         glEnd();
+//     }
+//
+enum TessElementType
+{
+	TESS_POLYGONS,
+	TESS_CONNECTED_POLYGONS,
+	TESS_BOUNDARY_CONTOURS,
+};
+
+typedef float TESSreal;
+typedef int TESSindex;
+typedef struct TESStesselator TESStesselator;
+typedef struct TESSalloc TESSalloc;
+
+#define TESS_UNDEF (~(TESSindex)0)
+
+#define TESS_NOTUSED(v) do { (void)(1 ? (void)0 : ( (void)(v) ) ); } while(0)
+
+// Custom memory allocator interface.
+// The internal memory allocator allocates mesh edges, vertices and faces
+// as well as dictionary nodes and active regions in buckets and uses simple
+// freelist to speed up the allocation. The bucket size should roughly match your
+// expected input data. For example if you process only hundreds of vertices,
+// a bucket size of 128 might be ok, where as when processing thousands of vertices
+// bucket size of 1024 might be approproate. The bucket size is a compromise between
+// how often to allocate memory from the system versus how much extra space the system
+// should allocate. Reasonable defaults are show in commects below, they will be used if
+// the bucket sizes are zero.
+//
+// The use may left the memrealloc to be null. In that case, the tesselator will not try to
+// dynamically grow int's internal arrays. The tesselator only needs the reallocation when it
+// has found intersecting segments and needs to add new vertex. This defency can be cured by
+// allocating some extra vertices beforehand. The 'extraVertices' variable allows to specify
+// number of expected extra vertices.
+struct TESSalloc
+{
+	void *(*memalloc)( void *userData, unsigned int size );
+	void *(*memrealloc)( void *userData, void* ptr, unsigned int size );
+	void (*memfree)( void *userData, void *ptr );
+	void* userData;				// User data passed to the allocator functions.
+	int meshEdgeBucketSize;		// 512
+	int meshVertexBucketSize;	// 512
+	int meshFaceBucketSize;		// 256
+	int dictNodeBucketSize;		// 512
+	int regionBucketSize;		// 256
+	int extraVertices;			// Number of extra vertices allocated for the priority queue.
+};
+
+
+//
+// Example use:
+//
+//
+//
+//
+
+// tessNewTess() - Creates a new tesselator.
+// Use tessDeleteTess() to delete the tesselator.
+// Parameters:
+//   alloc - pointer to a filled TESSalloc struct or NULL to use default malloc based allocator.
+// Returns:
+//   new tesselator object.
+TESStesselator* tessNewTess( TESSalloc* alloc );
+
+// tessDeleteTess() - Deletes a tesselator.
+// Parameters:
+//   tess - pointer to tesselator object to be deleted.
+void tessDeleteTess( TESStesselator *tess );
+
+// tessAddContour() - Adds a contour to be tesselated.
+// The type of the vertex coordinates is assumed to be TESSreal.
+// Parameters:
+//   tess - pointer to tesselator object.
+//   size - number of coordinates per vertex. Must be 2 or 3.
+//   pointer - pointer to the first coordinate of the first vertex in the array.
+//   stride - defines offset in bytes between consecutive vertices.
+//   count - number of vertices in contour.
+void tessAddContour( TESStesselator *tess, int size, const void* pointer, int stride, int count );
+
+// tessTesselate() - tesselate contours.
+// Parameters:
+//   tess - pointer to tesselator object.
+//   windingRule - winding rules used for tesselation, must be one of TessWindingRule.
+//   elementType - defines the tesselation result element type, must be one of TessElementType.
+//   polySize - defines maximum vertices per polygons if output is polygons.
+//   vertexSize - defines the number of coordinates in tesselation result vertex, must be 2 or 3.
+//   normal - defines the normal of the input contours, of null the normal is calculated automatically.
+// Returns:
+//   1 if succeed, 0 if failed.
+int tessTesselate( TESStesselator *tess, int windingRule, int elementType, int polySize, int vertexSize, const TESSreal* normal );
+
+// tessGetVertexCount() - Returns number of vertices in the tesselated output.
+int tessGetVertexCount( TESStesselator *tess );
+
+// tessGetVertices() - Returns pointer to first coordinate of first vertex.
+const TESSreal* tessGetVertices( TESStesselator *tess );
+
+// tessGetVertexIndices() - Returns pointer to first vertex index.
+// Vertex indices can be used to map the generated vertices to the original vertices.
+// Every point added using tessAddContour() will get a new index starting at 0.
+// New vertices generated at the intersections of segments are assigned value TESS_UNDEF.
+const TESSindex* tessGetVertexIndices( TESStesselator *tess );
+
+// tessGetElementCount() - Returns number of elements in the the tesselated output.
+int tessGetElementCount( TESStesselator *tess );
+
+// tessGetElements() - Returns pointer to the first element.
+const TESSindex* tessGetElements( TESStesselator *tess );
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // TESSELATOR_H

polygon.mod/earcut/test/convert_tests.js

@@ -0,0 +1,79 @@
+'use strict';
+/* jshint node: true */
+
+var fs = require('fs');
+var path = require('path');
+var earcut = require('../../earcut/src/earcut.js');
+
+var integerPolygons = '';
+var doublePolygons = '';
+
+var base = '../earcut/test/fixtures';
+fs.readdirSync(base).filter(function (name) {
+    return path.extname(name) === '.json';
+}).forEach(function (name) {
+    var json = JSON.parse(fs.readFileSync(path.join(base, name), 'utf-8'));
+    var data = earcut.flatten(json),
+        indices = earcut(data.vertices, data.holes, data.dimensions),
+        deviation = earcut.deviation(data.vertices, data.holes, data.dimensions, indices);
+
+    var id = path.basename(name, path.extname(name)).replace(/[^a-z0-9]+/g, '_');
+
+    var integer = true;
+    var short_integer = true;
+
+    function processPoint(p) {
+        if (integer && (p[0] % 1 !== 0 || p[1] % 1 !== 0)) {
+            integer = false;
+            short_integer = false;
+        }
+        if (short_integer && (p[0] < -32767 || p[0] > 32767 || p[1] < -32767 || p[1] > 32767)) {
+            short_integer = false;
+        }
+        return p.join(',');
+    }
+
+    var geometry = '';
+    for (var i = 0; i < json.length; i++) {
+        geometry += '    {{' + (json[i].map(processPoint).join('},{')) + '}},\n';
+    }
+
+    var className = "Fixture<double>"
+    if (short_integer) {
+        className = "Fixture<short>"
+    } else if (integer) {
+        className = "Fixture<int>"
+    }
+
+    var expectedTriangles = indices.length / 3;
+    var expectedDeviation = deviation;
+    expectedDeviation += 1e-14;
+    var libtessDeviationMap = {
+        "water": 0.00002,
+        "water_huge": 0.0002,
+        "water_huge2": 0.00015,
+        "bad_hole": 0.0022,
+        "issue16": 0.0255,
+        "self_touching": 0.002,
+        "simplified_us_border": 0.001,
+        "issue45": 0.094,
+        "empty_square": Infinity,
+        "issue83": Infinity,
+        "issue107": Infinity,
+        "issue119": 0.04,
+        "touching4": 0.06
+    };
+    var expectedLibtessDeviation = libtessDeviationMap[id];
+    if (!expectedLibtessDeviation) expectedLibtessDeviation = 0.000001;
+    var cpp = '// This file is auto-generated, manual changes will be lost if the code is regenerated.\n\n';
+    cpp += '#include "geometries.hpp"\n\n';
+    cpp += 'namespace mapbox {\n';
+    cpp += 'namespace fixtures {\n\n';
+    cpp += 'static const ' + className + ' ' + id + '("' + id + '", ' + expectedTriangles + ', ' + expectedDeviation + ', ' + expectedLibtessDeviation +', {\n';
+    cpp += geometry;
+    cpp += '});\n\n';
+    cpp += '}\n';
+    cpp += '}\n';
+
+    fs.writeFileSync('test/fixtures/' + id + '.cpp', cpp);
+});

polygon.mod/earcut/test/fixtures/bad_diagonals.cpp

@@ -0,0 +1,13 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> bad_diagonals("bad_diagonals", 7, 1e-14, 0.000001, {
+    {{440,4152},{440,4208},{296,4192},{368,4192},{400,4200},{400,4176},{368,4192},{296,4192},{264,4200},{288,4160},{296,4192}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/bad_hole.cpp

@@ -0,0 +1,16 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> bad_hole("bad_hole", 42, 0.018674136321205143, 0.0022, {
+    {{810,2828},{818,2828},{832,2818},{844,2806},{855,2808},{866,2816},{867,2824},{876,2827},{883,2834},{875,2834},{867,2840},{878,2838},{889,2844},{880,2847},{870,2847},{860,2864},{852,2879},{847,2867},{810,2828},{810,2828}},
+    {{818,2834},{823,2833},{831,2828},{839,2829},{839,2837},{851,2845},{847,2835},{846,2827},{847,2827},{837,2827},{840,2815},{835,2823},{818,2834},{818,2834}},
+    {{857,2846},{864,2850},{866,2839},{857,2846},{857,2846}},
+    {{848,2863},{848,2866},{854,2852},{846,2854},{847,2862},{838,2851},{838,2859},{848,2863},{848,2863}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/boxy.cpp

@@ -0,0 +1,17 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> boxy("boxy", 57, 1e-14, 0.000001, {
+    {{3432,2779},{3432,2794},{3450,2794},{3450,2825},{3413,2825},{3413,2856},{3395,2856},{3395,2871},{3377,2871},{3377,2856},{3359,2856},{3359,2840},{3341,2840},{3341,2871},{3322,2871},{3322,2887},{3249,2887},{3249,2871},{3268,2871},{3268,2840},{3304,2840},{3304,2825},{3322,2825},{3322,2810},{3304,2810},{3304,2794},{3322,2794},{3322,2779},{3341,2779},{3341,2733},{3359,2733},{3359,2687},{3395,2687},{3395,2702},{3432,2702},{3432,2717},{3450,2717},{3450,2733},{3486,2733},{3486,2748},{3468,2748},{3468,2763},{3450,2763},{3450,2779},{3432,2779}},
+    {{3359,2794},{3341,2794},{3341,2810},{3395,2810},{3395,2794},{3377,2794},{3377,2779},{3359,2779},{3359,2794}},
+    {{3432,2779},{3432,2748},{3413,2748},{3413,2779},{3432,2779}},
+    {{3377,2779},{3395,2779},{3395,2748},{3377,2748},{3377,2779}},
+    {{3377,2717},{3395,2717},{3395,2702},{3377,2702},{3377,2717}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/building.cpp

@@ -0,0 +1,13 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> building("building", 13, 1e-14, 0.000001, {
+    {{661,112},{661,96},{666,96},{666,87},{743,87},{771,87},{771,114},{750,114},{750,113},{742,113},{742,106},{710,106},{710,113},{666,113},{666,112}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/collinear_diagonal.cpp

@@ -0,0 +1,13 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> collinear_diagonal("collinear_diagonal", 14, 1e-14, 0.000001, {
+    {{3468,1913},{3486,1884},{3413,1869},{3322,1869},{3413,1854},{3413,1869},{3486,1869},{3486,1884},{3504,1884},{3504,1869},{3432,1869},{3432,1854},{3395,1854},{3432,1839},{3432,1854},{3450,1839},{3341,1839},{3341,1825},{3195,1825},{3341,1810},{3341,1825},{3450,1825},{3523,1854},{3523,1913}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/degenerate.cpp

@@ -0,0 +1,13 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> degenerate("degenerate", 0, 1e-14, 0.000001, {
+    {{100,100},{100,100},{200,100},{200,200},{200,100},{0,100}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/eberly_3.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> eberly_3("eberly_3", 73, 1e-14, 0.000001, {
+    {{2328,2408},{2328,2472},{2344,2472},{2344,2432},{2384,2448},{2384,2536},{2408,2552},{2448,2544},{2456,2560},{2496,2544},{2480,2624},{2456,2664},{2424,2680},{2400,2768},{2376,2768},{2368,2704},{2336,2704},{2264,2784},{2216,2784},{2200,2760},{2168,2760},{2152,2744},{2128,2744},{2128,2784},{2072,2768},{2032,2720},{2000,2720},{2000,2688},{1936,2696},{1920,2736},{1888,2728},{1896,2696},{1928,2688},{1928,2664},{1896,2664},{1896,2640},{1912,2632},{1872,2608},{1888,2576},{2056,2576},{2088,2600},{2184,2608},{2216,2632},{2256,2624},{2248,2600},{2216,2592},{2192,2560},{2120,2576},{2072,2544},{2096,2544},{2080,2520},{2080,2488},{2096,2480},{2080,2448},{2096,2432},{2176,2496},{2200,2488},{2224,2528},{2248,2528},{2240,2488},{2256,2472},{2280,2480},{2264,2416},{2272,2392},{2328,2408}},
+    {{2320,2608},{2304,2640},{2312,2664},{2360,2632},{2352,2608},{2320,2608}},
+    {{1912,2632},{1936,2632},{1936,2616},{1912,2608},{1912,2632}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/empty_square.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> empty_square("empty_square", 0, 1e-14, Infinity, {
+    {{0,0},{4000,0},{4000,4000},{0,4000}},
+    {{0,0},{4000,0},{4000,4000},{0,4000}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/filtered_bridge_jhl.cpp

@@ -0,0 +1,17 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> filtered_bridge_jhl("filtered_bridge_jhl", 25, 1e-14, 0.000001, {
+    {{22,14},{17,12},{5,12},{0,12},{0,0},{22,0}},
+    {{9,4},{10,4},{10,3},{9,3}},
+    {{6,9},{7,9},{7,8},{6,8}},
+    {{7,10},{17,10},{17,5},{8,5}},
+    {{13,4},{14,4},{14,3},{13,3}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/geometries.hpp

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <map>
+#include <string>
+#include <utility>
+#include <string>
+#include <iostream>
+#include <algorithm>
+#include <type_traits>
+
+#include "../comparison/earcut.hpp"
+#include "../comparison/libtess2.hpp"
+
+namespace mapbox {
+namespace fixtures {
+template <typename T> using Polygon = std::vector<std::vector<T>>;
+template <typename T> using Triangles = std::vector<T>;
+using DoublePoint = std::pair<double, double>;
+using DoubleTriangles = Triangles<DoublePoint>;
+using DoublePolygon = Polygon<DoublePoint>;
+const double Infinity = std::numeric_limits<double>::infinity();
+
+template<class T>
+class Collector {
+    std::vector<T> objects;
+    Collector<T>() = default;
+public:
+    static std::vector<T>& collection() {
+        static Collector singleton;
+        return singleton.objects;
+    }
+    static void add(T const& object) {
+        collection().push_back(object);
+    }
+    static void remove(T const& object) {
+        auto& objects = collection();
+        objects.erase(std::remove(objects.begin(), objects.end(), object), objects.end());
+    }
+};
+
+class FixtureTester {
+public:
+    struct TesselatorResult {
+        std::vector<std::array<double, 2>> const& vertices;
+        std::vector<uint32_t> const& indices;
+    };
+    const std::string name;
+    const std::size_t expectedTriangles;
+    const double expectedEarcutDeviation;
+    const double expectedLibtessDeviation;
+    FixtureTester(std::string testname, std::size_t triangles, double deviation, double libtessdeviation)
+    : name(std::move(testname)), expectedTriangles(triangles), expectedEarcutDeviation(deviation), expectedLibtessDeviation(libtessdeviation) {
+        Collector<FixtureTester*>::add(this);
+    }
+    virtual ~FixtureTester() {
+        Collector<FixtureTester*>::remove(this);
+    }
+    virtual TesselatorResult earcut() = 0;
+    virtual TesselatorResult libtess() = 0;
+    virtual DoublePolygon const& polygon() = 0;
+    static std::vector<FixtureTester*>& collection() {
+        auto& objects = Collector<FixtureTester*>::collection();
+        std::sort(objects.begin(), objects.end(), [](FixtureTester* a, FixtureTester* b) { return a->name < b->name; });
+        return objects;
+    }
+};
+
+template <class T>
+class Fixture : public FixtureTester {
+private:
+    Polygon<std::pair<T, T>> inputPolygon;
+    DoublePolygon doublePolygon;
+    EarcutTesselator<double, Polygon<std::pair<T, T>>> earcutTesselator;
+    Libtess2Tesselator<double, Polygon<std::pair<T, T>>> libtessTesselator;
+public:
+    Fixture<T>(std::string const& name, std::size_t expectedTriangles,
+        double expectedDeviation, double expectedLibtessDeviation, Polygon<std::pair<T, T>> const& p)
+        : FixtureTester(name, expectedTriangles, expectedDeviation, expectedLibtessDeviation),
+          inputPolygon(p), earcutTesselator(inputPolygon), libtessTesselator(inputPolygon) {
+        doublePolygon.reserve(inputPolygon.size());
+        for (auto& ring : inputPolygon) {
+            std::vector<std::pair<double, double>> r;
+            r.reserve(ring.size());
+            for (auto& point : ring) {
+                r.emplace_back(static_cast<double>(std::get<0>(point)), static_cast<double>(std::get<1>(point)));
+            }
+            doublePolygon.push_back(r);
+        }
+    }
+    TesselatorResult earcut() override {
+        earcutTesselator.run();
+        return { earcutTesselator.vertices(), earcutTesselator.indices() };
+    }
+    TesselatorResult libtess() override {
+        libtessTesselator.run();
+        return { libtessTesselator.vertices(), libtessTesselator.indices() };
+    }
+    DoublePolygon const& polygon() override {
+        return doublePolygon;
+    }
+};
+
+}
+}

polygon.mod/earcut/test/fixtures/hole_touching_outer.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> hole_touching_outer("hole_touching_outer", 77, 1e-14, 0.000001, {
+    {{-64,-64},{253,-64},{491,358},{697,298},{928,197},{929,505},{1346,507},{1347,303},{1771,306},{1770,512},{2191,509},{2198,933},{2621,932},{2623,1115},{2577,1120},{2494,1183},{2390,1329},{2326,1590},{2287,1678},{2286,1407},{2229,1407},{2182,1493},{2106,1494},{2068,1460},{2019,1460},{2016,1775},{1889,1923},{1953,1989},{2097,1866},{2198,1925},{2203,1973},{2311,1976},{2320,1831},{2352,1824},{2358,1797},{2378,1780},{3350,1782},{3307,2086},{3139,2088},{3143,2203},{3493,2205},{3543,2187},{3540,2260},{3661,2264},{3665,1906},{3630,1902},{3626,1784},{4160,1786},{4160,2631},{4076,2631},{4021,2683},{3930,2701},{3915,2693},{3898,2639},{2630,2630},{2635,3476},{2287,3478},{2118,3203},{2180,3145},{2327,3087},{2610,2643},{2613,2536},{2658,2495},{2650,2203},{1829,2189},{1732,2241},{1551,2245},{933,1183},{890,1152},{455,401},{398,412},{89,547},{-64,606},{-64,-64}},
+    {{1762,928},{1770,512},{1343,513},{1345,715},{931,719},{932,930},{1762,928}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/hourglass.cpp

@@ -0,0 +1,13 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> hourglass("hourglass", 2, 1e-14, 0.000001, {
+    {{7,18},{7,15},{5,15},{7,13},{7,15},{17,17}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/infinite_loop_jhl.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<double> infinite_loop_jhl("infinite_loop_jhl", 0, 1e-14, Infinity, {
+    {{-1,2},{0,0},{2,-1}},
+    {{2,-1},{0,1e-28},{-1,2}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue107.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<double> issue107("issue107", 0, 1.00000000000001, Infinity, {
+    {{7.943741826741378,46.46223436733343},{7.943741826741378,46.43293749233343},{7.943741826741378,46.46223436733343}},
+    {{7.973038701741378,46.46223436733343},{8.002335576741377,46.46223436733343},{8.002335576741377,46.43293749233343},{8.031632451741377,46.43293749233343},{8.002335576741377,46.43293749233343},{8.002335576741377,46.46223436733343},{8.031632451741377,46.46223436733343},{8.031632451741377,46.49153124233343},{8.002335576741377,46.49153124233343},{8.002335576741377,46.46223436733343},{7.973038701741378,46.46223436733343}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue111.cpp

@@ -0,0 +1,16 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue111("issue111", 19, 1e-14, 0.000001, {
+    {{800,4520},{800,4700},{796,4702},{800,4692},{734,4644},{734,4628},{730,4632},{726,4630},{718,4640},{690,4623},{722,4598},{690,4608},{690,4520},{800,4520}},
+    {{718,4640},{716,4630},{710,4628},{718,4640}},
+    {{734,4610},{734,4628},{740,4622},{734,4610}},
+    {{734,4610},{745,4600},{734,4602},{734,4610}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue119.cpp

@@ -0,0 +1,17 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue119("issue119", 18, 1e-14, 0.04, {
+    {{2,12},{2,20},{25,20},{25,12}},
+    {{7,18},{7,15},{5,15}},
+    {{19,18},{19,17},{17,17}},
+    {{19,17},{21,17},{19,16}},
+    {{7,15},{9,15},{7,13}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue131.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue131("issue131", 12, 1e-14, 0.000001, {
+    {{3506,-2048},{7464,402},{-2048,2685},{-2048,-2048},{3506,-2048}},
+    {{-2048,-37},{1235,747},{338,-1464},{-116,-1188},{-2048,-381},{-2048,-37}},
+    {{-1491,-1981},{-1300,-1800},{-1155,-1981},{-1491,-1981}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue135.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue135("issue135", 1, Infinity, Infinity, {
+    {{1,2},{2,2},{1,2},{1,1}},
+    {{4,1},{5,1},{3,2},{4,2}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue142.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<double> issue142("issue142", 4, 0.12754968037146489, 8.53067013, {
+    {{5.62675358811389,31.94879819160804},{-16.369709114391867,28.341954255099814},{-10.786562672455382,-1.2779295357476745},{10.819423740334923,2.069348113719755}},
+    {{3.220439475288522,4.197526331591453},{5.024815373142793,1.1716264034331543},{10.819423740334923,2.069348113719755},{5.62675358811389,31.94879819160804},{-16.369709114391867,28.341954255099814},{-10.786562672455382,-1.2779295357476745},{-6.833718161055838,-0.6655405509524673},{-8.602352370111433,2.142874784407777},{-5.34630560403934,6.768689248602321},{-1.4053749889060216,7.453573097663546}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue149.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue149("issue149", 2, 1e-14, 0.000001, {
+    {{1888,5504},{1872,5504},{1872,5536},{1856,5536},{1856,5520},{1840,5520},{1840,5504},{1856,5504},{1856,5520},{1872,5520},{1872,5504},{1888,5504}},
+    {{1856,5520},{1856,5536},{1872,5536},{1872,5520}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue16.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<double> issue16("issue16", 12, 1e-14, 0.0255, {
+    {{143.12952728374512,61.24016082659364},{147.39952728376375,74.78016082663089},{154.04952728375793,90.26016082707793},{174.42952728376258,81.71016082633287},{168.0395272837486,67.04016082640737},{159.09952728374628,53.590160826221116}},
+    {{156.8595272837556,67.43016082700342},{157.48952728376025,67.16016082651913},{159.96952728374163,68.35016082692891},{161.33952728376607,67.64016082696617},{159.64952728376375,63.31016082689166},{155.75952728374978,64.88016082625836}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue17.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<double> issue17("issue17", 11, 1.0156177186728038e-14, 0.000001, {
+    {{-20037508.34,19971868.877628453},{-20037508.34,-19971868.877628453},{20037508.34,-19971868.877628453},{20037508.34,19971868.877628453}},
+    {{537637.6007702783,5907542.234420554},{539500.1483225027,5905165.501947839},{538610.3146341922,5905217.430281373},{538040.6306361248,5906132.0755739985},{538068.958329954,5906571.138846622},{537711.0379352621,5906645.06648362},{537629.886026485,5907533.69114742}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue29.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<double> issue29("issue29", 40, 1.0364030632684926e-14, 0.000001, {
+    {{200.95000055654114,69.90565782485673},{201.73186418809928,76.50881049432792},{204.05247248713854,82.73234962527638},{207.79442497901618,88.23839184455574},{212.7323883100471,92.70045673093409},{218.58296075442922,95.86217257360113},{225.00460918453172,97.53918036725955},{231.66534446463922,97.66082593216561},{238.15796607054654,96.21973398409901},{244.1176358256489,93.27806596420706},{249.2188404462824,88.99822680730722},{253.15628113771672,83.64108043884043},{255.70631344406866,77.51111824424007},{256.73126424155197,70.93641692795792},{256.19351709797047,64.30797780468129},{254.1057433114911,57.996416078653425},{250.56431880965246,52.346517799043795},{245.8112865351897,47.719993951247304},{240.07834375849924,44.33761266223155},{233.71343464441597,42.419284673407674},{227.06488359675492,42.055728640102465},{220.51757991796475,43.257153422775446},{214.45449861431845,45.97523169373744},{209.20995664413203,50.053084840223896},{205.06721924245355,55.271000209450726},{202.29122001552022,61.30178454495035},{201.02451470680535,67.8368895214051}},
+    {{242.34999892718187,69.90549289577612},{240.7584948063828,76.30057721128688},{236.31611852571368,81.17358751371503},{230.07699953842675,83.34595728587593},{223.55761859836056,82.33733346881347},{218.2910646148026,78.34856240227819},{215.5668820463121,72.34290095195175},{215.9904494531453,65.75019118711353},{219.47497291108593,60.1536534355022},{225.2189893186092,56.88651757836341},{231.8100271829404,56.72041164720431},{237.70269737243652,59.67713584899902},{241.47838292121884,65.0856644153595}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue34.cpp

@@ -0,0 +1,20 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue34("issue34", 139, 1e-14, 0.000001, {
+    {{1500,0},{0,0},{0,1000},{1500,1000},{1500,0}},
+    {{804,642},{814,644},{818,676},{850,690},{838,728},{806,728},{772,752},{748,746},{764,724},{728,726},{710,708},{738,656},{764,668},{784,700},{806,702},{792,666},{804,642}},
+    {{1176,214},{1254,216},{1292,242},{1324,242},{1332,268},{1352,278},{1352,298},{1290,348},{1290,358},{1312,350},{1314,362},{1266,416},{1240,474},{1182,500},{1200,510},{1200,520},{1186,520},{1200,544},{1186,580},{1160,584},{1162,606},{1146,620},{1162,650},{1136,672},{1124,658},{1076,668},{1022,658},{1036,698},{1066,706},{1118,688},{1144,708},{1132,746},{1064,748},{1004,740},{990,668},{966,670},{946,648},{948,632},{962,628},{992,650},{1016,648},{1054,622},{1044,592},{1054,584},{1078,606},{1076,576},{1052,570},{1056,540},{1038,568},{1004,570},{976,526},{996,502},{958,496},{948,454},{962,454},{952,436},{964,390},{986,382},{974,368},{1004,376},{1018,420},{1052,434},{1060,482},{1078,490},{1062,472},{1062,442},{1104,450},{1104,436},{1142,422},{1154,402},{1110,424},{1046,416},{1022,388},{1022,344},{1002,344},{1018,318},{1060,308},{1076,272},{1104,288},{1122,246},{1140,230},{1168,234},{1176,214}},
+    {{974,698},{986,738},{964,740},{952,714},{974,698}},
+    {{842,596},{860,626},{848,622},{842,596}},
+    {{798,572},{792,606},{768,614},{740,580},{758,586},{798,572}},
+    {{892,584},{894,594},{882,588},{892,584}},
+    {{870,500},{912,538},{922,586},{908,590},{894,568},{864,564},{854,550},{868,538},{846,520},{854,500},{870,500}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue45.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue45("issue45", 10, 1e-14, 0.094, {
+    {{10,10},{25,10},{25,40},{10,40}},
+    {{15,30},{20,35},{10,40}},
+    {{15,15},{15,20},{20,15}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue52.cpp

@@ -0,0 +1,18 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue52("issue52", 109, 1e-14, 0.000001, {
+    {{1920,552},{1904,616},{1912,664},{1984,672},{2008,712},{1944,720},{1904,760},{1896,800},{1856,760},{1824,768},{1824,832},{1864,864},{1888,864},{1904,936},{1936,944},{1936,1064},{1936,1112},{1872,1136},{1856,1160},{1840,1144},{1792,1152},{1784,1112},{1752,1096},{1608,1096},{1600,1064},{1640,1040},{1664,992},{1640,968},{1568,1024},{1560,1056},{1480,1048},{1440,1072},{1440,1032},{1400,1032},{1400,1088},{1336,1136},{1320,1136},{1264,1072},{1232,1080},{1240,1104},{1200,1096},{1232,1048},{1272,1032},{1272,1000},{1232,1024},{1176,1024},{1176,1000},{1248,952},{1344,944},{1352,904},{1424,880},{1448,848},{1496,840},{1512,800},{1568,760},{1616,752},{1640,640},{1680,600},{1736,592},{1776,560},{1776,536},{1840,464},{1848,400},{1888,328},{1952,264},{2000,240},{2040,240},{2040,264},{1968,376},{1912,424},{1936,512},{1920,528},{1880,528},{1872,552},{1920,552}},
+    {{1608,800},{1576,848},{1520,840},{1512,872},{1456,904},{1440,952},{1528,936},{1552,912},{1584,912},{1608,880},{1664,864},{1680,816},{1656,776},{1608,800}},
+    {{1720,792},{1736,792},{1720,780},{1720,792}},
+    {{1656,728},{1670,752},{1672,728},{1656,728}},
+    {{1712,680},{1696,720},{1720,728},{1736,704},{1736,680},{1712,680}},
+    {{1968,712},{2000,712},{1968,688},{1968,712}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/issue83.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> issue83("issue83", 0, 1e-14, Infinity, {
+    {{0,0},{4000,0},{4000,4000},{0,4000}},
+    {{0,0},{4000,0},{4000,4000},{0,4000}},
+    {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/outside_ring.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> outside_ring("outside_ring", 64, 1e-14, 0.000001, {
+    {{2181,1228},{2182,1231},{2178,1231},{2180,1228},{2175,1225},{2174,1212},{2182,1210},{2182,1193},{2190,1187},{2187,1166},{2194,1158},{2186,1149},{2186,1103},{2195,1091},{2207,1092},{2209,1080},{2203,1077},{2213,1057},{2213,1035},{2224,1031},{2238,983},{2251,982},{2254,965},{2275,970},{2277,948},{2317,982},{2317,1030},{2323,1044},{2306,1041},{2303,1051},{2290,1057},{2294,1062},{2287,1071},{2294,1081},{2255,1123},{2249,1118},{2253,1128},{2245,1131},{2249,1137},{2243,1168},{2265,1195},{2253,1203},{2260,1204},{2252,1215},{2249,1208},{2245,1217},{2232,1220},{2241,1223},{2235,1223},{2238,1245},{2229,1274},{2215,1272},{2209,1288},{2196,1288},{2190,1269},{2194,1271},{2195,1262},{2181,1240},{2182,1233},{2183,1229},{2181,1228}},
+    {{2181,1228},{2181,1227},{2180,1228},{2181,1228}},
+    {{2246,1197},{2230,1201},{2251,1203},{2246,1197}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/shared_points.cpp

@@ -0,0 +1,13 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> shared_points("shared_points", 4, 1e-14, 0.000001, {
+    {{4136,1016},{4112,1016},{4104,976},{4136,1016},{4144,984},{4104,976},{4144,968},{4144,984},{4168,992},{4152,1064}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/simplified_us_border.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> simplified_us_border("simplified_us_border", 120, 1e-14, 0.001, {
+    {{1130,1713},{1131,1710},{1137,1731},{1133,1752},{1125,1753},{1118,1742},{1110,1717},{1105,1718},{1108,1704},{1096,1691},{1077,1694},{1067,1683},{1019,1687},{1031,1689},{1031,1704},{1022,1696},{1022,1702},{1010,1700},{1003,1692},{998,1696},{980,1690},{970,1698},{966,1694},{966,1702},{938,1718},{943,1742},{920,1736},{916,1721},{894,1693},{884,1691},{872,1703},{837,1667},{785,1672},{743,1654},{715,1656},{699,1636},{676,1628},{654,1587},{656,1583},{660,1588},{657,1579},{649,1580},{633,1547},{637,1529},{631,1507},{638,1454},{647,1454},{637,1452},{639,1441},{635,1442},{629,1417},{651,1421},{647,1434},{655,1428},{650,1440},{656,1434},{654,1423},{651,1420},{653,1419},{651,1407},{965,1407},{966,1400},{972,1411},{1008,1423},{1043,1419},{1083,1442},{1086,1450},{1091,1448},{1109,1468},{1114,1496},{1102,1520},{1107,1525},{1149,1508},{1147,1498},{1152,1495},{1174,1495},{1195,1474},{1242,1470},{1260,1433},{1277,1440},{1277,1462},{1286,1476},{1274,1484},{1265,1480},{1243,1503},{1240,1516},{1252,1526},{1238,1529},{1236,1523},{1234,1530},{1218,1531},{1206,1540},{1205,1554},{1195,1567},{1188,1556},{1194,1574},{1185,1590},{1187,1581},{1179,1567},{1185,1557},{1176,1562},{1180,1579},{1179,1585},{1170,1577},{1180,1593},{1169,1590},{1183,1596},{1186,1607},{1175,1605},{1183,1613},{1182,1618},{1171,1615},{1179,1624},{1167,1626},{1145,1650},{1132,1659},{1128,1656},{1121,1675},{1131,1708},{1129,1710},{1130,1713}},
+    {{654,1419},{653,1419},{654,1423},{656,1425},{654,1419}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/steiner.cpp

@@ -0,0 +1,17 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> steiner("steiner", 9, 1e-14, 0.000001, {
+    {{0,0},{100,0},{100,100},{0,100}},
+    {{50,50}},
+    {{30,40}},
+    {{70,60}},
+    {{20,70}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/touching2.cpp

@@ -0,0 +1,14 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> touching2("touching2", 8, 1e-14, 0.000001, {
+    {{120,2031},{92,2368},{94,2200},{33,2119},{42,2112},{53,2068}},
+    {{44,2104},{79,2132},{88,2115},{44,2104}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/touching3.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> touching3("touching3", 15, 1e-14, 0.000001, {
+    {{1241,887},{1257,891},{1248,904},{1232,911},{1212,911},{1207,911},{1209,900},{1219,898},{1225,907},{1241,887}},
+    {{1212,902},{1212,911},{1219,909},{1212,902}},
+    {{1248,891},{1239,896},{1246,898},{1248,891}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/touching4.cpp

@@ -0,0 +1,17 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> touching4("touching4", 20, 1e-14, 0.06, {
+    {{11,10},{0,10},{0,0},{11,0}},
+    {{7,6},{7,9},{10,9}},
+    {{7,5},{10,2},{10,5}},
+    {{6,9},{1,4},{1,9}},
+    {{1,1},{1,4},{4,1}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/touching_holes.cpp

@@ -0,0 +1,20 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> touching_holes("touching_holes", 57, 1e-14, 0.000001, {
+    {{3694,2061},{3794,2035},{3812,2123},{3784,2123},{3708,2139},{3694,2061}},
+    {{3752,2109},{3740,2102},{3712,2109},{3715,2125},{3723,2128},{3740,2124},{3742,2112},{3752,2109}},
+    {{3797,2101},{3787,2096},{3780,2106},{3788,2114},{3797,2101}},
+    {{3734,2099},{3732,2091},{3719,2094},{3721,2102},{3734,2099}},
+    {{3777,2082},{3774,2071},{3772,2086},{3765,2091},{3748,2088},{3749,2062},{3738,2081},{3745,2095},{3761,2099},{3777,2082}},
+    {{3719,2079},{3712,2079},{3706,2091},{3712,2097},{3721,2080},{3719,2079}},
+    {{3773,2067},{3761,2053},{3753,2061},{3753,2071},{3756,2075},{3773,2067}},
+    {{3708,2079},{3712,2079},{3714,2076},{3719,2079},{3722,2079},{3718,2088},{3723,2089},{3734,2075},{3730,2068},{3717,2065},{3708,2079}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/water3.cpp

@@ -0,0 +1,18 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> water3("water3", 197, 1e-14, 0.000001, {
+    {{-128,4224},{-128,-128},{4224,-128},{4224,4224},{-128,4224}},
+    {{3030,-21},{3019,7},{3025,21},{3045,65},{3054,114},{3041,189},{3000,219},{3017,257},{2966,338},{2938,340},{2934,541},{2973,618},{2979,752},{3026,803},{3052,938},{3083,1030},{3034,1175},{3041,1264},{3083,1311},{3088,1348},{3067,1399},{3139,1435},{3209,1412},{3220,1378},{3242,1316},{3276,1335},{3314,1367},{3369,1529},{3436,1563},{3464,1681},{3512,1732},{3521,1811},{3508,1883},{3591,1939},{3724,2088},{3828,2171},{3867,2238},{3905,2344},{3939,2443},{3892,2498},{3889,2521},{3884,2560},{3942,2624},{3986,2681},{3999,2831},{4089,3008},{4117,3130},{4104,3172},{4023,3205},{3969,3283},{3991,3347},{4091,3365},{4146,3411},{4136,3456},{4068,3467},{3999,3412},{3978,3373},{3935,3350},{3937,3401},{4001,3465},{4036,3503},{3941,3459},{3907,3533},{3939,3655},{3867,3574},{3867,3663},{3796,3614},{3773,3730},{3880,4118},{3854,4159},{3891,4224},{4084,4224},{4106,4103},{4213,4062},{4224,4060},{4224,2439},{4155,2244},{4020,2282},{3978,2233},{3976,2146},{3927,2103},{3937,2060},{3910,1930},{3933,1862},{3893,1781},{3850,1774},{3803,1712},{3824,1651},{3794,1572},{3820,1535},{3835,1493},{3920,1550},{3957,1520},{3948,1444},{3973,1459},{3982,1508},{4016,1520},{4012,1471},{4042,1426},{4068,1422},{4198,1390},{4224,1368},{4224,969},{4214,1019},{4177,1095},{4142,1070},{4176,978},{4202,843},{4213,653},{4181,656},{4181,804},{4155,796},{4138,673},{4114,600},{4050,622},{4050,573},{4100,551},{4050,379},{4015,274},{3986,208},{3972,175},{3965,158},{3953,131},{3921,99},{3885,60},{3853,29},{3807,-4},{3755,-27},{3692,-53},{3639,-58},{3595,-34},{3573,-11},{3519,-4},{3488,17},{3467,6},{3426,4},{3384,25},{3308,28},{3263,-93},{3126,-83},{3041,-46},{3030,-21},{3030,-21}},
+    {{3832,-21},{3840,-17},{3877,21},{3895,39},{3961,-21},{3893,-98},{3855,-128},{3688,-128},{3742,-81},{3793,-41},{3832,-21},{3832,-21}},
+    {{4205,596},{4224,572},{4224,248},{4166,163},{4119,50},{4020,36},{4004,21},{3969,21},{3936,62},{3982,117},{4088,293},{4152,419},{4185,544},{4205,596},{4205,596}},
+    {{3228,2459},{3243,2459},{3248,2434},{3273,2429},{3218,2186},{3255,2102},{3285,2094},{3314,1972},{3198,1969},{3192,1943},{3223,1943},{3222,1913},{3177,1928},{3187,1979},{3180,2171},{3134,2187},{3212,2399},{3243,2398},{3228,2459},{3228,2459}},
+    {{4224,1574},{4212,1572},{4175,1600},{4152,1647},{4131,1689},{4106,1736},{4101,1785},{4115,1851},{4149,1885},{4169,1920},{4204,1908},{4224,1875},{4214,1844},{4199,1798},{4215,1763},{4224,1767},{4224,1574}},
+});
+
+}
+}

polygon.mod/earcut/test/fixtures/water3b.cpp

@@ -0,0 +1,15 @@
+// This file is auto-generated, manual changes will be lost if the code is regenerated.
+
+#include "geometries.hpp"
+
+namespace mapbox {
+namespace fixtures {
+
+static const Fixture<short> water3b("water3b", 25, 1e-14, 0.000001, {
+    {{-128,4224},{-128,-128},{4224,-128},{4224,4224},{-128,4224}},
+    {{3832,-21},{3840,-17},{3877,21},{3895,39},{3961,-21},{3893,-98},{3855,-128},{3688,-128},{3742,-81},{3793,-41},{3832,-21},{3832,-21}},
+    {{4205,596},{4224,572},{4224,248},{4166,163},{4119,50},{4020,36},{4004,21},{3969,21},{3936,62},{3982,117},{4088,293},{4152,419},{4185,544},{4205,596},{4205,596}},
+});
+
+}
+}

polygon.mod/earcut/test/tap.cpp

@@ -0,0 +1,70 @@
+#include "tap.hpp"
+
+#include <iostream>
+#include <stdexcept>
+#include <cassert>
+
+int Tap::total = 0;
+int Tap::errored = 0;
+bool Tap::started = false;
+
+Tap::Tap() {
+    if (started) {
+#if defined(__cpp_exceptions) || defined(__EXCEPTIONS)
+        throw std::runtime_error("Tap cannot be initialized more than once");
+#else
+        assert(false && "Tap cannot be initialized more than once");
+        exit(1);
+#endif
+    }
+
+    std::cout << "TAP version 13" << std::endl;
+
+    atexit([]() {
+
+    });
+}
+
+Tap::~Tap() {
+    std::cout << std::endl;
+    std::cout << "1.." << total << std::endl;
+    std::cout << "# tests " << total << std::endl;
+    std::cout << "# pass  " << (total - errored) << std::endl;
+    std::cout << std::endl;
+    if (!errored) {
+        std::cout << "# ok" << std::endl << std::endl;
+    } else {
+        std::cout << "# not ok" << std::endl << std::endl;
+        exit(1);
+    }
+}
+
+Tap::Test::Test(const std::string &name) {
+    std::cout << "# " << name << std::endl;
+}
+
+Tap::Test::~Test() {
+    if (!finished) {
+        fail("test exited without ending");
+    }
+    if (failed) {
+        errored++;
+    }
+}
+
+void Tap::Test::ok(bool status, const std::string &message) {
+    if (!status) {
+        fail(message);
+    } else {
+        std::cout << "ok " << ++total << " " << message << std::endl;
+    }
+}
+
+void Tap::Test::fail(const std::string &message) {
+    failed = true;
+    std::cout << "not ok " << ++total << " " << message << std::endl;
+}
+
+void Tap::Test::end() {
+    finished = true;
+}

polygon.mod/earcut/test/tap.hpp

@@ -0,0 +1,27 @@
+#include <string>
+
+class Tap {
+public:
+    class Test;
+    Tap();
+    ~Tap();
+
+private:
+    static int total;
+    static int errored;
+    static bool started;
+};
+
+class Tap::Test {
+public:
+    Test(const std::string &name);
+    ~Test();
+
+    void ok(bool status, const std::string &message);
+    void fail(const std::string &message);
+    void end();
+
+private:
+    bool failed = false;
+    bool finished = false;
+};

polygon.mod/earcut/test/test.cpp

@@ -0,0 +1,117 @@
+#include "tap.hpp"
+#include "fixtures/geometries.hpp"
+
+#include <iomanip>
+#include <locale>
+#include <sstream>
+
+template <typename Point>
+double triangleArea(const Point &a, const Point &b, const Point &c) {
+    using namespace mapbox::util;
+    return double(std::abs((nth<0, Point>::get(a) - nth<0, Point>::get(c)) * (nth<1, Point>::get(b) - nth<1, Point>::get(a)) -
+                           (nth<0, Point>::get(a) - nth<0, Point>::get(b)) * (nth<1, Point>::get(c) - nth<1, Point>::get(a)))) / 2;
+}
+
+template <typename Vertices, typename Indices>
+double trianglesArea(const Vertices &vertices, const Indices &indices) {
+    double area = 0;
+    for (size_t i = 0; i < indices.size(); i += 3) {
+        area += triangleArea(
+            vertices[indices[i]],
+            vertices[indices[i + 1]],
+            vertices[indices[i + 2]]
+        );
+    }
+    return area;
+}
+
+template <typename Ring>
+double ringArea(const Ring &points) {
+    using namespace mapbox::util;
+    using Point = typename Ring::value_type;
+    double sum = 0;
+    for (size_t i = 0, len = points.size(), j = len - 1; i < len; j = i++) {
+        sum += (nth<0, Point>::get(points[i]) - nth<0, Point>::get(points[j])) *
+               (nth<1, Point>::get(points[i]) + nth<1, Point>::get(points[j]));
+    }
+    return std::abs(sum) / 2;
+}
+
+template <typename Polygon>
+double polygonArea(const Polygon &rings) {
+    if (rings.empty()) return .0;
+    double sum = ringArea(rings[0]);
+    for (size_t i = 1; i < rings.size(); i++) {
+        sum -= ringArea(rings[i]);
+    }
+    return std::max(sum, .0);
+}
+
+std::string formatPercent(double num) {
+    std::stringstream ss;
+    ss.imbue(std::locale(""));
+    ss << std::fixed << std::setprecision(6) << num * 100 << "%";
+    return ss.str();
+}
+
+void areaTest(mapbox::fixtures::FixtureTester* fixture) {
+    Tap::Test t(fixture->name);
+
+    const auto expectedArea = polygonArea(fixture->polygon());
+    const auto expectedTriangles = fixture->expectedTriangles;
+
+    { // Earcut
+        const auto earcut = fixture->earcut();
+
+        const auto earcutTriangles = earcut.indices.size() / 3;
+        t.ok(earcutTriangles == expectedTriangles, std::to_string(earcutTriangles) + " triangles when expected " +
+            std::to_string(expectedTriangles));
+
+        if (expectedTriangles > 0) {
+            const auto area = trianglesArea(earcut.vertices, earcut.indices);
+            const double deviation = (expectedArea == area) ? 0 :
+                    expectedArea == 0 ? std::numeric_limits<double>::infinity() :
+                    std::abs(area - expectedArea) / expectedArea;
+
+            bool deviationOk = deviation <= fixture->expectedEarcutDeviation;
+            t.ok(deviationOk, std::string{ "earcut deviation " } + formatPercent(deviation) +
+                                                    " is " + (deviationOk ? "" : "not ") + "less than " +
+                                                    formatPercent(fixture->expectedEarcutDeviation));
+        }
+    }
+
+    { // Libtess2
+        const auto libtess = fixture->libtess();
+        const auto area = trianglesArea(libtess.vertices, libtess.indices);
+        const double deviation = (expectedArea == area) ? 0 :
+                expectedArea == 0 ? std::numeric_limits<double>::infinity() :
+                std::abs(area - expectedArea) / expectedArea;
+
+        bool deviationOk = deviation <= fixture->expectedLibtessDeviation;
+        t.ok(deviationOk, std::string{ "libtess2 deviation " } + formatPercent(deviation) +
+                                             " is " + (deviationOk ? "" : "not ") + "less than " +
+                                             formatPercent(fixture->expectedLibtessDeviation));
+    }
+
+    t.end();
+}
+
+int main() {
+    Tap tap;
+
+    {
+        Tap::Test t("empty");
+        auto polygon = mapbox::fixtures::Polygon<std::pair<int, int>> {};
+        EarcutTesselator<int, decltype(polygon)> tesselator(polygon);
+        tesselator.run();
+        t.ok(tesselator.indices().empty(), "empty input produces empty result");
+        t.end();
+    }
+
+    auto& fixtures = mapbox::fixtures::FixtureTester::collection();
+    for (auto fixture : fixtures) {
+        areaTest(fixture);
+    }
+
+    return 0;
+}

polygon.mod/earcut/test/viz.cpp

@@ -0,0 +1,510 @@
+#include "comparison/earcut.hpp"
+#include "comparison/libtess2.hpp"
+
+#include "fixtures/geometries.hpp"
+
+#if _MSC_VER >= 1900
+#pragma comment(lib, "legacy_stdio_definitions.lib")
+#endif
+
+#include <GLFW/glfw3.h>
+
+#include <cstdlib>
+#include <cmath>
+#include <vector>
+#include <memory>
+
+static GLFWwindow *window = nullptr;
+static const int width = 1024;
+static const int height = 1024;
+static bool drawFill = true, drawMesh = true, drawOutline = true;
+static bool dirtyViewport = true, dirtyShape = true, dirtyTessellator = true;
+static float colorBackground[4] = {1.f, 1.f, 1.f, 1.f};
+static float colorMesh[4] = {1.f, 0.f, 0.f, 0.2f}, colorFill[4] = {1.f, 1.f, 0.f, 0.2f};
+static float colorOutline[4] = {0.2f, 0.2f, 0.2f, 0.9f}, colorInline[4] = {0.7f, 0.6f, .2f, 0.9f};
+
+static bool mouseDrag = false;
+
+static std::size_t shapeIndex = 0;
+static std::size_t tessellator = 0;
+
+struct Camera2D {
+    double left = .0, right = .0, bottom = .0, top = .0;
+    double translateX = .0, translateY = .0;
+    int viewWidth = 0, viewHeight = 0;
+    double zoom = -1.;
+    double mx = .0, cx = .0, my = .0, cy = .0;
+    inline float dpi() { return float(viewHeight) / height; }
+    inline double scaling() { return std::pow(1.1, zoom); }
+    void setView(int width, int height) {
+        viewWidth = width;
+        viewHeight = height;
+    }
+    void limits(double l, double r, double b, double t) {
+        left = l;
+        right = r;
+        bottom = b;
+        top = t;
+    }
+    bool scale(double z) {
+        if (z == 0) return false;
+        zoom += z;
+        return true;
+    }
+    bool move(double x, double y) {
+        const double s = scaling();
+        const double dx = x / double(viewWidth) * (right - left) / s;
+        const double dy = y / double(viewHeight) * (bottom - top) / s;
+        if (dx == 0 && dy == 0) {
+            return false;
+        }
+        translateX += dx;
+        translateY += dy;
+        return true;
+    }
+    /* apply current transform to opengl context */
+    void apply() {
+        glViewport(0, 0, viewWidth, viewHeight);
+
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+
+        const double s = scaling();
+        const double w2 = .5 * (right - left);
+        const double h2 = .5 * (top - bottom);
+        mx = s / w2;
+        cx = (-left - w2 + translateX) * mx;
+        my = s / h2;
+        cy = (-bottom - h2 + translateY) * my;
+    }
+    void setDefaults() {
+        zoom = -1.;
+        translateX = .0;
+        translateY = .0;
+    }
+    /* transforms world coordinate to screen range [-1,1] with double precision */
+    inline void toScreen(double *x, double *y) {
+        *x = *x * mx + cx;
+        *y = *y * my + cy;
+    }
+    /* transforms screen coordinates in range [-1,1] to world coordinates with double precision */
+    inline void toWorld(double *x, double *y) {
+        *x = (*x - cx) / mx;
+        *y = (*y - cy) / my;
+    }
+    inline void vec2(double x, double y) {
+        toScreen(&x, &y);
+        glVertex2d(x, y);
+    }
+};
+
+static Camera2D cam;
+
+class DrawablePolygon {
+public:
+    static std::unique_ptr<DrawablePolygon> makeDrawable(std::size_t index, mapbox::fixtures::FixtureTester* fixture);
+    DrawablePolygon() = default;
+    virtual ~DrawablePolygon() = default;
+    virtual const char* name() = 0;
+    virtual void drawMesh() = 0;
+    virtual void drawOutline() = 0;
+    virtual void drawFill() = 0;
+};
+
+class DrawableTesselator : public DrawablePolygon {
+    mapbox::fixtures::FixtureTester::TesselatorResult shape;
+    mapbox::fixtures::DoublePolygon const& polygon;
+public:
+    explicit DrawableTesselator(mapbox::fixtures::FixtureTester::TesselatorResult tessellation,
+                                mapbox::fixtures::DoublePolygon const& poly) : shape(tessellation), polygon(poly) { }
+    void drawMesh() override {
+        const auto &v = shape.vertices;
+        const auto &x = shape.indices;
+        glBegin(GL_LINES);
+        glColor4fv(colorMesh);
+        for (size_t i = 0; i < x.size(); i += 3) {
+            cam.vec2(v[x[i]][0], v[x[i]][1]);
+            cam.vec2(v[x[i + 1]][0], v[x[i + 1]][1]);
+            cam.vec2(v[x[i + 1]][0], v[x[i + 1]][1]);
+            cam.vec2(v[x[i + 2]][0], v[x[i + 2]][1]);
+            cam.vec2(v[x[i + 2]][0], v[x[i + 2]][1]);
+            cam.vec2(v[x[i]][0], v[x[i]][1]);
+        }
+        glEnd();
+    }
+    void drawOutline() override {
+        glBegin(GL_LINES);
+        for (std::size_t i = 0; i < polygon.size(); i++) {
+            auto& ring = polygon[i];
+            glColor4fv(i == 0 ? colorOutline : colorInline);
+            for (std::size_t j = 0; j < ring.size(); j++) {
+                auto& p0 = ring[j];
+                auto& p1 = ring[(j+1) % ring.size()];
+                cam.vec2(std::get<0>(p0), std::get<1>(p0));
+                cam.vec2(std::get<0>(p1), std::get<1>(p1));
+            }
+        }
+        glEnd();
+    }
+    void drawFill() override {
+        const auto &v = shape.vertices;
+        const auto &x = shape.indices;
+        glBegin(GL_TRIANGLES);
+        glColor4fv(colorFill);
+        for (const auto pt : x) {
+            cam.vec2(v[pt][0], v[pt][1]);
+        }
+        glEnd();
+    }
+};
+
+class DrawableEarcut : public DrawableTesselator {
+public:
+    explicit DrawableEarcut(mapbox::fixtures::FixtureTester* fixture)
+            : DrawableTesselator(fixture->earcut(), fixture->polygon()) { }
+    const char *name() override { return "earcut"; };
+};
+
+class DrawableLibtess : public DrawableTesselator {
+public:
+    explicit DrawableLibtess(mapbox::fixtures::FixtureTester* fixture)
+            : DrawableTesselator(fixture->libtess(), fixture->polygon()) { }
+    const char *name() override { return "libtess2"; };
+};
+
+class DrawableScanLineFill : public DrawablePolygon {
+    struct Edge {
+        float yMin;
+        float yMax;
+        float scale;
+        float offset;
+        Edge* next = nullptr;
+        Edge(double x1, double y1, double x2, double y2)
+                : yMin((float)std::min<double>(y1, y2)),
+                  yMax((float)std::max<double>(y1, y2))
+        {
+            const double dx = x1 - x2;
+            const double dy = y1 - y2;
+            scale = (float)(dx / dy);
+            offset = (float)((y1 * x2 - x1 * y2) / dy);
+        }
+        inline double intersection(double scanline) const {
+            // horizontal scan-line intersection from the left
+            // double precision for the calculation is required to avoid artifacts
+            return scanline * scale + offset;
+        }
+    };
+    mapbox::fixtures::FixtureTester* shape;
+    std::vector<Edge*> activeList; /* contains current sorted intersections */
+    std::vector<std::vector<Edge>> edgeTables; /* contains all edges sorted by yMin */
+public:
+    explicit DrawableScanLineFill(mapbox::fixtures::FixtureTester* fixture) : shape(fixture) {
+        auto& polygon = shape->polygon();
+        edgeTables.reserve(polygon.size());
+        for (const auto &ring : polygon) {
+            std::vector<Edge> edgeTable;
+            edgeTable.reserve(ring.size());
+            for (std::size_t i = 1; i <= ring.size(); i++) {
+                const auto &p0 = ring[i - 1], p1 = i == ring.size() ? ring[0] : ring[i];
+                const double x1 = std::get<0>(p0), y1 = std::get<1>(p0), x2 = std::get<0>(p1), y2 = std::get<1>(p1);
+                if (y1 != y2) { edgeTable.emplace_back(x1, y1, x2, y2); }
+            }
+            std::sort(edgeTable.begin(), edgeTable.end(), [&](Edge const &a, Edge const &b) {
+                return a.yMin < b.yMin;
+            });
+            edgeTables.push_back(std::move(edgeTable));
+        }
+    }
+    void scanLineFill(std::vector<Edge>& edgeTable, double top, double bottom, double lineWidth) {
+        assert(top < bottom);
+        assert(lineWidth > 0);
+
+        // create intrusive sorted edge list
+        for (std::size_t i = 1; i < edgeTable.size(); i++) {
+            edgeTable[i-1].next = &edgeTable[i];
+        }
+        Edge* edgeList = edgeTable.empty() ? nullptr : &edgeTable[0];
+
+        const double halfWidth = lineWidth * 0.5;
+        top -= lineWidth;
+        bottom += lineWidth;
+
+        double y0 = top;
+        while(y0 < bottom && edgeList) {
+            double y1 = y0 + lineWidth;
+            if (y1 == y0) { y1 = std::nextafter(y1, bottom); }
+            const double y = y0 + halfWidth;
+
+            activeList.clear();
+            Edge* prevEdge = nullptr;
+            for (auto edge = edgeList; edge != nullptr; edge = edge->next) {
+                const auto min = edge->yMin, max = edge->yMax;
+                if (min <= y && y < max) {
+                    activeList.push_back(edge);
+                }
+                if (min > y)  {
+                    break;
+                } else if (y >= max) {
+                    // unlink edge
+                    Edge** next = prevEdge ? &prevEdge->next : &edgeList;
+                    *next = edge->next;
+                } else {
+                    prevEdge = edge;
+                }
+            }
+            std::sort(activeList.begin(), activeList.end(), [&](Edge *a, Edge *b) {
+                return a->intersection(y) < b->intersection(y);
+            });
+
+            double x1y0 = 0, x1y1 = 0;
+            for (std::size_t i = 0; i < activeList.size(); i++) {
+                Edge *edge = activeList[i];
+
+                // use slope to make MSAA possible
+                const double x2y0 = edge->intersection(std::max<double>(edge->yMin, y0));
+                const double x2y1 = edge->intersection(std::min<double>(edge->yMax, y1));
+                if ((i % 2) != 0) {
+                    cam.vec2(x1y0, y0);
+                    cam.vec2(x1y1, y1);
+                    cam.vec2(x2y1, y1);
+                    cam.vec2(x2y0, y0);
+                }
+                x1y0 = x2y0;
+                x1y1 = x2y1;
+            }
+
+            y0 = y1;
+        }
+    }
+    void drawFill() override {
+        for (std::size_t i = 0; i < edgeTables.size(); i++) {
+            auto& edgeTable = edgeTables[i];
+            glBegin(GL_QUADS);
+            glColor4fv(i == 0 ? colorFill : colorBackground);
+            double x0 = 1;
+            double y0 = 1;
+            cam.toWorld(&x0, &y0);
+            double x1 = -1;
+            double y1 = -1;
+            cam.toWorld(&x1, &y1);
+            scanLineFill(edgeTable, y0, y1, (y1 - y0) / cam.viewHeight);
+            glEnd();
+        }
+    }
+    void drawOutline() override {
+        auto& polygon = shape->polygon();
+        glBegin(GL_LINES);
+        for (std::size_t i = 0; i < polygon.size(); i++) {
+            auto& ring = polygon[i];
+            glColor4fv(i == 0 ? colorOutline : colorInline);
+            for (std::size_t j = 0; j < ring.size(); j++) {
+                auto& p0 = ring[j];
+                auto& p1 = ring[(j+1) % ring.size()];
+                cam.vec2(std::get<0>(p0), std::get<1>(p0));
+                cam.vec2(std::get<0>(p1), std::get<1>(p1));
+            }
+        }
+        glEnd();
+    }
+    void drawMesh() override { }
+    const char *name() override { return "scanline-fill"; }
+};
+
+std::unique_ptr<DrawablePolygon> DrawablePolygon::makeDrawable(std::size_t index, mapbox::fixtures::FixtureTester* fixture) {
+    if (index == 0) {
+        return std::unique_ptr<DrawablePolygon>(new DrawableEarcut(fixture));
+    } else if (index == 1) {
+        return std::unique_ptr<DrawablePolygon>(new DrawableLibtess(fixture));
+    } else {
+        return std::unique_ptr<DrawablePolygon>(new DrawableScanLineFill(fixture));
+    }
+}
+
+static std::array<std::unique_ptr<DrawablePolygon>, 3> tessellators;
+
+
+mapbox::fixtures::FixtureTester *getFixture(std::size_t i) {
+    auto& fixtures = mapbox::fixtures::FixtureTester::collection();
+    if (fixtures.empty()) {
+        assert(false);
+        exit(1);
+    }
+    return fixtures[i % fixtures.size()];
+}
+
+int main() {
+    if (!glfwInit()) {
+        return 1;
+    }
+
+    glfwWindowHint(GLFW_RESIZABLE, 0);
+    glfwWindowHint(GLFW_SAMPLES, 4);
+    window = glfwCreateWindow(width, height, "Tessellation", nullptr, nullptr);
+    if (!window) {
+        glfwTerminate();
+        return 1;
+    }
+
+    glfwSetKeyCallback(window,
+                       [](GLFWwindow *win, int key, int /*scancode*/, int action, int /*mods*/) {
+        if (action != GLFW_PRESS && action != GLFW_REPEAT) {
+            return;
+        }
+
+        if (key == GLFW_KEY_ESCAPE || key == GLFW_KEY_Q) {
+            glfwSetWindowShouldClose(win, 1);
+        } else if (key == GLFW_KEY_F) {
+            drawFill = !drawFill;
+            dirtyViewport = true;
+        } else if (key == GLFW_KEY_M) {
+            drawMesh = !drawMesh;
+            dirtyViewport = true;
+        } else if (key == GLFW_KEY_O) {
+            drawOutline = !drawOutline;
+            dirtyViewport = true;
+        } else if (key == GLFW_KEY_RIGHT) {
+            if (shapeIndex + 1 < mapbox::fixtures::FixtureTester::collection().size()) {
+                shapeIndex++;
+                dirtyShape = true;
+            }
+        } else if (key == GLFW_KEY_LEFT) {
+            if (shapeIndex >= 1) {
+                shapeIndex--;
+                dirtyShape = true;
+            }
+        } else if (key == GLFW_KEY_T || key == GLFW_KEY_UP) {
+            tessellator = (tessellator + 1) % tessellators.size();
+            dirtyTessellator = true;
+        } else if (key == GLFW_KEY_DOWN) {
+            tessellator = (tessellator + tessellators.size() - 1) % tessellators.size();
+            dirtyTessellator = true;
+        } else if (key == GLFW_KEY_KP_ADD) {
+            dirtyViewport |= cam.scale(1.);
+        } else if (key == GLFW_KEY_KP_SUBTRACT) {
+            dirtyViewport |= cam.scale(-1.);
+        } else if (key == GLFW_KEY_R) {
+            dirtyTessellator = dirtyViewport = dirtyShape = true;
+        } else if (key == GLFW_KEY_W) {
+            dirtyViewport |= cam.move(.0, cam.viewHeight / 50.);
+        } else if (key == GLFW_KEY_A) {
+            dirtyViewport |= cam.move(cam.viewWidth / 50., .0);
+        } else if (key == GLFW_KEY_S) {
+            dirtyViewport |= cam.move(.0, -cam.viewHeight / 50.);
+        } else if (key == GLFW_KEY_D) {
+            dirtyViewport |= cam.move(-cam.viewWidth / 50., .0);
+        }
+    });
+
+    glfwSetScrollCallback(window, [](GLFWwindow* /* window */, double /* xoffset */, double yoffset) {
+        dirtyViewport |= cam.scale(yoffset);
+    });
+
+    glfwSetMouseButtonCallback(window, [](GLFWwindow* /* window */, int button, int action, int /* mods */){
+        if (button == GLFW_MOUSE_BUTTON_LEFT) {
+            mouseDrag = action != GLFW_RELEASE;
+        }
+    });
+
+    glfwSetFramebufferSizeCallback(window, [](GLFWwindow * /*win*/, int w, int h) {
+        cam.setView(w, h);
+    });
+
+    int fbWidth, fbHeight;
+    glfwGetFramebufferSize(window, &fbWidth, &fbHeight);
+    cam.setView(fbWidth, fbHeight);
+
+    glfwMakeContextCurrent(window);
+
+    glfwSwapInterval(1);
+
+    glClearColor(colorBackground[0], colorBackground[1], colorBackground[2], colorBackground[3]);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    glEnable(GL_LINE_SMOOTH);
+    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
+
+    while (!glfwWindowShouldClose(window)) {
+        static double mouseX = 0, mouseY = 0;
+        double mousePrevX = mouseX, mousePrevY = mouseY;
+        glfwGetCursorPos(window, &mouseX, &mouseY);
+        double mouseDeltaX = mouseX - mousePrevX, mouseDeltaY = mouseY - mousePrevY;
+        if (mouseDrag) {
+            dirtyViewport |= cam.move(mouseDeltaX, mouseDeltaY);
+        }
+
+        if (dirtyShape) {
+            for (auto &tessellator : tessellators) {
+                tessellator.reset(nullptr);
+            }
+
+            const auto& polygon = getFixture(shapeIndex)->polygon();
+            auto minX = std::numeric_limits<double>::max();
+            auto maxX = std::numeric_limits<double>::min();
+            auto minY = std::numeric_limits<double>::max();
+            auto maxY = std::numeric_limits<double>::min();
+            if (!polygon.empty()) {
+                for (const auto &pt : polygon[0]) {
+                    minX = std::min<double>(minX, std::get<0>(pt));
+                    minY = std::min<double>(minY, std::get<1>(pt));
+                    maxX = std::max<double>(maxX, std::get<0>(pt));
+                    maxY = std::max<double>(maxY, std::get<1>(pt));
+                }
+            }
+            const auto dimX = minX < maxX ? maxX - minX : 0;
+            const auto dimY = minY < maxY ? maxY - minY : 0;
+
+            auto midX = minX + dimX / 2;
+            auto midY = minY + dimY / 2;
+            auto ext = std::max<double>(dimX, dimY) / 2;
+
+            cam.setDefaults();
+            cam.limits(midX - ext, midX + ext, midY + ext, midY - ext);
+        }
+
+        if (dirtyViewport || dirtyShape || dirtyTessellator) {
+            glClear(GL_COLOR_BUFFER_BIT);
+
+            cam.apply();
+            glLineWidth(cam.dpi() * std::sqrt(2.f));
+
+            auto& drawable = tessellators[tessellator];
+
+            if (!drawable) {
+                drawable = DrawablePolygon::makeDrawable(tessellator, getFixture(shapeIndex));
+            }
+
+            if (dirtyTessellator || dirtyShape) {
+                glfwSetWindowTitle(window, (std::string(drawable->name()) + ": "
+                                            + getFixture(shapeIndex)->name).c_str());
+            }
+
+            if (!drawMesh && !drawFill && !drawOutline) {
+                drawMesh = drawFill = drawOutline = true;
+            }
+
+            if (drawFill) {
+                drawable->drawFill();
+            }
+            if (drawMesh) {
+                drawable->drawMesh();
+            }
+            if (drawOutline) {
+                drawable->drawOutline();
+            }
+
+            glFlush(); /* required for Mesa 3D driver */
+            glfwSwapBuffers(window);
+        }
+
+        dirtyTessellator = dirtyShape = dirtyViewport = false;
+        glfwWaitEvents();
+    }
+
+    glfwTerminate();
+    return 0;
+}

polygon.mod/examples/example_01.bmx

@@ -0,0 +1,15 @@
+SuperStrict
+
+Framework BRL.StandardIO
+Import BRL.Polygon
+
+
+Local points:SVec2I[] = [new SVec2I(1, 1), new SVec2I(10, 1), new SVec2I(10, 10), new SVec2I(1, 10)]
+
+Local indices:Int[] = TriangulatePoly(points)
+
+Print indices.length
+
+For Local i:Int = 0 Until indices.length
+	Print indices[i]
+next

polygon.mod/examples/example_02.bmx

@@ -0,0 +1,33 @@
+SuperStrict
+
+Framework SDL.SDLRenderMax2D
+'Framework brl.glmax2d
+import brl.polygon
+Import BRL.StandardIO
+
+Local poly:Float[] = [100, 100, 200, 100, 200, 200, 100, 200]
+
+Local indices:Int[] = TriangulatePoly(poly)
+
+Print "count = " + indices.length
+
+For Local i:Int = 0 Until indices.length
+	Print indices[i]
+next
+Graphics 800, 600, 0
+
+SetHandle( 150, 150 )
+SetOrigin( 200, 200 )
+
+Local angle:Float = 0
+While Not keydown(KEY_ESCAPE)
+	
+		Cls
+
+		DrawPoly(poly, indices)
+
+		SetRotation( angle )
+		angle :+ 0.5
+
+		Flip
+Wend

polygon.mod/glue.cpp

@@ -0,0 +1,102 @@
+/*
+ISC License
+
+Copyright (c) 2023, Bruce A Henderson
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+*/
+#include "mapbox/earcut.hpp"
+
+extern "C" {
+
+#include "brl.mod/blitz.mod/blitz.h"
+
+    struct SVec2I {
+        int x;
+        int y;
+    };
+
+    struct SVec2F {
+        float x;
+        float y;
+    };
+
+    BBArray * bmx_polygon_tri_svec2i(struct SVec2I * p, int size);
+    BBArray * bmx_polygon_tri_svec2f(struct SVec2F * p, int size);
+}
+
+namespace mapbox {
+namespace util {
+
+template <>
+struct nth<0, struct SVec2I> {
+    inline static int get(const struct SVec2I &v) {
+        return v.x;
+    };
+};
+template <>
+struct nth<1, struct SVec2I> {
+    inline static int get(const struct SVec2I &v) {
+        return v.y;
+    };
+};
+
+template <>
+struct nth<0, struct SVec2F> {
+    inline static float get(const struct SVec2F &v) {
+        return v.x;
+    };
+};
+template <>
+struct nth<1, struct SVec2F> {
+    inline static float get(const struct SVec2F &v) {
+        return v.y;
+    };
+};
+
+} // namespace util
+} // namespace mapbox
+
+BBArray * bmx_polygon_tri_svec2i(struct SVec2I * p, int size) {
+
+    std::vector<struct SVec2I> points(p, p + size);
+    std::vector<std::vector<struct SVec2I>> polygon;
+    polygon.push_back(points);
+
+    std::vector<int> indices = mapbox::earcut<int>(polygon);
+
+    BBArray *arr = bbArrayNew1DNoInit("i", indices.size());
+
+	int *s = (int*)BBARRAYDATA(arr,arr->dims);
+
+    std::copy(indices.begin(), indices.end(), s);
+
+    return arr;
+}
+
+BBArray * bmx_polygon_tri_svec2f(struct SVec2F * p, int size) {
+
+    std::vector<struct SVec2F> points(p, p + size);
+    std::vector<std::vector<struct SVec2F>> polygon;
+    polygon.push_back(points);
+
+    std::vector<int> indices = mapbox::earcut<int>(polygon);
+
+    BBArray *arr = bbArrayNew1DNoInit("f", indices.size());
+
+	int *s = (int*)BBARRAYDATA(arr,arr->dims);
+
+    std::copy(indices.begin(), indices.end(), s);
+
+    return arr;
+}

polygon.mod/polygon.bmx

@@ -0,0 +1,61 @@
+' ISC License
+' 
+' Copyright (c) 2023, Bruce A Henderson
+' 
+' Permission to use, copy, modify, and/or distribute this software for any purpose
+' with or without fee is hereby granted, provided that the above copyright notice
+' and this permission notice appear in all copies.
+' 
+' THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+' REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+' FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+' INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+' OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+' TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+' THIS SOFTWARE.
+'
+SuperStrict
+
+Rem
+bbdoc: Polygons
+End Rem
+Module BRL.Polygon
+
+ModuleInfo "Version: 1.00"
+ModuleInfo "Author: Bruce A Henderson"
+ModuleInfo "License: ISC"
+ModuleInfo "earcut - Copyright: 2015 mapbox"
+ModuleInfo "Copyright: 2023 Bruce A Henderson"
+
+ModuleInfo "History: 1.00"
+ModuleInfo "History: Initial Release"
+
+ModuleInfo "CPP_OPTS: -std=c++11"
+
+Import "common.bmx"
+
+
+Rem
+bbdoc: Runs a tesselation against a polygon #SVec2I array, returning a list of triangle indices.
+returns: An array of indices that refer to the vertices of the input polygon. Three subsequent indices form a triangle.
+End Rem
+Function TriangulatePoly:Int[](poly:SVec2I[])
+	Return bmx_polygon_tri_svec2i(poly, poly.Length)
+End Function
+
+Rem
+bbdoc: Runs a tesselation against a polygon #SVec2F array, returning a list of triangle indices.
+returns: An array of indices that refer to the vertices of the input polygon. Three subsequent indices form a triangle.
+End Rem
+Function TriangulatePoly:Int[](poly:SVec2F[])
+	Return bmx_polygon_tri_svec2f(poly, poly.Length)
+End Function
+
+Rem
+bbdoc: Runs a tesselation against a polygon #Float array, returning a list of triangle indices.
+returns: An array of indices that refer to the vertices of the input polygon. Three subsequent indices form a triangle.
+about: The array consists of pairs of x, y vertices.  Output triangles are clockwise.
+End Rem
+Function TriangulatePoly:Int[](poly:Float[])
+	Return bmx_polygon_tri_svec2f(poly, poly.Length / 2)
+End Function