Working on meshes
This commit is contained in:
parent
c479ccb9e2
commit
7b472fe18d
652 changed files with 81120 additions and 852 deletions
448
include/CDT/include/CDT.h
Normal file
448
include/CDT/include/CDT.h
Normal 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
107
include/CDT/include/CDT.hpp
Normal 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
|
||||
592
include/CDT/include/CDTUtils.h
Normal file
592
include/CDT/include/CDTUtils.h
Normal 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
|
||||
264
include/CDT/include/CDTUtils.hpp
Normal file
264
include/CDT/include/CDTUtils.hpp
Normal 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
|
||||
471
include/CDT/include/KDTree.h
Normal file
471
include/CDT/include/KDTree.h
Normal 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
|
||||
81
include/CDT/include/LocatorKDTree.h
Normal file
81
include/CDT/include/LocatorKDTree.h
Normal 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
|
||||
1160
include/CDT/include/Triangulation.h
Normal file
1160
include/CDT/include/Triangulation.h
Normal file
File diff suppressed because it is too large
Load diff
2178
include/CDT/include/Triangulation.hpp
Normal file
2178
include/CDT/include/Triangulation.hpp
Normal file
File diff suppressed because it is too large
Load diff
313
include/CDT/include/portable_nth_element.hpp
Normal file
313
include/CDT/include/portable_nth_element.hpp
Normal 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
|
||||
915
include/CDT/include/predicates.h
Normal file
915
include/CDT/include/predicates.h
Normal 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
|
||||
55
include/CDT/include/remove_at.hpp
Normal file
55
include/CDT/include/remove_at.hpp
Normal 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
|
||||
Loading…
Add table
Add a link
Reference in a new issue