#2 parity with js: mapbox/delaunator@3a61ecc

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.8)
-project(delaunator VERSION 0.2.0)
+project(delaunator VERSION 0.3.0)
 set (CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED on)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

README.md

@@ -11,7 +11,7 @@ delaunator-cpp is a C++ port from https://github.com/mapbox/delaunator a JavaScr
 ## Features
 
 * Probably the fastest C++ open source 2D Delaunay implementation
-* Roughly 6 times faster then JS version (more improvements are coming).
+* Roughly 6 times faster then JS version `[email protected]`
 * Example showing triangulation of GeoJson points
 
 ## Usage

bench/benchmark_out.csv

@@ -0,0 +1,4 @@
+Run on (4 X 2300 MHz CPU s)
+2018-09-18 07:36:59
+name,iterations,real_time,cpu_time,time_unit,bytes_per_second,items_per_second,label,error_occurred,error_message
+"BM_45K_geojson_nodes",32,22.7033,22.4578,ms,,,,,

generate-reference-triangles/package.json

@@ -3,6 +3,6 @@
   "private": true,
   "main": "index.js",
   "dependencies": {
-    "delaunator": "^2.0.2"
+    "delaunator": "2.0.3"
   }
 }

include/delaunator.hpp

@@ -141,6 +141,12 @@ inline bool check_pts_equal(double x1, double y1, double x2, double y2) {
            std::fabs(y1 - y2) < std::numeric_limits<double>::epsilon();
 }
 
+// monotonically increases with real angle, but doesn't need expensive trigonometry
+inline double pseudo_angle(double dx, double dy) {
+    const double p = dx / (std::abs(dx) + std::abs(dy));
+    return (dy > 0.0 ? 3.0 - p : 1.0 + p) / 4.0; // [0..1)
+}
+
 constexpr std::size_t INVALID_INDEX = std::numeric_limits<std::size_t>::max();
 
 struct DelaunatorPoint {
@@ -335,6 +341,7 @@ Delaunator::Delaunator(std::vector<double> const& in_coords)
             (start == INVALID_INDEX || m_hull[start].removed) &&
             (key != start_key));
 
+        start = m_hull[start].prev;
         e = start;
 
         while (
@@ -497,12 +504,9 @@ std::size_t Delaunator::insert_node(std::size_t i, std::size_t prev) {
 std::size_t Delaunator::hash_key(double x, double y) {
     const double dx = x - m_center_x;
     const double dy = y - m_center_y;
-    // use pseudo-angle: a measure that monotonically increases
-    // with real angle, but doesn't require expensive trigonometry
-    const double p = 1.0 - dx / (std::abs(dx) + std::abs(dy));
-    return static_cast<std::size_t>(std::llround(std::floor(
-        (2.0 + (dy < 0.0 ? -p : p)) / 4.0 * static_cast<double>(m_hash_size) //TODO:is this conversion save?
-        )));
+    return static_cast<std::size_t>(std::llround(
+        std::floor(pseudo_angle(dx, dy) * static_cast<double>(m_hash_size))
+    ));
 }
 
 void Delaunator::hash_edge(std::size_t e) {