Working on meshes

This commit is contained in:
Yousef Khadadeh 2026-05-23 18:27:45 +03:00
parent c479ccb9e2
commit 7b472fe18d
652 changed files with 81120 additions and 852 deletions

448
include/CDT/include/CDT.h Normal file
View file

@ -0,0 +1,448 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
/**
* @file
* Public API
*/
#ifndef CDT_lNrmUayWQaIR5fxnsg9B
#define CDT_lNrmUayWQaIR5fxnsg9B
#include "CDTUtils.h"
#include "Triangulation.h"
#include "remove_at.hpp"
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <iterator>
#include <memory>
#include <stack>
#include <vector>
/// Namespace containing triangulation functionality
namespace CDT
{
/** @defgroup API Public API
* Contains API for constrained and conforming Delaunay triangulations
*/
/// @{
/**
* Type used for storing layer depths for triangles
* @note LayerDepth should support 60K+ layers, which could be to much or
* too little for some use cases. Feel free to re-define this typedef.
*/
typedef unsigned short LayerDepth;
typedef LayerDepth BoundaryOverlapCount;
/// Triangles by vertex index
typedef std::vector<TriIndVec> VerticesTriangles;
/** @defgroup helpers Helpers
* Helpers for working with CDT::Triangulation.
*/
/// @{
/**
* Calculate triangles adjacent to vertices (triangles by vertex index)
* @param triangles triangulation
* @param verticesSize total number of vertices to pre-allocate the output
* @return triangles by vertex index
*/
CDT_EXPORT VerticesTriangles
calculateTrianglesByVertex(const TriangleVec& triangles, VertInd verticesSize);
/**
* Information about removed duplicated vertices.
*
* Contains mapping information and removed duplicates indices.
* @note vertices {0,1,2,3,4} where 0 and 3 are the same will produce mapping
* {0,1,2,0,3} (to new vertices {0,1,2,3}) and duplicates {3}
*/
struct CDT_EXPORT DuplicatesInfo
{
std::vector<std::size_t> mapping; ///< vertex index mapping
std::vector<std::size_t> duplicates; ///< duplicates' indices
};
/**
* Find duplicates in given custom point-type range
* @note duplicates are points with exactly same X and Y coordinates
* @tparam TVertexIter iterator that dereferences to custom point type
* @tparam TGetVertexCoordX function object getting x coordinate from vertex.
* Getter signature: const TVertexIter::value_type& -> T
* @tparam TGetVertexCoordY function object getting y coordinate from vertex.
* Getter signature: const TVertexIter::value_type& -> T
* @param first beginning of the range of vertices
* @param last end of the range of vertices
* @param getX getter of X-coordinate
* @param getY getter of Y-coordinate
* @returns information about vertex duplicates
*/
template <
typename T,
typename TVertexIter,
typename TGetVertexCoordX,
typename TGetVertexCoordY>
DuplicatesInfo FindDuplicates(
TVertexIter first,
TVertexIter last,
TGetVertexCoordX getX,
TGetVertexCoordY getY);
/**
* Remove duplicates in-place from vector of custom points
* @tparam TVertex vertex type
* @tparam TAllocator allocator used by input vector of vertices
* @param vertices vertices to remove duplicates from
* @param duplicates information about duplicates
*/
template <typename TVertex, typename TAllocator>
void RemoveDuplicates(
std::vector<TVertex, TAllocator>& vertices,
const std::vector<std::size_t>& duplicates);
/**
* Remove duplicated points in-place
*
* @tparam T type of vertex coordinates (e.g., float, double)
* @param[in, out] vertices collection of vertices to remove duplicates from
* @returns information about duplicated vertices that were removed.
*/
template <typename T>
CDT_EXPORT DuplicatesInfo RemoveDuplicates(std::vector<V2d<T> >& vertices);
/**
* Remap vertex indices in edges (in-place) using given vertex-index mapping.
* @tparam TEdgeIter iterator that dereferences to custom edge type
* @tparam TGetEdgeVertexStart function object getting start vertex index
* from an edge.
* Getter signature: const TEdgeIter::value_type& -> CDT::VertInd
* @tparam TGetEdgeVertexEnd function object getting end vertex index from
* an edge. Getter signature: const TEdgeIter::value_type& -> CDT::VertInd
* @tparam TMakeEdgeFromStartAndEnd function object that makes new edge from
* start and end vertices
* @param first beginning of the range of edges
* @param last end of the range of edges
* @param mapping vertex-index mapping
* @param getStart getter of edge start vertex index
* @param getEnd getter of edge end vertex index
* @param makeEdge factory for making edge from vetices
*/
template <
typename TEdgeIter,
typename TGetEdgeVertexStart,
typename TGetEdgeVertexEnd,
typename TMakeEdgeFromStartAndEnd>
void RemapEdges(
TEdgeIter first,
TEdgeIter last,
const std::vector<std::size_t>& mapping,
TGetEdgeVertexStart getStart,
TGetEdgeVertexEnd getEnd,
TMakeEdgeFromStartAndEnd makeEdge);
/**
* Remap vertex indices in edges (in-place) using given vertex-index mapping.
*
* @note Mapping can be a result of RemoveDuplicates function
* @param[in,out] edges collection of edges to remap
* @param mapping vertex-index mapping
*/
CDT_EXPORT void
RemapEdges(std::vector<Edge>& edges, const std::vector<std::size_t>& mapping);
/**
* Find point duplicates, remove them from vector (in-place) and remap edges
* (in-place)
* @note Same as a chained call of CDT::FindDuplicates, CDT::RemoveDuplicates,
* and CDT::RemapEdges
* @tparam T type of vertex coordinates (e.g., float, double)
* @tparam TVertex type of vertex
* @tparam TGetVertexCoordX function object getting x coordinate from vertex.
* Getter signature: const TVertexIter::value_type& -> T
* @tparam TGetVertexCoordY function object getting y coordinate from vertex.
* Getter signature: const TVertexIter::value_type& -> T
* @tparam TEdgeIter iterator that dereferences to custom edge type
* @tparam TGetEdgeVertexStart function object getting start vertex index
* from an edge.
* Getter signature: const TEdgeIter::value_type& -> CDT::VertInd
* @tparam TGetEdgeVertexEnd function object getting end vertex index from
* an edge. Getter signature: const TEdgeIter::value_type& -> CDT::VertInd
* @tparam TMakeEdgeFromStartAndEnd function object that makes new edge from
* start and end vertices
* @param[in, out] vertices vertices to remove duplicates from
* @param[in, out] edges collection of edges connecting vertices
* @param getX getter of X-coordinate
* @param getY getter of Y-coordinate
* @param edgesFirst beginning of the range of edges
* @param edgesLast end of the range of edges
* @param getStart getter of edge start vertex index
* @param getEnd getter of edge end vertex index
* @param makeEdge factory for making edge from vetices
* @returns information about vertex duplicates
*/
template <
typename T,
typename TVertex,
typename TGetVertexCoordX,
typename TGetVertexCoordY,
typename TVertexAllocator,
typename TEdgeIter,
typename TGetEdgeVertexStart,
typename TGetEdgeVertexEnd,
typename TMakeEdgeFromStartAndEnd>
DuplicatesInfo RemoveDuplicatesAndRemapEdges(
std::vector<TVertex, TVertexAllocator>& vertices,
TGetVertexCoordX getX,
TGetVertexCoordY getY,
TEdgeIter edgesFirst,
TEdgeIter edgesLast,
TGetEdgeVertexStart getStart,
TGetEdgeVertexEnd getEnd,
TMakeEdgeFromStartAndEnd makeEdge);
/**
* Same as a chained call of CDT::RemoveDuplicates + CDT::RemapEdges
*
* @tparam T type of vertex coordinates (e.g., float, double)
* @param[in, out] vertices collection of vertices to remove duplicates from
* @param[in,out] edges collection of edges to remap
*/
template <typename T>
CDT_EXPORT DuplicatesInfo RemoveDuplicatesAndRemapEdges(
std::vector<V2d<T> >& vertices,
std::vector<Edge>& edges);
/**
* Extract all edges of triangles
*
* @param triangles triangles used to extract edges
* @return an unordered set of all edges of triangulation
*/
CDT_EXPORT EdgeUSet extractEdgesFromTriangles(const TriangleVec& triangles);
/*!
* Converts piece->original_edges mapping to original_edge->pieces
* @param pieceToOriginals maps pieces to original edges
* @return mapping of original edges to pieces
*/
CDT_EXPORT unordered_map<Edge, EdgeVec>
EdgeToPiecesMapping(const unordered_map<Edge, EdgeVec>& pieceToOriginals);
/*!
* Convert edge-to-pieces mapping into edge-to-split-vertices mapping
* @tparam T type of vertex coordinates (e.g., float, double)
* @param edgeToPieces edge-to-pieces mapping
* @param vertices vertex buffer
* @return mapping of edge-to-split-points.
* Split points are sorted from edge's start (v1) to end (v2)
*/
template <typename T>
unordered_map<Edge, std::vector<VertInd> > EdgeToSplitVertices(
const unordered_map<Edge, EdgeVec>& edgeToPieces,
const std::vector<V2d<T> >& vertices);
/// @}
/// @}
} // namespace CDT
//*****************************************************************************
// Implementations of template functionlity
//*****************************************************************************
// hash for CDT::V2d<T>
#ifdef CDT_CXX11_IS_SUPPORTED
namespace std
#else
namespace boost
#endif
{
template <typename T>
struct hash<CDT::V2d<T> >
{
size_t operator()(const CDT::V2d<T>& xy) const
{
#ifdef CDT_CXX11_IS_SUPPORTED
typedef std::hash<T> Hasher;
#else
typedef boost::hash<T> Hasher;
#endif
return Hasher()(xy.x) ^ Hasher()(xy.y);
}
};
} // namespace std
namespace CDT
{
//-----
// API
//-----
template <
typename T,
typename TVertexIter,
typename TGetVertexCoordX,
typename TGetVertexCoordY>
DuplicatesInfo FindDuplicates(
TVertexIter first,
TVertexIter last,
TGetVertexCoordX getX,
TGetVertexCoordY getY)
{
typedef unordered_map<V2d<T>, std::size_t> PosToIndex;
PosToIndex uniqueVerts;
const std::size_t verticesSize = std::distance(first, last);
DuplicatesInfo di = {
std::vector<std::size_t>(verticesSize), std::vector<std::size_t>()};
for(std::size_t iIn = 0, iOut = iIn; iIn < verticesSize; ++iIn, ++first)
{
typename PosToIndex::const_iterator it;
bool isUnique;
tie(it, isUnique) = uniqueVerts.insert(
std::make_pair(V2d<T>(getX(*first), getY(*first)), iOut));
if(isUnique)
{
di.mapping[iIn] = iOut++;
continue;
}
di.mapping[iIn] = it->second; // found a duplicate
di.duplicates.push_back(iIn);
}
return di;
}
template <typename TVertex, typename TAllocator>
void RemoveDuplicates(
std::vector<TVertex, TAllocator>& vertices,
const std::vector<std::size_t>& duplicates)
{
vertices.erase(
remove_at(
vertices.begin(),
vertices.end(),
duplicates.begin(),
duplicates.end()),
vertices.end());
}
template <
typename TEdgeIter,
typename TGetEdgeVertexStart,
typename TGetEdgeVertexEnd,
typename TMakeEdgeFromStartAndEnd>
void RemapEdges(
TEdgeIter first,
const TEdgeIter last,
const std::vector<std::size_t>& mapping,
TGetEdgeVertexStart getStart,
TGetEdgeVertexEnd getEnd,
TMakeEdgeFromStartAndEnd makeEdge)
{
for(; first != last; ++first)
{
*first = makeEdge(
static_cast<VertInd>(mapping[getStart(*first)]),
static_cast<VertInd>(mapping[getEnd(*first)]));
}
}
template <
typename T,
typename TVertex,
typename TGetVertexCoordX,
typename TGetVertexCoordY,
typename TVertexAllocator,
typename TEdgeIter,
typename TGetEdgeVertexStart,
typename TGetEdgeVertexEnd,
typename TMakeEdgeFromStartAndEnd>
DuplicatesInfo RemoveDuplicatesAndRemapEdges(
std::vector<TVertex, TVertexAllocator>& vertices,
TGetVertexCoordX getX,
TGetVertexCoordY getY,
const TEdgeIter edgesFirst,
const TEdgeIter edgesLast,
TGetEdgeVertexStart getStart,
TGetEdgeVertexEnd getEnd,
TMakeEdgeFromStartAndEnd makeEdge)
{
const DuplicatesInfo di =
FindDuplicates<T>(vertices.begin(), vertices.end(), getX, getY);
RemoveDuplicates(vertices, di.duplicates);
RemapEdges(edgesFirst, edgesLast, di.mapping, getStart, getEnd, makeEdge);
return di;
}
template <typename T>
unordered_map<Edge, std::vector<VertInd> > EdgeToSplitVertices(
const unordered_map<Edge, EdgeVec>& edgeToPieces,
const std::vector<V2d<T> >& vertices)
{
typedef std::pair<VertInd, T> VertCoordPair;
struct ComparePred
{
bool operator()(const VertCoordPair& a, const VertCoordPair& b) const
{
return a.second < b.second;
}
} comparePred;
unordered_map<Edge, std::vector<VertInd> > edgeToSplitVerts;
typedef unordered_map<Edge, EdgeVec>::const_iterator It;
for(It e2pIt = edgeToPieces.begin(); e2pIt != edgeToPieces.end(); ++e2pIt)
{
const Edge& e = e2pIt->first;
const T dX = vertices[e.v2()].x - vertices[e.v1()].x;
const T dY = vertices[e.v2()].y - vertices[e.v1()].y;
const bool isX = std::abs(dX) >= std::abs(dY); // X-coord longer
const bool isAscending =
isX ? dX >= 0 : dY >= 0; // Longer coordinate ascends
const EdgeVec& pieces = e2pIt->second;
std::vector<VertCoordPair> splitVerts;
// size is: 2[ends] + (pieces - 1)[split vertices] = pieces + 1
splitVerts.reserve(pieces.size() + 1);
typedef EdgeVec::const_iterator EIt;
for(EIt pieceIt = pieces.begin(); pieceIt != pieces.end(); ++pieceIt)
{
const array<VertInd, 2> vv = {pieceIt->v1(), pieceIt->v2()};
typedef array<VertInd, 2>::const_iterator VIt;
for(VIt v = vv.begin(); v != vv.end(); ++v)
{
const T c = isX ? vertices[*v].x : vertices[*v].y;
splitVerts.push_back(std::make_pair(*v, isAscending ? c : -c));
}
}
// sort by longest coordinate
std::sort(splitVerts.begin(), splitVerts.end(), comparePred);
// remove duplicates
splitVerts.erase(
std::unique(splitVerts.begin(), splitVerts.end()),
splitVerts.end());
assert(splitVerts.size() > 2); // 2 end points with split vertices
std::pair<Edge, std::vector<VertInd> > val =
std::make_pair(e, std::vector<VertInd>());
val.second.reserve(splitVerts.size());
typedef typename std::vector<VertCoordPair>::const_iterator SEIt;
for(SEIt it = splitVerts.begin() + 1; it != splitVerts.end() - 1; ++it)
{
val.second.push_back(it->first);
}
edgeToSplitVerts.insert(val);
}
return edgeToSplitVerts;
}
} // namespace CDT
#ifndef CDT_USE_AS_COMPILED_LIBRARY
#include "CDT.hpp"
#endif
#endif // header-guard

