Move to exact arithmetic for new boolean implementation.

This is a regression in functionality from the previous version,
as I have not yet got anything beyond intersection working (and
that only for triangulated meshes). But want to get this into
the repository now while I continue to work on the functionality,
and then, the performance.

26 files changed, 7767 insertions, 5592 deletions

diff --git a/source/blender/blenlib/BLI_boolean.h b/source/blender/blenlib/BLI_boolean.h
new file mode 100644
index 00000000000..f23e59c8c8d
--- /dev/null
+++ b/source/blender/blenlib/BLI_boolean.h
@@ -0,0 +1,60 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_BOOLEAN_H__
+#define __BLI_BOOLEAN_H__
+
+
+/** \file
+ * \ingroup bli
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum bool_optype {
+  BOOLEAN_NONE = -1,
+  /* Aligned with BooleanModifierOp. */
+  BOOLEAN_ISECT = 0,
+  BOOLEAN_UNION = 1,
+  BOOLEAN_DIFFERENCE = 2,
+} bool_optype;
+
+typedef struct Boolean_trimesh_input {
+  int vert_len;
+  int tri_len;
+  float (*vert_coord)[3];
+  int (*tri)[3];
+} Boolean_trimesh_input;
+
+typedef struct Boolean_trimesh_output {
+  int vert_len;
+  int tri_len;
+  float (*vert_coord)[3];
+  int (*tri)[3];
+} Boolean_trimesh_output;
+
+Boolean_trimesh_output *BLI_boolean_trimesh(const Boolean_trimesh_input *input, int bool_optype);
+
+void BLI_boolean_trimesh_free(Boolean_trimesh_output *output);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __BLI_BOOLEAN_H__ */
diff --git a/source/blender/blenlib/BLI_delaunay_2d.h b/source/blender/blenlib/BLI_delaunay_2d.h
index 95111dbbbf7..fc5c7123890 100644
--- a/source/blender/blenlib/BLI_delaunay_2d.h
+++ b/source/blender/blenlib/BLI_delaunay_2d.h
@@ -19,6 +19,9 @@
 
 /** \file
  * \ingroup bli
+ *
+ *  This header file contains both a C interface and a C++ interface
+ *  to the 2D Constrained Delaunay Triangulation library routine.
  */
 
 #ifdef __cplusplus
@@ -108,11 +111,6 @@ extern "C" {
  * If zero is supplied for epsilon, an internal value of 1e-8 used
  * instead, since this code will not work correctly if it is not allowed
  * to merge "too near" vertices.
- *
- * Normally, if epsilon is non-zero, there is an "input modify" pass which
- * checks to see if some vertices are within epsilon of other edges, and
- * snapping them to those edges if so. You can skip this pass by setting
- * skip_input_modify to true. (This is also useful in some unit tests.)
  */
 typedef struct CDT_input {
   int verts_len;
@@ -124,7 +122,6 @@ typedef struct CDT_input {
   int *faces_start_table;
   int *faces_len_table;
   float epsilon;
-  bool skip_input_modify;
 } CDT_input;
 
 /**
@@ -208,6 +205,55 @@ void BLI_delaunay_2d_cdt_free(CDT_result *result);
 
 #ifdef __cplusplus
 }
-#endif
+
+/* C++ Interface. */
+
+#  include "gmpxx.h"
+
+#  include "BLI_array.hh"
+#  include "BLI_double2.hh"
+#  include "BLI_linklist.h"
+#  include "BLI_mempool.h"
+#  include "BLI_mpq2.hh"
+#  include "BLI_vector.hh"
+
+namespace BLI {
+
+template<typename Arith_t> struct vec2_impl;
+template<> struct vec2_impl<double> {
+  typedef double2 type;
+};
+template<> struct vec2_impl<mpq_class> {
+  typedef mpq2 type;
+};
+template<typename Arith_t> using vec2 = typename vec2_impl<Arith_t>::type;
+
+template<typename Arith_t> class CDT_input {
+ public:
+  Array<vec2<Arith_t>> vert;
+  Array<std::pair<int, int>> edge;
+  Array<Vector<int>> face;
+  Arith_t epsilon{0};
+};
+
+template<typename Arith_t> class CDT_result {
+ public:
+  Array<vec2<Arith_t>> vert;
+  Array<std::pair<int, int>> edge;
+  Array<Vector<int>> face;
+  Array<Vector<int>> vert_orig;
+  Array<Vector<int>> edge_orig;
+  Array<Vector<int>> face_orig;
+  int face_edge_offset;
+};
+
+CDT_result<double> delaunay_2d_calc(const CDT_input<double> &input, CDT_output_type output_type);
+
+CDT_result<mpq_class> delaunay_2d_calc(const CDT_input<mpq_class> &input,
+                                       CDT_output_type output_type);
+
+} /* namespace BLI */
+
+#endif /* __cplusplus */
 
 #endif /* __BLI_DELAUNAY_2D_H__ */
diff --git a/source/blender/blenlib/BLI_double2.hh b/source/blender/blenlib/BLI_double2.hh
new file mode 100644
index 00000000000..994d6213502
--- /dev/null
+++ b/source/blender/blenlib/BLI_double2.hh
@@ -0,0 +1,140 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_DOUBLE2_HH__
+#define __BLI_DOUBLE2_HH__
+
+#include "BLI_double3.hh"
+
+namespace BLI {
+
+struct double2 {
+  double x, y;
+
+  double2() = default;
+
+  double2(const double *ptr) : x{ptr[0]}, y{ptr[1]}
+  {
+  }
+
+  double2(double x, double y) : x(x), y(y)
+  {
+  }
+
+  double2(const double3 &other) : x(other.x), y(other.y)
+  {
+  }
+
+  operator double *()
+  {
+    return &x;
+  }
+
+  operator const double *() const
+  {
+    return &x;
+  }
+
+  float length() const
+  {
+    return len_v2_db(*this);
+  }
+
+  friend double2 operator+(const double2 &a, const double2 &b)
+  {
+    return {a.x + b.x, a.y + b.y};
+  }
+
+  friend double2 operator-(const double2 &a, const double2 &b)
+  {
+    return {a.x - b.x, a.y - b.y};
+  }
+
+  friend double2 operator*(const double2 &a, double b)
+  {
+    return {a.x * b, a.y * b};
+  }
+
+  friend double2 operator/(const double2 &a, double b)
+  {
+    BLI_assert(b != 0.0);
+    return {a.x / b, a.y / b};
+  }
+
+  friend double2 operator*(double a, const double2 &b)
+  {
+    return b * a;
+  }
+
+  friend bool operator==(const double2 &a, const double2 &b)
+  {
+    return a.x == b.x && a.y == b.y;
+  }
+
+  friend std::ostream &operator<<(std::ostream &stream, const double2 &v)
+  {
+    stream << "(" << v.x << ", " << v.y << ")";
+    return stream;
+  }
+
+  static double dot(const double2 &a, const double2 &b)
+  {
+    return a.x * b.x + a.y * b.y;
+  }
+
+  static double2 interpolate(const double2 &a, const double2 &b, double t)
+  {
+    return a * (1 - t) + b * t;
+  }
+
+  static double distance(const double2 &a, const double2 &b)
+  {
+    return (a - b).length();
+  }
+
+  static double distance_squared(const double2 &a, const double2 &b)
+  {
+    return double2::dot(a, b);
+  }
+
+  struct isect_result {
+    enum {
+      LINE_LINE_COLINEAR = -1,
+      LINE_LINE_NONE = 0,
+      LINE_LINE_EXACT = 1,
+      LINE_LINE_CROSS = 2,
+    } kind;
+    double lambda;
+    double mu;
+  };
+
+  static isect_result isect_seg_seg(const double2 &v1,
+                                    const double2 &v2,
+                                    const double2 &v3,
+                                    const double2 &v4);
+
+  static int orient2d(const double2 &a, const double2 &b, const double2 &c);
+
+  static int orient2d_fast(const double2 &a, const double2 &b, const double2 &c);
+
+  static int incircle(const double2 &a, const double2 &b, const double2 &c, const double2 &d);
+
+  static int incircle_fast(const double2 &a, const double2 &b, const double2 &c, const double2 &d);
+};
+
+}  // namespace BLI
+
+#endif /* __BLI_DOUBLE_HH__ */
diff --git a/source/blender/blenlib/BLI_double3.hh b/source/blender/blenlib/BLI_double3.hh
new file mode 100644
index 00000000000..d9926751e39
--- /dev/null
+++ b/source/blender/blenlib/BLI_double3.hh
@@ -0,0 +1,238 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_DOUBLE3_HH__
+#define __BLI_DOUBLE3_HH__
+
+#include <iostream>
+
+#include "BLI_math_vector.h"
+
+namespace BLI {
+
+struct double3 {
+  double x, y, z;
+
+  double3() = default;
+
+  double3(const double *ptr) : x{ptr[0]}, y{ptr[1]}, z{ptr[2]}
+  {
+  }
+
+  double3(const double (*ptr)[3]) : double3((const double *)ptr)
+  {
+  }
+
+  explicit double3(double value) : x(value), y(value), z(value)
+  {
+  }
+
+  explicit double3(int value) : x(value), y(value), z(value)
+  {
+  }
+
+  double3(double x, double y, double z) : x{x}, y{y}, z{z}
+  {
+  }
+
+  operator const double *() const
+  {
+    return &x;
+  }
+
+  operator double *()
+  {
+    return &x;
+  }
+
+  double normalize_and_get_length()
+  {
+    return normalize_v3_db(*this);
+  }
+
+  double3 normalized() const
+  {
+    double3 result;
+    normalize_v3_v3_db(result, *this);
+    return result;
+  }
+
+  double length() const
+  {
+    return len_v3_db(*this);
+  }
+
+  double length_squared() const
+  {
+    return len_squared_v3_db(*this);
+  }
+
+  void reflect(const double3 &normal)
+  {
+    *this = this->reflected(normal);
+  }
+
+  double3 reflected(const double3 &normal) const
+  {
+    double3 result;
+    reflect_v3_v3v3_db(result, *this, normal);
+    return result;
+  }
+
+  static double3 safe_divide(const double3 &a, const double3 &b)
+  {
+    double3 result;
+    result.x = (b.x == 0.0) ? 0.0 : a.x / b.x;
+    result.y = (b.y == 0.0) ? 0.0 : a.y / b.y;
+    result.z = (b.z == 0.0) ? 0.0 : a.z / b.z;
+    return result;
+  }
+
+  void invert()
+  {
+    x = -x;
+    y = -y;
+    z = -z;
+  }
+
+  friend double3 operator+(const double3 &a, const double3 &b)
+  {
+    return {a.x + b.x, a.y + b.y, a.z + b.z};
+  }
+
+  void operator+=(const double3 &b)
+  {
+    this->x += b.x;
+    this->y += b.y;
+    this->z += b.z;
+  }
+
+  friend double3 operator-(const double3 &a, const double3 &b)
+  {
+    return {a.x - b.x, a.y - b.y, a.z - b.z};
+  }
+
+  friend double3 operator-(const double3 &a)
+  {
+    return {-a.x, -a.y, -a.z};
+  }
+
+  void operator-=(const double3 &b)
+  {
+    this->x -= b.x;
+    this->y -= b.y;
+    this->z -= b.z;
+  }
+
+  void operator*=(const double &scalar)
+  {
+    this->x *= scalar;
+    this->y *= scalar;
+    this->z *= scalar;
+  }
+
+  void operator*=(const double3 &other)
+  {
+    this->x *= other.x;
+    this->y *= other.y;
+    this->z *= other.z;
+  }
+
+  friend double3 operator*(const double3 &a, const double3 &b)
+  {
+    return {a.x * b.x, a.y * b.y, a.z * b.z};
+  }
+
+  friend double3 operator*(const double3 &a, const double &b)
+  {
+    return {a.x * b, a.y * b, a.z * b};
+  }
+
+  friend double3 operator*(const double &a, const double3 &b)
+  {
+    return b * a;
+  }
+
+  friend double3 operator/(const double3 &a, const double &b)
+  {
+    BLI_assert(b != 0.0);
+    return {a.x / b, a.y / b, a.z / b};
+  }
+
+  friend bool operator==(const double3 &a, const double3 &b)
+  {
+    return a.x == b.x && a.y == b.y && a.z == b.z;
+  }
+
+  friend std::ostream &operator<<(std::ostream &stream, const double3 &v)
+  {
+    stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
+    return stream;
+  }
+
+  static double dot(const double3 &a, const double3 &b)
+  {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+  }
+
+  static double3 cross_high_precision(const double3 &a, const double3 &b)
+  {
+    double3 result;
+    cross_v3_v3v3_db(result, a, b);
+    return result;
+  }
+
+  static double3 project(const double3 &a, const double3 &b)
+  {
+    double3 result;
+    project_v3_v3v3_db(result, a, b);
+    return result;
+  }
+
+  static double distance(const double3 &a, const double3 &b)
+  {
+    return (a - b).length();
+  }
+
+  static double distance_squared(const double3 &a, const double3 &b)
+  {
+    return double3::dot(a, b);
+  }
+
+  static double3 interpolate(const double3 &a, const double3 &b, double t)
+  {
+    return a * (1 - t) + b * t;
+  }
+
+  /* orient3d gives the exact result, using multiprecision artihmetic when result
+   * is close to zero. orient3d_fast just uses double arithmetic, so may be
+   * wrong if the answer is very close to zero.
+   * Similarly, for insphere and insphere_fast.
+   */
+  static int orient3d(const double3 &a, const double3 &b, const double3 &c, const double3 &d);
+
+  static int orient3d_fast(const double3 &a, const double3 &b, const double3 &c, const double3 &d);
+
+  static int insphere(
+      const double3 &a, const double3 &b, const double3 &c, const double3 &d, const double3 &e);
+
+  static int insphere_fast(
+      const double3 &a, const double3 &b, const double3 &c, const double3 &d, const double3 &e);
+};
+
+}  // namespace BLI
+
+#endif /* __BLI_DOUBLE3_HH__ */
diff --git a/source/blender/blenlib/BLI_float2.hh b/source/blender/blenlib/BLI_float2.hh
index da12dd7d206..2bb5cf82214 100644
--- a/source/blender/blenlib/BLI_float2.hh
+++ b/source/blender/blenlib/BLI_float2.hh
@@ -48,6 +48,11 @@ struct float2 {
     return &x;
   }
 
+  float length() const
+  {
+    return len_v2(*this);
+  }
+
   friend float2 operator+(const float2 &a, const float2 &b)
   {
     return {a.x + b.x, a.y + b.y};
@@ -74,11 +79,52 @@ struct float2 {
     return b * a;
   }
 
+  friend bool operator==(const float2 &a, const float2 &b)
+  {
+    return a.x == b.x && a.y == b.y;
+  }
+
   friend std::ostream &operator<<(std::ostream &stream, const float2 &v)
   {
     stream << "(" << v.x << ", " << v.y << ")";
     return stream;
   }
+
+  static float dot(const float2 &a, const float2 &b)
+  {
+    return a.x * b.x + a.y * b.y;
+  }
+
+  static float2 interpolate(const float2 &a, const float2 &b, float t)
+  {
+    return a * (1 - t) + b * t;
+  }
+
+  static float distance(const float2 &a, const float2 &b)
+  {
+    return (a - b).length();
+  }
+
+  static float distance_squared(const float2 &a, const float2 &b)
+  {
+    return float2::dot(a, b);
+  }
+
+  struct isect_result {
+    enum {
+      LINE_LINE_COLINEAR = -1,
+      LINE_LINE_NONE = 0,
+      LINE_LINE_EXACT = 1,
+      LINE_LINE_CROSS = 2,
+    } kind;
+    float lambda;
+    float mu;
+  };
+
+  static isect_result isect_seg_seg(const float2 &v1,
+                                    const float2 &v2,
+                                    const float2 &v3,
+                                    const float2 &v4);
 };
 
 }  // namespace BLI
diff --git a/source/blender/blenlib/BLI_float3.hh b/source/blender/blenlib/BLI_float3.hh
index 9678fa4b2d3..db174a2e0e4 100644
--- a/source/blender/blenlib/BLI_float3.hh
+++ b/source/blender/blenlib/BLI_float3.hh
@@ -172,6 +172,11 @@ struct float3 {
     return {a.x / b, a.y / b, a.z / b};
   }
 
+  friend bool operator==(const float3 &a, const float3 &b)
+  {
+    return a.x == b.x && a.y == b.y && a.z == b.z;
+  }
+
   friend std::ostream &operator<<(std::ostream &stream, const float3 &v)
   {
     stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
diff --git a/source/blender/blenlib/BLI_math_base.h b/source/blender/blenlib/BLI_math_base.h
index d74b6295002..279f248e8c7 100644
--- a/source/blender/blenlib/BLI_math_base.h
+++ b/source/blender/blenlib/BLI_math_base.h
@@ -288,7 +288,6 @@ double double_round(double x, int ndigits);
 #else
 #  define BLI_ASSERT_UNIT_V2(v) (void)(v)
 #  define BLI_ASSERT_UNIT_V3(v) (void)(v)
-#  define BLI_ASSERT_UNIT_V3_DB(v) (void)(v)
 #  define BLI_ASSERT_UNIT_QUAT(v) (void)(v)
 #  define BLI_ASSERT_ZERO_M3(m) (void)(m)
 #  define BLI_ASSERT_ZERO_M4(m) (void)(m)
diff --git a/source/blender/blenlib/BLI_math_geom.h b/source/blender/blenlib/BLI_math_geom.h
index fb976dcf09b..563bcad5d14 100644
--- a/source/blender/blenlib/BLI_math_geom.h
+++ b/source/blender/blenlib/BLI_math_geom.h
@@ -42,7 +42,6 @@ extern "C" {
 /********************************** Polygons *********************************/
 
 float normal_tri_v3(float r[3], const float a[3], const float b[3], const float c[3]);
-double normal_tri_v3_db(double r[3], const double a[3], const double b[3], const double c[3]);
 float normal_quad_v3(
     float r[3], const float a[3], const float b[3], const float c[3], const float d[3]);
 float normal_poly_v3(float r[3], const float verts[][3], unsigned int nr);
@@ -81,7 +80,6 @@ void plane_to_point_vector_v3_normalized(const float plane[4],
                                          float r_plane_no[3]);
 
 MINLINE float plane_point_side_v3(const float plane[4], const float co[3]);
-MINLINE double plane_point_side_v3_db(const double plane[4], const double co[3]);
 
 /********************************* Volume **********************************/
 
@@ -116,7 +114,6 @@ float dist_to_line_segment_v2(const float p[2], const float l1[2], const float l
 
 float dist_signed_squared_to_plane_v3(const float p[3], const float plane[4]);
 float dist_squared_to_plane_v3(const float p[3], const float plane[4]);
-double dist_squared_to_plane_normalized_v3_db(const double pt[3], const double plane[4]);
 float dist_signed_to_plane_v3(const float p[3], const float plane[4]);
 float dist_to_plane_v3(const float p[3], const float plane[4]);
 
@@ -129,7 +126,6 @@ float dist_to_plane3_v3(const float p[3], const float plane[4]);
 float dist_squared_to_line_segment_v3(const float p[3], const float l1[3], const float l2[3]);
 float dist_to_line_segment_v3(const float p[3], const float l1[3], const float l2[3]);
 float dist_squared_to_line_v3(const float p[3], const float l1[3], const float l2[3]);
-double dist_squared_to_line_v3_db(const double p[3], const double l1[3], const double l2[3]);
 float dist_to_line_v3(const float p[3], const float l1[3], const float l2[3]);
 float dist_signed_squared_to_corner_v3v3v3(const float p[3],
                                            const float v1[3],
@@ -200,10 +196,6 @@ double closest_to_line_v2_db(double r_close[2],
                              const double l1[2],
                              const double l2[2]);
 float closest_to_line_v3(float r_close[3], const float p[3], const float l1[3], const float l2[3]);
-double closest_to_line_v3_db(double r_close[3],
-                             const double p[3],
-                             const double l1[3],
-                             const double l2[3]);
 void closest_to_line_segment_v2(float r_close[2],
                                 const float p[2],
                                 const float l1[2],
@@ -215,9 +207,6 @@ void closest_to_line_segment_v3(float r_close[3],
 void closest_to_plane_normalized_v3(float r_close[3], const float plane[4], const float pt[3]);
 void closest_to_plane_v3(float r_close[3], const float plane[4], const float pt[3]);
 void closest_to_plane3_normalized_v3(float r_close[3], const float plane[3], const float pt[3]);
-void closest_to_plane3_normalized_v3_db(double r_close[3],
-                                        const double plane[3],
-                                        const double pt[3]);
 void closest_to_plane3_v3(float r_close[3], const float plane[3], const float pt[3]);
 
 /* Set 'r' to the point in triangle (t1, t2, t3) closest to point 'p' */
@@ -238,11 +227,6 @@ float line_point_factor_v3_ex(const float p[3],
                               const float l2[3],
                               const float epsilon,
                               const float fallback);
-double line_point_factor_v3_ex_db(const double p[3],
-                                  const double l1[3],
-                                  const double l2[3],
-                                  const double epsilon,
-                                  const double fallback);
 float line_point_factor_v3(const float p[3], const float l1[3], const float l2[3]);
 
 float line_point_factor_v2_ex(const float p[2],
@@ -318,25 +302,12 @@ int isect_line_line_epsilon_v3(const float v1[3],
                                float i1[3],
                                float i2[3],
                                const float epsilon);
-int isect_line_line_epsilon_v3_db(const double v1[3],
-                                  const double v2[3],
-                                  const double v3[3],
-                                  const double v4[3],
-                                  double i1[3],
-                                  double i2[3],
-                                  const double epsilon);
 int isect_line_line_v3(const float v1[3],
                        const float v2[3],
                        const float v3[3],
                        const float v4[3],
                        float r_i1[3],
                        float r_i2[3]);
-int isect_line_line_v3_db(const double v1[3],
-                          const double v2[3],
-                          const double v3[3],
-                          const double v4[3],
-                          double r_i1[3],
-                          double r_i2[3]);
 bool isect_line_line_strict_v3(const float v1[3],
                                const float v2[3],
                                const float v3[3],
@@ -380,10 +351,6 @@ bool isect_plane_plane_v3(const float plane_a[4],
                           const float plane_b[4],
                           float r_isect_co[3],
                           float r_isect_no[3]) ATTR_WARN_UNUSED_RESULT;
-bool isect_plane_plane_v3_db(const double plane_a[4],
-                             const double plane_b[4],
-                             double r_isect_co[3],
-                             double r_isect_no[3]) ATTR_WARN_UNUSED_RESULT;
 
 /* line/ray triangle */
 bool isect_line_segment_tri_v3(const float p1[3],
@@ -524,10 +491,6 @@ bool isect_aabb_aabb_v3(const float min1[3],
                         const float max1[3],
                         const float min2[3],
                         const float max2[3]);
-bool isect_aabb_aabb_v3_db(const double min1[3],
-                           const double max1[3],
-                           const double min2[3],
-                           const double max2[3]);
 
 struct IsectRayAABB_Precalc {
   float ray_origin[3];
@@ -815,7 +778,6 @@ float form_factor_hemi_poly(
 
 void axis_dominant_v3_to_m3_negate(float r_mat[3][3], const float normal[3]);
 void axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3]);
-void axis_dominant_v3_to_m3_db(double r_mat[3][3], const double normal[3]);
 
 MINLINE void axis_dominant_v3(int *r_axis_a, int *r_axis_b, const float axis[3]);
 MINLINE float axis_dominant_v3_max(int *r_axis_a,
diff --git a/source/blender/blenlib/BLI_math_matrix.h b/source/blender/blenlib/BLI_math_matrix.h
index 879c1b720e4..2d11797bc34 100644
--- a/source/blender/blenlib/BLI_math_matrix.h
+++ b/source/blender/blenlib/BLI_math_matrix.h
@@ -226,7 +226,6 @@ bool invert_m3_m3_ex(float m1[3][3], const float m2[3][3], const float epsilon);
 
 bool invert_m3(float R[3][3]);
 bool invert_m3_m3(float R[3][3], const float A[3][3]);
-bool invert_m3_m3_db(double R[3][3], const double A[3][3]);
 bool invert_m4(float R[4][4]);
 bool invert_m4_m4(float R[4][4], const float A[4][4]);
 bool invert_m4_m4_fallback(float R[4][4], const float A[4][4]);
@@ -242,7 +241,6 @@ void mul_m3_v3_db(const double M[3][3], double r[3]);
 /****************************** Linear Algebra *******************************/
 
 void transpose_m3(float R[3][3]);
-void transpose_m3_db(double R[3][3]);
 void transpose_m3_m3(float R[3][3], const float A[3][3]);
 void transpose_m3_m4(float R[3][3], const float A[4][4]);
 void transpose_m4(float R[4][4]);
@@ -283,14 +281,12 @@ bool is_uniform_scaled_m4(const float m[4][4]);
  */
 void adjoint_m2_m2(float R[2][2], const float A[2][2]);
 void adjoint_m3_m3(float R[3][3], const float A[3][3]);
-void adjoint_m3_m3_db(double R[3][3], const double A[3][3]);
 void adjoint_m4_m4(float R[4][4], const float A[4][4]);
 
 float determinant_m2(float a, float b, float c, float d);
 float determinant_m3(
     float a, float b, float c, float d, float e, float f, float g, float h, float i);
 float determinant_m3_array(const float m[3][3]);
-double determinant_m3_array_db(const double m[3][3]);
 float determinant_m4_mat3_array(const float m[4][4]);
 float determinant_m4(const float A[4][4]);
 
diff --git a/source/blender/blenlib/BLI_math_mpq.hh b/source/blender/blenlib/BLI_math_mpq.hh
new file mode 100644
index 00000000000..ede30da29b8
--- /dev/null
+++ b/source/blender/blenlib/BLI_math_mpq.hh
@@ -0,0 +1,26 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_MATH_MPQ_HH__
+#define __BLI_MATH_MPQ_HH__
+
+#include "gmpxx.h"
+
+namespace BLI {
+
+}  // namespace BLI
+
+#endif /* __BLI_MATH_NPQ_HH__ */
diff --git a/source/blender/blenlib/BLI_math_vector.h b/source/blender/blenlib/BLI_math_vector.h
index 46f83604e5a..b4b0265ca6f 100644
--- a/source/blender/blenlib/BLI_math_vector.h
+++ b/source/blender/blenlib/BLI_math_vector.h
@@ -82,8 +82,6 @@ MINLINE void copy_v3_v3_int(int r[3], const int a[3]);
 MINLINE void copy_v4_v4_int(int r[4], const int a[4]);
 /* double */
 MINLINE void zero_v3_db(double r[3]);
-MINLINE void zero_v4_db(double r[4]);
-MINLINE void copy_v3_db(double r[3], double d);
 MINLINE void copy_v2_v2_db(double r[2], const double a[2]);
 MINLINE void copy_v3_v3_db(double r[3], const double a[3]);
 MINLINE void copy_v4_v4_db(double r[4], const double a[4]);
@@ -118,7 +116,6 @@ MINLINE void add_v2_v2v2_int(int r[2], const int a[2], const int b[2]);
 MINLINE void add_v3_v3(float r[3], const float a[3]);
 MINLINE void add_v3_v3_db(double r[3], const double a[3]);
 MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3]);
-MINLINE void add_v3_v3v3_db(double r[3], const double a[3], const double b[3]);
 MINLINE void add_v4_v4(float r[4], const float a[4]);
 MINLINE void add_v4_v4v4(float r[4], const float a[4], const float b[4]);
 
@@ -142,9 +139,8 @@ MINLINE void mul_v2_fl(float r[2], float f);
 MINLINE void mul_v2_v2fl(float r[2], const float a[2], float f);
 MINLINE void mul_v3_fl(float r[3], float f);
 MINLINE void mul_v3db_db(double r[3], double f);
-MINLINE void mul_v3db_db(double r[3], double f);
 MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f);
-MINLINE void mul_v3db_v3dbdb(double r[3], const double a[3], double f);
+MINLINE void mul_v3_v3db_db(double r[3], const double a[3], double f);
 MINLINE void mul_v2_v2(float r[2], const float a[2]);
 MINLINE void mul_v2_v2v2(float r[2], const float a[2], const float b[2]);
 MINLINE void mul_v3_v3(float r[3], const float a[3]);
@@ -165,12 +161,9 @@ MINLINE float dot_m4_v3_row_z(const float M[4][4], const float a[3]) ATTR_WARN_U
 
 MINLINE void madd_v2_v2fl(float r[2], const float a[2], float f);
 MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f);
-MINLINE void madd_v3db_v3dbdb(double r[3], const double a[3], double f);
 MINLINE void madd_v3_v3v3(float r[3], const float a[3], const float b[3]);
-MINLINE void madd_v3_v3v3_db(double r[3], const double a[3], const double b[3]);
 MINLINE void madd_v2_v2v2fl(float r[2], const float a[2], const float b[2], float f);
 MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f);
-MINLINE void madd_v3_v3v3db_db(double r[3], const double a[3], const double b[3], double f);
 MINLINE void madd_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3]);
 MINLINE void madd_v4_v4fl(float r[4], const float a[4], float f);
 MINLINE void madd_v4_v4v4(float r[4], const float a[4], const float b[4]);
@@ -224,40 +217,40 @@ MINLINE void star_m3_v3(float rmat[3][3], float a[3]);
 /*********************************** Length **********************************/
 
 MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT;
-MINLINE double len_squared_v2_db(const double v[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
-MINLINE double len_squared_v3_db(const double v[3]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_manhattan_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE int len_manhattan_v2_int(const int v[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_manhattan_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_v2(const float a[2]) ATTR_WARN_UNUSED_RESULT;
+MINLINE double len_v2_db(const double a[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE double len_v2v2_db(const double a[2], const double b[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_v2v2_int(const int v1[2], const int v2[2]);
 MINLINE float len_squared_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE double len_squared_v2v2_db(const double a[2], const double b[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT;
-MINLINE double len_squared_v3v3_db(const double a[3], const double b[3]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_squared_v4v4(const float a[4], const float b[4]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_manhattan_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE int len_manhattan_v2v2_int(const int a[2], const int b[2]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_manhattan_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT;
-MINLINE double len_v3_db(const double a[3]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT;
-MINLINE double len_v3v3_db(const double a[3], const double b[3]) ATTR_WARN_UNUSED_RESULT;
 
+MINLINE double len_v3_db(const double a[3]) ATTR_WARN_UNUSED_RESULT;
+MINLINE double len_squared_v3_db(const double v[3]) ATTR_WARN_UNUSED_RESULT;
 MINLINE float normalize_v2_length(float r[2], const float unit_scale);
 MINLINE float normalize_v2_v2_length(float r[2], const float a[2], const float unit_scale);
 MINLINE float normalize_v3_length(float r[3], const float unit_scale);
 MINLINE float normalize_v3_v3_length(float r[3], const float a[3], const float unit_scale);
-MINLINE double normalize_v3_length_d(double n[3], const double unit_scale);
+MINLINE double normalize_v3_length_db(double n[3], const double unit_scale);
+MINLINE double normalize_v3_v3_length_db(double r[3], const double a[3], const double unit_scale);
 
 MINLINE float normalize_v2(float r[2]);
 MINLINE float normalize_v2_v2(float r[2], const float a[2]);
 MINLINE float normalize_v3(float r[3]);
 MINLINE float normalize_v3_v3(float r[3], const float a[3]);
-MINLINE double normalize_v3_d(double n[3]);
+MINLINE double normalize_v3_v3_db(double r[3], const double a[3]);
+MINLINE double normalize_v3_db(double n[3]);
 
 /******************************* Interpolation *******************************/
 
@@ -351,9 +344,6 @@ MINLINE bool compare_v2v2(const float a[2],
 MINLINE bool compare_v3v3(const float a[3],
                           const float b[3],
                           const float limit) ATTR_WARN_UNUSED_RESULT;
-MINLINE bool compare_v3v3_db(const double a[3],
-                             const double b[3],
-                             const double limit) ATTR_WARN_UNUSED_RESULT;
 MINLINE bool compare_v4v4(const float a[4],
                           const float b[4],
                           const float limit) ATTR_WARN_UNUSED_RESULT;
@@ -379,10 +369,6 @@ MINLINE float line_point_side_v2(const float l1[2],
                                  const float l2[2],
                                  const float pt[2]) ATTR_WARN_UNUSED_RESULT;
 
-MINLINE double line_point_side_v2_db(const double l1[2],
-                                     const double l2[2],
-                                     const double pt[2]) ATTR_WARN_UNUSED_RESULT;
-
 /********************************** Angles ***********************************/
 /* - angle with 2 arguments is angle between vector                          */
 /* - angle with 3 arguments is angle between 3 points at the middle point    */
@@ -426,14 +412,11 @@ void project_v3_v3v3_normalized(float out[3], const float p[3], const float v_pr
 void project_plane_v3_v3v3(float out[3], const float p[3], const float v_plane[3]);
 void project_plane_v2_v2v2(float out[2], const float p[2], const float v_plane[2]);
 void project_plane_normalized_v3_v3v3(float out[3], const float p[3], const float v_plane[3]);
-void project_plane_normalized_v3_v3v3_db(double out[3],
-                                         const double p[3],
-                                         const double v_plane[3]);
 void project_plane_normalized_v2_v2v2(float out[2], const float p[2], const float v_plane[2]);
 void project_v3_plane(float out[3], const float plane_no[3], const float plane_co[3]);
 void reflect_v3_v3v3(float out[3], const float vec[3], const float normal[3]);
+void reflect_v3_v3v3_db(double out[3], const double vec[3], const double normal[3]);
 void ortho_basis_v3v3_v3(float r_n1[3], float r_n2[3], const float n[3]);
-void ortho_basis_v3v3_v3_db(double r_n1[3], double r_n2[3], const double n[3]);
 void ortho_v3_v3(float out[3], const float v[3]);
 void ortho_v2_v2(float out[2], const float v[2]);
 void bisect_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3]);
diff --git a/source/blender/blenlib/BLI_mesh_intersect.hh b/source/blender/blenlib/BLI_mesh_intersect.hh
new file mode 100644
index 00000000000..77addf51f0e
--- /dev/null
+++ b/source/blender/blenlib/BLI_mesh_intersect.hh
@@ -0,0 +1,122 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_MESH_INTERSECT_HH__
+#define __BLI_MESH_INTERSECT_HH__
+
+/** \file
+ * \ingroup bli
+ *
+ *  Work in progress on mesh intersection library function.
+ */
+
+#include <iostream>
+
+#include "gmpxx.h"
+
+#include "BLI_array.hh"
+#include "BLI_mpq3.hh"
+#include "BLI_vector.hh"
+
+namespace BLI {
+
+namespace MeshIntersect {
+
+/* The indices are for vertices in some external space of coordinates.
+ * The "orig" component is used to track how a triangle originally came
+ * from some other space of triangle indices. Which we usually need,
+ * and it packs nicely into this structure, so keeping it here will save
+ * memory.
+ */
+struct IndexedTriangle {
+  IndexedTriangle() : m_v{-1, -1, -1}, m_orig{-1}
+  {
+  }
+  IndexedTriangle(int v0, int v1, int v2, int orig) : m_v{v0, v1, v2}, m_orig{orig}
+  {
+  }
+  IndexedTriangle(const IndexedTriangle &other) : m_orig{other.m_orig}
+  {
+    for (int i = 0; i < 3; ++i) {
+      this->m_v[i] = other.m_v[i];
+    }
+  }
+
+  int v0() const
+  {
+    return m_v[0];
+  }
+  int v1() const
+  {
+    return m_v[1];
+  }
+  int v2() const
+  {
+    return m_v[2];
+  }
+  int orig() const
+  {
+    return m_orig;
+  }
+  int operator[](int i) const
+  {
+    return m_v[i];
+  }
+  int &operator[](int i)
+  {
+    return m_v[i];
+  }
+
+ private:
+  int m_v[3];
+  int m_orig;
+};
+
+struct TriMesh {
+  Array<mpq3> vert;
+  Array<IndexedTriangle> tri;
+
+  TriMesh() = default;
+};
+
+/* The output will have dup vertices merged and degenerate triangles ignored.
+ * If the input has overlapping coplanar triangles, then there will be
+ * as many duplicates as there are overlaps in each overlapping triangular region.
+ * The orig field of each IndexedTriangle will give the orig index in the input TriMesh
+ * that the output triangle was a part of (input can have -1 for that field and then
+ * the index in tri[] will be used as the original index).
+ */
+TriMesh trimesh_self_intersect(const TriMesh &tm_in);
+
+/* For debugging output. */
+std::ostream &operator<<(std::ostream &os, const IndexedTriangle &tri);
+
+std::ostream &operator<<(std::ostream &os, const TriMesh &tm);
+
+void write_html_trimesh(const Array<mpq3> &vert,
+                        const Array<IndexedTriangle> &tri,
+                        const std::string &fname,
+                        const std::string &label);
+
+void write_obj_trimesh(const Array<mpq3> &vert,
+                       const Array<IndexedTriangle> &tri,
+                       const std::string &objname);
+
+} /* namespace MeshIntersect */
+
+} /* namespace BLI */
+
+#endif /* __BLI_MESH_INTERSECT_HH__ */
diff --git a/source/blender/blenlib/BLI_mpq2.hh b/source/blender/blenlib/BLI_mpq2.hh
new file mode 100644
index 00000000000..48c9aa9580d
--- /dev/null
+++ b/source/blender/blenlib/BLI_mpq2.hh
@@ -0,0 +1,143 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_MPQ2_HH__
+#define __BLI_MPQ2_HH__
+
+#include "gmpxx.h"
+
+#include "BLI_math_mpq.hh"
+#include "BLI_mpq3.hh"
+
+namespace BLI {
+
+struct mpq2 {
+  mpq_class x, y;
+
+  mpq2() = default;
+
+  mpq2(const mpq_class *ptr) : x{ptr[0]}, y{ptr[1]}
+  {
+  }
+
+  mpq2(mpq_class x, mpq_class y) : x(x), y(y)
+  {
+  }
+
+  mpq2(const mpq3 &other) : x(other.x), y(other.y)
+  {
+  }
+
+  operator mpq_class *()
+  {
+    return &x;
+  }
+
+  operator const mpq_class *() const
+  {
+    return &x;
+  }
+
+  /* Cannot do this exactly in rational arithmetic!
+   * Approximate by going in and out of doubles.
+   */
+  mpq_class length() const
+  {
+    mpq_class lsquared = dot(*this, *this);
+    return mpq_class(sqrt(lsquared.get_d()));
+  }
+
+  friend mpq2 operator+(const mpq2 &a, const mpq2 &b)
+  {
+    return {a.x + b.x, a.y + b.y};
+  }
+
+  friend mpq2 operator-(const mpq2 &a, const mpq2 &b)
+  {
+    return {a.x - b.x, a.y - b.y};
+  }
+
+  friend mpq2 operator*(const mpq2 &a, mpq_class b)
+  {
+    return {a.x * b, a.y * b};
+  }
+
+  friend mpq2 operator/(const mpq2 &a, mpq_class b)
+  {
+    BLI_assert(b != 0);
+    return {a.x / b, a.y / b};
+  }
+
+  friend mpq2 operator*(mpq_class a, const mpq2 &b)
+  {
+    return b * a;
+  }
+
+  friend bool operator==(const mpq2 &a, const mpq2 &b)
+  {
+    return a.x == b.x && a.y == b.y;
+  }
+
+  friend std::ostream &operator<<(std::ostream &stream, const mpq2 &v)
+  {
+    stream << "(" << v.x << ", " << v.y << ")";
+    return stream;
+  }
+
+  static mpq_class dot(const mpq2 &a, const mpq2 &b)
+  {
+    return a.x * b.x + a.y * b.y;
+  }
+
+  static mpq2 interpolate(const mpq2 &a, const mpq2 &b, mpq_class t)
+  {
+    return a * (1 - t) + b * t;
+  }
+
+  static mpq_class distance(const mpq2 &a, const mpq2 &b)
+  {
+    return (a - b).length();
+  }
+
+  static mpq_class distance_squared(const mpq2 &a, const mpq2 &b)
+  {
+    return dot(a, b);
+  }
+
+  struct isect_result {
+    enum {
+      LINE_LINE_COLINEAR = -1,
+      LINE_LINE_NONE = 0,
+      LINE_LINE_EXACT = 1,
+      LINE_LINE_CROSS = 2,
+    } kind;
+    mpq_class lambda;
+    mpq_class mu;
+  };
+
+  static isect_result isect_seg_seg(const mpq2 &v1,
+                                    const mpq2 &v2,
+                                    const mpq2 &v3,
+                                    const mpq2 &v4);
+
+  static int orient2d(const mpq2 &a, const mpq2 &b, const mpq2 &c);
+
+  static int incircle(const mpq2 &a, const mpq2 &b, const mpq2 &c, const mpq2 &d);
+};
+
+}  // namespace BLI
+
+#endif /* __BLI_MPQ_HH__ */
diff --git a/source/blender/blenlib/BLI_mpq3.hh b/source/blender/blenlib/BLI_mpq3.hh
new file mode 100644
index 00000000000..ca556e46e83
--- /dev/null
+++ b/source/blender/blenlib/BLI_mpq3.hh
@@ -0,0 +1,257 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __BLI_MPQ3_HH__
+#define __BLI_MPQ3_HH__
+
+#include <iostream>
+
+#include "BLI_math.h"
+#include "BLI_math_mpq.hh"
+#include "gmpxx.h"
+
+namespace BLI {
+
+struct mpq3 {
+  mpq_class x, y, z;
+
+  mpq3() = default;
+
+  mpq3(const mpq_class *ptr) : x{ptr[0]}, y{ptr[1]}, z{ptr[2]}
+  {
+  }
+
+  mpq3(const mpq_class (*ptr)[3]) : mpq3((const mpq_class *)ptr)
+  {
+  }
+
+  explicit mpq3(mpq_class value) : x(value), y(value), z(value)
+  {
+  }
+
+  explicit mpq3(int value) : x(value), y(value), z(value)
+  {
+  }
+
+  mpq3(mpq_class x, mpq_class y, mpq_class z) : x{x}, y{y}, z{z}
+  {
+  }
+
+  operator const mpq_class *() const
+  {
+    return &x;
+  }
+
+  operator mpq_class *()
+  {
+    return &x;
+  }
+
+  /* Cannot do this exactly in rational arithmetic!
+   * Approximate by going in and out of doubles.
+   */
+  mpq_class normalize_and_get_length()
+  {
+    double dv[3] = {x.get_d(), y.get_d(), z.get_d()};
+    double len = normalize_v3_db(dv);
+    this->x = mpq_class(dv[0]);
+    this->y = mpq_class(dv[1]);
+    this->z = mpq_class(dv[2]);
+    return len;
+  }
+
+  mpq3 normalized() const
+  {
+    double dv[3] = {x.get_d(), y.get_d(), z.get_d()};
+    double dr[3];
+    normalize_v3_v3_db(dr, dv);
+    return mpq3(mpq_class(dr[0]), mpq_class(dr[1]), mpq_class(dr[2]));
+  }
+
+  /* Cannot do this exactly in rational arithmetic!
+   * Approximate by going in and out of double.
+   */
+  mpq_class length() const
+  {
+    mpq_class lsquared = this->length_squared();
+    double dsquared = lsquared.get_d();
+    double d = sqrt(dsquared);
+    return mpq_class(d);
+  }
+
+  mpq_class length_squared() const
+  {
+    return x * x + y * y + z * z;
+  }
+
+  void reflect(const mpq3 &normal)
+  {
+    *this = this->reflected(normal);
+  }
+
+  mpq3 reflected(const mpq3 &normal) const
+  {
+    mpq3 result;
+    const mpq_class dot2 = 2 * dot(*this, normal);
+    result.x = this->x - (dot2 * normal.x);
+    result.y = this->y - (dot2 * normal.y);
+    result.z = this->z - (dot2 * normal.z);
+    return result;
+  }
+
+  static mpq3 safe_divide(const mpq3 &a, const mpq3 &b)
+  {
+    mpq3 result;
+    result.x = (b.x == 0) ? mpq_class(0) : a.x / b.x;
+    result.y = (b.y == 0) ? mpq_class(0) : a.y / b.y;
+    result.z = (b.z == 0) ? mpq_class(0) : a.z / b.z;
+    return result;
+  }
+
+  void invert()
+  {
+    x = -x;
+    y = -y;
+    z = -z;
+  }
+
+  friend mpq3 operator+(const mpq3 &a, const mpq3 &b)
+  {
+    return mpq3(a.x + b.x, a.y + b.y, a.z + b.z);
+  }
+
+  void operator+=(const mpq3 &b)
+  {
+    this->x += b.x;
+    this->y += b.y;
+    this->z += b.z;
+  }
+
+  friend mpq3 operator-(const mpq3 &a, const mpq3 &b)
+  {
+    return mpq3(a.x - b.x, a.y - b.y, a.z - b.z);
+  }
+
+  friend mpq3 operator-(const mpq3 &a)
+  {
+    return mpq3(-a.x, -a.y, -a.z);
+  }
+
+  void operator-=(const mpq3 &b)
+  {
+    this->x -= b.x;
+    this->y -= b.y;
+    this->z -= b.z;
+  }
+
+  void operator*=(mpq_class scalar)
+  {
+    this->x *= scalar;
+    this->y *= scalar;
+    this->z *= scalar;
+  }
+
+  void operator*=(const mpq3 &other)
+  {
+    this->x *= other.x;
+    this->y *= other.y;
+    this->z *= other.z;
+  }
+
+  friend mpq3 operator*(const mpq3 &a, const mpq3 &b)
+  {
+    return {a.x * b.x, a.y * b.y, a.z * b.z};
+  }
+
+  friend mpq3 operator*(const mpq3 &a, const mpq_class &b)
+  {
+    return mpq3(a.x * b, a.y * b, a.z * b);
+  }
+
+  friend mpq3 operator*(const mpq_class &a, const mpq3 &b)
+  {
+    return mpq3(a * b.x, a * b.y, a * b.z);
+  }
+
+  friend mpq3 operator/(const mpq3 &a, const mpq_class &b)
+  {
+    BLI_assert(b != 0);
+    return mpq3(a.x / b, a.y / b, a.z / b);
+  }
+
+  friend bool operator==(const mpq3 &a, const mpq3 &b)
+  {
+    return a.x == b.x && a.y == b.y && a.z == b.z;
+  }
+
+  friend std::ostream &operator<<(std::ostream &stream, const mpq3 &v)
+  {
+    stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
+    return stream;
+  }
+
+  static mpq_class dot(const mpq3 &a, const mpq3 &b)
+  {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+  }
+
+  static mpq3 cross(const mpq3 &a, const mpq3 &b)
+  {
+    return mpq3(a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]);
+  }
+
+  static mpq3 cross_high_precision(const mpq3 &a, const mpq3 &b)
+  {
+    return cross(a, b);
+  }
+
+  static mpq3 project(const mpq3 &a, const mpq3 &b)
+  {
+    const mpq_class mul = mpq3::dot(a, b) / mpq3::dot(b, b);
+    return mpq3(mul * b[0], mul * b[1], mul * b[2]);
+  }
+
+  static mpq_class distance(const mpq3 &a, const mpq3 &b)
+  {
+    mpq3 diff(a.x - b.x, a.y - b.y, a.z - b.z);
+    return diff.length();
+  }
+
+  static mpq_class distance_squared(const mpq3 &a, const mpq3 &b)
+  {
+    return mpq3::dot(a, b);
+  }
+
+  static mpq3 interpolate(const mpq3 &a, const mpq3 &b, mpq_class t)
+  {
+    mpq_class s = 1 - t;
+    return mpq3(a.x * s + b.x * t, a.y * s + b.y * t, a.z * s + b.z * t);
+  }
+
+  static int dominant_axis(const mpq3 &a)
+  {
+    mpq_class x = abs(a[0]);
+    mpq_class y = abs(a[1]);
+    mpq_class z = abs(a[2]);
+    return ((x > y) ? ((x > z) ? 0 : 2) : ((y > z) ? 1 : 2));
+  }
+
+  static int orient3d(const mpq3 &a, const mpq3 &b, const mpq3 &c, const mpq3 &d);
+};
+
+}  // namespace BLI
+
+#endif /* __BLI_MPQ3_HH__ */
diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt
index 7757b838afe..f09291ecf03 100644
--- a/source/blender/blenlib/CMakeLists.txt
+++ b/source/blender/blenlib/CMakeLists.txt
@@ -32,6 +32,7 @@ set(INC
 set(INC_SYS
   ${ZLIB_INCLUDE_DIRS}
   ${FREETYPE_INCLUDE_DIRS}
+  ${GMP_INCLUDE_DIRS}
 )
 
 set(SRC
@@ -60,10 +61,11 @@ set(SRC
   intern/astar.c
   intern/bitmap.c
   intern/bitmap_draw_2d.c
+  intern/boolean.cc
   intern/boxpack_2d.c
   intern/buffer.c
   intern/convexhull_2d.c
-  intern/delaunay_2d.c
+  intern/delaunay_2d.cc
   intern/dot_export.cc
   intern/dynlib.c
   intern/easing.c
@@ -97,9 +99,11 @@ set(SRC
   intern/math_rotation.c
   intern/math_solvers.c
   intern/math_statistics.c
+  intern/math_vec.cc
   intern/math_vector.c
   intern/math_vector_inline.c
   intern/memory_utils.c
+  intern/mesh_intersect.cc
   intern/noise.c
   intern/path_util.c
   intern/polyfill_2d.c
@@ -154,6 +158,7 @@ set(SRC
   BLI_bitmap.h
   BLI_bitmap_draw_2d.h
   BLI_blenlib.h
+  BLI_boolean.h
   BLI_boxpack_2d.h
   BLI_buffer.h
   BLI_color.hh
@@ -167,6 +172,8 @@ set(SRC
   BLI_dlrbTree.h
   BLI_dot_export.hh
   BLI_dot_export_attribute_enums.hh
+  BLI_double2.hh
+  BLI_double3.hh
   BLI_dynlib.h
   BLI_dynstr.h
   BLI_easing.h
@@ -211,6 +218,7 @@ set(SRC
   BLI_math_geom.h
   BLI_math_inline.h
   BLI_math_interp.h
+  BLI_math_mpq.hh
   BLI_math_matrix.h
   BLI_math_rotation.h
   BLI_math_solvers.h
@@ -222,6 +230,9 @@ set(SRC
   BLI_memory_utils.h
   BLI_memory_utils.hh
   BLI_mempool.h
+  BLI_mesh_intersect.hh
+  BLI_mpq2.hh
+  BLI_mpq3.hh
   BLI_noise.h
   BLI_open_addressing.hh
   BLI_optional.hh
@@ -293,6 +304,18 @@ if(WITH_TBB)
   )
 endif()
 
+if(WITH_GMP)
+  add_definitions(-DWITH_GMP)
+
+  list(APPEND INC_SYS
+    ${GMP_INCLUDE_DIRS}
+  )
+
+  list(APPEND LIB
+    ${GMP_LIBRARIES}
+  )
+endif()
+
 if(WIN32)
   list(APPEND INC
     ../../../intern/utfconv
diff --git a/source/blender/blenlib/intern/boolean.cc b/source/blender/blenlib/intern/boolean.cc
new file mode 100644
index 00000000000..ae4422dabec
--- /dev/null
+++ b/source/blender/blenlib/intern/boolean.cc
@@ -0,0 +1,93 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include <iostream>
+
+#include "gmpxx.h"
+
+#include "BLI_array.hh"
+#include "BLI_assert.h"
+#include "BLI_mesh_intersect.hh"
+#include "BLI_mpq3.hh"
+
+#include "BLI_boolean.h"
+
+namespace BLI {
+namespace MeshIntersect {
+
+static TriMesh self_boolean(const TriMesh &tm_in, int bool_optype)
+{
+  constexpr int dbg_level = 0;
+  if (dbg_level > 0) {
+    std::cout << "\nSELF_BOOLEAN op=" << bool_optype << "\n";
+  }
+  TriMesh tm_si = trimesh_self_intersect(tm_in);
+  return tm_si;
+}
+
+} /* namespace MeshIntersect */
+} /* namespace BLI */
+
+extern "C" Boolean_trimesh_output *BLI_boolean_trimesh(const Boolean_trimesh_input *input,
+                                                       int bool_optype)
+{
+  constexpr int dbg_level = 1;
+  BLI::MeshIntersect::TriMesh tm_in;
+  tm_in.vert = BLI::Array<BLI::mpq3>(input->vert_len);
+  for (int v = 0; v < input->vert_len; ++v) {
+    tm_in.vert[v] = BLI::mpq3(
+        input->vert_coord[v][0], input->vert_coord[v][1], input->vert_coord[v][2]);
+  }
+  tm_in.tri = BLI::Array<BLI::MeshIntersect::IndexedTriangle>(input->tri_len);
+  for (int t = 0; t < input->tri_len; ++t) {
+    tm_in.tri[t] = BLI::MeshIntersect::IndexedTriangle(
+        input->tri[t][0], input->tri[t][1], input->tri[t][2], t);
+  }
+  BLI::MeshIntersect::TriMesh tm_out = self_boolean(tm_in, bool_optype);
+  if (dbg_level > 0) {
+    BLI::MeshIntersect::write_html_trimesh(
+        tm_out.vert, tm_out.tri, "mesh_boolean_test.html", "after self_boolean");
+    BLI::MeshIntersect::write_obj_trimesh(tm_out.vert, tm_out.tri, "test_tettet");
+  }
+  int nv = tm_out.vert.size();
+  int nt = tm_out.tri.size();
+  Boolean_trimesh_output *output = static_cast<Boolean_trimesh_output *>(
+      MEM_mallocN(sizeof(*output), __func__));
+  output->vert_len = nv;
+  output->tri_len = nt;
+  output->vert_coord = static_cast<decltype(output->vert_coord)>(
+      MEM_malloc_arrayN(nv, sizeof(output->vert_coord[0]), __func__));
+  output->tri = static_cast<decltype(output->tri)>(
+      MEM_malloc_arrayN(nt, sizeof(output->tri[0]), __func__));
+  for (int v = 0; v < nv; ++v) {
+    output->vert_coord[v][0] = static_cast<float>(tm_out.vert[v][0].get_d());
+    output->vert_coord[v][1] = static_cast<float>(tm_out.vert[v][1].get_d());
+    output->vert_coord[v][2] = static_cast<float>(tm_out.vert[v][2].get_d());
+  }
+  for (int t = 0; t < nt; ++t) {
+    output->tri[t][0] = tm_out.tri[t].v0();
+    output->tri[t][1] = tm_out.tri[t].v1();
+    output->tri[t][2] = tm_out.tri[t].v2();
+  }
+  return output;
+}
+
+extern "C" void BLI_boolean_trimesh_free(Boolean_trimesh_output *output)
+{
+  MEM_freeN(output->vert_coord);
+  MEM_freeN(output->tri);
+  MEM_freeN(output);
+}
diff --git a/source/blender/blenlib/intern/delaunay_2d.c b/source/blender/blenlib/intern/delaunay_2d.c
deleted file mode 100644
index 4e0cd3a78dc..00000000000
--- a/source/blender/blenlib/intern/delaunay_2d.c
+++ /dev/null
@@ -1,5171 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-
-/** \file
- * \ingroup bli
- *
- * Constrained 2d Delaunay Triangulation.
- */
-
-#include "MEM_guardedalloc.h"
-
-#include "BLI_array.h"
-#include "BLI_bitmap.h"
-#include "BLI_linklist.h"
-#include "BLI_math.h"
-#include "BLI_memarena.h"
-#include "BLI_mempool.h"
-
-#include "BLI_delaunay_2d.h"
-
-/* Uncomment this define to get helpful debugging functions etc. defined. */
-// #define DEBUG_CDT
-
-struct CDTEdge;
-struct CDTFace;
-struct CDTVert;
-
-typedef struct SymEdge {
-  struct SymEdge *next; /* In face, doing CCW traversal of face. */
-  struct SymEdge *rot;  /* CCW around vert. */
-  struct CDTVert *vert; /* Vert at origin. */
-  struct CDTEdge *edge; /* Undirected edge this is for. */
-  struct CDTFace *face; /* Face on left side. */
-} SymEdge;
-
-typedef struct CDTVert {
-  double co[2];        /* Coordinate. */
-  SymEdge *symedge;    /* Some edge attached to it. */
-  LinkNode *input_ids; /* List of corresponding vertex input ids. */
-  int index;           /* Index into array that cdt keeps. */
-  int merge_to_index;  /* Index of a CDTVert that this has merged to. -1 if no merge. */
-  int visit_index;     /* Which visit epoch has this been seen. */
-} CDTVert;
-
-typedef struct CDTEdge {
-  LinkNode *input_ids; /* List of input edge ids that this is part of. */
-  SymEdge symedges[2]; /* The directed edges for this edge. */
-  bool in_queue;       /* Used in flipping algorithm. */
-} CDTEdge;
-
-typedef struct CDTFace {
-  SymEdge *symedge;    /* A symedge in face; only used during output, so only valid then. */
-  LinkNode *input_ids; /* List of input face ids that this is part of. */
-  int visit_index;     /* Which visit epoch has this been seen. */
-  bool deleted;        /* Marks this face no longer used. */
-  bool in_queue;       /* Used in remove_small_features algorithm. */
-} CDTFace;
-
-typedef struct CDT_state {
-  LinkNode *edges;          /* List of CDTEdge pointer. */
-  LinkNode *faces;          /* List of CDTFace pointer. */
-  CDTFace *outer_face;      /* Which CDTFace is the outer face. */
-  CDTVert **vert_array;     /* Array of CDTVert pointer, grows. */
-  int vert_array_len;       /* Current length of vert_array. */
-  int vert_array_len_alloc; /* Allocated length of vert_array. */
-  int input_vert_tot;       /* How many verts were in input (will be first in vert_array). */
-  double minx;              /* Used for debug drawing. */
-  double miny;              /* Used for debug drawing. */
-  double maxx;              /* Used for debug drawing. */
-  double maxy;              /* Used for debug drawing. */
-  double margin;            /* Used for debug drawing. */
-  int visit_count; /* Used for visiting things without having to initialized their visit fields. */
-  int face_edge_offset;  /* Input edge id where we start numbering the face edges. */
-  MemArena *arena;       /* Most allocations are done from here, so can free all at once at end. */
-  BLI_mempool *listpool; /* Allocations of ListNodes done from this pool. */
-  double epsilon;        /* The user-specified nearness limit. */
-  double epsilon_squared; /* Square of epsilon. */
-  bool output_prepared;   /* Set after the mesh has been modified for output (may not be all
-                             triangles now). */
-} CDT_state;
-
-#define DLNY_ARENASIZE 1 << 14
-
-#ifdef DEBUG_CDT
-#  ifdef __GNUC__
-#    define ATTU __attribute__((unused))
-#  else
-#    define ATTU
-#  endif
-#  define F2(p) p[0], p[1]
-#  define F3(p) p[0], p[1], p[2]
-struct CrossData;
-ATTU static void dump_se(const SymEdge *se, const char *lab);
-ATTU static void dump_se_short(const SymEdge *se, const char *lab);
-ATTU static void dump_v(const CDTVert *v, const char *lab);
-ATTU static void dump_se_cycle(const SymEdge *se, const char *lab, const int limit);
-ATTU static void dump_id_list(const LinkNode *id_list, const char *lab);
-ATTU static void dump_cross_data(struct CrossData *cd, const char *lab);
-ATTU static void dump_cdt(const CDT_state *cdt, const char *lab);
-ATTU static void dump_cdt_vert_neighborhood(CDT_state *cdt, int v, int maxdist, const char *lab);
-ATTU static void cdt_draw(CDT_state *cdt, const char *lab);
-ATTU static void cdt_draw_region(
-    CDT_state *cdt, const char *lab, double minx, double miny, double maxx, double maxy);
-
-ATTU static void cdt_draw_vertex_region(CDT_state *cdt, int v, double dist, const char *lab);
-ATTU static void cdt_draw_edge_region(
-    CDT_state *cdt, int v1, int v2, double dist, const char *lab);
-ATTU static void write_cdt_input_to_file(const CDT_input *inp);
-ATTU static void validate_cdt(CDT_state *cdt,
-                              bool check_all_tris,
-                              bool check_delaunay,
-                              bool check_visibility);
-#endif
-
-static void exactinit(void);
-static double orient2d(const double *pa, const double *pb, const double *pc);
-static double incircle(const double *pa, const double *pb, const double *pc, const double *pd);
-
-/** Return other #SymEdge for same #CDTEdge as se. */
-BLI_INLINE SymEdge *sym(const SymEdge *se)
-{
-  return se->next->rot;
-}
-
-/** Return SymEdge whose next is se. */
-BLI_INLINE SymEdge *prev(const SymEdge *se)
-{
-  return se->rot->next->rot;
-}
-
-/**
- * Return true if a -- b -- c are in that order, assuming they are on a straight line according to
- * orient2d and we know the order is either `abc` or `bac`.
- * This means `ab . ac` and `bc . ac` must both be non-negative.  */
-static bool in_line(const double a[2], const double b[2], const double c[2])
-{
-  double ab[2], bc[2], ac[2];
-  sub_v2_v2v2_db(ab, b, a);
-  sub_v2_v2v2_db(bc, c, b);
-  sub_v2_v2v2_db(ac, c, a);
-  if (dot_v2v2_db(ab, ac) < 0.0) {
-    return false;
-  }
-  return dot_v2v2_db(bc, ac) >= 0.0;
-}
-
-#ifndef NDEBUG
-/** Is s2 reachable from s1 by next pointers with < limit hops? */
-static bool reachable(SymEdge *s1, SymEdge *s2, int limit)
-{
-  int count = 0;
-  for (SymEdge *s = s1; s && count < limit; s = s->next) {
-    if (s == s2) {
-      return true;
-    }
-    count++;
-  }
-  return false;
-}
-#endif
-
-/** Using array to store these instead of linked list so can make a random selection from them. */
-static CDTVert *add_cdtvert(CDT_state *cdt, double x, double y)
-{
-  CDTVert *v = BLI_memarena_alloc(cdt->arena, sizeof(*v));
-  v->co[0] = x;
-  v->co[1] = y;
-  v->input_ids = NULL;
-  v->symedge = NULL;
-  if (cdt->vert_array_len == cdt->vert_array_len_alloc) {
-    CDTVert **old_array = cdt->vert_array;
-    cdt->vert_array_len_alloc *= 4;
-    cdt->vert_array = BLI_memarena_alloc(cdt->arena,
-                                         cdt->vert_array_len_alloc * sizeof(cdt->vert_array[0]));
-    memmove(cdt->vert_array, old_array, cdt->vert_array_len * sizeof(cdt->vert_array[0]));
-  }
-  BLI_assert(cdt->vert_array_len < cdt->vert_array_len_alloc);
-  v->index = cdt->vert_array_len;
-  v->merge_to_index = -1;
-  v->visit_index = 0;
-  cdt->vert_array[cdt->vert_array_len++] = v;
-  return v;
-}
-
-static CDTEdge *add_cdtedge(
-    CDT_state *cdt, CDTVert *v1, CDTVert *v2, CDTFace *fleft, CDTFace *fright)
-{
-  CDTEdge *e = BLI_memarena_alloc(cdt->arena, sizeof(*e));
-  SymEdge *se = &e->symedges[0];
-  SymEdge *sesym = &e->symedges[1];
-  e->input_ids = NULL;
-  e->in_queue = false;
-  BLI_linklist_prepend_arena(&cdt->edges, (void *)e, cdt->arena);
-  se->edge = sesym->edge = e;
-  se->face = fleft;
-  sesym->face = fright;
-  se->vert = v1;
-  if (v1->symedge == NULL) {
-    v1->symedge = se;
-  }
-  sesym->vert = v2;
-  if (v2->symedge == NULL) {
-    v2->symedge = sesym;
-  }
-  se->next = sesym->next = se->rot = sesym->rot = NULL;
-  return e;
-}
-
-static CDTFace *add_cdtface(CDT_state *cdt)
-{
-  CDTFace *f = BLI_memarena_alloc(cdt->arena, sizeof(*f));
-  f->visit_index = 0;
-  f->deleted = false;
-  f->symedge = NULL;
-  f->input_ids = NULL;
-  f->in_queue = false;
-  BLI_linklist_prepend_arena(&cdt->faces, (void *)f, cdt->arena);
-  return f;
-}
-
-static bool id_in_list(const LinkNode *id_list, int id)
-{
-  const LinkNode *ln;
-
-  for (ln = id_list; ln; ln = ln->next) {
-    if (POINTER_AS_INT(ln->link) == id) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/** is any id in (range_start, range_start+1, ... , range_end) in id_list? */
-static bool id_range_in_list(const LinkNode *id_list, int range_start, int range_end)
-{
-  const LinkNode *ln;
-  int id;
-
-  for (ln = id_list; ln; ln = ln->next) {
-    id = POINTER_AS_INT(ln->link);
-    if (id >= range_start && id <= range_end) {
-      return true;
-    }
-  }
-  return false;
-}
-
-static void add_to_input_ids(LinkNode **dst, int input_id, CDT_state *cdt)
-{
-  if (!id_in_list(*dst, input_id)) {
-    BLI_linklist_prepend_arena(dst, POINTER_FROM_INT(input_id), cdt->arena);
-  }
-}
-
-static void add_list_to_input_ids(LinkNode **dst, const LinkNode *src, CDT_state *cdt)
-{
-  const LinkNode *ln;
-
-  for (ln = src; ln; ln = ln->next) {
-    add_to_input_ids(dst, POINTER_AS_INT(ln->link), cdt);
-  }
-}
-
-BLI_INLINE bool is_border_edge(const CDTEdge *e, const CDT_state *cdt)
-{
-  return e->symedges[0].face == cdt->outer_face || e->symedges[1].face == cdt->outer_face;
-}
-
-BLI_INLINE bool is_constrained_edge(const CDTEdge *e)
-{
-  return e->input_ids != NULL;
-}
-
-BLI_INLINE bool is_deleted_edge(const CDTEdge *e)
-{
-  return e->symedges[0].next == NULL;
-}
-
-BLI_INLINE bool is_original_vert(const CDTVert *v, CDT_state *cdt)
-{
-  return (v->index < cdt->input_vert_tot);
-}
-
-/** Return the Symedge that goes from v1 to v2, if it exists, else return NULL. */
-static SymEdge *find_symedge_between_verts(const CDTVert *v1, const CDTVert *v2)
-{
-  SymEdge *tstart, *t;
-
-  t = tstart = v1->symedge;
-  do {
-    if (t->next->vert == v2) {
-      return t;
-    }
-  } while ((t = t->rot) != tstart);
-  return NULL;
-}
-
-/** Return the SymEdge attached to v that has face f, if it exists, else return NULL. */
-static SymEdge *find_symedge_with_face(const CDTVert *v, const CDTFace *f)
-{
-  SymEdge *tstart, *t;
-
-  t = tstart = v->symedge;
-  do {
-    if (t->face == f) {
-      return t;
-    }
-  } while ((t = t->rot) != tstart);
-  return NULL;
-}
-
-/** Is there already an edge between a and b? */
-static inline bool exists_edge(const CDTVert *v1, const CDTVert *v2)
-{
-  return find_symedge_between_verts(v1, v2) != NULL;
-}
-
-/** Is the vertex v incident on face f? */
-static bool vert_touches_face(const CDTVert *v, const CDTFace *f)
-{
-  SymEdge *se = v->symedge;
-  do {
-    if (se->face == f) {
-      return true;
-    }
-  } while ((se = se->rot) != v->symedge);
-  return false;
-}
-
-/**
- * Assume s1 and s2 are both SymEdges in a face with > 3 sides,
- * and one is not the next of the other.
- * Add an edge from s1->v to s2->v, splitting the face in two.
- * The original face will continue to be associated with the subface
- * that has s1, and a new face will be made for s2's new face.
- * Return the new diagonal's CDTEdge *.
- */
-static CDTEdge *add_diagonal(CDT_state *cdt, SymEdge *s1, SymEdge *s2)
-{
-  CDTEdge *ediag;
-  CDTFace *fold, *fnew;
-  SymEdge *sdiag, *sdiagsym;
-  SymEdge *s1prev, *s1prevsym, *s2prev, *s2prevsym, *se;
-  BLI_assert(reachable(s1, s2, 20000));
-  BLI_assert(reachable(s2, s1, 20000));
-  fold = s1->face;
-  fnew = add_cdtface(cdt);
-  s1prev = prev(s1);
-  s1prevsym = sym(s1prev);
-  s2prev = prev(s2);
-  s2prevsym = sym(s2prev);
-  ediag = add_cdtedge(cdt, s1->vert, s2->vert, fnew, fold);
-  sdiag = &ediag->symedges[0];
-  sdiagsym = &ediag->symedges[1];
-  sdiag->next = s2;
-  sdiagsym->next = s1;
-  s2prev->next = sdiagsym;
-  s1prev->next = sdiag;
-  s1->rot = sdiag;
-  sdiag->rot = s1prevsym;
-  s2->rot = sdiagsym;
-  sdiagsym->rot = s2prevsym;
-#ifdef DEBUG_CDT
-  BLI_assert(reachable(s2, sdiag, 2000));
-#endif
-  for (se = s2; se != sdiag; se = se->next) {
-    se->face = fnew;
-  }
-  add_list_to_input_ids(&fnew->input_ids, fold->input_ids, cdt);
-  return ediag;
-}
-
-/**
- * Add a dangling edge from an isolated v to the vert at se in the same face as se->face.
- */
-static CDTEdge *add_vert_to_symedge_edge(CDT_state *cdt, CDTVert *v, SymEdge *se)
-{
-  CDTEdge *e;
-  SymEdge *se_rot, *se_rotsym, *new_se, *new_se_sym;
-
-  se_rot = se->rot;
-  se_rotsym = sym(se_rot);
-  e = add_cdtedge(cdt, v, se->vert, se->face, se->face);
-  new_se = &e->symedges[0];
-  new_se_sym = &e->symedges[1];
-  new_se->next = se;
-  new_se_sym->next = new_se;
-  new_se->rot = new_se;
-  new_se_sym->rot = se_rot;
-  se->rot = new_se_sym;
-  se_rotsym->next = new_se_sym;
-  return e;
-}
-
-/* Connect the verts of se1 and se2, assuming that currently those two SymEdges are on
- * the outer boundary (have face == outer_face) of two components that are isolated from
- * each other.
- */
-static CDTEdge *connect_separate_parts(CDT_state *cdt, SymEdge *se1, SymEdge *se2)
-{
-  CDTEdge *e;
-  SymEdge *se1_rot, *se1_rotsym, *se2_rot, *se2_rotsym, *new_se, *new_se_sym;
-
-  BLI_assert(se1->face == cdt->outer_face && se2->face == cdt->outer_face);
-  se1_rot = se1->rot;
-  se1_rotsym = sym(se1_rot);
-  se2_rot = se2->rot;
-  se2_rotsym = sym(se2_rot);
-  e = add_cdtedge(cdt, se1->vert, se2->vert, cdt->outer_face, cdt->outer_face);
-  new_se = &e->symedges[0];
-  new_se_sym = &e->symedges[1];
-  new_se->next = se2;
-  new_se_sym->next = se1;
-  new_se->rot = se1_rot;
-  new_se_sym->rot = se2_rot;
-  se1->rot = new_se;
-  se2->rot = new_se_sym;
-  se1_rotsym->next = new_se;
-  se2_rotsym->next = new_se_sym;
-  return e;
-}
-
-/**
- * Split \a se at fraction \a lambda,
- * and return the new #CDTEdge that is the new second half.
- * Copy the edge input_ids into the new one.
- */
-static CDTEdge *split_edge(CDT_state *cdt, SymEdge *se, double lambda)
-{
-  const double *a, *b;
-  double p[2];
-  CDTVert *v;
-  CDTEdge *e;
-  SymEdge *sesym, *newse, *newsesym, *senext, *sesymprev, *sesymprevsym;
-  /* Split e at lambda. */
-  a = se->vert->co;
-  b = se->next->vert->co;
-  sesym = sym(se);
-  sesymprev = prev(sesym);
-  sesymprevsym = sym(sesymprev);
-  senext = se->next;
-  p[0] = (1.0 - lambda) * a[0] + lambda * b[0];
-  p[1] = (1.0 - lambda) * a[1] + lambda * b[1];
-  v = add_cdtvert(cdt, p[0], p[1]);
-  e = add_cdtedge(cdt, v, se->next->vert, se->face, sesym->face);
-  sesym->vert = v;
-  newse = &e->symedges[0];
-  newsesym = &e->symedges[1];
-  se->next = newse;
-  newsesym->next = sesym;
-  newse->next = senext;
-  newse->rot = sesym;
-  sesym->rot = newse;
-  senext->rot = newsesym;
-  newsesym->rot = sesymprevsym;
-  sesymprev->next = newsesym;
-  if (newsesym->vert->symedge == sesym) {
-    newsesym->vert->symedge = newsesym;
-  }
-  add_list_to_input_ids(&e->input_ids, se->edge->input_ids, cdt);
-  return e;
-}
-
-/**
- * Delete an edge from the structure. The new combined face on either side of
- * the deleted edge will be the one that was e's face.
- * There will be now an unused face, marked by setting its deleted flag,
- * and an unused #CDTEdge, marked by setting the next and rot pointers of
- * its SymEdges to NULL.
- * <pre>
- *        .  v2               .
- *       / \                 / \
- *      /f|j\               /   \
- *     /  |  \             /     \
- *        |
- *      A |  B                A
- *    \  e|   /           \       /
- *     \  | /              \     /
- *      \h|i/               \   /
- *        .  v1               .
- * </pre>
- * Also handle variant cases where one or both ends
- * are attached only to e.
- */
-static void delete_edge(CDT_state *cdt, SymEdge *e)
-{
-  SymEdge *esym, *f, *h, *i, *j, *k, *jsym, *hsym;
-  CDTFace *aface, *bface;
-  CDTVert *v1, *v2;
-  bool v1_isolated, v2_isolated;
-
-  esym = sym(e);
-  v1 = e->vert;
-  v2 = esym->vert;
-  aface = e->face;
-  bface = esym->face;
-  f = e->next;
-  h = prev(e);
-  i = esym->next;
-  j = prev(esym);
-  jsym = sym(j);
-  hsym = sym(h);
-  v1_isolated = (i == e);
-  v2_isolated = (f == esym);
-
-  if (!v1_isolated) {
-    h->next = i;
-    i->rot = hsym;
-  }
-  if (!v2_isolated) {
-    j->next = f;
-    f->rot = jsym;
-  }
-  if (!v1_isolated && !v2_isolated && aface != bface) {
-    for (k = i; k != f; k = k->next) {
-      k->face = aface;
-    }
-  }
-
-  /* If e was representative symedge for v1 or v2, fix that. */
-  if (v1_isolated) {
-    v1->symedge = NULL;
-  }
-  else if (v1->symedge == e) {
-    v1->symedge = i;
-  }
-  if (v2_isolated) {
-    v2->symedge = NULL;
-  }
-  else if (v2->symedge == esym) {
-    v2->symedge = f;
-  }
-
-  /* Mark SymEdge as deleted by setting all its pointers to NULL. */
-  e->next = e->rot = NULL;
-  esym->next = esym->rot = NULL;
-  if (!v1_isolated && !v2_isolated && aface != bface) {
-    bface->deleted = true;
-    if (cdt->outer_face == bface) {
-      cdt->outer_face = aface;
-    }
-  }
-}
-
-static CDT_state *cdt_init(const CDT_input *in)
-{
-  int i;
-  MemArena *arena = BLI_memarena_new(DLNY_ARENASIZE, __func__);
-  CDT_state *cdt = BLI_memarena_calloc(arena, sizeof(CDT_state));
-
-  cdt->epsilon = (double)in->epsilon;
-  cdt->epsilon_squared = cdt->epsilon * cdt->epsilon;
-  cdt->arena = arena;
-  cdt->input_vert_tot = in->verts_len;
-  cdt->vert_array_len_alloc = 2 * in->verts_len;
-  cdt->vert_array = BLI_memarena_alloc(arena,
-                                       cdt->vert_array_len_alloc * sizeof(*cdt->vert_array));
-  cdt->listpool = BLI_mempool_create(
-      sizeof(LinkNode), 128 + 4 * in->verts_len, 128 + in->verts_len, 0);
-
-  for (i = 0; i < in->verts_len; i++) {
-    add_cdtvert(cdt, (double)(in->vert_coords[i][0]), (double)(in->vert_coords[i][1]));
-  }
-  cdt->outer_face = add_cdtface(cdt);
-  return cdt;
-}
-
-static void new_cdt_free(CDT_state *cdt)
-{
-  BLI_mempool_destroy(cdt->listpool);
-  BLI_memarena_free(cdt->arena);
-}
-
-typedef struct SiteInfo {
-  CDTVert *v;
-  int orig_index;
-} SiteInfo;
-
-static int site_lexicographic_cmp(const void *a, const void *b)
-{
-  const SiteInfo *s1 = a;
-  const SiteInfo *s2 = b;
-  const double *co1 = s1->v->co;
-  const double *co2 = s2->v->co;
-
-  if (co1[0] < co2[0]) {
-    return -1;
-  }
-  else if (co1[0] > co2[0]) {
-    return 1;
-  }
-  else if (co1[1] < co2[1]) {
-    return -1;
-  }
-  else if (co1[1] > co2[1]) {
-    return 1;
-  }
-  else if (s1->orig_index < s2->orig_index) {
-    return -1;
-  }
-  else if (s1->orig_index > s2->orig_index) {
-    return 1;
-  }
-  return 0;
-}
-
-BLI_INLINE bool vert_left_of_symedge(CDTVert *v, SymEdge *se)
-{
-  return orient2d(v->co, se->vert->co, se->next->vert->co) > 0.0;
-}
-
-BLI_INLINE bool vert_right_of_symedge(CDTVert *v, SymEdge *se)
-{
-  return orient2d(v->co, se->next->vert->co, se->vert->co) > 0.0;
-}
-
-/* Is se above basel? */
-BLI_INLINE bool dc_tri_valid(SymEdge *se, SymEdge *basel, SymEdge *basel_sym)
-{
-  return orient2d(se->next->vert->co, basel_sym->vert->co, basel->vert->co) > 0.0;
-}
-
-/* Delaunay triangulate sites[start} to sites[end-1].
- * Assume sites are lexicographically sorted by coordinate.
- * Return SymEdge of ccw convex hull at left-most point in *r_le
- * and that of right-most point of cw convex null in *r_re.
- */
-static void dc_tri(
-    CDT_state *cdt, SiteInfo *sites, int start, int end, SymEdge **r_le, SymEdge **r_re)
-{
-  int n = end - start;
-  int n2;
-  CDTVert *v1, *v2, *v3;
-  CDTEdge *ea, *eb, *ebasel;
-  SymEdge *ldo, *ldi, *rdi, *rdo, *basel, *basel_sym, *lcand, *rcand, *t;
-  double orient;
-  bool valid_lcand, valid_rcand;
-#ifdef DEBUG_CDT
-  char label_buf[100];
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "DC_TRI start=%d end=%d\n", start, end);
-  }
-#endif
-
-  BLI_assert(r_le != NULL && r_re != NULL);
-  if (n <= 1) {
-    *r_le = NULL;
-    *r_re = NULL;
-    return;
-  }
-  if (n <= 3) {
-    v1 = sites[start].v;
-    v2 = sites[start + 1].v;
-    ea = add_cdtedge(cdt, v1, v2, cdt->outer_face, cdt->outer_face);
-    ea->symedges[0].next = &ea->symedges[1];
-    ea->symedges[1].next = &ea->symedges[0];
-    ea->symedges[0].rot = &ea->symedges[0];
-    ea->symedges[1].rot = &ea->symedges[1];
-    if (n == 2) {
-      *r_le = &ea->symedges[0];
-      *r_re = &ea->symedges[1];
-      return;
-    }
-    v3 = sites[start + 2].v;
-    eb = add_vert_to_symedge_edge(cdt, v3, &ea->symedges[1]);
-    orient = orient2d(v1->co, v2->co, v3->co);
-    if (orient > 0.0) {
-      add_diagonal(cdt, &eb->symedges[0], &ea->symedges[0]);
-      *r_le = &ea->symedges[0];
-      *r_re = &eb->symedges[0];
-    }
-    else if (orient < 0.0) {
-      add_diagonal(cdt, &ea->symedges[0], &eb->symedges[0]);
-      *r_le = ea->symedges[0].rot;
-      *r_re = eb->symedges[0].rot;
-    }
-    else {
-      /* Collinear points. Just return a line. */
-      *r_le = &ea->symedges[0];
-      *r_re = &eb->symedges[0];
-    }
-    return;
-  }
-  /* Here: n >= 4.  Divide and conquer. */
-  n2 = n / 2;
-  BLI_assert(n2 >= 2 && end - (start + n2) >= 2);
-
-  /* Delaunay triangulate two halves, L and R. */
-  dc_tri(cdt, sites, start, start + n2, &ldo, &ldi);
-  dc_tri(cdt, sites, start + n2, end, &rdi, &rdo);
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nDC_TRI merge step for start=%d, end=%d\n", start, end);
-    dump_se(ldo, "ldo");
-    dump_se(ldi, "ldi");
-    dump_se(rdi, "rdi");
-    dump_se(rdo, "rdo");
-    if (dbg_level > 1) {
-      sprintf(label_buf, "dc_tri(%d,%d)(%d,%d)", start, start + n2, start + n2, end);
-      /* dump_cdt(cdt, label_buf); */
-      cdt_draw(cdt, label_buf);
-    }
-  }
-#endif
-
-  /* Find lower common tangent of L and R. */
-  for (;;) {
-    if (vert_left_of_symedge(rdi->vert, ldi)) {
-      ldi = ldi->next;
-    }
-    else if (vert_right_of_symedge(ldi->vert, rdi)) {
-      rdi = sym(rdi)->rot; /* Previous edge to rdi with same right face. */
-    }
-    else {
-      break;
-    }
-  }
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "common lower tangent is between\n");
-    dump_se(rdi, "rdi");
-    dump_se(ldi, "ldi");
-  }
-#endif
-  ebasel = connect_separate_parts(cdt, sym(rdi)->next, ldi);
-  basel = &ebasel->symedges[0];
-  basel_sym = &ebasel->symedges[1];
-#ifdef DEBUG_CDT
-  if (dbg_level > 1) {
-    dump_se(basel, "basel");
-    cdt_draw(cdt, "after basel made");
-  }
-#endif
-  if (ldi->vert == ldo->vert) {
-    ldo = basel_sym;
-  }
-  if (rdi->vert == rdo->vert) {
-    rdo = basel;
-  }
-
-  /* Merge loop. */
-  for (;;) {
-    /* Locate the first point lcand->next->vert encountered by rising bubble,
-     * and delete L edges out of basel->next->vert that fail the circle test. */
-    lcand = basel_sym->rot;
-    rcand = basel_sym->next;
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "\ntop of merge loop\n");
-      dump_se(lcand, "lcand");
-      dump_se(rcand, "rcand");
-      dump_se(basel, "basel");
-    }
-#endif
-    if (dc_tri_valid(lcand, basel, basel_sym)) {
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "found valid lcand\n");
-        dump_se(lcand, "  lcand");
-      }
-#endif
-      while (incircle(basel_sym->vert->co,
-                      basel->vert->co,
-                      lcand->next->vert->co,
-                      lcand->rot->next->vert->co) > 0.0) {
-#ifdef DEBUG_CDT
-        if (dbg_level > 1) {
-          fprintf(stderr, "incircle says to remove lcand\n");
-          dump_se(lcand, "  lcand");
-        }
-#endif
-        t = lcand->rot;
-        delete_edge(cdt, sym(lcand));
-        lcand = t;
-      }
-    }
-    /* Symmetrically, locate first R point to be hit and delete R edges. */
-    if (dc_tri_valid(rcand, basel, basel_sym)) {
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "found valid rcand\n");
-        dump_se(rcand, "  rcand");
-      }
-#endif
-      while (incircle(basel_sym->vert->co,
-                      basel->vert->co,
-                      rcand->next->vert->co,
-                      sym(rcand)->next->next->vert->co) > 0.0) {
-#ifdef DEBUG_CDT
-        if (dbg_level > 0) {
-          fprintf(stderr, "incircle says to remove rcand\n");
-          dump_se(lcand, "  rcand");
-        }
-#endif
-        t = sym(rcand)->next;
-        delete_edge(cdt, rcand);
-        rcand = t;
-      }
-    }
-    /* If both lcand and rcand are invalid, then basel is the common upper tangent. */
-    valid_lcand = dc_tri_valid(lcand, basel, basel_sym);
-    valid_rcand = dc_tri_valid(rcand, basel, basel_sym);
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(
-          stderr, "after bubbling up, valid_lcand=%d, valid_rcand=%d\n", valid_lcand, valid_rcand);
-      dump_se(lcand, "lcand");
-      dump_se(rcand, "rcand");
-    }
-#endif
-    if (!valid_lcand && !valid_rcand) {
-      break;
-    }
-    /* The next cross edge to be connected is to either lcand->next->vert or rcand->next->vert;
-     * if both are valid, choose the appropriate one using the incircle test.
-     */
-    if (!valid_lcand ||
-        (valid_rcand &&
-         incircle(lcand->next->vert->co, lcand->vert->co, rcand->vert->co, rcand->next->vert->co) >
-             0.0)) {
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr, "connecting rcand\n");
-        dump_se(basel_sym, "  se1=basel_sym");
-        dump_se(rcand->next, "  se2=rcand->next");
-      }
-#endif
-      ebasel = add_diagonal(cdt, rcand->next, basel_sym);
-    }
-    else {
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr, "connecting lcand\n");
-        dump_se(sym(lcand), "  se1=sym(lcand)");
-        dump_se(basel_sym->next, "  se2=basel_sym->next");
-      }
-#endif
-      ebasel = add_diagonal(cdt, basel_sym->next, sym(lcand));
-    }
-    basel = &ebasel->symedges[0];
-    basel_sym = &ebasel->symedges[1];
-    BLI_assert(basel_sym->face == cdt->outer_face);
-#ifdef DEBUG_CDT
-    if (dbg_level > 2) {
-      cdt_draw(cdt, "after adding new crossedge");
-      // dump_cdt(cdt, "after adding new crossedge");
-    }
-#endif
-  }
-  *r_le = ldo;
-  *r_re = rdo;
-  BLI_assert(sym(ldo)->face == cdt->outer_face && rdo->face == cdt->outer_face);
-}
-
-/* Guibas-Stolfi Divide-and_Conquer algorithm. */
-static void dc_triangulate(CDT_state *cdt, SiteInfo *sites, int nsites)
-{
-  int i, j, n;
-  SymEdge *le, *re;
-
-  /* Compress sites in place to eliminated verts that merge to others. */
-  i = 0;
-  j = 0;
-  while (j < nsites) {
-    /* Invariante: sites[0..i-1] have non-merged verts from 0..(j-1) in them. */
-    sites[i] = sites[j++];
-    if (sites[i].v->merge_to_index < 0) {
-      i++;
-    }
-  }
-  n = i;
-  if (n == 0) {
-    return;
-  }
-  dc_tri(cdt, sites, 0, n, &le, &re);
-}
-
-/**
- * Do a Delaunay Triangulation of the points in cdt->vert_array.
- * This  is only a first step in the Constrained Delaunay triangulation,
- * because it doesn't yet deal with the segment constraints.
- * The algorithm used is the Divide & Conquer algorithm from the
- * Guibas-Stolfi "Primitives for the Manipulation of General Subdivision
- * and the Computation of Voronoi Diagrams" paper.
- * The data structure here is similar to but not exactly the same as
- * the quad-edge structure described in that paper.
- * The incircle and ccw tests are done using Shewchuk's exact
- * primitives (see below), so that this routine is robust.
- *
- * As a preprocessing step, we want to merge all vertices that are
- * within cdt->epsilon of each other. This is accomplished by lexicographically
- * sorting the coordinates first (which is needed anyway for the D&C algorithm).
- * The CDTVerts with merge_to_index not equal to -1 are after this regarded
- * as having been merged into the vertex with the corresponding index.
- */
-static void initial_triangulation(CDT_state *cdt)
-{
-  int i, j, n;
-  SiteInfo *sites;
-  double *ico, *jco;
-  double xend, yend, xcur;
-  double epsilon = cdt->epsilon;
-  double epsilon_squared = cdt->epsilon_squared;
-#ifdef SJF_WAY
-  CDTEdge *e;
-  CDTVert *va, *vb;
-#endif
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nINITIAL TRIANGULATION\n\n");
-  }
-#endif
-
-  /* First sort the vertices by lexicographic order of their
-   * coordinates, breaking ties by putting earlier original-index
-   * vertices first.
-   */
-  n = cdt->vert_array_len;
-  if (n <= 1) {
-    return;
-  }
-  sites = MEM_malloc_arrayN(n, sizeof(SiteInfo), __func__);
-  for (i = 0; i < n; i++) {
-    sites[i].v = cdt->vert_array[i];
-    sites[i].orig_index = i;
-  }
-  qsort(sites, n, sizeof(SiteInfo), site_lexicographic_cmp);
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "after sorting\n");
-    for (i = 0; i < n; i++) {
-      fprintf(stderr, "%d: orig index: %d, (%f,%f)\n", i, sites[i].orig_index, F2(sites[i].v->co));
-    }
-  }
-#endif
-
-  /* Now dedup according to user-defined epsilon.
-   * We will merge a vertex into an earlier-indexed vertex
-   * that is within epsilon (Euclidean distance).
-   * Merges may cascade. So we may end up merging two things
-   * that are farther than epsilon by transitive merging. Oh well.
-   * Assume that merges are rare, so use simple searches in the
-   * lexicographic ordering - likely we will soon hit y's with
-   * the same x that are farther away than epsilon, and then
-   * skipping ahead to the next biggest x, are likely to soon
-   * find one of those farther away than epsilon.
-   */
-  for (i = 0; i < n - 1; i++) {
-    ico = sites[i].v->co;
-    /* Start j at next place that has both x and y coords within epsilon. */
-    xend = ico[0] + epsilon;
-    yend = ico[1] + epsilon;
-    j = i + 1;
-    while (j < n) {
-      jco = sites[j].v->co;
-      if (jco[0] > xend) {
-        break; /* No more j's to process. */
-      }
-      else if (jco[1] > yend) {
-        /* Get past any string of v's with the same x and too-big y. */
-        xcur = jco[0];
-        while (++j < n) {
-          if (sites[j].v->co[0] > xcur) {
-            break;
-          }
-        }
-        BLI_assert(j == n || sites[j].v->co[0] > xcur);
-        if (j == n) {
-          break;
-        }
-        jco = sites[j].v->co;
-        if (jco[0] > xend || jco[1] > yend) {
-          break;
-        }
-      }
-      /* When here, vertex i and j are within epsilon by box test.
-       * The Euclidean distance test is stricter, so need to do it too, now.
-       */
-      BLI_assert(j < n && jco[0] <= xend && jco[1] <= yend);
-      if (len_squared_v2v2_db(ico, jco) <= epsilon_squared) {
-        sites[j].v->merge_to_index = (sites[i].v->merge_to_index == -1) ?
-                                         sites[i].orig_index :
-                                         sites[i].v->merge_to_index;
-#ifdef DEBUG_CDT
-        if (dbg_level > 0) {
-          fprintf(stderr,
-                  "merged orig vert %d to %d\n",
-                  sites[j].orig_index,
-                  sites[j].v->merge_to_index);
-        }
-#endif
-      }
-      j++;
-    }
-  }
-
-  /* Now add non-dup vertices into triangulation in lexicographic order. */
-
-  dc_triangulate(cdt, sites, n);
-  MEM_freeN(sites);
-}
-
-/** Use LinkNode linked list as stack of SymEdges, allocating from cdt->listpool. */
-typedef LinkNode *Stack;
-
-BLI_INLINE void push(Stack *stack, SymEdge *se, CDT_state *cdt)
-{
-  BLI_linklist_prepend_pool(stack, se, cdt->listpool);
-}
-
-BLI_INLINE SymEdge *pop(Stack *stack, CDT_state *cdt)
-{
-  return (SymEdge *)BLI_linklist_pop_pool(stack, cdt->listpool);
-}
-
-BLI_INLINE bool is_empty(Stack *stack)
-{
-  return *stack == NULL;
-}
-
-/**
- * Re-triangulates, assuring constrained delaunay condition,
- * the pseudo-polygon that cycles from se.
- * "pseudo" because a vertex may be repeated.
- * See Anglada paper, "An Improved incremental algorithm
- * for constructing restricted Delaunay triangulations".
- */
-static void re_delaunay_triangulate(CDT_state *cdt, SymEdge *se)
-{
-  SymEdge *ss, *first, *cse;
-  CDTVert *a, *b, *c, *v;
-  CDTEdge *ebc, *eca;
-  int count;
-#ifdef DEBUG_CDT
-  SymEdge *last;
-  const int dbg_level = 0;
-#endif
-
-  if (se->face == cdt->outer_face || sym(se)->face == cdt->outer_face) {
-    return;
-  }
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "retriangulate");
-    dump_se_cycle(se, "poly ", 1000);
-  }
-#endif
-  /* 'se' is a diagonal just added, and it is base of area to retriangulate (face on its left) */
-  count = 1;
-  for (ss = se->next; ss != se; ss = ss->next) {
-    count++;
-  }
-  if (count <= 3) {
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "nothing to do\n");
-    }
-#endif
-    return;
-  }
-  /* First and last are the SymEdges whose verts are first and last off of base,
-   * continuing from 'se'. */
-  first = se->next->next;
-  /* We want to make a triangle with 'se' as base and some other c as 3rd vertex. */
-  a = se->vert;
-  b = se->next->vert;
-  c = first->vert;
-  cse = first;
-#ifdef DEBUG_CDT
-  last = prev(se);
-  if (dbg_level > 1) {
-    dump_se(first, "first");
-    dump_se(last, "last");
-    dump_v(a, "a");
-    dump_v(b, "b");
-    dump_v(c, "c");
-  }
-#endif
-  for (ss = first->next; ss != se; ss = ss->next) {
-    v = ss->vert;
-    if (incircle(a->co, b->co, c->co, v->co) > 0.0) {
-      c = v;
-      cse = ss;
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        dump_v(c, "new c ");
-      }
-#endif
-    }
-  }
-  /* Add diagonals necessary to make abc a triangle. */
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "make triangle abc exist where\n");
-    dump_v(a, "  a");
-    dump_v(b, "  b");
-    dump_v(c, "  c");
-  }
-#endif
-  ebc = NULL;
-  eca = NULL;
-  if (!exists_edge(b, c)) {
-    ebc = add_diagonal(cdt, se->next, cse);
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "added edge ebc\n");
-      dump_se(&ebc->symedges[0], "  ebc");
-    }
-#endif
-  }
-  if (!exists_edge(c, a)) {
-    eca = add_diagonal(cdt, cse, se);
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "added edge eca\n");
-      dump_se(&eca->symedges[0], "  eca");
-    }
-#endif
-  }
-  /* Now recurse. */
-  if (ebc) {
-    re_delaunay_triangulate(cdt, &ebc->symedges[1]);
-  }
-  if (eca) {
-    re_delaunay_triangulate(cdt, &eca->symedges[1]);
-  }
-}
-
-static double tri_orient(const SymEdge *t)
-{
-  return orient2d(t->vert->co, t->next->vert->co, t->next->next->vert->co);
-}
-
-/**
- * The CrossData struct gives defines either an endpoint or an intermediate point
- * in the path we will take to insert an edge constraint.
- * Each such point will either be
- * (a) a vertex or
- * (b) a fraction lambda (0 < lambda < 1) along some SymEdge.]
- *
- * In general, lambda=0 indicates case a and lambda != 0 indicates case be.
- * The 'in' edge gives the destination attachment point of a diagonal from the previous crossing,
- * and the 'out' edge gives the origin attachment point of a diagonal to the next crossing.
- * But in some cases, 'in' and 'out' are undefined or not needed, and will be NULL.
- *
- * For case (a), 'vert' will be the vertex, and lambda will be 0, and 'in' will be the SymEdge from
- * 'vert' that has as face the one that you go through to get to this vertex. If you go exactly
- * along an edge then we set 'in' to NULL, since it won't be needed. The first crossing will have
- * 'in' = NULL. We set 'out' to the SymEdge that has the face we go though to get to the next
- * crossing, or, if the next crossing is a case (a), then it is the edge that goes to that next
- * vertex. 'out' wlll be NULL for the last one.
- *
- * For case (b), vert will be NULL at first, and later filled in with the created split vertex,
- * and 'in' will be the SymEdge that we go through, and lambda will be between 0 and 1,
- * the fraction from in's vert to in->next's vert to put the split vertex.
- * 'out' is not needed in this case, since the attachment point will be the sym of the first
- * half of the split edge.
- */
-typedef struct CrossData {
-  double lambda;
-  CDTVert *vert;
-  SymEdge *in;
-  SymEdge *out;
-} CrossData;
-
-static bool get_next_crossing_from_vert(CDT_state *cdt,
-                                        CrossData *cd,
-                                        CrossData *cd_next,
-                                        const CDTVert *v2);
-
-/**
- * As part of finding crossings, we found a case where the next crossing goes through vert v.
- * If it came from a previous vert in cd, then cd_out is the edge that leads from that to v.
- * Else cd_out can be NULL, because it won't be used.
- * Set *cd_next to indicate this. We can set 'in' but not 'out'.  We can set the 'out' of the
- * current cd.
- */
-static void fill_crossdata_for_through_vert(CDTVert *v,
-                                            SymEdge *cd_out,
-                                            CrossData *cd,
-                                            CrossData *cd_next)
-{
-  SymEdge *se;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-#endif
-
-  cd_next->lambda = 0.0;
-  cd_next->vert = v;
-  cd_next->in = NULL;
-  cd_next->out = NULL;
-  if (cd->lambda == 0.0) {
-    cd->out = cd_out;
-  }
-  else {
-    /* One of the edges in the triangle with edge sym(cd->in) contains v. */
-    se = sym(cd->in);
-    if (se->vert != v) {
-      se = se->next;
-      if (se->vert != v) {
-        se = se->next;
-      }
-    }
-    BLI_assert(se->vert == v);
-    cd_next->in = se;
-  }
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    dump_cross_data(cd, "cd through vert, cd");
-    dump_cross_data(cd_next, "cd_next through vert, cd");
-  }
-#endif
-}
-
-/**
- * As part of finding crossings, we found a case where orient tests say that the next crossing
- * is on the SymEdge t, while intersecting with the ray from curco to v2.
- * Find the intersection point and fill in the CrossData for that point.
- * It may turn out that when doing the intersection, we get an answer that says that
- * this case is better handled as through-vertex case instead, so we may do that.
- * In the latter case, we want to avoid a situation where the current crossing is on an edge
- * and the next will be an endpoint of the same edge. When that happens, we "rewrite history"
- * and turn the current crossing into a vert one, and then extend from there.
- *
- * We cannot fill cd_next's 'out' edge yet, in the case that the next one ends up being a vert
- * case. We need to fill in cd's 'out' edge if it was a vert case.
- */
-static void fill_crossdata_for_intersect(CDT_state *cdt,
-                                         const double *curco,
-                                         const CDTVert *v2,
-                                         SymEdge *t,
-                                         CrossData *cd,
-                                         CrossData *cd_next)
-{
-  CDTVert *va, *vb, *vc;
-  double lambda, mu, len_ab;
-  SymEdge *se_vcva, *se_vcvb;
-  int isect;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-#endif
-
-  va = t->vert;
-  vb = t->next->vert;
-  vc = t->next->next->vert;
-  se_vcvb = sym(t->next);
-  se_vcva = t->next->next;
-  BLI_assert(se_vcva->vert == vc && se_vcva->next->vert == va);
-  BLI_assert(se_vcvb->vert == vc && se_vcvb->next->vert == vb);
-  UNUSED_VARS_NDEBUG(vc);
-  isect = isect_seg_seg_v2_lambda_mu_db(va->co, vb->co, curco, v2->co, &lambda, &mu);
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    double co[2];
-    fprintf(stderr, "crossdata for intersect gets lambda=%.17g, mu=%.17g\n", lambda, mu);
-    fprintf(stderr,
-            "isect=%s\n",
-            isect == 2 ? "cross" : (isect == 1 ? "exact" : (isect == 0 ? "none" : "colinear")));
-    fprintf(stderr,
-            "va=v%d=(%g,%g), vb=v%d=(%g,%g), vc=v%d, curco=(%g,%g), v2=(%g,%g)\n",
-            va->index,
-            F2(va->co),
-            vb->index,
-            F2(vb->co),
-            vc->index,
-            F2(curco),
-            F2(v2->co));
-    dump_se_short(se_vcva, "vcva=");
-    dump_se_short(se_vcvb, " vcvb=");
-    interp_v2_v2v2_db(co, va->co, vb->co, lambda);
-    fprintf(stderr, "\nco=(%.17g,%.17g)\n", F2(co));
-  }
-#endif
-  switch (isect) {
-    case ISECT_LINE_LINE_CROSS:
-      len_ab = len_v2v2_db(va->co, vb->co);
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr,
-                "len_ab=%g, near a=%g, near b=%g\n",
-                len_ab,
-                lambda * len_ab,
-                (1.0 - lambda) * len_ab);
-      }
-#endif
-      if (lambda * len_ab <= cdt->epsilon) {
-        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
-      }
-      else if ((1.0 - lambda) * len_ab <= cdt->epsilon) {
-        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
-      }
-      else {
-        *cd_next = (CrossData){lambda, NULL, t, NULL};
-        if (cd->lambda == 0.0) {
-          cd->out = se_vcva;
-        }
-      }
-      break;
-    case ISECT_LINE_LINE_EXACT:
-      if (lambda == 0.0) {
-        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
-      }
-      else if (lambda == 1.0) {
-        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
-      }
-      else {
-        *cd_next = (CrossData){lambda, NULL, t, NULL};
-        if (cd->lambda == 0.0) {
-          cd->out = se_vcva;
-        }
-      }
-      break;
-    case ISECT_LINE_LINE_NONE:
-      /* It should be very near one end or other of segment. */
-      if (lambda <= 0.5) {
-        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
-      }
-      else {
-        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
-      }
-      break;
-    case ISECT_LINE_LINE_COLINEAR:
-      if (len_squared_v2v2_db(va->co, v2->co) <= len_squared_v2v2_db(vb->co, v2->co)) {
-        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
-      }
-      else {
-        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
-      }
-      break;
-  }
-}
-
-/**
- * As part of finding the crossings of a ray to v2, find the next crossing after 'cd', assuming
- * 'cd' represents a crossing that goes through a vertex.
- *
- * We do a rotational scan around cd's vertex, looking for the triangle where the ray from cd->vert
- * to v2 goes between the two arms from cd->vert, or where it goes along one of the edges.
- */
-static bool get_next_crossing_from_vert(CDT_state *cdt,
-                                        CrossData *cd,
-                                        CrossData *cd_next,
-                                        const CDTVert *v2)
-{
-  SymEdge *t, *tstart;
-  CDTVert *vcur, *va, *vb;
-  double orient1, orient2;
-  bool ok;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nget_next_crossing_from_vert\n");
-    dump_v(cd->vert, "  cd->vert");
-  }
-#endif
-
-  t = tstart = cd->vert->symedge;
-  vcur = cd->vert;
-  ok = false;
-  do {
-    /*
-     * The ray from vcur to v2 has to go either between two successive
-     * edges around vcur or exactly along them. This time through the
-     * loop, check to see if the ray goes along vcur-va
-     * or between vcur-va and vcur-vb, where va is the end of t
-     * and vb is the next vertex (on the next rot edge around vcur, but
-     * should also be the next vert of triangle starting with vcur-va.
-     */
-    if (t->face != cdt->outer_face && tri_orient(t) < 0.0) {
-      fprintf(stderr, "BAD TRI orientation %g\n", tri_orient(t)); /* TODO: handle this */
-#ifdef DEBUG_CDT
-      dump_se_cycle(t, "top of ccw scan loop", 4);
-#endif
-    }
-    va = t->next->vert;
-    vb = t->next->next->vert;
-    orient1 = orient2d(t->vert->co, va->co, v2->co);
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "non-final through vert case\n");
-      dump_v(va, " va");
-      dump_v(vb, " vb");
-      fprintf(stderr, "orient1=%g\n", orient1);
-    }
-#endif
-    if (orient1 == 0.0 && in_line(vcur->co, va->co, v2->co)) {
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "ray goes through va\n");
-      }
-#endif
-      fill_crossdata_for_through_vert(va, t, cd, cd_next);
-      ok = true;
-      break;
-    }
-    else if (t->face != cdt->outer_face) {
-      orient2 = orient2d(vcur->co, vb->co, v2->co);
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "orient2=%g\n", orient2);
-      }
-#endif
-      /* Don't handle orient2 == 0.0 case here: next rotation will get it. */
-      if (orient1 > 0.0 && orient2 < 0.0) {
-#ifdef DEBUG_CDT
-        if (dbg_level > 1) {
-          fprintf(stderr, "segment intersects\n");
-        }
-#endif
-        t = t->next;
-        fill_crossdata_for_intersect(cdt, vcur->co, v2, t, cd, cd_next);
-        ok = true;
-        break;
-      }
-    }
-  } while ((t = t->rot) != tstart);
-#ifdef DEBUG_CDT
-  if (!ok) {
-    /* Didn't find the exit! Shouldn't happen. */
-    fprintf(stderr, "shouldn't happen: can't find next crossing from vert\n");
-  }
-#endif
-  return ok;
-}
-
-/**
- * As part of finding the crossings of a ray to v2, find the next crossing after 'cd', assuming
- * 'cd' represents a crossing that goes through a an edge, not at either end of that edge.
- *
- * We have the triangle vb-va-vc, where va and vb are the split edge and vc is the third vertex on
- * that new side of the edge (should be closer to v2). The next crossing should be through vc or
- * intersecting vb-vc or va-vc.
- */
-static void get_next_crossing_from_edge(CDT_state *cdt,
-                                        CrossData *cd,
-                                        CrossData *cd_next,
-                                        const CDTVert *v2)
-{
-  double curco[2];
-  double orient;
-  CDTVert *va, *vb, *vc;
-  SymEdge *se_ac;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nget_next_crossing_from_edge\n");
-    fprintf(stderr, "  lambda=%.17g\n", cd->lambda);
-    dump_se_short(cd->in, "  cd->in");
-  }
-#endif
-
-  va = cd->in->vert;
-  vb = cd->in->next->vert;
-  interp_v2_v2v2_db(curco, va->co, vb->co, cd->lambda);
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "  curco=(%.17g,%.17g)\n", F2(curco));
-  }
-#endif
-  se_ac = sym(cd->in)->next;
-  vc = se_ac->next->vert;
-  orient = orient2d(curco, v2->co, vc->co);
-#ifdef DEBUG_CDT
-  if (dbg_level > 1) {
-    fprintf(stderr, "now searching with third vertex ");
-    dump_v(vc, "vc");
-    fprintf(stderr, "orient2d(cur, v2, vc) = %g\n", orient);
-  }
-#endif
-  if (orient < 0.0) {
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "curco--v2 intersects vb--vc\n");
-    }
-#endif
-    fill_crossdata_for_intersect(cdt, curco, v2, se_ac->next, cd, cd_next);
-  }
-  else if (orient > 0.0) {
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "curco--v2 intersects va--vc\n");
-    }
-#endif
-    fill_crossdata_for_intersect(cdt, curco, v2, se_ac, cd, cd_next);
-  }
-  else {
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "orient==0 case, so going through or to vc\n");
-    }
-#endif
-    *cd_next = (CrossData){0.0, vc, se_ac->next, NULL};
-  }
-}
-
-/**
- * Add a constrained edge between v1 and v2 to cdt structure.
- * This may result in a number of #CDTEdges created, due to intersections
- * and partial overlaps with existing cdt vertices and edges.
- * Each created #CDTEdge will have input_id added to its input_ids list.
- *
- * If \a r_edges is not NULL, the #CDTEdges generated or found that go from
- * v1 to v2 are put into that linked list, in order.
- *
- * Assumes that #BLI_constrained_delaunay_get_output has not been called yet.
- */
-static void add_edge_constraint(
-    CDT_state *cdt, CDTVert *v1, CDTVert *v2, int input_id, LinkNode **r_edges)
-{
-  SymEdge *t, *se, *tstart, *tnext;
-  int i, j, n, visit;
-  bool ok;
-  CrossData *crossings = NULL;
-  CrossData *cd, *cd_prev, *cd_next;
-  CDTVert *v;
-  CDTEdge *edge;
-  LinkNodePair edge_list = {NULL, NULL};
-  BLI_array_staticdeclare(crossings, 128);
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nADD_EDGE_CONSTRAINT\n");
-    dump_v(v1, "  1");
-    dump_v(v2, "  2");
-  }
-#endif
-
-  if (r_edges) {
-    *r_edges = NULL;
-  }
-
-  /*
-   * Handle two special cases first:
-   * 1) The two end vertices are the same (can happen because of merging).
-   * 2) There is already an edge between v1 and v2.
-   */
-  if (v1 == v2) {
-    return;
-  }
-  if ((t = find_symedge_between_verts(v1, v2)) != NULL) {
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "segment already there\n");
-    }
-#endif
-    add_to_input_ids(&t->edge->input_ids, input_id, cdt);
-    if (r_edges != NULL) {
-      BLI_linklist_append_pool(&edge_list, t->edge, cdt->listpool);
-      *r_edges = edge_list.list;
-    }
-    return;
-  }
-
-  /*
-   * Fill crossings array with CrossData points for intersection path from v1 to v2.
-   *
-   * At every point, the crossings array has the path so far, except that
-   * the .out field of the last element of it may not be known yet -- if that
-   * last element is a vertex, then we won't know the output edge until we
-   * find the next crossing.
-   *
-   * To protect against infinite loops, we keep track of which vertices
-   * we have visited by setting their visit_index to a new visit epoch.
-   *
-   * We check a special case first: where the segment is already there in
-   * one hop. Saves a bunch of orient2d tests in that common case.
-   */
-  visit = ++cdt->visit_count;
-  BLI_array_grow_one(crossings);
-  crossings[0] = (CrossData){0.0, v1, NULL, NULL};
-  while (!((n = BLI_array_len(crossings)) > 0 && crossings[n - 1].vert == v2)) {
-    BLI_array_grow_one(crossings);
-    cd = &crossings[n - 1];
-    cd_next = &crossings[n];
-    if (crossings[n - 1].lambda == 0.0) {
-      ok = get_next_crossing_from_vert(cdt, cd, cd_next, v2);
-    }
-    else {
-      get_next_crossing_from_edge(cdt, cd, cd_next, v2);
-    }
-    if (!ok || BLI_array_len(crossings) == 100000) {
-      /* Shouldn't happen but if does, just bail out. */
-#ifdef DEBUG_CDT
-      fprintf(stderr, "FAILURE adding segment, bailing out\n");
-#endif
-      BLI_array_free(crossings);
-      return;
-    }
-#ifdef DEBUG_CDT
-    if (dbg_level > 1) {
-      fprintf(stderr, "crossings[%d]: ", n);
-      dump_cross_data(&crossings[n], "");
-    }
-#endif
-    if (crossings[n].lambda == 0.0) {
-      if (crossings[n].vert->visit_index == visit) {
-        fprintf(stderr, "WHOOPS, REVISIT. Bailing out.\n"); /*TODO: desperation search here. */
-        BLI_array_free(crossings);
-        return;
-      }
-      crossings[n].vert->visit_index = visit;
-    }
-  }
-
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "\ncrossings found\n");
-    for (i = 0; i < BLI_array_len(crossings); i++) {
-      fprintf(stderr, "%d: ", i);
-      dump_cross_data(&crossings[i], "");
-      if (crossings[i].lambda == 0.0) {
-        if (i == 0 || crossings[i - 1].lambda == 0.0) {
-          BLI_assert(crossings[i].in == NULL);
-        }
-        else {
-          BLI_assert(crossings[i].in != NULL && crossings[i].in->vert == crossings[i].vert);
-          BLI_assert(crossings[i].in->face == sym(crossings[i - 1].in)->face);
-        }
-        if (i == BLI_array_len(crossings) - 1) {
-          BLI_assert(crossings[i].vert == v2);
-          BLI_assert(crossings[i].out == NULL);
-        }
-        else {
-          BLI_assert(crossings[i].out->vert == crossings[i].vert);
-          if (crossings[i + 1].lambda == 0.0) {
-            BLI_assert(crossings[i].out->next->vert == crossings[i + 1].vert);
-          }
-          else {
-            BLI_assert(crossings[i].out->face == crossings[i + 1].in->face);
-          }
-        }
-      }
-      else {
-        if (i > 0 && crossings[i - 1].lambda == 0.0) {
-          BLI_assert(crossings[i].in->face == crossings[i - 1].out->face);
-        }
-        BLI_assert(crossings[i].out == NULL);
-      }
-    }
-  }
-#endif
-
-  /*
-   * Postprocess crossings.
-   * Some crossings may have an intersection crossing followed
-   * by a vertex crossing that is on the same edge that was just
-   * intersected. We prefer to go directly from the previous
-   * crossing directly to the vertex. This may chain backwards.
-   *
-   * This loop marks certain crossings as "deleted", by setting
-   * their lambdas to -1.0.
-   */
-  for (i = 2; i < BLI_array_len(crossings); i++) {
-    cd = &crossings[i];
-    if (cd->lambda == 0.0) {
-      v = cd->vert;
-      for (j = i - 1; j > 0; j--) {
-        cd_prev = &crossings[j];
-        if ((cd_prev->lambda == 0.0 && cd_prev->vert != v) ||
-            (cd_prev->lambda != 0.0 && cd_prev->in->vert != v && cd_prev->in->next->vert != v)) {
-          break;
-        }
-        else {
-          cd_prev->lambda = -1.0; /* Mark cd_prev as 'deleted'. */
-#ifdef DEBUG_CDT
-          if (dbg_level > 0) {
-            fprintf(stderr, "deleted crossing %d\n", j);
-          }
-#endif
-        }
-      }
-      if (j < i - 1) {
-        /* Some crossings were deleted. Fix the in and out edges across gap. */
-        cd_prev = &crossings[j];
-        if (cd_prev->lambda == 0.0) {
-          se = find_symedge_between_verts(cd_prev->vert, v);
-          if (se == NULL) {
-#ifdef DEBUG_CDT
-            fprintf(stderr, "FAILURE(a) in delete crossings, bailing out.\n");
-#endif
-            BLI_array_free(crossings);
-            return;
-          }
-          cd_prev->out = se;
-          cd->in = NULL;
-        }
-        else {
-          se = find_symedge_with_face(v, sym(cd_prev->in)->face);
-          if (se == NULL) {
-#ifdef DEBUG_CDT
-            fprintf(stderr, "FAILURE(b) in delete crossings, bailing out.\n");
-#endif
-            BLI_array_free(crossings);
-            return;
-          }
-          cd->in = se;
-        }
-#ifdef DEBUG_CDT
-        if (dbg_level > 0) {
-          fprintf(stderr, "after deleting crossings:\n");
-          fprintf(stderr, "cross[%d]: ", j);
-          dump_cross_data(cd_prev, "");
-          fprintf(stderr, "cross[%d]: ", i);
-          dump_cross_data(cd, "");
-        }
-#endif
-      }
-    }
-  }
-
-  /*
-   * Insert all intersection points on constrained edges.
-   */
-  for (i = 0; i < BLI_array_len(crossings); i++) {
-    cd = &crossings[i];
-    if (cd->lambda != 0.0 && cd->lambda != -1.0 && is_constrained_edge(cd->in->edge)) {
-      edge = split_edge(cdt, cd->in, cd->lambda);
-      cd->vert = edge->symedges[0].vert;
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "insert vert for crossing %d: ", i);
-        dump_v(cd->vert, "inserted");
-      }
-#endif
-    }
-  }
-
-  /*
-   * Remove any crossed, non-intersected edges.
-   */
-  for (i = 0; i < BLI_array_len(crossings); i++) {
-    cd = &crossings[i];
-    if (cd->lambda != 0.0 && cd->lambda != -1.0 && !is_constrained_edge(cd->in->edge)) {
-      delete_edge(cdt, cd->in);
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "delete edge for crossing %d\n", i);
-      }
-#endif
-    }
-  }
-
-  /*
-   * Insert segments for v1->v2.
-   */
-  tstart = crossings[0].out;
-  for (i = 1; i < BLI_array_len(crossings); i++) {
-    cd = &crossings[i];
-    if (cd->lambda == -1.0) {
-      continue; /* This crossing was deleted. */
-    }
-    t = tnext = NULL;
-    if (cd->lambda != 0.0) {
-      if (is_constrained_edge(cd->in->edge)) {
-        t = cd->vert->symedge;
-        tnext = sym(t)->next;
-      }
-    }
-    else if (cd->lambda == 0.0) {
-      t = cd->in;
-      tnext = cd->out;
-      if (t == NULL) {
-        /* Previous non-deleted crossing must also have been a vert, and segment should exist. */
-        for (j = i - 1; j >= 0; j--) {
-          cd_prev = &crossings[j];
-          if (cd_prev->lambda != -1.0) {
-            break;
-          }
-        }
-        BLI_assert(cd_prev->lambda == 0.0);
-        BLI_assert(cd_prev->out->next->vert == cd->vert);
-#ifdef DEBUG_CDT
-        if (dbg_level > 1) {
-          fprintf(stderr, "edge to crossing %d already there\n", i);
-        }
-#endif
-        edge = cd_prev->out->edge;
-        add_to_input_ids(&edge->input_ids, input_id, cdt);
-      }
-    }
-    if (t != NULL) {
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "edge to crossing %d: insert diagonal between\n", i);
-        dump_se(tstart, "  ");
-        dump_se(t, " ");
-        dump_se_cycle(tstart, "tstart", 100);
-        dump_se_cycle(t, "t", 100);
-      }
-#endif
-      if (tstart->next->vert == t->vert) {
-        edge = tstart->edge;
-#ifdef DEBUG_CDT
-        if (dbg_level > 1) {
-          fprintf(stderr, "already there (b)\n");
-        }
-#endif
-      }
-      else {
-        edge = add_diagonal(cdt, tstart, t);
-      }
-      add_to_input_ids(&edge->input_ids, input_id, cdt);
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        fprintf(stderr, "added\n");
-      }
-#endif
-      if (r_edges != NULL) {
-        BLI_linklist_append_pool(&edge_list, edge, cdt->listpool);
-      }
-      /* Now retriangulate upper and lower gaps. */
-      re_delaunay_triangulate(cdt, &edge->symedges[0]);
-      re_delaunay_triangulate(cdt, &edge->symedges[1]);
-    }
-    if (i < BLI_array_len(crossings) - 1) {
-      if (tnext != NULL) {
-        tstart = tnext;
-#ifdef DEBUG_CDT
-        if (dbg_level > 1) {
-          fprintf(stderr, "now tstart = ");
-          dump_se(tstart, "");
-        }
-#endif
-      }
-    }
-  }
-
-  if (r_edges) {
-    *r_edges = edge_list.list;
-  }
-  BLI_array_free(crossings);
-}
-
-/**
- * Add face_id to the input_ids lists of all #CDTFace's on the interior of the input face with that
- * id. face_symedge is on edge of the boundary of the input face, with assumption that interior is
- * on the left of that SymEdge.
- *
- * The algorithm is: starting from the #CDTFace for face_symedge, add the face_id and then
- * process all adjacent faces where the adjacency isn't across an edge that was a constraint added
- * for the boundary of the input face.
- * fedge_start..fedge_end is the inclusive range of edge input ids that are for the given face.
- *
- * Note: if the input face is not CCW oriented, we'll be labeling the outside, not the inside.
- * Note 2: if the boundary has self-crossings, this method will arbitrarily pick one of the
- * contiguous set of faces enclosed by parts of the boundary, leaving the other such untagged. This
- * may be a feature instead of a bug if the first contiguous section is most of the face and the
- * others are tiny self-crossing triangles at some parts of the boundary. On the other hand, if
- * decide we want to handle these in full generality, then will need a more complicated algorithm
- * (using "inside" tests and a parity rule) to decide on the interior.
- */
-static void add_face_ids(
-    CDT_state *cdt, SymEdge *face_symedge, int face_id, int fedge_start, int fedge_end)
-{
-  Stack stack;
-  SymEdge *se, *se_start, *se_sym;
-  CDTFace *face, *face_other;
-  int visit;
-
-  /* Can't loop forever since eventually would visit every face. */
-  cdt->visit_count++;
-  visit = cdt->visit_count;
-  stack = NULL;
-  push(&stack, face_symedge, cdt);
-  while (!is_empty(&stack)) {
-    se = pop(&stack, cdt);
-    face = se->face;
-    if (face->visit_index == visit) {
-      continue;
-    }
-    face->visit_index = visit;
-    add_to_input_ids(&face->input_ids, face_id, cdt);
-    se_start = se;
-    for (se = se->next; se != se_start; se = se->next) {
-      if (!id_range_in_list(se->edge->input_ids, fedge_start, fedge_end)) {
-        se_sym = sym(se);
-        face_other = se_sym->face;
-        if (face_other->visit_index != visit) {
-          push(&stack, se_sym, cdt);
-        }
-      }
-    }
-  }
-}
-
-/* Delete_edge but try not to mess up outer face.
- * Also faces have symedges now, so make sure not
- * to mess those up either. */
-static void dissolve_symedge(CDT_state *cdt, SymEdge *se)
-{
-  SymEdge *symse = sym(se);
-  if (symse->face == cdt->outer_face) {
-    se = sym(se);
-    symse = sym(se);
-  }
-  if (cdt->outer_face->symedge == se || cdt->outer_face->symedge == symse) {
-    /* Advancing by 2 to get past possible 'sym(se)'. */
-    if (se->next->next == se) {
-      cdt->outer_face->symedge = NULL;
-    }
-    else {
-      cdt->outer_face->symedge = se->next->next;
-    }
-  }
-  else {
-    if (se->face->symedge == se) {
-      se->face->symedge = se->next;
-    }
-    if (symse->face->symedge == symse) {
-      symse->face->symedge = symse->next;
-    }
-  }
-  delete_edge(cdt, se);
-}
-
-/* Slow way to get face and start vertex index within face for edge id e. */
-static bool get_face_edge_id_indices(const CDT_input *in, int e, int *r_f, int *r_fi)
-{
-  int f;
-  int id;
-
-  id = in->edges_len;
-  if (e < id) {
-    return false;
-  }
-  for (f = 0; f < in->faces_len; f++) {
-    if (e < id + in->faces_len_table[f]) {
-      *r_f = f;
-      *r_fi = e - id;
-      return true;
-    }
-    id += in->faces_len_table[f];
-  }
-  return false;
-}
-
-/* Is pt_co when snapped to segment seg1 seg2 all of:
- * a) strictly within that segment
- * b) within epsilon from original pt_co
- * c) pt_co is not within epsilon of either seg1 or seg2.
- * Return true if so, and return in *r_lambda the fraction of the way from seg1 to seg2 of the
- * snapped point.
- */
-static bool check_vert_near_segment(const double *pt_co,
-                                    const double *seg1,
-                                    const double *seg2,
-                                    double epsilon_squared,
-                                    double *r_lambda)
-{
-  double lambda, snap_co[2];
-
-  lambda = closest_to_line_v2_db(snap_co, pt_co, seg1, seg2);
-  *r_lambda = lambda;
-  if (lambda <= 0.0 || lambda >= 1.0) {
-    return false;
-  }
-  if (len_squared_v2v2_db(pt_co, snap_co) > epsilon_squared) {
-    return false;
-  }
-  if (len_squared_v2v2_db(pt_co, seg1) <= epsilon_squared ||
-      len_squared_v2v2_db(pt_co, seg2) <= epsilon_squared) {
-    return false;
-  }
-  return true;
-}
-
-typedef struct EdgeVertLambda {
-  int e_id;
-  int v_id;
-  double lambda;
-} EdgeVertLambda;
-
-/* For sorting first by edge id, then by lambda, then by vert id. */
-static int evl_cmp(const void *a, const void *b)
-{
-  const EdgeVertLambda *area = a;
-  const EdgeVertLambda *sb = b;
-
-  if (area->e_id < sb->e_id) {
-    return -1;
-  }
-  else if (area->e_id > sb->e_id) {
-    return 1;
-  }
-  else if (area->lambda < sb->lambda) {
-    return -1;
-  }
-  else if (area->lambda > sb->lambda) {
-    return 1;
-  }
-  else if (area->v_id < sb->v_id) {
-    return -1;
-  }
-  else if (area->v_id > sb->v_id) {
-    return 1;
-  }
-  return 0;
-}
-
-/**
- * If epsilon > 0, and input doesn't have skip_modify_input == true,
- * check input to see if any constraint edge ends (including face edges) come
- * within epsilon of another edge.
- * For all such cases, we want to split the constraint edge at the point nearest to near vertex
- * and move the vertex coordinates to be on that edge.
- * But exclude cases where they come within epsilon of either end because those will be handled
- * by vertex merging in the main triangulation algorithm.
- *
- * If any such splits are found, make a new CDT_input reflecting this change, and provide an
- * edge map to map from edge ids in the new input space to edge ids in the old input space.
- *
- * TODO: replace naive O(n^2) algorithm with kdopbvh-based one.
- */
-static const CDT_input *modify_input_for_near_edge_ends(const CDT_input *input, int **r_edge_map)
-{
-  CDT_input *new_input = NULL;
-  int e, eprev, e1, e2, f, fi, flen, start, i, j;
-  int i_new, i_old, i_evl;
-  int v11, v12, v21, v22;
-  double co11[2], co12[2], co21[2], co22[2];
-  double lambda;
-  double eps = (double)input->epsilon;
-  double eps_sq = eps * eps;
-  int tot_edge_constraints, edges_len, tot_face_edges;
-  int new_tot_face_edges, new_tot_con_edges;
-  int delta_con_edges, delta_face_edges, cur_e_cnt;
-  int *edge_map;
-  int evl_len;
-  EdgeVertLambda *edge_vert_lambda = NULL;
-  BLI_array_staticdeclare(edge_vert_lambda, 128);
-#ifdef DEBUG_CDT
-  EdgeVertLambda *evl;
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nMODIFY INPUT\n\n");
-  }
-#endif
-
-  *r_edge_map = NULL;
-  if (input->epsilon == 0.0 || input->skip_input_modify ||
-      (input->edges_len == 0 && input->faces_len == 0)) {
-    return input;
-  }
-
-  /* Edge constraints are union of the explicitly provided edges and the implicit edges
-   * that are part of the provided faces. We index constraints by have the first input->edges_len
-   * ints standing for the explicit edge with the same index, and the rest being face edges in
-   * the order that the faces appear and then edges within those faces, with indices offset by
-   * input->edges_len.
-   * Calculate tot_edge_constraints to be the sum of the two kinds of edges.
-   * We first have to count the number of face edges.
-   * That is the same as the number of vertices in the faces table, which
-   * we can find by adding the last length to the last start.
-   */
-  edges_len = input->edges_len;
-  tot_edge_constraints = edges_len;
-  if (input->faces_len > 0) {
-    tot_face_edges = input->faces_start_table[input->faces_len - 1] +
-                     input->faces_len_table[input->faces_len - 1];
-  }
-  else {
-    tot_face_edges = 0;
-  }
-  tot_edge_constraints = edges_len + tot_face_edges;
-
-  for (e1 = 0; e1 < tot_edge_constraints - 1; e1++) {
-    if (e1 < edges_len) {
-      v11 = input->edges[e1][0];
-      v12 = input->edges[e1][1];
-    }
-    else {
-      if (!get_face_edge_id_indices(input, e1, &f, &fi)) {
-        /* Must be bad input. Will be caught later so don't need to signal here. */
-        continue;
-      }
-      start = input->faces_start_table[f];
-      flen = input->faces_len_table[f];
-      v11 = input->faces[start + fi];
-      v12 = input->faces[(fi == flen - 1) ? start : start + fi + 1];
-    }
-    for (e2 = e1 + 1; e2 < tot_edge_constraints; e2++) {
-      if (e2 < edges_len) {
-        v21 = input->edges[e2][0];
-        v22 = input->edges[e2][1];
-      }
-      else {
-        if (!get_face_edge_id_indices(input, e2, &f, &fi)) {
-          continue;
-        }
-        start = input->faces_start_table[f];
-        flen = input->faces_len_table[f];
-        v21 = input->faces[start + fi];
-        v22 = input->faces[(fi == flen - 1) ? start : start + fi + 1];
-      }
-      copy_v2db_v2fl(co11, input->vert_coords[v11]);
-      copy_v2db_v2fl(co12, input->vert_coords[v12]);
-      copy_v2db_v2fl(co21, input->vert_coords[v21]);
-      copy_v2db_v2fl(co22, input->vert_coords[v22]);
-      if (check_vert_near_segment(co11, co21, co22, eps_sq, &lambda)) {
-
-        BLI_array_append(edge_vert_lambda, ((EdgeVertLambda){e2, v11, lambda}));
-      }
-      if (check_vert_near_segment(co12, co21, co22, eps_sq, &lambda)) {
-        BLI_array_append(edge_vert_lambda, ((EdgeVertLambda){e2, v12, lambda}));
-      }
-      if (check_vert_near_segment(co21, co11, co12, eps_sq, &lambda)) {
-        BLI_array_append(edge_vert_lambda, ((EdgeVertLambda){e1, v21, lambda}));
-      }
-      if (check_vert_near_segment(co22, co11, co12, eps_sq, &lambda)) {
-        BLI_array_append(edge_vert_lambda, ((EdgeVertLambda){e1, v22, lambda}));
-      }
-    }
-  }
-
-  evl_len = BLI_array_len(edge_vert_lambda);
-  if (evl_len > 0) {
-    /* Sort to bring splits for each edge together,
-     * and for each edge, to be in order of lambda. */
-    qsort(edge_vert_lambda, evl_len, sizeof(EdgeVertLambda), evl_cmp);
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "\nafter sorting\n");
-      for (i = 0; i < evl_len; i++) {
-        evl = &edge_vert_lambda[i];
-        fprintf(stderr, "e%d, v%d, %g\n", evl->e_id, evl->v_id, evl->lambda);
-      }
-    }
-#endif
-
-    /* Remove dups in edge_vert_lambda, where dup means that the edge is the
-     * same, and the verts are either the same or will be merged by epsilon-nearness.
-     */
-    i = 0;
-    j = 0;
-    /* In loop, copy from position j to position i. */
-    for (j = 0; j < evl_len;) {
-      int k;
-      if (i != j) {
-        memmove(&edge_vert_lambda[i], &edge_vert_lambda[j], sizeof(EdgeVertLambda));
-      }
-      for (k = j + 1; k < evl_len; k++) {
-        int vj = edge_vert_lambda[j].v_id;
-        int vk = edge_vert_lambda[k].v_id;
-        if (vj != vk) {
-          if (len_squared_v2v2(input->vert_coords[vj], input->vert_coords[vk]) > (float)eps_sq) {
-            break;
-          }
-        }
-      }
-      j = k;
-      i++;
-    }
-
-    if (i != evl_len) {
-      evl_len = i;
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr, "\nduplicates eliminated\n");
-        for (i = 0; i < evl_len; i++) {
-          evl = &edge_vert_lambda[i];
-          fprintf(stderr, "e%d, v%d, %g\n", evl->e_id, evl->v_id, evl->lambda);
-        }
-      }
-#endif
-    }
-    /* Find delta in number of constraint edges and face edges.
-     * This may be overestimates of true number, due to duplicates. */
-    delta_con_edges = 0;
-    delta_face_edges = 0;
-    cur_e_cnt = 0;
-    eprev = -1;
-    for (i = 0; i < evl_len; i++) {
-      e = edge_vert_lambda[i].e_id;
-      if (i > 0 && e > eprev) {
-        /* New edge group. Previous group had cur_e_cnt split vertices.
-         * That is the delta in the number of edges needed in input since
-         * there will be cur_e_cnt + 1 edges replacing one edge.
-         */
-        if (eprev < edges_len) {
-          delta_con_edges += cur_e_cnt;
-        }
-        else {
-          delta_face_edges += cur_e_cnt;
-        }
-        cur_e_cnt = 1;
-        ;
-      }
-      else {
-        cur_e_cnt++;
-      }
-      eprev = e;
-    }
-    if (eprev < edges_len) {
-      delta_con_edges += cur_e_cnt;
-    }
-    else {
-      delta_face_edges += cur_e_cnt;
-    }
-    new_tot_con_edges = input->edges_len + delta_con_edges;
-    if (input->faces_len > 0) {
-      new_tot_face_edges = input->faces_start_table[input->faces_len - 1] +
-                           input->faces_len_table[input->faces_len - 1] + delta_face_edges;
-    }
-    else {
-      new_tot_face_edges = 0;
-    }
-
-    /* Allocate new CDT_input, now we know sizes needed (perhaps overestimated a bit).
-     * Caller will be responsible for freeing it and its arrays.
-     */
-    new_input = MEM_callocN(sizeof(CDT_input), __func__);
-    new_input->epsilon = input->epsilon;
-    new_input->verts_len = input->verts_len;
-    new_input->vert_coords = (float(*)[2])MEM_malloc_arrayN(
-        new_input->verts_len, 2 * sizeof(float), __func__);
-    /* We don't do it now, but may decide to change coords of snapped verts. */
-    memmove(new_input->vert_coords,
-            input->vert_coords,
-            (size_t)new_input->verts_len * sizeof(float) * 2);
-
-    if (edges_len > 0) {
-      new_input->edges_len = new_tot_con_edges;
-      new_input->edges = (int(*)[2])MEM_malloc_arrayN(
-          new_tot_con_edges, 2 * sizeof(int), __func__);
-    }
-
-    if (input->faces_len > 0) {
-      new_input->faces_len = input->faces_len;
-      new_input->faces_start_table = (int *)MEM_malloc_arrayN(
-          new_input->faces_len, sizeof(int), __func__);
-      new_input->faces_len_table = (int *)MEM_malloc_arrayN(
-          new_input->faces_len, sizeof(int), __func__);
-      new_input->faces = (int *)MEM_malloc_arrayN(new_tot_face_edges, sizeof(int), __func__);
-    }
-
-    edge_map = (int *)MEM_malloc_arrayN(
-        new_tot_con_edges + new_tot_face_edges, sizeof(int), __func__);
-    *r_edge_map = edge_map;
-
-    i_new = i_old = i_evl = 0;
-    e = edge_vert_lambda[0].e_id;
-    /* First do new constraint edges. */
-    for (i_old = 0; i_old < edges_len; i_old++) {
-      if (i_old < e) {
-        /* Edge for i_old not split; copy it into new_input. */
-        new_input->edges[i_new][0] = input->edges[i_old][0];
-        new_input->edges[i_new][1] = input->edges[i_old][1];
-        edge_map[i_new] = i_old;
-        i_new++;
-      }
-      else {
-        /* Edge for i_old is split. */
-        BLI_assert(i_old == e);
-        new_input->edges[i_new][0] = input->edges[i_old][0];
-        new_input->edges[i_new][1] = edge_vert_lambda[i_evl].v_id;
-        edge_map[i_new] = i_old;
-        i_new++;
-        i_evl++;
-        while (i_evl < evl_len && e == edge_vert_lambda[i_evl].e_id) {
-          new_input->edges[i_new][0] = new_input->edges[i_new - 1][1];
-          new_input->edges[i_new][1] = edge_vert_lambda[i_evl].v_id;
-          edge_map[i_new] = i_old;
-          i_new++;
-          i_evl++;
-        }
-        new_input->edges[i_new][0] = new_input->edges[i_new - 1][1];
-        new_input->edges[i_new][1] = input->edges[i_old][1];
-        edge_map[i_new] = i_old;
-        i_new++;
-        if (i_evl < evl_len) {
-          e = edge_vert_lambda[i_evl].e_id;
-        }
-        else {
-          e = INT_MAX;
-        }
-      }
-    }
-    BLI_assert(i_new <= new_tot_con_edges);
-    new_input->edges_len = i_new;
-
-    /* Now do face constraints. */
-    if (input->faces_len > 0) {
-      f = 0;
-      i_new = 0; /* Now will index cur place in new_input->faces. */
-      while (i_old < tot_edge_constraints) {
-        flen = input->faces_len_table[f];
-        BLI_assert(i_old - edges_len == input->faces_start_table[f]);
-        new_input->faces_start_table[f] = i_new;
-        if (i_old + flen - 1 < e) {
-          /* Face f is not split. */
-          for (j = 0; j < flen; j++) {
-            new_input->faces[i_new] = input->faces[i_old - edges_len + j];
-            edge_map[i_new + new_input->edges_len] = i_old + j;
-            i_new++;
-          }
-          i_old += flen;
-          new_input->faces_len_table[f] = flen;
-          f++;
-        }
-        else {
-          /* Face f has at least one split edge. */
-          int i_new_start = i_new;
-          for (j = 0; j < flen; j++) {
-            if (i_old + j < e) {
-              /* jth edge of f is not split. */
-              new_input->faces[i_new] = input->faces[i_old - edges_len + j];
-              edge_map[i_new + new_input->edges_len] = i_old + j;
-              i_new++;
-            }
-            else {
-              /* jth edge of f is split. */
-              BLI_assert(i_old + j == e);
-              new_input->faces[i_new] = input->faces[i_old - edges_len + j];
-              edge_map[i_new + new_input->edges_len] = i_old + j;
-              i_new++;
-              while (i_evl < evl_len && e == edge_vert_lambda[i_evl].e_id) {
-                new_input->faces[i_new] = edge_vert_lambda[i_evl].v_id;
-                edge_map[i_new + new_input->edges_len] = i_old + j;
-                i_new++;
-                i_evl++;
-              }
-              if (i_evl < evl_len) {
-                e = edge_vert_lambda[i_evl].e_id;
-              }
-              else {
-                e = INT_MAX;
-              }
-            }
-          }
-          new_input->faces_len_table[f] = i_new - i_new_start;
-          i_old += flen;
-          f++;
-        }
-      }
-    }
-
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "\nnew constraint edges\n");
-      for (i = 0; i < new_input->edges_len; i++) {
-        fprintf(stderr, "  e%d: (%d,%d)\n", i, new_input->edges[i][0], new_input->edges[i][1]);
-      }
-      fprintf(stderr, "\nnew faces\n");
-      for (f = 0; f < new_input->faces_len; f++) {
-        flen = new_input->faces_len_table[f];
-        start = new_input->faces_start_table[f];
-        fprintf(stderr, "  f%d: start=%d, len=%d\n    ", f, start, flen);
-        for (i = start; i < start + flen; i++) {
-          fprintf(stderr, "%d ", new_input->faces[i]);
-        }
-        fprintf(stderr, "\n");
-      }
-      fprintf(stderr, "\nedge map (new->old)\n");
-      for (i = 0; i < new_tot_con_edges + new_tot_face_edges; i++) {
-        fprintf(stderr, "  %d->%d\n", i, edge_map[i]);
-      }
-    }
-#endif
-  }
-
-  BLI_array_free(edge_vert_lambda);
-  if (new_input != NULL) {
-    return (const CDT_input *)new_input;
-  }
-  else {
-    return input;
-  }
-}
-
-static void free_modified_input(CDT_input *input)
-{
-  MEM_freeN(input->vert_coords);
-  if (input->edges != NULL) {
-    MEM_freeN(input->edges);
-  }
-  if (input->faces != NULL) {
-    MEM_freeN(input->faces);
-    MEM_freeN(input->faces_len_table);
-    MEM_freeN(input->faces_start_table);
-  }
-  MEM_freeN(input);
-}
-
-/* Return true if we can merge se's vert into se->next's vert
- * without making the area of any new triangle formed by doing
- * that into a zero or negative area triangle.*/
-static bool can_collapse(const SymEdge *se)
-{
-  SymEdge *loop_se;
-  const double *co = se->next->vert->co;
-
-  for (loop_se = se->rot; loop_se != se && loop_se->rot != se; loop_se = loop_se->rot) {
-    if (orient2d(co, loop_se->next->vert->co, loop_se->rot->next->vert->co) <= 0.0) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/*
- * Merge one end of e onto the other, fixing up surrounding faces.
- *
- * General situation looks something like:
- *
- *             c-----e
- *           /  \   / \
- *          /    \ /   \
- *         a------b-----f
- *          \    / \   /
- *           \  /   \ /
- *             d-----g
- *
- * where ab is the tiny edge. We want to merge a and b and delete edge ab.
- * We don't want to change the coordinates of input vertices [We could revisit this
- * in the future, as API def doesn't prohibit this, but callers will appreciate if they
- * don't change.]
- * Sometimes the collapse shouldn't happen because the triangles formed by the changed
- * edges may end up with zero or negative area (see can_collapse, above).
- * So don't choose a collapse direction that is not allowed or one that has an original vertex
- * as origin and a non-original vertex as destination.
- * If both collapse directions are allowed by that rule, pick the one with the lower original
- * index.
- *
- * After merging, the faces abc and adb disappear (if they are not the outer face).
- * Suppose we merge b onto a.
- * Then edges cb and db are deleted. Face cbe becomes cae and face bdg becomes adg.
- * Any other faces attached to b now have a in their place.
- * We can do this by rotating edges round b, replacing their vert references with a.
- * Similar statements can be made about what happens when a merges into b;
- * in code below we'll swap a and b to make above lettering work for a b->a merge.
- * Return the vert at the collapsed edge, if a collapse happens.
- */
-static CDTVert *collapse_tiny_edge(CDT_state *cdt, CDTEdge *e)
-{
-  CDTVert *va, *vb;
-  SymEdge *ab_se, *ba_se, *bd_se, *bc_se, *ad_se, *ac_se;
-  SymEdge *bg_se, *be_se, *se, *gb_se, *ca_se;
-  bool can_collapse_a_to_b, can_collapse_b_to_a;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-#endif
-
-  ab_se = &e->symedges[0];
-  ba_se = &e->symedges[1];
-  va = ab_se->vert;
-  vb = ba_se->vert;
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "\ncollapse_tiny_edge\n");
-    dump_se(&e->symedges[0], "tiny edge");
-    fprintf(stderr, "a = [%d], b = [%d]\n", va->index, vb->index);
-    validate_cdt(cdt, true, false, true);
-  }
-#endif
-  can_collapse_a_to_b = can_collapse(ab_se);
-  can_collapse_b_to_a = can_collapse(ba_se);
-  /* Now swap a and b if necessary and possible, so that from this point on we are collapsing b to
-   * a. */
-  if (va->index > vb->index || !can_collapse_b_to_a) {
-    if (can_collapse_a_to_b && !(is_original_vert(va, cdt) && !is_original_vert(vb, cdt))) {
-      SWAP(CDTVert *, va, vb);
-      ab_se = &e->symedges[1];
-      ba_se = &e->symedges[0];
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr, "swapped a and b\n");
-      }
-#endif
-    }
-    else {
-      /* Neither collapse direction is OK. */
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr, "neither collapse direction ok\n");
-      }
-#endif
-      return NULL;
-    }
-  }
-  bc_se = ab_se->next;
-  bd_se = ba_se->rot;
-  if (bd_se == ba_se) {
-    /* Shouldn't happen. Wire edge in outer face. */
-    fprintf(stderr, "unexpected wire edge\n");
-    return NULL;
-  }
-  vb->merge_to_index = va->merge_to_index == -1 ? va->index : va->merge_to_index;
-  vb->symedge = NULL;
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr,
-            "vb = v[%d] merges to va = v[%d], vb->merge_to_index=%d\n",
-            vb->index,
-            va->index,
-            vb->merge_to_index);
-  }
-#endif
-  /* First fix the vertex of intermediate triangles, like bgf. */
-  for (se = bd_se->rot; se != bc_se; se = se->rot) {
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      dump_se(se, "intermediate tri edge, setting vert to va");
-    }
-#endif
-    se->vert = va;
-  }
-  ad_se = sym(sym(bd_se)->rot);
-  ca_se = bc_se->next;
-  ac_se = sym(ca_se);
-  if (bd_se->rot != bc_se) {
-    bg_se = bd_se->rot;
-    be_se = sym(bc_se)->next;
-    gb_se = sym(bg_se);
-  }
-  else {
-    bg_se = NULL;
-    be_se = NULL;
-  }
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr, "delete bd, inputs to ad\n");
-    dump_se(bd_se, "  bd");
-    dump_se(ad_se, "  ad");
-    fprintf(stderr, "delete bc, inputs to ac\n");
-    dump_se(bc_se, "  bc");
-    dump_se(ac_se, "  ac");
-    fprintf(stderr, "delete ab\n");
-    dump_se(ab_se, "  ab");
-    if (bg_se != NULL) {
-      fprintf(stderr, "fix up bg, be\n");
-      dump_se(bg_se, "  bg");
-      dump_se(be_se, "  be");
-    }
-  }
-#endif
-  add_list_to_input_ids(&ad_se->edge->input_ids, bd_se->edge->input_ids, cdt);
-  delete_edge(cdt, bd_se);
-  add_list_to_input_ids(&ac_se->edge->input_ids, bc_se->edge->input_ids, cdt);
-  delete_edge(cdt, sym(bc_se));
-  /* At this point we have this:
-   *
-   *             c-----e
-   *           /      / \
-   *          /      /   \
-   *         a------b-----f
-   *          \      \   /
-   *           \      \ /
-   *             d-----g
-   *
-   * Or, if there is not bg_se and be_se, like this:
-   *
-   *             c
-   *           /
-   *          /
-   *         a------b
-   *          \
-   *           \
-   *             d
-   *
-   * (But we've already changed the vert field for bg, bf, ..., be to be va.)
-   */
-  if (bg_se != NULL) {
-    gb_se->next = ad_se;
-    ad_se->rot = bg_se;
-    ca_se->next = be_se;
-    be_se->rot = ac_se;
-    bg_se->vert = va;
-    be_se->vert = va;
-  }
-  else {
-    ca_se->next = ad_se;
-    ad_se->rot = ac_se;
-  }
-  /* Don't use delete_edge as it changes too much. */
-  ab_se->next = ab_se->rot = NULL;
-  ba_se->next = ba_se->rot = NULL;
-  if (va->symedge == ab_se) {
-    va->symedge = ac_se;
-  }
-  return va;
-}
-
-/*
- * Check to see if e is tiny (length <= epsilon) and queue it if so.
- */
-static void maybe_enqueue_small_feature(CDT_state *cdt, CDTEdge *e, LinkNodePair *tiny_edge_queue)
-{
-  SymEdge *se, *sesym;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nmaybe_enqueue_small_features\n");
-    dump_se(&e->symedges[0], "  se0");
-  }
-#endif
-
-  if (is_deleted_edge(e) || e->in_queue) {
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "returning because of e conditions\n");
-    }
-#endif
-    return;
-  }
-  se = &e->symedges[0];
-  sesym = &e->symedges[1];
-  if (len_squared_v2v2_db(se->vert->co, sesym->vert->co) <= cdt->epsilon_squared) {
-    BLI_linklist_append_pool(tiny_edge_queue, e, cdt->listpool);
-    e->in_queue = true;
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "Queue tiny edge\n");
-    }
-#endif
-  }
-}
-
-/* Consider all edges in rot ring around v for possible enqueing as small features .*/
-static void maybe_enqueue_small_features(CDT_state *cdt, CDTVert *v, LinkNodePair *tiny_edge_queue)
-{
-  SymEdge *se, *se_start;
-
-  se = se_start = v->symedge;
-  if (!se_start) {
-    return;
-  }
-  do {
-    maybe_enqueue_small_feature(cdt, se->edge, tiny_edge_queue);
-  } while ((se = se->rot) != se_start);
-}
-
-/* Collapse small edges (length <= epsilon) until no more exist.
- */
-static void remove_small_features(CDT_state *cdt)
-{
-  double epsilon = cdt->epsilon;
-  LinkNodePair tiny_edge_queue = {NULL, NULL};
-  BLI_mempool *pool = cdt->listpool;
-  LinkNode *ln;
-  CDTEdge *e;
-  CDTVert *v_change;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nREMOVE_SMALL_FEATURES, epsilon=%g\n", epsilon);
-  }
-#endif
-
-  if (epsilon == 0.0) {
-    return;
-  }
-
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    maybe_enqueue_small_feature(cdt, e, &tiny_edge_queue);
-  }
-
-  while (tiny_edge_queue.list != NULL) {
-    e = (CDTEdge *)BLI_linklist_pop_pool(&tiny_edge_queue.list, pool);
-    if (tiny_edge_queue.list == NULL) {
-      tiny_edge_queue.last_node = NULL;
-    }
-    e->in_queue = false;
-    if (is_deleted_edge(e)) {
-      continue;
-    }
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "collapse tiny edge\n");
-      dump_se(&e->symedges[0], "");
-    }
-#endif
-    v_change = collapse_tiny_edge(cdt, e);
-    if (v_change) {
-      maybe_enqueue_small_features(cdt, v_change, &tiny_edge_queue);
-    }
-  }
-}
-
-/* Remove all non-constraint edges. */
-static void remove_non_constraint_edges(CDT_state *cdt)
-{
-  LinkNode *ln;
-  CDTEdge *e;
-  SymEdge *se;
-
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    se = &e->symedges[0];
-    if (!is_deleted_edge(e) && !is_constrained_edge(e)) {
-      dissolve_symedge(cdt, se);
-    }
-  }
-}
-
-/*
- * Remove the non-constraint edges, but leave enough of them so that all of the
- * faces that would be bmesh faces (that is, the faces that have some input representative)
- * are valid: they can't have holes, they can't have repeated vertices, and they can't have
- * repeated edges.
- *
- * Not essential, but to make the result look more aesthetically nice,
- * remove the edges in order of decreasing length, so that it is more likely that the
- * final remaining support edges are short, and therefore likely to make a fairly
- * direct path from an outer face to an inner hole face.
- */
-
-/* For sorting edges by decreasing length (squared). */
-struct EdgeToSort {
-  double len_squared;
-  CDTEdge *e;
-};
-
-static int edge_to_sort_cmp(const void *a, const void *b)
-{
-  const struct EdgeToSort *e1 = a;
-  const struct EdgeToSort *e2 = b;
-
-  if (e1->len_squared > e2->len_squared) {
-    return -1;
-  }
-  else if (e1->len_squared < e2->len_squared) {
-    return 1;
-  }
-  return 0;
-}
-
-static void remove_non_constraint_edges_leave_valid_bmesh(CDT_state *cdt)
-{
-  LinkNode *ln;
-  CDTEdge *e;
-  SymEdge *se, *se2;
-  CDTFace *fleft, *fright;
-  bool dissolve;
-  size_t nedges;
-  int i, ndissolvable;
-  const double *co1, *co2;
-  struct EdgeToSort *sorted_edges;
-
-  nedges = 0;
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    nedges++;
-  }
-  if (nedges == 0) {
-    return;
-  }
-  sorted_edges = BLI_memarena_alloc(cdt->arena, nedges * sizeof(*sorted_edges));
-  i = 0;
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    if (!is_deleted_edge(e) && !is_constrained_edge(e)) {
-      sorted_edges[i].e = e;
-      co1 = e->symedges[0].vert->co;
-      co2 = e->symedges[1].vert->co;
-      sorted_edges[i].len_squared = len_squared_v2v2_db(co1, co2);
-      i++;
-    }
-  }
-  ndissolvable = i;
-  qsort(sorted_edges, ndissolvable, sizeof(*sorted_edges), edge_to_sort_cmp);
-  for (i = 0; i < ndissolvable; i++) {
-    e = sorted_edges[i].e;
-    se = &e->symedges[0];
-    dissolve = true;
-    if (true /*!edge_touches_frame(e)*/) {
-      fleft = se->face;
-      fright = sym(se)->face;
-      if (fleft != cdt->outer_face && fright != cdt->outer_face &&
-          (fleft->input_ids != NULL || fright->input_ids != NULL)) {
-        /* Is there another symedge with same left and right faces?
-         * Or is there a vertex not part of e touching the same left and right faces? */
-        for (se2 = se->next; dissolve && se2 != se; se2 = se2->next) {
-          if (sym(se2)->face == fright ||
-              (se2->vert != se->next->vert && vert_touches_face(se2->vert, fright))) {
-            dissolve = false;
-          }
-        }
-      }
-    }
-    if (dissolve) {
-      dissolve_symedge(cdt, se);
-    }
-  }
-}
-
-static void remove_outer_edges_until_constraints(CDT_state *cdt)
-{
-  LinkNode *fstack = NULL;
-  SymEdge *se, *se_start;
-  CDTFace *f, *fsym;
-  int visit = ++cdt->visit_count;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "remove_outer_edges_until_constraints\n");
-  }
-#endif
-
-  cdt->outer_face->visit_index = visit;
-  /* Walk around outer face, adding faces on other side of dissolvable edges to stack. */
-  se_start = se = cdt->outer_face->symedge;
-  do {
-    if (!is_constrained_edge(se->edge)) {
-      fsym = sym(se)->face;
-      if (fsym->visit_index != visit) {
-#ifdef DEBUG_CDT
-        if (dbg_level > 0) {
-          fprintf(stderr, "pushing f=%p from symedge ", fsym);
-          dump_se(se, "an outer edge");
-        }
-#endif
-        BLI_linklist_prepend_pool(&fstack, fsym, cdt->listpool);
-      }
-    }
-  } while ((se = se->next) != se_start);
-
-  while (fstack != NULL) {
-    LinkNode *to_dissolve = NULL;
-    bool dissolvable;
-    f = (CDTFace *)BLI_linklist_pop_pool(&fstack, cdt->listpool);
-    if (f->visit_index == visit) {
-#ifdef DEBUG_CDT
-      if (dbg_level > 0) {
-        fprintf(stderr, "skipping f=%p, already visited\n", f);
-      }
-#endif
-      continue;
-    }
-    BLI_assert(f != cdt->outer_face);
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "top of loop, f=%p\n", f);
-      dump_se_cycle(f->symedge, "visit", 10000);
-      if (dbg_level > 1) {
-        dump_cdt(cdt, "cdt at top of loop");
-        cdt_draw(cdt, "top of dissolve loop");
-      }
-    }
-#endif
-    f->visit_index = visit;
-    se_start = se = f->symedge;
-    do {
-      dissolvable = !is_constrained_edge(se->edge);
-#ifdef DEBUG_CDT
-      if (dbg_level > 1) {
-        dump_se(se, "edge in f");
-        fprintf(stderr, "  dissolvable=%d\n", dissolvable);
-      }
-#endif
-      if (dissolvable) {
-        fsym = sym(se)->face;
-#ifdef DEBUG_CDT
-        if (dbg_level > 1) {
-          dump_se_cycle(fsym->symedge, "fsym", 10000);
-          fprintf(stderr, "  visited=%d\n", fsym->visit_index == visit);
-        }
-#endif
-        if (fsym->visit_index != visit) {
-#ifdef DEBUG_CDT
-          if (dbg_level > 0) {
-            fprintf(stderr, "pushing face %p\n", fsym);
-            dump_se_cycle(fsym->symedge, "pushed", 10000);
-          }
-#endif
-          BLI_linklist_prepend_pool(&fstack, fsym, cdt->listpool);
-        }
-        else {
-          BLI_linklist_prepend_pool(&to_dissolve, se, cdt->listpool);
-        }
-      }
-      se = se->next;
-    } while (se != se_start);
-    while (to_dissolve != NULL) {
-      se = (SymEdge *)BLI_linklist_pop_pool(&to_dissolve, cdt->listpool);
-      if (se->next != NULL) {
-        dissolve_symedge(cdt, se);
-      }
-    }
-  }
-}
-
-/**
- * Remove edges and merge faces to get desired output, as per options.
- * \note the cdt cannot be further changed after this.
- */
-static void prepare_cdt_for_output(CDT_state *cdt, const CDT_output_type output_type)
-{
-  CDTFace *f;
-  CDTEdge *e;
-  LinkNode *ln;
-
-  cdt->output_prepared = true;
-  if (cdt->edges == NULL) {
-    return;
-  }
-
-  /* Make sure all non-deleted faces have a symedge. */
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    if (!is_deleted_edge(e)) {
-      if (e->symedges[0].face->symedge == NULL) {
-        e->symedges[0].face->symedge = &e->symedges[0];
-      }
-      if (e->symedges[1].face->symedge == NULL) {
-        e->symedges[1].face->symedge = &e->symedges[1];
-      }
-    }
-  }
-#ifdef DEBUG_CDT
-  /* All non-deleted faces should have a symedge now. */
-  for (ln = cdt->faces; ln; ln = ln->next) {
-    f = (CDTFace *)ln->link;
-    if (!f->deleted) {
-      BLI_assert(f->symedge != NULL);
-    }
-  }
-#else
-  UNUSED_VARS(f);
-#endif
-
-  if (output_type == CDT_CONSTRAINTS) {
-    remove_non_constraint_edges(cdt);
-  }
-  else if (output_type == CDT_CONSTRAINTS_VALID_BMESH) {
-    remove_non_constraint_edges_leave_valid_bmesh(cdt);
-  }
-  else if (output_type == CDT_INSIDE) {
-    remove_outer_edges_until_constraints(cdt);
-  }
-}
-
-static CDT_result *cdt_get_output(CDT_state *cdt,
-                                  const CDT_input *input,
-                                  const CDT_output_type output_type)
-{
-  int i, j, nv, ne, nf, faces_len_total;
-  int orig_map_size, orig_map_index;
-  int *vert_to_output_map;
-  CDT_result *result;
-  CDTVert *v;
-  LinkNode *lne, *lnf, *ln;
-  SymEdge *se, *se_start;
-  CDTEdge *e;
-  CDTFace *f;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-
-  if (dbg_level > 0) {
-    fprintf(stderr, "\nCDT_GET_OUTPUT\n\n");
-  }
-#endif
-
-  prepare_cdt_for_output(cdt, output_type);
-
-  result = (CDT_result *)MEM_callocN(sizeof(*result), __func__);
-  if (cdt->vert_array_len == 0) {
-    return result;
-  }
-
-#ifdef DEBUG_CDT
-  if (dbg_level > 1) {
-    dump_cdt(cdt, "cdt to output");
-  }
-#endif
-
-  /* All verts without a merge_to_index will be output.
-   * vert_to_output_map[i] will hold the output vertex index
-   * corresponding to the vert in position i in cdt->vert_array.
-   * Since merging picked the leftmost-lowermost representative,
-   * that is not necessarily the same as the vertex with the lowest original
-   * index (i.e., index in cdt->vert_array), so we need two passes:
-   * one to get the non-merged-to vertices in vert_to_output_map,
-   * and a second to put in the merge targets for merged-to vertices.
-   */
-  vert_to_output_map = BLI_memarena_alloc(cdt->arena, (size_t)cdt->vert_array_len * sizeof(int *));
-  nv = 0;
-  for (i = 0; i < cdt->vert_array_len; i++) {
-    v = cdt->vert_array[i];
-    if (v->merge_to_index == -1) {
-      vert_to_output_map[i] = nv;
-      nv++;
-    }
-  }
-  if (nv <= 0) {
-    return result;
-  }
-  if (nv < cdt->vert_array_len) {
-    for (i = 0; i < input->verts_len; i++) {
-      v = cdt->vert_array[i];
-      if (v->merge_to_index != -1) {
-        add_to_input_ids(&cdt->vert_array[v->merge_to_index]->input_ids, i, cdt);
-        vert_to_output_map[i] = vert_to_output_map[v->merge_to_index];
-      }
-    }
-  }
-
-  result->verts_len = nv;
-  result->vert_coords = MEM_malloc_arrayN(nv, sizeof(result->vert_coords[0]), __func__);
-
-  /* Make the vertex "orig" map arrays, mapping output verts to lists of input ones. */
-  orig_map_size = 0;
-  for (i = 0; i < cdt->vert_array_len; i++) {
-    if (cdt->vert_array[i]->merge_to_index == -1) {
-      orig_map_size += 1 + BLI_linklist_count(cdt->vert_array[i]->input_ids);
-    }
-  }
-  result->verts_orig_len_table = MEM_malloc_arrayN(nv, sizeof(int), __func__);
-  result->verts_orig_start_table = MEM_malloc_arrayN(nv, sizeof(int), __func__);
-  result->verts_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
-
-  orig_map_index = 0;
-  i = 0;
-  for (j = 0; j < cdt->vert_array_len; j++) {
-    v = cdt->vert_array[j];
-    if (v->merge_to_index == -1) {
-      result->vert_coords[i][0] = (float)v->co[0];
-      result->vert_coords[i][1] = (float)v->co[1];
-      result->verts_orig_start_table[i] = orig_map_index;
-      if (j < input->verts_len) {
-        result->verts_orig[orig_map_index++] = j;
-      }
-      for (ln = v->input_ids; ln; ln = ln->next) {
-        result->verts_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
-      }
-      result->verts_orig_len_table[i] = orig_map_index - result->verts_orig_start_table[i];
-      i++;
-    }
-  }
-
-  ne = 0;
-  orig_map_size = 0;
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    if (!is_deleted_edge(e)) {
-      ne++;
-      if (e->input_ids) {
-        orig_map_size += BLI_linklist_count(e->input_ids);
-      }
-    }
-  }
-  if (ne != 0) {
-    result->edges_len = ne;
-    result->face_edge_offset = cdt->face_edge_offset;
-    result->edges = MEM_malloc_arrayN(ne, sizeof(result->edges[0]), __func__);
-    result->edges_orig_len_table = MEM_malloc_arrayN(ne, sizeof(int), __func__);
-    result->edges_orig_start_table = MEM_malloc_arrayN(ne, sizeof(int), __func__);
-    if (orig_map_size > 0) {
-      result->edges_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
-    }
-    orig_map_index = 0;
-    i = 0;
-    for (lne = cdt->edges; lne; lne = lne->next) {
-      e = (CDTEdge *)lne->link;
-      if (!is_deleted_edge(e)) {
-        result->edges[i][0] = vert_to_output_map[e->symedges[0].vert->index];
-        result->edges[i][1] = vert_to_output_map[e->symedges[1].vert->index];
-        result->edges_orig_start_table[i] = orig_map_index;
-        for (ln = e->input_ids; ln; ln = ln->next) {
-          result->edges_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
-        }
-        result->edges_orig_len_table[i] = orig_map_index - result->edges_orig_start_table[i];
-        i++;
-      }
-    }
-  }
-
-  nf = 0;
-  faces_len_total = 0;
-  orig_map_size = 0;
-  for (ln = cdt->faces; ln; ln = ln->next) {
-    f = (CDTFace *)ln->link;
-    if (!f->deleted && f != cdt->outer_face) {
-      nf++;
-      se = se_start = f->symedge;
-      BLI_assert(se != NULL);
-      do {
-        faces_len_total++;
-        se = se->next;
-      } while (se != se_start);
-      if (f->input_ids) {
-        orig_map_size += BLI_linklist_count(f->input_ids);
-      }
-    }
-  }
-
-  if (nf != 0) {
-    result->faces_len = nf;
-    result->faces_len_table = MEM_malloc_arrayN(nf, sizeof(int), __func__);
-    result->faces_start_table = MEM_malloc_arrayN(nf, sizeof(int), __func__);
-    result->faces = MEM_malloc_arrayN(faces_len_total, sizeof(int), __func__);
-    result->faces_orig_len_table = MEM_malloc_arrayN(nf, sizeof(int), __func__);
-    result->faces_orig_start_table = MEM_malloc_arrayN(nf, sizeof(int), __func__);
-    if (orig_map_size > 0) {
-      result->faces_orig = MEM_malloc_arrayN(orig_map_size, sizeof(int), __func__);
-    }
-    orig_map_index = 0;
-    i = 0;
-    j = 0;
-    for (lnf = cdt->faces; lnf; lnf = lnf->next) {
-      f = (CDTFace *)lnf->link;
-      if (!f->deleted && f != cdt->outer_face) {
-        result->faces_start_table[i] = j;
-        se = se_start = f->symedge;
-        do {
-          result->faces[j++] = vert_to_output_map[se->vert->index];
-          se = se->next;
-        } while (se != se_start);
-        result->faces_len_table[i] = j - result->faces_start_table[i];
-        result->faces_orig_start_table[i] = orig_map_index;
-        for (ln = f->input_ids; ln; ln = ln->next) {
-          result->faces_orig[orig_map_index++] = POINTER_AS_INT(ln->link);
-        }
-        result->faces_orig_len_table[i] = orig_map_index - result->faces_orig_start_table[i];
-        i++;
-      }
-    }
-  }
-  return result;
-}
-
-/**
- * Calculate the Constrained Delaunay Triangulation of the 2d elements given in \a input.
- *
- * A Delaunay triangulation of a set of vertices is a triangulation where no triangle in the
- * triangulation has a circumcircle that strictly contains another vertex. Delaunay triangulations
- * are avoid long skinny triangles: they maximize the minimum angle of all triangles in the
- * triangulation.
- *
- * A Constrained Delaunay Triangulation adds the requirement that user-provided line segments must
- * appear as edges in the output (perhaps divided into several sub-segments). It is not required
- * that the input edges be non-intersecting: this routine will calculate the intersections. This
- * means that besides triangulating, this routine is also useful for general and robust 2d edge and
- * face intersection.
- *
- * This routine also takes an epsilon parameter in the \a input. Input vertices closer than epsilon
- * will be merged, and we collapse tiny edges (less than epsilon length).
- *
- * The current initial Deluanay triangulation algorithm is the Guibas-Stolfi Divide and Conquer
- * algorithm (see "Primitives for the Manipulation of General Subdivisions and the Computation of
- * Voronoi Diagrams"). and uses Shewchuk's exact predicates to issues where numeric errors cause
- * inconsistent geometric judgments. This is followed by inserting edge constraints (including the
- * edges implied by faces) using the algorithms discussed in "Fully Dynamic Constrained Delaunay
- * Triangulations" by Kallmann, Bieri, and Thalmann.
- *
- * \param input: points to a CDT_input struct which contains the vertices, edges, and faces to be
- * triangulated. \param output_type: specifies which edges to remove after doing the triangulation.
- * \return A pointer to an allocated CDT_result struct, which describes the triangulation in terms
- * of vertices, edges, and faces, and also has tables to map output elements back to input
- * elements. The caller must use BLI_delaunay_2d_cdt_free() on the result when done with it.
- *
- * See the header file BLI_delaunay_2d.h for details of the CDT_input and CDT_result structs and
- * the CDT_output_type enum.
- */
-CDT_result *BLI_delaunay_2d_cdt_calc(const CDT_input *input, const CDT_output_type output_type)
-{
-  int nv = input->verts_len;
-  int ne = input->edges_len;
-  int nf = input->faces_len;
-  int i, iv1, iv2, f, fedge_start, fedge_end, ei;
-  CDT_state *cdt;
-  CDTVert *v1, *v2;
-  CDTEdge *face_edge;
-  SymEdge *face_symedge;
-  LinkNode *edge_list;
-  CDT_result *result;
-  const CDT_input *input_orig;
-  int *new_edge_map;
-  static bool called_exactinit = false;
-#ifdef DEBUG_CDT
-  int dbg_level = 0;
-#endif
-
-  /* The exact orientation and incircle primitives need a one-time initialization of certain
-   * constants. */
-  if (!called_exactinit) {
-    exactinit();
-    called_exactinit = true;
-  }
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    fprintf(stderr,
-            "\n\nCDT CALC, nv=%d, ne=%d, nf=%d, eps=%g\n",
-            input->verts_len,
-            input->edges_len,
-            input->faces_len,
-            input->epsilon);
-  }
-  if (dbg_level == -1) {
-    write_cdt_input_to_file(input);
-  }
-#endif
-
-  if ((nv > 0 && input->vert_coords == NULL) || (ne > 0 && input->edges == NULL) ||
-      (nf > 0 && (input->faces == NULL || input->faces_start_table == NULL ||
-                  input->faces_len_table == NULL))) {
-#ifdef DEBUG_CDT
-    fprintf(stderr, "invalid input: unexpected NULL array(s)\n");
-#endif
-    return NULL;
-  }
-
-  input_orig = input;
-  input = modify_input_for_near_edge_ends(input, &new_edge_map);
-  if (input != input_orig) {
-    nv = input->verts_len;
-    ne = input->edges_len;
-    nf = input->faces_len;
-#ifdef DEBUG_CDT
-    if (dbg_level > 0) {
-      fprintf(stderr, "input modified for near ends; now ne=%d\n", ne);
-    }
-#endif
-  }
-  cdt = cdt_init(input);
-  initial_triangulation(cdt);
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    validate_cdt(cdt, true, false, false);
-    if (dbg_level > 1) {
-      cdt_draw(cdt, "after initial triangulation");
-    }
-  }
-#endif
-
-  for (i = 0; i < ne; i++) {
-    iv1 = input->edges[i][0];
-    iv2 = input->edges[i][1];
-    if (iv1 < 0 || iv1 >= nv || iv2 < 0 || iv2 >= nv) {
-#ifdef DEBUG_CDT
-      fprintf(stderr, "edge indices for e%d not valid: v1=%d, v2=%d, nv=%d\n", i, iv1, iv2, nv);
-#endif
-      continue;
-    }
-    v1 = cdt->vert_array[iv1];
-    v2 = cdt->vert_array[iv2];
-    if (v1->merge_to_index != -1) {
-      v1 = cdt->vert_array[v1->merge_to_index];
-    }
-    if (v2->merge_to_index != -1) {
-      v2 = cdt->vert_array[v2->merge_to_index];
-    }
-    if (new_edge_map) {
-      ei = new_edge_map[i];
-    }
-    else {
-      ei = i;
-    }
-    add_edge_constraint(cdt, v1, v2, ei, NULL);
-#ifdef DEBUG_CDT
-    if (dbg_level > 3) {
-      char namebuf[60];
-      sprintf(namebuf, "after edge constraint %d = (%d,%d)\n", i, iv1, iv2);
-      cdt_draw(cdt, namebuf);
-      // dump_cdt(cdt, namebuf);
-      validate_cdt(cdt, true, true, false);
-    }
-#endif
-  }
-
-  cdt->face_edge_offset = ne;
-  for (f = 0; f < nf; f++) {
-    int flen = input->faces_len_table[f];
-    int fstart = input->faces_start_table[f];
-    if (flen <= 2) {
-#ifdef DEBUG_CDT
-      fprintf(stderr, "face %d has length %d; ignored\n", f, flen);
-#endif
-      continue;
-    }
-    for (i = 0; i < flen; i++) {
-      int face_edge_id = cdt->face_edge_offset + fstart + i;
-      if (new_edge_map) {
-        face_edge_id = new_edge_map[face_edge_id];
-      }
-      iv1 = input->faces[fstart + i];
-      iv2 = input->faces[fstart + ((i + 1) % flen)];
-      if (iv1 < 0 || iv1 >= nv || iv2 < 0 || iv2 >= nv) {
-#ifdef DEBUG_CDT
-        fprintf(stderr, "face indices not valid: f=%d, iv1=%d, iv2=%d, nv=%d\n", f, iv1, iv2, nv);
-#endif
-        continue;
-      }
-      v1 = cdt->vert_array[iv1];
-      v2 = cdt->vert_array[iv2];
-      if (v1->merge_to_index != -1) {
-        v1 = cdt->vert_array[v1->merge_to_index];
-      }
-      if (v2->merge_to_index != -1) {
-        v2 = cdt->vert_array[v2->merge_to_index];
-      }
-      add_edge_constraint(cdt, v1, v2, face_edge_id, &edge_list);
-#ifdef DEBUG_CDT
-      if (dbg_level > 2) {
-        fprintf(stderr, "edges for edge %d:\n", i);
-        for (LinkNode *ln = edge_list; ln; ln = ln->next) {
-          CDTEdge *cdt_e = (CDTEdge *)ln->link;
-          fprintf(stderr,
-                  "  (%.2f,%.2f)->(%.2f,%.2f)\n",
-                  F2(cdt_e->symedges[0].vert->co),
-                  F2(cdt_e->symedges[1].vert->co));
-        }
-      }
-      if (dbg_level > 2) {
-        cdt_draw(cdt, "after a face edge");
-        if (dbg_level > 3) {
-          dump_cdt(cdt, "after a face edge");
-        }
-        validate_cdt(cdt, true, true, false);
-      }
-#endif
-      if (i == 0) {
-        face_edge = (CDTEdge *)edge_list->link;
-        face_symedge = &face_edge->symedges[0];
-        if (face_symedge->vert != v1) {
-          face_symedge = &face_edge->symedges[1];
-          BLI_assert(face_symedge->vert == v1);
-        }
-      }
-      BLI_linklist_free_pool(edge_list, NULL, cdt->listpool);
-    }
-    fedge_start = cdt->face_edge_offset + fstart;
-    fedge_end = fedge_start + flen - 1;
-    add_face_ids(cdt, face_symedge, f, fedge_start, fedge_end);
-  }
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    validate_cdt(cdt, true, true, false);
-  }
-  if (dbg_level > 1) {
-    cdt_draw(cdt, "after adding edges and faces");
-    if (dbg_level > 2) {
-      dump_cdt(cdt, "after adding edges and faces");
-    }
-  }
-#endif
-
-  if (cdt->epsilon > 0.0) {
-    remove_small_features(cdt);
-#ifdef DEBUG_CDT
-    if (dbg_level > 2) {
-      cdt_draw(cdt, "after remove small features\n");
-      if (dbg_level > 3) {
-        dump_cdt(cdt, "after remove small features\n");
-      }
-    }
-#endif
-  }
-
-  result = cdt_get_output(cdt, input, output_type);
-#ifdef DEBUG_CDT
-  if (dbg_level > 0) {
-    cdt_draw(cdt, "final");
-  }
-#endif
-
-  if (input != input_orig) {
-    free_modified_input((CDT_input *)input);
-  }
-  new_cdt_free(cdt);
-  return result;
-}
-
-void BLI_delaunay_2d_cdt_free(CDT_result *result)
-{
-  if (result == NULL) {
-    return;
-  }
-  if (result->vert_coords) {
-    MEM_freeN(result->vert_coords);
-  }
-  if (result->edges) {
-    MEM_freeN(result->edges);
-  }
-  if (result->faces) {
-    MEM_freeN(result->faces);
-  }
-  if (result->faces_start_table) {
-    MEM_freeN(result->faces_start_table);
-  }
-  if (result->faces_len_table) {
-    MEM_freeN(result->faces_len_table);
-  }
-  if (result->verts_orig) {
-    MEM_freeN(result->verts_orig);
-  }
-  if (result->verts_orig_start_table) {
-    MEM_freeN(result->verts_orig_start_table);
-  }
-  if (result->verts_orig_len_table) {
-    MEM_freeN(result->verts_orig_len_table);
-  }
-  if (result->edges_orig) {
-    MEM_freeN(result->edges_orig);
-  }
-  if (result->edges_orig_start_table) {
-    MEM_freeN(result->edges_orig_start_table);
-  }
-  if (result->edges_orig_len_table) {
-    MEM_freeN(result->edges_orig_len_table);
-  }
-  if (result->faces_orig) {
-    MEM_freeN(result->faces_orig);
-  }
-  if (result->faces_orig_start_table) {
-    MEM_freeN(result->faces_orig_start_table);
-  }
-  if (result->faces_orig_len_table) {
-    MEM_freeN(result->faces_orig_len_table);
-  }
-  MEM_freeN(result);
-}
-
-#ifdef DEBUG_CDT
-
-ATTU static const char *vertname(const CDTVert *v)
-{
-  static char vertnamebuf[20];
-
-  sprintf(vertnamebuf, "[%d]", v->index);
-  return vertnamebuf;
-}
-
-ATTU static const char *sename(const SymEdge *se)
-{
-  static char senamebuf[20];
-
-  sprintf(senamebuf, "{%x}", (POINTER_AS_UINT(se)) & 0xFFFF);
-  return senamebuf;
-}
-
-static void dump_v(const CDTVert *v, const char *lab)
-{
-  fprintf(stderr, "%s%s(%.10f,%.10f)\n", lab, vertname(v), F2(v->co));
-}
-
-static void dump_se(const SymEdge *se, const char *lab)
-{
-  if (se->next) {
-    fprintf(stderr,
-            "%s%s((%.10f,%.10f)->(%.10f,%.10f))",
-            lab,
-            vertname(se->vert),
-            F2(se->vert->co),
-            F2(se->next->vert->co));
-    fprintf(stderr, "%s\n", vertname(se->next->vert));
-  }
-  else {
-    fprintf(stderr, "%s%s((%.10f,%.10f)->NULL)\n", lab, vertname(se->vert), F2(se->vert->co));
-  }
-}
-
-static void dump_se_short(const SymEdge *se, const char *lab)
-{
-  if (se == NULL) {
-    fprintf(stderr, "%sNULL", lab);
-  }
-  else {
-    fprintf(stderr, "%s%s", lab, vertname(se->vert));
-    fprintf(stderr, "%s", se->next == NULL ? "[NULL]" : vertname(se->next->vert));
-  }
-}
-
-static void dump_se_cycle(const SymEdge *se, const char *lab, const int limit)
-{
-  int count = 0;
-  const SymEdge *s = se;
-  fprintf(stderr, "%s:\n", lab);
-  do {
-    dump_se(s, "  ");
-    s = s->next;
-    count++;
-  } while (s != se && count < limit);
-  if (count == limit) {
-    fprintf(stderr, "  limit hit without cycle!\n");
-  }
-}
-
-static void dump_id_list(const LinkNode *id_list, const char *lab)
-{
-  const LinkNode *ln;
-  if (!id_list) {
-    return;
-  }
-  fprintf(stderr, "%s", lab);
-  for (ln = id_list; ln; ln = ln->next) {
-    fprintf(stderr, "%d%c", POINTER_AS_INT(ln->link), ln->next ? ' ' : '\n');
-  }
-}
-
-static void dump_cross_data(struct CrossData *cd, const char *lab)
-{
-  fprintf(stderr, "%s", lab);
-  if (cd->lambda == 0.0) {
-    fprintf(stderr, "v%d", cd->vert->index);
-  }
-  else {
-    fprintf(stderr, "lambda=%.17g", cd->lambda);
-  }
-  dump_se_short(cd->in, " in=");
-  dump_se_short(cd->out, " out=");
-  fprintf(stderr, "\n");
-}
-
-/* If filter_fn != NULL, only dump vert v its edges when filter_fn(cdt, v, filter_data) is true. */
-#  define PL(p) (POINTER_AS_UINT(p) & 0xFFFF)
-static void dump_cdt_filtered(const CDT_state *cdt,
-                              bool (*filter_fn)(const CDT_state *, int, void *),
-                              void *filter_data,
-                              const char *lab)
-{
-  LinkNode *ln;
-  CDTVert *v, *vother;
-  CDTEdge *e;
-  CDTFace *f;
-  SymEdge *se;
-  int i, cnt;
-
-  fprintf(stderr, "\nCDT %s\n", lab);
-  fprintf(stderr, "\nVERTS\n");
-  for (i = 0; i < cdt->vert_array_len; i++) {
-    if (filter_fn && !filter_fn(cdt, i, filter_data)) {
-      continue;
-    }
-    v = cdt->vert_array[i];
-    fprintf(stderr, "%s %x: (%f,%f) symedge=%x", vertname(v), PL(v), F2(v->co), PL(v->symedge));
-    if (v->merge_to_index == -1) {
-      fprintf(stderr, "\n");
-    }
-    else {
-      fprintf(stderr, " merge to %s\n", vertname(cdt->vert_array[v->merge_to_index]));
-      continue;
-    }
-    dump_id_list(v->input_ids, "  ");
-    se = v->symedge;
-    cnt = 0;
-    if (se) {
-      fprintf(stderr, "  edges out:\n");
-      do {
-        if (se->next == NULL) {
-          fprintf(stderr, "    [NULL next/rot symedge, se=%x\n", PL(se));
-          break;
-        }
-        if (se->next->next == NULL) {
-          fprintf(stderr, "    [NULL next-next/rot symedge, se=%x\n", PL(se));
-          break;
-        }
-        vother = sym(se)->vert;
-        fprintf(stderr, "    %s (e=%x, se=%x)\n", vertname(vother), PL(se->edge), PL(se));
-        se = se->rot;
-        cnt++;
-      } while (se != v->symedge && cnt < 25);
-      fprintf(stderr, "\n");
-    }
-  }
-  if (filter_fn) {
-    return;
-  }
-  fprintf(stderr, "\nEDGES\n");
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    if (e->symedges[0].next == NULL) {
-      continue;
-    }
-    fprintf(stderr, "%x:\n", PL(e));
-    for (i = 0; i < 2; i++) {
-      se = &e->symedges[i];
-      fprintf(stderr,
-              "  se[%d] @%x: next=%x, rot=%x, vert=%x [%s] (%.2f,%.2f), edge=%x, face=%x\n",
-              i,
-              PL(se),
-              PL(se->next),
-              PL(se->rot),
-              PL(se->vert),
-              vertname(se->vert),
-              F2(se->vert->co),
-              PL(se->edge),
-              PL(se->face));
-    }
-    dump_id_list(e->input_ids, "  ");
-  }
-  fprintf(stderr, "\nFACES\n");
-  for (ln = cdt->faces; ln; ln = ln->next) {
-    f = (CDTFace *)ln->link;
-    if (f->deleted) {
-      continue;
-    }
-    if (f == cdt->outer_face) {
-      fprintf(stderr, "%x: outer", PL(f));
-    }
-    fprintf(stderr, " symedge=%x\n", PL(f->symedge));
-    dump_id_list(f->input_ids, "  ");
-  }
-  fprintf(stderr, "\nOTHER\n");
-  fprintf(stderr, "outer_face=%x\n", PL(cdt->outer_face));
-  fprintf(
-      stderr, "minx=%f, maxx=%f, miny=%f, maxy=%f\n", cdt->minx, cdt->maxx, cdt->miny, cdt->maxy);
-  fprintf(stderr, "margin=%f\n", cdt->margin);
-}
-#  undef PL
-
-static void dump_cdt(const CDT_state *cdt, const char *lab)
-{
-  dump_cdt_filtered(cdt, NULL, NULL, lab);
-}
-
-typedef struct ReachableFilterData {
-  int vstart_index;
-  int maxdist;
-} ReachableFilterData;
-
-/* Stupid algorithm will repeat itself. Don't use for large n. */
-static bool reachable_filter(const CDT_state *cdt, int v_index, void *filter_data)
-{
-  CDTVert *v;
-  SymEdge *se;
-  ReachableFilterData *rfd_in = (ReachableFilterData *)filter_data;
-  ReachableFilterData rfd_next;
-
-  if (v_index == rfd_in->vstart_index) {
-    return true;
-  }
-  if (rfd_in->maxdist <= 0 || v_index < 0 || v_index >= cdt->vert_array_len) {
-    return false;
-  }
-  else {
-    v = cdt->vert_array[v_index];
-    se = v->symedge;
-    if (se != NULL) {
-      rfd_next.vstart_index = rfd_in->vstart_index;
-      rfd_next.maxdist = rfd_in->maxdist - 1;
-      do {
-        if (reachable_filter(cdt, se->next->vert->index, &rfd_next)) {
-          return true;
-        }
-        se = se->rot;
-      } while (se != v->symedge);
-    }
-  }
-  return false;
-}
-
-static void set_min_max(CDT_state *cdt)
-{
-  int i;
-  double minx, maxx, miny, maxy;
-  double *co;
-
-  minx = miny = DBL_MAX;
-  maxx = maxy = -DBL_MAX;
-  for (i = 0; i < cdt->vert_array_len; i++) {
-    co = cdt->vert_array[i]->co;
-    if (co[0] < minx) {
-      minx = co[0];
-    }
-    if (co[0] > maxx) {
-      maxx = co[0];
-    }
-    if (co[1] < miny) {
-      miny = co[1];
-    }
-    if (co[1] > maxy) {
-      maxy = co[1];
-    }
-  }
-  if (minx != DBL_MAX) {
-    cdt->minx = minx;
-    cdt->miny = miny;
-    cdt->maxx = maxx;
-    cdt->maxy = maxy;
-  }
-}
-
-static void dump_cdt_vert_neighborhood(CDT_state *cdt, int v, int maxdist, const char *lab)
-{
-  ReachableFilterData rfd;
-  rfd.vstart_index = v;
-  rfd.maxdist = maxdist;
-  dump_cdt_filtered(cdt, reachable_filter, &rfd, lab);
-}
-
-/*
- * Make an html file with svg in it to display the argument cdt.
- * Mouse-overs will reveal the coordinates of vertices and edges.
- * Constraint edges are drawn thicker than non-constraint edges.
- * The first call creates DRAWFILE; subsequent calls append to it.
- */
-#  define DRAWFILE "/tmp/debug_draw.html"
-#  define MAX_DRAW_WIDTH 2000
-#  define MAX_DRAW_HEIGHT 1400
-#  define THIN_LINE 1
-#  define THICK_LINE 4
-#  define VERT_RADIUS 3
-#  define DRAW_VERT_LABELS 1
-#  define DRAW_EDGE_LABELS 0
-
-static void cdt_draw_region(
-    CDT_state *cdt, const char *lab, double minx, double miny, double maxx, double maxy)
-{
-  static bool append = false;
-  FILE *f = fopen(DRAWFILE, append ? "a" : "w");
-  int view_width, view_height;
-  double width, height, aspect, scale;
-  LinkNode *ln;
-  CDTVert *v, *u;
-  CDTEdge *e;
-  int i, strokew;
-
-  width = maxx - minx;
-  height = maxy - miny;
-  aspect = height / width;
-  view_width = MAX_DRAW_WIDTH;
-  view_height = (int)(view_width * aspect);
-  if (view_height > MAX_DRAW_HEIGHT) {
-    view_height = MAX_DRAW_HEIGHT;
-    view_width = (int)(view_height / aspect);
-  }
-  scale = view_width / width;
-
-#  define SX(x) ((x - minx) * scale)
-#  define SY(y) ((maxy - y) * scale)
-
-  if (!f) {
-    printf("couldn't open file %s\n", DRAWFILE);
-    return;
-  }
-  fprintf(f, "<div>%s</div>\n<div>\n", lab);
-  fprintf(f,
-          "<svg version=\"1.1\" "
-          "xmlns=\"http://www.w3.org/2000/svg\" "
-          "xmlns:xlink=\"http://www.w3.org/1999/xlink\" "
-          "xml:space=\"preserve\"\n");
-  fprintf(f, "width=\"%d\" height=\"%d\">/n", view_width, view_height);
-
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    if (is_deleted_edge(e)) {
-      continue;
-    }
-    u = e->symedges[0].vert;
-    v = e->symedges[1].vert;
-    strokew = is_constrained_edge(e) ? THICK_LINE : THIN_LINE;
-    fprintf(f,
-            "<line fill=\"none\" stroke=\"black\" stroke-width=\"%d\" "
-            "x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\">\n",
-            strokew,
-            SX(u->co[0]),
-            SY(u->co[1]),
-            SX(v->co[0]),
-            SY(v->co[1]));
-    fprintf(f, "  <title>%s", vertname(u));
-    fprintf(f, "%s</title>\n", vertname(v));
-    fprintf(f, "</line>\n");
-#  if DRAW_EDGE_LABELS
-    fprintf(f,
-            "<text x=\"%f\" y=\"%f\" font-size=\"small\">",
-            SX(0.5 * (u->co[0] + v->co[0])),
-            SY(0.5 * (u->co[1] + v->co[1])));
-    fprintf(f, "%s", vertname(u));
-    fprintf(f, "%s", vertname(v));
-    fprintf(f, "%s", sename(&e->symedges[0]));
-    fprintf(f, "%s</text>\n", sename(&e->symedges[1]));
-#  endif
-  }
-  i = 0;
-  for (; i < cdt->vert_array_len; i++) {
-    v = cdt->vert_array[i];
-    if (v->merge_to_index != -1) {
-      continue;
-    }
-    fprintf(f,
-            "<circle fill=\"black\" cx=\"%f\" cy=\"%f\" r=\"%d\">\n",
-            SX(v->co[0]),
-            SY(v->co[1]),
-            VERT_RADIUS);
-    fprintf(f, "  <title>%s(%.10f,%.10f)</title>\n", vertname(v), v->co[0], v->co[1]);
-    fprintf(f, "</circle>\n");
-#  if DRAW_VERT_LABELS
-    fprintf(f,
-            "<text x=\"%f\" y=\"%f\" font-size=\"small\">%s</text>\n",
-            SX(v->co[0]) + VERT_RADIUS,
-            SY(v->co[1]) - VERT_RADIUS,
-            vertname(v));
-#  endif
-  }
-
-  fprintf(f, "</svg>\n</div>\n");
-  fclose(f);
-  append = true;
-#  undef SX
-#  undef SY
-}
-
-static void cdt_draw(CDT_state *cdt, const char *lab)
-{
-  double draw_margin, minx, maxx, miny, maxy;
-
-  set_min_max(cdt);
-  draw_margin = (cdt->maxx - cdt->minx + cdt->maxy - cdt->miny + 1) * 0.05;
-  minx = cdt->minx - draw_margin;
-  maxx = cdt->maxx + draw_margin;
-  miny = cdt->miny - draw_margin;
-  maxy = cdt->maxy + draw_margin;
-  cdt_draw_region(cdt, lab, minx, miny, maxx, maxy);
-}
-
-static void cdt_draw_vertex_region(CDT_state *cdt, int v, double dist, const char *lab)
-{
-  const double *co = cdt->vert_array[v]->co;
-  cdt_draw_region(cdt, lab, co[0] - dist, co[1] - dist, co[0] + dist, co[1] + dist);
-}
-
-static void cdt_draw_edge_region(CDT_state *cdt, int v1, int v2, double dist, const char *lab)
-{
-  const double *co1 = cdt->vert_array[v1]->co;
-  const double *co2 = cdt->vert_array[v2]->co;
-  double minx, miny, maxx, maxy;
-
-  minx = min_dd(co1[0], co2[0]);
-  miny = min_dd(co1[1], co2[1]);
-  maxx = max_dd(co1[0], co2[0]);
-  maxy = max_dd(co1[1], co2[1]);
-  cdt_draw_region(cdt, lab, minx - dist, miny - dist, maxx + dist, maxy + dist);
-}
-
-#  define CDTFILE "/tmp/cdtinput.txt"
-static void write_cdt_input_to_file(const CDT_input *inp)
-{
-  int i, j;
-  FILE *f = fopen(CDTFILE, "w");
-
-  fprintf(f, "%d %d %d\n", inp->verts_len, inp->edges_len, inp->faces_len);
-  for (i = 0; i < inp->verts_len; i++) {
-    fprintf(f, "%.17f %.17f\n", inp->vert_coords[i][0], inp->vert_coords[i][1]);
-  }
-  for (i = 0; i < inp->edges_len; i++) {
-    fprintf(f, "%d %d\n", inp->edges[i][0], inp->edges[i][1]);
-  }
-  for (i = 0; i < inp->faces_len; i++) {
-    for (j = 0; j < inp->faces_len_table[i]; j++) {
-      fprintf(f, "%d ", inp->faces[j + inp->faces_start_table[i]]);
-    }
-    fprintf(f, "\n");
-  }
-  fclose(f);
-}
-
-#  ifndef NDEBUG /* Only used in assert. */
-/*
- * Is a visible from b: i.e., ab crosses no edge of cdt?
- * If constrained is true, consider only constrained edges as possible crossed edges.
- * In any case, don't count an edge ab itself.
- * Note: this is an expensive test if there are a lot of edges.
- */
-static bool is_visible(const CDTVert *a, const CDTVert *b, bool constrained, const CDT_state *cdt)
-{
-  const LinkNode *ln;
-  const CDTEdge *e;
-  const SymEdge *se, *senext;
-  double lambda, mu;
-  int ikind;
-
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (const CDTEdge *)ln->link;
-    if (is_deleted_edge(e) || is_border_edge(e, cdt)) {
-      continue;
-    }
-    if (constrained && !is_constrained_edge(e)) {
-      continue;
-    }
-    se = (const SymEdge *)&e->symedges[0];
-    senext = se->next;
-    if ((a == se->vert || a == senext->vert) || b == se->vert || b == se->next->vert) {
-      continue;
-    }
-    ikind = isect_seg_seg_v2_lambda_mu_db(
-        a->co, b->co, se->vert->co, senext->vert->co, &lambda, &mu);
-    if (ikind != ISECT_LINE_LINE_NONE) {
-      if (ikind == ISECT_LINE_LINE_COLINEAR) {
-        /* TODO: special test here for overlap. */
-        continue;
-      }
-      /* Allow an intersection very near or at ends, to allow for numerical error. */
-      if (lambda > FLT_EPSILON && (1.0 - lambda) > FLT_EPSILON && mu > FLT_EPSILON &&
-          (1.0 - mu) > FLT_EPSILON) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-#  endif
-
-#  ifndef NDEBUG /* Only used in assert. */
-/*
- * Check that edge ab satisfies constrained delaunay condition:
- * That is, for all non-constraint, non-border edges ab,
- * (1) ab is visible in the constraint graph; and
- * (2) there is a circle through a and b such that any vertex v connected by an edge to a or b
- *     is not inside that circle.
- * The argument 'se' specifies ab by: a is se's vert and b is se->next's vert.
- * Return true if check is OK.
- */
-static bool is_delaunay_edge(const SymEdge *se)
-{
-  int i;
-  CDTVert *a, *b, *c;
-  const SymEdge *sesym, *curse, *ss;
-  bool ok[2];
-
-  if (!is_constrained_edge(se->edge)) {
-    return true;
-  }
-  sesym = sym(se);
-  a = se->vert;
-  b = se->next->vert;
-  /* Try both the triangles adjacent to se's edge for circle. */
-  for (i = 0; i < 2; i++) {
-    ok[i] = true;
-    curse = (i == 0) ? se : sesym;
-    a = curse->vert;
-    b = curse->next->vert;
-    c = curse->next->next->vert;
-    for (ss = curse->rot; ss != curse; ss = ss->rot) {
-      ok[i] |= incircle(a->co, b->co, c->co, ss->next->vert->co) <= 0.0;
-    }
-  }
-  return ok[0] || ok[1];
-}
-#  endif
-
-#  ifndef NDEBUG
-static bool plausible_non_null_ptr(void *p)
-{
-  return p > (void *)0x1000;
-}
-#  endif
-
-static void validate_cdt(CDT_state *cdt,
-                         bool check_all_tris,
-                         bool check_delaunay,
-                         bool check_visibility)
-{
-  LinkNode *ln;
-  int totedges, totfaces, totverts;
-  CDTEdge *e;
-  SymEdge *se, *sesym, *s;
-  CDTVert *v, *v1, *v2, *v3;
-  CDTFace *f;
-  int i, limit;
-  bool isborder;
-
-  if (cdt->output_prepared) {
-    return;
-  }
-  if (cdt->edges == NULL || cdt->edges->next == NULL) {
-    return;
-  }
-
-  BLI_assert(cdt != NULL);
-  totedges = 0;
-  for (ln = cdt->edges; ln; ln = ln->next) {
-    e = (CDTEdge *)ln->link;
-    se = &e->symedges[0];
-    sesym = &e->symedges[1];
-    if (is_deleted_edge(e)) {
-      BLI_assert(se->rot == NULL && sesym->next == NULL && sesym->rot == NULL);
-      continue;
-    }
-    totedges++;
-    isborder = is_border_edge(e, cdt);
-    BLI_assert(se->vert != sesym->vert);
-    BLI_assert(se->edge == sesym->edge && se->edge == e);
-    BLI_assert(sym(se) == sesym && sym(sesym) == se);
-    for (i = 0; i < 2; i++) {
-      se = &e->symedges[i];
-      v = se->vert;
-      f = se->face;
-      BLI_assert(plausible_non_null_ptr(v));
-      if (f != NULL) {
-        BLI_assert(plausible_non_null_ptr(f));
-      }
-      BLI_assert(plausible_non_null_ptr(se->next));
-      BLI_assert(plausible_non_null_ptr(se->rot));
-      if (check_all_tris && se->face != cdt->outer_face) {
-        limit = 3;
-      }
-      else {
-        limit = 10000;
-      }
-      BLI_assert(reachable(se->next, se, limit));
-      if (limit == 3) {
-        v1 = se->vert;
-        v2 = se->next->vert;
-        v3 = se->next->next->vert;
-        /* The triangle should be positively oriented, but because
-         * the insertion of intersection vertices doesn't use exact
-         * arithmetic, this may not be true, so allow a little slop. */
-        BLI_assert(orient2d(v1->co, v2->co, v3->co) >= -FLT_EPSILON);
-        BLI_assert(orient2d(v2->co, v3->co, v1->co) >= -FLT_EPSILON);
-        BLI_assert(orient2d(v3->co, v1->co, v2->co) >= -FLT_EPSILON);
-      }
-      UNUSED_VARS_NDEBUG(limit);
-      BLI_assert(se->next->next != se);
-      s = se;
-      do {
-        BLI_assert(prev(s)->next == s);
-        BLI_assert(s->rot == sym(prev(s)));
-        s = s->next;
-      } while (s != se);
-    }
-    if (check_visibility) {
-      BLI_assert(isborder || is_visible(se->vert, se->next->vert, false, cdt));
-    }
-    if (!isborder && check_delaunay) {
-      BLI_assert(is_delaunay_edge(se));
-    }
-  }
-  totverts = 0;
-  for (i = 0; i < cdt->vert_array_len; i++) {
-    v = cdt->vert_array[i];
-    BLI_assert(plausible_non_null_ptr(v));
-    if (v->merge_to_index != -1) {
-      BLI_assert(v->merge_to_index >= 0 && v->merge_to_index < cdt->vert_array_len);
-      continue;
-    }
-    totverts++;
-    BLI_assert(cdt->vert_array_len <= 1 || v->symedge->vert == v);
-  }
-  totfaces = 0;
-  for (ln = cdt->faces; ln; ln = ln->next) {
-    f = (CDTFace *)ln->link;
-    BLI_assert(plausible_non_null_ptr(f));
-    if (f->deleted) {
-      continue;
-    }
-    totfaces++;
-    if (f == cdt->outer_face) {
-      continue;
-    }
-  }
-  /* Euler's formula for planar graphs. */
-  if (check_all_tris && totfaces > 1) {
-    BLI_assert(totverts - totedges + totfaces == 2);
-  }
-}
-#endif
-
-/* Jonathan Shewchuk's adaptive predicates, trimmed to those needed here.
- * Permission obtained by private communication from Jonathan to include this code in Blender.
- */
-
-/*
- *  Routines for Arbitrary Precision Floating-point Arithmetic
- *  and Fast Robust Geometric Predicates
- *  (predicates.c)
- *
- *  May 18, 1996
- *
- *  Placed in the public domain by
- *  Jonathan Richard Shewchuk
- *  School of Computer Science
- *  Carnegie Mellon University
- *  5000 Forbes Avenue
- *  Pittsburgh, Pennsylvania  15213-3891
- *  jrs@cs.cmu.edu
- *
- *  This file contains C implementation of algorithms for exact addition
- *    and multiplication of floating-point numbers, and predicates for
- *    robustly performing the orientation and incircle tests used in
- *    computational geometry.  The algorithms and underlying theory are
- *    described in Jonathan Richard Shewchuk.  "Adaptive Precision Floating-
- *    Point Arithmetic and Fast Robust Geometric Predicates."  Technical
- *    Report CMU-CS-96-140, School of Computer Science, Carnegie Mellon
- *    University, Pittsburgh, Pennsylvania, May 1996.  (Submitted to
- *    Discrete & Computational Geometry.)
- *
- *  This file, the paper listed above, and other information are available
- *    from the Web page http://www.cs.cmu.edu/~quake/robust.html .
- *
- *  Using this code:
- *
- *  First, read the short or long version of the paper (from the Web page
- *    above).
- *
- *  Be sure to call exactinit() once, before calling any of the arithmetic
- *    functions or geometric predicates.  Also be sure to turn on the
- *    optimizer when compiling this file.
- *
- * On some machines, the exact arithmetic routines might be defeated by the
- *   use of internal extended precision floating-point registers.  Sometimes
- *   this problem can be fixed by defining certain values to be volatile,
- *   thus forcing them to be stored to memory and rounded off.  This isn't
- *   a great solution, though, as it slows the arithmetic down.
- *
- * To try this out, write "#define INEXACT volatile" below.  Normally,
- *   however, INEXACT should be defined to be nothing.  ("#define INEXACT".)
- */
-
-#define INEXACT /* Nothing */
-/* #define INEXACT volatile */
-
-/* Which of the following two methods of finding the absolute values is
- *   fastest is compiler-dependent.  A few compilers can inline and optimize
- *   the fabs() call; but most will incur the overhead of a function call,
- *   which is disastrously slow.  A faster way on IEEE machines might be to
- *   mask the appropriate bit, but that's difficult to do in C.
- */
-
-#define Absolute(a) ((a) >= 0.0 ? (a) : -(a))
-/* #define Absolute(a)  fabs(a) */
-
-/* Many of the operations are broken up into two pieces, a main part that
- *   performs an approximate operation, and a "tail" that computes the
- *   roundoff error of that operation.
- *
- * The operations Fast_Two_Sum(), Fast_Two_Diff(), Two_Sum(), Two_Diff(),
- *   Split(), and Two_Product() are all implemented as described in the
- *   reference.  Each of these macros requires certain variables to be
- *   defined in the calling routine.  The variables `bvirt', `c', `abig',
- *   `_i', `_j', `_k', `_l', `_m', and `_n' are declared `INEXACT' because
- *   they store the result of an operation that may incur roundoff error.
- *   The input parameter `x' (or the highest numbered `x_' parameter) must
- *   also be declared `INEXACT'.
- */
-
-#define Fast_Two_Sum_Tail(a, b, x, y) \
-  bvirt = x - a; \
-  y = b - bvirt
-
-#define Fast_Two_Sum(a, b, x, y) \
-  x = (double)(a + b); \
-  Fast_Two_Sum_Tail(a, b, x, y)
-
-#define Fast_Two_Diff_Tail(a, b, x, y) \
-  bvirt = a - x; \
-  y = bvirt - b
-
-#define Fast_Two_Diff(a, b, x, y) \
-  x = (double)(a - b); \
-  Fast_Two_Diff_Tail(a, b, x, y)
-
-#define Two_Sum_Tail(a, b, x, y) \
-  bvirt = (double)(x - a); \
-  avirt = x - bvirt; \
-  bround = b - bvirt; \
-  around = a - avirt; \
-  y = around + bround
-
-#define Two_Sum(a, b, x, y) \
-  x = (double)(a + b); \
-  Two_Sum_Tail(a, b, x, y)
-
-#define Two_Diff_Tail(a, b, x, y) \
-  bvirt = (double)(a - x); \
-  avirt = x + bvirt; \
-  bround = bvirt - b; \
-  around = a - avirt; \
-  y = around + bround
-
-#define Two_Diff(a, b, x, y) \
-  x = (double)(a - b); \
-  Two_Diff_Tail(a, b, x, y)
-
-#define Split(a, ahi, alo) \
-  c = (double)(splitter * a); \
-  abig = (double)(c - a); \
-  ahi = c - abig; \
-  alo = a - ahi
-
-#define Two_Product_Tail(a, b, x, y) \
-  Split(a, ahi, alo); \
-  Split(b, bhi, blo); \
-  err1 = x - (ahi * bhi); \
-  err2 = err1 - (alo * bhi); \
-  err3 = err2 - (ahi * blo); \
-  y = (alo * blo) - err3
-
-#define Two_Product(a, b, x, y) \
-  x = (double)(a * b); \
-  Two_Product_Tail(a, b, x, y)
-
-#define Two_Product_Presplit(a, b, bhi, blo, x, y) \
-  x = (double)(a * b); \
-  Split(a, ahi, alo); \
-  err1 = x - (ahi * bhi); \
-  err2 = err1 - (alo * bhi); \
-  err3 = err2 - (ahi * blo); \
-  y = (alo * blo) - err3
-
-#define Square_Tail(a, x, y) \
-  Split(a, ahi, alo); \
-  err1 = x - (ahi * ahi); \
-  err3 = err1 - ((ahi + ahi) * alo); \
-  y = (alo * alo) - err3
-
-#define Square(a, x, y) \
-  x = (double)(a * a); \
-  Square_Tail(a, x, y)
-
-#define Two_One_Sum(a1, a0, b, x2, x1, x0) \
-  Two_Sum(a0, b, _i, x0); \
-  Two_Sum(a1, _i, x2, x1)
-
-#define Two_One_Diff(a1, a0, b, x2, x1, x0) \
-  Two_Diff(a0, b, _i, x0); \
-  Two_Sum(a1, _i, x2, x1)
-
-#define Two_Two_Sum(a1, a0, b1, b0, x3, x2, x1, x0) \
-  Two_One_Sum(a1, a0, b0, _j, _0, x0); \
-  Two_One_Sum(_j, _0, b1, x3, x2, x1)
-
-#define Two_Two_Diff(a1, a0, b1, b0, x3, x2, x1, x0) \
-  Two_One_Diff(a1, a0, b0, _j, _0, x0); \
-  Two_One_Diff(_j, _0, b1, x3, x2, x1)
-
-static double splitter;  /* = 2^ceiling(p / 2) + 1.  Used to split floats in half. */
-static double m_epsilon; /* = 2^(-p).  Used to estimate roundoff errors. */
-/* A set of coefficients used to calculate maximum roundoff errors. */
-static double resulterrbound;
-static double ccwerrboundA, ccwerrboundB, ccwerrboundC;
-static double o3derrboundA, o3derrboundB, o3derrboundC;
-static double iccerrboundA, iccerrboundB, iccerrboundC;
-static double isperrboundA, isperrboundB, isperrboundC;
-
-/*  exactinit()   Initialize the variables used for exact arithmetic.
- *
- *  `epsilon' is the largest power of two such that 1.0 + epsilon = 1.0 in
- *  floating-point arithmetic.  `epsilon' bounds the relative roundoff
- *  error.  It is used for floating-point error analysis.
- *
- *  `splitter' is used to split floating-point numbers into two
- *  half-length significands for exact multiplication.
- *
- *  I imagine that a highly optimizing compiler might be too smart for its
- *  own good, and somehow cause this routine to fail, if it pretends that
- *  floating-point arithmetic is too much like real arithmetic.
- *
- *  Don't change this routine unless you fully understand it.
- */
-
-static void exactinit(void)
-{
-  double half;
-  double check, lastcheck;
-  int every_other;
-
-  every_other = 1;
-  half = 0.5;
-  m_epsilon = 1.0;
-  splitter = 1.0;
-  check = 1.0;
-  /* Repeatedly divide `epsilon' by two until it is too small to add to
-   *   one without causing roundoff.  (Also check if the sum is equal to
-   *   the previous sum, for machines that round up instead of using exact
-   *   rounding.  Not that this library will work on such machines anyway.
-   */
-  do {
-    lastcheck = check;
-    m_epsilon *= half;
-    if (every_other) {
-      splitter *= 2.0;
-    }
-    every_other = !every_other;
-    check = 1.0 + m_epsilon;
-  } while ((check != 1.0) && (check != lastcheck));
-  splitter += 1.0;
-
-  /* Error bounds for orientation and incircle tests. */
-  resulterrbound = (3.0 + 8.0 * m_epsilon) * m_epsilon;
-  ccwerrboundA = (3.0 + 16.0 * m_epsilon) * m_epsilon;
-  ccwerrboundB = (2.0 + 12.0 * m_epsilon) * m_epsilon;
-  ccwerrboundC = (9.0 + 64.0 * m_epsilon) * m_epsilon * m_epsilon;
-  o3derrboundA = (7.0 + 56.0 * m_epsilon) * m_epsilon;
-  o3derrboundB = (3.0 + 28.0 * m_epsilon) * m_epsilon;
-  o3derrboundC = (26.0 + 288.0 * m_epsilon) * m_epsilon * m_epsilon;
-  iccerrboundA = (10.0 + 96.0 * m_epsilon) * m_epsilon;
-  iccerrboundB = (4.0 + 48.0 * m_epsilon) * m_epsilon;
-  iccerrboundC = (44.0 + 576.0 * m_epsilon) * m_epsilon * m_epsilon;
-  isperrboundA = (16.0 + 224.0 * m_epsilon) * m_epsilon;
-  isperrboundB = (5.0 + 72.0 * m_epsilon) * m_epsilon;
-  isperrboundC = (71.0 + 1408.0 * m_epsilon) * m_epsilon * m_epsilon;
-}
-
-/*  fast_expansion_sum_zeroelim()   Sum two expansions, eliminating zero
- *                                  components from the output expansion.
- *
- *  Sets h = e + f.  See the long version of my paper for details.
- *
- *  If round-to-even is used (as with IEEE 754), maintains the strongly
- *  non-overlapping property.  (That is, if e is strongly non-overlapping, h
- *  will be also.)  Does NOT maintain the non-overlapping or non-adjacent
- *  properties.
- */
-
-static int fast_expansion_sum_zeroelim(
-    int elen, double *e, int flen, double *f, double *h) /* h cannot be e or f. */
-{
-  double Q;
-  INEXACT double Qnew;
-  INEXACT double hh;
-  INEXACT double bvirt;
-  double avirt, bround, around;
-  int eindex, findex, hindex;
-  double enow, fnow;
-
-  enow = e[0];
-  fnow = f[0];
-  eindex = findex = 0;
-  if ((fnow > enow) == (fnow > -enow)) {
-    Q = enow;
-    enow = e[++eindex];
-  }
-  else {
-    Q = fnow;
-    fnow = f[++findex];
-  }
-  hindex = 0;
-  if ((eindex < elen) && (findex < flen)) {
-    if ((fnow > enow) == (fnow > -enow)) {
-      Fast_Two_Sum(enow, Q, Qnew, hh);
-      enow = e[++eindex];
-    }
-    else {
-      Fast_Two_Sum(fnow, Q, Qnew, hh);
-      fnow = f[++findex];
-    }
-    Q = Qnew;
-    if (hh != 0.0) {
-      h[hindex++] = hh;
-    }
-    while ((eindex < elen) && (findex < flen)) {
-      if ((fnow > enow) == (fnow > -enow)) {
-        Two_Sum(Q, enow, Qnew, hh);
-        enow = e[++eindex];
-      }
-      else {
-        Two_Sum(Q, fnow, Qnew, hh);
-        fnow = f[++findex];
-      }
-      Q = Qnew;
-      if (hh != 0.0) {
-        h[hindex++] = hh;
-      }
-    }
-  }
-  while (eindex < elen) {
-    Two_Sum(Q, enow, Qnew, hh);
-    enow = e[++eindex];
-    Q = Qnew;
-    if (hh != 0.0) {
-      h[hindex++] = hh;
-    }
-  }
-  while (findex < flen) {
-    Two_Sum(Q, fnow, Qnew, hh);
-    fnow = f[++findex];
-    Q = Qnew;
-    if (hh != 0.0) {
-      h[hindex++] = hh;
-    }
-  }
-  if ((Q != 0.0) || (hindex == 0)) {
-    h[hindex++] = Q;
-  }
-  return hindex;
-}
-
-/*  scale_expansion_zeroelim()   Multiply an expansion by a scalar,
- *                               eliminating zero components from the
- *                               output expansion.
- *
- *  Sets h = be.  See either version of my paper for details.
- *
- *  Maintains the nonoverlapping property.  If round-to-even is used (as
- *  with IEEE 754), maintains the strongly nonoverlapping and nonadjacent
- *  properties as well.  (That is, if e has one of these properties, so
- *  will h.)
- */
-
-static int scale_expansion_zeroelim(int elen,
-                                    double *e,
-                                    double b,
-                                    double *h) /* e and h cannot be the same. */
-{
-  INEXACT double Q, sum;
-  double hh;
-  INEXACT double product1;
-  double product0;
-  int eindex, hindex;
-  double enow;
-  INEXACT double bvirt;
-  double avirt, bround, around;
-  INEXACT double c;
-  INEXACT double abig;
-  double ahi, alo, bhi, blo;
-  double err1, err2, err3;
-
-  Split(b, bhi, blo);
-  Two_Product_Presplit(e[0], b, bhi, blo, Q, hh);
-  hindex = 0;
-  if (hh != 0) {
-    h[hindex++] = hh;
-  }
-  for (eindex = 1; eindex < elen; eindex++) {
-    enow = e[eindex];
-    Two_Product_Presplit(enow, b, bhi, blo, product1, product0);
-    Two_Sum(Q, product0, sum, hh);
-    if (hh != 0) {
-      h[hindex++] = hh;
-    }
-    Fast_Two_Sum(product1, sum, Q, hh);
-    if (hh != 0) {
-      h[hindex++] = hh;
-    }
-  }
-  if ((Q != 0.0) || (hindex == 0)) {
-    h[hindex++] = Q;
-  }
-  return hindex;
-}
-
-/*  estimate()   Produce a one-word estimate of an expansion's value.
- *
- *  See either version of my paper for details.
- */
-
-static double estimate(int elen, double *e)
-{
-  double Q;
-  int eindex;
-
-  Q = e[0];
-  for (eindex = 1; eindex < elen; eindex++) {
-    Q += e[eindex];
-  }
-  return Q;
-}
-
-/*  orient2d()   Adaptive exact 2D orientation test.  Robust.
- *
- *               Return a positive value if the points pa, pb, and pc occur
- *               in counterclockwise order; a negative value if they occur
- *               in clockwise order; and zero if they are collinear.  The
- *               result is also a rough approximation of twice the signed
- *               area of the triangle defined by the three points.
- *
- *  This uses exact arithmetic to ensure a correct answer.  The
- *  result returned is the determinant of a matrix.
- *  This determinant is computed adaptively, in the sense that exact
- *  arithmetic is used only to the degree it is needed to ensure that the
- *  returned value has the correct sign.  Hence, orient2d() is usually quite
- *  fast, but will run more slowly when the input points are collinear or
- *  nearly so.
- */
-
-static double orient2dadapt(const double *pa, const double *pb, const double *pc, double detsum)
-{
-  INEXACT double acx, acy, bcx, bcy;
-  double acxtail, acytail, bcxtail, bcytail;
-  INEXACT double detleft, detright;
-  double detlefttail, detrighttail;
-  double det, errbound;
-  double B[4], C1[8], C2[12], D[16];
-  INEXACT double B3;
-  int C1length, C2length, Dlength;
-  double u[4];
-  INEXACT double u3;
-  INEXACT double s1, t1;
-  double s0, t0;
-
-  INEXACT double bvirt;
-  double avirt, bround, around;
-  INEXACT double c;
-  INEXACT double abig;
-  double ahi, alo, bhi, blo;
-  double err1, err2, err3;
-  INEXACT double _i, _j;
-  double _0;
-
-  acx = (double)(pa[0] - pc[0]);
-  bcx = (double)(pb[0] - pc[0]);
-  acy = (double)(pa[1] - pc[1]);
-  bcy = (double)(pb[1] - pc[1]);
-
-  Two_Product(acx, bcy, detleft, detlefttail);
-  Two_Product(acy, bcx, detright, detrighttail);
-
-  Two_Two_Diff(detleft, detlefttail, detright, detrighttail, B3, B[2], B[1], B[0]);
-  B[3] = B3;
-
-  det = estimate(4, B);
-  errbound = ccwerrboundB * detsum;
-  if ((det >= errbound) || (-det >= errbound)) {
-    return det;
-  }
-
-  Two_Diff_Tail(pa[0], pc[0], acx, acxtail);
-  Two_Diff_Tail(pb[0], pc[0], bcx, bcxtail);
-  Two_Diff_Tail(pa[1], pc[1], acy, acytail);
-  Two_Diff_Tail(pb[1], pc[1], bcy, bcytail);
-
-  if ((acxtail == 0.0) && (acytail == 0.0) && (bcxtail == 0.0) && (bcytail == 0.0)) {
-    return det;
-  }
-
-  errbound = ccwerrboundC * detsum + resulterrbound * Absolute(det);
-  det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
-  if ((det >= errbound) || (-det >= errbound)) {
-    return det;
-  }
-
-  Two_Product(acxtail, bcy, s1, s0);
-  Two_Product(acytail, bcx, t1, t0);
-  Two_Two_Diff(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
-  u[3] = u3;
-  C1length = fast_expansion_sum_zeroelim(4, B, 4, u, C1);
-
-  Two_Product(acx, bcytail, s1, s0);
-  Two_Product(acy, bcxtail, t1, t0);
-  Two_Two_Diff(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
-  u[3] = u3;
-  C2length = fast_expansion_sum_zeroelim(C1length, C1, 4, u, C2);
-
-  Two_Product(acxtail, bcytail, s1, s0);
-  Two_Product(acytail, bcxtail, t1, t0);
-  Two_Two_Diff(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
-  u[3] = u3;
-  Dlength = fast_expansion_sum_zeroelim(C2length, C2, 4, u, D);
-
-  return (D[Dlength - 1]);
-}
-
-static double orient2d(const double *pa, const double *pb, const double *pc)
-{
-  double detleft, detright, det;
-  double detsum, errbound;
-
-  detleft = (pa[0] - pc[0]) * (pb[1] - pc[1]);
-  detright = (pa[1] - pc[1]) * (pb[0] - pc[0]);
-  det = detleft - detright;
-
-  if (detleft > 0.0) {
-    if (detright <= 0.0) {
-      return det;
-    }
-    else {
-      detsum = detleft + detright;
-    }
-  }
-  else if (detleft < 0.0) {
-    if (detright >= 0.0) {
-      return det;
-    }
-    else {
-      detsum = -detleft - detright;
-    }
-  }
-  else {
-    return det;
-  }
-
-  errbound = ccwerrboundA * detsum;
-  if ((det >= errbound) || (-det >= errbound)) {
-    return det;
-  }
-
-  return orient2dadapt(pa, pb, pc, detsum);
-}
-
-/*  incircle()   Adaptive exact 2D incircle test.  Robust.
- *
- *               Return a positive value if the point pd lies inside the
- *               circle passing through pa, pb, and pc; a negative value if
- *               it lies outside; and zero if the four points are cocircular.
- *               The points pa, pb, and pc must be in counterclockwise
- *               order, or the sign of the result will be reversed.
- *
- *  This uses exact arithmetic to ensure a correct answer.
- *  The result returned is the determinant of a matrix.
- *  This determinant is computed adaptively, in the sense that exact
- *  arithmetic is used only to the degree it is needed to ensure that the
- *  returned value has the correct sign.  Hence, incircle() is usually quite
- *  fast, but will run more slowly when the input points are cocircular or
- *  nearly so.
- */
-
-static double incircleadapt(
-    const double *pa, const double *pb, const double *pc, const double *pd, double permanent)
-{
-  INEXACT double adx, bdx, cdx, ady, bdy, cdy;
-  double det, errbound;
-
-  INEXACT double bdxcdy1, cdxbdy1, cdxady1, adxcdy1, adxbdy1, bdxady1;
-  double bdxcdy0, cdxbdy0, cdxady0, adxcdy0, adxbdy0, bdxady0;
-  double bc[4], ca[4], ab[4];
-  INEXACT double bc3, ca3, ab3;
-  double axbc[8], axxbc[16], aybc[8], ayybc[16], adet[32];
-  int axbclen, axxbclen, aybclen, ayybclen, alen;
-  double bxca[8], bxxca[16], byca[8], byyca[16], bdet[32];
-  int bxcalen, bxxcalen, bycalen, byycalen, blen;
-  double cxab[8], cxxab[16], cyab[8], cyyab[16], cdet[32];
-  int cxablen, cxxablen, cyablen, cyyablen, clen;
-  double abdet[64];
-  int ablen;
-  double fin1[1152], fin2[1152];
-  double *finnow, *finother, *finswap;
-  int finlength;
-
-  double adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
-  INEXACT double adxadx1, adyady1, bdxbdx1, bdybdy1, cdxcdx1, cdycdy1;
-  double adxadx0, adyady0, bdxbdx0, bdybdy0, cdxcdx0, cdycdy0;
-  double aa[4], bb[4], cc[4];
-  INEXACT double aa3, bb3, cc3;
-  INEXACT double ti1, tj1;
-  double ti0, tj0;
-  double u[4], v[4];
-  INEXACT double u3, v3;
-  double temp8[8], temp16a[16], temp16b[16], temp16c[16];
-  double temp32a[32], temp32b[32], temp48[48], temp64[64];
-  int temp8len, temp16alen, temp16blen, temp16clen;
-  int temp32alen, temp32blen, temp48len, temp64len;
-  double axtbb[8], axtcc[8], aytbb[8], aytcc[8];
-  int axtbblen, axtcclen, aytbblen, aytcclen;
-  double bxtaa[8], bxtcc[8], bytaa[8], bytcc[8];
-  int bxtaalen, bxtcclen, bytaalen, bytcclen;
-  double cxtaa[8], cxtbb[8], cytaa[8], cytbb[8];
-  int cxtaalen, cxtbblen, cytaalen, cytbblen;
-  double axtbc[8], aytbc[8], bxtca[8], bytca[8], cxtab[8], cytab[8];
-  int axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
-  double axtbct[16], aytbct[16], bxtcat[16], bytcat[16], cxtabt[16], cytabt[16];
-  int axtbctlen, aytbctlen, bxtcatlen, bytcatlen, cxtabtlen, cytabtlen;
-  double axtbctt[8], aytbctt[8], bxtcatt[8];
-  double bytcatt[8], cxtabtt[8], cytabtt[8];
-  int axtbcttlen, aytbcttlen, bxtcattlen, bytcattlen, cxtabttlen, cytabttlen;
-  double abt[8], bct[8], cat[8];
-  int abtlen, bctlen, catlen;
-  double abtt[4], bctt[4], catt[4];
-  int abttlen, bcttlen, cattlen;
-  INEXACT double abtt3, bctt3, catt3;
-  double negate;
-
-  INEXACT double bvirt;
-  double avirt, bround, around;
-  INEXACT double c;
-  INEXACT double abig;
-  double ahi, alo, bhi, blo;
-  double err1, err2, err3;
-  INEXACT double _i, _j;
-  double _0;
-
-  adx = (double)(pa[0] - pd[0]);
-  bdx = (double)(pb[0] - pd[0]);
-  cdx = (double)(pc[0] - pd[0]);
-  ady = (double)(pa[1] - pd[1]);
-  bdy = (double)(pb[1] - pd[1]);
-  cdy = (double)(pc[1] - pd[1]);
-
-  Two_Product(bdx, cdy, bdxcdy1, bdxcdy0);
-  Two_Product(cdx, bdy, cdxbdy1, cdxbdy0);
-  Two_Two_Diff(bdxcdy1, bdxcdy0, cdxbdy1, cdxbdy0, bc3, bc[2], bc[1], bc[0]);
-  bc[3] = bc3;
-  axbclen = scale_expansion_zeroelim(4, bc, adx, axbc);
-  axxbclen = scale_expansion_zeroelim(axbclen, axbc, adx, axxbc);
-  aybclen = scale_expansion_zeroelim(4, bc, ady, aybc);
-  ayybclen = scale_expansion_zeroelim(aybclen, aybc, ady, ayybc);
-  alen = fast_expansion_sum_zeroelim(axxbclen, axxbc, ayybclen, ayybc, adet);
-
-  Two_Product(cdx, ady, cdxady1, cdxady0);
-  Two_Product(adx, cdy, adxcdy1, adxcdy0);
-  Two_Two_Diff(cdxady1, cdxady0, adxcdy1, adxcdy0, ca3, ca[2], ca[1], ca[0]);
-  ca[3] = ca3;
-  bxcalen = scale_expansion_zeroelim(4, ca, bdx, bxca);
-  bxxcalen = scale_expansion_zeroelim(bxcalen, bxca, bdx, bxxca);
-  bycalen = scale_expansion_zeroelim(4, ca, bdy, byca);
-  byycalen = scale_expansion_zeroelim(bycalen, byca, bdy, byyca);
-  blen = fast_expansion_sum_zeroelim(bxxcalen, bxxca, byycalen, byyca, bdet);
-
-  Two_Product(adx, bdy, adxbdy1, adxbdy0);
-  Two_Product(bdx, ady, bdxady1, bdxady0);
-  Two_Two_Diff(adxbdy1, adxbdy0, bdxady1, bdxady0, ab3, ab[2], ab[1], ab[0]);
-  ab[3] = ab3;
-  cxablen = scale_expansion_zeroelim(4, ab, cdx, cxab);
-  cxxablen = scale_expansion_zeroelim(cxablen, cxab, cdx, cxxab);
-  cyablen = scale_expansion_zeroelim(4, ab, cdy, cyab);
-  cyyablen = scale_expansion_zeroelim(cyablen, cyab, cdy, cyyab);
-  clen = fast_expansion_sum_zeroelim(cxxablen, cxxab, cyyablen, cyyab, cdet);
-
-  ablen = fast_expansion_sum_zeroelim(alen, adet, blen, bdet, abdet);
-  finlength = fast_expansion_sum_zeroelim(ablen, abdet, clen, cdet, fin1);
-
-  det = estimate(finlength, fin1);
-  errbound = iccerrboundB * permanent;
-  if ((det >= errbound) || (-det >= errbound)) {
-    return det;
-  }
-
-  Two_Diff_Tail(pa[0], pd[0], adx, adxtail);
-  Two_Diff_Tail(pa[1], pd[1], ady, adytail);
-  Two_Diff_Tail(pb[0], pd[0], bdx, bdxtail);
-  Two_Diff_Tail(pb[1], pd[1], bdy, bdytail);
-  Two_Diff_Tail(pc[0], pd[0], cdx, cdxtail);
-  Two_Diff_Tail(pc[1], pd[1], cdy, cdytail);
-  if ((adxtail == 0.0) && (bdxtail == 0.0) && (cdxtail == 0.0) && (adytail == 0.0) &&
-      (bdytail == 0.0) && (cdytail == 0.0)) {
-    return det;
-  }
-
-  errbound = iccerrboundC * permanent + resulterrbound * Absolute(det);
-  det += ((adx * adx + ady * ady) *
-              ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
-          2.0 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
-         ((bdx * bdx + bdy * bdy) *
-              ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
-          2.0 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
-         ((cdx * cdx + cdy * cdy) *
-              ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
-          2.0 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
-  if ((det >= errbound) || (-det >= errbound)) {
-    return det;
-  }
-
-  finnow = fin1;
-  finother = fin2;
-
-  if ((bdxtail != 0.0) || (bdytail != 0.0) || (cdxtail != 0.0) || (cdytail != 0.0)) {
-    Square(adx, adxadx1, adxadx0);
-    Square(ady, adyady1, adyady0);
-    Two_Two_Sum(adxadx1, adxadx0, adyady1, adyady0, aa3, aa[2], aa[1], aa[0]);
-    aa[3] = aa3;
-  }
-  if ((cdxtail != 0.0) || (cdytail != 0.0) || (adxtail != 0.0) || (adytail != 0.0)) {
-    Square(bdx, bdxbdx1, bdxbdx0);
-    Square(bdy, bdybdy1, bdybdy0);
-    Two_Two_Sum(bdxbdx1, bdxbdx0, bdybdy1, bdybdy0, bb3, bb[2], bb[1], bb[0]);
-    bb[3] = bb3;
-  }
-  if ((adxtail != 0.0) || (adytail != 0.0) || (bdxtail != 0.0) || (bdytail != 0.0)) {
-    Square(cdx, cdxcdx1, cdxcdx0);
-    Square(cdy, cdycdy1, cdycdy0);
-    Two_Two_Sum(cdxcdx1, cdxcdx0, cdycdy1, cdycdy0, cc3, cc[2], cc[1], cc[0]);
-    cc[3] = cc3;
-  }
-
-  if (adxtail != 0.0) {
-    axtbclen = scale_expansion_zeroelim(4, bc, adxtail, axtbc);
-    temp16alen = scale_expansion_zeroelim(axtbclen, axtbc, 2.0 * adx, temp16a);
-
-    axtcclen = scale_expansion_zeroelim(4, cc, adxtail, axtcc);
-    temp16blen = scale_expansion_zeroelim(axtcclen, axtcc, bdy, temp16b);
-
-    axtbblen = scale_expansion_zeroelim(4, bb, adxtail, axtbb);
-    temp16clen = scale_expansion_zeroelim(axtbblen, axtbb, -cdy, temp16c);
-
-    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
-    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
-    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-    finswap = finnow;
-    finnow = finother;
-    finother = finswap;
-  }
-  if (adytail != 0.0) {
-    aytbclen = scale_expansion_zeroelim(4, bc, adytail, aytbc);
-    temp16alen = scale_expansion_zeroelim(aytbclen, aytbc, 2.0 * ady, temp16a);
-
-    aytbblen = scale_expansion_zeroelim(4, bb, adytail, aytbb);
-    temp16blen = scale_expansion_zeroelim(aytbblen, aytbb, cdx, temp16b);
-
-    aytcclen = scale_expansion_zeroelim(4, cc, adytail, aytcc);
-    temp16clen = scale_expansion_zeroelim(aytcclen, aytcc, -bdx, temp16c);
-
-    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
-    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
-    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-    finswap = finnow;
-    finnow = finother;
-    finother = finswap;
-  }
-  if (bdxtail != 0.0) {
-    bxtcalen = scale_expansion_zeroelim(4, ca, bdxtail, bxtca);
-    temp16alen = scale_expansion_zeroelim(bxtcalen, bxtca, 2.0 * bdx, temp16a);
-
-    bxtaalen = scale_expansion_zeroelim(4, aa, bdxtail, bxtaa);
-    temp16blen = scale_expansion_zeroelim(bxtaalen, bxtaa, cdy, temp16b);
-
-    bxtcclen = scale_expansion_zeroelim(4, cc, bdxtail, bxtcc);
-    temp16clen = scale_expansion_zeroelim(bxtcclen, bxtcc, -ady, temp16c);
-
-    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
-    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
-    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-    finswap = finnow;
-    finnow = finother;
-    finother = finswap;
-  }
-  if (bdytail != 0.0) {
-    bytcalen = scale_expansion_zeroelim(4, ca, bdytail, bytca);
-    temp16alen = scale_expansion_zeroelim(bytcalen, bytca, 2.0 * bdy, temp16a);
-
-    bytcclen = scale_expansion_zeroelim(4, cc, bdytail, bytcc);
-    temp16blen = scale_expansion_zeroelim(bytcclen, bytcc, adx, temp16b);
-
-    bytaalen = scale_expansion_zeroelim(4, aa, bdytail, bytaa);
-    temp16clen = scale_expansion_zeroelim(bytaalen, bytaa, -cdx, temp16c);
-
-    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
-    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
-    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-    finswap = finnow;
-    finnow = finother;
-    finother = finswap;
-  }
-  if (cdxtail != 0.0) {
-    cxtablen = scale_expansion_zeroelim(4, ab, cdxtail, cxtab);
-    temp16alen = scale_expansion_zeroelim(cxtablen, cxtab, 2.0 * cdx, temp16a);
-
-    cxtbblen = scale_expansion_zeroelim(4, bb, cdxtail, cxtbb);
-    temp16blen = scale_expansion_zeroelim(cxtbblen, cxtbb, ady, temp16b);
-
-    cxtaalen = scale_expansion_zeroelim(4, aa, cdxtail, cxtaa);
-    temp16clen = scale_expansion_zeroelim(cxtaalen, cxtaa, -bdy, temp16c);
-
-    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
-    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
-    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-    finswap = finnow;
-    finnow = finother;
-    finother = finswap;
-  }
-  if (cdytail != 0.0) {
-    cytablen = scale_expansion_zeroelim(4, ab, cdytail, cytab);
-    temp16alen = scale_expansion_zeroelim(cytablen, cytab, 2.0 * cdy, temp16a);
-
-    cytaalen = scale_expansion_zeroelim(4, aa, cdytail, cytaa);
-    temp16blen = scale_expansion_zeroelim(cytaalen, cytaa, bdx, temp16b);
-
-    cytbblen = scale_expansion_zeroelim(4, bb, cdytail, cytbb);
-    temp16clen = scale_expansion_zeroelim(cytbblen, cytbb, -adx, temp16c);
-
-    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
-    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
-    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-    finswap = finnow;
-    finnow = finother;
-    finother = finswap;
-  }
-
-  if ((adxtail != 0.0) || (adytail != 0.0)) {
-    if ((bdxtail != 0.0) || (bdytail != 0.0) || (cdxtail != 0.0) || (cdytail != 0.0)) {
-      Two_Product(bdxtail, cdy, ti1, ti0);
-      Two_Product(bdx, cdytail, tj1, tj0);
-      Two_Two_Sum(ti1, ti0, tj1, tj0, u3, u[2], u[1], u[0]);
-      u[3] = u3;
-      negate = -bdy;
-      Two_Product(cdxtail, negate, ti1, ti0);
-      negate = -bdytail;
-      Two_Product(cdx, negate, tj1, tj0);
-      Two_Two_Sum(ti1, ti0, tj1, tj0, v3, v[2], v[1], v[0]);
-      v[3] = v3;
-      bctlen = fast_expansion_sum_zeroelim(4, u, 4, v, bct);
-
-      Two_Product(bdxtail, cdytail, ti1, ti0);
-      Two_Product(cdxtail, bdytail, tj1, tj0);
-      Two_Two_Diff(ti1, ti0, tj1, tj0, bctt3, bctt[2], bctt[1], bctt[0]);
-      bctt[3] = bctt3;
-      bcttlen = 4;
-    }
-    else {
-      bct[0] = 0.0;
-      bctlen = 1;
-      bctt[0] = 0.0;
-      bcttlen = 1;
-    }
-
-    if (adxtail != 0.0) {
-      temp16alen = scale_expansion_zeroelim(axtbclen, axtbc, adxtail, temp16a);
-      axtbctlen = scale_expansion_zeroelim(bctlen, bct, adxtail, axtbct);
-      temp32alen = scale_expansion_zeroelim(axtbctlen, axtbct, 2.0 * adx, temp32a);
-      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-      if (bdytail != 0.0) {
-        temp8len = scale_expansion_zeroelim(4, cc, adxtail, temp8);
-        temp16alen = scale_expansion_zeroelim(temp8len, temp8, bdytail, temp16a);
-        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
-        finswap = finnow;
-        finnow = finother;
-        finother = finswap;
-      }
-      if (cdytail != 0.0) {
-        temp8len = scale_expansion_zeroelim(4, bb, -adxtail, temp8);
-        temp16alen = scale_expansion_zeroelim(temp8len, temp8, cdytail, temp16a);
-        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
-        finswap = finnow;
-        finnow = finother;
-        finother = finswap;
-      }
-
-      temp32alen = scale_expansion_zeroelim(axtbctlen, axtbct, adxtail, temp32a);
-      axtbcttlen = scale_expansion_zeroelim(bcttlen, bctt, adxtail, axtbctt);
-      temp16alen = scale_expansion_zeroelim(axtbcttlen, axtbctt, 2.0 * adx, temp16a);
-      temp16blen = scale_expansion_zeroelim(axtbcttlen, axtbctt, adxtail, temp16b);
-      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
-      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-    }
-    if (adytail != 0.0) {
-      temp16alen = scale_expansion_zeroelim(aytbclen, aytbc, adytail, temp16a);
-      aytbctlen = scale_expansion_zeroelim(bctlen, bct, adytail, aytbct);
-      temp32alen = scale_expansion_zeroelim(aytbctlen, aytbct, 2.0 * ady, temp32a);
-      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-
-      temp32alen = scale_expansion_zeroelim(aytbctlen, aytbct, adytail, temp32a);
-      aytbcttlen = scale_expansion_zeroelim(bcttlen, bctt, adytail, aytbctt);
-      temp16alen = scale_expansion_zeroelim(aytbcttlen, aytbctt, 2.0 * ady, temp16a);
-      temp16blen = scale_expansion_zeroelim(aytbcttlen, aytbctt, adytail, temp16b);
-      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
-      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-    }
-  }
-  if ((bdxtail != 0.0) || (bdytail != 0.0)) {
-    if ((cdxtail != 0.0) || (cdytail != 0.0) || (adxtail != 0.0) || (adytail != 0.0)) {
-      Two_Product(cdxtail, ady, ti1, ti0);
-      Two_Product(cdx, adytail, tj1, tj0);
-      Two_Two_Sum(ti1, ti0, tj1, tj0, u3, u[2], u[1], u[0]);
-      u[3] = u3;
-      negate = -cdy;
-      Two_Product(adxtail, negate, ti1, ti0);
-      negate = -cdytail;
-      Two_Product(adx, negate, tj1, tj0);
-      Two_Two_Sum(ti1, ti0, tj1, tj0, v3, v[2], v[1], v[0]);
-      v[3] = v3;
-      catlen = fast_expansion_sum_zeroelim(4, u, 4, v, cat);
-
-      Two_Product(cdxtail, adytail, ti1, ti0);
-      Two_Product(adxtail, cdytail, tj1, tj0);
-      Two_Two_Diff(ti1, ti0, tj1, tj0, catt3, catt[2], catt[1], catt[0]);
-      catt[3] = catt3;
-      cattlen = 4;
-    }
-    else {
-      cat[0] = 0.0;
-      catlen = 1;
-      catt[0] = 0.0;
-      cattlen = 1;
-    }
-
-    if (bdxtail != 0.0) {
-      temp16alen = scale_expansion_zeroelim(bxtcalen, bxtca, bdxtail, temp16a);
-      bxtcatlen = scale_expansion_zeroelim(catlen, cat, bdxtail, bxtcat);
-      temp32alen = scale_expansion_zeroelim(bxtcatlen, bxtcat, 2.0 * bdx, temp32a);
-      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-      if (cdytail != 0.0) {
-        temp8len = scale_expansion_zeroelim(4, aa, bdxtail, temp8);
-        temp16alen = scale_expansion_zeroelim(temp8len, temp8, cdytail, temp16a);
-        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
-        finswap = finnow;
-        finnow = finother;
-        finother = finswap;
-      }
-      if (adytail != 0.0) {
-        temp8len = scale_expansion_zeroelim(4, cc, -bdxtail, temp8);
-        temp16alen = scale_expansion_zeroelim(temp8len, temp8, adytail, temp16a);
-        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
-        finswap = finnow;
-        finnow = finother;
-        finother = finswap;
-      }
-
-      temp32alen = scale_expansion_zeroelim(bxtcatlen, bxtcat, bdxtail, temp32a);
-      bxtcattlen = scale_expansion_zeroelim(cattlen, catt, bdxtail, bxtcatt);
-      temp16alen = scale_expansion_zeroelim(bxtcattlen, bxtcatt, 2.0 * bdx, temp16a);
-      temp16blen = scale_expansion_zeroelim(bxtcattlen, bxtcatt, bdxtail, temp16b);
-      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
-      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-    }
-    if (bdytail != 0.0) {
-      temp16alen = scale_expansion_zeroelim(bytcalen, bytca, bdytail, temp16a);
-      bytcatlen = scale_expansion_zeroelim(catlen, cat, bdytail, bytcat);
-      temp32alen = scale_expansion_zeroelim(bytcatlen, bytcat, 2.0 * bdy, temp32a);
-      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-
-      temp32alen = scale_expansion_zeroelim(bytcatlen, bytcat, bdytail, temp32a);
-      bytcattlen = scale_expansion_zeroelim(cattlen, catt, bdytail, bytcatt);
-      temp16alen = scale_expansion_zeroelim(bytcattlen, bytcatt, 2.0 * bdy, temp16a);
-      temp16blen = scale_expansion_zeroelim(bytcattlen, bytcatt, bdytail, temp16b);
-      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
-      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-    }
-  }
-  if ((cdxtail != 0.0) || (cdytail != 0.0)) {
-    if ((adxtail != 0.0) || (adytail != 0.0) || (bdxtail != 0.0) || (bdytail != 0.0)) {
-      Two_Product(adxtail, bdy, ti1, ti0);
-      Two_Product(adx, bdytail, tj1, tj0);
-      Two_Two_Sum(ti1, ti0, tj1, tj0, u3, u[2], u[1], u[0]);
-      u[3] = u3;
-      negate = -ady;
-      Two_Product(bdxtail, negate, ti1, ti0);
-      negate = -adytail;
-      Two_Product(bdx, negate, tj1, tj0);
-      Two_Two_Sum(ti1, ti0, tj1, tj0, v3, v[2], v[1], v[0]);
-      v[3] = v3;
-      abtlen = fast_expansion_sum_zeroelim(4, u, 4, v, abt);
-
-      Two_Product(adxtail, bdytail, ti1, ti0);
-      Two_Product(bdxtail, adytail, tj1, tj0);
-      Two_Two_Diff(ti1, ti0, tj1, tj0, abtt3, abtt[2], abtt[1], abtt[0]);
-      abtt[3] = abtt3;
-      abttlen = 4;
-    }
-    else {
-      abt[0] = 0.0;
-      abtlen = 1;
-      abtt[0] = 0.0;
-      abttlen = 1;
-    }
-
-    if (cdxtail != 0.0) {
-      temp16alen = scale_expansion_zeroelim(cxtablen, cxtab, cdxtail, temp16a);
-      cxtabtlen = scale_expansion_zeroelim(abtlen, abt, cdxtail, cxtabt);
-      temp32alen = scale_expansion_zeroelim(cxtabtlen, cxtabt, 2.0 * cdx, temp32a);
-      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-      if (adytail != 0.0) {
-        temp8len = scale_expansion_zeroelim(4, bb, cdxtail, temp8);
-        temp16alen = scale_expansion_zeroelim(temp8len, temp8, adytail, temp16a);
-        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
-        finswap = finnow;
-        finnow = finother;
-        finother = finswap;
-      }
-      if (bdytail != 0.0) {
-        temp8len = scale_expansion_zeroelim(4, aa, -cdxtail, temp8);
-        temp16alen = scale_expansion_zeroelim(temp8len, temp8, bdytail, temp16a);
-        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
-        finswap = finnow;
-        finnow = finother;
-        finother = finswap;
-      }
-
-      temp32alen = scale_expansion_zeroelim(cxtabtlen, cxtabt, cdxtail, temp32a);
-      cxtabttlen = scale_expansion_zeroelim(abttlen, abtt, cdxtail, cxtabtt);
-      temp16alen = scale_expansion_zeroelim(cxtabttlen, cxtabtt, 2.0 * cdx, temp16a);
-      temp16blen = scale_expansion_zeroelim(cxtabttlen, cxtabtt, cdxtail, temp16b);
-      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
-      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-    }
-    if (cdytail != 0.0) {
-      temp16alen = scale_expansion_zeroelim(cytablen, cytab, cdytail, temp16a);
-      cytabtlen = scale_expansion_zeroelim(abtlen, abt, cdytail, cytabt);
-      temp32alen = scale_expansion_zeroelim(cytabtlen, cytabt, 2.0 * cdy, temp32a);
-      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-
-      temp32alen = scale_expansion_zeroelim(cytabtlen, cytabt, cdytail, temp32a);
-      cytabttlen = scale_expansion_zeroelim(abttlen, abtt, cdytail, cytabtt);
-      temp16alen = scale_expansion_zeroelim(cytabttlen, cytabtt, 2.0 * cdy, temp16a);
-      temp16blen = scale_expansion_zeroelim(cytabttlen, cytabtt, cdytail, temp16b);
-      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
-      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
-      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
-      finswap = finnow;
-      finnow = finother;
-      finother = finswap;
-    }
-  }
-
-  return finnow[finlength - 1];
-}
-
-static double incircle(const double *pa, const double *pb, const double *pc, const double *pd)
-{
-  double adx, bdx, cdx, ady, bdy, cdy;
-  double bdxcdy, cdxbdy, cdxady, adxcdy, adxbdy, bdxady;
-  double alift, blift, clift;
-  double det;
-  double permanent, errbound;
-
-  adx = pa[0] - pd[0];
-  bdx = pb[0] - pd[0];
-  cdx = pc[0] - pd[0];
-  ady = pa[1] - pd[1];
-  bdy = pb[1] - pd[1];
-  cdy = pc[1] - pd[1];
-
-  bdxcdy = bdx * cdy;
-  cdxbdy = cdx * bdy;
-  alift = adx * adx + ady * ady;
-
-  cdxady = cdx * ady;
-  adxcdy = adx * cdy;
-  blift = bdx * bdx + bdy * bdy;
-
-  adxbdy = adx * bdy;
-  bdxady = bdx * ady;
-  clift = cdx * cdx + cdy * cdy;
-
-  det = alift * (bdxcdy - cdxbdy) + blift * (cdxady - adxcdy) + clift * (adxbdy - bdxady);
-
-  permanent = (Absolute(bdxcdy) + Absolute(cdxbdy)) * alift +
-              (Absolute(cdxady) + Absolute(adxcdy)) * blift +
-              (Absolute(adxbdy) + Absolute(bdxady)) * clift;
-  errbound = iccerrboundA * permanent;
-  if ((det > errbound) || (-det > errbound)) {
-    return det;
-  }
-
-  return incircleadapt(pa, pb, pc, pd, permanent);
-}
diff --git a/source/blender/blenlib/intern/delaunay_2d.cc b/source/blender/blenlib/intern/delaunay_2d.cc
new file mode 100644
index 00000000000..9b00431391a
--- /dev/null
+++ b/source/blender/blenlib/intern/delaunay_2d.cc
@@ -0,0 +1,2262 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+#include "gmpxx.h"
+
+#include "BLI_array.hh"
+#include "BLI_double2.hh"
+#include "BLI_linklist.h"
+#include "BLI_mempool.h"
+#include "BLI_mpq2.hh"
+#include "BLI_vector.hh"
+
+#include "BLI_delaunay_2d.h"
+
+namespace BLI {
+namespace CDT {
+
+/* Throughout this file, template argument T will be an
+ * arithmetic-like type, like float, double, or gmp.
+ */
+
+template<typename T> T math_abs(const T v)
+{
+  if (v < 0) {
+    return -v;
+  }
+  else {
+    return v;
+  }
+}
+
+template<> mpq_class math_abs<mpq_class>(const mpq_class v)
+{
+  return abs(v);
+}
+
+template<> double math_abs<double>(const double v)
+{
+  return fabs(v);
+}
+
+template<typename T> double math_to_double(const T UNUSED(v))
+{
+  BLI_assert(false); /* Need implementation for other type. */
+  return 0.0;
+}
+
+template<> double math_to_double<mpq_class>(const mpq_class v)
+{
+  return v.get_d();
+}
+
+template<> double math_to_double<double>(const double v)
+{
+  return v;
+}
+
+template<typename T> class CDTVert;
+template<typename T> class CDTEdge;
+template<typename T> class CDTFace;
+
+template<typename T> class SymEdge {
+ public:
+  SymEdge<T> *next{nullptr}; /* In face, doing CCW traversal of face. */
+  SymEdge<T> *rot{nullptr};  /* CCW around vert. */
+  CDTVert<T> *vert{nullptr}; /* Vert at origin. */
+  CDTEdge<T> *edge{nullptr}; /* Undirected edge this is for. */
+  CDTFace<T> *face{nullptr}; /* Face on left side. */
+
+  SymEdge() = default;
+};
+
+template<typename T> class CDTVert {
+ public:
+  vec2<T> co;                   /* Coordinate. */
+  SymEdge<T> *symedge{nullptr}; /* Some edge attached to it. */
+  LinkNode *input_ids{nullptr}; /* List of corresponding vertex input ids. */
+  int index{-1};                /* Index into array that cdt keeps. */
+  int merge_to_index{-1};       /* Index of a CDTVert that this has merged to. -1 if no merge. */
+  int visit_index{0};           /* Which visit epoch has this been seen. */
+
+  CDTVert() = default;
+  explicit CDTVert(const vec2<T> &pt);
+};
+
+template<typename T> class CDTEdge {
+ public:
+  LinkNode *input_ids{nullptr}; /* List of input edge ids that this is part of. */
+  SymEdge<T> symedges[2]{SymEdge<T>(), SymEdge<T>()}; /* The directed edges for this edge. */
+  bool in_queue{false};                               /* Used in flipping algorithm. */
+
+  CDTEdge() = default;
+};
+
+template<typename T> class CDTFace {
+ public:
+  SymEdge<T> *symedge{
+      nullptr}; /* A symedge in face; only used during output, so only valid then. */
+  LinkNode *input_ids{nullptr}; /* List of input face ids that this is part of. */
+  int visit_index{0};           /* Which visit epoch has this been seen. */
+  bool deleted{false};          /* Marks this face no longer used. */
+  bool in_queue{false};         /* Used in remove_small_features algorithm. */
+
+  CDTFace() = default;
+};
+
+template<typename T> class CDT_state {
+ public:
+  /* Since the following can resize, need to store pointers there, not actual values. */
+  Vector<CDTVert<T> *> verts; /* The verts. */
+  Vector<CDTEdge<T> *> edges; /* The edges. */
+  Vector<CDTFace<T> *> faces; /* The faces. */
+  CDTFace<T> *outer_face;     /* Which CDTFace is the outer face. */
+  int input_vert_tot;         /* How many verts were in input (will be first in vert_array). */
+  int visit_count; /* Used for visiting things without having to initialized their visit fields. */
+  int face_edge_offset;  /* Input edge id where we start numbering the face edges. */
+  T epsilon;             /* How close before coords considered equal. */
+  BLI_mempool *listpool; /* Allocations of ListNodes done from this pool. */
+
+  explicit CDT_state(int num_input_verts,
+                     int num_input_edges,
+                     int num_input_faces,
+                     const T epsilon);
+  ~CDT_state()
+  {
+    BLI_mempool_destroy(this->listpool);
+    this->listpool = nullptr;
+  }
+  CDTVert<T> *add_vert(const vec2<T> &pt);
+  CDTEdge<T> *add_edge(CDTVert<T> *v1, CDTVert<T> *v2, CDTFace<T> *fleft, CDTFace<T> *fright);
+  CDTFace<T> *add_face();
+  CDTEdge<T> *add_vert_to_symedge_edge(CDTVert<T> *v, SymEdge<T> *se);
+  CDTEdge<T> *add_diagonal(SymEdge<T> *s1, SymEdge<T> *s2);
+  CDTEdge<T> *connect_separate_parts(SymEdge<T> *se1, SymEdge<T> *se2);
+  CDTEdge<T> *split_edge(SymEdge<T> *se, T lambda);
+  void delete_edge(SymEdge<T> *se);
+  CDTVert<T> *get_vert_resolve_merge(int i);
+};
+
+#define DEBUG_CDT
+#ifdef DEBUG_CDT
+/* Some functions to aid in debugging. */
+template<typename T> const std::string vertname(const CDTVert<T> *v)
+{
+  std::stringstream ss;
+  ss << "[" << v->index << "]";
+  return ss.str();
+}
+
+/* Abbreviated pointer value is easier to read in dumps. */
+static const std::string trunc_ptr(const void *p)
+{
+  std::stringstream ss;
+  ss << std::hex << (POINTER_AS_INT(p) & 0xFFFF);
+  return ss.str();
+}
+
+template<typename T> const std::string sename(const SymEdge<T> *se)
+{
+  std::stringstream ss;
+  ss << "{" << trunc_ptr(se) << "}";
+  return ss.str();
+}
+
+template<typename T> std::ostream &operator<<(std::ostream &os, const SymEdge<T> &se)
+{
+  if (se.next) {
+    os << vertname(se.vert) << "(" << se.vert->co << "->" << se.next->vert->co << ")"
+       << vertname(se.next->vert);
+  }
+  else {
+    os << vertname(se.vert) << "(" << se.vert->co << "->NULL)";
+  }
+  return os;
+}
+
+template<typename T> std::ostream &operator<<(std::ostream &os, const SymEdge<T> *se)
+{
+  os << *se;
+  return os;
+}
+
+template<typename T> const std::string short_se_dump(const SymEdge<T> *se)
+{
+  if (se == nullptr) {
+    return std::string("NULL");
+  }
+  else {
+    return vertname(se->vert) +
+           (se->next == nullptr ? std::string("[NULL]") : vertname(se->next->vert));
+  }
+}
+
+template<typename T> std::ostream &operator<<(std::ostream &os, const CDT_state<T> &cdt)
+{
+  os << "\nCDT\n\nVERTS\n";
+  for (const CDTVert<T> *v : cdt.verts) {
+    os << vertname(v) << " " << trunc_ptr(v) << ": " << v->co
+       << " symedge=" << trunc_ptr(v->symedge);
+    if (v->merge_to_index == -1) {
+      os << "\n";
+    }
+    else {
+      os << " merge to " << vertname(cdt.verts[v->merge_to_index]) << "\n";
+    }
+    const SymEdge<T> *se = v->symedge;
+    int cnt = 0;
+    if (se) {
+      os << "  edges out:\n";
+      do {
+        if (se->next == NULL) {
+          os << "    [NULL] next/rot symedge, se=" << trunc_ptr(se) << "\n";
+          break;
+        }
+        if (se->next->next == NULL) {
+          os << "    [NULL] next-next/rot symedge, se=" << trunc_ptr(se) << "\n";
+          break;
+        }
+        const CDTVert<T> *vother = sym(se)->vert;
+        os << "    " << vertname(vother) << "(e=" << trunc_ptr(se->edge)
+           << ", se=" << trunc_ptr(se) << ")\n";
+        se = se->rot;
+        cnt++;
+      } while (se != v->symedge && cnt < 25);
+      os << "\n";
+    }
+  }
+  os << "\nEDGES\n";
+  for (const CDTEdge<T> *e : cdt.edges) {
+    if (e->symedges[0].next == nullptr) {
+      continue;
+    }
+    os << trunc_ptr(&e) << ":\n";
+    for (int i = 0; i < 2; ++i) {
+      const SymEdge<T> *se = &e->symedges[i];
+      os << "  se[" << i << "] @" << trunc_ptr(se) << " next=" << trunc_ptr(se->next)
+         << ", rot=" << trunc_ptr(se->rot) << ", vert=" << trunc_ptr(se->vert) << " "
+         << vertname(se->vert) << " " << se->vert->co << ", edge=" << trunc_ptr(se->edge)
+         << ", face=" << trunc_ptr(se->face) << "\n";
+    }
+  }
+  os << "\nFACES\n";
+  os << "outer_face=" << trunc_ptr(cdt.outer_face) << "\n";
+  /* Only after prepare_output do faces have non-null symedges. */
+  if (cdt.outer_face->symedge != nullptr) {
+    for (const CDTFace<T> *f : cdt.faces) {
+      if (!f->deleted) {
+        os << trunc_ptr(f) << " symedge=" << trunc_ptr(f->symedge) << "\n";
+      }
+    }
+  }
+  return os;
+}
+
+template<typename T> void cdt_draw(const std::string &label, const CDT_state<T> &cdt)
+{
+  static bool append = false; /* Will be set to true after first call. */
+  constexpr const char *drawfile = "/home/howard/debug_draw.html";
+  constexpr int max_draw_width = 1800;
+  constexpr int max_draw_height = 1600;
+  constexpr int thin_line = 1;
+  constexpr int thick_line = 4;
+  constexpr int vert_radius = 3;
+  constexpr bool draw_vert_labels = true;
+  constexpr bool draw_edge_labels = false;
+
+  if (cdt.verts.size() == 0) {
+    return;
+  }
+  vec2<double> vmin(1e10, 1e10);
+  vec2<double> vmax(-1e10, -1e10);
+  for (const CDTVert<T> *v : cdt.verts) {
+    for (int i = 0; i < 2; ++i) {
+      double dvi = math_to_double(v->co[i]);
+      if (dvi < vmin[i]) {
+        vmin[i] = dvi;
+      }
+      if (dvi > vmax[i]) {
+        vmax[i] = dvi;
+      }
+    }
+  }
+  double draw_margin = ((vmax.x - vmin.x) + (vmax.y - vmin.y)) * 0.05;
+  double minx = vmin.x - draw_margin;
+  double maxx = vmax.x + draw_margin;
+  double miny = vmin.y - draw_margin;
+  double maxy = vmax.y + draw_margin;
+
+  double width = maxx - minx;
+  double height = maxy - miny;
+  double aspect = height / width;
+  int view_width = max_draw_width;
+  int view_height = static_cast<int>(view_width * aspect);
+  if (view_height > max_draw_height) {
+    view_height = max_draw_height;
+    view_width = static_cast<int>(view_height / aspect);
+  }
+  double scale = view_width / width;
+
+#  define SX(x) ((math_to_double(x) - minx) * scale)
+#  define SY(y) ((maxy - math_to_double(y)) * scale)
+
+  std::ofstream f;
+  if (append) {
+    f.open(drawfile, std::ios_base::app);
+  }
+  else {
+    f.open(drawfile);
+  }
+  if (!f) {
+    std::cout << "Could not open file " << drawfile << "\n";
+    return;
+  }
+
+  f << "<div>" << label << "</div>\n<div>\n"
+    << "<svg version=\"1.1\" "
+       "xmlns=\"http://www.w3.org/2000/svg\" "
+       "xmlns:xlink=\"http://www.w3.org/1999/xlink\" "
+       "xml:space=\"preserve\"\n"
+    << "width=\"" << view_width << "\" height=\"" << view_height << "\">n";
+
+  for (const CDTEdge<T> *e : cdt.edges) {
+    if (e->symedges[0].next == nullptr) {
+      continue;
+    }
+    const CDTVert<T> *u = e->symedges[0].vert;
+    const CDTVert<T> *v = e->symedges[1].vert;
+    const vec2<T> &uco = u->co;
+    const vec2<T> &vco = v->co;
+    int strokew = e->input_ids == nullptr ? thin_line : thick_line;
+    f << "<line fill=\"none\" stroke=\"black\" stroke-width=\"" << strokew << "\" x1=\""
+      << SX(uco[0]) << "\" y1=\"" << SY(uco[1]) << "\" x2=\"" << SX(vco[0]) << "\" y2=\""
+      << SY(vco[1]) << "\">\n";
+    f << "  <title>" << vertname(u) << vertname(v) << "</title>\n";
+    f << "</line>\n";
+    if (draw_edge_labels) {
+      f << "<text x=\"" << SX(0.5 * (uco[0] + vco[0])) << "\" y=\"" << SY(0.5 * (uco[1] + vco[1]))
+        << "\" font-size=\"small\">";
+      f << vertname(u) << vertname(v) << sename(&e->symedges[0]) << sename(&e->symedges[1])
+        << "</text>\n";
+    }
+  }
+
+  int i = 0;
+  for (const CDTVert<T> *v : cdt.verts) {
+    f << "<circle fill=\"black\" cx=\"" << SX(v->co[0]) << "\" cy=\"" << SY(v->co[1]) << "\" r=\""
+      << vert_radius << "\">\n";
+    f << "  <title>[" << i << "]" << v->co << "</title>\n";
+    f << "</circle>\n";
+    if (draw_vert_labels) {
+      f << "<text x=\"" << SX(v->co[0]) + vert_radius << "\" y=\"" << SY(v->co[1]) - vert_radius
+        << "\" font-size=\"small\">[" << i << "]</text>\n";
+    }
+    ++i;
+  }
+
+  append = true;
+#  undef SX
+#  undef SY
+}
+#endif
+
+/* Return other SymEdge for same CDTEdge as se. */
+template<typename T> inline SymEdge<T> *sym(const SymEdge<T> *se)
+{
+  return se->next->rot;
+}
+
+/* Return SymEdge whose next is se. */
+template<typename T> inline SymEdge<T> *prev(const SymEdge<T> *se)
+{
+  return se->rot->next->rot;
+}
+
+/*
+ * Return true if a -- b -- c are in that order, assuming they are on a straight line according to
+ * orient2d and we know the order is either `abc` or `bac`.
+ * This means `ab . ac` and `bc . ac` must both be non-negative.  */
+template<typename T> bool in_line(const vec2<T> &a, const vec2<T> &b, const vec2<T> &c)
+{
+  vec2<T> ab = b - a;
+  vec2<T> bc = c - b;
+  vec2<T> ac = c - a;
+  if (vec2<T>::dot(ab, ac) < 0) {
+    return false;
+  }
+  return vec2<T>::dot(bc, ac) >= 0;
+}
+
+template<typename T> CDTVert<T>::CDTVert(const vec2<T> &pt)
+{
+  this->co = pt;
+  this->input_ids = nullptr;
+  this->symedge = nullptr;
+  this->index = -1;
+  this->merge_to_index = -1;
+  this->visit_index = 0;
+}
+
+template<typename T> CDTVert<T> *CDT_state<T>::add_vert(const vec2<T> &pt)
+{
+  CDTVert<T> *v = new CDTVert<T>(pt); /* TODO: use pooled or arena allocator. */
+  int index = static_cast<int>(this->verts.append_and_get_index(v));
+  v->index = index;
+  return v;
+}
+
+template<typename T>
+CDTEdge<T> *CDT_state<T>::add_edge(CDTVert<T> *v1,
+                                   CDTVert<T> *v2,
+                                   CDTFace<T> *fleft,
+                                   CDTFace<T> *fright)
+{
+  CDTEdge<T> *e = new CDTEdge<T>(); /* TODO: use pooled or arena allocator. */
+  this->edges.append(e);
+  SymEdge<T> *se = &e->symedges[0];
+  SymEdge<T> *sesym = &e->symedges[1];
+  se->edge = sesym->edge = e;
+  se->face = fleft;
+  sesym->face = fright;
+  se->vert = v1;
+  if (v1->symedge == nullptr) {
+    v1->symedge = se;
+  }
+  sesym->vert = v2;
+  if (v2->symedge == nullptr) {
+    v2->symedge = sesym;
+  }
+  se->next = sesym->next = se->rot = sesym->rot = nullptr;
+  return e;
+}
+
+template<typename T> CDTFace<T> *CDT_state<T>::add_face()
+{
+  CDTFace<T> *f = new CDTFace<T>(); /* TODO: use pooled or arena allocator. */
+  this->faces.append(f);
+  return f;
+}
+
+template<typename T> inline CDTVert<T> *CDT_state<T>::get_vert_resolve_merge(int i)
+{
+  CDTVert<T> *v = this->verts[i];
+  if (v->merge_to_index != -1) {
+    v = this->verts[v->merge_to_index];
+  }
+  return v;
+}
+
+template<typename T>
+CDT_state<T>::CDT_state(int num_input_verts,
+                        int num_input_edges,
+                        int num_input_faces,
+                        const T epsilon)
+{
+  this->input_vert_tot = num_input_verts;
+  /* These reserves are just guesses; OK if they aren't exactly right since vectors will resize. */
+  this->verts.reserve(2 * num_input_verts);
+  this->edges.reserve(3 * num_input_verts + 2 * num_input_edges + 5 * num_input_faces);
+  this->faces.reserve(2 * num_input_verts + 2 * num_input_edges + 2 * num_input_faces);
+  this->listpool = BLI_mempool_create(
+      sizeof(LinkNode), 128 + 4 * num_input_verts, 128 + num_input_verts, 0);
+  this->outer_face = this->add_face();
+  this->epsilon = epsilon;
+  this->visit_count = 0;
+}
+
+static bool id_in_list(const LinkNode *id_list, int id)
+{
+  const LinkNode *ln;
+
+  for (ln = id_list; ln; ln = ln->next) {
+    if (POINTER_AS_INT(ln->link) == id) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* Is any id in (range_start, range_start+1, ... , range_end) in id_list? */
+static bool id_range_in_list(const LinkNode *id_list, int range_start, int range_end)
+{
+  const LinkNode *ln;
+  int id;
+
+  for (ln = id_list; ln; ln = ln->next) {
+    id = POINTER_AS_INT(ln->link);
+    if (id >= range_start && id <= range_end) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template<typename T> void add_to_input_ids(LinkNode **dst, int input_id, CDT_state<T> *cdt)
+{
+  if (!id_in_list(*dst, input_id)) {
+    BLI_linklist_prepend_pool(dst, POINTER_FROM_INT(input_id), cdt->listpool);
+  }
+}
+
+template<typename T>
+void add_list_to_input_ids(LinkNode **dst, const LinkNode *src, CDT_state<T> *cdt)
+{
+  const LinkNode *ln;
+
+  for (ln = src; ln; ln = ln->next) {
+    add_to_input_ids(dst, POINTER_AS_INT(ln->link), cdt);
+  }
+}
+
+template<typename T> inline bool is_border_edge(const CDTEdge<T> *e, const CDT_state<T> *cdt)
+{
+  return e->symedges[0].face == cdt->outer_face || e->symedges[1].face == cdt->outer_face;
+}
+
+template<typename T> inline bool is_constrained_edge(const CDTEdge<T> *e)
+{
+  return e->input_ids != NULL;
+}
+
+template<typename T> inline bool is_deleted_edge(const CDTEdge<T> *e)
+{
+  return e->symedges[0].next == NULL;
+}
+
+template<typename T> inline bool is_original_vert(const CDTVert<T> *v, CDT_state<T> *cdt)
+{
+  return (v->index < cdt->input_vert_tot);
+}
+
+/* Return the Symedge that goes from v1 to v2, if it exists, else return nullptr. */
+template<typename T>
+SymEdge<T> *find_symedge_between_verts(const CDTVert<T> *v1, const CDTVert<T> *v2)
+{
+  SymEdge<T> *t = v1->symedge;
+  SymEdge<T> *tstart = t;
+  do {
+    if (t->next->vert == v2) {
+      return t;
+    }
+  } while ((t = t->rot) != tstart);
+  return nullptr;
+}
+
+/* Return the SymEdge attached to v that has face f, if it exists, else return nullptr. */
+template<typename T> SymEdge<T> *find_symedge_with_face(const CDTVert<T> *v, const CDTFace<T> *f)
+{
+  SymEdge<T> *t = v->symedge;
+  SymEdge<T> *tstart = t;
+  do {
+    if (t->face == f) {
+      return t;
+    }
+  } while ((t = t->rot) != tstart);
+  return nullptr;
+}
+
+/* Is there already an edge between a and b? */
+template<typename T> inline bool exists_edge(const CDTVert<T> *v1, const CDTVert<T> *v2)
+{
+  return find_symedge_between_verts(v1, v2) != nullptr;
+}
+
+/* Is the vertex v incident on face f? */
+template<typename T> bool vert_touches_face(const CDTVert<T> *v, const CDTFace<T> *f)
+{
+  SymEdge<T> *se = v->symedge;
+  do {
+    if (se->face == f) {
+      return true;
+    }
+  } while ((se = se->rot) != v->symedge);
+  return false;
+}
+
+/*
+ * Assume s1 and s2 are both SymEdges in a face with > 3 sides,
+ * and one is not the next of the other.
+ * Add an edge from s1->v to s2->v, splitting the face in two.
+ * The original face will continue to be associated with the subface
+ * that has s1, and a new face will be made for s2's new face.
+ * Return the new diagonal's CDTEdge *.
+ */
+template<typename T> CDTEdge<T> *CDT_state<T>::add_diagonal(SymEdge<T> *s1, SymEdge<T> *s2)
+{
+  CDTFace<T> *fold = s1->face;
+  CDTFace<T> *fnew = this->add_face();
+  SymEdge<T> *s1prev = prev(s1);
+  SymEdge<T> *s1prevsym = sym(s1prev);
+  SymEdge<T> *s2prev = prev(s2);
+  SymEdge<T> *s2prevsym = sym(s2prev);
+  CDTEdge<T> *ediag = this->add_edge(s1->vert, s2->vert, fnew, fold);
+  SymEdge<T> *sdiag = &ediag->symedges[0];
+  SymEdge<T> *sdiagsym = &ediag->symedges[1];
+  sdiag->next = s2;
+  sdiagsym->next = s1;
+  s2prev->next = sdiagsym;
+  s1prev->next = sdiag;
+  s1->rot = sdiag;
+  sdiag->rot = s1prevsym;
+  s2->rot = sdiagsym;
+  sdiagsym->rot = s2prevsym;
+  for (SymEdge<T> *se = s2; se != sdiag; se = se->next) {
+    se->face = fnew;
+  }
+  add_list_to_input_ids(&fnew->input_ids, fold->input_ids, this);
+  return ediag;
+}
+
+template<typename T>
+CDTEdge<T> *CDT_state<T>::add_vert_to_symedge_edge(CDTVert<T> *v, SymEdge<T> *se)
+{
+  SymEdge<T> *se_rot = se->rot;
+  SymEdge<T> *se_rotsym = sym(se_rot);
+  CDTEdge<T> *e = this->add_edge(v, se->vert, se->face, se->face);
+  SymEdge<T> *new_se = &e->symedges[0];
+  SymEdge<T> *new_se_sym = &e->symedges[1];
+  new_se->next = se;
+  new_se_sym->next = new_se;
+  new_se->rot = new_se;
+  new_se_sym->rot = se_rot;
+  se->rot = new_se_sym;
+  se_rotsym->next = new_se_sym;
+  return e;
+}
+
+/* Connect the verts of se1 and se2, assuming that currently those two SymEdges are on
+ * the outer boundary (have face == outer_face) of two components that are isolated from
+ * each other.
+ */
+template<typename T>
+CDTEdge<T> *CDT_state<T>::connect_separate_parts(SymEdge<T> *se1, SymEdge<T> *se2)
+{
+  BLI_assert(se1->face == this->outer_face && se2->face == this->outer_face);
+  SymEdge<T> *se1_rot = se1->rot;
+  SymEdge<T> *se1_rotsym = sym(se1_rot);
+  SymEdge<T> *se2_rot = se2->rot;
+  SymEdge<T> *se2_rotsym = sym(se2_rot);
+  CDTEdge<T> *e = this->add_edge(se1->vert, se2->vert, this->outer_face, this->outer_face);
+  SymEdge<T> *new_se = &e->symedges[0];
+  SymEdge<T> *new_se_sym = &e->symedges[1];
+  new_se->next = se2;
+  new_se_sym->next = se1;
+  new_se->rot = se1_rot;
+  new_se_sym->rot = se2_rot;
+  se1->rot = new_se;
+  se2->rot = new_se_sym;
+  se1_rotsym->next = new_se;
+  se2_rotsym->next = new_se_sym;
+  return e;
+}
+
+/*
+ * Split se at fraction lambda,
+ * and return the new CDTEdge that is the new second half.
+ * Copy the edge input_ids into the new one.
+ */
+template<typename T> CDTEdge<T> *CDT_state<T>::split_edge(SymEdge<T> *se, T lambda)
+{
+  /* Split e at lambda. */
+  const vec2<T> *a = &se->vert->co;
+  const vec2<T> *b = &se->next->vert->co;
+  SymEdge<T> *sesym = sym(se);
+  SymEdge<T> *sesymprev = prev(sesym);
+  SymEdge<T> *sesymprevsym = sym(sesymprev);
+  SymEdge<T> *senext = se->next;
+  CDTVert<T> *v = this->add_vert(vec2<T>::interpolate(*a, *b, lambda));
+  CDTEdge<T> *e = this->add_edge(v, se->next->vert, se->face, sesym->face);
+  sesym->vert = v;
+  SymEdge<T> *newse = &e->symedges[0];
+  SymEdge<T> *newsesym = &e->symedges[1];
+  se->next = newse;
+  newsesym->next = sesym;
+  newse->next = senext;
+  newse->rot = sesym;
+  sesym->rot = newse;
+  senext->rot = newsesym;
+  newsesym->rot = sesymprevsym;
+  sesymprev->next = newsesym;
+  if (newsesym->vert->symedge == sesym) {
+    newsesym->vert->symedge = newsesym;
+  }
+  add_list_to_input_ids(&e->input_ids, se->edge->input_ids, this);
+  return e;
+}
+
+/*
+ * Delete an edge from the structure. The new combined face on either side of
+ * the deleted edge will be the one that was e's face.
+ * There will be now an unused face, marked by setting its deleted flag,
+ * and an unused #CDTEdge, marked by setting the next and rot pointers of
+ * its SymEdges to NULL.
+ * <pre>
+ *        .  v2               .
+ *       / \                 / \
+ *      /f|j\               /   \
+ *     /  |  \             /     \
+ *        |
+ *      A |  B                A
+ *    \  e|   /           \       /
+ *     \  | /              \     /
+ *      \h|i/               \   /
+ *        .  v1               .
+ * </pre>
+ * Also handle variant cases where one or both ends
+ * are attached only to e.
+ */
+template<typename T> void CDT_state<T>::delete_edge(SymEdge<T> *se)
+{
+  SymEdge<T> *sesym = sym(se);
+  CDTVert<T> *v1 = se->vert;
+  CDTVert<T> *v2 = sesym->vert;
+  CDTFace<T> *aface = se->face;
+  CDTFace<T> *bface = sesym->face;
+  SymEdge<T> *f = se->next;
+  SymEdge<T> *h = prev(se);
+  SymEdge<T> *i = sesym->next;
+  SymEdge<T> *j = prev(sesym);
+  SymEdge<T> *jsym = sym(j);
+  SymEdge<T> *hsym = sym(h);
+  bool v1_isolated = (i == se);
+  bool v2_isolated = (f == sesym);
+
+  if (!v1_isolated) {
+    h->next = i;
+    i->rot = hsym;
+  }
+  if (!v2_isolated) {
+    j->next = f;
+    f->rot = jsym;
+  }
+  if (!v1_isolated && !v2_isolated && aface != bface) {
+    for (SymEdge<T> *k = i; k != f; k = k->next) {
+      k->face = aface;
+    }
+  }
+
+  /* If e was representative symedge for v1 or v2, fix that. */
+  if (v1_isolated) {
+    v1->symedge = nullptr;
+  }
+  else if (v1->symedge == se) {
+    v1->symedge = i;
+  }
+  if (v2_isolated) {
+    v2->symedge = nullptr;
+  }
+  else if (v2->symedge == sesym) {
+    v2->symedge = f;
+  }
+
+  /* Mark SymEdge as deleted by setting all its pointers to NULL. */
+  se->next = se->rot = nullptr;
+  sesym->next = sesym->rot = nullptr;
+  if (!v1_isolated && !v2_isolated && aface != bface) {
+    bface->deleted = true;
+    if (this->outer_face == bface) {
+      this->outer_face = aface;
+    }
+  }
+}
+
+template<typename T> class SiteInfo {
+ public:
+  CDTVert<T> *v;
+  int orig_index;
+};
+
+/* Compare function for lexicographic sort: x, then y, then index. */
+template<typename T> bool site_lexicographic_sort(const SiteInfo<T> &a, const SiteInfo<T> &b)
+{
+  const vec2<T> &co_a = a.v->co;
+  const vec2<T> &co_b = b.v->co;
+  if (co_a[0] < co_b[0]) {
+    return true;
+  }
+  else if (co_a[0] > co_b[0]) {
+    return false;
+  }
+  else if (co_a[1] < co_b[1]) {
+    return true;
+  }
+  else if (co_a[1] > co_b[1]) {
+    return false;
+  }
+  else {
+    return a.orig_index < b.orig_index;
+  }
+}
+
+/* Find series of equal vertices in the sorted sites array
+ * and use the vertice's merge_to_index to indicate that
+ * all vertices after the first merge to the first.
+ */
+template<typename T> void find_site_merges(Array<SiteInfo<T>> &sites)
+{
+  int n = static_cast<int>(sites.size());
+  for (int i = 0; i < n - 1; ++i) {
+    int j = i + 1;
+    while (j < n && sites[j].v->co == sites[i].v->co) {
+      sites[j].v->merge_to_index = sites[i].orig_index;
+      ++j;
+    }
+    if (j - i > 1) {
+      i = j - 1; /* j-1 because loop head will add another 1. */
+    }
+  }
+}
+
+template<typename T> inline bool vert_left_of_symedge(CDTVert<T> *v, SymEdge<T> *se)
+{
+  return vec2<T>::orient2d(v->co, se->vert->co, se->next->vert->co) > 0;
+}
+
+template<typename T> inline bool vert_right_of_symedge(CDTVert<T> *v, SymEdge<T> *se)
+{
+  return vec2<T>::orient2d(v->co, se->next->vert->co, se->vert->co) > 0;
+}
+
+/* Is se above basel? */
+template<typename T>
+inline bool dc_tri_valid(SymEdge<T> *se, SymEdge<T> *basel, SymEdge<T> *basel_sym)
+{
+  return vec2<T>::orient2d(se->next->vert->co, basel_sym->vert->co, basel->vert->co) > 0;
+}
+
+/* Delaunay triangulate sites[start} to sites[end-1].
+ * Assume sites are lexicographically sorted by coordinate.
+ * Return SymEdge of ccw convex hull at left-most point in *r_le
+ * and that of right-most point of cw convex null in *r_re.
+ */
+template<typename T>
+void dc_tri(CDT_state<T> *cdt,
+            Array<SiteInfo<T>> &sites,
+            int start,
+            int end,
+            SymEdge<T> **r_le,
+            SymEdge<T> **r_re)
+{
+  constexpr int dbg_level = 0;
+  if (dbg_level > 0) {
+    std::cout << "DC_TRI start=" << start << " end=" << end << "\n";
+  }
+  int n = end - start;
+  if (n <= 1) {
+    *r_le = nullptr;
+    *r_re = nullptr;
+    return;
+  }
+
+  /* Base case: if n <= 3, triangulate directly. */
+  if (n <= 3) {
+    CDTVert<T> *v1 = sites[start].v;
+    CDTVert<T> *v2 = sites[start + 1].v;
+    CDTEdge<T> *ea = cdt->add_edge(v1, v2, cdt->outer_face, cdt->outer_face);
+    ea->symedges[0].next = &ea->symedges[1];
+    ea->symedges[1].next = &ea->symedges[0];
+    ea->symedges[0].rot = &ea->symedges[0];
+    ea->symedges[1].rot = &ea->symedges[1];
+    if (n == 2) {
+      *r_le = &ea->symedges[0];
+      *r_re = &ea->symedges[1];
+      return;
+    }
+    CDTVert<T> *v3 = sites[start + 2].v;
+    CDTEdge<T> *eb = cdt->add_vert_to_symedge_edge(v3, &ea->symedges[1]);
+    int orient = vec2<T>::orient2d(v1->co, v2->co, v3->co);
+    if (orient > 0) {
+      cdt->add_diagonal(&eb->symedges[0], &ea->symedges[0]);
+      *r_le = &ea->symedges[0];
+      *r_re = &eb->symedges[0];
+    }
+    else if (orient < 0) {
+      cdt->add_diagonal(&ea->symedges[0], &eb->symedges[0]);
+      *r_le = ea->symedges[0].rot;
+      *r_re = eb->symedges[0].rot;
+    }
+    else {
+      /* Collinear points. Just return a line. */
+      *r_le = &ea->symedges[0];
+      *r_re = &eb->symedges[0];
+    }
+    return;
+  }
+  /* Recursive case. Do left (L) and right (R) halves seperately, then join. */
+  int n2 = n / 2;
+  BLI_assert(n2 >= 2 && end - (start + n2) >= 2);
+  SymEdge<T> *ldo, *ldi, *rdi, *rdo;
+  dc_tri(cdt, sites, start, start + n2, &ldo, &ldi);
+  dc_tri(cdt, sites, start + n2, end, &rdi, &rdo);
+  if (dbg_level > 0) {
+    std::cout << "\nDC_TRI merge step for start=" << start << ", end=" << end << "\n";
+    std::cout << "ldo " << ldo << "\n"
+              << "ldi " << ldi << "\n"
+              << "rdi " << rdi << "\n"
+              << "rdo " << rdo << "\n";
+    if (dbg_level > 1) {
+      std::string lab = "dc_tri (" + std::to_string(start) + "," + std::to_string(start + n2) +
+                        ")(" + std::to_string(start + n2) + "," + std::to_string(end) + ")";
+      cdt_draw(lab, *cdt);
+    }
+  }
+  /* Find lower common tangent of L and R. */
+  for (;;) {
+    if (vert_left_of_symedge(rdi->vert, ldi)) {
+      ldi = ldi->next;
+    }
+    else if (vert_right_of_symedge(ldi->vert, rdi)) {
+      rdi = sym(rdi)->rot; /* Previous edge to rdi with same right face. */
+    }
+    else {
+      break;
+    }
+  }
+  if (dbg_level > 0) {
+    std::cout << "common lower tangent in between\n"
+              << "rdi " << rdi << "\n"
+              << "ldi" << ldi << "\n";
+  }
+
+  CDTEdge<T> *ebasel = cdt->connect_separate_parts(sym(rdi)->next, ldi);
+  SymEdge<T> *basel = &ebasel->symedges[0];
+  SymEdge<T> *basel_sym = &ebasel->symedges[1];
+  if (dbg_level > 1) {
+    std::cout << "basel " << basel;
+    cdt_draw("after basel made", *cdt);
+  }
+  if (ldi->vert == ldo->vert) {
+    ldo = basel_sym;
+  }
+  if (rdi->vert == rdo->vert) {
+    rdo = basel;
+  }
+
+  /* Merge loop. */
+  for (;;) {
+    /* Locate the first point lcand->next->vert encountered by rising bubble,
+     * and delete L edges out of basel->next->vert that fail the circle test. */
+    SymEdge<T> *lcand = basel_sym->rot;
+    SymEdge<T> *rcand = basel_sym->next;
+    if (dbg_level > 1) {
+      std::cout << "\ntop of merge loop\n";
+      std::cout << "lcand " << lcand << "\n"
+                << "rcand " << rcand << "\n"
+                << "basel " << basel << "\n";
+    }
+    if (dc_tri_valid(lcand, basel, basel_sym)) {
+      if (dbg_level > 1) {
+        std::cout << "found valid lcand\n";
+        std::cout << "  lcand" << lcand << "\n";
+      }
+      while (vec2<T>::incircle(basel_sym->vert->co,
+                               basel->vert->co,
+                               lcand->next->vert->co,
+                               lcand->rot->next->vert->co) > 0.0) {
+        if (dbg_level > 1) {
+          std::cout << "incircle says to remove lcand\n";
+          std::cout << "  lcand" << lcand << "\n";
+        }
+        SymEdge<T> *t = lcand->rot;
+        cdt->delete_edge(sym(lcand));
+        lcand = t;
+      }
+    }
+    /* Symmetrically, locate first R point to be hit and delete R edges. */
+    if (dc_tri_valid(rcand, basel, basel_sym)) {
+      if (dbg_level > 1) {
+        std::cout << "found valid rcand\n";
+        std::cout << "  rcand" << rcand << "\n";
+      }
+      while (vec2<T>::incircle(basel_sym->vert->co,
+                               basel->vert->co,
+                               rcand->next->vert->co,
+                               sym(rcand)->next->next->vert->co) > 0.0) {
+        if (dbg_level > 0) {
+          std::cout << "incircle says to remove rcand\n";
+          std::cout << "  rcand" << rcand << "\n";
+        }
+        SymEdge<T> *t = sym(rcand)->next;
+        cdt->delete_edge(rcand);
+        rcand = t;
+      }
+    }
+    /* If both lcand and rcand are invalid, then basel is the common upper tangent. */
+    bool valid_lcand = dc_tri_valid(lcand, basel, basel_sym);
+    bool valid_rcand = dc_tri_valid(rcand, basel, basel_sym);
+    if (dbg_level > 0) {
+      std::cout << "after bubbling up, valid_lcand=" << valid_lcand
+                << ", valid_rand=" << valid_rcand << "\n";
+      std::cout << "lcand" << lcand << "\n"
+                << "rcand" << rcand << "\n";
+    }
+    if (!valid_lcand && !valid_rcand) {
+      break;
+    }
+    /* The next cross edge to be connected is to either lcand->next->vert or rcand->next->vert;
+     * if both are valid, choose the appropriate one using the incircle test.
+     */
+    if (!valid_lcand || (valid_rcand && vec2<T>::incircle(lcand->next->vert->co,
+                                                          lcand->vert->co,
+                                                          rcand->vert->co,
+                                                          rcand->next->vert->co) > 0)) {
+      if (dbg_level > 0) {
+        std::cout << "connecting rcand\n";
+        std::cout << "  se1=basel_sym" << basel_sym << "\n";
+        std::cout << "  se2=rcand->next" << rcand->next << "\n";
+      }
+      ebasel = cdt->add_diagonal(rcand->next, basel_sym);
+    }
+    else {
+      if (dbg_level > 0) {
+        std::cout << "connecting lcand\n";
+        std::cout << "  se1=sym(lcand)" << sym(lcand) << "\n";
+        std::cout << "  se2=basel_sym->next" << basel_sym->next << "\n";
+      }
+      ebasel = cdt->add_diagonal(basel_sym->next, sym(lcand));
+    }
+    basel = &ebasel->symedges[0];
+    basel_sym = &ebasel->symedges[1];
+    BLI_assert(basel_sym->face == cdt->outer_face);
+    if (dbg_level > 2) {
+      cdt_draw("after adding new crossedge", *cdt);
+    }
+  }
+  *r_le = ldo;
+  *r_re = rdo;
+  BLI_assert(sym(ldo)->face == cdt->outer_face && rdo->face == cdt->outer_face);
+}
+
+/* Guibas-Stolfi Divide-and_Conquer algorithm. */
+template<typename T> void dc_triangulate(CDT_state<T> *cdt, Array<SiteInfo<T>> &sites)
+{
+  /* Compress sites in place to eliminted verts that merge to others. */
+  int i = 0;
+  int j = 0;
+  int nsites = static_cast<int>(sites.size());
+  while (j < nsites) {
+    /* Invariante: sites[0..i-1] have non-merged verts from 0..(j-1) in them. */
+    sites[i] = sites[j++];
+    if (sites[i].v->merge_to_index < 0) {
+      i++;
+    }
+  }
+  int n = i;
+  if (n == 0) {
+    return;
+  }
+  SymEdge<T> *le, *re;
+  dc_tri(cdt, sites, 0, n, &le, &re);
+}
+
+/*
+ * Do a Delaunay Triangulation of the points in cdt.verts.
+ * This  is only a first step in the Constrained Delaunay triangulation,
+ * because it doesn't yet deal with the segment constraints.
+ * The algorithm used is the Divide & Conquer algorithm from the
+ * Guibas-Stolfi "Primitives for the Manipulation of General Subdivision
+ * and the Computation of Voronoi Diagrams" paper.
+ * The data structure here is similar to but not exactly the same as
+ * the quad-edge structure described in that paper.
+ * If T is not exact arithmetic, incircle and ccw tests are done using
+ * Shewchuk's exact primitives, so that this routine is robust.
+ *
+ * As a preprocessing step, we want to merge all vertices that the same.
+ * This is accomplished by lexicographically
+ * sorting the coordinates first (which is needed anyway for the D&C algorithm).
+ * The CDTVerts with merge_to_index not equal to -1 are after this regarded
+ * as having been merged into the vertex with the corresponding index.
+ */
+template<typename T> void initial_triangulation(CDT_state<T> *cdt)
+{
+  int n = static_cast<int>(cdt->verts.size());
+  if (n <= 1) {
+    return;
+  }
+  Array<SiteInfo<T>> sites(n);
+  for (int i = 0; i < n; ++i) {
+    sites[i].v = cdt->verts[i];
+    sites[i].orig_index = i;
+  }
+  std::sort(sites.begin(), sites.end(), site_lexicographic_sort<T>);
+  find_site_merges(sites);
+  dc_triangulate(cdt, sites);
+}
+
+/*
+ * Re-triangulates, assuring constrained delaunay condition,
+ * the pseudo-polygon that cycles from se.
+ * "pseudo" because a vertex may be repeated.
+ * See Anglada paper, "An Improved incremental algorithm
+ * for constructing restricted Delaunay triangulations".
+ */
+template<typename T> static void re_delaunay_triangulate(CDT_state<T> *cdt, SymEdge<T> *se)
+{
+  if (se->face == cdt->outer_face || sym(se)->face == cdt->outer_face) {
+    return;
+  }
+  /* 'se' is a diagonal just added, and it is base of area to retriangulate (face on its left) */
+  int count = 1;
+  for (SymEdge<T> *ss = se->next; ss != se; ss = ss->next) {
+    count++;
+  }
+  if (count <= 3) {
+    return;
+  }
+  /* First and last are the SymEdges whose verts are first and last off of base,
+   * continuing from 'se'. */
+  SymEdge<T> *first = se->next->next;
+  /* We want to make a triangle with 'se' as base and some other c as 3rd vertex. */
+  CDTVert<T> *a = se->vert;
+  CDTVert<T> *b = se->next->vert;
+  CDTVert<T> *c = first->vert;
+  SymEdge<T> *cse = first;
+  for (SymEdge<T> *ss = first->next; ss != se; ss = ss->next) {
+    CDTVert<T> *v = ss->vert;
+    if (vec2<T>::incircle(a->co, b->co, c->co, v->co) > 0) {
+      c = v;
+      cse = ss;
+    }
+  }
+  /* Add diagonals necessary to make abc a triangle. */
+  CDTEdge<T> *ebc = nullptr;
+  CDTEdge<T> *eca = nullptr;
+  if (!exists_edge(b, c)) {
+    ebc = cdt->add_diagonal(se->next, cse);
+  }
+  if (!exists_edge(c, a)) {
+    eca = cdt->add_diagonal(cse, se);
+  }
+  /* Now recurse. */
+  if (ebc) {
+    re_delaunay_triangulate(cdt, &ebc->symedges[1]);
+  }
+  if (eca) {
+    re_delaunay_triangulate(cdt, &eca->symedges[1]);
+  }
+}
+
+template<typename T> inline int tri_orient(const SymEdge<T> *t)
+{
+  return vec2<T>::orient2d(t->vert->co, t->next->vert->co, t->next->next->vert->co);
+}
+
+/*
+ * The CrossData class defines either an endpoint or an intermediate point
+ * in the path we will take to insert an edge constraint.
+ * Each such point will either be
+ * (a) a vertex or
+ * (b) a fraction lambda (0 < lambda < 1) along some SymEdge.]
+ *
+ * In general, lambda=0 indicates case a and lambda != 0 indicates case be.
+ * The 'in' edge gives the destination attachment point of a diagonal from the previous crossing,
+ * and the 'out' edge gives the origin attachment point of a diagonal to the next crossing.
+ * But in some cases, 'in' and 'out' are undefined or not needed, and will be NULL.
+ *
+ * For case (a), 'vert' will be the vertex, and lambda will be 0, and 'in' will be the SymEdge from
+ * 'vert' that has as face the one that you go through to get to this vertex. If you go exactly
+ * along an edge then we set 'in' to NULL, since it won't be needed. The first crossing will have
+ * 'in' = NULL. We set 'out' to the SymEdge that has the face we go though to get to the next
+ * crossing, or, if the next crossing is a case (a), then it is the edge that goes to that next
+ * vertex. 'out' wlll be NULL for the last one.
+ *
+ * For case (b), vert will be NULL at first, and later filled in with the created split vertex,
+ * and 'in' will be the SymEdge that we go through, and lambda will be between 0 and 1,
+ * the fraction from in's vert to in->next's vert to put the split vertex.
+ * 'out' is not needed in this case, since the attachment point will be the sym of the first
+ * half of the split edge.
+ */
+template<typename T> class CrossData {
+ public:
+  T lambda;
+  CDTVert<T> *vert;
+  SymEdge<T> *in;
+  SymEdge<T> *out;
+
+  CrossData() : lambda(T(0)), vert(nullptr), in(nullptr), out(nullptr)
+  {
+  }
+  CrossData(T l, CDTVert<T> *v, SymEdge<T> *i, SymEdge<T> *o) : lambda(l), vert(v), in(i), out(o)
+  {
+  }
+};
+
+template<typename T>
+bool get_next_crossing_from_vert(CDT_state<T> *cdt,
+                                 CrossData<T> *cd,
+                                 CrossData<T> *cd_next,
+                                 const CDTVert<T> *v2);
+
+/*
+ * As part of finding crossings, we found a case where the next crossing goes through vert v.
+ * If it came from a previous vert in cd, then cd_out is the edge that leads from that to v.
+ * Else cd_out can be NULL, because it won't be used.
+ * Set *cd_next to indicate this. We can set 'in' but not 'out'.  We can set the 'out' of the
+ * current cd.
+ */
+template<typename T>
+void fill_crossdata_for_through_vert(CDTVert<T> *v,
+                                     SymEdge<T> *cd_out,
+                                     CrossData<T> *cd,
+                                     CrossData<T> *cd_next)
+{
+  SymEdge<T> *se;
+
+  cd_next->lambda = T(0);
+  cd_next->vert = v;
+  cd_next->in = NULL;
+  cd_next->out = NULL;
+  if (cd->lambda == 0) {
+    cd->out = cd_out;
+  }
+  else {
+    /* One of the edges in the triangle with edge sym(cd->in) contains v. */
+    se = sym(cd->in);
+    if (se->vert != v) {
+      se = se->next;
+      if (se->vert != v) {
+        se = se->next;
+      }
+    }
+    BLI_assert(se->vert == v);
+    cd_next->in = se;
+  }
+}
+
+/*
+ * As part of finding crossings, we found a case where orient tests say that the next crossing
+ * is on the SymEdge t, while intersecting with the ray from curco to v2.
+ * Find the intersection point and fill in the CrossData for that point.
+ * It may turn out that when doing the intersection, we get an answer that says that
+ * this case is better handled as through-vertex case instead, so we may do that.
+ * In the latter case, we want to avoid a situation where the current crossing is on an edge
+ * and the next will be an endpoint of the same edge. When that happens, we "rewrite history"
+ * and turn the current crossing into a vert one, and then extend from there.
+ *
+ * We cannot fill cd_next's 'out' edge yet, in the case that the next one ends up being a vert
+ * case. We need to fill in cd's 'out' edge if it was a vert case.
+ */
+template<typename T>
+void fill_crossdata_for_intersect(const vec2<T> &curco,
+                                  const CDTVert<T> *v2,
+                                  SymEdge<T> *t,
+                                  CrossData<T> *cd,
+                                  CrossData<T> *cd_next,
+                                  const T epsilon)
+{
+  CDTVert<T> *va = t->vert;
+  CDTVert<T> *vb = t->next->vert;
+  CDTVert<T> *vc = t->next->next->vert;
+  SymEdge<T> *se_vcvb = sym(t->next);
+  SymEdge<T> *se_vcva = t->next->next;
+  BLI_assert(se_vcva->vert == vc && se_vcva->next->vert == va);
+  BLI_assert(se_vcvb->vert == vc && se_vcvb->next->vert == vb);
+  UNUSED_VARS_NDEBUG(vc);
+  auto isect = vec2<T>::isect_seg_seg(va->co, vb->co, curco, v2->co);
+  T &lambda = isect.lambda;
+  switch (isect.kind) {
+    case vec2<T>::isect_result::LINE_LINE_CROSS:
+      if (!std::is_same<T, mpq_class>::value) {
+        T len_ab = vec2<T>::distance(va->co, vb->co);
+        if (lambda * len_ab <= epsilon) {
+          fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
+        }
+        else if ((1 - lambda) * len_ab <= epsilon) {
+          fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
+        }
+        else {
+          *cd_next = CrossData<T>(lambda, nullptr, t, nullptr);
+          if (cd->lambda == 0) {
+            cd->out = se_vcva;
+          }
+        }
+      }
+      else {
+        *cd_next = CrossData<T>(lambda, nullptr, t, nullptr);
+        if (cd->lambda == 0) {
+          cd->out = se_vcva;
+        }
+      }
+      break;
+    case vec2<T>::isect_result::LINE_LINE_EXACT:
+      if (lambda == 0) {
+        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
+      }
+      else if (lambda == 1) {
+        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
+      }
+      else {
+        *cd_next = CrossData<T>(lambda, nullptr, t, nullptr);
+        if (cd->lambda == 0) {
+          cd->out = se_vcva;
+        }
+      }
+      break;
+    case vec2<T>::isect_result::LINE_LINE_NONE:
+      if (std::is_same<T, mpq_class>::value) {
+        BLI_assert(false);
+      }
+      /* It should be very near one end or other of segment. */
+      if (lambda <= T(0.5)) {
+        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
+      }
+      else {
+        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
+      }
+      break;
+    case vec2<T>::isect_result::LINE_LINE_COLINEAR:
+      if (vec2<T>::distance_squared(va->co, v2->co) <= vec2<T>::distance_squared(vb->co, v2->co)) {
+        fill_crossdata_for_through_vert(va, se_vcva, cd, cd_next);
+      }
+      else {
+        fill_crossdata_for_through_vert(vb, se_vcvb, cd, cd_next);
+      }
+      break;
+  }
+}
+
+/*
+ * As part of finding the crossings of a ray to v2, find the next crossing after 'cd', assuming
+ * 'cd' represents a crossing that goes through a vertex.
+ *
+ * We do a rotational scan around cd's vertex, looking for the triangle where the ray from cd->vert
+ * to v2 goes between the two arms from cd->vert, or where it goes along one of the edges.
+ */
+template<typename T>
+bool get_next_crossing_from_vert(CDT_state<T> *cdt,
+                                 CrossData<T> *cd,
+                                 CrossData<T> *cd_next,
+                                 const CDTVert<T> *v2)
+{
+  SymEdge<T> *tstart = cd->vert->symedge;
+  SymEdge<T> *t = tstart;
+  CDTVert<T> *vcur = cd->vert;
+  bool ok = false;
+  do {
+    /*
+     * The ray from vcur to v2 has to go either between two successive
+     * edges around vcur or exactly along them. This time through the
+     * loop, check to see if the ray goes along vcur-va
+     * or between vcur-va and vcur-vb, where va is the end of t
+     * and vb is the next vertex (on the next rot edge around vcur, but
+     * should also be the next vert of triangle starting with vcur-va.
+     */
+    if (t->face != cdt->outer_face && tri_orient(t) < 0) {
+      BLI_assert(false); /* Shouldn't happen. */
+    }
+    CDTVert<T> *va = t->next->vert;
+    CDTVert<T> *vb = t->next->next->vert;
+    int orient1 = vec2<T>::orient2d(t->vert->co, va->co, v2->co);
+    if (orient1 == 0 && in_line<T>(vcur->co, va->co, v2->co)) {
+      fill_crossdata_for_through_vert(va, t, cd, cd_next);
+      ok = true;
+      break;
+    }
+    else if (t->face != cdt->outer_face) {
+      int orient2 = vec2<T>::orient2d(vcur->co, vb->co, v2->co);
+      /* Don't handle orient2 == 0 case here: next rotation will get it. */
+      if (orient1 > 0 && orient2 < 0) {
+        /* Segment intersection. */
+        t = t->next;
+        fill_crossdata_for_intersect(vcur->co, v2, t, cd, cd_next, cdt->epsilon);
+        ok = true;
+        break;
+      }
+    }
+  } while ((t = t->rot) != tstart);
+  return ok;
+}
+
+/*
+ * As part of finding the crossings of a ray to v2, find the next crossing after 'cd', assuming
+ * 'cd' represents a crossing that goes through a an edge, not at either end of that edge.
+ *
+ * We have the triangle vb-va-vc, where va and vb are the split edge and vc is the third vertex on
+ * that new side of the edge (should be closer to v2). The next crossing should be through vc or
+ * intersecting vb-vc or va-vc.
+ */
+template<typename T>
+void get_next_crossing_from_edge(CrossData<T> *cd,
+                                 CrossData<T> *cd_next,
+                                 const CDTVert<T> *v2,
+                                 const T epsilon)
+{
+  CDTVert<T> *va = cd->in->vert;
+  CDTVert<T> *vb = cd->in->next->vert;
+  vec2<T> curco = vec2<T>::interpolate(va->co, vb->co, cd->lambda);
+  SymEdge<T> *se_ac = sym(cd->in)->next;
+  CDTVert<T> *vc = se_ac->next->vert;
+  int orient = vec2<T>::orient2d(curco, v2->co, vc->co);
+  if (orient < 0) {
+    fill_crossdata_for_intersect<T>(curco, v2, se_ac->next, cd, cd_next, epsilon);
+  }
+  else if (orient > 0.0) {
+    fill_crossdata_for_intersect(curco, v2, se_ac, cd, cd_next, epsilon);
+  }
+  else {
+    *cd_next = CrossData<T>{0.0, vc, se_ac->next, nullptr};
+  }
+}
+
+template<typename T> void dump_crossings(const Vector<CrossData<T>, 128> &crossings)
+{
+  std::cout << "CROSSINGS\n";
+  for (int i = 0; i < static_cast<int>(crossings.size()); ++i) {
+    std::cout << i << ": ";
+    const CrossData<T> &cd = crossings[i];
+    if (cd.lambda == 0) {
+      std::cout << "v" << cd.vert->index;
+    }
+    else {
+      std::cout << "lambda=" << cd.lambda;
+    }
+    if (cd.in != nullptr) {
+      std::cout << " in=" << short_se_dump(cd.in);
+      std::cout << " out=" << short_se_dump(cd.out);
+    }
+    std::cout << "\n";
+  }
+}
+
+/*
+ * Add a constrained edge between v1 and v2 to cdt structure.
+ * This may result in a number of #CDTEdges created, due to intersections
+ * and partial overlaps with existing cdt vertices and edges.
+ * Each created #CDTEdge will have input_id added to its input_ids list.
+ *
+ * If \a r_edges is not NULL, the #CDTEdges generated or found that go from
+ * v1 to v2 are put into that linked list, in order.
+ *
+ * Assumes that #BLI_constrained_delaunay_get_output has not been called yet.
+ */
+template<typename T>
+void add_edge_constraint(
+    CDT_state<T> *cdt, CDTVert<T> *v1, CDTVert<T> *v2, int input_id, LinkNode **r_edges)
+{
+  constexpr int dbg_level = 0;
+  if (dbg_level > 0) {
+    std::cout << "\nADD EDGE CONSTRAINT\n" << vertname(v1) << " " << vertname(v2) << "\n";
+  }
+  LinkNodePair edge_list = {NULL, NULL};
+
+  if (r_edges) {
+    *r_edges = NULL;
+  }
+
+  /*
+   * Handle two special cases first:
+   * 1) The two end vertices are the same (can happen because of merging).
+   * 2) There is already an edge between v1 and v2.
+   */
+  if (v1 == v2) {
+    return;
+  }
+  SymEdge<T> *t = find_symedge_between_verts(v1, v2);
+  if (t != nullptr) {
+    /* Segment already there. */
+    add_to_input_ids(&t->edge->input_ids, input_id, cdt);
+    if (r_edges != NULL) {
+      BLI_linklist_append_pool(&edge_list, t->edge, cdt->listpool);
+      *r_edges = edge_list.list;
+    }
+    return;
+  }
+
+  /*
+   * Fill crossings array with CrossData points for intersection path from v1 to v2.
+   *
+   * At every point, the crossings array has the path so far, except that
+   * the .out field of the last element of it may not be known yet -- if that
+   * last element is a vertex, then we won't know the output edge until we
+   * find the next crossing.
+   *
+   * To protect against infinite loops, we keep track of which vertices
+   * we have visited by setting their visit_index to a new visit epoch.
+   *
+   * We check a special case first: where the segment is already there in
+   * one hop. Saves a bunch of orient2d tests in that common case.
+   */
+  int visit = ++cdt->visit_count;
+  Vector<CrossData<T>, 128> crossings;
+  crossings.append(CrossData<T>(T(0), v1, nullptr, nullptr));
+  int n;
+  while (!((n = static_cast<int>(crossings.size())) > 0 && crossings[n - 1].vert == v2)) {
+    crossings.append(CrossData<T>());
+    CrossData<T> *cd = &crossings[n - 1];
+    CrossData<T> *cd_next = &crossings[n];
+    bool ok;
+    if (crossings[n - 1].lambda == 0) {
+      ok = get_next_crossing_from_vert(cdt, cd, cd_next, v2);
+    }
+    else {
+      get_next_crossing_from_edge(cd, cd_next, v2, cdt->epsilon);
+      ok = true;
+    }
+    if (!ok || crossings.size() == 100000) {
+      /* Shouldn't happen but if does, just bail out. */
+      BLI_assert(false);
+      return;
+    }
+    if (crossings[n].lambda == 0) {
+      if (crossings[n].vert->visit_index == visit) {
+        /* Shouldn't happen but if it does, just bail out. */
+        BLI_assert(false);
+        return;
+      }
+      crossings[n].vert->visit_index = visit;
+    }
+  }
+
+  if (dbg_level > 0) {
+    dump_crossings(crossings);
+  }
+
+  /*
+   * Postprocess crossings.
+   * Some crossings may have an intersection crossing followed
+   * by a vertex crossing that is on the same edge that was just
+   * intersected. We prefer to go directly from the previous
+   * crossing directly to the vertex. This may chain backwards.
+   *
+   * This loop marks certain crossings as "deleted", by setting
+   * their lambdas to -1.0.
+   */
+  int ncrossings = static_cast<int>(crossings.size());
+  for (int i = 2; i < ncrossings; ++i) {
+    CrossData<T> *cd = &crossings[i];
+    if (cd->lambda == 0.0) {
+      CDTVert<T> *v = cd->vert;
+      int j;
+      CrossData<T> *cd_prev;
+      for (j = i - 1; j > 0; --j) {
+        cd_prev = &crossings[j];
+        if ((cd_prev->lambda == 0.0 && cd_prev->vert != v) ||
+            (cd_prev->lambda != 0.0 && cd_prev->in->vert != v && cd_prev->in->next->vert != v)) {
+          break;
+        }
+        else {
+          cd_prev->lambda = -1.0; /* Mark cd_prev as 'deleted'. */
+        }
+      }
+      if (j < i - 1) {
+        /* Some crossings were deleted. Fix the in and out edges across gap. */
+        cd_prev = &crossings[j];
+        SymEdge<T> *se;
+        if (cd_prev->lambda == 0.0) {
+          se = find_symedge_between_verts(cd_prev->vert, v);
+          if (se == NULL) {
+            return;
+          }
+          cd_prev->out = se;
+          cd->in = NULL;
+        }
+        else {
+          se = find_symedge_with_face(v, sym(cd_prev->in)->face);
+          if (se == NULL) {
+            return;
+          }
+          cd->in = se;
+        }
+      }
+    }
+  }
+
+  /*
+   * Insert all intersection points on constrained edges.
+   */
+  for (int i = 0; i < ncrossings; ++i) {
+    CrossData<T> *cd = &crossings[i];
+    if (cd->lambda != 0.0 && cd->lambda != -1.0 && is_constrained_edge(cd->in->edge)) {
+      CDTEdge<T> *edge = cdt->split_edge(cd->in, cd->lambda);
+      cd->vert = edge->symedges[0].vert;
+    }
+  }
+
+  /*
+   * Remove any crossed, non-intersected edges.
+   */
+  for (int i = 0; i < ncrossings; ++i) {
+    CrossData<T> *cd = &crossings[i];
+    if (cd->lambda != 0.0 && cd->lambda != -1.0 && !is_constrained_edge(cd->in->edge)) {
+      cdt->delete_edge(cd->in);
+    }
+  }
+
+  /*
+   * Insert segments for v1->v2.
+   */
+  SymEdge<T> *tstart = crossings[0].out;
+  for (int i = 1; i < ncrossings; i++) {
+    CrossData<T> *cd = &crossings[i];
+    if (cd->lambda == -1.0) {
+      continue; /* This crossing was deleted. */
+    }
+    t = NULL;
+    SymEdge<T> *tnext = t;
+    CDTEdge<T> *edge;
+    if (cd->lambda != 0.0) {
+      if (is_constrained_edge(cd->in->edge)) {
+        t = cd->vert->symedge;
+        tnext = sym(t)->next;
+      }
+    }
+    else if (cd->lambda == 0.0) {
+      t = cd->in;
+      tnext = cd->out;
+      if (t == NULL) {
+        /* Previous non-deleted crossing must also have been a vert, and segment should exist. */
+        int j;
+        CrossData<T> *cd_prev;
+        for (j = i - 1; j >= 0; j--) {
+          cd_prev = &crossings[j];
+          if (cd_prev->lambda != -1.0) {
+            break;
+          }
+        }
+        BLI_assert(cd_prev->lambda == 0.0);
+        BLI_assert(cd_prev->out->next->vert == cd->vert);
+        edge = cd_prev->out->edge;
+        add_to_input_ids(&edge->input_ids, input_id, cdt);
+        if (r_edges != NULL) {
+          BLI_linklist_append_pool(&edge_list, edge, cdt->listpool);
+        }
+      }
+    }
+    if (t != NULL) {
+      if (tstart->next->vert == t->vert) {
+        edge = tstart->edge;
+      }
+      else {
+        edge = cdt->add_diagonal(tstart, t);
+      }
+      add_to_input_ids(&edge->input_ids, input_id, cdt);
+      if (r_edges != NULL) {
+        BLI_linklist_append_pool(&edge_list, edge, cdt->listpool);
+      }
+      /* Now retriangulate upper and lower gaps. */
+      re_delaunay_triangulate(cdt, &edge->symedges[0]);
+      re_delaunay_triangulate(cdt, &edge->symedges[1]);
+    }
+    if (i < ncrossings - 1) {
+      if (tnext != NULL) {
+        tstart = tnext;
+      }
+    }
+  }
+
+  if (r_edges) {
+    *r_edges = edge_list.list;
+  }
+}
+
+/* Incrementally add edge input edge as a constraint. This may cause the graph structure
+ * to change, in cases where the constraints intersect existing edges.
+ * The code will ensure that CDTEdges created will have ids that tie them back
+ * to the original edge constraint index.
+ */
+template<typename T> void add_edge_constraints(CDT_state<T> *cdt, const CDT_input<T> &input)
+{
+  int ne = static_cast<int>(input.edge.size());
+  int nv = static_cast<int>(input.vert.size());
+  for (int i = 0; i < ne; i++) {
+    int iv1 = input.edge[i].first;
+    int iv2 = input.edge[i].second;
+    if (iv1 < 0 || iv1 >= nv || iv2 < 0 || iv2 >= nv) {
+      /* Ignore invalid indices in edges. */
+      continue;
+    }
+    CDTVert<T> *v1 = cdt->get_vert_resolve_merge(iv1);
+    CDTVert<T> *v2 = cdt->get_vert_resolve_merge(iv2);
+    add_edge_constraint(cdt, v1, v2, i, nullptr);
+  }
+  cdt->face_edge_offset = ne;
+}
+
+/*
+ * Add face_id to the input_ids lists of all #CDTFace's on the interior of the input face with that
+ * id. face_symedge is on edge of the boundary of the input face, with assumption that interior is
+ * on the left of that SymEdge.
+ *
+ * The algorithm is: starting from the #CDTFace for face_symedge, add the face_id and then
+ * process all adjacent faces where the adjacency isn't across an edge that was a constraint added
+ * for the boundary of the input face.
+ * fedge_start..fedge_end is the inclusive range of edge input ids that are for the given face.
+ *
+ * Note: if the input face is not CCW oriented, we'll be labeling the outside, not the inside.
+ * Note 2: if the boundary has self-crossings, this method will arbitrarily pick one of the
+ * contiguous set of faces enclosed by parts of the boundary, leaving the other such untagged. This
+ * may be a feature instead of a bug if the first contiguous section is most of the face and the
+ * others are tiny self-crossing triangles at some parts of the boundary. On the other hand, if
+ * decide we want to handle these in full generality, then will need a more complicated algorithm
+ * (using "inside" tests and a parity rule) to decide on the interior.
+ */
+template<typename T>
+void add_face_ids(
+    CDT_state<T> *cdt, SymEdge<T> *face_symedge, int face_id, int fedge_start, int fedge_end)
+{
+  /* Can't loop forever since eventually would visit every face. */
+  cdt->visit_count++;
+  int visit = cdt->visit_count;
+  Vector<SymEdge<T> *> stack;
+  stack.append(face_symedge);
+  while (!stack.is_empty()) {
+    SymEdge<T> *se = stack.pop_last();
+    CDTFace<T> *face = se->face;
+    if (face->visit_index == visit) {
+      continue;
+    }
+    face->visit_index = visit;
+    add_to_input_ids(&face->input_ids, face_id, cdt);
+    SymEdge<T> *se_start = se;
+    for (se = se->next; se != se_start; se = se->next) {
+      if (!id_range_in_list(se->edge->input_ids, fedge_start, fedge_end)) {
+        SymEdge<T> *se_sym = sym(se);
+        CDTFace<T> *face_other = se_sym->face;
+        if (face_other->visit_index != visit) {
+          stack.append(se_sym);
+        }
+      }
+    }
+  }
+}
+
+/* Incrementally each edge of each input face as an edge constraint.
+ * The code will ensure that the CDTEdges created will have ids that tie them
+ * back to the original face edge (using a numbering system for those edges
+ * that starts with cdt->face_edge_offset, and continues with the edges in
+ * order around each face in turn.
+ */
+template<typename T> void add_face_constraints(CDT_state<T> *cdt, const CDT_input<T> &input)
+{
+  int nv = static_cast<int>(input.vert.size());
+  int nf = static_cast<int>(input.face.size());
+  int fstart = 0;
+  SymEdge<T> *face_symedge0 = nullptr;
+  for (int f = 0; f < nf; f++) {
+    int flen = static_cast<int>(input.face[f].size());
+    if (flen <= 2) {
+      /* Ignore faces with fewer than 3 vertices. */
+      fstart += flen;
+      continue;
+    }
+    for (int i = 0; i < flen; i++) {
+      int face_edge_id = cdt->face_edge_offset + fstart + i;
+      int iv1 = input.face[f][i];
+      int iv2 = input.face[f][(i + 1) % flen];
+      if (iv1 < 0 || iv1 >= nv || iv2 < 0 || iv2 >= nv) {
+        /* Ignore face edges with invalid vertices. */
+        continue;
+      }
+      CDTVert<T> *v1 = cdt->get_vert_resolve_merge(iv1);
+      CDTVert<T> *v2 = cdt->get_vert_resolve_merge(iv2);
+      LinkNode *edge_list;
+      add_edge_constraint(cdt, v1, v2, face_edge_id, &edge_list);
+      /* Set a new face_symedge0 each time since earlier ones may not
+       * survive later symedge splits. Really, just want the one when
+       * i == flen -1, but this code guards against that one somehow
+       * being null.
+       */
+      if (edge_list != nullptr) {
+        CDTEdge<T> *face_edge = static_cast<CDTEdge<T> *>(edge_list->link);
+        face_symedge0 = &face_edge->symedges[0];
+        if (face_symedge0->vert != v1) {
+          face_symedge0 = &face_edge->symedges[1];
+          BLI_assert(face_symedge0->vert == v1);
+        }
+      }
+      BLI_linklist_free_pool(edge_list, nullptr, cdt->listpool);
+    }
+    int fedge_start = cdt->face_edge_offset + fstart;
+    int fedge_end = fedge_start + flen - 1;
+    if (face_symedge0 != nullptr) {
+      add_face_ids(cdt, face_symedge0, f, fedge_start, fedge_end);
+    }
+    fstart += flen;
+  }
+}
+
+/* Delete_edge but try not to mess up outer face.
+ * Also faces have symedges now, so make sure not
+ * to mess those up either. */
+template<typename T> void dissolve_symedge(CDT_state<T> *cdt, SymEdge<T> *se)
+{
+  SymEdge<T> *symse = sym(se);
+  if (symse->face == cdt->outer_face) {
+    se = sym(se);
+    symse = sym(se);
+  }
+  if (cdt->outer_face->symedge == se || cdt->outer_face->symedge == symse) {
+    /* Advancing by 2 to get past possible 'sym(se)'. */
+    if (se->next->next == se) {
+      cdt->outer_face->symedge = NULL;
+    }
+    else {
+      cdt->outer_face->symedge = se->next->next;
+    }
+  }
+  else {
+    if (se->face->symedge == se) {
+      se->face->symedge = se->next;
+    }
+    if (symse->face->symedge == symse) {
+      symse->face->symedge = symse->next;
+    }
+  }
+  cdt->delete_edge(se);
+}
+
+/* Remove all non-constraint edges. */
+template<typename T> void remove_non_constraint_edges(CDT_state<T> *cdt)
+{
+  for (CDTEdge<T> *e : cdt->edges) {
+    SymEdge<T> *se = &e->symedges[0];
+    if (!is_deleted_edge(e) && !is_constrained_edge(e)) {
+      dissolve_symedge(cdt, se);
+    }
+  }
+}
+
+/*
+ * Remove the non-constraint edges, but leave enough of them so that all of the
+ * faces that would be bmesh faces (that is, the faces that have some input representative)
+ * are valid: they can't have holes, they can't have repeated vertices, and they can't have
+ * repeated edges.
+ *
+ * Not essential, but to make the result look more aesthetically nice,
+ * remove the edges in order of decreasing length, so that it is more likely that the
+ * final remaining support edges are short, and therefore likely to make a fairly
+ * direct path from an outer face to an inner hole face.
+ */
+
+/* For sorting edges by decreasing length (squared). */
+template<typename T> struct EdgeToSort {
+  T len_squared;
+  CDTEdge<T> *e{nullptr};
+};
+
+template<typename T> void remove_non_constraint_edges_leave_valid_bmesh(CDT_state<T> *cdt)
+{
+  size_t nedges = cdt->edges.size();
+  if (nedges == 0) {
+    return;
+  }
+  Vector<EdgeToSort<T>> dissolvable_edges;
+  dissolvable_edges.reserve(cdt->edges.size());
+  int i = 0;
+  for (CDTEdge<T> *e : cdt->edges) {
+    if (!is_deleted_edge(e) && !is_constrained_edge(e)) {
+      dissolvable_edges.append(EdgeToSort<T>());
+      dissolvable_edges[i].e = e;
+      const vec2<T> &co1 = e->symedges[0].vert->co;
+      const vec2<T> &co2 = e->symedges[1].vert->co;
+      dissolvable_edges[i].len_squared = vec2<T>::distance_squared(co1, co2);
+      i++;
+    }
+  }
+  std::sort(dissolvable_edges.begin(),
+            dissolvable_edges.end(),
+            [](const EdgeToSort<T> &a, const EdgeToSort<T> &b) -> bool {
+              return (a.len_squared < b.len_squared);
+            });
+  for (EdgeToSort<T> &ets : dissolvable_edges) {
+    CDTEdge<T> *e = ets.e;
+    SymEdge<T> *se = &e->symedges[0];
+    bool dissolve = true;
+    CDTFace<T> *fleft = se->face;
+    CDTFace<T> *fright = sym(se)->face;
+    if (fleft != cdt->outer_face && fright != cdt->outer_face &&
+        (fleft->input_ids != nullptr || fright->input_ids != nullptr)) {
+      /* Is there another symedge with same left and right faces?
+       * Or is there a vertex not part of e touching the same left and right faces?
+       */
+      for (SymEdge<T> *se2 = se->next; dissolve && se2 != se; se2 = se2->next) {
+        if (sym(se2)->face == fright ||
+            (se2->vert != se->next->vert && vert_touches_face(se2->vert, fright))) {
+          dissolve = false;
+        }
+      }
+    }
+
+    if (dissolve) {
+      dissolve_symedge(cdt, se);
+    }
+  }
+}
+
+template<typename T> void remove_outer_edges_until_constraints(CDT_state<T> *cdt)
+{
+  // LinkNode *fstack = NULL;
+  // SymEdge *se, *se_start;
+  // CDTFace *f, *fsym;
+  int visit = ++cdt->visit_count;
+
+  cdt->outer_face->visit_index = visit;
+  /* Walk around outer face, adding faces on other side of dissolvable edges to stack. */
+  Vector<CDTFace<T> *> fstack;
+  SymEdge<T> *se_start = cdt->outer_face->symedge;
+  SymEdge<T> *se = se_start;
+  do {
+    if (!is_constrained_edge(se->edge)) {
+      CDTFace<T> *fsym = sym(se)->face;
+      if (fsym->visit_index != visit) {
+        fstack.append(fsym);
+      }
+    }
+  } while ((se = se->next) != se_start);
+
+  while (!fstack.is_empty()) {
+    LinkNode *to_dissolve = nullptr;
+    bool dissolvable;
+    CDTFace<T> *f = fstack.pop_last();
+    if (f->visit_index == visit) {
+      continue;
+    }
+    BLI_assert(f != cdt->outer_face);
+    f->visit_index = visit;
+    se_start = se = f->symedge;
+    do {
+      dissolvable = !is_constrained_edge(se->edge);
+      if (dissolvable) {
+        CDTFace<T> *fsym = sym(se)->face;
+        if (fsym->visit_index != visit) {
+          fstack.append(fsym);
+        }
+        else {
+          BLI_linklist_prepend_pool(&to_dissolve, se, cdt->listpool);
+        }
+      }
+      se = se->next;
+    } while (se != se_start);
+    while (to_dissolve != NULL) {
+      se = static_cast<SymEdge<T> *>(BLI_linklist_pop_pool(&to_dissolve, cdt->listpool));
+      if (se->next != NULL) {
+        dissolve_symedge(cdt, se);
+      }
+    }
+  }
+}
+
+/*
+ * Remove edges and merge faces to get desired output, as per options.
+ * \note the cdt cannot be further changed after this.
+ */
+template<typename T>
+void prepare_cdt_for_output(CDT_state<T> *cdt, const CDT_output_type output_type)
+{
+  if (cdt->edges.is_empty()) {
+    return;
+  }
+
+  /* Make sure all non-deleted faces have a symedge. */
+  for (CDTEdge<T> *e : cdt->edges) {
+    if (!is_deleted_edge(e)) {
+      if (e->symedges[0].face->symedge == nullptr) {
+        e->symedges[0].face->symedge = &e->symedges[0];
+      }
+      if (e->symedges[1].face->symedge == nullptr) {
+        e->symedges[1].face->symedge = &e->symedges[1];
+      }
+    }
+  }
+
+  if (output_type == CDT_CONSTRAINTS) {
+    remove_non_constraint_edges(cdt);
+  }
+  else if (output_type == CDT_CONSTRAINTS_VALID_BMESH) {
+    remove_non_constraint_edges_leave_valid_bmesh(cdt);
+  }
+  else if (output_type == CDT_INSIDE) {
+    remove_outer_edges_until_constraints(cdt);
+  }
+}
+
+template<typename T>
+CDT_result<T> get_cdt_output(CDT_state<T> *cdt,
+                             const CDT_input<T> UNUSED(input),
+                             CDT_output_type output_type)
+{
+  prepare_cdt_for_output(cdt, output_type);
+  CDT_result<T> result;
+  result.face_edge_offset = cdt->face_edge_offset;
+
+  /* All verts without a merge_to_index will be output.
+   * vert_to_output_map[i] will hold the output vertex index
+   * corresponding to the vert in position i in cdt->verts.
+   * This first loop sets vert_to_output_map for unmerged verts.
+   */
+  int verts_size = static_cast<int>(cdt->verts.size());
+  Array<int> vert_to_output_map(verts_size);
+  int nv = 0;
+  for (int i = 0; i < verts_size; ++i) {
+    CDTVert<T> *v = cdt->verts[i];
+    if (v->merge_to_index == -1) {
+      vert_to_output_map[i] = nv;
+      ++nv;
+    }
+  }
+  if (nv <= 0) {
+    return result;
+  }
+  /* Now we can set vert_to_output_map for merged verts,
+   * and also add the input indices of merged verts to the input_ids
+   * list of the merge target if they were an original input id.
+   */
+  if (nv < verts_size) {
+    for (int i = 0; i < verts_size; ++i) {
+      CDTVert<T> *v = cdt->verts[i];
+      if (v->merge_to_index != -1) {
+        if (i < cdt->input_vert_tot) {
+          add_to_input_ids(&cdt->verts[v->merge_to_index]->input_ids, i, cdt);
+        }
+        vert_to_output_map[i] = vert_to_output_map[v->merge_to_index];
+      }
+    }
+  }
+  result.vert = Array<vec2<T>>(nv);
+  result.vert_orig = Array<Vector<int>>(nv);
+  int i_out = 0;
+  for (int i = 0; i < verts_size; ++i) {
+    CDTVert<T> *v = cdt->verts[i];
+    if (v->merge_to_index == -1) {
+      result.vert[i_out] = v->co;
+      if (i < cdt->input_vert_tot) {
+        result.vert_orig[i_out].append(i);
+      }
+      for (LinkNode *ln = v->input_ids; ln; ln = ln->next) {
+        result.vert_orig[i_out].append(POINTER_AS_INT(ln->link));
+      }
+      ++i_out;
+    }
+  }
+
+  /* All non-deleted edges will be output. */
+  int ne = std::count_if(cdt->edges.begin(), cdt->edges.end(), [](const CDTEdge<T> *e) -> bool {
+    return !is_deleted_edge(e);
+  });
+  result.edge = Array<std::pair<int, int>>(ne);
+  result.edge_orig = Array<Vector<int>>(ne);
+  int e_out = 0;
+  for (const CDTEdge<T> *e : cdt->edges) {
+    if (!is_deleted_edge(e)) {
+      int vo1 = vert_to_output_map[e->symedges[0].vert->index];
+      int vo2 = vert_to_output_map[e->symedges[1].vert->index];
+      result.edge[e_out] = std::pair<int, int>(vo1, vo2);
+      for (LinkNode *ln = e->input_ids; ln; ln = ln->next) {
+        result.edge_orig[e_out].append(POINTER_AS_INT(ln->link));
+      }
+      ++e_out;
+    }
+  }
+
+  /* All non-deleted, non-outer faces will be output. */
+  int nf = std::count_if(cdt->faces.begin(), cdt->faces.end(), [=](const CDTFace<T> *f) -> bool {
+    return !f->deleted && f != cdt->outer_face;
+  });
+  result.face = Array<Vector<int>>(nf);
+  result.face_orig = Array<Vector<int>>(nf);
+  int f_out = 0;
+  for (const CDTFace<T> *f : cdt->faces) {
+    if (!f->deleted && f != cdt->outer_face) {
+      SymEdge<T> *se = f->symedge;
+      BLI_assert(se != nullptr);
+      SymEdge<T> *se_start = se;
+      do {
+        result.face[f_out].append(vert_to_output_map[se->vert->index]);
+        se = se->next;
+      } while (se != se_start);
+      for (LinkNode *ln = f->input_ids; ln; ln = ln->next) {
+        result.face_orig[f_out].append(POINTER_AS_INT(ln->link));
+      }
+      ++f_out;
+    }
+  }
+  return result;
+}
+
+/* Add all the input verts into cdt. This will dedup, setting vert's merge_to_index to show merges.
+ */
+template<typename T> void add_input_verts(CDT_state<T> *cdt, const CDT_input<T> &input)
+{
+  for (int i = 0; i < cdt->input_vert_tot; ++i) {
+    cdt->add_vert(input.vert[i]);
+  }
+}
+
+template<typename T>
+CDT_result<T> delaunay_calc(const CDT_input<T> &input, CDT_output_type output_type)
+{
+  int nv = static_cast<int>(input.vert.size());
+  int ne = static_cast<int>(input.edge.size());
+  int nf = static_cast<int>(input.face.size());
+  CDT_state<T> cdt(nv, ne, nf, input.epsilon);
+  add_input_verts(&cdt, input);
+  initial_triangulation(&cdt);
+  add_edge_constraints(&cdt, input);
+  add_face_constraints(&cdt, input);
+  return get_cdt_output(&cdt, input, output_type);
+}
+
+} /* namespace CDT */
+
+CDT_result<double> delaunay_2d_calc(const CDT_input<double> &input, CDT_output_type output_type)
+{
+  return CDT::delaunay_calc(input, output_type);
+}
+
+CDT_result<mpq_class> delaunay_2d_calc(const CDT_input<mpq_class> &input,
+                                       CDT_output_type output_type)
+{
+  return CDT::delaunay_calc(input, output_type);
+}
+
+} /* namespace BLI */
+
+/* C interface. */
+
+/* This function uses the double version of CDT::delaunay_calc.
+ * Almost all of the work here is to convert between C++ Arrays<Vector<int>>
+ * and a C version that linearizes all the elements and uses a "start"
+ * and "len" array to say where the individual vectors start and how
+ * long they are.
+ */
+extern "C" ::CDT_result *BLI_delaunay_2d_cdt_calc(const ::CDT_input *input,
+                                                  const CDT_output_type output_type)
+{
+  BLI::CDT_input<double> in;
+  in.vert = BLI::Array<BLI::vec2<double>>(input->verts_len);
+  in.edge = BLI::Array<std::pair<int, int>>(input->edges_len);
+  in.face = BLI::Array<BLI::Vector<int>>(input->faces_len);
+  for (int v = 0; v < input->verts_len; ++v) {
+    double x = static_cast<double>(input->vert_coords[v][0]);
+    double y = static_cast<double>(input->vert_coords[v][1]);
+    in.vert[v] = BLI::vec2<double>(x, y);
+  }
+  for (int e = 0; e < input->edges_len; ++e) {
+    in.edge[e] = std::pair<int, int>(input->edges[e][0], input->edges[e][1]);
+  }
+  for (int f = 0; f < input->faces_len; ++f) {
+    in.face[f] = BLI::Vector<int>(input->faces_len_table[f]);
+    int fstart = input->faces_start_table[f];
+    for (int j = 0; j < input->faces_len_table[f]; ++j) {
+      in.face[f][j] = input->faces[fstart + j];
+    }
+  }
+  in.epsilon = static_cast<double>(input->epsilon);
+
+  BLI::CDT_result<double> res = BLI::CDT::delaunay_calc(in, output_type);
+
+  ::CDT_result *output = static_cast<::CDT_result *>(MEM_mallocN(sizeof(*output), __func__));
+  int nv = output->verts_len = static_cast<int>(res.vert.size());
+  int ne = output->edges_len = static_cast<int>(res.edge.size());
+  int nf = output->faces_len = static_cast<int>(res.face.size());
+  int tot_v_orig = 0;
+  int tot_e_orig = 0;
+  int tot_f_orig = 0;
+  int tot_f_lens = 0;
+  for (int v = 0; v < nv; ++v) {
+    tot_v_orig += static_cast<int>(res.vert_orig[v].size());
+  }
+  for (int e = 0; e < ne; ++e) {
+    tot_e_orig += static_cast<int>(res.edge_orig[e].size());
+  }
+  for (int f = 0; f < nf; ++f) {
+    tot_f_orig += static_cast<int>(res.face_orig[f].size());
+    tot_f_lens += static_cast<int>(res.face[f].size());
+  }
+
+  output->vert_coords = static_cast<decltype(output->vert_coords)>(
+      MEM_malloc_arrayN(nv, sizeof(output->vert_coords[0]), __func__));
+  output->verts_orig = static_cast<int *>(MEM_malloc_arrayN(tot_v_orig, sizeof(int), __func__));
+  output->verts_orig_start_table = static_cast<int *>(
+      MEM_malloc_arrayN(nv, sizeof(int), __func__));
+  output->verts_orig_len_table = static_cast<int *>(MEM_malloc_arrayN(nv, sizeof(int), __func__));
+  output->edges = static_cast<decltype(output->edges)>(
+      MEM_malloc_arrayN(ne, sizeof(output->edges[0]), __func__));
+  output->edges_orig = static_cast<int *>(MEM_malloc_arrayN(tot_e_orig, sizeof(int), __func__));
+  output->edges_orig_start_table = static_cast<int *>(
+      MEM_malloc_arrayN(ne, sizeof(int), __func__));
+  output->edges_orig_len_table = static_cast<int *>(MEM_malloc_arrayN(ne, sizeof(int), __func__));
+  output->faces = static_cast<int *>(MEM_malloc_arrayN(tot_f_lens, sizeof(int), __func__));
+  output->faces_start_table = static_cast<int *>(MEM_malloc_arrayN(nf, sizeof(int), __func__));
+  output->faces_len_table = static_cast<int *>(MEM_malloc_arrayN(nf, sizeof(int), __func__));
+  output->faces_orig = static_cast<int *>(MEM_malloc_arrayN(tot_f_orig, sizeof(int), __func__));
+  output->faces_orig_start_table = static_cast<int *>(
+      MEM_malloc_arrayN(nf, sizeof(int), __func__));
+  output->faces_orig_len_table = static_cast<int *>(MEM_malloc_arrayN(nf, sizeof(int), __func__));
+
+  int v_orig_index = 0;
+  for (int v = 0; v < nv; ++v) {
+    output->vert_coords[v][0] = static_cast<float>(res.vert[v][0]);
+    output->vert_coords[v][1] = static_cast<float>(res.vert[v][1]);
+    int this_start = v_orig_index;
+    output->verts_orig_start_table[v] = this_start;
+    for (uint j = 0; j < res.vert_orig[v].size(); ++j) {
+      output->verts_orig[v_orig_index++] = res.vert_orig[v][j];
+    }
+    output->verts_orig_len_table[v] = v_orig_index - this_start;
+  }
+  int e_orig_index = 0;
+  for (int e = 0; e < ne; ++e) {
+    output->edges[e][0] = res.edge[e].first;
+    output->edges[e][1] = res.edge[e].second;
+    int this_start = e_orig_index;
+    output->edges_orig_start_table[e] = this_start;
+    for (uint j = 0; j < res.edge_orig[e].size(); ++j) {
+      output->edges_orig[e_orig_index++] = res.vert_orig[e][j];
+    }
+    output->edges_orig_len_table[e] = e_orig_index - this_start;
+  }
+  int f_orig_index = 0;
+  int f_index = 0;
+  for (int f = 0; f < nf; ++f) {
+    output->faces_start_table[f] = f_index;
+    int flen = static_cast<int>(res.face[f].size());
+    output->faces_len_table[f] = flen;
+    for (int j = 0; j < flen; ++j) {
+      output->faces[f_index++] = res.face[f][j];
+    }
+    int this_start = f_orig_index;
+    output->faces_orig_start_table[f] = this_start;
+    for (uint k = 0; k < res.face_orig[f].size(); ++k) {
+      output->faces_orig[f_orig_index++] = res.face_orig[f][k];
+    }
+    output->faces_orig_len_table[f] = f_orig_index - this_start;
+  }
+  return output;
+}
+
+extern "C" void BLI_delaunay_2d_cdt_free(::CDT_result *result)
+{
+  MEM_freeN(result->vert_coords);
+  MEM_freeN(result->edges);
+  MEM_freeN(result->faces);
+  MEM_freeN(result->faces_start_table);
+  MEM_freeN(result->faces_len_table);
+  MEM_freeN(result->verts_orig);
+  MEM_freeN(result->verts_orig_start_table);
+  MEM_freeN(result->verts_orig_len_table);
+  MEM_freeN(result->edges_orig_start_table);
+  MEM_freeN(result->edges_orig_len_table);
+  MEM_freeN(result->faces_orig);
+  MEM_freeN(result->faces_orig_start_table);
+  MEM_freeN(result->faces_orig_len_table);
+  MEM_freeN(result);
+}
diff --git a/source/blender/blenlib/intern/math_base_inline.c b/source/blender/blenlib/intern/math_base_inline.c
index 4ee32efb681..1b388dcf11f 100644
--- a/source/blender/blenlib/intern/math_base_inline.c
+++ b/source/blender/blenlib/intern/math_base_inline.c
@@ -576,11 +576,6 @@ MINLINE int compare_ff(float a, float b, const float max_diff)
   return fabsf(a - b) <= max_diff;
 }
 
-MINLINE int compare_dd(double a, double b, const double max_diff)
-{
-  return fabs(a - b) <= max_diff;
-}
-
 /**
  * Almost-equal for IEEE floats, using their integer representation
  * (mixing ULP and absolute difference methods).
diff --git a/source/blender/blenlib/intern/math_geom.c b/source/blender/blenlib/intern/math_geom.c
index 7691b0fa6fb..e7c1fc8c2d9 100644
--- a/source/blender/blenlib/intern/math_geom.c
+++ b/source/blender/blenlib/intern/math_geom.c
@@ -432,15 +432,6 @@ void closest_to_plane3_normalized_v3(float r_close[3], const float plane[3], con
   madd_v3_v3v3fl(r_close, pt, plane, -side);
 }
 
-void closest_to_plane3_normalized_v3_db(double r_close[3],
-                                        const double plane[3],
-                                        const double pt[3])
-{
-  const double side = dot_v3v3_db(plane, pt);
-  BLI_ASSERT_UNIT_V3_DB(plane);
-  madd_v3_v3v3db_db(r_close, pt, plane, -side);
-}
-
 float dist_signed_squared_to_plane_v3(const float pt[3], const float plane[4])
 {
   const float len_sq = len_squared_v3(plane);
@@ -523,16 +514,6 @@ float dist_squared_to_line_v3(const float p[3], const float l1[3], const float l
 
   return len_squared_v3v3(closest, p);
 }
-
-double dist_squared_to_line_v3_db(const double p[3], const double l1[3], const double l2[3])
-{
-  double closest[3];
-
-  closest_to_line_v3_db(closest, p, l1, l2);
-
-  return len_squared_v3v3_db(closest, p);
-}
-
 float dist_to_line_v3(const float p[3], const float l1[3], const float l2[3])
 {
   return sqrtf(dist_squared_to_line_v3(p, l1, l2));
@@ -2327,41 +2308,6 @@ bool isect_plane_plane_v3(const float plane_a[4],
   }
 }
 
-bool isect_plane_plane_v3_db(const double plane_a[4],
-                             const double plane_b[4],
-                             double r_isect_co[3],
-                             double r_isect_no[3])
-{
-  double det, plane_c[3];
-
-  /* direction is simply the cross product */
-  cross_v3_v3v3_db(plane_c, plane_a, plane_b);
-
-  /* in this case we don't need to use 'determinant_m3' */
-  det = len_squared_v3_db(plane_c);
-
-  if (det != 0.0) {
-    double tmp[3];
-
-    /* (plane_b.xyz.cross(plane_c.xyz) * -plane_a[3] +
-     *  plane_c.xyz.cross(plane_a.xyz) * -plane_b[3]) / det; */
-    cross_v3_v3v3_db(tmp, plane_c, plane_b);
-    mul_v3db_v3dbdb(r_isect_co, tmp, plane_a[3]);
-
-    cross_v3_v3v3_db(tmp, plane_a, plane_c);
-    madd_v3db_v3dbdb(r_isect_co, tmp, plane_b[3]);
-
-    mul_v3db_db(r_isect_co, 1.0 / det);
-
-    copy_v3_v3_db(r_isect_no, plane_c);
-
-    return true;
-  }
-  else {
-    return false;
-  }
-}
-
 /**
  * Intersect two triangles.
  *
@@ -3061,71 +3007,6 @@ int isect_line_line_epsilon_v3(const float v1[3],
   }
 }
 
-int isect_line_line_epsilon_v3_db(const double v1[3],
-                                  const double v2[3],
-                                  const double v3[3],
-                                  const double v4[3],
-                                  double r_i1[3],
-                                  double r_i2[3],
-                                  const double epsilon)
-{
-  double a[3], b[3], c[3], ab[3], cb[3];
-  double d, div;
-
-  sub_v3_v3v3_db(c, v3, v1);
-  sub_v3_v3v3_db(a, v2, v1);
-  sub_v3_v3v3_db(b, v4, v3);
-
-  cross_v3_v3v3_db(ab, a, b);
-  d = dot_v3v3_db(c, ab);
-  div = dot_v3v3_db(ab, ab);
-
-  /* important not to use an epsilon here, see: T45919 */
-  /* test zero length line */
-  if (UNLIKELY(div == 0.0)) {
-    return 0;
-  }
-  /* test if the two lines are coplanar */
-  else if (UNLIKELY(fabs(d) <= epsilon)) {
-    cross_v3_v3v3_db(cb, c, b);
-
-    mul_v3db_db(a, dot_v3v3_db(cb, ab) / div);
-    add_v3_v3v3_db(r_i1, v1, a);
-    copy_v3_v3_db(r_i2, r_i1);
-
-    return 1; /* one intersection only */
-  }
-  /* if not */
-  else {
-    double n[3], t[3];
-    double v3t[3], v4t[3];
-    sub_v3_v3v3_db(t, v1, v3);
-
-    /* offset between both plane where the lines lies */
-    cross_v3_v3v3_db(n, a, b);
-    project_v3_v3v3_db(t, t, n);
-
-    /* for the first line, offset the second line until it is coplanar */
-    add_v3_v3v3_db(v3t, v3, t);
-    add_v3_v3v3_db(v4t, v4, t);
-
-    sub_v3_v3v3_db(c, v3t, v1);
-    sub_v3_v3v3_db(a, v2, v1);
-    sub_v3_v3v3_db(b, v4t, v3t);
-
-    cross_v3_v3v3_db(ab, a, b);
-    cross_v3_v3v3_db(cb, c, b);
-
-    mul_v3db_db(a, dot_v3v3_db(cb, ab) / dot_v3v3_db(ab, ab));
-    add_v3_v3v3_db(r_i1, v1, a);
-
-    /* for the second line, just substract the offset from the first intersection point */
-    sub_v3_v3v3_db(r_i2, r_i1, t);
-
-    return 2; /* two nearest points */
-  }
-}
-
 int isect_line_line_v3(const float v1[3],
                        const float v2[3],
                        const float v3[3],
@@ -3260,15 +3141,6 @@ bool isect_aabb_aabb_v3(const float min1[3],
           min2[1] < max1[1] && min2[2] < max1[2]);
 }
 
-bool isect_aabb_aabb_v3_db(const double min1[3],
-                           const double max1[3],
-                           const double min2[3],
-                           const double max2[3])
-{
-  return (min1[0] < max2[0] && min1[1] < max2[1] && min1[2] < max2[2] && min2[0] < max1[0] &&
-          min2[1] < max1[1] && min2[2] < max1[2]);
-}
-
 void isect_ray_aabb_v3_precalc(struct IsectRayAABB_Precalc *data,
                                const float ray_origin[3],
                                const float ray_direction[3])
@@ -3391,21 +3263,6 @@ float closest_to_line_v3(float r_close[3], const float p[3], const float l1[3],
   return lambda;
 }
 
-double closest_to_line_v3_db(double r_close[3],
-                             const double p[3],
-                             const double l1[3],
-                             const double l2[3])
-{
-  double h[3], u[3], lambda;
-  sub_v3_v3v3_db(u, l2, l1);
-  sub_v3_v3v3_db(h, p, l1);
-  lambda = dot_v3v3_db(u, h) / dot_v3v3_db(u, u);
-  r_close[0] = l1[0] + u[0] * lambda;
-  r_close[1] = l1[1] + u[1] * lambda;
-  r_close[2] = l1[2] + u[2] * lambda;
-  return lambda;
-}
-
 float closest_to_line_v2(float r_close[2], const float p[2], const float l1[2], const float l2[2])
 {
   float h[2], u[2], lambda;
@@ -3799,19 +3656,6 @@ void axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3])
              is_zero_v3(normal));
 }
 
-void axis_dominant_v3_to_m3_db(double r_mat[3][3], const double normal[3])
-{
-  BLI_ASSERT_UNIT_V3_DB(normal);
-
-  copy_v3_v3_db(r_mat[2], normal);
-  ortho_basis_v3v3_v3_db(r_mat[0], r_mat[1], r_mat[2]);
-
-  BLI_ASSERT_UNIT_V3_DB(r_mat[0]);
-  BLI_ASSERT_UNIT_V3_DB(r_mat[1]);
-
-  transpose_m3_db(r_mat);
-}
-
 /**
  * Same as axis_dominant_v3_to_m3, but flips the normal
  */
diff --git a/source/blender/blenlib/intern/math_geom_inline.c b/source/blender/blenlib/intern/math_geom_inline.c
index 2178e925204..893c978d084 100644
--- a/source/blender/blenlib/intern/math_geom_inline.c
+++ b/source/blender/blenlib/intern/math_geom_inline.c
@@ -261,11 +261,6 @@ MINLINE float plane_point_side_v3(const float plane[4], const float co[3])
   return dot_v3v3(co, plane) + plane[3];
 }
 
-MINLINE double plane_point_side_v3_db(const double plane[4], const double co[3])
-{
-  return dot_v3v3_db(co, plane) + plane[3];
-}
-
 /* useful to calculate an even width shell, by taking the angle between 2 planes.
  * The return value is a scale on the offset.
  * no angle between planes is 1.0, as the angle between the 2 planes approaches 180d
diff --git a/source/blender/blenlib/intern/math_matrix.c b/source/blender/blenlib/intern/math_matrix.c
index c557b5cb609..9e398239bc7 100644
--- a/source/blender/blenlib/intern/math_matrix.c
+++ b/source/blender/blenlib/intern/math_matrix.c
@@ -1103,13 +1103,6 @@ float determinant_m3_array(const float m[3][3])
           m[2][0] * (m[0][1] * m[1][2] - m[0][2] * m[1][1]));
 }
 
-double determinant_m3_array_db(const double m[3][3])
-{
-  return (m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) -
-          m[1][0] * (m[0][1] * m[2][2] - m[0][2] * m[2][1]) +
-          m[2][0] * (m[0][1] * m[1][2] - m[0][2] * m[1][1]));
-}
-
 float determinant_m4_mat3_array(const float m[4][4])
 {
   return (m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) -
@@ -1188,32 +1181,6 @@ bool invert_m3_m3(float m1[3][3], const float m2[3][3])
   return success;
 }
 
-bool invert_m3_m3_db(double m1[3][3], const double m2[3][3])
-{
-  double det;
-  int a, b;
-  bool success;
-
-  /* calc adjoint */
-  adjoint_m3_m3_db(m1, m2);
-
-  /* then determinant old matrix! */
-  det = determinant_m3_array_db(m2);
-
-  success = (det != 0.0);
-
-  if (LIKELY(det != 0.0)) {
-    det = 1.0 / det;
-    for (a = 0; a < 3; a++) {
-      for (b = 0; b < 3; b++) {
-        m1[a][b] *= det;
-      }
-    }
-  }
-
-  return success;
-}
-
 bool invert_m4(float m[4][4])
 {
   float tmp[4][4];
@@ -1354,21 +1321,6 @@ void transpose_m3(float mat[3][3])
   mat[2][1] = t;
 }
 
-void transpose_m3_db(double mat[3][3])
-{
-  double t;
-
-  t = mat[0][1];
-  mat[0][1] = mat[1][0];
-  mat[1][0] = t;
-  t = mat[0][2];
-  mat[0][2] = mat[2][0];
-  mat[2][0] = t;
-  t = mat[1][2];
-  mat[1][2] = mat[2][1];
-  mat[2][1] = t;
-}
-
 void transpose_m3_m3(float rmat[3][3], const float mat[3][3])
 {
   BLI_assert(rmat != mat);
@@ -1967,22 +1919,6 @@ void adjoint_m3_m3(float m1[3][3], const float m[3][3])
   m1[2][2] = m[0][0] * m[1][1] - m[0][1] * m[1][0];
 }
 
-void adjoint_m3_m3_db(double m1[3][3], const double m[3][3])
-{
-  BLI_assert(m1 != m);
-  m1[0][0] = m[1][1] * m[2][2] - m[1][2] * m[2][1];
-  m1[0][1] = -m[0][1] * m[2][2] + m[0][2] * m[2][1];
-  m1[0][2] = m[0][1] * m[1][2] - m[0][2] * m[1][1];
-
-  m1[1][0] = -m[1][0] * m[2][2] + m[1][2] * m[2][0];
-  m1[1][1] = m[0][0] * m[2][2] - m[0][2] * m[2][0];
-  m1[1][2] = -m[0][0] * m[1][2] + m[0][2] * m[1][0];
-
-  m1[2][0] = m[1][0] * m[2][1] - m[1][1] * m[2][0];
-  m1[2][1] = -m[0][0] * m[2][1] + m[0][1] * m[2][0];
-  m1[2][2] = m[0][0] * m[1][1] - m[0][1] * m[1][0];
-}
-
 void adjoint_m4_m4(float out[4][4], const float in[4][4]) /* out = ADJ(in) */
 {
   float a1, a2, a3, a4, b1, b2, b3, b4;
diff --git a/source/blender/blenlib/intern/math_vec.cc b/source/blender/blenlib/intern/math_vec.cc
new file mode 100644
index 00000000000..089f941820c
--- /dev/null
+++ b/source/blender/blenlib/intern/math_vec.cc
@@ -0,0 +1,2592 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/** \file
+ * \ingroup bli
+ */
+
+#include "gmpxx.h"
+
+#include "BLI_double2.hh"
+#include "BLI_double3.hh"
+#include "BLI_float2.hh"
+#include "BLI_float3.hh"
+#include "BLI_mpq2.hh"
+#include "BLI_mpq3.hh"
+#include "BLI_utildefines.h"
+
+namespace BLI {
+
+float2::isect_result float2::isect_seg_seg(const float2 &v1,
+                                           const float2 &v2,
+                                           const float2 &v3,
+                                           const float2 &v4)
+{
+  float2::isect_result ans;
+  float div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]);
+  if (div == 0.0f) {
+    ans.lambda = 0.0f;
+    ans.mu = 0.0f;
+    ans.kind = float2::isect_result::LINE_LINE_COLINEAR;
+  }
+  else {
+    ans.lambda = ((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div;
+    ans.mu = ((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div;
+    if (ans.lambda >= 0.0f && ans.lambda <= 1.0f && ans.mu >= 0.0f && ans.mu <= 1.0f) {
+      if (ans.lambda == 0.0f || ans.lambda == 1.0f || ans.mu == 0.0f || ans.mu == 1.0f) {
+        ans.kind = float2::isect_result::LINE_LINE_EXACT;
+      }
+      else {
+        ans.kind = float2::isect_result::LINE_LINE_CROSS;
+      }
+    }
+    else {
+      ans.kind = float2::isect_result::LINE_LINE_NONE;
+    }
+  }
+  return ans;
+}
+
+double2::isect_result double2::isect_seg_seg(const double2 &v1,
+                                             const double2 &v2,
+                                             const double2 &v3,
+                                             const double2 &v4)
+{
+  double2::isect_result ans;
+  double div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]);
+  if (div == 0.0) {
+    ans.lambda = 0.0;
+    ans.mu = 0.0;
+    ans.kind = double2::isect_result::LINE_LINE_COLINEAR;
+  }
+  else {
+    ans.lambda = ((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div;
+    ans.mu = ((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div;
+    if (ans.lambda >= 0.0 && ans.lambda <= 1.0 && ans.mu >= 0.0 && ans.mu <= 1.0) {
+      if (ans.lambda == 0.0 || ans.lambda == 1.0 || ans.mu == 0.0 || ans.mu == 1.0) {
+        ans.kind = double2::isect_result::LINE_LINE_EXACT;
+      }
+      else {
+        ans.kind = double2::isect_result::LINE_LINE_CROSS;
+      }
+    }
+    else {
+      ans.kind = double2::isect_result::LINE_LINE_NONE;
+    }
+  }
+  return ans;
+}
+
+mpq2::isect_result mpq2::isect_seg_seg(const mpq2 &v1,
+                                       const mpq2 &v2,
+                                       const mpq2 &v3,
+                                       const mpq2 &v4)
+{
+  mpq2::isect_result ans;
+  mpq_class div = (v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]);
+  if (div == 0.0) {
+    ans.lambda = 0.0;
+    ans.mu = 0.0;
+    ans.kind = mpq2::isect_result::LINE_LINE_COLINEAR;
+  }
+  else {
+    ans.lambda = ((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div;
+    ans.mu = ((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div;
+    if (ans.lambda >= 0 && ans.lambda <= 1 && ans.mu >= 0 && ans.mu <= 1) {
+      if (ans.lambda == 0 || ans.lambda == 1 || ans.mu == 0 || ans.mu == 1) {
+        ans.kind = mpq2::isect_result::LINE_LINE_EXACT;
+      }
+      else {
+        ans.kind = mpq2::isect_result::LINE_LINE_CROSS;
+      }
+    }
+    else {
+      ans.kind = mpq2::isect_result::LINE_LINE_NONE;
+    }
+  }
+  return ans;
+}
+
+int mpq2::orient2d(const mpq2 &a, const mpq2 &b, const mpq2 &c)
+{
+  mpq_class detleft = (a[0] - c[0]) * (b[1] - c[1]);
+  mpq_class detright = (a[1] - c[1]) * (b[0] - c[0]);
+  mpq_class det = detleft - detright;
+  return sgn(det);
+}
+
+int mpq2::incircle(const mpq2 &a, const mpq2 &b, const mpq2 &c, const mpq2 &d)
+{
+  mpq_class adx = a[0] - d[0];
+  mpq_class bdx = b[0] - d[0];
+  mpq_class cdx = c[0] - d[0];
+  mpq_class ady = a[1] - d[1];
+  mpq_class bdy = b[1] - d[1];
+  mpq_class cdy = c[1] - d[1];
+
+  mpq_class bdxcdy = bdx * cdy;
+  mpq_class cdxbdy = cdx * bdy;
+  mpq_class alift = adx * adx + ady * ady;
+
+  mpq_class cdxady = cdx * ady;
+  mpq_class adxcdy = adx * cdy;
+  mpq_class blift = bdx * bdx + bdy * bdy;
+
+  mpq_class adxbdy = adx * bdy;
+  mpq_class bdxady = bdx * ady;
+  mpq_class clift = cdx * cdx + cdy * cdy;
+
+  mpq_class det = alift * (bdxcdy - cdxbdy) + blift * (cdxady - adxcdy) +
+                  clift * (adxbdy - bdxady);
+  return sgn(det);
+}
+
+int mpq3::orient3d(const mpq3 &a, const mpq3 &b, const mpq3 &c, const mpq3 &d)
+{
+  mpq_class adx = a[0] - d[0];
+  mpq_class bdx = b[0] - d[0];
+  mpq_class cdx = c[0] - d[0];
+  mpq_class ady = a[1] - d[1];
+  mpq_class bdy = b[1] - d[1];
+  mpq_class cdy = c[1] - d[1];
+  mpq_class adz = a[2] - d[2];
+  mpq_class bdz = b[2] - d[2];
+  mpq_class cdz = c[2] - d[2];
+
+  mpq_class bdxcdy = bdx * cdy;
+  mpq_class cdxbdy = cdx * bdy;
+
+  mpq_class cdxady = cdx * ady;
+  mpq_class adxcdy = adx * cdy;
+
+  mpq_class adxbdy = adx * bdy;
+  mpq_class bdxady = bdx * ady;
+
+  mpq_class det = adz * (bdxcdy - cdxbdy) + bdz * (cdxady - adxcdy) + cdz * (adxbdy - bdxady);
+  return sgn(det);
+}
+
+/* For double versions of orient and incircle functions, use robust predicates
+ * that give exact answers for double inputs.
+ * First, encapsulate functions frm Jonathan Shewchuk's implementation.
+ * After this namespace, see the implementation of the double3 primitives.
+ */
+namespace robust_pred {
+
+/* Using Shewchuk's file here, edited to removed unneeded functions,
+ * change REAL to double everywhere, added const to some arguments,
+ * and to export only the following declared non-static functions.
+ *
+ * Since this is C++, an instantiated singleton class is used to make
+ * sure that exactinit() is called once.
+ * (Because of undefinedness of when this is called in initialization of all
+ * modules, other modules shouldn't use these functions in initialization.)
+ */
+
+void exactinit();
+double orient2dfast(const double *pa, const double *pb, const double *pc);
+double orient2d(const double *pa, const double *pb, const double *pc);
+double orient3dfast(const double *pa, const double *pb, const double *pc, const double *pd);
+double orient3d(const double *pa, const double *pb, const double *pc, const double *pd);
+double incirclefast(const double *pa, const double *pb, const double *pc, const double *pd);
+double incircle(const double *pa, const double *pb, const double *pc, const double *pd);
+double inspherefast(
+    const double *pa, const double *pb, const double *pc, const double *pd, const double *pe);
+double insphere(
+    const double *pa, const double *pb, const double *pc, const double *pd, const double *pe);
+
+class RobustInitCaller {
+ public:
+  RobustInitCaller()
+  {
+    exactinit();
+  }
+};
+
+static RobustInitCaller init_caller;
+
+/*  Routines for Arbitrary Precision Floating-point Arithmetic
+ *  and Fast Robust Geometric Predicates
+ *  (predicates.c)
+ *
+ *  May 18, 1996
+ *
+ *  Placed in the public domain by
+ *  Jonathan Richard Shewchuk
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  5000 Forbes Avenue
+ *  Pittsburgh, Pennsylvania  15213-3891
+ *  jrs@cs.cmu.edu
+ *
+ *  This file contains C implementation of algorithms for exact addition
+ *    and multiplication of floating-point numbers, and predicates for
+ *    robustly performing the orientation and incircle tests used in
+ *    computational geometry.  The algorithms and underlying theory are
+ *    described in Jonathan Richard Shewchuk.  "Adaptive Precision Floating-
+ *    Point Arithmetic and Fast Robust Geometric Predicates."  Technical
+ *    Report CMU-CS-96-140, School of Computer Science, Carnegie Mellon
+ *    University, Pittsburgh, Pennsylvania, May 1996.  (Submitted to
+ *    Discrete & Computational Geometry.)
+ *
+ *  This file, the paper listed above, and other information are available
+ *    from the Web page http://www.cs.cmu.edu/~quake/robust.html .
+ *
+ *
+ *  Using this code:
+ *
+ *  First, read the short or long version of the paper (from the Web page
+ *    above).
+ *
+ *  Be sure to call exactinit() once, before calling any of the arithmetic
+ *    functions or geometric predicates.  Also be sure to turn on the
+ *    optimizer when compiling this file.
+ */
+
+/* On some machines, the exact arithmetic routines might be defeated by the
+ *   use of internal extended precision floating-point registers.  Sometimes
+ *   this problem can be fixed by defining certain values to be volatile,
+ *   thus forcing them to be stored to memory and rounded off.  This isn't
+ *   a great solution, though, as it slows the arithmetic down.
+ *
+ * To try this out, write "#define INEXACT volatile" below.  Normally,
+ *   however, INEXACT should be defined to be nothing.  ("#define INEXACT".)
+ */
+
+#define INEXACT /* Nothing */
+/* #define INEXACT volatile */
+
+/* Which of the following two methods of finding the absolute values is
+ *   fastest is compiler-dependent.  A few compilers can inline and optimize
+ *   the fabs() call; but most will incur the overhead of a function call,
+ *   which is disastrously slow.  A faster way on IEEE machines might be to
+ *   mask the appropriate bit, but that's difficult to do in C.
+ */
+
+#define Absolute(a) ((a) >= 0.0 ? (a) : -(a))
+/* #define Absolute(a)  fabs(a) */
+
+/* Many of the operations are broken up into two pieces, a main part that
+ *   performs an approximate operation, and a "tail" that computes the
+ *   roundoff error of that operation.
+ *
+ * The operations Fast_Two_Sum(), Fast_Two_Diff(), Two_Sum(), Two_Diff(),
+ *   Split(), and Two_Product() are all implemented as described in the
+ *   reference.  Each of these macros requires certain variables to be
+ *   defined in the calling routine.  The variables `bvirt', `c', `abig',
+ *   `_i', `_j', `_k', `_l', `_m', and `_n' are declared `INEXACT' because
+ *   they store the result of an operation that may incur roundoff error.
+ *   The input parameter `x' (or the highest numbered `x_' parameter) must
+ *   also be declared `INEXACT'.
+ */
+
+#define Fast_Two_Sum_Tail(a, b, x, y) \
+  bvirt = x - a; \
+  y = b - bvirt
+
+#define Fast_Two_Sum(a, b, x, y) \
+  x = (double)(a + b); \
+  Fast_Two_Sum_Tail(a, b, x, y)
+
+#define Fast_Two_Diff_Tail(a, b, x, y) \
+  bvirt = a - x; \
+  y = bvirt - b
+
+#define Fast_Two_Diff(a, b, x, y) \
+  x = (double)(a - b); \
+  Fast_Two_Diff_Tail(a, b, x, y)
+
+#define Two_Sum_Tail(a, b, x, y) \
+  bvirt = (double)(x - a); \
+  avirt = x - bvirt; \
+  bround = b - bvirt; \
+  around = a - avirt; \
+  y = around + bround
+
+#define Two_Sum(a, b, x, y) \
+  x = (double)(a + b); \
+  Two_Sum_Tail(a, b, x, y)
+
+#define Two_Diff_Tail(a, b, x, y) \
+  bvirt = (double)(a - x); \
+  avirt = x + bvirt; \
+  bround = bvirt - b; \
+  around = a - avirt; \
+  y = around + bround
+
+#define Two_Diff(a, b, x, y) \
+  x = (double)(a - b); \
+  Two_Diff_Tail(a, b, x, y)
+
+#define Split(a, ahi, alo) \
+  c = (double)(splitter * a); \
+  abig = (double)(c - a); \
+  ahi = c - abig; \
+  alo = a - ahi
+
+#define Two_Product_Tail(a, b, x, y) \
+  Split(a, ahi, alo); \
+  Split(b, bhi, blo); \
+  err1 = x - (ahi * bhi); \
+  err2 = err1 - (alo * bhi); \
+  err3 = err2 - (ahi * blo); \
+  y = (alo * blo) - err3
+
+#define Two_Product(a, b, x, y) \
+  x = (double)(a * b); \
+  Two_Product_Tail(a, b, x, y)
+
+#define Two_Product_Presplit(a, b, bhi, blo, x, y) \
+  x = (double)(a * b); \
+  Split(a, ahi, alo); \
+  err1 = x - (ahi * bhi); \
+  err2 = err1 - (alo * bhi); \
+  err3 = err2 - (ahi * blo); \
+  y = (alo * blo) - err3
+
+#define Two_Product_2Presplit(a, ahi, alo, b, bhi, blo, x, y) \
+  x = (double)(a * b); \
+  err1 = x - (ahi * bhi); \
+  err2 = err1 - (alo * bhi); \
+  err3 = err2 - (ahi * blo); \
+  y = (alo * blo) - err3
+
+#define Square_Tail(a, x, y) \
+  Split(a, ahi, alo); \
+  err1 = x - (ahi * ahi); \
+  err3 = err1 - ((ahi + ahi) * alo); \
+  y = (alo * alo) - err3
+
+#define Square(a, x, y) \
+  x = (double)(a * a); \
+  Square_Tail(a, x, y)
+
+#define Two_One_Sum(a1, a0, b, x2, x1, x0) \
+  Two_Sum(a0, b, _i, x0); \
+  Two_Sum(a1, _i, x2, x1)
+
+#define Two_One_Diff(a1, a0, b, x2, x1, x0) \
+  Two_Diff(a0, b, _i, x0); \
+  Two_Sum(a1, _i, x2, x1)
+
+#define Two_Two_Sum(a1, a0, b1, b0, x3, x2, x1, x0) \
+  Two_One_Sum(a1, a0, b0, _j, _0, x0); \
+  Two_One_Sum(_j, _0, b1, x3, x2, x1)
+
+#define Two_Two_Diff(a1, a0, b1, b0, x3, x2, x1, x0) \
+  Two_One_Diff(a1, a0, b0, _j, _0, x0); \
+  Two_One_Diff(_j, _0, b1, x3, x2, x1)
+
+#define Four_One_Sum(a3, a2, a1, a0, b, x4, x3, x2, x1, x0) \
+  Two_One_Sum(a1, a0, b, _j, x1, x0); \
+  Two_One_Sum(a3, a2, _j, x4, x3, x2)
+
+#define Four_Two_Sum(a3, a2, a1, a0, b1, b0, x5, x4, x3, x2, x1, x0) \
+  Four_One_Sum(a3, a2, a1, a0, b0, _k, _2, _1, _0, x0); \
+  Four_One_Sum(_k, _2, _1, _0, b1, x5, x4, x3, x2, x1)
+
+#define Four_Four_Sum(a3, a2, a1, a0, b4, b3, b1, b0, x7, x6, x5, x4, x3, x2, x1, x0) \
+  Four_Two_Sum(a3, a2, a1, a0, b1, b0, _l, _2, _1, _0, x1, x0); \
+  Four_Two_Sum(_l, _2, _1, _0, b4, b3, x7, x6, x5, x4, x3, x2)
+
+#define Eight_One_Sum(a7, a6, a5, a4, a3, a2, a1, a0, b, x8, x7, x6, x5, x4, x3, x2, x1, x0) \
+  Four_One_Sum(a3, a2, a1, a0, b, _j, x3, x2, x1, x0); \
+  Four_One_Sum(a7, a6, a5, a4, _j, x8, x7, x6, x5, x4)
+
+#define Eight_Two_Sum( \
+    a7, a6, a5, a4, a3, a2, a1, a0, b1, b0, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0) \
+  Eight_One_Sum(a7, a6, a5, a4, a3, a2, a1, a0, b0, _k, _6, _5, _4, _3, _2, _1, _0, x0); \
+  Eight_One_Sum(_k, _6, _5, _4, _3, _2, _1, _0, b1, x9, x8, x7, x6, x5, x4, x3, x2, x1)
+
+#define Eight_Four_Sum(a7, \
+                       a6, \
+                       a5, \
+                       a4, \
+                       a3, \
+                       a2, \
+                       a1, \
+                       a0, \
+                       b4, \
+                       b3, \
+                       b1, \
+                       b0, \
+                       x11, \
+                       x10, \
+                       x9, \
+                       x8, \
+                       x7, \
+                       x6, \
+                       x5, \
+                       x4, \
+                       x3, \
+                       x2, \
+                       x1, \
+                       x0) \
+  Eight_Two_Sum(a7, a6, a5, a4, a3, a2, a1, a0, b1, b0, _l, _6, _5, _4, _3, _2, _1, _0, x1, x0); \
+  Eight_Two_Sum(_l, _6, _5, _4, _3, _2, _1, _0, b4, b3, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2)
+
+#define Two_One_Product(a1, a0, b, x3, x2, x1, x0) \
+  Split(b, bhi, blo); \
+  Two_Product_Presplit(a0, b, bhi, blo, _i, x0); \
+  Two_Product_Presplit(a1, b, bhi, blo, _j, _0); \
+  Two_Sum(_i, _0, _k, x1); \
+  Fast_Two_Sum(_j, _k, x3, x2)
+
+#define Four_One_Product(a3, a2, a1, a0, b, x7, x6, x5, x4, x3, x2, x1, x0) \
+  Split(b, bhi, blo); \
+  Two_Product_Presplit(a0, b, bhi, blo, _i, x0); \
+  Two_Product_Presplit(a1, b, bhi, blo, _j, _0); \
+  Two_Sum(_i, _0, _k, x1); \
+  Fast_Two_Sum(_j, _k, _i, x2); \
+  Two_Product_Presplit(a2, b, bhi, blo, _j, _0); \
+  Two_Sum(_i, _0, _k, x3); \
+  Fast_Two_Sum(_j, _k, _i, x4); \
+  Two_Product_Presplit(a3, b, bhi, blo, _j, _0); \
+  Two_Sum(_i, _0, _k, x5); \
+  Fast_Two_Sum(_j, _k, x7, x6)
+
+#define Two_Two_Product(a1, a0, b1, b0, x7, x6, x5, x4, x3, x2, x1, x0) \
+  Split(a0, a0hi, a0lo); \
+  Split(b0, bhi, blo); \
+  Two_Product_2Presplit(a0, a0hi, a0lo, b0, bhi, blo, _i, x0); \
+  Split(a1, a1hi, a1lo); \
+  Two_Product_2Presplit(a1, a1hi, a1lo, b0, bhi, blo, _j, _0); \
+  Two_Sum(_i, _0, _k, _1); \
+  Fast_Two_Sum(_j, _k, _l, _2); \
+  Split(b1, bhi, blo); \
+  Two_Product_2Presplit(a0, a0hi, a0lo, b1, bhi, blo, _i, _0); \
+  Two_Sum(_1, _0, _k, x1); \
+  Two_Sum(_2, _k, _j, _1); \
+  Two_Sum(_l, _j, _m, _2); \
+  Two_Product_2Presplit(a1, a1hi, a1lo, b1, bhi, blo, _j, _0); \
+  Two_Sum(_i, _0, _n, _0); \
+  Two_Sum(_1, _0, _i, x2); \
+  Two_Sum(_2, _i, _k, _1); \
+  Two_Sum(_m, _k, _l, _2); \
+  Two_Sum(_j, _n, _k, _0); \
+  Two_Sum(_1, _0, _j, x3); \
+  Two_Sum(_2, _j, _i, _1); \
+  Two_Sum(_l, _i, _m, _2); \
+  Two_Sum(_1, _k, _i, x4); \
+  Two_Sum(_2, _i, _k, x5); \
+  Two_Sum(_m, _k, x7, x6)
+
+#define Two_Square(a1, a0, x5, x4, x3, x2, x1, x0) \
+  Square(a0, _j, x0); \
+  _0 = a0 + a0; \
+  Two_Product(a1, _0, _k, _1); \
+  Two_One_Sum(_k, _1, _j, _l, _2, x1); \
+  Square(a1, _j, _1); \
+  Two_Two_Sum(_j, _1, _l, _2, x5, x4, x3, x2)
+
+static double splitter; /* = 2^ceiling(p / 2) + 1.  Used to split floats in half. */
+static double epsilon;  /* = 2^(-p).  Used to estimate roundoff errors. */
+/* A set of coefficients used to calculate maximum roundoff errors. */
+static double resulterrbound;
+static double ccwerrboundA, ccwerrboundB, ccwerrboundC;
+static double o3derrboundA, o3derrboundB, o3derrboundC;
+static double iccerrboundA, iccerrboundB, iccerrboundC;
+static double isperrboundA, isperrboundB, isperrboundC;
+
+/*
+ *  exactinit()   Initialize the variables used for exact arithmetic.
+ *
+ *  `epsilon' is the largest power of two such that 1.0 + epsilon = 1.0 in
+ *  floating-point arithmetic.  `epsilon' bounds the relative roundoff
+ *  error.  It is used for floating-point error analysis.
+ *
+ *  `splitter' is used to split floating-point numbers into two half-
+ *  length significands for exact multiplication.
+ *
+ *  I imagine that a highly optimizing compiler might be too smart for its
+ *  own good, and somehow cause this routine to fail, if it pretends that
+ *  floating-point arithmetic is too much like real arithmetic.
+ *
+ *  Don't change this routine unless you fully understand it.
+ */
+
+void exactinit()
+{
+  double half;
+  double check, lastcheck;
+  int every_other;
+
+  every_other = 1;
+  half = 0.5;
+  epsilon = 1.0;
+  splitter = 1.0;
+  check = 1.0;
+  /* Repeatedly divide `epsilon' by two until it is too small to add to    */
+  /*   one without causing roundoff.  (Also check if the sum is equal to   */
+  /*   the previous sum, for machines that round up instead of using exact */
+  /*   rounding.  Not that this library will work on such machines anyway. */
+  do {
+    lastcheck = check;
+    epsilon *= half;
+    if (every_other) {
+      splitter *= 2.0;
+    }
+    every_other = !every_other;
+    check = 1.0 + epsilon;
+  } while ((check != 1.0) && (check != lastcheck));
+  splitter += 1.0;
+
+  /* Error bounds for orientation and incircle tests. */
+  resulterrbound = (3.0 + 8.0 * epsilon) * epsilon;
+  ccwerrboundA = (3.0 + 16.0 * epsilon) * epsilon;
+  ccwerrboundB = (2.0 + 12.0 * epsilon) * epsilon;
+  ccwerrboundC = (9.0 + 64.0 * epsilon) * epsilon * epsilon;
+  o3derrboundA = (7.0 + 56.0 * epsilon) * epsilon;
+  o3derrboundB = (3.0 + 28.0 * epsilon) * epsilon;
+  o3derrboundC = (26.0 + 288.0 * epsilon) * epsilon * epsilon;
+  iccerrboundA = (10.0 + 96.0 * epsilon) * epsilon;
+  iccerrboundB = (4.0 + 48.0 * epsilon) * epsilon;
+  iccerrboundC = (44.0 + 576.0 * epsilon) * epsilon * epsilon;
+  isperrboundA = (16.0 + 224.0 * epsilon) * epsilon;
+  isperrboundB = (5.0 + 72.0 * epsilon) * epsilon;
+  isperrboundC = (71.0 + 1408.0 * epsilon) * epsilon * epsilon;
+}
+
+/*  fast_expansion_sum_zeroelim()   Sum two expansions, eliminating zero
+ *                                  components from the output expansion.
+ *
+ *  Sets h = e + f.  See the long version of my paper for details.
+ * h cannot be e or f.
+ */
+static int fast_expansion_sum_zeroelim(int elen, double *e, int flen, double *f, double *h)
+{
+  double Q;
+  INEXACT double Qnew;
+  INEXACT double hh;
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  int eindex, findex, hindex;
+  double enow, fnow;
+
+  enow = e[0];
+  fnow = f[0];
+  eindex = findex = 0;
+  if ((fnow > enow) == (fnow > -enow)) {
+    Q = enow;
+    enow = e[++eindex];
+  }
+  else {
+    Q = fnow;
+    fnow = f[++findex];
+  }
+  hindex = 0;
+  if ((eindex < elen) && (findex < flen)) {
+    if ((fnow > enow) == (fnow > -enow)) {
+      Fast_Two_Sum(enow, Q, Qnew, hh);
+      enow = e[++eindex];
+    }
+    else {
+      Fast_Two_Sum(fnow, Q, Qnew, hh);
+      fnow = f[++findex];
+    }
+    Q = Qnew;
+    if (hh != 0.0) {
+      h[hindex++] = hh;
+    }
+    while ((eindex < elen) && (findex < flen)) {
+      if ((fnow > enow) == (fnow > -enow)) {
+        Two_Sum(Q, enow, Qnew, hh);
+        enow = e[++eindex];
+      }
+      else {
+        Two_Sum(Q, fnow, Qnew, hh);
+        fnow = f[++findex];
+      }
+      Q = Qnew;
+      if (hh != 0.0) {
+        h[hindex++] = hh;
+      }
+    }
+  }
+  while (eindex < elen) {
+    Two_Sum(Q, enow, Qnew, hh);
+    enow = e[++eindex];
+    Q = Qnew;
+    if (hh != 0.0) {
+      h[hindex++] = hh;
+    }
+  }
+  while (findex < flen) {
+    Two_Sum(Q, fnow, Qnew, hh);
+    fnow = f[++findex];
+    Q = Qnew;
+    if (hh != 0.0) {
+      h[hindex++] = hh;
+    }
+  }
+  if ((Q != 0.0) || (hindex == 0)) {
+    h[hindex++] = Q;
+  }
+  return hindex;
+}
+
+/*  scale_expansion_zeroelim()   Multiply an expansion by a scalar,
+ *                               eliminating zero components from the
+ *                               output expansion.
+ *
+ *  Sets h = be.  See either version of my paper for details.
+ *  e and h cannot be the same.
+ */
+static int scale_expansion_zeroelim(int elen, double *e, double b, double *h)
+{
+  INEXACT double Q, sum;
+  double hh;
+  INEXACT double product1;
+  double product0;
+  int eindex, hindex;
+  double enow;
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  INEXACT double c;
+  INEXACT double abig;
+  double ahi, alo, bhi, blo;
+  double err1, err2, err3;
+
+  Split(b, bhi, blo);
+  Two_Product_Presplit(e[0], b, bhi, blo, Q, hh);
+  hindex = 0;
+  if (hh != 0) {
+    h[hindex++] = hh;
+  }
+  for (eindex = 1; eindex < elen; eindex++) {
+    enow = e[eindex];
+    Two_Product_Presplit(enow, b, bhi, blo, product1, product0);
+    Two_Sum(Q, product0, sum, hh);
+    if (hh != 0) {
+      h[hindex++] = hh;
+    }
+    Fast_Two_Sum(product1, sum, Q, hh);
+    if (hh != 0) {
+      h[hindex++] = hh;
+    }
+  }
+  if ((Q != 0.0) || (hindex == 0)) {
+    h[hindex++] = Q;
+  }
+  return hindex;
+}
+
+/*  estimate()   Produce a one-word estimate of an expansion's value. */
+static double estimate(int elen, double *e)
+{
+  double Q;
+  int eindex;
+
+  Q = e[0];
+  for (eindex = 1; eindex < elen; eindex++) {
+    Q += e[eindex];
+  }
+  return Q;
+}
+
+/*  orient2dfast()   Approximate 2D orientation test.  Nonrobust.
+ *  orient2d()   Adaptive exact 2D orientation test.  Robust.
+ *               Return a positive value if the points pa, pb, and pc occur
+ *               in counterclockwise order; a negative value if they occur
+ *               in clockwise order; and zero if they are collinear.  The
+ *               result is also a rough approximation of twice the signed
+ *               area of the triangle defined by the three points.
+ *
+ *  The second uses exact arithmetic to ensure a correct answer.  The
+ *  result returned is the determinant of a matrix.  In orient2d() only,
+ *  this determinant is computed adaptively, in the sense that exact
+ *  arithmetic is used only to the degree it is needed to ensure that the
+ *  returned value has the correct sign.  Hence, orient2d() is usually quite
+ *  fast, but will run more slowly when the input points are collinear or
+ *  nearly so.
+ */
+
+double orient2dfast(const double *pa, const double *pb, const double *pc)
+{
+  double acx, bcx, acy, bcy;
+
+  acx = pa[0] - pc[0];
+  bcx = pb[0] - pc[0];
+  acy = pa[1] - pc[1];
+  bcy = pb[1] - pc[1];
+  return acx * bcy - acy * bcx;
+}
+
+static double orient2dadapt(const double *pa, const double *pb, const double *pc, double detsum)
+{
+  INEXACT double acx, acy, bcx, bcy;
+  double acxtail, acytail, bcxtail, bcytail;
+  INEXACT double detleft, detright;
+  double detlefttail, detrighttail;
+  double det, errbound;
+  double B[4], C1[8], C2[12], D[16];
+  INEXACT double B3;
+  int C1length, C2length, Dlength;
+  double u[4];
+  INEXACT double u3;
+  INEXACT double s1, t1;
+  double s0, t0;
+
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  INEXACT double c;
+  INEXACT double abig;
+  double ahi, alo, bhi, blo;
+  double err1, err2, err3;
+  INEXACT double _i, _j;
+  double _0;
+
+  acx = (double)(pa[0] - pc[0]);
+  bcx = (double)(pb[0] - pc[0]);
+  acy = (double)(pa[1] - pc[1]);
+  bcy = (double)(pb[1] - pc[1]);
+
+  Two_Product(acx, bcy, detleft, detlefttail);
+  Two_Product(acy, bcx, detright, detrighttail);
+
+  Two_Two_Diff(detleft, detlefttail, detright, detrighttail, B3, B[2], B[1], B[0]);
+  B[3] = B3;
+
+  det = estimate(4, B);
+  errbound = ccwerrboundB * detsum;
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  Two_Diff_Tail(pa[0], pc[0], acx, acxtail);
+  Two_Diff_Tail(pb[0], pc[0], bcx, bcxtail);
+  Two_Diff_Tail(pa[1], pc[1], acy, acytail);
+  Two_Diff_Tail(pb[1], pc[1], bcy, bcytail);
+
+  if ((acxtail == 0.0) && (acytail == 0.0) && (bcxtail == 0.0) && (bcytail == 0.0)) {
+    return det;
+  }
+
+  errbound = ccwerrboundC * detsum + resulterrbound * Absolute(det);
+  det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  Two_Product(acxtail, bcy, s1, s0);
+  Two_Product(acytail, bcx, t1, t0);
+  Two_Two_Diff(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
+  u[3] = u3;
+  C1length = fast_expansion_sum_zeroelim(4, B, 4, u, C1);
+
+  Two_Product(acx, bcytail, s1, s0);
+  Two_Product(acy, bcxtail, t1, t0);
+  Two_Two_Diff(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
+  u[3] = u3;
+  C2length = fast_expansion_sum_zeroelim(C1length, C1, 4, u, C2);
+
+  Two_Product(acxtail, bcytail, s1, s0);
+  Two_Product(acytail, bcxtail, t1, t0);
+  Two_Two_Diff(s1, s0, t1, t0, u3, u[2], u[1], u[0]);
+  u[3] = u3;
+  Dlength = fast_expansion_sum_zeroelim(C2length, C2, 4, u, D);
+
+  return (D[Dlength - 1]);
+}
+
+double orient2d(const double *pa, const double *pb, const double *pc)
+{
+  double detleft, detright, det;
+  double detsum, errbound;
+
+  detleft = (pa[0] - pc[0]) * (pb[1] - pc[1]);
+  detright = (pa[1] - pc[1]) * (pb[0] - pc[0]);
+  det = detleft - detright;
+
+  if (detleft > 0.0) {
+    if (detright <= 0.0) {
+      return det;
+    }
+    else {
+      detsum = detleft + detright;
+    }
+  }
+  else if (detleft < 0.0) {
+    if (detright >= 0.0) {
+      return det;
+    }
+    else {
+      detsum = -detleft - detright;
+    }
+  }
+  else {
+    return det;
+  }
+
+  errbound = ccwerrboundA * detsum;
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  return orient2dadapt(pa, pb, pc, detsum);
+}
+
+/*  orient3dfast()   Approximate 3D orientation test.  Nonrobust.
+ *  orient3d()   Adaptive exact 3D orientation test.  Robust.
+ *
+ *               Return a positive value if the point pd lies below the
+ *               plane passing through pa, pb, and pc; "below" is defined so
+ *               that pa, pb, and pc appear in counterclockwise order when
+ *               viewed from above the plane.  Returns a negative value if
+ *               pd lies above the plane.  Returns zero if the points are
+ *               coplanar.  The result is also a rough approximation of six
+ *               times the signed volume of the tetrahedron defined by the
+ *               four points.
+ *
+ *  The second uses exact arithmetic to ensure a correct answer.  The
+ *  result returned is the determinant of a matrix.  In orient3d() only,
+ *  this determinant is computed adaptively, in the sense that exact
+ *  arithmetic is used only to the degree it is needed to ensure that the
+ *  returned value has the correct sign.  Hence, orient3d() is usually quite
+ *  fast, but will run more slowly when the input points are coplanar or
+ *  nearly so.
+ */
+
+double orient3dfast(const double *pa, const double *pb, const double *pc, const double *pd)
+{
+  double adx, bdx, cdx;
+  double ady, bdy, cdy;
+  double adz, bdz, cdz;
+
+  adx = pa[0] - pd[0];
+  bdx = pb[0] - pd[0];
+  cdx = pc[0] - pd[0];
+  ady = pa[1] - pd[1];
+  bdy = pb[1] - pd[1];
+  cdy = pc[1] - pd[1];
+  adz = pa[2] - pd[2];
+  bdz = pb[2] - pd[2];
+  cdz = pc[2] - pd[2];
+
+  return adx * (bdy * cdz - bdz * cdy) + bdx * (cdy * adz - cdz * ady) +
+         cdx * (ady * bdz - adz * bdy);
+}
+
+static double orient3dadapt(
+    const double *pa, const double *pb, const double *pc, const double *pd, double permanent)
+{
+  INEXACT double adx, bdx, cdx, ady, bdy, cdy, adz, bdz, cdz;
+  double det, errbound;
+
+  INEXACT double bdxcdy1, cdxbdy1, cdxady1, adxcdy1, adxbdy1, bdxady1;
+  double bdxcdy0, cdxbdy0, cdxady0, adxcdy0, adxbdy0, bdxady0;
+  double bc[4], ca[4], ab[4];
+  INEXACT double bc3, ca3, ab3;
+  double adet[8], bdet[8], cdet[8];
+  int alen, blen, clen;
+  double abdet[16];
+  int ablen;
+  double *finnow, *finother, *finswap;
+  double fin1[192], fin2[192];
+  int finlength;
+
+  double adxtail, bdxtail, cdxtail;
+  double adytail, bdytail, cdytail;
+  double adztail, bdztail, cdztail;
+  INEXACT double at_blarge, at_clarge;
+  INEXACT double bt_clarge, bt_alarge;
+  INEXACT double ct_alarge, ct_blarge;
+  double at_b[4], at_c[4], bt_c[4], bt_a[4], ct_a[4], ct_b[4];
+  int at_blen, at_clen, bt_clen, bt_alen, ct_alen, ct_blen;
+  INEXACT double bdxt_cdy1, cdxt_bdy1, cdxt_ady1;
+  INEXACT double adxt_cdy1, adxt_bdy1, bdxt_ady1;
+  double bdxt_cdy0, cdxt_bdy0, cdxt_ady0;
+  double adxt_cdy0, adxt_bdy0, bdxt_ady0;
+  INEXACT double bdyt_cdx1, cdyt_bdx1, cdyt_adx1;
+  INEXACT double adyt_cdx1, adyt_bdx1, bdyt_adx1;
+  double bdyt_cdx0, cdyt_bdx0, cdyt_adx0;
+  double adyt_cdx0, adyt_bdx0, bdyt_adx0;
+  double bct[8], cat[8], abt[8];
+  int bctlen, catlen, abtlen;
+  INEXACT double bdxt_cdyt1, cdxt_bdyt1, cdxt_adyt1;
+  INEXACT double adxt_cdyt1, adxt_bdyt1, bdxt_adyt1;
+  double bdxt_cdyt0, cdxt_bdyt0, cdxt_adyt0;
+  double adxt_cdyt0, adxt_bdyt0, bdxt_adyt0;
+  double u[4], v[12], w[16];
+  INEXACT double u3;
+  int vlength, wlength;
+  double negate;
+
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  INEXACT double c;
+  INEXACT double abig;
+  double ahi, alo, bhi, blo;
+  double err1, err2, err3;
+  INEXACT double _i, _j, _k;
+  double _0;
+
+  adx = (double)(pa[0] - pd[0]);
+  bdx = (double)(pb[0] - pd[0]);
+  cdx = (double)(pc[0] - pd[0]);
+  ady = (double)(pa[1] - pd[1]);
+  bdy = (double)(pb[1] - pd[1]);
+  cdy = (double)(pc[1] - pd[1]);
+  adz = (double)(pa[2] - pd[2]);
+  bdz = (double)(pb[2] - pd[2]);
+  cdz = (double)(pc[2] - pd[2]);
+
+  Two_Product(bdx, cdy, bdxcdy1, bdxcdy0);
+  Two_Product(cdx, bdy, cdxbdy1, cdxbdy0);
+  Two_Two_Diff(bdxcdy1, bdxcdy0, cdxbdy1, cdxbdy0, bc3, bc[2], bc[1], bc[0]);
+  bc[3] = bc3;
+  alen = scale_expansion_zeroelim(4, bc, adz, adet);
+
+  Two_Product(cdx, ady, cdxady1, cdxady0);
+  Two_Product(adx, cdy, adxcdy1, adxcdy0);
+  Two_Two_Diff(cdxady1, cdxady0, adxcdy1, adxcdy0, ca3, ca[2], ca[1], ca[0]);
+  ca[3] = ca3;
+  blen = scale_expansion_zeroelim(4, ca, bdz, bdet);
+
+  Two_Product(adx, bdy, adxbdy1, adxbdy0);
+  Two_Product(bdx, ady, bdxady1, bdxady0);
+  Two_Two_Diff(adxbdy1, adxbdy0, bdxady1, bdxady0, ab3, ab[2], ab[1], ab[0]);
+  ab[3] = ab3;
+  clen = scale_expansion_zeroelim(4, ab, cdz, cdet);
+
+  ablen = fast_expansion_sum_zeroelim(alen, adet, blen, bdet, abdet);
+  finlength = fast_expansion_sum_zeroelim(ablen, abdet, clen, cdet, fin1);
+
+  det = estimate(finlength, fin1);
+  errbound = o3derrboundB * permanent;
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  Two_Diff_Tail(pa[0], pd[0], adx, adxtail);
+  Two_Diff_Tail(pb[0], pd[0], bdx, bdxtail);
+  Two_Diff_Tail(pc[0], pd[0], cdx, cdxtail);
+  Two_Diff_Tail(pa[1], pd[1], ady, adytail);
+  Two_Diff_Tail(pb[1], pd[1], bdy, bdytail);
+  Two_Diff_Tail(pc[1], pd[1], cdy, cdytail);
+  Two_Diff_Tail(pa[2], pd[2], adz, adztail);
+  Two_Diff_Tail(pb[2], pd[2], bdz, bdztail);
+  Two_Diff_Tail(pc[2], pd[2], cdz, cdztail);
+
+  if ((adxtail == 0.0) && (bdxtail == 0.0) && (cdxtail == 0.0) && (adytail == 0.0) &&
+      (bdytail == 0.0) && (cdytail == 0.0) && (adztail == 0.0) && (bdztail == 0.0) &&
+      (cdztail == 0.0)) {
+    return det;
+  }
+
+  errbound = o3derrboundC * permanent + resulterrbound * Absolute(det);
+  det += (adz * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
+          adztail * (bdx * cdy - bdy * cdx)) +
+         (bdz * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
+          bdztail * (cdx * ady - cdy * adx)) +
+         (cdz * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
+          cdztail * (adx * bdy - ady * bdx));
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  finnow = fin1;
+  finother = fin2;
+
+  if (adxtail == 0.0) {
+    if (adytail == 0.0) {
+      at_b[0] = 0.0;
+      at_blen = 1;
+      at_c[0] = 0.0;
+      at_clen = 1;
+    }
+    else {
+      negate = -adytail;
+      Two_Product(negate, bdx, at_blarge, at_b[0]);
+      at_b[1] = at_blarge;
+      at_blen = 2;
+      Two_Product(adytail, cdx, at_clarge, at_c[0]);
+      at_c[1] = at_clarge;
+      at_clen = 2;
+    }
+  }
+  else {
+    if (adytail == 0.0) {
+      Two_Product(adxtail, bdy, at_blarge, at_b[0]);
+      at_b[1] = at_blarge;
+      at_blen = 2;
+      negate = -adxtail;
+      Two_Product(negate, cdy, at_clarge, at_c[0]);
+      at_c[1] = at_clarge;
+      at_clen = 2;
+    }
+    else {
+      Two_Product(adxtail, bdy, adxt_bdy1, adxt_bdy0);
+      Two_Product(adytail, bdx, adyt_bdx1, adyt_bdx0);
+      Two_Two_Diff(
+          adxt_bdy1, adxt_bdy0, adyt_bdx1, adyt_bdx0, at_blarge, at_b[2], at_b[1], at_b[0]);
+      at_b[3] = at_blarge;
+      at_blen = 4;
+      Two_Product(adytail, cdx, adyt_cdx1, adyt_cdx0);
+      Two_Product(adxtail, cdy, adxt_cdy1, adxt_cdy0);
+      Two_Two_Diff(
+          adyt_cdx1, adyt_cdx0, adxt_cdy1, adxt_cdy0, at_clarge, at_c[2], at_c[1], at_c[0]);
+      at_c[3] = at_clarge;
+      at_clen = 4;
+    }
+  }
+  if (bdxtail == 0.0) {
+    if (bdytail == 0.0) {
+      bt_c[0] = 0.0;
+      bt_clen = 1;
+      bt_a[0] = 0.0;
+      bt_alen = 1;
+    }
+    else {
+      negate = -bdytail;
+      Two_Product(negate, cdx, bt_clarge, bt_c[0]);
+      bt_c[1] = bt_clarge;
+      bt_clen = 2;
+      Two_Product(bdytail, adx, bt_alarge, bt_a[0]);
+      bt_a[1] = bt_alarge;
+      bt_alen = 2;
+    }
+  }
+  else {
+    if (bdytail == 0.0) {
+      Two_Product(bdxtail, cdy, bt_clarge, bt_c[0]);
+      bt_c[1] = bt_clarge;
+      bt_clen = 2;
+      negate = -bdxtail;
+      Two_Product(negate, ady, bt_alarge, bt_a[0]);
+      bt_a[1] = bt_alarge;
+      bt_alen = 2;
+    }
+    else {
+      Two_Product(bdxtail, cdy, bdxt_cdy1, bdxt_cdy0);
+      Two_Product(bdytail, cdx, bdyt_cdx1, bdyt_cdx0);
+      Two_Two_Diff(
+          bdxt_cdy1, bdxt_cdy0, bdyt_cdx1, bdyt_cdx0, bt_clarge, bt_c[2], bt_c[1], bt_c[0]);
+      bt_c[3] = bt_clarge;
+      bt_clen = 4;
+      Two_Product(bdytail, adx, bdyt_adx1, bdyt_adx0);
+      Two_Product(bdxtail, ady, bdxt_ady1, bdxt_ady0);
+      Two_Two_Diff(
+          bdyt_adx1, bdyt_adx0, bdxt_ady1, bdxt_ady0, bt_alarge, bt_a[2], bt_a[1], bt_a[0]);
+      bt_a[3] = bt_alarge;
+      bt_alen = 4;
+    }
+  }
+  if (cdxtail == 0.0) {
+    if (cdytail == 0.0) {
+      ct_a[0] = 0.0;
+      ct_alen = 1;
+      ct_b[0] = 0.0;
+      ct_blen = 1;
+    }
+    else {
+      negate = -cdytail;
+      Two_Product(negate, adx, ct_alarge, ct_a[0]);
+      ct_a[1] = ct_alarge;
+      ct_alen = 2;
+      Two_Product(cdytail, bdx, ct_blarge, ct_b[0]);
+      ct_b[1] = ct_blarge;
+      ct_blen = 2;
+    }
+  }
+  else {
+    if (cdytail == 0.0) {
+      Two_Product(cdxtail, ady, ct_alarge, ct_a[0]);
+      ct_a[1] = ct_alarge;
+      ct_alen = 2;
+      negate = -cdxtail;
+      Two_Product(negate, bdy, ct_blarge, ct_b[0]);
+      ct_b[1] = ct_blarge;
+      ct_blen = 2;
+    }
+    else {
+      Two_Product(cdxtail, ady, cdxt_ady1, cdxt_ady0);
+      Two_Product(cdytail, adx, cdyt_adx1, cdyt_adx0);
+      Two_Two_Diff(
+          cdxt_ady1, cdxt_ady0, cdyt_adx1, cdyt_adx0, ct_alarge, ct_a[2], ct_a[1], ct_a[0]);
+      ct_a[3] = ct_alarge;
+      ct_alen = 4;
+      Two_Product(cdytail, bdx, cdyt_bdx1, cdyt_bdx0);
+      Two_Product(cdxtail, bdy, cdxt_bdy1, cdxt_bdy0);
+      Two_Two_Diff(
+          cdyt_bdx1, cdyt_bdx0, cdxt_bdy1, cdxt_bdy0, ct_blarge, ct_b[2], ct_b[1], ct_b[0]);
+      ct_b[3] = ct_blarge;
+      ct_blen = 4;
+    }
+  }
+
+  bctlen = fast_expansion_sum_zeroelim(bt_clen, bt_c, ct_blen, ct_b, bct);
+  wlength = scale_expansion_zeroelim(bctlen, bct, adz, w);
+  finlength = fast_expansion_sum_zeroelim(finlength, finnow, wlength, w, finother);
+  finswap = finnow;
+  finnow = finother;
+  finother = finswap;
+
+  catlen = fast_expansion_sum_zeroelim(ct_alen, ct_a, at_clen, at_c, cat);
+  wlength = scale_expansion_zeroelim(catlen, cat, bdz, w);
+  finlength = fast_expansion_sum_zeroelim(finlength, finnow, wlength, w, finother);
+  finswap = finnow;
+  finnow = finother;
+  finother = finswap;
+
+  abtlen = fast_expansion_sum_zeroelim(at_blen, at_b, bt_alen, bt_a, abt);
+  wlength = scale_expansion_zeroelim(abtlen, abt, cdz, w);
+  finlength = fast_expansion_sum_zeroelim(finlength, finnow, wlength, w, finother);
+  finswap = finnow;
+  finnow = finother;
+  finother = finswap;
+
+  if (adztail != 0.0) {
+    vlength = scale_expansion_zeroelim(4, bc, adztail, v);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, vlength, v, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (bdztail != 0.0) {
+    vlength = scale_expansion_zeroelim(4, ca, bdztail, v);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, vlength, v, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (cdztail != 0.0) {
+    vlength = scale_expansion_zeroelim(4, ab, cdztail, v);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, vlength, v, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+
+  if (adxtail != 0.0) {
+    if (bdytail != 0.0) {
+      Two_Product(adxtail, bdytail, adxt_bdyt1, adxt_bdyt0);
+      Two_One_Product(adxt_bdyt1, adxt_bdyt0, cdz, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (cdztail != 0.0) {
+        Two_One_Product(adxt_bdyt1, adxt_bdyt0, cdztail, u3, u[2], u[1], u[0]);
+        u[3] = u3;
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+    }
+    if (cdytail != 0.0) {
+      negate = -adxtail;
+      Two_Product(negate, cdytail, adxt_cdyt1, adxt_cdyt0);
+      Two_One_Product(adxt_cdyt1, adxt_cdyt0, bdz, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (bdztail != 0.0) {
+        Two_One_Product(adxt_cdyt1, adxt_cdyt0, bdztail, u3, u[2], u[1], u[0]);
+        u[3] = u3;
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+    }
+  }
+  if (bdxtail != 0.0) {
+    if (cdytail != 0.0) {
+      Two_Product(bdxtail, cdytail, bdxt_cdyt1, bdxt_cdyt0);
+      Two_One_Product(bdxt_cdyt1, bdxt_cdyt0, adz, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (adztail != 0.0) {
+        Two_One_Product(bdxt_cdyt1, bdxt_cdyt0, adztail, u3, u[2], u[1], u[0]);
+        u[3] = u3;
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+    }
+    if (adytail != 0.0) {
+      negate = -bdxtail;
+      Two_Product(negate, adytail, bdxt_adyt1, bdxt_adyt0);
+      Two_One_Product(bdxt_adyt1, bdxt_adyt0, cdz, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (cdztail != 0.0) {
+        Two_One_Product(bdxt_adyt1, bdxt_adyt0, cdztail, u3, u[2], u[1], u[0]);
+        u[3] = u3;
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+    }
+  }
+  if (cdxtail != 0.0) {
+    if (adytail != 0.0) {
+      Two_Product(cdxtail, adytail, cdxt_adyt1, cdxt_adyt0);
+      Two_One_Product(cdxt_adyt1, cdxt_adyt0, bdz, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (bdztail != 0.0) {
+        Two_One_Product(cdxt_adyt1, cdxt_adyt0, bdztail, u3, u[2], u[1], u[0]);
+        u[3] = u3;
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+    }
+    if (bdytail != 0.0) {
+      negate = -cdxtail;
+      Two_Product(negate, bdytail, cdxt_bdyt1, cdxt_bdyt0);
+      Two_One_Product(cdxt_bdyt1, cdxt_bdyt0, adz, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (adztail != 0.0) {
+        Two_One_Product(cdxt_bdyt1, cdxt_bdyt0, adztail, u3, u[2], u[1], u[0]);
+        u[3] = u3;
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, 4, u, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+    }
+  }
+
+  if (adztail != 0.0) {
+    wlength = scale_expansion_zeroelim(bctlen, bct, adztail, w);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, wlength, w, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (bdztail != 0.0) {
+    wlength = scale_expansion_zeroelim(catlen, cat, bdztail, w);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, wlength, w, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (cdztail != 0.0) {
+    wlength = scale_expansion_zeroelim(abtlen, abt, cdztail, w);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, wlength, w, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+
+  return finnow[finlength - 1];
+}
+
+double orient3d(const double *pa, const double *pb, const double *pc, const double *pd)
+{
+  double adx, bdx, cdx, ady, bdy, cdy, adz, bdz, cdz;
+  double bdxcdy, cdxbdy, cdxady, adxcdy, adxbdy, bdxady;
+  double det;
+  double permanent, errbound;
+
+  adx = pa[0] - pd[0];
+  bdx = pb[0] - pd[0];
+  cdx = pc[0] - pd[0];
+  ady = pa[1] - pd[1];
+  bdy = pb[1] - pd[1];
+  cdy = pc[1] - pd[1];
+  adz = pa[2] - pd[2];
+  bdz = pb[2] - pd[2];
+  cdz = pc[2] - pd[2];
+
+  bdxcdy = bdx * cdy;
+  cdxbdy = cdx * bdy;
+
+  cdxady = cdx * ady;
+  adxcdy = adx * cdy;
+
+  adxbdy = adx * bdy;
+  bdxady = bdx * ady;
+
+  det = adz * (bdxcdy - cdxbdy) + bdz * (cdxady - adxcdy) + cdz * (adxbdy - bdxady);
+
+  permanent = (Absolute(bdxcdy) + Absolute(cdxbdy)) * Absolute(adz) +
+              (Absolute(cdxady) + Absolute(adxcdy)) * Absolute(bdz) +
+              (Absolute(adxbdy) + Absolute(bdxady)) * Absolute(cdz);
+  errbound = o3derrboundA * permanent;
+  if ((det > errbound) || (-det > errbound)) {
+    return det;
+  }
+
+  return orient3dadapt(pa, pb, pc, pd, permanent);
+}
+
+/*  incirclefast()   Approximate 2D incircle test.  Nonrobust.
+ *  incircle()
+ *
+ *               Return a positive value if the point pd lies inside the
+ *               circle passing through pa, pb, and pc; a negative value if
+ *               it lies outside; and zero if the four points are cocircular.
+ *               The points pa, pb, and pc must be in counterclockwise
+ *               order, or the sign of the result will be reversed.
+ *
+ *  The second uses exact arithmetic to ensure a correct answer.  The
+ *  result returned is the determinant of a matrix.  In incircle() only,
+ *  this determinant is computed adaptively, in the sense that exact
+ *  arithmetic is used only to the degree it is needed to ensure that the
+ *  returned value has the correct sign.  Hence, incircle() is usually quite
+ *  fast, but will run more slowly when the input points are cocircular or
+ *  nearly so.
+ */
+
+double incirclefast(const double *pa, const double *pb, const double *pc, const double *pd)
+{
+  double adx, ady, bdx, bdy, cdx, cdy;
+  double abdet, bcdet, cadet;
+  double alift, blift, clift;
+
+  adx = pa[0] - pd[0];
+  ady = pa[1] - pd[1];
+  bdx = pb[0] - pd[0];
+  bdy = pb[1] - pd[1];
+  cdx = pc[0] - pd[0];
+  cdy = pc[1] - pd[1];
+
+  abdet = adx * bdy - bdx * ady;
+  bcdet = bdx * cdy - cdx * bdy;
+  cadet = cdx * ady - adx * cdy;
+  alift = adx * adx + ady * ady;
+  blift = bdx * bdx + bdy * bdy;
+  clift = cdx * cdx + cdy * cdy;
+
+  return alift * bcdet + blift * cadet + clift * abdet;
+}
+
+static double incircleadapt(
+    const double *pa, const double *pb, const double *pc, const double *pd, double permanent)
+{
+  INEXACT double adx, bdx, cdx, ady, bdy, cdy;
+  double det, errbound;
+
+  INEXACT double bdxcdy1, cdxbdy1, cdxady1, adxcdy1, adxbdy1, bdxady1;
+  double bdxcdy0, cdxbdy0, cdxady0, adxcdy0, adxbdy0, bdxady0;
+  double bc[4], ca[4], ab[4];
+  INEXACT double bc3, ca3, ab3;
+  double axbc[8], axxbc[16], aybc[8], ayybc[16], adet[32];
+  int axbclen, axxbclen, aybclen, ayybclen, alen;
+  double bxca[8], bxxca[16], byca[8], byyca[16], bdet[32];
+  int bxcalen, bxxcalen, bycalen, byycalen, blen;
+  double cxab[8], cxxab[16], cyab[8], cyyab[16], cdet[32];
+  int cxablen, cxxablen, cyablen, cyyablen, clen;
+  double abdet[64];
+  int ablen;
+  double fin1[1152], fin2[1152];
+  double *finnow, *finother, *finswap;
+  int finlength;
+
+  double adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
+  INEXACT double adxadx1, adyady1, bdxbdx1, bdybdy1, cdxcdx1, cdycdy1;
+  double adxadx0, adyady0, bdxbdx0, bdybdy0, cdxcdx0, cdycdy0;
+  double aa[4], bb[4], cc[4];
+  INEXACT double aa3, bb3, cc3;
+  INEXACT double ti1, tj1;
+  double ti0, tj0;
+  double u[4], v[4];
+  INEXACT double u3, v3;
+  double temp8[8], temp16a[16], temp16b[16], temp16c[16];
+  double temp32a[32], temp32b[32], temp48[48], temp64[64];
+  int temp8len, temp16alen, temp16blen, temp16clen;
+  int temp32alen, temp32blen, temp48len, temp64len;
+  double axtbb[8], axtcc[8], aytbb[8], aytcc[8];
+  int axtbblen, axtcclen, aytbblen, aytcclen;
+  double bxtaa[8], bxtcc[8], bytaa[8], bytcc[8];
+  int bxtaalen, bxtcclen, bytaalen, bytcclen;
+  double cxtaa[8], cxtbb[8], cytaa[8], cytbb[8];
+  int cxtaalen, cxtbblen, cytaalen, cytbblen;
+  double axtbc[8], aytbc[8], bxtca[8], bytca[8], cxtab[8], cytab[8];
+  int axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
+  double axtbct[16], aytbct[16], bxtcat[16], bytcat[16], cxtabt[16], cytabt[16];
+  int axtbctlen, aytbctlen, bxtcatlen, bytcatlen, cxtabtlen, cytabtlen;
+  double axtbctt[8], aytbctt[8], bxtcatt[8];
+  double bytcatt[8], cxtabtt[8], cytabtt[8];
+  int axtbcttlen, aytbcttlen, bxtcattlen, bytcattlen, cxtabttlen, cytabttlen;
+  double abt[8], bct[8], cat[8];
+  int abtlen, bctlen, catlen;
+  double abtt[4], bctt[4], catt[4];
+  int abttlen, bcttlen, cattlen;
+  INEXACT double abtt3, bctt3, catt3;
+  double negate;
+
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  INEXACT double c;
+  INEXACT double abig;
+  double ahi, alo, bhi, blo;
+  double err1, err2, err3;
+  INEXACT double _i, _j;
+  double _0;
+
+  adx = (double)(pa[0] - pd[0]);
+  bdx = (double)(pb[0] - pd[0]);
+  cdx = (double)(pc[0] - pd[0]);
+  ady = (double)(pa[1] - pd[1]);
+  bdy = (double)(pb[1] - pd[1]);
+  cdy = (double)(pc[1] - pd[1]);
+
+  Two_Product(bdx, cdy, bdxcdy1, bdxcdy0);
+  Two_Product(cdx, bdy, cdxbdy1, cdxbdy0);
+  Two_Two_Diff(bdxcdy1, bdxcdy0, cdxbdy1, cdxbdy0, bc3, bc[2], bc[1], bc[0]);
+  bc[3] = bc3;
+  axbclen = scale_expansion_zeroelim(4, bc, adx, axbc);
+  axxbclen = scale_expansion_zeroelim(axbclen, axbc, adx, axxbc);
+  aybclen = scale_expansion_zeroelim(4, bc, ady, aybc);
+  ayybclen = scale_expansion_zeroelim(aybclen, aybc, ady, ayybc);
+  alen = fast_expansion_sum_zeroelim(axxbclen, axxbc, ayybclen, ayybc, adet);
+
+  Two_Product(cdx, ady, cdxady1, cdxady0);
+  Two_Product(adx, cdy, adxcdy1, adxcdy0);
+  Two_Two_Diff(cdxady1, cdxady0, adxcdy1, adxcdy0, ca3, ca[2], ca[1], ca[0]);
+  ca[3] = ca3;
+  bxcalen = scale_expansion_zeroelim(4, ca, bdx, bxca);
+  bxxcalen = scale_expansion_zeroelim(bxcalen, bxca, bdx, bxxca);
+  bycalen = scale_expansion_zeroelim(4, ca, bdy, byca);
+  byycalen = scale_expansion_zeroelim(bycalen, byca, bdy, byyca);
+  blen = fast_expansion_sum_zeroelim(bxxcalen, bxxca, byycalen, byyca, bdet);
+
+  Two_Product(adx, bdy, adxbdy1, adxbdy0);
+  Two_Product(bdx, ady, bdxady1, bdxady0);
+  Two_Two_Diff(adxbdy1, adxbdy0, bdxady1, bdxady0, ab3, ab[2], ab[1], ab[0]);
+  ab[3] = ab3;
+  cxablen = scale_expansion_zeroelim(4, ab, cdx, cxab);
+  cxxablen = scale_expansion_zeroelim(cxablen, cxab, cdx, cxxab);
+  cyablen = scale_expansion_zeroelim(4, ab, cdy, cyab);
+  cyyablen = scale_expansion_zeroelim(cyablen, cyab, cdy, cyyab);
+  clen = fast_expansion_sum_zeroelim(cxxablen, cxxab, cyyablen, cyyab, cdet);
+
+  ablen = fast_expansion_sum_zeroelim(alen, adet, blen, bdet, abdet);
+  finlength = fast_expansion_sum_zeroelim(ablen, abdet, clen, cdet, fin1);
+
+  det = estimate(finlength, fin1);
+  errbound = iccerrboundB * permanent;
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  Two_Diff_Tail(pa[0], pd[0], adx, adxtail);
+  Two_Diff_Tail(pa[1], pd[1], ady, adytail);
+  Two_Diff_Tail(pb[0], pd[0], bdx, bdxtail);
+  Two_Diff_Tail(pb[1], pd[1], bdy, bdytail);
+  Two_Diff_Tail(pc[0], pd[0], cdx, cdxtail);
+  Two_Diff_Tail(pc[1], pd[1], cdy, cdytail);
+  if ((adxtail == 0.0) && (bdxtail == 0.0) && (cdxtail == 0.0) && (adytail == 0.0) &&
+      (bdytail == 0.0) && (cdytail == 0.0)) {
+    return det;
+  }
+
+  errbound = iccerrboundC * permanent + resulterrbound * Absolute(det);
+  det += ((adx * adx + ady * ady) *
+              ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
+          2.0 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
+         ((bdx * bdx + bdy * bdy) *
+              ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
+          2.0 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
+         ((cdx * cdx + cdy * cdy) *
+              ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
+          2.0 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  finnow = fin1;
+  finother = fin2;
+
+  if ((bdxtail != 0.0) || (bdytail != 0.0) || (cdxtail != 0.0) || (cdytail != 0.0)) {
+    Square(adx, adxadx1, adxadx0);
+    Square(ady, adyady1, adyady0);
+    Two_Two_Sum(adxadx1, adxadx0, adyady1, adyady0, aa3, aa[2], aa[1], aa[0]);
+    aa[3] = aa3;
+  }
+  if ((cdxtail != 0.0) || (cdytail != 0.0) || (adxtail != 0.0) || (adytail != 0.0)) {
+    Square(bdx, bdxbdx1, bdxbdx0);
+    Square(bdy, bdybdy1, bdybdy0);
+    Two_Two_Sum(bdxbdx1, bdxbdx0, bdybdy1, bdybdy0, bb3, bb[2], bb[1], bb[0]);
+    bb[3] = bb3;
+  }
+  if ((adxtail != 0.0) || (adytail != 0.0) || (bdxtail != 0.0) || (bdytail != 0.0)) {
+    Square(cdx, cdxcdx1, cdxcdx0);
+    Square(cdy, cdycdy1, cdycdy0);
+    Two_Two_Sum(cdxcdx1, cdxcdx0, cdycdy1, cdycdy0, cc3, cc[2], cc[1], cc[0]);
+    cc[3] = cc3;
+  }
+
+  if (adxtail != 0.0) {
+    axtbclen = scale_expansion_zeroelim(4, bc, adxtail, axtbc);
+    temp16alen = scale_expansion_zeroelim(axtbclen, axtbc, 2.0 * adx, temp16a);
+
+    axtcclen = scale_expansion_zeroelim(4, cc, adxtail, axtcc);
+    temp16blen = scale_expansion_zeroelim(axtcclen, axtcc, bdy, temp16b);
+
+    axtbblen = scale_expansion_zeroelim(4, bb, adxtail, axtbb);
+    temp16clen = scale_expansion_zeroelim(axtbblen, axtbb, -cdy, temp16c);
+
+    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (adytail != 0.0) {
+    aytbclen = scale_expansion_zeroelim(4, bc, adytail, aytbc);
+    temp16alen = scale_expansion_zeroelim(aytbclen, aytbc, 2.0 * ady, temp16a);
+
+    aytbblen = scale_expansion_zeroelim(4, bb, adytail, aytbb);
+    temp16blen = scale_expansion_zeroelim(aytbblen, aytbb, cdx, temp16b);
+
+    aytcclen = scale_expansion_zeroelim(4, cc, adytail, aytcc);
+    temp16clen = scale_expansion_zeroelim(aytcclen, aytcc, -bdx, temp16c);
+
+    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (bdxtail != 0.0) {
+    bxtcalen = scale_expansion_zeroelim(4, ca, bdxtail, bxtca);
+    temp16alen = scale_expansion_zeroelim(bxtcalen, bxtca, 2.0 * bdx, temp16a);
+
+    bxtaalen = scale_expansion_zeroelim(4, aa, bdxtail, bxtaa);
+    temp16blen = scale_expansion_zeroelim(bxtaalen, bxtaa, cdy, temp16b);
+
+    bxtcclen = scale_expansion_zeroelim(4, cc, bdxtail, bxtcc);
+    temp16clen = scale_expansion_zeroelim(bxtcclen, bxtcc, -ady, temp16c);
+
+    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (bdytail != 0.0) {
+    bytcalen = scale_expansion_zeroelim(4, ca, bdytail, bytca);
+    temp16alen = scale_expansion_zeroelim(bytcalen, bytca, 2.0 * bdy, temp16a);
+
+    bytcclen = scale_expansion_zeroelim(4, cc, bdytail, bytcc);
+    temp16blen = scale_expansion_zeroelim(bytcclen, bytcc, adx, temp16b);
+
+    bytaalen = scale_expansion_zeroelim(4, aa, bdytail, bytaa);
+    temp16clen = scale_expansion_zeroelim(bytaalen, bytaa, -cdx, temp16c);
+
+    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (cdxtail != 0.0) {
+    cxtablen = scale_expansion_zeroelim(4, ab, cdxtail, cxtab);
+    temp16alen = scale_expansion_zeroelim(cxtablen, cxtab, 2.0 * cdx, temp16a);
+
+    cxtbblen = scale_expansion_zeroelim(4, bb, cdxtail, cxtbb);
+    temp16blen = scale_expansion_zeroelim(cxtbblen, cxtbb, ady, temp16b);
+
+    cxtaalen = scale_expansion_zeroelim(4, aa, cdxtail, cxtaa);
+    temp16clen = scale_expansion_zeroelim(cxtaalen, cxtaa, -bdy, temp16c);
+
+    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+  if (cdytail != 0.0) {
+    cytablen = scale_expansion_zeroelim(4, ab, cdytail, cytab);
+    temp16alen = scale_expansion_zeroelim(cytablen, cytab, 2.0 * cdy, temp16a);
+
+    cytaalen = scale_expansion_zeroelim(4, aa, cdytail, cytaa);
+    temp16blen = scale_expansion_zeroelim(cytaalen, cytaa, bdx, temp16b);
+
+    cytbblen = scale_expansion_zeroelim(4, bb, cdytail, cytbb);
+    temp16clen = scale_expansion_zeroelim(cytbblen, cytbb, -adx, temp16c);
+
+    temp32alen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32a);
+    temp48len = fast_expansion_sum_zeroelim(temp16clen, temp16c, temp32alen, temp32a, temp48);
+    finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+    finswap = finnow;
+    finnow = finother;
+    finother = finswap;
+  }
+
+  if ((adxtail != 0.0) || (adytail != 0.0)) {
+    if ((bdxtail != 0.0) || (bdytail != 0.0) || (cdxtail != 0.0) || (cdytail != 0.0)) {
+      Two_Product(bdxtail, cdy, ti1, ti0);
+      Two_Product(bdx, cdytail, tj1, tj0);
+      Two_Two_Sum(ti1, ti0, tj1, tj0, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      negate = -bdy;
+      Two_Product(cdxtail, negate, ti1, ti0);
+      negate = -bdytail;
+      Two_Product(cdx, negate, tj1, tj0);
+      Two_Two_Sum(ti1, ti0, tj1, tj0, v3, v[2], v[1], v[0]);
+      v[3] = v3;
+      bctlen = fast_expansion_sum_zeroelim(4, u, 4, v, bct);
+
+      Two_Product(bdxtail, cdytail, ti1, ti0);
+      Two_Product(cdxtail, bdytail, tj1, tj0);
+      Two_Two_Diff(ti1, ti0, tj1, tj0, bctt3, bctt[2], bctt[1], bctt[0]);
+      bctt[3] = bctt3;
+      bcttlen = 4;
+    }
+    else {
+      bct[0] = 0.0;
+      bctlen = 1;
+      bctt[0] = 0.0;
+      bcttlen = 1;
+    }
+
+    if (adxtail != 0.0) {
+      temp16alen = scale_expansion_zeroelim(axtbclen, axtbc, adxtail, temp16a);
+      axtbctlen = scale_expansion_zeroelim(bctlen, bct, adxtail, axtbct);
+      temp32alen = scale_expansion_zeroelim(axtbctlen, axtbct, 2.0 * adx, temp32a);
+      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (bdytail != 0.0) {
+        temp8len = scale_expansion_zeroelim(4, cc, adxtail, temp8);
+        temp16alen = scale_expansion_zeroelim(temp8len, temp8, bdytail, temp16a);
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+      if (cdytail != 0.0) {
+        temp8len = scale_expansion_zeroelim(4, bb, -adxtail, temp8);
+        temp16alen = scale_expansion_zeroelim(temp8len, temp8, cdytail, temp16a);
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+
+      temp32alen = scale_expansion_zeroelim(axtbctlen, axtbct, adxtail, temp32a);
+      axtbcttlen = scale_expansion_zeroelim(bcttlen, bctt, adxtail, axtbctt);
+      temp16alen = scale_expansion_zeroelim(axtbcttlen, axtbctt, 2.0 * adx, temp16a);
+      temp16blen = scale_expansion_zeroelim(axtbcttlen, axtbctt, adxtail, temp16b);
+      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+    }
+    if (adytail != 0.0) {
+      temp16alen = scale_expansion_zeroelim(aytbclen, aytbc, adytail, temp16a);
+      aytbctlen = scale_expansion_zeroelim(bctlen, bct, adytail, aytbct);
+      temp32alen = scale_expansion_zeroelim(aytbctlen, aytbct, 2.0 * ady, temp32a);
+      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+
+      temp32alen = scale_expansion_zeroelim(aytbctlen, aytbct, adytail, temp32a);
+      aytbcttlen = scale_expansion_zeroelim(bcttlen, bctt, adytail, aytbctt);
+      temp16alen = scale_expansion_zeroelim(aytbcttlen, aytbctt, 2.0 * ady, temp16a);
+      temp16blen = scale_expansion_zeroelim(aytbcttlen, aytbctt, adytail, temp16b);
+      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+    }
+  }
+  if ((bdxtail != 0.0) || (bdytail != 0.0)) {
+    if ((cdxtail != 0.0) || (cdytail != 0.0) || (adxtail != 0.0) || (adytail != 0.0)) {
+      Two_Product(cdxtail, ady, ti1, ti0);
+      Two_Product(cdx, adytail, tj1, tj0);
+      Two_Two_Sum(ti1, ti0, tj1, tj0, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      negate = -cdy;
+      Two_Product(adxtail, negate, ti1, ti0);
+      negate = -cdytail;
+      Two_Product(adx, negate, tj1, tj0);
+      Two_Two_Sum(ti1, ti0, tj1, tj0, v3, v[2], v[1], v[0]);
+      v[3] = v3;
+      catlen = fast_expansion_sum_zeroelim(4, u, 4, v, cat);
+
+      Two_Product(cdxtail, adytail, ti1, ti0);
+      Two_Product(adxtail, cdytail, tj1, tj0);
+      Two_Two_Diff(ti1, ti0, tj1, tj0, catt3, catt[2], catt[1], catt[0]);
+      catt[3] = catt3;
+      cattlen = 4;
+    }
+    else {
+      cat[0] = 0.0;
+      catlen = 1;
+      catt[0] = 0.0;
+      cattlen = 1;
+    }
+
+    if (bdxtail != 0.0) {
+      temp16alen = scale_expansion_zeroelim(bxtcalen, bxtca, bdxtail, temp16a);
+      bxtcatlen = scale_expansion_zeroelim(catlen, cat, bdxtail, bxtcat);
+      temp32alen = scale_expansion_zeroelim(bxtcatlen, bxtcat, 2.0 * bdx, temp32a);
+      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (cdytail != 0.0) {
+        temp8len = scale_expansion_zeroelim(4, aa, bdxtail, temp8);
+        temp16alen = scale_expansion_zeroelim(temp8len, temp8, cdytail, temp16a);
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+      if (adytail != 0.0) {
+        temp8len = scale_expansion_zeroelim(4, cc, -bdxtail, temp8);
+        temp16alen = scale_expansion_zeroelim(temp8len, temp8, adytail, temp16a);
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+
+      temp32alen = scale_expansion_zeroelim(bxtcatlen, bxtcat, bdxtail, temp32a);
+      bxtcattlen = scale_expansion_zeroelim(cattlen, catt, bdxtail, bxtcatt);
+      temp16alen = scale_expansion_zeroelim(bxtcattlen, bxtcatt, 2.0 * bdx, temp16a);
+      temp16blen = scale_expansion_zeroelim(bxtcattlen, bxtcatt, bdxtail, temp16b);
+      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+    }
+    if (bdytail != 0.0) {
+      temp16alen = scale_expansion_zeroelim(bytcalen, bytca, bdytail, temp16a);
+      bytcatlen = scale_expansion_zeroelim(catlen, cat, bdytail, bytcat);
+      temp32alen = scale_expansion_zeroelim(bytcatlen, bytcat, 2.0 * bdy, temp32a);
+      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+
+      temp32alen = scale_expansion_zeroelim(bytcatlen, bytcat, bdytail, temp32a);
+      bytcattlen = scale_expansion_zeroelim(cattlen, catt, bdytail, bytcatt);
+      temp16alen = scale_expansion_zeroelim(bytcattlen, bytcatt, 2.0 * bdy, temp16a);
+      temp16blen = scale_expansion_zeroelim(bytcattlen, bytcatt, bdytail, temp16b);
+      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+    }
+  }
+  if ((cdxtail != 0.0) || (cdytail != 0.0)) {
+    if ((adxtail != 0.0) || (adytail != 0.0) || (bdxtail != 0.0) || (bdytail != 0.0)) {
+      Two_Product(adxtail, bdy, ti1, ti0);
+      Two_Product(adx, bdytail, tj1, tj0);
+      Two_Two_Sum(ti1, ti0, tj1, tj0, u3, u[2], u[1], u[0]);
+      u[3] = u3;
+      negate = -ady;
+      Two_Product(bdxtail, negate, ti1, ti0);
+      negate = -adytail;
+      Two_Product(bdx, negate, tj1, tj0);
+      Two_Two_Sum(ti1, ti0, tj1, tj0, v3, v[2], v[1], v[0]);
+      v[3] = v3;
+      abtlen = fast_expansion_sum_zeroelim(4, u, 4, v, abt);
+
+      Two_Product(adxtail, bdytail, ti1, ti0);
+      Two_Product(bdxtail, adytail, tj1, tj0);
+      Two_Two_Diff(ti1, ti0, tj1, tj0, abtt3, abtt[2], abtt[1], abtt[0]);
+      abtt[3] = abtt3;
+      abttlen = 4;
+    }
+    else {
+      abt[0] = 0.0;
+      abtlen = 1;
+      abtt[0] = 0.0;
+      abttlen = 1;
+    }
+
+    if (cdxtail != 0.0) {
+      temp16alen = scale_expansion_zeroelim(cxtablen, cxtab, cdxtail, temp16a);
+      cxtabtlen = scale_expansion_zeroelim(abtlen, abt, cdxtail, cxtabt);
+      temp32alen = scale_expansion_zeroelim(cxtabtlen, cxtabt, 2.0 * cdx, temp32a);
+      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+      if (adytail != 0.0) {
+        temp8len = scale_expansion_zeroelim(4, bb, cdxtail, temp8);
+        temp16alen = scale_expansion_zeroelim(temp8len, temp8, adytail, temp16a);
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+      if (bdytail != 0.0) {
+        temp8len = scale_expansion_zeroelim(4, aa, -cdxtail, temp8);
+        temp16alen = scale_expansion_zeroelim(temp8len, temp8, bdytail, temp16a);
+        finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp16alen, temp16a, finother);
+        finswap = finnow;
+        finnow = finother;
+        finother = finswap;
+      }
+
+      temp32alen = scale_expansion_zeroelim(cxtabtlen, cxtabt, cdxtail, temp32a);
+      cxtabttlen = scale_expansion_zeroelim(abttlen, abtt, cdxtail, cxtabtt);
+      temp16alen = scale_expansion_zeroelim(cxtabttlen, cxtabtt, 2.0 * cdx, temp16a);
+      temp16blen = scale_expansion_zeroelim(cxtabttlen, cxtabtt, cdxtail, temp16b);
+      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+    }
+    if (cdytail != 0.0) {
+      temp16alen = scale_expansion_zeroelim(cytablen, cytab, cdytail, temp16a);
+      cytabtlen = scale_expansion_zeroelim(abtlen, abt, cdytail, cytabt);
+      temp32alen = scale_expansion_zeroelim(cytabtlen, cytabt, 2.0 * cdy, temp32a);
+      temp48len = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp32alen, temp32a, temp48);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp48len, temp48, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+
+      temp32alen = scale_expansion_zeroelim(cytabtlen, cytabt, cdytail, temp32a);
+      cytabttlen = scale_expansion_zeroelim(abttlen, abtt, cdytail, cytabtt);
+      temp16alen = scale_expansion_zeroelim(cytabttlen, cytabtt, 2.0 * cdy, temp16a);
+      temp16blen = scale_expansion_zeroelim(cytabttlen, cytabtt, cdytail, temp16b);
+      temp32blen = fast_expansion_sum_zeroelim(temp16alen, temp16a, temp16blen, temp16b, temp32b);
+      temp64len = fast_expansion_sum_zeroelim(temp32alen, temp32a, temp32blen, temp32b, temp64);
+      finlength = fast_expansion_sum_zeroelim(finlength, finnow, temp64len, temp64, finother);
+      finswap = finnow;
+      finnow = finother;
+      finother = finswap;
+    }
+  }
+
+  return finnow[finlength - 1];
+}
+
+double incircle(const double *pa, const double *pb, const double *pc, const double *pd)
+{
+  double adx, bdx, cdx, ady, bdy, cdy;
+  double bdxcdy, cdxbdy, cdxady, adxcdy, adxbdy, bdxady;
+  double alift, blift, clift;
+  double det;
+  double permanent, errbound;
+
+  adx = pa[0] - pd[0];
+  bdx = pb[0] - pd[0];
+  cdx = pc[0] - pd[0];
+  ady = pa[1] - pd[1];
+  bdy = pb[1] - pd[1];
+  cdy = pc[1] - pd[1];
+
+  bdxcdy = bdx * cdy;
+  cdxbdy = cdx * bdy;
+  alift = adx * adx + ady * ady;
+
+  cdxady = cdx * ady;
+  adxcdy = adx * cdy;
+  blift = bdx * bdx + bdy * bdy;
+
+  adxbdy = adx * bdy;
+  bdxady = bdx * ady;
+  clift = cdx * cdx + cdy * cdy;
+
+  det = alift * (bdxcdy - cdxbdy) + blift * (cdxady - adxcdy) + clift * (adxbdy - bdxady);
+
+  permanent = (Absolute(bdxcdy) + Absolute(cdxbdy)) * alift +
+              (Absolute(cdxady) + Absolute(adxcdy)) * blift +
+              (Absolute(adxbdy) + Absolute(bdxady)) * clift;
+  errbound = iccerrboundA * permanent;
+  if ((det > errbound) || (-det > errbound)) {
+    return det;
+  }
+
+  return incircleadapt(pa, pb, pc, pd, permanent);
+}
+
+/*  inspherefast()   Approximate 3D insphere test.  Nonrobust.
+ *  insphere()   Adaptive exact 3D insphere test.  Robust.
+ *
+ *               Return a positive value if the point pe lies inside the
+ *               sphere passing through pa, pb, pc, and pd; a negative value
+ *               if it lies outside; and zero if the five points are
+ *               cospherical.  The points pa, pb, pc, and pd must be ordered
+ *               so that they have a positive orientation (as defined by
+ *               orient3d()), or the sign of the result will be reversed.
+ *
+ *  The second uses exact arithmetic to ensure a correct answer.  The
+ *  result returned is the determinant of a matrix.  In insphere() only,
+ *  this determinant is computed adaptively, in the sense that exact
+ *  arithmetic is used only to the degree it is needed to ensure that the
+ *  returned value has the correct sign.  Hence, insphere() is usually quite
+ *  fast, but will run more slowly when the input points are cospherical or
+ *  nearly so.
+ */
+
+double inspherefast(
+    const double *pa, const double *pb, const double *pc, const double *pd, const double *pe)
+{
+  double aex, bex, cex, dex;
+  double aey, bey, cey, dey;
+  double aez, bez, cez, dez;
+  double alift, blift, clift, dlift;
+  double ab, bc, cd, da, ac, bd;
+  double abc, bcd, cda, dab;
+
+  aex = pa[0] - pe[0];
+  bex = pb[0] - pe[0];
+  cex = pc[0] - pe[0];
+  dex = pd[0] - pe[0];
+  aey = pa[1] - pe[1];
+  bey = pb[1] - pe[1];
+  cey = pc[1] - pe[1];
+  dey = pd[1] - pe[1];
+  aez = pa[2] - pe[2];
+  bez = pb[2] - pe[2];
+  cez = pc[2] - pe[2];
+  dez = pd[2] - pe[2];
+
+  ab = aex * bey - bex * aey;
+  bc = bex * cey - cex * bey;
+  cd = cex * dey - dex * cey;
+  da = dex * aey - aex * dey;
+
+  ac = aex * cey - cex * aey;
+  bd = bex * dey - dex * bey;
+
+  abc = aez * bc - bez * ac + cez * ab;
+  bcd = bez * cd - cez * bd + dez * bc;
+  cda = cez * da + dez * ac + aez * cd;
+  dab = dez * ab + aez * bd + bez * da;
+
+  alift = aex * aex + aey * aey + aez * aez;
+  blift = bex * bex + bey * bey + bez * bez;
+  clift = cex * cex + cey * cey + cez * cez;
+  dlift = dex * dex + dey * dey + dez * dez;
+
+  return (dlift * abc - clift * dab) + (blift * cda - alift * bcd);
+}
+
+static double insphereexact(
+    const double *pa, const double *pb, const double *pc, const double *pd, const double *pe)
+{
+  INEXACT double axby1, bxcy1, cxdy1, dxey1, exay1;
+  INEXACT double bxay1, cxby1, dxcy1, exdy1, axey1;
+  INEXACT double axcy1, bxdy1, cxey1, dxay1, exby1;
+  INEXACT double cxay1, dxby1, excy1, axdy1, bxey1;
+  double axby0, bxcy0, cxdy0, dxey0, exay0;
+  double bxay0, cxby0, dxcy0, exdy0, axey0;
+  double axcy0, bxdy0, cxey0, dxay0, exby0;
+  double cxay0, dxby0, excy0, axdy0, bxey0;
+  double ab[4], bc[4], cd[4], de[4], ea[4];
+  double ac[4], bd[4], ce[4], da[4], eb[4];
+  double temp8a[8], temp8b[8], temp16[16];
+  int temp8alen, temp8blen, temp16len;
+  double abc[24], bcd[24], cde[24], dea[24], eab[24];
+  double abd[24], bce[24], cda[24], deb[24], eac[24];
+  int abclen, bcdlen, cdelen, dealen, eablen;
+  int abdlen, bcelen, cdalen, deblen, eaclen;
+  double temp48a[48], temp48b[48];
+  int temp48alen, temp48blen;
+  double abcd[96], bcde[96], cdea[96], deab[96], eabc[96];
+  int abcdlen, bcdelen, cdealen, deablen, eabclen;
+  double temp192[192];
+  double det384x[384], det384y[384], det384z[384];
+  int xlen, ylen, zlen;
+  double detxy[768];
+  int xylen;
+  double adet[1152], bdet[1152], cdet[1152], ddet[1152], edet[1152];
+  int alen, blen, clen, dlen, elen;
+  double abdet[2304], cddet[2304], cdedet[3456];
+  int ablen, cdlen;
+  double deter[5760];
+  int deterlen;
+  int i;
+
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  INEXACT double c;
+  INEXACT double abig;
+  double ahi, alo, bhi, blo;
+  double err1, err2, err3;
+  INEXACT double _i, _j;
+  double _0;
+
+  Two_Product(pa[0], pb[1], axby1, axby0);
+  Two_Product(pb[0], pa[1], bxay1, bxay0);
+  Two_Two_Diff(axby1, axby0, bxay1, bxay0, ab[3], ab[2], ab[1], ab[0]);
+
+  Two_Product(pb[0], pc[1], bxcy1, bxcy0);
+  Two_Product(pc[0], pb[1], cxby1, cxby0);
+  Two_Two_Diff(bxcy1, bxcy0, cxby1, cxby0, bc[3], bc[2], bc[1], bc[0]);
+
+  Two_Product(pc[0], pd[1], cxdy1, cxdy0);
+  Two_Product(pd[0], pc[1], dxcy1, dxcy0);
+  Two_Two_Diff(cxdy1, cxdy0, dxcy1, dxcy0, cd[3], cd[2], cd[1], cd[0]);
+
+  Two_Product(pd[0], pe[1], dxey1, dxey0);
+  Two_Product(pe[0], pd[1], exdy1, exdy0);
+  Two_Two_Diff(dxey1, dxey0, exdy1, exdy0, de[3], de[2], de[1], de[0]);
+
+  Two_Product(pe[0], pa[1], exay1, exay0);
+  Two_Product(pa[0], pe[1], axey1, axey0);
+  Two_Two_Diff(exay1, exay0, axey1, axey0, ea[3], ea[2], ea[1], ea[0]);
+
+  Two_Product(pa[0], pc[1], axcy1, axcy0);
+  Two_Product(pc[0], pa[1], cxay1, cxay0);
+  Two_Two_Diff(axcy1, axcy0, cxay1, cxay0, ac[3], ac[2], ac[1], ac[0]);
+
+  Two_Product(pb[0], pd[1], bxdy1, bxdy0);
+  Two_Product(pd[0], pb[1], dxby1, dxby0);
+  Two_Two_Diff(bxdy1, bxdy0, dxby1, dxby0, bd[3], bd[2], bd[1], bd[0]);
+
+  Two_Product(pc[0], pe[1], cxey1, cxey0);
+  Two_Product(pe[0], pc[1], excy1, excy0);
+  Two_Two_Diff(cxey1, cxey0, excy1, excy0, ce[3], ce[2], ce[1], ce[0]);
+
+  Two_Product(pd[0], pa[1], dxay1, dxay0);
+  Two_Product(pa[0], pd[1], axdy1, axdy0);
+  Two_Two_Diff(dxay1, dxay0, axdy1, axdy0, da[3], da[2], da[1], da[0]);
+
+  Two_Product(pe[0], pb[1], exby1, exby0);
+  Two_Product(pb[0], pe[1], bxey1, bxey0);
+  Two_Two_Diff(exby1, exby0, bxey1, bxey0, eb[3], eb[2], eb[1], eb[0]);
+
+  temp8alen = scale_expansion_zeroelim(4, bc, pa[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, ac, -pb[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, ab, pc[2], temp8a);
+  abclen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, abc);
+
+  temp8alen = scale_expansion_zeroelim(4, cd, pb[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, bd, -pc[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, bc, pd[2], temp8a);
+  bcdlen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, bcd);
+
+  temp8alen = scale_expansion_zeroelim(4, de, pc[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, ce, -pd[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, cd, pe[2], temp8a);
+  cdelen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, cde);
+
+  temp8alen = scale_expansion_zeroelim(4, ea, pd[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, da, -pe[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, de, pa[2], temp8a);
+  dealen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, dea);
+
+  temp8alen = scale_expansion_zeroelim(4, ab, pe[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, eb, -pa[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, ea, pb[2], temp8a);
+  eablen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, eab);
+
+  temp8alen = scale_expansion_zeroelim(4, bd, pa[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, da, pb[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, ab, pd[2], temp8a);
+  abdlen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, abd);
+
+  temp8alen = scale_expansion_zeroelim(4, ce, pb[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, eb, pc[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, bc, pe[2], temp8a);
+  bcelen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, bce);
+
+  temp8alen = scale_expansion_zeroelim(4, da, pc[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, ac, pd[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, cd, pa[2], temp8a);
+  cdalen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, cda);
+
+  temp8alen = scale_expansion_zeroelim(4, eb, pd[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, bd, pe[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, de, pb[2], temp8a);
+  deblen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, deb);
+
+  temp8alen = scale_expansion_zeroelim(4, ac, pe[2], temp8a);
+  temp8blen = scale_expansion_zeroelim(4, ce, pa[2], temp8b);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp8alen = scale_expansion_zeroelim(4, ea, pc[2], temp8a);
+  eaclen = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp16len, temp16, eac);
+
+  temp48alen = fast_expansion_sum_zeroelim(cdelen, cde, bcelen, bce, temp48a);
+  temp48blen = fast_expansion_sum_zeroelim(deblen, deb, bcdlen, bcd, temp48b);
+  for (i = 0; i < temp48blen; i++) {
+    temp48b[i] = -temp48b[i];
+  }
+  bcdelen = fast_expansion_sum_zeroelim(temp48alen, temp48a, temp48blen, temp48b, bcde);
+  xlen = scale_expansion_zeroelim(bcdelen, bcde, pa[0], temp192);
+  xlen = scale_expansion_zeroelim(xlen, temp192, pa[0], det384x);
+  ylen = scale_expansion_zeroelim(bcdelen, bcde, pa[1], temp192);
+  ylen = scale_expansion_zeroelim(ylen, temp192, pa[1], det384y);
+  zlen = scale_expansion_zeroelim(bcdelen, bcde, pa[2], temp192);
+  zlen = scale_expansion_zeroelim(zlen, temp192, pa[2], det384z);
+  xylen = fast_expansion_sum_zeroelim(xlen, det384x, ylen, det384y, detxy);
+  alen = fast_expansion_sum_zeroelim(xylen, detxy, zlen, det384z, adet);
+
+  temp48alen = fast_expansion_sum_zeroelim(dealen, dea, cdalen, cda, temp48a);
+  temp48blen = fast_expansion_sum_zeroelim(eaclen, eac, cdelen, cde, temp48b);
+  for (i = 0; i < temp48blen; i++) {
+    temp48b[i] = -temp48b[i];
+  }
+  cdealen = fast_expansion_sum_zeroelim(temp48alen, temp48a, temp48blen, temp48b, cdea);
+  xlen = scale_expansion_zeroelim(cdealen, cdea, pb[0], temp192);
+  xlen = scale_expansion_zeroelim(xlen, temp192, pb[0], det384x);
+  ylen = scale_expansion_zeroelim(cdealen, cdea, pb[1], temp192);
+  ylen = scale_expansion_zeroelim(ylen, temp192, pb[1], det384y);
+  zlen = scale_expansion_zeroelim(cdealen, cdea, pb[2], temp192);
+  zlen = scale_expansion_zeroelim(zlen, temp192, pb[2], det384z);
+  xylen = fast_expansion_sum_zeroelim(xlen, det384x, ylen, det384y, detxy);
+  blen = fast_expansion_sum_zeroelim(xylen, detxy, zlen, det384z, bdet);
+
+  temp48alen = fast_expansion_sum_zeroelim(eablen, eab, deblen, deb, temp48a);
+  temp48blen = fast_expansion_sum_zeroelim(abdlen, abd, dealen, dea, temp48b);
+  for (i = 0; i < temp48blen; i++) {
+    temp48b[i] = -temp48b[i];
+  }
+  deablen = fast_expansion_sum_zeroelim(temp48alen, temp48a, temp48blen, temp48b, deab);
+  xlen = scale_expansion_zeroelim(deablen, deab, pc[0], temp192);
+  xlen = scale_expansion_zeroelim(xlen, temp192, pc[0], det384x);
+  ylen = scale_expansion_zeroelim(deablen, deab, pc[1], temp192);
+  ylen = scale_expansion_zeroelim(ylen, temp192, pc[1], det384y);
+  zlen = scale_expansion_zeroelim(deablen, deab, pc[2], temp192);
+  zlen = scale_expansion_zeroelim(zlen, temp192, pc[2], det384z);
+  xylen = fast_expansion_sum_zeroelim(xlen, det384x, ylen, det384y, detxy);
+  clen = fast_expansion_sum_zeroelim(xylen, detxy, zlen, det384z, cdet);
+
+  temp48alen = fast_expansion_sum_zeroelim(abclen, abc, eaclen, eac, temp48a);
+  temp48blen = fast_expansion_sum_zeroelim(bcelen, bce, eablen, eab, temp48b);
+  for (i = 0; i < temp48blen; i++) {
+    temp48b[i] = -temp48b[i];
+  }
+  eabclen = fast_expansion_sum_zeroelim(temp48alen, temp48a, temp48blen, temp48b, eabc);
+  xlen = scale_expansion_zeroelim(eabclen, eabc, pd[0], temp192);
+  xlen = scale_expansion_zeroelim(xlen, temp192, pd[0], det384x);
+  ylen = scale_expansion_zeroelim(eabclen, eabc, pd[1], temp192);
+  ylen = scale_expansion_zeroelim(ylen, temp192, pd[1], det384y);
+  zlen = scale_expansion_zeroelim(eabclen, eabc, pd[2], temp192);
+  zlen = scale_expansion_zeroelim(zlen, temp192, pd[2], det384z);
+  xylen = fast_expansion_sum_zeroelim(xlen, det384x, ylen, det384y, detxy);
+  dlen = fast_expansion_sum_zeroelim(xylen, detxy, zlen, det384z, ddet);
+
+  temp48alen = fast_expansion_sum_zeroelim(bcdlen, bcd, abdlen, abd, temp48a);
+  temp48blen = fast_expansion_sum_zeroelim(cdalen, cda, abclen, abc, temp48b);
+  for (i = 0; i < temp48blen; i++) {
+    temp48b[i] = -temp48b[i];
+  }
+  abcdlen = fast_expansion_sum_zeroelim(temp48alen, temp48a, temp48blen, temp48b, abcd);
+  xlen = scale_expansion_zeroelim(abcdlen, abcd, pe[0], temp192);
+  xlen = scale_expansion_zeroelim(xlen, temp192, pe[0], det384x);
+  ylen = scale_expansion_zeroelim(abcdlen, abcd, pe[1], temp192);
+  ylen = scale_expansion_zeroelim(ylen, temp192, pe[1], det384y);
+  zlen = scale_expansion_zeroelim(abcdlen, abcd, pe[2], temp192);
+  zlen = scale_expansion_zeroelim(zlen, temp192, pe[2], det384z);
+  xylen = fast_expansion_sum_zeroelim(xlen, det384x, ylen, det384y, detxy);
+  elen = fast_expansion_sum_zeroelim(xylen, detxy, zlen, det384z, edet);
+
+  ablen = fast_expansion_sum_zeroelim(alen, adet, blen, bdet, abdet);
+  cdlen = fast_expansion_sum_zeroelim(clen, cdet, dlen, ddet, cddet);
+  cdelen = fast_expansion_sum_zeroelim(cdlen, cddet, elen, edet, cdedet);
+  deterlen = fast_expansion_sum_zeroelim(ablen, abdet, cdelen, cdedet, deter);
+
+  return deter[deterlen - 1];
+}
+
+static double insphereadapt(const double *pa,
+                            const double *pb,
+                            const double *pc,
+                            const double *pd,
+                            const double *pe,
+                            double permanent)
+{
+  INEXACT double aex, bex, cex, dex, aey, bey, cey, dey, aez, bez, cez, dez;
+  double det, errbound;
+
+  INEXACT double aexbey1, bexaey1, bexcey1, cexbey1;
+  INEXACT double cexdey1, dexcey1, dexaey1, aexdey1;
+  INEXACT double aexcey1, cexaey1, bexdey1, dexbey1;
+  double aexbey0, bexaey0, bexcey0, cexbey0;
+  double cexdey0, dexcey0, dexaey0, aexdey0;
+  double aexcey0, cexaey0, bexdey0, dexbey0;
+  double ab[4], bc[4], cd[4], da[4], ac[4], bd[4];
+  INEXACT double ab3, bc3, cd3, da3, ac3, bd3;
+  double abeps, bceps, cdeps, daeps, aceps, bdeps;
+  double temp8a[8], temp8b[8], temp8c[8], temp16[16], temp24[24], temp48[48];
+  int temp8alen, temp8blen, temp8clen, temp16len, temp24len, temp48len;
+  double xdet[96], ydet[96], zdet[96], xydet[192];
+  int xlen, ylen, zlen, xylen;
+  double adet[288], bdet[288], cdet[288], ddet[288];
+  int alen, blen, clen, dlen;
+  double abdet[576], cddet[576];
+  int ablen, cdlen;
+  double fin1[1152];
+  int finlength;
+
+  double aextail, bextail, cextail, dextail;
+  double aeytail, beytail, ceytail, deytail;
+  double aeztail, beztail, ceztail, deztail;
+
+  INEXACT double bvirt;
+  double avirt, bround, around;
+  INEXACT double c;
+  INEXACT double abig;
+  double ahi, alo, bhi, blo;
+  double err1, err2, err3;
+  INEXACT double _i, _j;
+  double _0;
+
+  aex = (double)(pa[0] - pe[0]);
+  bex = (double)(pb[0] - pe[0]);
+  cex = (double)(pc[0] - pe[0]);
+  dex = (double)(pd[0] - pe[0]);
+  aey = (double)(pa[1] - pe[1]);
+  bey = (double)(pb[1] - pe[1]);
+  cey = (double)(pc[1] - pe[1]);
+  dey = (double)(pd[1] - pe[1]);
+  aez = (double)(pa[2] - pe[2]);
+  bez = (double)(pb[2] - pe[2]);
+  cez = (double)(pc[2] - pe[2]);
+  dez = (double)(pd[2] - pe[2]);
+
+  Two_Product(aex, bey, aexbey1, aexbey0);
+  Two_Product(bex, aey, bexaey1, bexaey0);
+  Two_Two_Diff(aexbey1, aexbey0, bexaey1, bexaey0, ab3, ab[2], ab[1], ab[0]);
+  ab[3] = ab3;
+
+  Two_Product(bex, cey, bexcey1, bexcey0);
+  Two_Product(cex, bey, cexbey1, cexbey0);
+  Two_Two_Diff(bexcey1, bexcey0, cexbey1, cexbey0, bc3, bc[2], bc[1], bc[0]);
+  bc[3] = bc3;
+
+  Two_Product(cex, dey, cexdey1, cexdey0);
+  Two_Product(dex, cey, dexcey1, dexcey0);
+  Two_Two_Diff(cexdey1, cexdey0, dexcey1, dexcey0, cd3, cd[2], cd[1], cd[0]);
+  cd[3] = cd3;
+
+  Two_Product(dex, aey, dexaey1, dexaey0);
+  Two_Product(aex, dey, aexdey1, aexdey0);
+  Two_Two_Diff(dexaey1, dexaey0, aexdey1, aexdey0, da3, da[2], da[1], da[0]);
+  da[3] = da3;
+
+  Two_Product(aex, cey, aexcey1, aexcey0);
+  Two_Product(cex, aey, cexaey1, cexaey0);
+  Two_Two_Diff(aexcey1, aexcey0, cexaey1, cexaey0, ac3, ac[2], ac[1], ac[0]);
+  ac[3] = ac3;
+
+  Two_Product(bex, dey, bexdey1, bexdey0);
+  Two_Product(dex, bey, dexbey1, dexbey0);
+  Two_Two_Diff(bexdey1, bexdey0, dexbey1, dexbey0, bd3, bd[2], bd[1], bd[0]);
+  bd[3] = bd3;
+
+  temp8alen = scale_expansion_zeroelim(4, cd, bez, temp8a);
+  temp8blen = scale_expansion_zeroelim(4, bd, -cez, temp8b);
+  temp8clen = scale_expansion_zeroelim(4, bc, dez, temp8c);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp24len = fast_expansion_sum_zeroelim(temp8clen, temp8c, temp16len, temp16, temp24);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, aex, temp48);
+  xlen = scale_expansion_zeroelim(temp48len, temp48, -aex, xdet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, aey, temp48);
+  ylen = scale_expansion_zeroelim(temp48len, temp48, -aey, ydet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, aez, temp48);
+  zlen = scale_expansion_zeroelim(temp48len, temp48, -aez, zdet);
+  xylen = fast_expansion_sum_zeroelim(xlen, xdet, ylen, ydet, xydet);
+  alen = fast_expansion_sum_zeroelim(xylen, xydet, zlen, zdet, adet);
+
+  temp8alen = scale_expansion_zeroelim(4, da, cez, temp8a);
+  temp8blen = scale_expansion_zeroelim(4, ac, dez, temp8b);
+  temp8clen = scale_expansion_zeroelim(4, cd, aez, temp8c);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp24len = fast_expansion_sum_zeroelim(temp8clen, temp8c, temp16len, temp16, temp24);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, bex, temp48);
+  xlen = scale_expansion_zeroelim(temp48len, temp48, bex, xdet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, bey, temp48);
+  ylen = scale_expansion_zeroelim(temp48len, temp48, bey, ydet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, bez, temp48);
+  zlen = scale_expansion_zeroelim(temp48len, temp48, bez, zdet);
+  xylen = fast_expansion_sum_zeroelim(xlen, xdet, ylen, ydet, xydet);
+  blen = fast_expansion_sum_zeroelim(xylen, xydet, zlen, zdet, bdet);
+
+  temp8alen = scale_expansion_zeroelim(4, ab, dez, temp8a);
+  temp8blen = scale_expansion_zeroelim(4, bd, aez, temp8b);
+  temp8clen = scale_expansion_zeroelim(4, da, bez, temp8c);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp24len = fast_expansion_sum_zeroelim(temp8clen, temp8c, temp16len, temp16, temp24);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, cex, temp48);
+  xlen = scale_expansion_zeroelim(temp48len, temp48, -cex, xdet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, cey, temp48);
+  ylen = scale_expansion_zeroelim(temp48len, temp48, -cey, ydet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, cez, temp48);
+  zlen = scale_expansion_zeroelim(temp48len, temp48, -cez, zdet);
+  xylen = fast_expansion_sum_zeroelim(xlen, xdet, ylen, ydet, xydet);
+  clen = fast_expansion_sum_zeroelim(xylen, xydet, zlen, zdet, cdet);
+
+  temp8alen = scale_expansion_zeroelim(4, bc, aez, temp8a);
+  temp8blen = scale_expansion_zeroelim(4, ac, -bez, temp8b);
+  temp8clen = scale_expansion_zeroelim(4, ab, cez, temp8c);
+  temp16len = fast_expansion_sum_zeroelim(temp8alen, temp8a, temp8blen, temp8b, temp16);
+  temp24len = fast_expansion_sum_zeroelim(temp8clen, temp8c, temp16len, temp16, temp24);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, dex, temp48);
+  xlen = scale_expansion_zeroelim(temp48len, temp48, dex, xdet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, dey, temp48);
+  ylen = scale_expansion_zeroelim(temp48len, temp48, dey, ydet);
+  temp48len = scale_expansion_zeroelim(temp24len, temp24, dez, temp48);
+  zlen = scale_expansion_zeroelim(temp48len, temp48, dez, zdet);
+  xylen = fast_expansion_sum_zeroelim(xlen, xdet, ylen, ydet, xydet);
+  dlen = fast_expansion_sum_zeroelim(xylen, xydet, zlen, zdet, ddet);
+
+  ablen = fast_expansion_sum_zeroelim(alen, adet, blen, bdet, abdet);
+  cdlen = fast_expansion_sum_zeroelim(clen, cdet, dlen, ddet, cddet);
+  finlength = fast_expansion_sum_zeroelim(ablen, abdet, cdlen, cddet, fin1);
+
+  det = estimate(finlength, fin1);
+  errbound = isperrboundB * permanent;
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  Two_Diff_Tail(pa[0], pe[0], aex, aextail);
+  Two_Diff_Tail(pa[1], pe[1], aey, aeytail);
+  Two_Diff_Tail(pa[2], pe[2], aez, aeztail);
+  Two_Diff_Tail(pb[0], pe[0], bex, bextail);
+  Two_Diff_Tail(pb[1], pe[1], bey, beytail);
+  Two_Diff_Tail(pb[2], pe[2], bez, beztail);
+  Two_Diff_Tail(pc[0], pe[0], cex, cextail);
+  Two_Diff_Tail(pc[1], pe[1], cey, ceytail);
+  Two_Diff_Tail(pc[2], pe[2], cez, ceztail);
+  Two_Diff_Tail(pd[0], pe[0], dex, dextail);
+  Two_Diff_Tail(pd[1], pe[1], dey, deytail);
+  Two_Diff_Tail(pd[2], pe[2], dez, deztail);
+  if ((aextail == 0.0) && (aeytail == 0.0) && (aeztail == 0.0) && (bextail == 0.0) &&
+      (beytail == 0.0) && (beztail == 0.0) && (cextail == 0.0) && (ceytail == 0.0) &&
+      (ceztail == 0.0) && (dextail == 0.0) && (deytail == 0.0) && (deztail == 0.0)) {
+    return det;
+  }
+
+  errbound = isperrboundC * permanent + resulterrbound * Absolute(det);
+  abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);
+  bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);
+  cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);
+  daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);
+  aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);
+  bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);
+  det +=
+      (((bex * bex + bey * bey + bez * bez) * ((cez * daeps + dez * aceps + aez * cdeps) +
+                                               (ceztail * da3 + deztail * ac3 + aeztail * cd3)) +
+        (dex * dex + dey * dey + dez * dez) * ((aez * bceps - bez * aceps + cez * abeps) +
+                                               (aeztail * bc3 - beztail * ac3 + ceztail * ab3))) -
+       ((aex * aex + aey * aey + aez * aez) * ((bez * cdeps - cez * bdeps + dez * bceps) +
+                                               (beztail * cd3 - ceztail * bd3 + deztail * bc3)) +
+        (cex * cex + cey * cey + cez * cez) * ((dez * abeps + aez * bdeps + bez * daeps) +
+                                               (deztail * ab3 + aeztail * bd3 + beztail * da3)))) +
+      2.0 *
+          (((bex * bextail + bey * beytail + bez * beztail) * (cez * da3 + dez * ac3 + aez * cd3) +
+            (dex * dextail + dey * deytail + dez * deztail) *
+                (aez * bc3 - bez * ac3 + cez * ab3)) -
+           ((aex * aextail + aey * aeytail + aez * aeztail) * (bez * cd3 - cez * bd3 + dez * bc3) +
+            (cex * cextail + cey * ceytail + cez * ceztail) *
+                (dez * ab3 + aez * bd3 + bez * da3)));
+  if ((det >= errbound) || (-det >= errbound)) {
+    return det;
+  }
+
+  return insphereexact(pa, pb, pc, pd, pe);
+}
+
+double insphere(
+    const double *pa, const double *pb, const double *pc, const double *pd, const double *pe)
+{
+  double aex, bex, cex, dex;
+  double aey, bey, cey, dey;
+  double aez, bez, cez, dez;
+  double aexbey, bexaey, bexcey, cexbey, cexdey, dexcey, dexaey, aexdey;
+  double aexcey, cexaey, bexdey, dexbey;
+  double alift, blift, clift, dlift;
+  double ab, bc, cd, da, ac, bd;
+  double abc, bcd, cda, dab;
+  double aezplus, bezplus, cezplus, dezplus;
+  double aexbeyplus, bexaeyplus, bexceyplus, cexbeyplus;
+  double cexdeyplus, dexceyplus, dexaeyplus, aexdeyplus;
+  double aexceyplus, cexaeyplus, bexdeyplus, dexbeyplus;
+  double det;
+  double permanent, errbound;
+
+  aex = pa[0] - pe[0];
+  bex = pb[0] - pe[0];
+  cex = pc[0] - pe[0];
+  dex = pd[0] - pe[0];
+  aey = pa[1] - pe[1];
+  bey = pb[1] - pe[1];
+  cey = pc[1] - pe[1];
+  dey = pd[1] - pe[1];
+  aez = pa[2] - pe[2];
+  bez = pb[2] - pe[2];
+  cez = pc[2] - pe[2];
+  dez = pd[2] - pe[2];
+
+  aexbey = aex * bey;
+  bexaey = bex * aey;
+  ab = aexbey - bexaey;
+  bexcey = bex * cey;
+  cexbey = cex * bey;
+  bc = bexcey - cexbey;
+  cexdey = cex * dey;
+  dexcey = dex * cey;
+  cd = cexdey - dexcey;
+  dexaey = dex * aey;
+  aexdey = aex * dey;
+  da = dexaey - aexdey;
+
+  aexcey = aex * cey;
+  cexaey = cex * aey;
+  ac = aexcey - cexaey;
+  bexdey = bex * dey;
+  dexbey = dex * bey;
+  bd = bexdey - dexbey;
+
+  abc = aez * bc - bez * ac + cez * ab;
+  bcd = bez * cd - cez * bd + dez * bc;
+  cda = cez * da + dez * ac + aez * cd;
+  dab = dez * ab + aez * bd + bez * da;
+
+  alift = aex * aex + aey * aey + aez * aez;
+  blift = bex * bex + bey * bey + bez * bez;
+  clift = cex * cex + cey * cey + cez * cez;
+  dlift = dex * dex + dey * dey + dez * dez;
+
+  det = (dlift * abc - clift * dab) + (blift * cda - alift * bcd);
+
+  aezplus = Absolute(aez);
+  bezplus = Absolute(bez);
+  cezplus = Absolute(cez);
+  dezplus = Absolute(dez);
+  aexbeyplus = Absolute(aexbey);
+  bexaeyplus = Absolute(bexaey);
+  bexceyplus = Absolute(bexcey);
+  cexbeyplus = Absolute(cexbey);
+  cexdeyplus = Absolute(cexdey);
+  dexceyplus = Absolute(dexcey);
+  dexaeyplus = Absolute(dexaey);
+  aexdeyplus = Absolute(aexdey);
+  aexceyplus = Absolute(aexcey);
+  cexaeyplus = Absolute(cexaey);
+  bexdeyplus = Absolute(bexdey);
+  dexbeyplus = Absolute(dexbey);
+  permanent = ((cexdeyplus + dexceyplus) * bezplus + (dexbeyplus + bexdeyplus) * cezplus +
+               (bexceyplus + cexbeyplus) * dezplus) *
+                  alift +
+              ((dexaeyplus + aexdeyplus) * cezplus + (aexceyplus + cexaeyplus) * dezplus +
+               (cexdeyplus + dexceyplus) * aezplus) *
+                  blift +
+              ((aexbeyplus + bexaeyplus) * dezplus + (bexdeyplus + dexbeyplus) * aezplus +
+               (dexaeyplus + aexdeyplus) * bezplus) *
+                  clift +
+              ((bexceyplus + cexbeyplus) * aezplus + (cexaeyplus + aexceyplus) * bezplus +
+               (aexbeyplus + bexaeyplus) * cezplus) *
+                  dlift;
+  errbound = isperrboundA * permanent;
+  if ((det > errbound) || (-det > errbound)) {
+    return det;
+  }
+
+  return insphereadapt(pa, pb, pc, pd, pe, permanent);
+}
+
+} /* namespace robust_pred */
+
+static int sgn(double x)
+{
+  return (x > 0) ? 1 : ((x < 0) ? -1 : 0);
+}
+
+int double2::orient2d(const double2 &a, const double2 &b, const double2 &c)
+{
+  return sgn(BLI::robust_pred::orient2d(a, b, c));
+}
+
+int double2::orient2d_fast(const double2 &a, const double2 &b, const double2 &c)
+{
+  return sgn(BLI::robust_pred::orient2dfast(a, b, c));
+}
+
+int double2::incircle(const double2 &a, const double2 &b, const double2 &c, const double2 &d)
+{
+  return sgn(robust_pred::incircle(a, b, c, d));
+}
+
+int double2::incircle_fast(const double2 &a, const double2 &b, const double2 &c, const double2 &d)
+{
+  return sgn(robust_pred::incirclefast(a, b, c, d));
+}
+
+int double3::orient3d(const double3 &a, const double3 &b, const double3 &c, const double3 &d)
+{
+  return sgn(robust_pred::orient3d(a, b, c, d));
+}
+
+int double3::orient3d_fast(const double3 &a, const double3 &b, const double3 &c, const double3 &d)
+{
+  return sgn(robust_pred::orient3dfast(a, b, c, d));
+}
+
+int double3::insphere(
+    const double3 &a, const double3 &b, const double3 &c, const double3 &d, const double3 &e)
+{
+  return sgn(robust_pred::insphere(a, b, c, d, e));
+}
+
+int double3::insphere_fast(
+    const double3 &a, const double3 &b, const double3 &c, const double3 &d, const double3 &e)
+{
+  return sgn(robust_pred::inspherefast(a, b, c, d, e));
+}
+
+}  // namespace BLI
diff --git a/source/blender/blenlib/intern/math_vector.c b/source/blender/blenlib/intern/math_vector.c
index 9439d0890b5..6df93efd3d7 100644
--- a/source/blender/blenlib/intern/math_vector.c
+++ b/source/blender/blenlib/intern/math_vector.c
@@ -745,16 +745,6 @@ void project_plane_normalized_v3_v3v3(float out[3], const float p[3], const floa
   out[2] = p[2] - (mul * v_plane[2]);
 }
 
-void project_plane_normalized_v3_v3v3_db(double out[3], const double p[3], const double v_plane[3])
-{
-  BLI_ASSERT_UNIT_V3_DB(v_plane);
-  const double mul = dot_v3v3_db(p, v_plane);
-
-  out[0] = p[0] - (mul * v_plane[0]);
-  out[1] = p[1] - (mul * v_plane[1]);
-  out[2] = p[2] - (mul * v_plane[2]);
-}
-
 void project_plane_normalized_v2_v2v2(float out[2], const float p[2], const float v_plane[2])
 {
   BLI_ASSERT_UNIT_V2(v_plane);
@@ -817,6 +807,17 @@ void reflect_v3_v3v3(float out[3], const float v[3], const float normal[3])
   out[2] = v[2] - (dot2 * normal[2]);
 }
 
+void reflect_v3_v3v3_db(double out[3], const double v[3], const double normal[3])
+{
+  const double dot2 = 2.0 * dot_v3v3_db(v, normal);
+
+  BLI_ASSERT_UNIT_V3_DB(normal);
+
+  out[0] = v[0] - (dot2 * normal[0]);
+  out[1] = v[1] - (dot2 * normal[1]);
+  out[2] = v[2] - (dot2 * normal[2]);
+}
+
 /**
  * Takes a vector and computes 2 orthogonal directions.
  *
@@ -847,31 +848,6 @@ void ortho_basis_v3v3_v3(float r_n1[3], float r_n2[3], const float n[3])
   }
 }
 
-void ortho_basis_v3v3_v3_db(double r_n1[3], double r_n2[3], const double n[3])
-{
-  const double eps = FLT_EPSILON;
-  const double f = len_squared_v2_db(n);
-
-  if (f > eps) {
-    const double d = 1.0 / sqrt(f);
-
-    BLI_assert(isfinite(d));
-
-    r_n1[0] = n[1] * d;
-    r_n1[1] = -n[0] * d;
-    r_n1[2] = 0.0;
-    r_n2[0] = -n[2] * r_n1[1];
-    r_n2[1] = n[2] * r_n1[0];
-    r_n2[2] = n[0] * r_n1[1] - n[1] * r_n1[0];
-  }
-  else {
-    /* degenerate case */
-    r_n1[0] = (n[2] < 0.0f) ? -1.0f : 1.0f;
-    r_n1[1] = r_n1[2] = r_n2[0] = r_n2[2] = 0.0f;
-    r_n2[1] = 1.0;
-  }
-}
-
 /**
  * Calculates \a p - a perpendicular vector to \a v
  *
diff --git a/source/blender/blenlib/intern/math_vector_inline.c b/source/blender/blenlib/intern/math_vector_inline.c
index dd4a7972c54..c5d4878bbc5 100644
--- a/source/blender/blenlib/intern/math_vector_inline.c
+++ b/source/blender/blenlib/intern/math_vector_inline.c
@@ -232,21 +232,6 @@ MINLINE void zero_v3_db(double r[3])
   r[2] = 0.0;
 }
 
-MINLINE void zero_v4_db(double r[4])
-{
-  r[0] = 0.0;
-  r[1] = 0.0;
-  r[2] = 0.0;
-  r[3] = 0.0;
-}
-
-MINLINE void copy_v3_db(double r[3], double d)
-{
-  r[0] = d;
-  r[1] = d;
-  r[2] = d;
-}
-
 MINLINE void copy_v2_v2_db(double r[2], const double a[2])
 {
   r[0] = a[0];
@@ -442,13 +427,6 @@ MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
   r[2] = a[2] + b[2];
 }
 
-MINLINE void add_v3_v3v3_db(double r[3], const double a[3], const double b[3])
-{
-  r[0] = a[0] + b[0];
-  r[1] = a[1] + b[1];
-  r[2] = a[2] + b[2];
-}
-
 MINLINE void add_v3fl_v3fl_v3i(float r[3], const float a[3], const int b[3])
 {
   r[0] = a[0] + (float)b[0];
@@ -587,7 +565,7 @@ MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
   r[2] = a[2] * f;
 }
 
-MINLINE void mul_v3db_v3dbdb(double r[3], const double a[3], double f)
+MINLINE void mul_v3_v3db_db(double r[3], const double a[3], double f)
 {
   r[0] = a[0] * f;
   r[1] = a[1] * f;
@@ -719,13 +697,6 @@ MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
   r[2] += a[2] * f;
 }
 
-MINLINE void madd_v3db_v3dbdb(double r[3], const double a[3], double f)
-{
-  r[0] += a[0] * f;
-  r[1] += a[1] * f;
-  r[2] += a[2] * f;
-}
-
 MINLINE void madd_v3_v3v3(float r[3], const float a[3], const float b[3])
 {
   r[0] += a[0] * b[0];
@@ -733,13 +704,6 @@ MINLINE void madd_v3_v3v3(float r[3], const float a[3], const float b[3])
   r[2] += a[2] * b[2];
 }
 
-MINLINE void madd_v3_v3v3_db(double r[3], const double a[3], const double b[3])
-{
-  r[0] += a[0] * b[0];
-  r[1] += a[1] * b[1];
-  r[2] += a[2] * b[2];
-}
-
 MINLINE void madd_v2_v2v2fl(float r[2], const float a[2], const float b[2], float f)
 {
   r[0] = a[0] + b[0] * f;
@@ -753,13 +717,6 @@ MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], floa
   r[2] = a[2] + b[2] * f;
 }
 
-MINLINE void madd_v3_v3v3db_db(double r[3], const double a[3], const double b[3], double f)
-{
-  r[0] = a[0] + b[0] * f;
-  r[1] = a[1] + b[1] * f;
-  r[2] = a[2] + b[2] * f;
-}
-
 MINLINE void madd_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
 {
   r[0] = a[0] + b[0] * c[0];
@@ -1022,11 +979,6 @@ MINLINE float len_squared_v2(const float v[2])
   return v[0] * v[0] + v[1] * v[1];
 }
 
-MINLINE double len_squared_v2_db(const double v[2])
-{
-  return v[0] * v[0] + v[1] * v[1];
-}
-
 MINLINE float len_squared_v3(const float v[3])
 {
   return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
@@ -1057,6 +1009,11 @@ MINLINE float len_v2(const float v[2])
   return sqrtf(v[0] * v[0] + v[1] * v[1]);
 }
 
+MINLINE double len_v2_db(const double v[2])
+{
+  return sqrt(v[0] * v[0] + v[1] * v[1]);
+}
+
 MINLINE float len_v2v2(const float v1[2], const float v2[2])
 {
   float x, y;
@@ -1118,14 +1075,6 @@ MINLINE float len_squared_v3v3(const float a[3], const float b[3])
   return dot_v3v3(d, d);
 }
 
-MINLINE double len_squared_v3v3_db(const double a[3], const double b[3])
-{
-  double d[3];
-
-  sub_v3_v3v3_db(d, b, a);
-  return dot_v3v3_db(d, d);
-}
-
 MINLINE float len_squared_v4v4(const float a[4], const float b[4])
 {
   float d[4];
@@ -1166,14 +1115,6 @@ MINLINE float len_v3v3(const float a[3], const float b[3])
   return len_v3(d);
 }
 
-MINLINE double len_v3v3_db(const double a[3], const double b[3])
-{
-  double d[3];
-
-  sub_v3_v3v3_db(d, b, a);
-  return len_v3_db(d);
-}
-
 MINLINE float normalize_v2_v2_length(float r[2], const float a[2], const float unit_length)
 {
   float d = dot_v2v2(a, a);
@@ -1226,7 +1167,29 @@ MINLINE float normalize_v3_v3(float r[3], const float a[3])
   return normalize_v3_v3_length(r, a, 1.0f);
 }
 
-MINLINE double normalize_v3_length_d(double n[3], const double unit_length)
+MINLINE double normalize_v3_v3_length_db(double r[3], const double a[3], double unit_length)
+{
+  double d = dot_v3v3_db(a, a);
+
+  /* a larger value causes normalize errors in a
+   * scaled down models with camera extreme close */
+  if (d > 1.0e-70) {
+    d = sqrt(d);
+    mul_v3_v3db_db(r, a, unit_length / d);
+  }
+  else {
+    zero_v3_db(r);
+    d = 0.0;
+  }
+
+  return d;
+}
+MINLINE double normalize_v3_v3_db(double r[3], const double a[3])
+{
+  return normalize_v3_v3_length_db(r, a, 1.0);
+}
+
+MINLINE double normalize_v3_length_db(double n[3], const double unit_length)
 {
   double d = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
 
@@ -1249,9 +1212,9 @@ MINLINE double normalize_v3_length_d(double n[3], const double unit_length)
 
   return d;
 }
-MINLINE double normalize_v3_d(double n[3])
+MINLINE double normalize_v3_db(double n[3])
 {
-  return normalize_v3_length_d(n, 1.0);
+  return normalize_v3_length_db(n, 1.0);
 }
 
 MINLINE float normalize_v3_length(float n[3], const float unit_length)
@@ -1350,12 +1313,6 @@ MINLINE bool compare_v3v3(const float v1[3], const float v2[3], const float limi
           compare_ff(v1[2], v2[2], limit));
 }
 
-MINLINE bool compare_v3v3_db(const double v1[3], const double v2[3], const double limit)
-{
-  return (compare_dd(v1[0], v2[0], limit) && compare_dd(v1[1], v2[1], limit) &&
-          compare_dd(v1[2], v2[2], limit));
-}
-
 MINLINE bool compare_v4v4(const float v1[4], const float v2[4], const float limit)
 {
   return (compare_ff(v1[0], v2[0], limit) && compare_ff(v1[1], v2[1], limit) &&
@@ -1463,11 +1420,6 @@ MINLINE float line_point_side_v2(const float l1[2], const float l2[2], const flo
   return (((l1[0] - pt[0]) * (l2[1] - pt[1])) - ((l2[0] - pt[0]) * (l1[1] - pt[1])));
 }
 
-MINLINE double line_point_side_v2_db(const double l1[2], const double l2[2], const double pt[2])
-{
-  return (((l1[0] - pt[0]) * (l2[1] - pt[1])) - ((l2[0] - pt[0]) * (l1[1] - pt[1])));
-}
-
 /** \} */
 
 #endif /* __MATH_VECTOR_INLINE_C__ */
diff --git a/source/blender/blenlib/intern/mesh_intersect.cc b/source/blender/blenlib/intern/mesh_intersect.cc
new file mode 100644
index 00000000000..e168aa04f65
--- /dev/null
+++ b/source/blender/blenlib/intern/mesh_intersect.cc
@@ -0,0 +1,1655 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include <fstream>
+#include <iostream>
+
+#include "BLI_allocator.hh"
+#include "BLI_array.hh"
+#include "BLI_array_ref.hh"
+#include "BLI_assert.h"
+#include "BLI_delaunay_2d.h"
+#include "BLI_double3.hh"
+#include "BLI_hash.hh"
+#include "BLI_map.hh"
+#include "BLI_mpq2.hh"
+#include "BLI_mpq3.hh"
+#include "BLI_vector.hh"
+#include "BLI_vector_set.hh"
+
+#include "BLI_mesh_intersect.hh"
+
+namespace BLI {
+namespace MeshIntersect {
+
+/* A plane whose equation is dot(n, p) + d = 0. */
+struct planeq {
+  mpq3 n;
+  mpq_class d;
+
+  planeq() = default;
+
+  planeq(mpq3 n, mpq_class d) : n(n), d(d)
+  {
+  }
+
+  operator const mpq_class *() const
+  {
+    return &n.x;
+  }
+
+  operator mpq_class *()
+  {
+    return &n.x;
+  }
+};
+
+/* A Triangle mesh but with a different structure to hold vertices, so that
+ * we can dedup them efficiently.
+ * Also optionally keeps the planeqs of the triangles, as those are needed sometimes.
+ */
+class TMesh {
+ public:
+  TMesh() : m_has_planes(false)
+  {
+  }
+
+  /* Copies verts and triangles from tm_in, but dedups the vertices
+   * and ignores degenerate and invalid triangles.
+   * If want_planes is true, calculate and store the planes for each triangle.
+   */
+  TMesh(const TriMesh &tm_in, bool want_planes)
+  {
+    int nvert = static_cast<int>(tm_in.vert.size());
+    this->m_verts.reserve(nvert);
+    Array<int> input_v_to_tm_v = Array<int>(nvert); /* Input vert index -> our vert index. */
+    for (int v = 0; v < nvert; ++v) {
+      const mpq3 &co = tm_in.vert[v];
+      int tmv = this->add_vert(co);
+      input_v_to_tm_v[v] = tmv;
+    }
+    int ntri = static_cast<int>(tm_in.tri.size());
+    this->m_tris.reserve(ntri);
+    for (int t = 0; t < ntri; ++t) {
+      const IndexedTriangle &tri = tm_in.tri[t];
+      int v0 = tri.v0();
+      int v1 = tri.v1();
+      int v2 = tri.v2();
+      int orig = tri.orig();
+      if (orig == -1) {
+        orig = t;
+      }
+      if (v0 == v1 || v0 == v2 || v1 == v2 || v0 < 0 || v0 >= nvert || v1 < 0 || v1 >= nvert ||
+          v2 < 0 || v2 >= nvert) {
+        /* Skip degenerate triangle and ones with invalid indices. */
+        /* TODO: test for collinear v0, v1, v2 and skip if so, too. */
+        continue;
+      }
+      int tmv0 = input_v_to_tm_v[v0];
+      int tmv1 = input_v_to_tm_v[v1];
+      int tmv2 = input_v_to_tm_v[v2];
+      this->m_tris.append(IndexedTriangle(tmv0, tmv1, tmv2, orig));
+    }
+    if (want_planes) {
+      this->init_planes();
+    }
+    else {
+      m_has_planes = false;
+    }
+  }
+
+  /* Copy a single triangle from the source TMesh. */
+  TMesh(const TMesh &source_tm, int t)
+  {
+    BLI_assert(t >= 0 && t < source_tm.tot_tri());
+    this->m_verts.reserve(3);
+    const IndexedTriangle &source_it = source_tm.tri(t);
+    int tmv0 = this->add_vert(source_tm.vert(source_it.v0()));
+    int tmv1 = this->add_vert(source_tm.vert(source_it.v1()));
+    int tmv2 = this->add_vert(source_tm.vert(source_it.v2()));
+    this->m_tris.append(IndexedTriangle(tmv0, tmv1, tmv2, source_it.orig()));
+    if (source_tm.m_has_planes) {
+      this->m_planes.append(source_tm.m_planes[t]);
+      this->m_has_planes = true;
+    }
+    else {
+      this->m_has_planes = false;
+    }
+  }
+
+  /* TODO: make sure assignment, copy, init, move init, and move assignment all work as expected.
+   */
+
+  void init_planes()
+  {
+    int ntri = this->tot_tri();
+    m_planes.reserve(ntri);
+    for (int t = 0; t < ntri; ++t) {
+      IndexedTriangle &tri = m_tris[t];
+      mpq3 tr02 = m_verts[tri[0]] - m_verts[tri[2]];
+      mpq3 tr12 = m_verts[tri[1]] - m_verts[tri[2]];
+      mpq3 n = mpq3::cross(tr02, tr12);
+      mpq_class d = -mpq3::dot(n, m_verts[tri[0]]);
+      this->m_planes.append(planeq(n, d));
+    }
+    m_has_planes = true;
+  }
+
+  int tot_vert() const
+  {
+    return static_cast<int>(m_verts.size());
+  }
+
+  int tot_tri() const
+  {
+    return static_cast<int>(m_tris.size());
+  }
+
+  bool has_planes() const
+  {
+    return m_has_planes;
+  }
+
+  const IndexedTriangle &tri(int index) const
+  {
+    return m_tris[index];
+  }
+
+  const mpq3 &vert(int index) const
+  {
+    return m_verts[index];
+  }
+
+  const planeq &tri_plane(int index) const
+  {
+    BLI_assert(m_has_planes);
+    return m_planes[index];
+  }
+
+  int add_tri(int v0, int v1, int v2, int tri_orig)
+  {
+    int t = this->tot_vert();
+    this->m_tris.append(IndexedTriangle(v0, v1, v2, tri_orig));
+    return t;
+  }
+
+  int add_tri(const IndexedTriangle &itri)
+  {
+    int t = this->tot_vert();
+    this->m_tris.append(itri);
+    return t;
+  }
+
+  int add_vert(const mpq3 &co)
+  {
+    int co_index = this->m_verts.index_try(co);
+    if (co_index == -1) {
+      co_index = static_cast<int>(this->m_verts.size());
+      this->m_verts.add_new(co);
+    }
+    return co_index;
+  }
+
+ private:
+  /* Invariants:
+   * m_verts contains no duplicates.
+   * Every index t in an m_tris element satisfies
+   *   0 <= t < m_verts.size()
+   * No degenerate triangles.
+   * If m_has_planes is true then m_planes parallels
+   * the m_tris vector, and has the corresponding planes.
+   * (The init_planes() function will set that up.)
+   */
+  bool m_has_planes;
+  VectorSet<mpq3> m_verts;
+  Vector<IndexedTriangle> m_tris;
+  Vector<planeq> m_planes;
+};
+
+static std::ostream &operator<<(std::ostream &os, const TMesh &tm);
+
+/* A cluster of coplanar triangles, by index.
+ * A pair of triangles T0 and T1 is said to "nontrivially coplanar-intersect"
+ * if they are coplanar, intersect, and their intersection is not just existing
+ * elements (verts, edges) of both triangles.
+ * A coplanar cluster is said to be "nontrivial" if it has more than one triangle
+ * and every triangle in it nontrivially coplanar-intersects with at least one other
+ * triangle in the cluster.
+ */
+class CoplanarCluster {
+ public:
+  CoplanarCluster() = default;
+  explicit CoplanarCluster(int t)
+  {
+    this->add_tri(t);
+  }
+  ~CoplanarCluster() = default;
+  /* Assume that caller knows this will not be a duplicate. */
+  void add_tri(int t)
+  {
+    m_tris.append(t);
+  }
+  int tot_tri() const
+  {
+    return static_cast<int>(m_tris.size());
+  }
+  int tri(int index) const
+  {
+    return m_tris[index];
+  }
+  const int *begin() const
+  {
+    return m_tris.begin();
+  }
+  const int *end() const
+  {
+    return m_tris.end();
+  }
+
+ private:
+  Vector<int> m_tris;
+};
+
+/* Maintains indexed set of CoplanarCluster, with the added ability
+ * to efficiently find the cluster index of any given triangle
+ * (the max triangle index needs to be given in the initializer).
+ * The tri_cluster(t) function returns -1 if t is not part of any cluster.
+ */
+class CoplanarClusterInfo {
+ public:
+  CoplanarClusterInfo() = default;
+  explicit CoplanarClusterInfo(int numtri) : m_tri_cluster(Array<int>(numtri))
+  {
+    m_tri_cluster.fill(-1);
+  }
+  const int tri_cluster(int t) const
+  {
+    BLI_assert(0 <= t && t < static_cast<int>(m_tri_cluster.size()));
+    return m_tri_cluster[t];
+  }
+  int add_cluster(const CoplanarCluster cl)
+  {
+    int c_index = static_cast<int>(m_clusters.append_and_get_index(cl));
+    for (const int t : cl) {
+      BLI_assert(0 <= t && t < static_cast<int>(m_tri_cluster.size()));
+      m_tri_cluster[t] = c_index;
+    }
+    return c_index;
+  }
+  int tot_cluster() const
+  {
+    return static_cast<int>(m_clusters.size());
+  }
+  const CoplanarCluster &cluster(int index) const
+  {
+    BLI_assert(0 <= index && index < static_cast<int>(m_clusters.size()));
+    return m_clusters[index];
+  }
+
+ private:
+  Vector<CoplanarCluster> m_clusters;
+  Array<int> m_tri_cluster;
+};
+
+static std::ostream &operator<<(std::ostream &os, const CoplanarCluster &cl);
+
+static std::ostream &operator<<(std::ostream &os, const CoplanarClusterInfo &clinfo);
+
+enum ITT_value_kind { INONE, IPOINT, ISEGMENT, ICOPLANAR };
+
+class ITT_value {
+ public:
+  enum ITT_value_kind kind;
+  mpq3 p1;      /* Only relevant for IPOINT and ISEGMENT kind. */
+  mpq3 p2;      /* Only relevant for ISEGMENT kind. */
+  int t_source; /* Index of the source triangle that intersected the target one. */
+
+  ITT_value() : kind(INONE), t_source(-1)
+  {
+  }
+  ITT_value(ITT_value_kind k) : kind(k), t_source(-1)
+  {
+  }
+  ITT_value(ITT_value_kind k, int tsrc) : kind(k), t_source(tsrc)
+  {
+  }
+  ITT_value(ITT_value_kind k, const mpq3 &p1) : kind(k), p1(p1), t_source(-1)
+  {
+  }
+  ITT_value(ITT_value_kind k, const mpq3 &p1, const mpq3 &p2)
+      : kind(k), p1(p1), p2(p2), t_source(-1)
+  {
+  }
+  ~ITT_value()
+  {
+  }
+};
+
+static std::ostream &operator<<(std::ostream &os, const ITT_value &itt);
+
+/*
+ * interesect_tri_tri and helper functions.
+ * This code uses the algorithm of Guigue and Devillers, as described
+ * in "Faster Triangle-Triangle Intersection Tests".
+ * Adapted from github code by Eric Haines:
+ * github.com/erich666/jgt-code/tree/master/Volume_08/Number_1/Guigue2003
+ */
+
+/* Helper function for intersect_tri_tri. Args have been fully canonicalized
+ * and we can construct the segment of intersection (triangles not coplanar).
+ */
+
+static ITT_value itt_canon2(const mpq3 &p1,
+                            const mpq3 &q1,
+                            const mpq3 &r1,
+                            const mpq3 &p2,
+                            const mpq3 &q2,
+                            const mpq3 &r2,
+                            const mpq3 &n1,
+                            const mpq3 &n2)
+{
+  constexpr int dbg_level = 0;
+  mpq3 source;
+  mpq3 target;
+  mpq_class alpha;
+  bool ans_ok = false;
+
+  mpq3 v1 = q1 - p1;
+  mpq3 v2 = r2 - p1;
+  mpq3 n = mpq3::cross(v1, v2);
+  mpq3 v = p2 - p1;
+  if (dbg_level > 1) {
+    std::cout << "itt_canon2:\n";
+    std::cout << "p1=" << p1 << " q1=" << q1 << " r1=" << r1 << "\n";
+    std::cout << "p2=" << p2 << " q2=" << q2 << " r2=" << r2 << "\n";
+    std::cout << "v=" << v << " n=" << n << "\n";
+  }
+  if (mpq3::dot(v, n) > 0) {
+    v1 = r1 - p1;
+    n = mpq3::cross(v1, v2);
+    if (dbg_level > 1) {
+      std::cout << "case 1: v1=" << v1 << " v2=" << v2 << " n=" << n << "\n";
+    }
+    if (mpq3::dot(v, n) <= 0) {
+      v2 = q2 - p1;
+      n = mpq3::cross(v1, v2);
+      if (dbg_level > 1) {
+        std::cout << "case 1a: v2=" << v2 << " n=" << n << "\n";
+      }
+      if (mpq3::dot(v, n) > 0) {
+        v1 = p1 - p2;
+        v2 = p1 - r1;
+        alpha = mpq3::dot(v1, n2) / mpq3::dot(v2, n2);
+        v1 = v2 * alpha;
+        source = p1 - v1;
+        v1 = p2 - p1;
+        v2 = p2 - r2;
+        alpha = mpq3::dot(v1, n1) / mpq3::dot(v2, n1);
+        v1 = v2 * alpha;
+        target = p2 - v1;
+        ans_ok = true;
+      }
+      else {
+        v1 = p2 - p1;
+        v2 = p2 - q2;
+        alpha = mpq3::dot(v1, n1) / mpq3::dot(v2, n1);
+        v1 = v2 * alpha;
+        source = p2 - v1;
+        v1 = p2 - p1;
+        v2 = p2 - r2;
+        alpha = mpq3::dot(v1, n1) / mpq3::dot(v2, n1);
+        v1 = v2 * alpha;
+        target = p2 - v1;
+        ans_ok = true;
+      }
+    }
+    else {
+      if (dbg_level > 1) {
+        std::cout << "case 1b: ans=false\n";
+      }
+      ans_ok = false;
+    }
+  }
+  else {
+    v2 = q2 - p1;
+    n = mpq3::cross(v1, v2);
+    if (dbg_level > 1) {
+      std::cout << "case 2: v1=" << v1 << " v2=" << v2 << " n=" << n << "\n";
+    }
+    if (mpq3::dot(v, n) < 0) {
+      if (dbg_level > 1) {
+        std::cout << "case 2a: ans=false\n";
+      }
+      ans_ok = false;
+    }
+    else {
+      v1 = r1 - p1;
+      n = mpq3::cross(v1, v2);
+      if (dbg_level > 1) {
+        std::cout << "case 2b: v1=" << v1 << " v2=" << v2 << " n=" << n << "\n";
+      }
+      if (mpq3::dot(v, n) > 0) {
+        v1 = p1 - p2;
+        v2 = p1 - r1;
+        alpha = mpq3::dot(v1, n2) / mpq3::dot(v2, n2);
+        v1 = v2 * alpha;
+        source = p1 - v1;
+        v1 = p1 - p2;
+        v2 = p1 - q1;
+        alpha = mpq3::dot(v1, n2) / mpq3::dot(v2, n2);
+        v1 = v2 * alpha;
+        target = p1 - v1;
+        ans_ok = true;
+      }
+      else {
+        v1 = p2 - p1;
+        v2 = p2 - q2;
+        alpha = mpq3::dot(v1, n1) / mpq3::dot(v2, n1);
+        v1 = v2 * alpha;
+        source = p2 - v1;
+        v1 = p1 - p2;
+        v2 = p1 - q1;
+        alpha = mpq3::dot(v1, n2) / mpq3::dot(v2, n2);
+        v1 = v2 * alpha;
+        target = p1 - v1;
+        ans_ok = true;
+      }
+    }
+  }
+
+  if (dbg_level > 0) {
+    if (ans_ok) {
+      std::cout << "intersect: " << source << ", " << target << "\n";
+    }
+    else {
+      std::cout << "no intersect\n";
+    }
+  }
+  if (ans_ok) {
+    if (source == target) {
+      return ITT_value(IPOINT, source);
+    }
+    else {
+      return ITT_value(ISEGMENT, source, target);
+    }
+  }
+  else {
+    return ITT_value(INONE);
+  }
+}
+
+/* Helper function for intersect_tri_tri. Args have been canonicalized for triangle 1. */
+
+static ITT_value itt_canon1(const mpq3 &p1,
+                            const mpq3 &q1,
+                            const mpq3 &r1,
+                            const mpq3 &p2,
+                            const mpq3 &q2,
+                            const mpq3 &r2,
+                            const mpq3 &n1,
+                            const mpq3 &n2,
+                            int sp2,
+                            int sq2,
+                            int sr2)
+{
+  constexpr int dbg_level = 0;
+  if (sp2 > 0) {
+    if (sq2 > 0) {
+      return itt_canon2(p1, r1, q1, r2, p2, q2, n1, n2);
+    }
+    else if (sr2 > 0) {
+      return itt_canon2(p1, r1, q1, q2, r2, p2, n1, n2);
+    }
+    else {
+      return itt_canon2(p1, q1, r1, p2, q2, r2, n1, n2);
+    }
+  }
+  else if (sp2 < 0) {
+    if (sq2 < 0) {
+      return itt_canon2(p1, q1, r1, r2, p2, q2, n1, n2);
+    }
+    else if (sr2 < 0) {
+      return itt_canon2(p1, q1, r1, q2, r2, p2, n1, n2);
+    }
+    else {
+      return itt_canon2(p1, r1, q1, p2, q2, r2, n1, n2);
+    }
+  }
+  else {
+    if (sq2 < 0) {
+      if (sr2 >= 0) {
+        return itt_canon2(p1, r1, q1, q2, r2, p2, n1, n2);
+      }
+      else {
+        return itt_canon2(p1, q1, r1, p2, q2, r2, n1, n2);
+      }
+    }
+    else if (sq2 > 0) {
+      if (sr2 > 0) {
+        return itt_canon2(p1, r1, q1, p2, q2, r2, n1, n2);
+      }
+      else {
+        return itt_canon2(p1, q1, r1, q2, r2, p2, n1, n2);
+      }
+    }
+    else {
+      if (sr2 > 0) {
+        return itt_canon2(p1, q1, r1, r2, p2, q2, n1, n2);
+      }
+      else if (sr2 < 0) {
+        return itt_canon2(p1, r1, q1, r2, p2, q2, n1, n2);
+      }
+      else {
+        if (dbg_level > 0) {
+          std::cout << "triangles are coplanar\n";
+        }
+        return ITT_value(ICOPLANAR);
+      }
+    }
+  }
+  return ITT_value(INONE);
+}
+
+static ITT_value intersect_tri_tri(const TMesh &tm, int t1, int t2)
+{
+  constexpr int dbg_level = 0;
+  const IndexedTriangle &tri1 = tm.tri(t1);
+  const IndexedTriangle &tri2 = tm.tri(t2);
+  const mpq3 &p1 = tm.vert(tri1.v0());
+  const mpq3 &q1 = tm.vert(tri1.v1());
+  const mpq3 &r1 = tm.vert(tri1.v2());
+  const mpq3 &p2 = tm.vert(tri2.v0());
+  const mpq3 &q2 = tm.vert(tri2.v1());
+  const mpq3 &r2 = tm.vert(tri2.v2());
+
+  if (dbg_level > 0) {
+    std::cout << "\nINTERSECT_TRI_TRI t1=" << t1 << ", t2=" << t2 << "\n";
+    std::cout << "  p1 = " << p1 << "\n";
+    std::cout << "  q1 = " << q1 << "\n";
+    std::cout << "  r1 = " << r1 << "\n";
+    std::cout << "  p2 = " << p2 << "\n";
+    std::cout << "  q2 = " << q2 << "\n";
+    std::cout << "  r2 = " << r2 << "\n";
+  }
+
+  /* Get signs of t1's vertices' distances to plane of t2. */
+  /* If don't have normal, use mpq3 n2 = cross_v3v3(sub_v3v3(p2, r2), sub_v3v3(q2, r2)); */
+  const mpq3 &n2 = tm.tri_plane(t2).n;
+  int sp1 = sgn(mpq3::dot(p1 - r2, n2));
+  int sq1 = sgn(mpq3::dot(q1 - r2, n2));
+  int sr1 = sgn(mpq3::dot(r1 - r2, n2));
+
+  if (dbg_level > 1) {
+    std::cout << "  sp1=" << sp1 << " sq1=" << sq1 << " sr1=" << sr1 << "\n";
+  }
+
+  if ((sp1 * sq1 > 0) && (sp1 * sr1 > 0)) {
+    if (dbg_level > 0) {
+      std::cout << "no intersection, all t1's verts above or below t2\n";
+    }
+    return ITT_value(INONE);
+  }
+
+  /* Repeat for signs of t2's vertices with respect to plane of t1. */
+  /* If don't have normal, use mpq3 n1 = cross_v3v3(sub_v3v3(q1, p1), sub_v3v3(r1, p1)); */
+  const mpq3 &n1 = tm.tri_plane(t1).n;
+  int sp2 = sgn(mpq3::dot(p2 - r1, n1));
+  int sq2 = sgn(mpq3::dot(q2 - r1, n1));
+  int sr2 = sgn(mpq3::dot(r2 - r1, n1));
+
+  if (dbg_level > 1) {
+    std::cout << "  sp2=" << sp2 << " sq2=" << sq2 << " sr2=" << sr2 << "\n";
+  }
+
+  if ((sp2 * sq2 > 0) && (sp2 * sr2 > 0)) {
+    if (dbg_level > 0) {
+      std::cout << "no intersection, all t2's verts above or below t1\n";
+    }
+    return ITT_value(INONE);
+  }
+
+  /* Do rest of the work with vertices in a canonical order, where p1 is on
+   * postive side of plane and q1, r1 are not; similarly for p2.
+   */
+  ITT_value ans;
+  if (sp1 > 0) {
+    if (sq1 > 0) {
+      ans = itt_canon1(r1, p1, q1, p2, r2, q2, n1, n2, sp2, sr2, sq2);
+    }
+    else if (sr1 > 0) {
+      ans = itt_canon1(q1, r1, p1, p2, r2, q2, n1, n2, sp2, sr2, sq2);
+    }
+    else {
+      ans = itt_canon1(p1, q1, r1, p2, q2, r2, n1, n2, sp2, sq2, sr2);
+    }
+  }
+  else if (sp1 < 0) {
+    if (sq1 < 0) {
+      ans = itt_canon1(r1, p1, q1, p2, q2, r2, n1, n2, sp2, sq2, sr2);
+    }
+    else if (sr1 < 0) {
+      ans = itt_canon1(q1, r1, p1, p2, q2, r2, n1, n2, sp2, sq2, sr2);
+    }
+    else {
+      ans = itt_canon1(p1, q1, r1, p2, r2, q2, n1, n2, sp2, sr2, sq2);
+    }
+  }
+  else {
+    if (sq1 < 0) {
+      if (sr1 >= 0) {
+        ans = itt_canon1(q1, r1, p1, p2, r2, q2, n1, n2, sp2, sr2, sq2);
+      }
+      else {
+        ans = itt_canon1(p1, q1, r1, p2, q2, r2, n1, n2, sp2, sq2, sr2);
+      }
+    }
+    else if (sq1 > 0) {
+      if (sr1 > 0) {
+        ans = itt_canon1(p1, q1, r1, p2, r2, q2, n1, n2, sp2, sr2, sq2);
+      }
+      else {
+        ans = itt_canon1(q1, r1, p1, p2, q2, r2, n1, n2, sp2, sq2, sr2);
+      }
+    }
+    else {
+      if (sr1 > 0) {
+        ans = itt_canon1(r1, p1, q1, p2, q2, r2, n1, n2, sp2, sq2, sr2);
+      }
+      else if (sr1 < 0) {
+        ans = itt_canon1(r1, p1, q1, p2, r2, q2, n1, n2, sp2, sr2, sq2);
+      }
+      else {
+        if (dbg_level > 0) {
+          std::cout << "triangles are coplanar\n";
+        }
+        ans = ITT_value(ICOPLANAR);
+      }
+    }
+  }
+  if (ans.kind == ICOPLANAR) {
+    ans.t_source = t2;
+  }
+  return ans;
+}
+
+struct CDT_data {
+  planeq t_plane;
+  Vector<mpq2> vert;
+  Vector<std::pair<int, int>> edge;
+  Vector<Vector<int>> face;
+  Vector<int> input_face;        /* Parallels face, gives id from input TMesh of input face. */
+  Vector<bool> is_reversed;      /* Parallels face, says if input face orientation is opposite. */
+  CDT_result<mpq_class> cdt_out; /* Result of running CDT on input with (vert, edge, face). */
+  int proj_axis;
+};
+
+/* Project a 3d vert to a 2d one by eliding proj_axis. This does not create
+ * degeneracies as long as the projection axis is one where the corresponding
+ * component of the originating plane normal is non-zero.
+ */
+static mpq2 project_3d_to_2d(const mpq3 &p3d, int proj_axis)
+{
+  mpq2 p2d;
+  switch (proj_axis) {
+    case (0): {
+      p2d[0] = p3d[1];
+      p2d[1] = p3d[2];
+    } break;
+    case (1): {
+      p2d[0] = p3d[0];
+      p2d[1] = p3d[2];
+    } break;
+    case (2): {
+      p2d[0] = p3d[0];
+      p2d[1] = p3d[1];
+    } break;
+    default:
+      BLI_assert(false);
+  }
+  return p2d;
+}
+
+/* We could dedup verts here, but CDT routine will do that anyway. */
+static int prepare_need_vert(CDT_data &cd, const mpq3 &p3d)
+{
+  mpq2 p2d = project_3d_to_2d(p3d, cd.proj_axis);
+  int v = cd.vert.append_and_get_index(p2d);
+  return v;
+}
+
+/* To unproject a 2d vert that was projected along cd.proj_axis, we copy the coordinates
+ * from the two axes not involved in the projection, and use the plane equation of the
+ * originating 3d plane, cd.t_plane, to derive the coordinate of the projected axis.
+ * The plane equation says a point p is on the plane if dot(p, plane.n()) + plane.d() == 0.
+ * Assume that the projection axis is such that plane.n()[proj_axis] != 0.
+ */
+static mpq3 unproject_cdt_vert(const CDT_data &cd, const mpq2 &p2d)
+{
+  mpq3 p3d;
+  BLI_assert(cd.t_plane.n[cd.proj_axis] != 0);
+  switch (cd.proj_axis) {
+    case (0): {
+      mpq_class num = cd.t_plane.n[1] * p2d[0] + cd.t_plane.n[2] * p2d[1] + cd.t_plane.d;
+      num = -num;
+      p3d[0] = num / cd.t_plane.n[0];
+      p3d[1] = p2d[0];
+      p3d[2] = p2d[1];
+    } break;
+    case (1): {
+      p3d[0] = p2d[0];
+      mpq_class num = cd.t_plane.n[0] * p2d[0] + cd.t_plane.n[2] * p2d[1] + cd.t_plane.d;
+      num = -num;
+      p3d[1] = num / cd.t_plane.n[1];
+      p3d[2] = p2d[1];
+    } break;
+    case (2): {
+      p3d[0] = p2d[0];
+      p3d[1] = p2d[1];
+      mpq_class num = cd.t_plane.n[0] * p2d[0] + cd.t_plane.n[1] * p2d[1] + cd.t_plane.d;
+      num = -num;
+      p3d[2] = num / cd.t_plane.n[2];
+    } break;
+    default:
+      BLI_assert(false);
+  }
+  return p3d;
+}
+
+static void prepare_need_edge(CDT_data &cd, const mpq3 &p1, const mpq3 &p2)
+{
+  int v1 = prepare_need_vert(cd, p1);
+  int v2 = prepare_need_vert(cd, p2);
+  cd.edge.append(std::pair<int, int>(v1, v2));
+}
+
+static void prepare_need_tri(CDT_data &cd, const TMesh &tm, int t)
+{
+  IndexedTriangle tri = tm.tri(t);
+  int v0 = prepare_need_vert(cd, tm.vert(tri.v0()));
+  int v1 = prepare_need_vert(cd, tm.vert(tri.v1()));
+  int v2 = prepare_need_vert(cd, tm.vert(tri.v2()));
+  bool rev;
+  /* How to get CCW orientation of projected tri? Note that when look down y axis
+   * as opposed to x or z, the orientation of the other two axes is not right-and-up.
+   */
+  if (cd.t_plane[cd.proj_axis] >= 0) {
+    rev = cd.proj_axis == 1;
+  }
+  else {
+    rev = cd.proj_axis != 1;
+  }
+  /* If t's plane is opposite to cd.t_plane, need to reverse again. */
+  if (sgn(tm.tri_plane(t).n[cd.proj_axis]) != sgn(cd.t_plane[cd.proj_axis])) {
+    rev = !rev;
+  }
+  int cd_t = cd.face.append_and_get_index(Vector<int>());
+  cd.face[cd_t].append(v0);
+  if (rev) {
+    cd.face[cd_t].append(v2);
+    cd.face[cd_t].append(v1);
+  }
+  else {
+    cd.face[cd_t].append(v1);
+    cd.face[cd_t].append(v2);
+  }
+  cd.input_face.append(t);
+  cd.is_reversed.append(rev);
+}
+
+static CDT_data prepare_cdt_input(const TMesh &tm, int t, const Vector<ITT_value> itts)
+{
+  CDT_data ans;
+  BLI_assert(tm.has_planes());
+  ans.t_plane = tm.tri_plane(t);
+  const planeq &pl = ans.t_plane;
+  ans.proj_axis = mpq3::dominant_axis(pl.n);
+  prepare_need_tri(ans, tm, t);
+  for (const ITT_value &itt : itts) {
+    switch (itt.kind) {
+      case INONE:
+        break;
+      case IPOINT: {
+        prepare_need_vert(ans, itt.p1);
+      } break;
+      case ISEGMENT: {
+        prepare_need_edge(ans, itt.p1, itt.p2);
+      } break;
+      case ICOPLANAR: {
+        prepare_need_tri(ans, tm, itt.t_source);
+      } break;
+    }
+  }
+  return ans;
+}
+
+static CDT_data prepare_cdt_input_for_cluster(const TMesh &tm,
+                                              const CoplanarClusterInfo &clinfo,
+                                              int c,
+                                              const Vector<ITT_value> itts)
+{
+  CDT_data ans;
+  BLI_assert(c >= 0 && c < clinfo.tot_cluster());
+  const CoplanarCluster &cl = clinfo.cluster(c);
+  BLI_assert(cl.tot_tri() > 0);
+  int t0 = cl.tri(0);
+  BLI_assert(tm.has_planes());
+  ans.t_plane = tm.tri_plane(t0);
+  const planeq &pl = ans.t_plane;
+  ans.proj_axis = mpq3::dominant_axis(pl.n);
+  for (const int t : cl) {
+    prepare_need_tri(ans, tm, t);
+  }
+  for (const ITT_value &itt : itts) {
+    switch (itt.kind) {
+      case IPOINT: {
+        prepare_need_vert(ans, itt.p1);
+      } break;
+      case ISEGMENT: {
+        prepare_need_edge(ans, itt.p1, itt.p2);
+      } break;
+      default:
+        break;
+    }
+  }
+  return ans;
+}
+
+/* Fills in cd.cdt_out with result of doing the cdt calculation on (vert, edge, face). */
+static void do_cdt(CDT_data &cd)
+{
+  constexpr int dbg_level = 0;
+  /* TODO: find a way to avoid the following copies. Maybe add a CDT_input variant (or just
+   * change its signature) to use Vectors instead of Arrays for the three inputs.
+   */
+  CDT_input<mpq_class> cdt_in;
+  cdt_in.vert = Array<mpq2>(cd.vert);
+  cdt_in.edge = Array<std::pair<int, int>>(cd.edge);
+  cdt_in.face = Array<Vector<int>>(cd.face);
+  if (dbg_level > 0) {
+    std::cout << "CDT input\nVerts:\n";
+    for (uint i = 0; i < cdt_in.vert.size(); ++i) {
+      std::cout << "v" << i << ": " << cdt_in.vert[i] << "\n";
+    }
+    std::cout << "Edges:\n";
+    for (uint i = 0; i < cdt_in.edge.size(); ++i) {
+      std::cout << "e" << i << ": (" << cdt_in.edge[i].first << ", " << cdt_in.edge[i].second
+                << ")\n";
+    }
+    std::cout << "Tris\n";
+    for (uint f = 0; f < cdt_in.face.size(); ++f) {
+      std::cout << "f" << f << ": ";
+      for (uint j = 0; j < cdt_in.face[f].size(); ++j) {
+        std::cout << cdt_in.face[f][j] << " ";
+      }
+      std::cout << "\n";
+    }
+  }
+  cdt_in.epsilon = 0; /* TODO: needs attention for non-exact T. */
+  cd.cdt_out = BLI::delaunay_2d_calc(cdt_in, CDT_INSIDE);
+  if (dbg_level > 0) {
+    std::cout << "\nCDT result\nVerts:\n";
+    for (uint i = 0; i < cd.cdt_out.vert.size(); ++i) {
+      std::cout << "v" << i << ": " << cd.cdt_out.vert[i] << "\n";
+    }
+    std::cout << "Tris\n";
+    for (uint f = 0; f < cd.cdt_out.face.size(); ++f) {
+      std::cout << "f" << f << ": ";
+      for (uint j = 0; j < cd.cdt_out.face[f].size(); ++j) {
+        std::cout << cd.cdt_out.face[f][j] << " ";
+      }
+      std::cout << "orig: ";
+      for (uint j = 0; j < cd.cdt_out.face_orig[f].size(); ++j) {
+        std::cout << cd.cdt_out.face_orig[f][j] << " ";
+      }
+      std::cout << "\n";
+    }
+  }
+}
+
+/* Using the result of CDT in cd.cdt_out, extract a TMesh representing the subdivision
+ * of input triangle t, which should be an element of cd.input_face.
+ */
+
+static TMesh extract_subdivided_tri(const CDT_data &cd, const TMesh &in_tm, int t)
+{
+  TMesh ans;
+
+  /* We want all triangles in cdt_out that had t (as indexed in the CDT_input) as an orig. */
+  /* Which output verts do we need in our answer? */
+  const CDT_result<mpq_class> &cdt_out = cd.cdt_out;
+  Array<bool> needvert(cdt_out.vert.size()); /* Initialized to all false. */
+  Array<bool> needtri(cdt_out.face.size());  /* Initialized to all false. */
+  int t_in_cdt = -1;
+  for (int i = 0; i < static_cast<int>(cd.input_face.size()); ++i) {
+    if (cd.input_face[i] == t) {
+      t_in_cdt = i;
+    }
+  }
+  if (t_in_cdt == -1) {
+    std::cout << "Could not find " << t << " in cdt input tris\n";
+    BLI_assert(false);
+    return ans;
+  }
+  int num_needed_v = 0;
+  for (uint f = 0; f < cdt_out.face.size(); ++f) {
+    if (cdt_out.face_orig[f].contains(t_in_cdt)) {
+      needtri[f] = true;
+      for (int v : cdt_out.face[f]) {
+        if (!needvert[v]) {
+          needvert[v] = true;
+          ++num_needed_v;
+        }
+      }
+    }
+  }
+  Array<int> cdt_v_to_out_v(cdt_out.vert.size());
+
+  for (uint cdt_v = 0; cdt_v < cdt_out.vert.size(); ++cdt_v) {
+    if (needvert[cdt_v]) {
+      mpq3 v3co = unproject_cdt_vert(cd, cdt_out.vert[cdt_v]);
+      cdt_v_to_out_v[cdt_v] = ans.add_vert(v3co);
+    }
+  }
+  int orig = in_tm.tri(t).orig();
+  for (uint f = 0; f < cdt_out.face.size(); ++f) {
+    if (needtri[f]) {
+      BLI_assert(cdt_out.face[f].size() == 3);
+      int v0 = cdt_out.face[f][0];
+      int v1 = cdt_out.face[f][1];
+      int v2 = cdt_out.face[f][2];
+      BLI_assert(needvert[v0] && needvert[v1] && needvert[v2]);
+      int out_v0 = cdt_v_to_out_v[v0];
+      int out_v1 = cdt_v_to_out_v[v1];
+      int out_v2 = cdt_v_to_out_v[v2];
+      if (cd.is_reversed[t_in_cdt]) {
+        ans.add_tri(out_v0, out_v2, out_v1, orig);
+      }
+      else {
+        ans.add_tri(out_v0, out_v1, out_v2, orig);
+      }
+    }
+  }
+  return ans;
+}
+
+static TMesh calc_tri_subdivided(const TMesh &in_tm, int t)
+{
+  constexpr int dbg_level = 0;
+  TMesh ans;
+
+  if (dbg_level > 0) {
+    std::cout << "\ncalc_tri_subdivided for tri " << t << "\n\n";
+  }
+  int ntri = in_tm.tot_tri();
+  Vector<ITT_value> itts;
+  for (int t_other = 0; t_other < ntri; ++t_other) {
+    if (t_other == t) {
+      continue;
+    }
+    /* Intersect t with t_other. */
+    ITT_value itt = intersect_tri_tri(in_tm, t, t_other);
+    if (dbg_level > 1) {
+      std::cout << "intersect " << t << " with " << t_other << " result: " << itt << "\n";
+    }
+    if (itt.kind != INONE) {
+      itts.append(itt);
+    }
+  }
+  if (itts.size() == 0) {
+    /* No intersections: answer is just the original triangle t. */
+    ans = TMesh(in_tm, t);
+  }
+  else {
+    /* Use CDT to subdivide the triangle. */
+    CDT_data cd_data = prepare_cdt_input(in_tm, t, itts);
+    do_cdt(cd_data);
+    ans = extract_subdivided_tri(cd_data, in_tm, t);
+  }
+  if (dbg_level > 0) {
+    std::cout << "\ncalc_tri_subdivided " << t << " result:\n" << ans;
+  }
+  return ans;
+}
+
+static CDT_data calc_cluster_subdivided(const CoplanarClusterInfo &clinfo, int c, const TMesh &tm)
+{
+  constexpr int dbg_level = 0;
+  BLI_assert(0 <= c && c < clinfo.tot_cluster());
+  const CoplanarCluster &cl = clinfo.cluster(c);
+  /* Make a CDT input with triangles from C and intersects from other triangles in tm. */
+  if (dbg_level > 0) {
+    std::cout << "calc_cluster_subdivided for cluster " << c << " = " << cl << "\n";
+  }
+  /* Get vector itts of all intersections of a triangle of cl with any triangle of tm not
+   * in cl and not coplanar with it (for that latter, if there were an intersection,
+   * it should already be in cluster cl).
+   */
+  int ntri = tm.tot_tri();
+  Vector<ITT_value> itts;
+  for (int t_other = 0; t_other < ntri; ++t_other) {
+    if (clinfo.tri_cluster(t_other) != c) {
+      if (dbg_level > 0) {
+        std::cout << "intersect cluster " << c << " with tri " << t_other << "\n";
+      }
+      for (const int t : cl) {
+        ITT_value itt = intersect_tri_tri(tm, t, t_other);
+        if (dbg_level > 0) {
+          std::cout << "intersect tri " << t << " with tri " << t_other << " = " << itt << "\n";
+        }
+        if (itt.kind != INONE && itt.kind != ICOPLANAR) {
+          itts.append(itt);
+        }
+      }
+    }
+  }
+  /* Use CDT to subdivide the cluster triangles and the points and segs in itts. */
+  CDT_data cd_data = prepare_cdt_input_for_cluster(tm, clinfo, c, itts);
+  do_cdt(cd_data);
+  return cd_data;
+}
+
+static TMesh union_tri_subdivides(const BLI::Array<TMesh> &tri_subdivided)
+{
+  TMesh ans;
+  for (const TMesh &tmsub : tri_subdivided) {
+    Array<int> vtrans(tmsub.tot_vert());
+    for (int v = 0; v < tmsub.tot_vert(); ++v) {
+      vtrans[v] = ans.add_vert(tmsub.vert(v));
+    }
+    for (int t = 0; t < tmsub.tot_tri(); ++t) {
+      const IndexedTriangle &tri = tmsub.tri(t);
+      ans.add_tri(vtrans[tri.v0()], vtrans[tri.v1()], vtrans[tri.v2()], tri.orig());
+    }
+  }
+  return ans;
+}
+
+/* Need a canonical form of a plane so that can use as a key in a map and
+ * all coplanar triangles will have the same key.
+ * Make the first nonzero component of the normal be 1.
+ */
+static planeq canon_plane(const planeq &pl)
+{
+  if (pl.n[0] != 0) {
+    return planeq(mpq3(1, pl.n[1] / pl.n[0], pl.n[2] / pl.n[0]), pl.d / pl.n[0]);
+  }
+  else if (pl.n[1] != 0) {
+    return planeq(mpq3(0, 1, pl.n[2] / pl.n[1]), pl.d / pl.n[1]);
+  }
+  else {
+    return planeq(mpq3(0, 0, 1), pl.d / pl.n[2]);
+  }
+}
+
+/* Is a point in the interior of a 2d triangle or on one of its
+ * edges but not either endpoint of the edge?
+ * orient[pi][i] is the orientation test of the point pi against
+ * the side of the triangle starting at index i.
+ * Assume the triangele is non-degenerate and CCW-oriented.
+ * Then answer is true if p is left of or on all three of triangle a's edges,
+ * and strictly left of at least on of them.
+ */
+static bool non_trivially_2d_point_in_tri(const int orients[3][3], int pi)
+{
+  int p_left_01 = orients[pi][0];
+  int p_left_12 = orients[pi][1];
+  int p_left_20 = orients[pi][2];
+  return (p_left_01 >= 0 && p_left_12 >= 0 && p_left_20 >= 0 &&
+          (p_left_01 + p_left_12 + p_left_20) >= 2);
+}
+
+/* Given orients as defined in non_trivially_2d_intersect, do the triangles
+ * overlap in a "hex" pattern? That is, the overlap region is a hexagon, which
+ * one gets by having, each point of one triangle being strictly rightof one
+ * edge of the other and strictly left of the other two edges; and vice versa.
+ */
+static bool non_trivially_2d_hex_overlap(int orients[2][3][3])
+{
+  for (int ab = 0; ab < 2; ++ab) {
+    for (int i = 0; i < 3; ++i) {
+      bool ok = orients[ab][i][0] + orients[ab][i][1] + orients[ab][i][2] == 1 &&
+                orients[ab][i][0] != 0 && orients[ab][i][1] != 0 && orients[i][2] != 0;
+      if (!ok) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/* Given orients as defined in non_trivially_2d_intersect, do the triangles
+ * have one shared edge in a "folded-over" configuration?
+ * As well as a shared edge, the third vertex of one triangle needs to be
+ * rightof one and leftof the other two edges of the other triangle.
+ */
+
+static bool non_trivially_2d_shared_edge_overlap(int orients[2][3][3],
+                                                 const mpq2 *a[3],
+                                                 const mpq2 *b[3])
+{
+  for (int i = 0; i < 3; ++i) {
+    int in = (i + 1) % 3;
+    int inn = (i + 2) % 3;
+    for (int j = 0; j < 3; ++j) {
+      int jn = (j + 1) % 3;
+      int jnn = (j + 2) % 3;
+      if (*a[i] == *b[j] && *a[in] == *b[jn]) {
+        /* Edge from a[i] is shared with edge from b[j]. */
+        /* See if a[inn] is rightof or on one of the other edges of b.
+         * If it is on, then it has to be rightof or leftof the shared edge,
+         * depending on which edge it is.
+         */
+        if (orients[0][inn][jn] < 0 || orients[0][inn][jnn] < 0) {
+          return true;
+        }
+        if (orients[0][inn][jn] == 0 && orients[0][inn][j] == 1) {
+          return true;
+        }
+        if (orients[0][inn][jnn] == 0 && orients[0][inn][j] == -1) {
+          return true;
+        }
+        /* Similarly for b[jnn]. */
+        if (orients[1][jnn][in] < 0 || orients[1][jnn][inn] < 0) {
+          return true;
+        }
+        if (orients[1][jnn][in] == 0 && orients[1][jnn][i] == 1) {
+          return true;
+        }
+        if (orients[1][jnn][inn] == 0 && orients[1][jnn][i] == -1) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/* Are the triangles the same, perhaps with some permutation of vertices? */
+static bool same_triangles(const mpq2 *a[3], const mpq2 *b[3])
+{
+  for (int i = 0; i < 3; ++i) {
+    if (a[0] == b[i] && a[1] == b[(i + 1) % 3] && a[2] == b[(i + 2) % 3]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/* Do 2d triangles (a[0], a[1], a[2]) and (b[0], b[1], b2[2]) intersect at more than just shared
+ * vertices or a shared edge? This is true if any point of one tri is non-trivially inside the
+ * other. NO: that isn't quite sufficient: there is also the case where the verts are all mutually
+ * outside the other's triangle, but there is a hexagonal overlap region where they overlap.
+ */
+
+static bool non_trivially_2d_intersect(const mpq2 *a[3], const mpq2 *b[3])
+{
+  /* TODO: Could experiment with trying bounding box tests before these.
+   * TODO: Find a less expensive way than 18 orient tests to do this.
+   */
+  /* orients[0][ai][bi] is orient of point a[ai] compared to seg starting at b[bi].
+   * orients[1][bi][ai] is orient of point b[bi] compared to seg starting at a[ai].
+   */
+  int orients[2][3][3];
+  for (int ab = 0; ab < 2; ++ab) {
+    for (int ai = 0; ai < 3; ++ai) {
+      for (int bi = 0; bi < 3; ++bi) {
+        if (ab == 0) {
+          orients[0][ai][bi] = mpq2::orient2d(*b[bi], *b[(bi + 1) % 3], *a[ai]);
+        }
+        else {
+          orients[1][bi][ai] = mpq2::orient2d(*a[ai], *a[(ai + 1) % 3], *b[bi]);
+        }
+      }
+    }
+  }
+  return non_trivially_2d_point_in_tri(orients[0], 0) ||
+         non_trivially_2d_point_in_tri(orients[0], 1) ||
+         non_trivially_2d_point_in_tri(orients[0], 2) ||
+         non_trivially_2d_point_in_tri(orients[1], 0) ||
+         non_trivially_2d_point_in_tri(orients[1], 1) ||
+         non_trivially_2d_point_in_tri(orients[1], 2) || non_trivially_2d_hex_overlap(orients) ||
+         non_trivially_2d_shared_edge_overlap(orients, a, b) || same_triangles(a, b);
+  return true;
+}
+
+/* Does triangle t in tm non-trivially non-coplanar intersect any triangle
+ * in CoplanarCluster cl? Assume t is known to be in the same plane as all
+ * the triangles in cl, and that proj_axis is a good axis to project down
+ * to solve this problem in 2d.
+ */
+
+static bool non_trivially_coplanar_intersects(const TMesh &tm,
+                                              int t,
+                                              const CoplanarCluster &cl,
+                                              int proj_axis)
+{
+  const IndexedTriangle &tri = tm.tri(t);
+  mpq2 v0 = project_3d_to_2d(tm.vert(tri.v0()), proj_axis);
+  mpq2 v1 = project_3d_to_2d(tm.vert(tri.v1()), proj_axis);
+  mpq2 v2 = project_3d_to_2d(tm.vert(tri.v2()), proj_axis);
+  if (mpq2::orient2d(v0, v1, v2) != 1) {
+    mpq2 tmp = v1;
+    v1 = v2;
+    v2 = tmp;
+  }
+  for (const int cl_t : cl) {
+    const IndexedTriangle &cl_tri = tm.tri(cl_t);
+    mpq2 ctv0 = project_3d_to_2d(tm.vert(cl_tri.v0()), proj_axis);
+    mpq2 ctv1 = project_3d_to_2d(tm.vert(cl_tri.v1()), proj_axis);
+    mpq2 ctv2 = project_3d_to_2d(tm.vert(cl_tri.v2()), proj_axis);
+    if (mpq2::orient2d(ctv0, ctv1, ctv2) != 1) {
+      mpq2 tmp = ctv1;
+      ctv1 = ctv2;
+      ctv2 = tmp;
+    }
+    const mpq2 *v[] = {&v0, &v1, &v2};
+    const mpq2 *ctv[] = {&ctv0, &ctv1, &ctv2};
+    if (non_trivially_2d_intersect(v, ctv)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static CoplanarClusterInfo find_clusters(const TMesh &tmesh)
+{
+  constexpr int dbg_level = 0;
+  if (dbg_level > 0) {
+    std::cout << "FIND_CLUSTERS\n";
+  }
+  CoplanarClusterInfo ans(tmesh.tot_tri());
+  /* There can be more than one CoplanarCluster per plane. Accumulate them in
+   * a Vector. We will have to merge some elements of the Vector as we discover
+   * triangles that form intersection bridges between two or more clusters.
+   */
+  Map<planeq, Vector<CoplanarCluster>> plane_cls;
+  for (int t = 0; t < tmesh.tot_tri(); ++t) {
+    const planeq &tplane = tmesh.tri_plane(t);
+    planeq canon_tplane = canon_plane(tplane);
+    if (plane_cls.contains(canon_tplane)) {
+      Vector<CoplanarCluster> &curcls = plane_cls.lookup(canon_tplane);
+      int proj_axis = mpq3::dominant_axis(canon_tplane.n);
+      /* Paritition curcls into those that intersect t non-trivially, and those that don't. */
+      Vector<CoplanarCluster *> int_cls;
+      Vector<CoplanarCluster *> no_int_cls;
+      for (CoplanarCluster &cl : curcls) {
+        if (non_trivially_coplanar_intersects(tmesh, t, cl, proj_axis)) {
+          int_cls.append(&cl);
+        }
+        else {
+          no_int_cls.append(&cl);
+        }
+      }
+      if (int_cls.size() == 0) {
+        /* t doesn't intersect any existing cluster in its plane, so make one just for it. */
+        curcls.append(CoplanarCluster(t));
+      }
+      else if (int_cls.size() == 1) {
+        /* t intersects exactly one existing cluster, so can add t to that cluster. */
+        int_cls[0]->add_tri(t);
+      }
+      else {
+        /* t intersections 2 or more existing clusters: need to merge them and replace all the
+         * originals with the merged one in curcls.
+         */
+        CoplanarCluster mergecl;
+        mergecl.add_tri(t);
+        for (CoplanarCluster *cl : int_cls) {
+          for (int t : *cl) {
+            mergecl.add_tri(t);
+          }
+        }
+        Vector<CoplanarCluster> newvec;
+        newvec.append(mergecl);
+        for (CoplanarCluster *cl_no_int : no_int_cls) {
+          newvec.append(*cl_no_int);
+        }
+        plane_cls.add_override(canon_tplane, newvec);
+      }
+    }
+    else {
+      plane_cls.add_new(canon_tplane, Vector<CoplanarCluster>{CoplanarCluster(t)});
+    }
+  }
+  /* Does this give deterministic order for cluster ids? I think so, since
+   * hash for planes is on their values, not their addresses.
+   */
+  for (auto item : plane_cls.items()) {
+    for (const CoplanarCluster &cl : item.value) {
+      if (cl.tot_tri() > 1) {
+        ans.add_cluster(cl);
+      }
+    }
+  }
+
+  return ans;
+}
+
+static TriMesh tmesh_to_trimesh(const TMesh &tm)
+{
+  TriMesh ans;
+  ans.vert = Array<mpq3>(tm.tot_vert());
+  ans.tri = Array<IndexedTriangle>(tm.tot_tri());
+  for (uint v = 0; v < tm.tot_vert(); ++v) {
+    ans.vert[v] = tm.vert(v);
+  }
+  for (uint t = 0; t < tm.tot_tri(); ++t) {
+    ans.tri[t] = tm.tri(t);
+  }
+  return ans;
+}
+
+/* This is the main routine for calculating the self_intersection of a TriMesh. */
+static TriMesh tpl_trimesh_self_intersect(const TriMesh &tm_in)
+{
+  constexpr int dbg_level = 1;
+  if (dbg_level > 0) {
+    std::cout << "\nTRIMESH_SELF_INTERSECT\n";
+  }
+  TMesh tmesh(tm_in, true);
+  int ntri = tmesh.tot_tri();
+  CoplanarClusterInfo clinfo = find_clusters(tmesh);
+  if (dbg_level > 1) {
+    std::cout << clinfo;
+  }
+  BLI::Array<CDT_data> cluster_subdivided(clinfo.tot_cluster());
+  for (int c = 0; c < clinfo.tot_cluster(); ++c) {
+    cluster_subdivided[c] = calc_cluster_subdivided(clinfo, c, tmesh);
+  }
+  BLI::Array<TMesh> tri_subdivided(ntri);
+  for (int t = 0; t < ntri; ++t) {
+    int c = clinfo.tri_cluster(t);
+    if (c == -1) {
+      tri_subdivided[t] = calc_tri_subdivided(tmesh, t);
+    }
+    else {
+      tri_subdivided[t] = extract_subdivided_tri(cluster_subdivided[c], tmesh, t);
+    }
+  }
+  TMesh combined = union_tri_subdivides(tri_subdivided);
+  return tmesh_to_trimesh(combined);
+}
+
+TriMesh trimesh_self_intersect(const TriMesh &tm_in)
+{
+  return tpl_trimesh_self_intersect(tm_in);
+}
+
+static std::ostream &operator<<(std::ostream &os, const TMesh &tm)
+{
+  os << "TMesh\nVerts:\n";
+  for (int v = 0; v < tm.tot_vert(); ++v) {
+    os << " " << v << ": " << tm.vert(v) << "\n";
+  }
+  os << "Tris:\n";
+  for (int t = 0; t < tm.tot_tri(); ++t) {
+    os << " " << t << ": " << tm.tri(t) << "\n";
+    if (tm.has_planes()) {
+      os << "  plane: [" << tm.tri_plane(t).n << ";" << tm.tri_plane(t).d << "]\n";
+    }
+  }
+  return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const IndexedTriangle &tri)
+{
+  os << "tri(" << tri.v0() << "," << tri.v1() << "," << tri.v2() << ")";
+  if (tri.orig() != -1) {
+    os << "(o" << tri.orig() << ")";
+  }
+  return os;
+}
+
+std::ostream &operator<<(std::ostream &os, const TriMesh &tm)
+{
+  os << "TriMesh input\nVerts:\n";
+  for (uint v = 0; v < tm.vert.size(); ++v) {
+    os << " " << v << ": " << tm.vert[v] << "\n";
+  }
+  os << "Tris:\n";
+  for (uint t = 0; t < tm.tri.size(); ++t) {
+    os << " " << t << ": " << tm.tri[t] << "\n";
+  }
+  return os;
+}
+
+static std::ostream &operator<<(std::ostream &os, const CoplanarCluster &cl)
+{
+  os << "cl(";
+  bool first = true;
+  for (const int t : cl) {
+    if (first) {
+      first = false;
+    }
+    else {
+      os << ",";
+    }
+    os << t;
+  }
+  os << ")";
+  return os;
+}
+
+static std::ostream &operator<<(std::ostream &os, const CoplanarClusterInfo &clinfo)
+{
+  os << "Coplanar Cluster Info:\n";
+  for (int c = 0; c < clinfo.tot_cluster(); ++c) {
+    os << c << ": " << clinfo.cluster(c) << "\n";
+  }
+  return os;
+}
+
+static std::ostream &operator<<(std::ostream &os, const ITT_value &itt)
+{
+  switch (itt.kind) {
+    case INONE:
+      os << "none";
+      break;
+    case IPOINT:
+      os << "point " << itt.p1;
+      break;
+    case ISEGMENT:
+      os << "segment " << itt.p1 << " " << itt.p2;
+      break;
+    case ICOPLANAR:
+      os << "coplanar t" << itt.t_source;
+      break;
+  }
+  return os;
+}
+
+/* Some contrasting colors to use for distinguishing triangles. */
+static const char *drawcolor[] = {
+    "0.67 0.14 0.14", /* red */
+    "0.16 0.29 0.84", /* blue */
+    "0.11 0.41 0.08", /* green */
+    "0.50 0.29 0.10", /* brown */
+    "0.50 0.15 0.75", /* purple */
+    "0.62 0.62 0.62", /* light grey */
+    "0.50 0.77 0.49", /* light green */
+    "0.61 0.68 1.00", /* light blue */
+    "0.16 0.82 0.82", /* cyan */
+    "1.00 0.57 0.20", /* orange */
+    "1.00 0.93 0.20", /* yellow */
+    "0.91 0.87 0.73", /* tan */
+    "1.00 0.80 0.95", /* pink */
+    "0.34 0.34 0.34"  /* dark grey */
+};
+static constexpr int numcolors = sizeof(drawcolor) / sizeof(drawcolor[0]);
+
+/* See x3dom.org for an explanation of this way of embedding 3d objects in a web page. */
+
+static const char *htmlfileheader = R"(<head>
+<title>Mesh Intersection Tests</title>
+<script type='text/javascript' src='http://www.x3dom.org/download/x3dom.js'> </script>
+<link rel='stylesheet' type='text/cs href='http://www.x3dom.org/download/x3dom.css'></link>
+</head>
+)";
+
+void write_html_trimesh(const Array<mpq3> &vert,
+                        const Array<IndexedTriangle> &tri,
+                        const std::string &fname,
+                        const std::string &label)
+{
+  static bool draw_append = false;
+  constexpr const char *drawfiledir = "/tmp/";
+  constexpr int draw_width = 1400;
+  constexpr int draw_height = 1000;
+  constexpr bool draw_vert_labels = true;
+
+  const std::string fpath = std::string(drawfiledir) + fname;
+
+  std::ofstream f;
+  if (draw_append) {
+    f.open(fpath, std::ios_base::app);
+  }
+  else {
+    f.open(fpath);
+  }
+  if (!f) {
+    std::cout << "Could not open file " << fpath << "\n";
+    return;
+  }
+  if (!draw_append) {
+    f << htmlfileheader;
+  }
+
+  f << "<div>" << label << "</div>\n<div>\n"
+    << "<x3d width='" << draw_width << "px' "
+    << "height='" << draw_height << "px'>\n"
+    << "<scene>\n";
+
+  BLI::Array<bool> vused(vert.size());
+  int i = 0;
+  for (const IndexedTriangle &t : tri) {
+    double3 dv0, dv1, dv2;
+    for (int axis = 0; axis < 3; ++axis) {
+      dv0[axis] = vert[t.v0()][axis].get_d();
+      dv1[axis] = vert[t.v1()][axis].get_d();
+      dv2[axis] = vert[t.v2()][axis].get_d();
+    }
+    f << "<shape>\n";
+    f << "  <appearance>\n";
+    f << "    <twosidedmaterial diffuseColor='" << drawcolor[i % numcolors]
+      << "' separatebackcolor='false'/>\n";
+    f << "  </appearance>\n";
+    f << "  <triangleset>\n";
+    f << "    <coordinate point='" << dv0[0] << " " << dv0[1] << " " << dv0[2] << " " << dv1[0]
+      << " " << dv1[1] << " " << dv1[2] << " " << dv2[0] << " " << dv2[1] << " " << dv2[2]
+      << "'/>\n";
+    f << "  </triangleset>\n";
+    f << "</shape>\n";
+    vused[t.v0()] = true;
+    vused[t.v1()] = true;
+    vused[t.v2()] = true;
+    ++i;
+  }
+  if (draw_vert_labels) {
+    for (uint i = 0; i < vert.size(); ++i) {
+      if (!vused[i]) {
+        continue;
+      }
+      double3 dv(vert[i][0].get_d(), vert[i][1].get_d(), vert[i][2].get_d());
+      f << "<transform translation='" << dv[0] << " " << dv[1] << " " << dv[2] << "'>\n";
+      f << "<shape>\n  <appearance>\n"
+        << "    <twosidedmaterial diffuseColor='0 0 0'/>\n"
+        << "  </appearance>\n"
+        << "  <text string='" << i << "'><fontstyle size='0.25'/></text>\n"
+        << "</shape>\n</transform>\n";
+    }
+  }
+  f << "</scene>\n</x3d>\n</div>\n";
+  draw_append = true;
+}
+
+void write_obj_trimesh(const Array<mpq3> &vert,
+                       const Array<IndexedTriangle> &tri,
+                       const std::string &objname)
+{
+  constexpr const char *objdir = "/tmp/";
+  if (tri.size() == 0) {
+    return;
+  }
+
+  std::string fname = std::string(objdir) + objname + std::string(".obj");
+  std::string matfname = std::string(objdir) + std::string("dumpobj.mtl");
+  std::ofstream f;
+  f.open(fname);
+  if (!f) {
+    std::cout << "Could not open file " << fname << "\n";
+    return;
+  }
+
+  f << "mtllib dumpobj.mtl\n";
+
+  for (const mpq3 &vco : vert) {
+    double3 dv(vco[0].get_d(), vco[1].get_d(), vco[2].get_d());
+    f << "v " << dv[0] << " " << dv[1] << " " << dv[2] << "\n";
+  }
+  int i = 0;
+  for (const IndexedTriangle &t : tri) {
+    int matindex = i % numcolors;
+    f << "usemtl mat" + std::to_string(matindex) + "\n";
+    /* OBJ files use 1-indexing for vertices. */
+    f << "f " << t.v0() + 1 << " " << t.v1() + 1 << " " << t.v2() + 1 << "\n";
+    ++i;
+  }
+  f.close();
+
+  /* Could check if it already exists, but why bother. */
+  std::ofstream mf;
+  mf.open(matfname);
+  if (!mf) {
+    std::cout << "Could not open file " << matfname << "\n";
+    return;
+  }
+  for (int c = 0; c < numcolors; ++c) {
+    mf << "newmtl mat" + std::to_string(c) + "\n";
+    mf << "Kd " << drawcolor[c] << "\n";
+  }
+}
+
+};  // namespace MeshIntersect
+
+template<> struct DefaultHash<mpq_class> {
+  uint32_t operator()(const mpq_class &value) const
+  {
+    return DefaultHash<float>{}(static_cast<float>(value.get_d()));
+  }
+};
+
+template<> struct DefaultHash<mpq3> {
+  uint32_t operator()(const mpq3 &value) const
+  {
+    uint32_t hashx = DefaultHash<mpq_class>{}(value.x);
+    uint32_t hashy = DefaultHash<mpq_class>{}(value.y);
+    uint32_t hashz = DefaultHash<mpq_class>{}(value.z);
+    return hashx ^ (hashy * 33) ^ (hashz * 33 * 37);
+  }
+};
+
+template<> struct DefaultHash<MeshIntersect::planeq> {
+  uint32_t operator()(const MeshIntersect::planeq &value) const
+  {
+    uint32_t hashx = DefaultHash<mpq_class>{}(value.n.x);
+    uint32_t hashy = DefaultHash<mpq_class>{}(value.n.y);
+    uint32_t hashz = DefaultHash<mpq_class>{}(value.n.z);
+    uint32_t hashd = DefaultHash<mpq_class>{}(value.d);
+    return hashx ^ (hashy * 33) ^ (hashz * 33 * 37) ^ (hashd * 33 * 37 * 39);
+  }
+};
+
+}  // namespace BLI