107
include/CDT/include/CDT.hpp Normal file
View file

@ -0,0 +1,107 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
/**
* @file
* Public API - implementation
*/
#include "CDT.h"
#include <algorithm>
#include <deque>
#include <limits>
#include <stdexcept>
namespace CDT
{
CDT_INLINE_IF_HEADER_ONLY VerticesTriangles calculateTrianglesByVertex(
const TriangleVec& triangles,
const VertInd verticesSize)
{
VerticesTriangles vertTris(verticesSize);
for(TriInd iT(0); iT < triangles.size(); ++iT)
{
const VerticesArr3& vv = triangles[iT].vertices;
for(VerticesArr3::const_iterator v = vv.begin(); v != vv.end(); ++v)
{
vertTris[*v].push_back(iT);
}
}
return vertTris;
}
template <typename T>
DuplicatesInfo RemoveDuplicates(std::vector<V2d<T> >& vertices)
{
const DuplicatesInfo di = FindDuplicates<T>(
vertices.begin(), vertices.end(), getX_V2d<T>, getY_V2d<T>);
RemoveDuplicates(vertices, di.duplicates);
return di;
}
CDT_INLINE_IF_HEADER_ONLY void
RemapEdges(std::vector<Edge>& edges, const std::vector<std::size_t>& mapping)
{
RemapEdges(
edges.begin(),
edges.end(),
mapping,
edge_get_v1,
edge_get_v2,
edge_make);
}
template <typename T>
DuplicatesInfo RemoveDuplicatesAndRemapEdges(
std::vector<V2d<T> >& vertices,
std::vector<Edge>& edges)
{
return RemoveDuplicatesAndRemapEdges<T>(
vertices,
getX_V2d<T>,
getY_V2d<T>,
edges.begin(),
edges.end(),
edge_get_v1,
edge_get_v2,
edge_make);
}
CDT_INLINE_IF_HEADER_ONLY EdgeUSet
extractEdgesFromTriangles(const TriangleVec& triangles)
{
EdgeUSet edges;
typedef TriangleVec::const_iterator CIt;
for(CIt t = triangles.begin(); t != triangles.end(); ++t)
{
edges.insert(Edge(VertInd(t->vertices[0]), VertInd(t->vertices[1])));
edges.insert(Edge(VertInd(t->vertices[1]), VertInd(t->vertices[2])));
edges.insert(Edge(VertInd(t->vertices[2]), VertInd(t->vertices[0])));
}
return edges;
}
CDT_INLINE_IF_HEADER_ONLY unordered_map<Edge, EdgeVec>
EdgeToPiecesMapping(const unordered_map<Edge, EdgeVec>& pieceToOriginals)
{
unordered_map<Edge, EdgeVec> originalToPieces;
typedef unordered_map<Edge, EdgeVec>::const_iterator Cit;
for(Cit ptoIt = pieceToOriginals.begin(); ptoIt != pieceToOriginals.end();
++ptoIt)
{
const Edge piece = ptoIt->first;
const EdgeVec& originals = ptoIt->second;
for(EdgeVec::const_iterator origIt = originals.begin();
origIt != originals.end();
++origIt)
{
originalToPieces[*origIt].push_back(piece);
}
}
return originalToPieces;
}
} // namespace CDT

View file

@ -0,0 +1,592 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
/**
* @file
* Utilities and helpers
*/
#ifndef CDT_obwOaxOTdAWcLNTlNnaq
#define CDT_obwOaxOTdAWcLNTlNnaq
#ifdef CDT_DONT_USE_BOOST_RTREE
// CDT_DONT_USE_BOOST_RTREE was replaced with CDT_USE_BOOST
typedef char CDT_DONT_USE_BOOST_RTREE__was__replaced__with__CDT_USE_BOOST[-1];
#endif
// #define CDT_USE_STRONG_TYPING // strong type checks on indices
// check if c++11 is supported
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
#define CDT_CXX11_IS_SUPPORTED
#elif !defined(__cplusplus) && !defined(_MSC_VER)
typedef char couldnt_parse_cxx_standard[-1]; ///< Error: couldn't parse standard
#endif
// Functions defined outside the class need to be 'inline'
// if CDT is configured to be used as header-only library:
// single-definition rule is violated otherwise
#ifdef CDT_USE_AS_COMPILED_LIBRARY
#define CDT_INLINE_IF_HEADER_ONLY
#include "cdt_export.h" // automatically generated by CMake
#else
/**
* Macro for inlining non-template functions when in header-only mode to
* avoid multiple declaration errors.
*/
#define CDT_INLINE_IF_HEADER_ONLY inline
/// Export not needed in header-only mode
#define CDT_EXPORT
#endif
#include <algorithm>
#include <cassert>
#include <cmath>
#include <limits>
#include <vector>
#ifdef CDT_USE_STRONG_TYPING
#include <boost/serialization/strong_typedef.hpp>
#endif
// use fall-backs for c++11 features
#ifdef CDT_CXX11_IS_SUPPORTED
#include <array>
#include <functional>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#ifdef CDT_DISABLE_EXCEPTIONS
#include <exception>
#endif
namespace CDT
{
using std::array;
using std::get;
using std::make_tuple;
using std::tie;
using std::to_string;
using std::tuple;
using std::unordered_map;
using std::unordered_set;
} // namespace CDT
#else
#include <boost/array.hpp>
#include <boost/functional/hash.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
namespace CDT
{
using boost::array;
using boost::get;
using boost::make_tuple;
using boost::tie;
using boost::tuple;
using boost::unordered_map;
using boost::unordered_set;
template <typename T>
std::string to_string(const T& value)
{
return boost::lexical_cast<std::string>(value);
}
} // namespace CDT
#endif
namespace CDT
{
template <typename T>
void handleException(const T& error)
{
#ifdef CDT_DISABLE_EXCEPTIONS
std::terminate();
#else
throw error;
#endif
}
/// Needed for c++03 compatibility (no uniform initialization available)
template <typename T>
array<T, 3> arr3(const T& v0, const T& v1, const T& v2)
{
const array<T, 3> out = {v0, v1, v2};
return out;
}
/// Needed for c++03 compatibility (no uniform initialization available)
template <typename T>
array<T, 3> arr3(const T& v)
{
const array<T, 3> out = {v, v, v};
return out;
}
/// 2D vector
template <typename T>
struct CDT_EXPORT V2d
{
T x; ///< X-coordinate
T y; ///< Y-coordinate
/// Vertex with zero coordinates
V2d()
: x(T(0))
, y(T(0))
{}
/// Vertex with given coordinates
V2d(const T x, const T y)
: x(x)
, y(y)
{}
};
/// X- coordinate getter for V2d
template <typename T>
const T& getX_V2d(const V2d<T>& v)
{
return v.x;
}
/// Y-coordinate getter for V2d
template <typename T>
const T& getY_V2d(const V2d<T>& v)
{
return v.y;
}
/// If two 2D vectors are exactly equal
template <typename T>
bool operator==(const CDT::V2d<T>& lhs, const CDT::V2d<T>& rhs)
{
return lhs.x == rhs.x && lhs.y == rhs.y;
}
#ifdef CDT_USE_64_BIT_INDEX_TYPE
typedef unsigned long long IndexSizeType;
#else
typedef unsigned int IndexSizeType;
#endif
#ifdef CDT_USE_STRONG_TYPING
/// Index in triangle
BOOST_STRONG_TYPEDEF(unsigned char, Index);
/// Vertex index
BOOST_STRONG_TYPEDEF(IndexSizeType, VertInd);
/// Triangle index
BOOST_STRONG_TYPEDEF(IndexSizeType, TriInd);
#else
/// Index in triangle
typedef unsigned char Index;
/// Vertex index
typedef IndexSizeType VertInd;
/// Triangle index
typedef IndexSizeType TriInd;
#endif
/// Constant representing no valid value for index
const static Index invalidIndex(std::numeric_limits<Index>::max());
/// Constant representing no valid value for index size
const static IndexSizeType
invalidIndexSizeType(std::numeric_limits<IndexSizeType>::max());
/// Number of super triangle vertices
/// @note placed in a constant so that it's easier to find usages in code
const static IndexSizeType nSuperTriangleVertices(3);
/// Constant representing no valid neighbor for a triangle
const static TriInd noNeighbor(invalidIndexSizeType);
/// Constant representing no valid vertex for a triangle
const static VertInd noVertex(invalidIndexSizeType);
typedef std::vector<TriInd> TriIndVec; ///< Vector of triangle indices
typedef array<VertInd, 3> VerticesArr3; ///< array of three vertex indices
typedef array<TriInd, 3> NeighborsArr3; ///< array of three neighbors
/// 2D bounding box
template <typename T>
struct CDT_EXPORT Box2d
{
V2d<T> min; ///< min box corner
V2d<T> max; ///< max box corner
/// Box that doesn't contain any point
Box2d()
: min(std::numeric_limits<T>::max(), std::numeric_limits<T>::max())
, max(-std::numeric_limits<T>::max(), -std::numeric_limits<T>::max())
{}
/// Envelop box around a point
Box2d<T>& envelopPoint(const V2d<T>& p)
{
return envelopPoint(p.x, p.y);
}
/// Envelop box around a point with given coordinates
Box2d<T>& envelopPoint(const T x, const T y)
{
min.x = std::min(x, min.x);
max.x = std::max(x, max.x);
min.y = std::min(y, min.y);
max.y = std::max(y, max.y);
return *this;
}
/// Envelop box around a collection of custom points
template <
typename TVertexIter,
typename TGetVertexCoordX,
typename TGetVertexCoordY>
Box2d<T>& envelopPoints(
TVertexIter first,
TVertexIter last,
TGetVertexCoordX getX,
TGetVertexCoordY getY)
{
for(; first != last; ++first)
{
envelopPoint(getX(*first), getY(*first));
}
return *this;
}
/// Envelop box around a collection of points
Box2d<T>& envelopPoints(const std::vector<V2d<T> >& vertices)
{
return envelopPoints(
vertices.begin(), vertices.end(), getX_V2d<T>, getY_V2d<T>);
}
};
/// Edge connecting two vertices: vertex with smaller index is always first
/// @note: hash Edge is specialized at the bottom
struct CDT_EXPORT Edge
{
/// Constructor
Edge(const VertInd iV1, const VertInd iV2)
: m_vertices(
iV1 < iV2 ? std::make_pair(iV1, iV2) : std::make_pair(iV2, iV1))
{}
/// Equals operator
bool operator==(const Edge& other) const
{
return m_vertices == other.m_vertices;
}
/// Not-equals operator
bool operator!=(const Edge& other) const
{
return !(this->operator==(other));
}
/// V1 getter
VertInd v1() const
{
return m_vertices.first;
}
/// V2 getter
VertInd v2() const
{
return m_vertices.second;
}
/// Edges' vertices
const std::pair<VertInd, VertInd>& verts() const
{
return m_vertices;
}
private:
std::pair<VertInd, VertInd> m_vertices;
};
/// Get edge first vertex
inline VertInd edge_get_v1(const Edge& e)
{
return e.v1();
}
/// Get edge second vertex
inline VertInd edge_get_v2(const Edge& e)
{
return e.v2();
}
/// Get edge second vertex
inline Edge edge_make(VertInd iV1, VertInd iV2)
{
return Edge(iV1, iV2);
}
typedef std::vector<Edge> EdgeVec; ///< Vector of edges
typedef unordered_set<Edge> EdgeUSet; ///< Hash table of edges
typedef unordered_set<TriInd> TriIndUSet; ///< Hash table of triangles
typedef unordered_map<TriInd, TriInd> TriIndUMap; ///< Triangle hash map
/// Triangulation triangle (counter-clockwise winding)
/*
* v3
* /\
* n3/ \n2
* /____\
* v1 n1 v2
*/
struct CDT_EXPORT Triangle
{
VerticesArr3 vertices; ///< triangle's three vertices
NeighborsArr3 neighbors; ///< triangle's three neighbors
/// Triangle with no vertices and no neighbors
Triangle()
: vertices(arr3(noVertex))
, neighbors(arr3(noNeighbor))
{}
/// Triangle with given vertices and neighbors
Triangle(const VerticesArr3& vertices, const NeighborsArr3& neighbors)
: vertices(vertices)
, neighbors(neighbors)
{}
/// Next triangle adjacent to a vertex (clockwise)
/// @returns pair of next triangle and the other vertex of a common edge
std::pair<TriInd, VertInd> next(const VertInd i) const
{
assert(vertices[0] == i || vertices[1] == i || vertices[2] == i);
if(vertices[0] == i)
{
return std::make_pair(neighbors[0], vertices[1]);
}
if(vertices[1] == i)
{
return std::make_pair(neighbors[1], vertices[2]);
}
return std::make_pair(neighbors[2], vertices[0]);
}
/// Previous triangle adjacent to a vertex (counter-clockwise)
/// @returns pair of previous triangle and the other vertex of a common edge
std::pair<TriInd, VertInd> prev(const VertInd i) const
{
assert(vertices[0] == i || vertices[1] == i || vertices[2] == i);
if(vertices[0] == i)
return std::make_pair(neighbors[2], vertices[2]);
if(vertices[1] == i)
return std::make_pair(neighbors[0], vertices[0]);
return std::make_pair(neighbors[1], vertices[1]);
}
/// Check if triangle contains a vertex
bool containsVertex(const VertInd i) const
{
return std::find(vertices.begin(), vertices.end(), i) != vertices.end();
}
};
typedef std::vector<Triangle> TriangleVec; ///< Vector of triangles
/// Advance vertex or neighbor index counter-clockwise
CDT_EXPORT Index ccw(Index i);
/// Advance vertex or neighbor index clockwise
CDT_EXPORT Index cw(Index i);
/// Location of point on a triangle
struct CDT_EXPORT PtTriLocation
{
/// Enum
enum Enum
{
Inside,
Outside,
OnEdge1,
OnEdge2,
OnEdge3,
OnVertex,
};
};
/// Check if location is classified as on any of three edges
CDT_EXPORT bool isOnEdge(PtTriLocation::Enum location);
/// Neighbor index from a on-edge location
/// @note Call only if located on the edge!
CDT_EXPORT Index edgeNeighbor(PtTriLocation::Enum location);
/// Relative location of point to a line
struct CDT_EXPORT PtLineLocation
{
/// Enum
enum Enum
{
Left,
Right,
OnLine,
};
};
/// Orient p against line v1-v2 2D: robust geometric predicate
template <typename T>
CDT_EXPORT T orient2D(const V2d<T>& p, const V2d<T>& v1, const V2d<T>& v2);
/// Check if point lies to the left of, to the right of, or on a line
template <typename T>
CDT_EXPORT PtLineLocation::Enum locatePointLine(
const V2d<T>& p,
const V2d<T>& v1,
const V2d<T>& v2,
T orientationTolerance = T(0));
/// Classify value of orient2d predicate
template <typename T>
CDT_EXPORT PtLineLocation::Enum
classifyOrientation(T orientation, T orientationTolerance = T(0));
/// Check if point a lies inside of, outside of, or on an edge of a triangle
template <typename T>
CDT_EXPORT PtTriLocation::Enum locatePointTriangle(
const V2d<T>& p,
const V2d<T>& v1,
const V2d<T>& v2,
const V2d<T>& v3);
/// Opposed neighbor index from vertex index
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY Index opoNbr(Index vertIndex);
/// Opposed vertex index from neighbor index
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY Index opoVrt(Index neighborIndex);
/// Index of triangle's neighbor opposed to a vertex
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY Index
opposedTriangleInd(const VerticesArr3& vv, VertInd iVert);
/// Index of triangle's neighbor opposed to an edge
CDT_INLINE_IF_HEADER_ONLY Index
edgeNeighborInd(const VerticesArr3& vv, VertInd iVedge1, VertInd iVedge2);
/// Index of triangle's vertex opposed to a triangle
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY Index
opposedVertexInd(const NeighborsArr3& nn, TriInd iTopo);
/// If triangle has a given vertex return vertex-index
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY Index
vertexInd(const VerticesArr3& vv, VertInd iV);
/// Given triangle and a vertex find opposed triangle
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY TriInd
opposedTriangle(const Triangle& tri, VertInd iVert);
/// Given triangle and an edge find neighbor sharing the edge
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY TriInd
edgeNeighbor(const Triangle& tri, VertInd iVedge1, VertInd iVedge2);
/// Given two triangles, return vertex of first triangle opposed to the second
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY VertInd
opposedVertex(const Triangle& tri, TriInd iTopo);
/// Test if point lies in a circumscribed circle of a triangle
template <typename T>
CDT_EXPORT bool isInCircumcircle(
const V2d<T>& p,
const V2d<T>& v1,
const V2d<T>& v2,
const V2d<T>& v3);
/// Test if two vertices share at least one common triangle
CDT_EXPORT CDT_INLINE_IF_HEADER_ONLY bool
verticesShareEdge(const TriIndVec& aTris, const TriIndVec& bTris);
/// Distance between two 2D points
template <typename T>
CDT_EXPORT T distance(const V2d<T>& a, const V2d<T>& b);
/// Squared distance between two 2D points
template <typename T>
CDT_EXPORT T distanceSquared(const V2d<T>& a, const V2d<T>& b);
/// Check if any of triangle's vertices belongs to a super-triangle
CDT_INLINE_IF_HEADER_ONLY bool touchesSuperTriangle(const Triangle& t);
} // namespace CDT
#ifndef CDT_USE_AS_COMPILED_LIBRARY
#include "CDTUtils.hpp"
#endif
//*****************************************************************************
// Specialize hash functions
//*****************************************************************************
#ifdef CDT_CXX11_IS_SUPPORTED
namespace std
#else
namespace boost
#endif
{
#ifdef CDT_USE_STRONG_TYPING
/// Vertex index hasher
template <>
struct hash<CDT::VertInd>
{
/// Hash operator
std::size_t operator()(const CDT::VertInd& vi) const
{
return std::hash<std::size_t>()(vi.t);
}
};
/// Triangle index hasher
template <>
struct hash<CDT::TriInd>
{
/// Hash operator
std::size_t operator()(const CDT::TriInd& vi) const
{
return std::hash<std::size_t>()(vi.t);
}
};
#endif // CDT_USE_STRONG_TYPING
/// Edge hasher
template <>
struct hash<CDT::Edge>
{
/// Hash operator
std::size_t operator()(const CDT::Edge& e) const
{
return hashEdge(e);
}
private:
static void hashCombine(std::size_t& seed, const CDT::VertInd& key)
{
#ifdef CDT_CXX11_IS_SUPPORTED
typedef std::hash<CDT::VertInd> Hasher;
#else
typedef boost::hash<CDT::VertInd> Hasher;
#endif
seed ^= Hasher()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
static std::size_t hashEdge(const CDT::Edge& e)
{
std::size_t seed(0);
hashCombine(seed, e.v1());
hashCombine(seed, e.v2());
return seed;
}
};
} // namespace std/boost
#endif // header guard

View file

@ -0,0 +1,264 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
/**
* @file
* Utilities and helpers - implementation
*/
#include "CDTUtils.h"
#include "predicates.h" // robust predicates: orient, in-circle
#include <stdexcept>
namespace CDT
{
CDT_INLINE_IF_HEADER_ONLY Index ccw(Index i)
{
return Index((i + 1) % 3);
}
CDT_INLINE_IF_HEADER_ONLY Index cw(Index i)
{
return Index((i + 2) % 3);
}
CDT_INLINE_IF_HEADER_ONLY bool isOnEdge(const PtTriLocation::Enum location)
{
return location == PtTriLocation::OnEdge1 ||
location == PtTriLocation::OnEdge2 ||
location == PtTriLocation::OnEdge3;
}
CDT_INLINE_IF_HEADER_ONLY Index edgeNeighbor(const PtTriLocation::Enum location)
{
assert(isOnEdge(location));
return static_cast<Index>(location - PtTriLocation::OnEdge1);
}
template <typename T>
T orient2D(const V2d<T>& p, const V2d<T>& v1, const V2d<T>& v2)
{
return predicates::adaptive::orient2d(v1.x, v1.y, v2.x, v2.y, p.x, p.y);
}
template <typename T>
PtLineLocation::Enum locatePointLine(
const V2d<T>& p,
const V2d<T>& v1,
const V2d<T>& v2,
const T orientationTolerance)
{
return classifyOrientation(orient2D(p, v1, v2), orientationTolerance);
}
template <typename T>
PtLineLocation::Enum
classifyOrientation(const T orientation, const T orientationTolerance)
{
if(orientation < -orientationTolerance)
return PtLineLocation::Right;
if(orientation > orientationTolerance)
return PtLineLocation::Left;
return PtLineLocation::OnLine;
}
template <typename T>
PtTriLocation::Enum locatePointTriangle(
const V2d<T>& p,
const V2d<T>& v1,
const V2d<T>& v2,
const V2d<T>& v3)
{
using namespace predicates::adaptive;
PtTriLocation::Enum result = PtTriLocation::Inside;
PtLineLocation::Enum edgeCheck = locatePointLine(p, v1, v2);
if(edgeCheck == PtLineLocation::Right)
return PtTriLocation::Outside;
if(edgeCheck == PtLineLocation::OnLine)
result = PtTriLocation::OnEdge1;
edgeCheck = locatePointLine(p, v2, v3);
if(edgeCheck == PtLineLocation::Right)
return PtTriLocation::Outside;
if(edgeCheck == PtLineLocation::OnLine)
{
result = (result == PtTriLocation::Inside) ? PtTriLocation::OnEdge2
: PtTriLocation::OnVertex;
}
edgeCheck = locatePointLine(p, v3, v1);
if(edgeCheck == PtLineLocation::Right)
return PtTriLocation::Outside;
if(edgeCheck == PtLineLocation::OnLine)
{
result = (result == PtTriLocation::Inside) ? PtTriLocation::OnEdge3
: PtTriLocation::OnVertex;
}
return result;
}
CDT_INLINE_IF_HEADER_ONLY Index opoNbr(const Index vertIndex)
{
if(vertIndex == Index(0))
return Index(1);
if(vertIndex == Index(1))
return Index(2);
if(vertIndex == Index(2))
return Index(0);
assert(false && "Invalid vertex index");
handleException(std::runtime_error("Invalid vertex index"));
return invalidIndex;
}
CDT_INLINE_IF_HEADER_ONLY Index opoVrt(const Index neighborIndex)
{
if(neighborIndex == Index(0))
return Index(2);
if(neighborIndex == Index(1))
return Index(0);
if(neighborIndex == Index(2))
return Index(1);
assert(false && "Invalid neighbor index");
handleException(std::runtime_error("Invalid neighbor index"));
return invalidIndex;
}
CDT_INLINE_IF_HEADER_ONLY Index
opposedTriangleInd(const VerticesArr3& vv, const VertInd iVert)
{
assert(vv[0] == iVert || vv[1] == iVert || vv[2] == iVert);
if(vv[0] == iVert)
return Index(1);
if(vv[1] == iVert)
return Index(2);
return Index(0);
}
CDT_INLINE_IF_HEADER_ONLY Index edgeNeighborInd(
const VerticesArr3& vv,
const VertInd iVedge1,
const VertInd iVedge2)
{
assert(vv[0] == iVedge1 || vv[1] == iVedge1 || vv[2] == iVedge1);
assert(vv[0] == iVedge2 || vv[1] == iVedge2 || vv[2] == iVedge2);
assert(
(vv[0] != iVedge1 && vv[0] != iVedge2) ||
(vv[1] != iVedge1 && vv[1] != iVedge2) ||
(vv[2] != iVedge1 && vv[2] != iVedge2));
/*
* vv[2]
* /\
* n[2]/ \n[1]
* /____\
* vv[0] n[0] vv[1]
*/
if(vv[0] == iVedge1)
{
if(vv[1] == iVedge2)
return Index(0);
return Index(2);
}
if(vv[0] == iVedge2)
{
if(vv[1] == iVedge1)
return Index(0);
return Index(2);
}
return Index(1);
}
CDT_INLINE_IF_HEADER_ONLY Index
opposedVertexInd(const NeighborsArr3& nn, const TriInd iTopo)
{
assert(nn[0] == iTopo || nn[1] == iTopo || nn[2] == iTopo);
if(nn[0] == iTopo)
return Index(2);
if(nn[1] == iTopo)
return Index(0);
return Index(1);
}
CDT_INLINE_IF_HEADER_ONLY Index
vertexInd(const VerticesArr3& vv, const VertInd iV)
{
assert(vv[0] == iV || vv[1] == iV || vv[2] == iV);
if(vv[0] == iV)
return Index(0);
if(vv[1] == iV)
return Index(1);
return Index(2);
}
CDT_INLINE_IF_HEADER_ONLY TriInd
opposedTriangle(const Triangle& tri, const VertInd iVert)
{
return tri.neighbors[opposedTriangleInd(tri.vertices, iVert)];
}
CDT_INLINE_IF_HEADER_ONLY VertInd
opposedVertex(const Triangle& tri, const TriInd iTopo)
{
return tri.vertices[opposedVertexInd(tri.neighbors, iTopo)];
}
/// Given triangle and an edge find neighbor sharing the edge
CDT_INLINE_IF_HEADER_ONLY TriInd
edgeNeighbor(const Triangle& tri, VertInd iVedge1, VertInd iVedge2)
{
return tri.neighbors[edgeNeighborInd(tri.vertices, iVedge1, iVedge2)];
}
template <typename T>
bool isInCircumcircle(
const V2d<T>& p,
const V2d<T>& v1,
const V2d<T>& v2,
const V2d<T>& v3)
{
using namespace predicates::adaptive;
return incircle(v1.x, v1.y, v2.x, v2.y, v3.x, v3.y, p.x, p.y) > T(0);
}
CDT_INLINE_IF_HEADER_ONLY
bool verticesShareEdge(const TriIndVec& aTris, const TriIndVec& bTris)
{
for(TriIndVec::const_iterator it = aTris.begin(); it != aTris.end(); ++it)
if(std::find(bTris.begin(), bTris.end(), *it) != bTris.end())
return true;
return false;
}
template <typename T>
T distanceSquared(const T ax, const T ay, const T bx, const T by)
{
const T dx = bx - ax;
const T dy = by - ay;
return dx * dx + dy * dy;
}
template <typename T>
T distance(const T ax, const T ay, const T bx, const T by)
{
return std::sqrt(distanceSquared(ax, ay, bx, by));
}
template <typename T>
T distance(const V2d<T>& a, const V2d<T>& b)
{
return distance(a.x, a.y, b.x, b.y);
}
template <typename T>
T distanceSquared(const V2d<T>& a, const V2d<T>& b)
{
return distanceSquared(a.x, a.y, b.x, b.y);
}
bool touchesSuperTriangle(const Triangle& t)
{
return t.vertices[0] < 3 || t.vertices[1] < 3 || t.vertices[2] < 3;
}
} // namespace CDT

View file

@ -0,0 +1,471 @@
/// This Source Code Form is subject to the terms of the Mozilla Public
/// License, v. 2.0. If a copy of the MPL was not distributed with this
/// file, You can obtain one at https://mozilla.org/MPL/2.0/.
/// Contribution of original implementation:
/// Andre Fecteau <andre.fecteau1@gmail.com>
#ifndef KDTREE_KDTREE_H
#define KDTREE_KDTREE_H
#include "CDTUtils.h"
#include <limits>
namespace CDT
{
namespace KDTree
{
struct NodeSplitDirection
{
enum Enum
{
X,
Y,
};
};
/// Simple tree structure with alternating half splitting nodes
/// @details Simple tree structure
/// - Tree to incrementally add points to the structure.
/// - Get the nearest point to a given input.
/// - Does not check for duplicates, expect unique points.
/// @tparam TCoordType type used for storing point coordinate.
/// @tparam NumVerticesInLeaf The number of points per leaf.
/// @tparam InitialStackDepth initial size of stack depth for nearest query.
/// Should be at least 1.
/// @tparam StackDepthIncrement increment of stack depth for nearest query when
/// stack depth is reached.
template <
typename TCoordType,
size_t NumVerticesInLeaf,
size_t InitialStackDepth,
size_t StackDepthIncrement>
class KDTree
{
public:
typedef TCoordType coord_type;
typedef CDT::V2d<coord_type> point_type;
typedef CDT::VertInd point_index;
typedef std::pair<point_type, point_index> value_type;
typedef std::vector<point_index> point_data_vec;
typedef point_data_vec::const_iterator pd_cit;
typedef CDT::VertInd node_index;
typedef CDT::array<node_index, 2> children_type;
/// Stores kd-tree node data
struct Node
{
children_type children; ///< two children if not leaf; {0,0} if leaf
point_data_vec data; ///< points' data if leaf
/// Create empty leaf
Node()
{
setChildren(node_index(0), node_index(0));
data.reserve(NumVerticesInLeaf);
}
/// Children setter for convenience
void setChildren(const node_index c1, const node_index c2)
{
children[0] = c1;
children[1] = c2;
}
/// Check if node is a leaf (has no valid children)
bool isLeaf() const
{
return children[0] == children[1];
}
};
/// Default constructor
KDTree()
: m_rootDir(NodeSplitDirection::X)
, m_min(point_type(
-std::numeric_limits<coord_type>::max(),
-std::numeric_limits<coord_type>::max()))
, m_max(point_type(
std::numeric_limits<coord_type>::max(),
std::numeric_limits<coord_type>::max()))
, m_size(0)
, m_isRootBoxInitialized(false)
, m_tasksStack(InitialStackDepth, NearestTask())
{
m_root = addNewNode();
}
/// Constructor with bounding box known in advance
KDTree(const point_type& min, const point_type& max)
: m_rootDir(NodeSplitDirection::X)
, m_min(min)
, m_max(max)
, m_size(0)
, m_isRootBoxInitialized(true)
, m_tasksStack(InitialStackDepth, NearestTask())
{
m_root = addNewNode();
}
CDT::VertInd size() const
{
return m_size;
}
/// Insert a point into kd-tree
/// @note external point-buffer is used to reduce kd-tree's memory footprint
/// @param iPoint index of point in external point-buffer
/// @param points external point-buffer
void
insert(const point_index& iPoint, const std::vector<point_type>& points)
{
++m_size;
// if point is outside root, extend tree by adding new roots
const point_type& pos = points[iPoint];
while(!isInsideBox(pos, m_min, m_max))
{
extendTree(pos);
}
// now insert the point into the tree
node_index node = m_root;
point_type min = m_min;
point_type max = m_max;
NodeSplitDirection::Enum dir = m_rootDir;
// below: initialized only to suppress warnings
NodeSplitDirection::Enum newDir(NodeSplitDirection::X);
coord_type mid(0);
point_type newMin, newMax;
while(true)
{
if(m_nodes[node].isLeaf())
{
// add point if capacity is not reached
point_data_vec& pd = m_nodes[node].data;
if(pd.size() < NumVerticesInLeaf)
{
pd.push_back(iPoint);
return;
}
// initialize bbox first time the root capacity is reached
if(!m_isRootBoxInitialized)
{
initializeRootBox(points);
min = m_min;
max = m_max;
}
// split a full leaf node
calcSplitInfo(min, max, dir, mid, newDir, newMin, newMax);
const node_index c1 = addNewNode(), c2 = addNewNode();
Node& n = m_nodes[node];
n.setChildren(c1, c2);
point_data_vec& c1data = m_nodes[c1].data;
point_data_vec& c2data = m_nodes[c2].data;
// move node's points to children
for(pd_cit it = n.data.begin(); it != n.data.end(); ++it)
{
whichChild(points[*it], mid, dir) == 0
? c1data.push_back(*it)
: c2data.push_back(*it);
}
n.data = point_data_vec();
}
else
{
calcSplitInfo(min, max, dir, mid, newDir, newMin, newMax);
}
// add the point to a child
const std::size_t iChild = whichChild(points[iPoint], mid, dir);
iChild == 0 ? max = newMax : min = newMin;
node = m_nodes[node].children[iChild];
dir = newDir;
}
}
/// Query kd-tree for a nearest neighbor point
/// @note external point-buffer is used to reduce kd-tree's memory footprint
/// @param point query point position
/// @param points external point-buffer
value_type nearest(
const point_type& point,
const std::vector<point_type>& points) const
{
value_type out;
int iTask = -1;
coord_type minDistSq = std::numeric_limits<coord_type>::max();
m_tasksStack[++iTask] = NearestTask(
m_root,
m_min,
m_max,
m_rootDir,
distanceSquaredToBox(point, m_min, m_max));
while(iTask != -1)
{
const NearestTask t = m_tasksStack[iTask--];
if(t.distSq > minDistSq)
continue;
const Node& n = m_nodes[t.node];
if(n.isLeaf())
{
for(pd_cit it = n.data.begin(); it != n.data.end(); ++it)
{
const point_type& p = points[*it];
const coord_type distSq = CDT::distanceSquared(point, p);
if(distSq < minDistSq)
{
minDistSq = distSq;
out.first = p;
out.second = *it;
}
}
}
else
{
coord_type mid(0);
NodeSplitDirection::Enum newDir(NodeSplitDirection::X);
point_type newMin = t.min, newMax = t.max;
coord_type dSqFarther = std::numeric_limits<coord_type>::max();
switch(t.dir)
{
case NodeSplitDirection::X:
{
mid = (t.min.x + t.max.x) / coord_type(2);
newDir = NodeSplitDirection::Y;
newMin.x = mid;
newMax.x = mid;
const coord_type dx = point.x - mid;
const coord_type dy = std::max(
std::max(t.min.y - point.y, coord_type(0)),
point.y - t.max.y);
dSqFarther = dx * dx + dy * dy;
break;
}
case NodeSplitDirection::Y:
{
mid = (t.min.y + t.max.y) / coord_type(2);
newDir = NodeSplitDirection::X;
newMin.y = mid;
newMax.y = mid;
const coord_type dx = std::max(
std::max(t.min.x - point.x, coord_type(0)),
point.x - t.max.x);
const coord_type dy = point.y - mid;
dSqFarther = dx * dx + dy * dy;
break;
}
}
if(iTask + 2 >= static_cast<int>(m_tasksStack.size()))
{
m_tasksStack.resize(
m_tasksStack.size() + StackDepthIncrement);
}
// put the closest node on top of the stack
if(isAfterSplit(point, mid, t.dir))
{
if(dSqFarther <= minDistSq)
{
m_tasksStack[++iTask] = NearestTask(
n.children[0], t.min, newMax, newDir, dSqFarther);
}
m_tasksStack[++iTask] = NearestTask(
n.children[1], newMin, t.max, newDir, t.distSq);
}
else
{
if(dSqFarther <= minDistSq)
{
m_tasksStack[++iTask] = NearestTask(
n.children[1], newMin, t.max, newDir, dSqFarther);
}
m_tasksStack[++iTask] = NearestTask(
n.children[0], t.min, newMax, newDir, t.distSq);
}
}
}
return out;
}
private:
/// Add a new node and return it's index in nodes buffer
node_index addNewNode()
{
const node_index newNodeIndex = static_cast<node_index>(m_nodes.size());
m_nodes.push_back(Node());
return newNodeIndex;
}
static bool isAfterSplit(
const point_type& point,
const coord_type& split,
const NodeSplitDirection::Enum dir)
{
return dir == NodeSplitDirection::X ? point.x > split : point.y > split;
}
/// Test which child point belongs to after the split
/// @returns 0 if first child, 1 if second child
static std::size_t whichChild(
const point_type& point,
const coord_type& split,
const NodeSplitDirection::Enum dir)
{
return isAfterSplit(point, split, dir);
}
/// Calculate split location, direction, and children boxes
static void calcSplitInfo(
const point_type& min,
const point_type& max,
const NodeSplitDirection::Enum dir,
coord_type& midOut,
NodeSplitDirection::Enum& newDirOut,
point_type& newMinOut,
point_type& newMaxOut)
{
newMaxOut = max;
newMinOut = min;
switch(dir)
{
case NodeSplitDirection::X:
midOut = (min.x + max.x) / coord_type(2);
newDirOut = NodeSplitDirection::Y;
newMinOut.x = midOut;
newMaxOut.x = midOut;
return;
case NodeSplitDirection::Y:
midOut = (min.y + max.y) / coord_type(2);
newDirOut = NodeSplitDirection::X;
newMinOut.y = midOut;
newMaxOut.y = midOut;
return;
}
}
/// Test if point is inside a box
static bool isInsideBox(
const point_type& p,
const point_type& min,
const point_type& max)
{
return p.x >= min.x && p.x <= max.x && p.y >= min.y && p.y <= max.y;
}
/// Extend a tree by creating new root with old root and a new node as
/// children
void extendTree(const point_type& point)
{
const node_index newRoot = addNewNode();
const node_index newLeaf = addNewNode();
switch(m_rootDir)
{
case NodeSplitDirection::X:
m_rootDir = NodeSplitDirection::Y;
if(point.y < m_min.y)
{
m_min.y -= m_max.y - m_min.y;
m_nodes[newRoot].setChildren(newLeaf, m_root);
}
else
{
m_max.y += m_max.y - m_min.y;
m_nodes[newRoot].setChildren(m_root, newLeaf);
}
break;
case NodeSplitDirection::Y:
m_rootDir = NodeSplitDirection::X;
if(point.x < m_min.x)
{
m_min.x -= m_max.x - m_min.x;
m_nodes[newRoot].setChildren(newLeaf, m_root);
}
else
{
m_max.x += m_max.x - m_min.x;
m_nodes[newRoot].setChildren(m_root, newLeaf);
}
break;
}
m_root = newRoot;
}
/// Calculate root's box enclosing all root points
void initializeRootBox(const std::vector<point_type>& points)
{
const point_data_vec& data = m_nodes[m_root].data;
m_min = points[data.front()];
m_max = m_min;
for(pd_cit it = data.begin(); it != data.end(); ++it)
{
const point_type& p = points[*it];
m_min = point_type(std::min(m_min.x, p.x), std::min(m_min.y, p.y));
m_max = point_type(std::max(m_max.x, p.x), std::max(m_max.y, p.y));
}
// Make sure bounding box does not have a zero size by adding padding:
// zero-size bounding box cannot be extended properly
const TCoordType padding(1);
if(m_min.x == m_max.x)
{
m_min.x -= padding;
m_max.x += padding;
}
if(m_min.y == m_max.y)
{
m_min.y -= padding;
m_max.y += padding;
}
m_isRootBoxInitialized = true;
}
static coord_type distanceSquaredToBox(
const point_type& p,
const point_type& min,
const point_type& max)
{
const coord_type dx =
std::max(std::max(min.x - p.x, coord_type(0)), p.x - max.x);
const coord_type dy =
std::max(std::max(min.y - p.y, coord_type(0)), p.y - max.y);
return dx * dx + dy * dy;
}
private:
node_index m_root;
std::vector<Node> m_nodes;
NodeSplitDirection::Enum m_rootDir;
point_type m_min;
point_type m_max;
CDT::VertInd m_size;
bool m_isRootBoxInitialized;
// used for nearest query
struct NearestTask
{
node_index node;
point_type min, max;
NodeSplitDirection::Enum dir;
coord_type distSq;
NearestTask()
: dir(NodeSplitDirection::X)
{}
NearestTask(
const node_index node,
const point_type& min,
const point_type& max,
const NodeSplitDirection::Enum dir,
const coord_type distSq = std::numeric_limits<coord_type>::max())
: node(node)
, min(min)
, max(max)
, dir(dir)
, distSq(distSq)
{}
};
// allocated in class (not in the 'nearest' method) for better performance
mutable std::vector<NearestTask> m_tasksStack;
};
} // namespace KDTree
} // namespace CDT
#endif // header guard

View file

@ -0,0 +1,81 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
/**
* @file
* Adapter between for KDTree and CDT
*/
#ifndef CDT_POINTKDTREE_H
#define CDT_POINTKDTREE_H
#include "CDTUtils.h"
#include "KDTree.h"
namespace CDT
{
/// KD-tree holding points
template <
typename TCoordType,
size_t NumVerticesInLeaf = 32,
size_t InitialStackDepth = 32,
size_t StackDepthIncrement = 32>
class LocatorKDTree
{
public:
/// Initialize KD-tree with points
void initialize(const std::vector<V2d<TCoordType> >& points)
{
typedef V2d<TCoordType> V2d_t;
V2d_t min = points.front();
V2d_t max = min;
typedef typename std::vector<V2d_t>::const_iterator Cit;
for(Cit it = points.begin(); it != points.end(); ++it)
{
min = V2d_t(std::min(min.x, it->x), std::min(min.y, it->y));
max = V2d_t(std::max(max.x, it->x), std::max(max.y, it->y));
}
m_kdTree = KDTree_t(min, max);
for(VertInd i(0); i < points.size(); ++i)
{
m_kdTree.insert(i, points);
}
}
/// Add point to KD-tree
void addPoint(const VertInd i, const std::vector<V2d<TCoordType> >& points)
{
m_kdTree.insert(i, points);
}
/// Find nearest point using R-tree
VertInd nearPoint(
const V2d<TCoordType>& pos,
const std::vector<V2d<TCoordType> >& points) const
{
return m_kdTree.nearest(pos, points).second;
}
CDT::VertInd size() const
{
return m_kdTree.size();
}
bool empty() const
{
return !size();
}
private:
typedef KDTree::KDTree<
TCoordType,
NumVerticesInLeaf,
InitialStackDepth,
StackDepthIncrement>
KDTree_t;
KDTree_t m_kdTree;
};
} // namespace CDT
#endif

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,313 @@
// This code is copied from LLVM's libc++
// https://github.com/llvm-mirror/libcxx/blob/4dde9ccef57d50e50620408a0b7a902f0aba803e/include/algorithm
// It is needed to provide portable nth_element on different platforms
// -*- C++ -*-
//===-------------------------- algorithm ---------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef CDT_PORTABLE_NTH_ELEMENT
#define CDT_PORTABLE_NTH_ELEMENT
#include <algorithm>
#include <iterator>
#ifdef CDT_CXX11_IS_SUPPORTED
#include <type_traits>
#else
#include <boost/type_traits/add_lvalue_reference.hpp>
#endif
namespace CDT
{
namespace detail
{
// sort
// stable, 2-3 compares, 0-2 swaps
template <class Compare, class ForwardIterator>
unsigned
sort3(ForwardIterator x, ForwardIterator y, ForwardIterator z, Compare c)
{
unsigned r = 0;
if(!c(*y, *x)) // if x <= y
{
if(!c(*z, *y)) // if y <= z
return r; // x <= y && y <= z
// x <= y && y > z
std::swap(*y, *z); // x <= z && y < z
r = 1;
if(c(*y, *x)) // if x > y
{
std::swap(*x, *y); // x < y && y <= z
r = 2;
}
return r; // x <= y && y < z
}
if(c(*z, *y)) // x > y, if y > z
{
std::swap(*x, *z); // x < y && y < z
r = 1;
return r;
}
std::swap(*x, *y); // x > y && y <= z
r = 1; // x < y && x <= z
if(c(*z, *y)) // if y > z
{
std::swap(*y, *z); // x <= y && y < z
r = 2;
}
return r;
} // x <= y && y <= z
// Assumes size > 0
template <class Compare, class BirdirectionalIterator>
void selection_sort(
BirdirectionalIterator first,
BirdirectionalIterator last,
Compare comp)
{
BirdirectionalIterator lm1 = last;
for(--lm1; first != lm1; ++first)
{
#ifdef CDT_CXX11_IS_SUPPORTED
BirdirectionalIterator i = std::min_element<
BirdirectionalIterator,
typename std::add_lvalue_reference<Compare>::type>(
first, last, comp);
#else
BirdirectionalIterator i = std::min_element<
BirdirectionalIterator,
typename boost::add_lvalue_reference<Compare>::type>(
first, last, comp);
#endif
if(i != first)
std::swap(*first, *i);
}
}
// nth_element
template <class Compare, class RandomAccessIterator>
void nth_element(
RandomAccessIterator first,
RandomAccessIterator nth,
RandomAccessIterator last,
Compare comp)
{
// Compare is known to be a reference type
typedef typename std::iterator_traits<RandomAccessIterator>::difference_type
difference_type;
const difference_type limit = 7;
while(true)
{
restart:
if(nth == last)
return;
difference_type len = last - first;
switch(len)
{
case 0:
case 1:
return;
case 2:
if(comp(*--last, *first))
std::swap(*first, *last);
return;
case 3: {
RandomAccessIterator m = first;
detail::sort3<Compare>(first, ++m, --last, comp);
return;
}
}
if(len <= limit)
{
detail::selection_sort<Compare>(first, last, comp);
return;
}
// len > limit >= 3
RandomAccessIterator m = first + len / 2;
RandomAccessIterator lm1 = last;
unsigned n_swaps = detail::sort3<Compare>(first, m, --lm1, comp);
// *m is median
// partition [first, m) < *m and *m <= [m, last)
// (this inhibits tossing elements equivalent to m around
// unnecessarily)
RandomAccessIterator i = first;
RandomAccessIterator j = lm1;
// j points beyond range to be tested, *lm1 is known to be <= *m
// The search going up is known to be guarded but the search coming
// down isn't. Prime the downward search with a guard.
if(!comp(*i, *m)) // if *first == *m
{
// *first == *m, *first doesn't go in first part
// manually guard downward moving j against i
while(true)
{
if(i == --j)
{
// *first == *m, *m <= all other elements
// Parition instead into [first, i) == *first and
// *first < [i, last)
++i; // first + 1
j = last;
if(!comp(*first, *--j)) // we need a guard if
// *first == *(last-1)
{
while(true)
{
if(i == j)
return; // [first, last) all equivalent
// elements
if(comp(*first, *i))
{
std::swap(*i, *j);
++n_swaps;
++i;
break;
}
++i;
}
}
// [first, i) == *first and *first < [j,
// last) and j == last - 1
if(i == j)
return;
while(true)
{
while(!comp(*first, *i))
++i;
while(comp(*first, *--j))
;
if(i >= j)
break;
std::swap(*i, *j);
++n_swaps;
++i;
}
// [first, i) == *first and *first < [i,
// last) The first part is sorted,
if(nth < i)
return;
// nth_element the secod part
// nth_element<Compare>(i, nth, last, comp);
first = i;
goto restart;
}
if(comp(*j, *m))
{
std::swap(*i, *j);
++n_swaps;
break; // found guard for downward moving j, now use
// unguarded partition
}
}
}
++i;
// j points beyond range to be tested, *lm1 is known to be <= *m
// if not yet partitioned...
if(i < j)
{
// known that *(i - 1) < *m
while(true)
{
// m still guards upward moving i
while(comp(*i, *m))
++i;
// It is now known that a guard exists for downward moving
// j
while(!comp(*--j, *m))
;
if(i >= j)
break;
std::swap(*i, *j);
++n_swaps;
// It is known that m != j
// If m just moved, follow it
if(m == i)
m = j;
++i;
}
}
// [first, i) < *m and *m <= [i, last)
if(i != m && comp(*m, *i))
{
std::swap(*i, *m);
++n_swaps;
}
// [first, i) < *i and *i <= [i+1, last)
if(nth == i)
return;
if(n_swaps == 0)
{
// We were given a perfectly partitioned sequence. Coincidence?
if(nth < i)
{
// Check for [first, i) already sorted
j = m = first;
while(++j != i)
{
if(comp(*j, *m))
// not yet sorted, so sort
goto not_sorted;
m = j;
}
// [first, i) sorted
return;
}
else
{
// Check for [i, last) already sorted
j = m = i;
while(++j != last)
{
if(comp(*j, *m))
// not yet sorted, so sort
goto not_sorted;
m = j;
}
// [i, last) sorted
return;
}
}
not_sorted:
// nth_element on range containing nth
if(nth < i)
{
// nth_element<Compare>(first, nth, i, comp);
last = i;
}
else
{
// nth_element<Compare>(i+1, nth, last, comp);
first = ++i;
}
}
}
template <class _RandomAccessIterator, class _Compare>
inline void portable_nth_element(
_RandomAccessIterator first,
_RandomAccessIterator nth,
_RandomAccessIterator last,
_Compare comp)
{
#ifdef CDT_CXX11_IS_SUPPORTED
detail::nth_element<typename std::add_lvalue_reference<_Compare>::type>(
first, nth, last, comp);
#else
detail::nth_element<typename boost::add_lvalue_reference<_Compare>::type>(
first, nth, last, comp);
#endif
}
} // namespace detail
} // namespace CDT
#endif // CDT_PORTABLE_NTH_ELEMENT

View file

@ -0,0 +1,915 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (c) 2019, William C. Lenthe *
* All rights reserved. *
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted provided that the following conditions are met: *
* *
* 1. Redistributions of source code must retain the above copyright notice, this *
* list of conditions and the following disclaimer. *
* *
* 2. Redistributions in binary form must reproduce the above copyright notice, *
* this list of conditions and the following disclaimer in the documentation *
* and/or other materials provided with the distribution. *
* *
* 3. Neither the name of the copyright holder nor the names of its *
* contributors may be used to endorse or promote products derived from *
* this software without specific prior written permission. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE *
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE *
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL *
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR *
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER *
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE *
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef PREDICATES_H_INCLUDED
#define PREDICATES_H_INCLUDED
//@reference: https://www.cs.cmu.edu/~quake/robust.html
namespace predicates {
//@brief: geometric predicates using arbitrary precision arithmetic
//@note : these are provided primarily for illustrative purposes and adaptive routines should be preferred
namespace exact {
//@brief : determine if the 2d point c is above, on, or below the line defined by a and b
//@param ax: X-coordinate of a
//@param ay: Y-coordinate of a
//@param bx: X-coordinate of b
//@param by: Y-coordinate of b
//@param cx: X-coordinate of c
//@param cy: Y-coordinate of c
//@return : determinant of {{ax - cx, ay - cy}, {bx - cx, by - cy}}
//@note : positive, 0, negative result for c above, on, or below the line defined by a -> b
template <typename T> T orient2d(T const ax, T const ay, T const bx, T const by, T const cx, T const cy);
//@brief : determine if the 2d point c is above, on, or below the line defined by a and b
//@param pa: pointer to a as {x, y}
//@param pb: pointer to b as {x, y}
//@param pc: pointer to c as {x, y}
//@return : determinant of {{ax - cx, ay - cy}, {bx - cx, by - cy}}
//@note : positive, 0, negative result for c above, on, or below the line defined by a -> b
template <typename T> T orient2d(T const*const pa, T const*const pb, T const*const pc);
//@brief : determine if the 2d point d is inside, on, or outside the circle defined by a, b, and c
//@param ax: X-coordinate of a
//@param ay: Y-coordinate of a
//@param bx: X-coordinate of b
//@param by: Y-coordinate of b
//@param cx: X-coordinate of c
//@param cy: Y-coordinate of c
//@param dx: X-coordinate of d
//@param dy: Y-coordinate of d
//@return : determinant of {{ax - dx, ay - dy, (ax - dx)^2 + (ay - dy)^2}, {bx - dx, by - dy, (bx - dx)^2 + (by - dy)^2}, {cx - dx, cy - dy, (cx - dx)^2 + (cy - dy)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T incircle(T const ax, T const ay, T const bx, T const by, T const cx, T const cy, T const dx, T const dy);
//@brief : determine if the 2d point d is inside, on, or outside the circle defined by a, b, and c
//@param pa: pointer to a as {x, y}
//@param pb: pointer to b as {x, y}
//@param pc: pointer to c as {x, y}
//@param pc: pointer to d as {x, y}
//@return : determinant of {{ax - dx, ay - dy, (ax - dx)^2 + (ay - dy)^2}, {bx - dx, by - dy, (bx - dx)^2 + (by - dy)^2}, {cx - dx, cy - dy, (cx - dx)^2 + (cy - dy)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T incircle(T const*const pa, T const*const pb, T const*const pc, T const*const pd);
//@brief : determine if the 3d point d is above, on, or below the plane defined by a, b, and c
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@return : determinant of {{ax - dx, ay - dy, az - dz}, {bx - dx, by - dy, bz - dz}, {cx - dx, cy - dy, cz - dz}}
//@note : positive, 0, negative result for c above, on, or below the plane defined by a, b, and c
template <typename T> T orient3d(T const*const pa, T const*const pb, T const*const pc, T const*const pd);
//@brief : determine if the 3d point e is inside, on, or outside the sphere defined by a, b, c, and d
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@param pe: pointer to e as {x, y, z}
//@return : determinant of {{ax - ex, ay - ey, az - ez, (ax - ex)^2 + (ay - ey)^2 + (az - ez)^2}, {bx - ex, by - ey, bz - ez, (bx - ex)^2 + (by - ey)^2 + (bz - ez)^2}, {cx - ex, cy - ey, cz - ez, (cx - ex)^2 + (cy - ey)^2 + (cz - ez)^2}, {dx - ex, dy - ey, dz - ez, (dx - ex)^2 + (dy - ey)^2 + (dz - ez)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T insphere(T const*const pa, T const*const pb, T const*const pc, T const*const pd, T const*const pe);
}
//@brief: geometric predicates using normal floating point arithmetic but falling back to arbitrary precision when needed
//@note : these should have the same accuracy but are significantly faster when determinants are large
namespace adaptive {
//@brief : determine if the 2d point c is above, on, or below the line defined by a and b
//@param ax: X-coordinate of a
//@param ay: Y-coordinate of a
//@param bx: X-coordinate of b
//@param by: Y-coordinate of b
//@param cx: X-coordinate of c
//@param cy: Y-coordinate of c
//@return : determinant of {{ax - cx, ay - cy}, {bx - cx, by - cy}}
//@note : positive, 0, negative result for c above, on, or below the line defined by a -> b
template <typename T> T orient2d(T const ax, T const ay, T const bx, T const by, T const cx, T const cy);
//@brief : determine if the 2d point c is above, on, or below the line defined by a and b
//@param pa: pointer to a as {x, y}
//@param pb: pointer to b as {x, y}
//@param pc: pointer to c as {x, y}
//@return : determinant of {{ax - cx, ay - cy}, {bx - cx, by - cy}}
//@note : positive, 0, negative result for c above, on, or below the line defined by a -> b
template <typename T> T orient2d(T const*const pa, T const*const pb, T const*const pc);
//@brief : determine if the 2d point d is inside, on, or outside the circle defined by a, b, and c
//@param ax: X-coordinate of a
//@param ay: Y-coordinate of a
//@param bx: X-coordinate of b
//@param by: Y-coordinate of b
//@param cx: X-coordinate of c
//@param cy: Y-coordinate of c
//@param dx: X-coordinate of d
//@param dy: Y-coordinate of d
//@return : determinant of {{ax - dx, ay - dy, (ax - dx)^2 + (ay - dy)^2}, {bx - dx, by - dy, (bx - dx)^2 + (by - dy)^2}, {cx - dx, cy - dy, (cx - dx)^2 + (cy - dy)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T incircle(T const ax, T const ay, T const bx, T const by, T const cx, T const cy, T const dx, T const dy);
//@brief : determine if the 2d point d is inside, on, or outside the circle defined by a, b, and c
//@param pa: pointer to a as {x, y}
//@param pb: pointer to b as {x, y}
//@param pc: pointer to c as {x, y}
//@param pc: pointer to d as {x, y}
//@return : determinant of {{ax - dx, ay - dy, (ax - dx)^2 + (ay - dy)^2}, {bx - dx, by - dy, (bx - dx)^2 + (by - dy)^2}, {cx - dx, cy - dy, (cx - dx)^2 + (cy - dy)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T incircle(T const*const pa, T const*const pb, T const*const pc, T const*const pd);
//@brief : determine if the 3d point d is above, on, or below the plane defined by a, b, and c
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@return : determinant of {{ax - dx, ay - dy, az - dz}, {bx - dx, by - dy, bz - dz}, {cx - dx, cy - dy, cz - dz}}
//@note : positive, 0, negative result for c above, on, or below the plane defined by a, b, and c
template <typename T> T orient3d(T const*const pa, T const*const pb, T const*const pc, T const*const pd);
//@brief : determine if the 3d point e is inside, on, or outside the sphere defined by a, b, c, and d
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@param pe: pointer to e as {x, y, z}
//@return : determinant of {{ax - ex, ay - ey, az - ez, (ax - ex)^2 + (ay - ey)^2 + (az - ez)^2}, {bx - ex, by - ey, bz - ez, (bx - ex)^2 + (by - ey)^2 + (bz - ez)^2}, {cx - ex, cy - ey, cz - ez, (cx - ex)^2 + (cy - ey)^2 + (cz - ez)^2}, {dx - ex, dy - ey, dz - ez, (dx - ex)^2 + (dy - ey)^2 + (dz - ez)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T insphere(T const*const pa, T const*const pb, T const*const pc, T const*const pd, T const*const pe);
}
}
#include <cmath>//abs, fma
#include <limits>
#include <utility>//pair
#include <numeric>//accumulate
#include <algorithm>//transform, copy_n, merge
#include <functional>//negate
// a macro based static assert for pre c++11
#define PREDICATES_PORTABLE_STATIC_ASSERT(condition, message) typedef char message[(condition) ? 1 : -1]
// check if c++11 is supported
#if !defined(__cplusplus) && !defined(_MSC_VER)
PREDICATES_PORTABLE_STATIC_ASSERT(false, couldnt_parse_cxx_standard)
#endif
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
#define PREDICATES_CXX11_IS_SUPPORTED
#endif
// choose to use c++11 features or their backports
#ifdef PREDICATES_CXX11_IS_SUPPORTED
#include <array>
#include <type_traits>// is_same, enable_if
#undef PREDICATES_PORTABLE_STATIC_ASSERT
#define PREDICATES_TOKEN_TO_STRING1(x) #x
#define PREDICATES_TOKEN_TO_STRING(x) PREDICATES_TOKEN_TO_STRING1(x)
#define PREDICATES_PORTABLE_STATIC_ASSERT(condition, message) static_assert(condition, PREDICATES_TOKEN_TO_STRING(message))
namespace predicates {
namespace stdx {
using std::array;
using std::copy_n;
}
#else
namespace predicates {
namespace stdx {
// array
template<typename T, size_t N>
class array {
T buff[N];
public:
T& operator[](const size_t& i) { return buff[i]; }
const T& operator[](const size_t& i) const { return buff[i]; }
T * data() { return buff; }
T const * data() const { return buff; }
T * begin() { return buff; }
T const * cbegin() const { return buff; }
};
// copy_n
template< class InputIt, class Size, class OutputIt>
OutputIt copy_n(InputIt first, Size count, OutputIt result)
{
if (count > 0) {
*result++ = *first;
for (Size i = 1; i < count; ++i) {
*result++ = *++first;
}
}
return result;
}
}
#endif // PREDICATES_CXX11_IS_SUPPORTED
namespace detail {
template<typename T> class ExpansionBase;
//@brief: class to exactly represent the result of a sequence of arithmetic operations as an sequence of values that sum to the result
template<typename T, size_t N>
class Expansion : private ExpansionBase<T>, public stdx::array<T, N> {
private:
public:
size_t m_size;
template <typename S> friend class ExpansionBase;//access for base class
template <typename S, size_t M> friend class Expansion;//access for expansions of different size
Expansion() : m_size(0) {}
template <size_t M> Expansion& operator=(const Expansion<T, M>& e) {
PREDICATES_PORTABLE_STATIC_ASSERT(M <= N, cannot_assign_a_larger_expansion_to_a_smaller_expansion);
stdx::copy_n(e.cbegin(), e.size(), stdx::array<T, N>::begin());
m_size = e.size();
return *this;
}
//vector like convenience functions
size_t size() const {return m_size;}
bool empty() const {return 0 == m_size;}
void push_back(const T v) {stdx::array<T, N>::operator[](m_size++) = v;}
public:
//estimates of expansion value
T mostSignificant() const {return empty() ? T(0) : stdx::array<T, N>::operator[](m_size - 1);}
T estimate() const {return std::accumulate(stdx::array<T, N>::cbegin(), stdx::array<T, N>::cbegin() + size(), T(0));}
template <size_t M> Expansion<T, N+M> operator+(const Expansion<T, M>& f) const {
Expansion<T, N+M> h;
h.m_size = ExpansionBase<T>::ExpansionSum(this->data(), this->size(), f.data(), f.size(), h.data());
return h;
}
void negate() {std::transform(stdx::array<T, N>::cbegin(), stdx::array<T, N>::cbegin() + size(), stdx::array<T, N>::begin(), std::negate<T>());}
Expansion operator-() const {Expansion e = *this; e.negate(); return e;}
template <size_t M> Expansion<T, N+M> operator-(const Expansion<T, M>& f) const {return operator+(-f);}
Expansion<T, 2*N> operator*(const T b) const {
Expansion<T, 2*N> h;
h.m_size = ExpansionBase<T>::ScaleExpansion(this->data(), this->size(), b, h.data());
return h;
}
};
// See: https://stackoverflow.com/a/40765925/1597714
// Standard defines: https://en.cppreference.com/w/cpp/numeric/math/fma
#if defined(__FMA__) || defined(__FMA4__) || defined(__AVX2__) || (defined(FP_FAST_FMA) && defined(FP_FAST_FMAF))
#define PREDICATES_FAST_FMA 1
#endif
//@brief : helper function to sort by absolute value
//@param a: lhs item to compare
//@param b: rhs item to compare
//@return : true if |a| < |b|
//@note : defined since lambda functions aren't allow in c++03
template <typename T> bool absLess(const T& a, const T& b) {return std::abs(a) < std::abs(b);}
template<typename T>
class ExpansionBase {
private:
static const T Splitter;
PREDICATES_PORTABLE_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, Requires_IEC_559_IEEE_754_floating_point_type);
PREDICATES_PORTABLE_STATIC_ASSERT(2 == std::numeric_limits<T>::radix, Requires_base_2_floating_point_type);
//combine result + roundoff error into expansion
static inline Expansion<T, 2> MakeExpansion(const T value, const T tail) {
Expansion<T, 2> e;
if(T(0) != tail) e.push_back(tail);
if(T(0) != value) e.push_back(value);
return e;
}
protected:
//add 2 expansions
static size_t ExpansionSum(T const * const e, const size_t n, T const * const f, const size_t m, T * const h) {
std::merge(e, e + n, f, f + m, h, absLess<T>);
if(m == 0) return n;
if(n == 0) return m;
size_t hIndex = 0;
T Q = h[0];
T Qnew = h[1] + Q;
T hh = FastPlusTail(h[1], Q, Qnew);
Q = Qnew;
if(T(0) != hh) h[hIndex++] = hh;
for(size_t g = 2; g != n + m; ++g) {
Qnew = Q + h[g];
hh = PlusTail(Q, h[g], Qnew);
Q = Qnew;
if(T(0) != hh) h[hIndex++] = hh;
}
if(T(0) != Q) h[hIndex++] = Q;
return hIndex;
}
//scale an expansion by a constant
static size_t ScaleExpansion(T const * const e, const size_t n, const T b, T * const h) {
if(n == 0 || T(0) == b) return 0;
size_t hIndex = 0;
T Q = e[0] * b;
const std::pair<T, T> bSplit = Split(b);
T hh = MultTailPreSplit(e[0], b, bSplit, Q);
if(T(0) != hh) h[hIndex++] = hh;
for(size_t eIndex = 1; eIndex < n; ++eIndex) {
T Ti = e[eIndex] * b;
T ti = MultTailPreSplit(e[eIndex], b, bSplit, Ti);
T Qi = Q + ti;
hh = PlusTail(Q, ti, Qi);
if(T(0) != hh) h[hIndex++] = hh;
Q = Ti + Qi;
hh = FastPlusTail(Ti, Qi, Q);
if(T(0) != hh) h[hIndex++] = hh;
}
if(T(0) != Q) h[hIndex++] = Q;
return hIndex;
}
public:
//roundoff error of x = a + b
static inline T PlusTail(const T a, const T b, const T x) {
const T bVirtual = x - a;
const T aVirtual = x - bVirtual;
const T bRoundoff = b - bVirtual;
const T aRoundoff = a - aVirtual;
return aRoundoff + bRoundoff;
}
//roundoff error of x = a + b if |a| > |b|
static inline T FastPlusTail(const T a, const T b, const T x) {
const T bVirtual = x - a;
return b - bVirtual;
}
//roundoff error of x = a - b
static inline T MinusTail(const T a, const T b, const T x) {
const T bVirtual = a - x;
const T aVirtual = x + bVirtual;
const T bRoundoff = bVirtual - b;
const T aRoundoff = a - aVirtual;
return aRoundoff + bRoundoff;
}
//split a into 2 nonoverlapping values
static inline std::pair<T, T> Split(const T a) {
const T c = a * Splitter;
const T aBig = c - a;
const T aHi = c - aBig;
return std::pair<T, T>(aHi, a - aHi);
}
//roundoff error of x = a * b via dekkers product
static inline T DekkersProduct(const T /*a*/, const std::pair<T, T> aSplit, const T /*b*/, const std::pair<T, T> bSplit, const T p) {
T y = p - T(aSplit.first * bSplit.first);
y -= T(aSplit.second * bSplit.first);
y -= T(aSplit.first * bSplit.second);
return T(aSplit.second * bSplit.second) - y;
}
//roundoff error of x = a * b
#if defined(PREDICATES_CXX11_IS_SUPPORTED) && defined(PREDICATES_FAST_FMA)
static T MultTail(const T a, const T b, const T p) {return std::fma(a, b, -p);}
static T MultTailPreSplit(const T a, const T b, const std::pair<T, T> /*bSplit*/, const T p) {return std::fma(a, b, -p);}
#else
static T MultTail(const T a, const T b, const T p) {return DekkersProduct(a, Split(a), b, Split(b), p);}
static T MultTailPreSplit(const T a, const T b, const std::pair<T, T> bSplit, const T p) {return DekkersProduct(a, Split(a), b, bSplit, p);}
#endif
//expand a + b
static inline Expansion<T, 2> Plus(const T a, const T b) {
const T x = a + b;
return MakeExpansion(x, PlusTail(a, b, x));
}
//expand a - b
static inline Expansion<T, 2> Minus(const T a, const T b) {return Plus(a, -b);}
//expand a * b
static inline Expansion<T, 2> Mult(const T a, const T b) {
const T x = a * b;
return MakeExpansion(x, MultTail(a, b, x));
}
//expand the determinant of {{ax, ay}, {bx, by}} (unrolled Mult(ax, by) - Mult(ay, bx))
static inline Expansion<T, 4> TwoTwoDiff(const T ax, const T by, const T ay, const T bx) {
const T axby1 = ax * by;
const T axby0 = MultTail(ax, by, axby1);
const T bxay1 = bx * ay;
const T bxay0 = MultTail(bx, ay, bxay1);
const T _i0 = axby0 - bxay0;
const T x0 = MinusTail(axby0, bxay0, _i0);
const T _j = axby1 + _i0;
const T _0 = PlusTail(axby1, _i0, _j);
const T _i1 = _0 - bxay1;
const T x1 = MinusTail(_0, bxay1, _i1);
const T x3 = _j + _i1;
const T x2 = PlusTail(_j, _i1, x3);
Expansion<T, 4> e;
if(T(0) != x0) e.push_back(x0);
if(T(0) != x1) e.push_back(x1);
if(T(0) != x2) e.push_back(x2);
if(T(0) != x3) e.push_back(x3);
return e;
}
//TwoTwoDiff checking for zeros to avoid extra splitting
static inline Expansion<T, 4> TwoTwoDiffZeroCheck(const T ax, const T by, const T ay, const T bx) {
Expansion<T, 4> e;
if(T(0) == ax && T(0) == ay) return e;
else if(T(0) == ax) e = Mult(ay, bx);
else if(T(0) == ay) e = Mult(ax, by);
else e = TwoTwoDiff(ax, by, ay, bx);
return e;
}
//(a * b) * c checking for zeros
static inline Expansion<T, 4> ThreeProd(const T a, const T b, const T c) {return (T(0) == a || T(0) == b || T(0) == c) ? Expansion<T, 4>() : Mult(a, b) * c;}
};
template <typename T> const T ExpansionBase<T>::Splitter =
#ifdef PREDICATES_CXX11_IS_SUPPORTED
static_cast<T>(std::exp2(std::numeric_limits<T>::digits/2 + 1));
#else
static_cast<T>(std::ldexp(T(1), std::numeric_limits<T>::digits/2 + 1));
#endif
}
namespace exact {
template <typename T> T orient2d(T const ax, T const ay, T const bx, T const by, T const cx, T const cy)
{
const detail::Expansion<T, 4> aterms = detail::ExpansionBase<T>::TwoTwoDiff(ax, by, ax, cy);
const detail::Expansion<T, 4> bterms = detail::ExpansionBase<T>::TwoTwoDiff(bx, cy, bx, ay);
const detail::Expansion<T, 4> cterms = detail::ExpansionBase<T>::TwoTwoDiff(cx, ay, cx, by);
const detail::Expansion<T, 12> w = aterms + bterms + cterms;
return w.mostSignificant();
}
template <typename T> T orient2d(T const*const pa, T const*const pb, T const*const pc) {
return orient2d(pa[0], pa[1], pb[0], pb[1], pc[0], pc[1]);
}
template <typename T> T incircle(T const ax, T const ay, T const bx, T const by, T const cx, T const cy, T const dx, T const dy) {
const detail::Expansion<T, 4> ab = detail::ExpansionBase<T>::TwoTwoDiff(ax, by, bx, ay);
const detail::Expansion<T, 4> bc = detail::ExpansionBase<T>::TwoTwoDiff(bx, cy, cx, by);
const detail::Expansion<T, 4> cd = detail::ExpansionBase<T>::TwoTwoDiff(cx, dy, dx, cy);
const detail::Expansion<T, 4> da = detail::ExpansionBase<T>::TwoTwoDiff(dx, ay, ax, dy);
const detail::Expansion<T, 4> ac = detail::ExpansionBase<T>::TwoTwoDiff(ax, cy, cx, ay);
const detail::Expansion<T, 4> bd = detail::ExpansionBase<T>::TwoTwoDiff(bx, dy, dx, by);
const detail::Expansion<T, 12> abc = ab + bc - ac;
const detail::Expansion<T, 12> bcd = bc + cd - bd;
const detail::Expansion<T, 12> cda = cd + da + ac;
const detail::Expansion<T, 12> dab = da + ab + bd;
const detail::Expansion<T, 96> adet = bcd * ax * ax + bcd * ay * ay;
const detail::Expansion<T, 96> bdet = cda * bx * -bx + cda * by * -by;
const detail::Expansion<T, 96> cdet = dab * cx * cx + dab * cy * cy;
const detail::Expansion<T, 96> ddet = abc * dx * -dx + abc * dy * -dy;
const detail::Expansion<T, 384> deter = (adet + bdet) + (cdet + ddet);
return deter.mostSignificant();
}
template <typename T> T incircle(T const*const pa, T const*const pb, T const*const pc, T const*const pd) {
return incircle(pa[0], pa[1], pb[0], pb[1], pc[0], pc[1], pd[0], pd[1]);
}
//@brief : determine if the 3d point d is above, on, or below the plane defined by a, b, and c
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@return : determinant of {{ax - dx, ay - dy, az - dz}, {bx - dx, by - dy, bz - dz}, {cx - dx, cy - dy, cz - dz}}
//@note : positive, 0, negative result for c above, on, or below the plane defined by a, b, and c
template <typename T> T orient3d(T const*const pa, T const*const pb, T const*const pc, T const*const pd) {
const detail::Expansion<T, 4> ab = detail::ExpansionBase<T>::TwoTwoDiff(pa[0], pb[1], pb[0], pa[1]);
const detail::Expansion<T, 4> bc = detail::ExpansionBase<T>::TwoTwoDiff(pb[0], pc[1], pc[0], pb[1]);
const detail::Expansion<T, 4> cd = detail::ExpansionBase<T>::TwoTwoDiff(pc[0], pd[1], pd[0], pc[1]);
const detail::Expansion<T, 4> da = detail::ExpansionBase<T>::TwoTwoDiff(pd[0], pa[1], pa[0], pd[1]);
const detail::Expansion<T, 4> ac = detail::ExpansionBase<T>::TwoTwoDiff(pa[0], pc[1], pc[0], pa[1]);
const detail::Expansion<T, 4> bd = detail::ExpansionBase<T>::TwoTwoDiff(pb[0], pd[1], pd[0], pb[1]);
const detail::Expansion<T, 12> abc = ab + bc - ac;
const detail::Expansion<T, 12> bcd = bc + cd - bd;
const detail::Expansion<T, 12> cda = cd + da + ac;
const detail::Expansion<T, 12> dab = da + ab + bd;
const detail::Expansion<T, 24> adet = bcd * pa[2];
const detail::Expansion<T, 24> bdet = cda * -pb[2];
const detail::Expansion<T, 24> cdet = dab * pc[2];
const detail::Expansion<T, 24> ddet = abc * -pd[2];
const detail::Expansion<T, 96> deter = (adet + bdet) + (cdet + ddet);
return deter.mostSignificant();
}
//@brief : determine if the 3d point e is inside, on, or outside the sphere defined by a, b, c, and d
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@param pe: pointer to e as {x, y, z}
//@return : determinant of {{ax - ex, ay - ey, az - ez, (ax - ex)^2 + (ay - ey)^2 + (az - ez)^2}, {bx - ex, by - ey, bz - ez, (bx - ex)^2 + (by - ey)^2 + (bz - ez)^2}, {cx - ex, cy - ey, cz - ez, (cx - ex)^2 + (cy - ey)^2 + (cz - ez)^2}, {dx - ex, dy - ey, dz - ez, (dx - ex)^2 + (dy - ey)^2 + (dz - ez)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T insphere(T const*const pa, T const*const pb, T const*const pc, T const*const pd, T const*const pe) {
const detail::Expansion<T, 4> ab = detail::ExpansionBase<T>::TwoTwoDiff(pa[0], pb[1], pb[0], pa[1]);
const detail::Expansion<T, 4> bc = detail::ExpansionBase<T>::TwoTwoDiff(pb[0], pc[1], pc[0], pb[1]);
const detail::Expansion<T, 4> cd = detail::ExpansionBase<T>::TwoTwoDiff(pc[0], pd[1], pd[0], pc[1]);
const detail::Expansion<T, 4> de = detail::ExpansionBase<T>::TwoTwoDiff(pd[0], pe[1], pe[0], pd[1]);
const detail::Expansion<T, 4> ea = detail::ExpansionBase<T>::TwoTwoDiff(pe[0], pa[1], pa[0], pe[1]);
const detail::Expansion<T, 4> ac = detail::ExpansionBase<T>::TwoTwoDiff(pa[0], pc[1], pc[0], pa[1]);
const detail::Expansion<T, 4> bd = detail::ExpansionBase<T>::TwoTwoDiff(pb[0], pd[1], pd[0], pb[1]);
const detail::Expansion<T, 4> ce = detail::ExpansionBase<T>::TwoTwoDiff(pc[0], pe[1], pe[0], pc[1]);
const detail::Expansion<T, 4> da = detail::ExpansionBase<T>::TwoTwoDiff(pd[0], pa[1], pa[0], pd[1]);
const detail::Expansion<T, 4> eb = detail::ExpansionBase<T>::TwoTwoDiff(pe[0], pb[1], pb[0], pe[1]);
const detail::Expansion<T, 24> abc = bc * pa[2] + ac * -pb[2] + ab * pc[2];
const detail::Expansion<T, 24> bcd = cd * pb[2] + bd * -pc[2] + bc * pd[2];
const detail::Expansion<T, 24> cde = de * pc[2] + ce * -pd[2] + cd * pe[2];
const detail::Expansion<T, 24> dea = ea * pd[2] + da * -pe[2] + de * pa[2];
const detail::Expansion<T, 24> eab = ab * pe[2] + eb * -pa[2] + ea * pb[2];
const detail::Expansion<T, 24> abd = bd * pa[2] + da * pb[2] + ab * pd[2];
const detail::Expansion<T, 24> bce = ce * pb[2] + eb * pc[2] + bc * pe[2];
const detail::Expansion<T, 24> cda = da * pc[2] + ac * pd[2] + cd * pa[2];
const detail::Expansion<T, 24> deb = eb * pd[2] + bd * pe[2] + de * pb[2];
const detail::Expansion<T, 24> eac = ac * pe[2] + ce * pa[2] + ea * pc[2];
const detail::Expansion<T, 96> bcde = (cde + bce) - (deb + bcd);
const detail::Expansion<T, 96> cdea = (dea + cda) - (eac + cde);
const detail::Expansion<T, 96> deab = (eab + deb) - (abd + dea);
const detail::Expansion<T, 96> eabc = (abc + eac) - (bce + eab);
const detail::Expansion<T, 96> abcd = (bcd + abd) - (cda + abc);
const detail::Expansion<T, 1152> adet = bcde * pa[0] * pa[0] + bcde * pa[1] * pa[1] + bcde * pa[2] * pa[2];
const detail::Expansion<T, 1152> bdet = cdea * pb[0] * pb[0] + cdea * pb[1] * pb[1] + cdea * pb[2] * pb[2];
const detail::Expansion<T, 1152> cdet = deab * pc[0] * pc[0] + deab * pc[1] * pc[1] + deab * pc[2] * pc[2];
const detail::Expansion<T, 1152> ddet = eabc * pd[0] * pd[0] + eabc * pd[1] * pd[1] + eabc * pd[2] * pd[2];
const detail::Expansion<T, 1152> edet = abcd * pe[0] * pe[0] + abcd * pe[1] * pe[1] + abcd * pe[2] * pe[2];
const detail::Expansion<T, 5760> deter = (adet + bdet) + ((cdet + ddet) + edet);
return deter.mostSignificant();
}
}
template <typename T>
const T& Epsilon()
{
static const T epsilon =
#ifdef PREDICATES_CXX11_IS_SUPPORTED
static_cast<T>(std::exp2(-std::numeric_limits<T>::digits));
#else
static_cast<T>(std::ldexp(T(1), -std::numeric_limits<T>::digits));
#endif
return epsilon;
}
template <typename T>
class Constants {
public:
static const T epsilon, resulterrbound;
static const T ccwerrboundA, ccwerrboundB, ccwerrboundC;
static const T o3derrboundA, o3derrboundB, o3derrboundC;
static const T iccerrboundA, iccerrboundB, iccerrboundC;
static const T isperrboundA, isperrboundB, isperrboundC;
};
template <typename T> const T Constants<T>::epsilon = Epsilon<T>();
template <typename T> const T Constants<T>::resulterrbound = (T( 3) + T( 8) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::ccwerrboundA = (T( 3) + T( 16) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::ccwerrboundB = (T( 2) + T( 12) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::ccwerrboundC = (T( 9) + T( 64) * Epsilon<T>()) * Epsilon<T>() * Epsilon<T>();
template <typename T> const T Constants<T>::o3derrboundA = (T( 7) + T( 56) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::o3derrboundB = (T( 3) + T( 28) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::o3derrboundC = (T(26) + T( 288) * Epsilon<T>()) * Epsilon<T>() * Epsilon<T>();
template <typename T> const T Constants<T>::iccerrboundA = (T(10) + T( 96) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::iccerrboundB = (T( 4) + T( 48) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::iccerrboundC = (T(44) + T( 576) * Epsilon<T>()) * Epsilon<T>() * Epsilon<T>();
template <typename T> const T Constants<T>::isperrboundA = (T(16) + T( 224) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::isperrboundB = (T( 5) + T( 72) * Epsilon<T>()) * Epsilon<T>();
template <typename T> const T Constants<T>::isperrboundC = (T(71) + T(1408) * Epsilon<T>()) * Epsilon<T>() * Epsilon<T>();
namespace adaptive {
template <typename T> T orient2d(T const ax, T const ay, T const bx, T const by, T const cx, T const cy) {
const T acx = ax - cx;
const T bcx = bx - cx;
const T acy = ay - cy;
const T bcy = by - cy;
const T detleft = acx * bcy;
const T detright = acy * bcx;
T det = detleft - detright;
if((detleft < 0) != (detright < 0)) return det;
if(T(0) == detleft || T(0) == detright) return det;
const T detsum = std::abs(detleft + detright);
T errbound = Constants<T>::ccwerrboundA * detsum;
if(std::abs(det) >= std::abs(errbound)) return det;
const detail::Expansion<T, 4> B = detail::ExpansionBase<T>::TwoTwoDiff(acx, bcy, acy, bcx);
det = B.estimate();
errbound = Constants<T>::ccwerrboundB * detsum;
if(std::abs(det) >= std::abs(errbound)) return det;
const T acxtail = detail::ExpansionBase<T>::MinusTail(ax, cx, acx);
const T bcxtail = detail::ExpansionBase<T>::MinusTail(bx, cx, bcx);
const T acytail = detail::ExpansionBase<T>::MinusTail(ay, cy, acy);
const T bcytail = detail::ExpansionBase<T>::MinusTail(by, cy, bcy);
if(T(0) == acxtail && T(0) == bcxtail && T(0) == acytail && T(0) == bcytail) return det;
errbound = Constants<T>::ccwerrboundC * detsum + Constants<T>::resulterrbound * std::abs(det);
det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
if(std::abs(det) >= std::abs(errbound)) return det;
const detail::Expansion<T, 16> D = ((B + detail::ExpansionBase<T>::TwoTwoDiff(acxtail, bcy, acytail, bcx)) + detail::ExpansionBase<T>::TwoTwoDiff(acx, bcytail, acy, bcxtail)) + detail::ExpansionBase<T>::TwoTwoDiff(acxtail, bcytail, acytail, bcxtail);
return D.mostSignificant();
}
template <typename T> T orient2d(T const*const pa, T const*const pb, T const*const pc) {
return orient2d(pa[0], pa[1], pb[0], pb[1], pc[0], pc[1]);
}
template <typename T> T incircle(T const ax, T const ay, T const bx, T const by, T const cx, T const cy, T const dx, T const dy) {
const T adx = ax - dx;
const T bdx = bx - dx;
const T cdx = cx - dx;
const T ady = ay - dy;
const T bdy = by - dy;
const T cdy = cy - dy;
const T bdxcdy = bdx * cdy;
const T cdxbdy = cdx * bdy;
const T cdxady = cdx * ady;
const T adxcdy = adx * cdy;
const T adxbdy = adx * bdy;
const T bdxady = bdx * ady;
const T alift = adx * adx + ady * ady;
const T blift = bdx * bdx + bdy * bdy;
const T clift = cdx * cdx + cdy * cdy;
T det = alift * (bdxcdy - cdxbdy) + blift * (cdxady - adxcdy) + clift * (adxbdy - bdxady);
const T permanent = (std::abs(bdxcdy) + std::abs(cdxbdy)) * alift
+ (std::abs(cdxady) + std::abs(adxcdy)) * blift
+ (std::abs(adxbdy) + std::abs(bdxady)) * clift;
T errbound = Constants<T>::iccerrboundA * permanent;
if(std::abs(det) >= std::abs(errbound)) return det;
const detail::Expansion<T, 4> bc = detail::ExpansionBase<T>::TwoTwoDiff(bdx, cdy, cdx, bdy);
const detail::Expansion<T, 4> ca = detail::ExpansionBase<T>::TwoTwoDiff(cdx, ady, adx, cdy);
const detail::Expansion<T, 4> ab = detail::ExpansionBase<T>::TwoTwoDiff(adx, bdy, bdx, ady);
const detail::Expansion<T, 32> adet = bc * adx * adx + bc * ady * ady;
const detail::Expansion<T, 32> bdet = ca * bdx * bdx + ca * bdy * bdy;
const detail::Expansion<T, 32> cdet = ab * cdx * cdx + ab * cdy * cdy;
const detail::Expansion<T, 96> fin1 = adet + bdet + cdet;
det = fin1.estimate();
errbound = Constants<T>::iccerrboundB * permanent;
if(std::abs(det) >= std::abs(errbound)) return det;
const T adxtail = detail::ExpansionBase<T>::MinusTail(ax, dx, adx);
const T adytail = detail::ExpansionBase<T>::MinusTail(ay, dy, ady);
const T bdxtail = detail::ExpansionBase<T>::MinusTail(bx, dx, bdx);
const T bdytail = detail::ExpansionBase<T>::MinusTail(by, dy, bdy);
const T cdxtail = detail::ExpansionBase<T>::MinusTail(cx, dx, cdx);
const T cdytail = detail::ExpansionBase<T>::MinusTail(cy, dy, cdy);
if(T(0) == adxtail && T(0) == bdxtail && T(0) == cdxtail && T(0) == adytail && T(0) == bdytail && T(0) == cdytail) return det;
errbound = Constants<T>::iccerrboundC * permanent + Constants<T>::resulterrbound * std::abs(det);
det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail))
+ (bdx * cdy - bdy * cdx) * (adx * adxtail + ady * adytail) * T(2))
+ ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail))
+ (cdx * ady - cdy * adx) * (bdx * bdxtail + bdy * bdytail) * T(2))
+ ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail))
+ (adx * bdy - ady * bdx) * (cdx * cdxtail + cdy * cdytail) * T(2));
if(std::abs(det) >= std::abs(errbound)) return det;
return exact::incircle(ax, ay, bx, by, cx, cy, dx, dy);
}
template <typename T> T incircle(T const*const pa, T const*const pb, T const*const pc, T const*const pd) {
return incircle(pa[0], pa[1], pb[0], pb[1], pc[0], pc[1], pd[0], pd[1]);
}
//@brief : determine if the 3d point d is above, on, or below the plane defined by a, b, and c
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@return : determinant of {{ax - dx, ay - dy, az - dz}, {bx - dx, by - dy, bz - dz}, {cx - dx, cy - dy, cz - dz}}
//@note : positive, 0, negative result for c above, on, or below the plane defined by a, b, and c
template <typename T> T orient3d(T const*const pa, T const*const pb, T const*const pc, T const*const pd) {
const T adx = pa[0] - pd[0];
const T bdx = pb[0] - pd[0];
const T cdx = pc[0] - pd[0];
const T ady = pa[1] - pd[1];
const T bdy = pb[1] - pd[1];
const T cdy = pc[1] - pd[1];
const T adz = pa[2] - pd[2];
const T bdz = pb[2] - pd[2];
const T cdz = pc[2] - pd[2];
const T bdxcdy = bdx * cdy;
const T cdxbdy = cdx * bdy;
const T cdxady = cdx * ady;
const T adxcdy = adx * cdy;
const T adxbdy = adx * bdy;
const T bdxady = bdx * ady;
T det = adz * (bdxcdy - cdxbdy) + bdz * (cdxady - adxcdy) + cdz * (adxbdy - bdxady);
const T permanent = (std::abs(bdxcdy) + std::abs(cdxbdy)) * std::abs(adz) + (std::abs(cdxady) + std::abs(adxcdy)) * std::abs(bdz) + (std::abs(adxbdy) + std::abs(bdxady)) * std::abs(cdz);
T errbound = Constants<T>::o3derrboundA * permanent;
if(std::abs(det) >= std::abs(errbound)) return det;
const detail::Expansion<T, 4> bc = detail::ExpansionBase<T>::TwoTwoDiff(bdx, cdy, cdx, bdy);
const detail::Expansion<T, 4> ca = detail::ExpansionBase<T>::TwoTwoDiff(cdx, ady, adx, cdy);
const detail::Expansion<T, 4> ab = detail::ExpansionBase<T>::TwoTwoDiff(adx, bdy, bdx, ady);
const detail::Expansion<T, 24> fin1 = (bc * adz + ca * bdz) + ab * cdz;
det = fin1.estimate();
errbound = Constants<T>::o3derrboundB * permanent;
if(std::abs(det) >= std::abs(errbound)) return det;
const T adxtail = detail::ExpansionBase<T>::MinusTail(pa[0], pd[0], adx);
const T bdxtail = detail::ExpansionBase<T>::MinusTail(pb[0], pd[0], bdx);
const T cdxtail = detail::ExpansionBase<T>::MinusTail(pc[0], pd[0], cdx);
const T adytail = detail::ExpansionBase<T>::MinusTail(pa[1], pd[1], ady);
const T bdytail = detail::ExpansionBase<T>::MinusTail(pb[1], pd[1], bdy);
const T cdytail = detail::ExpansionBase<T>::MinusTail(pc[1], pd[1], cdy);
const T adztail = detail::ExpansionBase<T>::MinusTail(pa[2], pd[2], adz);
const T bdztail = detail::ExpansionBase<T>::MinusTail(pb[2], pd[2], bdz);
const T cdztail = detail::ExpansionBase<T>::MinusTail(pc[2], pd[2], cdz);
if(T(0) == adxtail && T(0) == adytail && T(0) == adztail &&
T(0) == bdxtail && T(0) == bdytail && T(0) == bdztail &&
T(0) == cdxtail && T(0) == cdytail && T(0) == cdztail) return det;
errbound = Constants<T>::o3derrboundC * permanent + Constants<T>::resulterrbound * std::abs(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(std::abs(det) >= std::abs(errbound)) return det;
const detail::Expansion<T, 8> bct = detail::ExpansionBase<T>::TwoTwoDiffZeroCheck(bdxtail, cdy, bdytail, cdx) + detail::ExpansionBase<T>::TwoTwoDiffZeroCheck(cdytail, bdx, cdxtail, bdy);
const detail::Expansion<T, 8> cat = detail::ExpansionBase<T>::TwoTwoDiffZeroCheck(cdxtail, ady, cdytail, adx) + detail::ExpansionBase<T>::TwoTwoDiffZeroCheck(adytail, cdx, adxtail, cdy);
const detail::Expansion<T, 8> abt = detail::ExpansionBase<T>::TwoTwoDiffZeroCheck(adxtail, bdy, adytail, bdx) + detail::ExpansionBase<T>::TwoTwoDiffZeroCheck(bdytail, adx, bdxtail, ady);
const detail::Expansion<T, 192> fin2 = fin1 + bct * adz + cat * bdz + abt * cdz + bc * adztail + ca * bdztail + ab * cdztail
+ detail::ExpansionBase<T>::ThreeProd( adxtail, bdytail, cdz) + detail::ExpansionBase<T>::ThreeProd( adxtail, bdytail, cdztail)
+ detail::ExpansionBase<T>::ThreeProd(-adxtail, cdytail, bdz) + detail::ExpansionBase<T>::ThreeProd(-adxtail, cdytail, bdztail)
+ detail::ExpansionBase<T>::ThreeProd( bdxtail, cdytail, adz) + detail::ExpansionBase<T>::ThreeProd( bdxtail, cdytail, adztail)
+ detail::ExpansionBase<T>::ThreeProd(-bdxtail, adytail, cdz) + detail::ExpansionBase<T>::ThreeProd(-bdxtail, adytail, cdztail)
+ detail::ExpansionBase<T>::ThreeProd( cdxtail, adytail, bdz) + detail::ExpansionBase<T>::ThreeProd( cdxtail, adytail, bdztail)
+ detail::ExpansionBase<T>::ThreeProd(-cdxtail, bdytail, adz) + detail::ExpansionBase<T>::ThreeProd(-cdxtail, bdytail, adztail)
+ bct * adztail + cat * bdztail + abt * cdztail;
return fin2.mostSignificant();
}
//@brief : determine if the 3d point e is inside, on, or outside the sphere defined by a, b, c, and d
//@param pa: pointer to a as {x, y, z}
//@param pb: pointer to b as {x, y, z}
//@param pc: pointer to c as {x, y, z}
//@param pd: pointer to d as {x, y, z}
//@param pe: pointer to e as {x, y, z}
//@return : determinant of {{ax - ex, ay - ey, az - ez, (ax - ex)^2 + (ay - ey)^2 + (az - ez)^2}, {bx - ex, by - ey, bz - ez, (bx - ex)^2 + (by - ey)^2 + (bz - ez)^2}, {cx - ex, cy - ey, cz - ez, (cx - ex)^2 + (cy - ey)^2 + (cz - ez)^2}, {dx - ex, dy - ey, dz - ez, (dx - ex)^2 + (dy - ey)^2 + (dz - ez)^2}}
//@note : positive, 0, negative result for d inside, on, or outside the circle defined by a, b, and c
template <typename T> T insphere(T const*const pa, T const*const pb, T const*const pc, T const*const pd, T const*const pe) {
T permanent;
const T aex = pa[0] - pe[0];
const T bex = pb[0] - pe[0];
const T cex = pc[0] - pe[0];
const T dex = pd[0] - pe[0];
const T aey = pa[1] - pe[1];
const T bey = pb[1] - pe[1];
const T cey = pc[1] - pe[1];
const T dey = pd[1] - pe[1];
const T aez = pa[2] - pe[2];
const T bez = pb[2] - pe[2];
const T cez = pc[2] - pe[2];
const T dez = pd[2] - pe[2];
{
const T aexbey = aex * bey;
const T bexaey = bex * aey;
const T bexcey = bex * cey;
const T cexbey = cex * bey;
const T cexdey = cex * dey;
const T dexcey = dex * cey;
const T dexaey = dex * aey;
const T aexdey = aex * dey;
const T aexcey = aex * cey;
const T cexaey = cex * aey;
const T bexdey = bex * dey;
const T dexbey = dex * bey;
const T ab = aexbey - bexaey;
const T bc = bexcey - cexbey;
const T cd = cexdey - dexcey;
const T da = dexaey - aexdey;
const T ac = aexcey - cexaey;
const T bd = bexdey - dexbey;
const T abc = aez * bc - bez * ac + cez * ab;
const T bcd = bez * cd - cez * bd + dez * bc;
const T cda = cez * da + dez * ac + aez * cd;
const T dab = dez * ab + aez * bd + bez * da;
const T alift = aex * aex + aey * aey + aez * aez;
const T blift = bex * bex + bey * bey + bez * bez;
const T clift = cex * cex + cey * cey + cez * cez;
const T dlift = dex * dex + dey * dey + dez * dez;
const T det = (dlift * abc - clift * dab) + (blift * cda - alift * bcd);
const T aezplus = std::abs(aez);
const T bezplus = std::abs(bez);
const T cezplus = std::abs(cez);
const T dezplus = std::abs(dez);
const T aexbeyplus = std::abs(aexbey);
const T bexaeyplus = std::abs(bexaey);
const T bexceyplus = std::abs(bexcey);
const T cexbeyplus = std::abs(cexbey);
const T cexdeyplus = std::abs(cexdey);
const T dexceyplus = std::abs(dexcey);
const T dexaeyplus = std::abs(dexaey);
const T aexdeyplus = std::abs(aexdey);
const T aexceyplus = std::abs(aexcey);
const T cexaeyplus = std::abs(cexaey);
const T bexdeyplus = std::abs(bexdey);
const T dexbeyplus = std::abs(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;
const T errbound = Constants<T>::isperrboundA * permanent;
if(std::abs(det) >= std::abs(errbound)) return det;
}
const detail::Expansion<T, 4> ab = detail::ExpansionBase<T>::TwoTwoDiff(aex, bey, bex, aey);
const detail::Expansion<T, 4> bc = detail::ExpansionBase<T>::TwoTwoDiff(bex, cey, cex, bey);
const detail::Expansion<T, 4> cd = detail::ExpansionBase<T>::TwoTwoDiff(cex, dey, dex, cey);
const detail::Expansion<T, 4> da = detail::ExpansionBase<T>::TwoTwoDiff(dex, aey, aex, dey);
const detail::Expansion<T, 4> ac = detail::ExpansionBase<T>::TwoTwoDiff(aex, cey, cex, aey);
const detail::Expansion<T, 4> bd = detail::ExpansionBase<T>::TwoTwoDiff(bex, dey, dex, bey);
const detail::Expansion<T, 24> temp24a = bc * dez + (cd * bez + bd * -cez);
const detail::Expansion<T, 24> temp24b = cd * aez + (da * cez + ac * dez);
const detail::Expansion<T, 24> temp24c = da * bez + (ab * dez + bd * aez);
const detail::Expansion<T, 24> temp24d = ab * cez + (bc * aez + ac * -bez);
const detail::Expansion<T, 288> adet = temp24a * aex * -aex + temp24a * aey * -aey + temp24a * aez * -aez;
const detail::Expansion<T, 288> bdet = temp24b * bex * bex + temp24b * bey * bey + temp24b * bez * bez;
const detail::Expansion<T, 288> cdet = temp24c * cex * -cex + temp24c * cey * -cey + temp24c * cez * -cez;
const detail::Expansion<T, 288> ddet = temp24d * dex * dex + temp24d * dey * dey + temp24d * dez * dez;
const detail::Expansion<T, 1152> fin1 = (adet + bdet) + (cdet + ddet);
T det = fin1.estimate();
T errbound = Constants<T>::isperrboundB * permanent;
if(std::abs(det) >= std::abs(errbound)) return det;
const T aextail = detail::ExpansionBase<T>::MinusTail(pa[0], pe[0], aex);
const T aeytail = detail::ExpansionBase<T>::MinusTail(pa[1], pe[1], aey);
const T aeztail = detail::ExpansionBase<T>::MinusTail(pa[2], pe[2], aez);
const T bextail = detail::ExpansionBase<T>::MinusTail(pb[0], pe[0], bex);
const T beytail = detail::ExpansionBase<T>::MinusTail(pb[1], pe[1], bey);
const T beztail = detail::ExpansionBase<T>::MinusTail(pb[2], pe[2], bez);
const T cextail = detail::ExpansionBase<T>::MinusTail(pc[0], pe[0], cex);
const T ceytail = detail::ExpansionBase<T>::MinusTail(pc[1], pe[1], cey);
const T ceztail = detail::ExpansionBase<T>::MinusTail(pc[2], pe[2], cez);
const T dextail = detail::ExpansionBase<T>::MinusTail(pd[0], pe[0], dex);
const T deytail = detail::ExpansionBase<T>::MinusTail(pd[1], pe[1], dey);
const T deztail = detail::ExpansionBase<T>::MinusTail(pd[2], pe[2], dez);
if (T(0) == aextail && T(0) == aeytail && T(0) == aeztail &&
T(0) == bextail && T(0) == beytail && T(0) == beztail &&
T(0) == cextail && T(0) == ceytail && T(0) == ceztail &&
T(0) == dextail && T(0) == deytail && T(0) == deztail) return det;
errbound = Constants<T>::isperrboundC * permanent + Constants<T>::resulterrbound * std::abs(det);
const T abeps = (aex * beytail + bey * aextail) - (aey * bextail + bex * aeytail);
const T bceps = (bex * ceytail + cey * bextail) - (bey * cextail + cex * beytail);
const T cdeps = (cex * deytail + dey * cextail) - (cey * dextail + dex * ceytail);
const T daeps = (dex * aeytail + aey * dextail) - (dey * aextail + aex * deytail);
const T aceps = (aex * ceytail + cey * aextail) - (aey * cextail + cex * aeytail);
const T bdeps = (bex * deytail + dey * bextail) - (bey * dextail + dex * beytail);
const T ab3 = ab.mostSignificant();
const T bc3 = bc.mostSignificant();
const T cd3 = cd.mostSignificant();
const T da3 = da.mostSignificant();
const T ac3 = ac.mostSignificant();
const T bd3 = bd.mostSignificant();
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)) ) )
+ T(2) * ( ( (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(std::abs(det) >= std::abs(errbound)) return det;
return exact::insphere(pa, pb, pc, pd, pe);
}
}
}
#endif

View file

@ -0,0 +1,55 @@
#ifndef REMOVE_AT_HPP
#define REMOVE_AT_HPP
// check if c++11 is supported
#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
#define REMOVE_AT_CXX11_IS_SUPPORTED
#elif !defined(__cplusplus) && !defined(_MSC_VER)
typedef char couldnt_parse_cxx_standard[-1];
#endif
#include <algorithm>
#include <iterator>
/*!
* Remove elements in the range [first; last) with indices from the sorted
* unique range [ii_first, ii_last)
*/
template <class ForwardIt, class SortUniqIndsFwdIt>
inline ForwardIt remove_at(
ForwardIt first,
ForwardIt last,
SortUniqIndsFwdIt ii_first,
SortUniqIndsFwdIt ii_last)
{
if(ii_first == ii_last) // no indices-to-remove are given
return last;
typedef typename std::iterator_traits<ForwardIt>::difference_type diff_t;
typedef typename std::iterator_traits<SortUniqIndsFwdIt>::value_type ind_t;
ForwardIt destination = first + static_cast<diff_t>(*ii_first);
while(ii_first != ii_last)
{
// advance to an index after a chunk of elements-to-keep
for(ind_t cur = *ii_first++; ii_first != ii_last; ++ii_first)
{
const ind_t nxt = *ii_first;
if(nxt - cur > 1)
break;
cur = nxt;
}
// move the chunk of elements-to-keep to new destination
const ForwardIt source_first =
first + static_cast<diff_t>(*(ii_first - 1)) + 1;
const ForwardIt source_last =
ii_first != ii_last ? first + static_cast<diff_t>(*ii_first) : last;
#ifdef REMOVE_AT_CXX11_IS_SUPPORTED
std::move(source_first, source_last, destination);
#else
std::copy(source_first, source_last, destination); // c++98 version
#endif
destination += source_last - source_first;
}
return destination;
}
#endif // REMOVE_AT_HPP