|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r78335 - in trunk: boost/polygon boost/polygon/detail libs/polygon/test
From: sydorchuk.andriy_at_[hidden]
Date: 2012-05-05 10:29:12
Author: asydorchuk
Date: 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
New Revision: 78335
URL: http://svn.boost.org/trac/boost/changeset/78335
Log:
Merging Polygon with Voronoi library.
Adding Boost.Polygon segment concept.
Adding Voronoi tests.
Adding Boost.Polygon segment concept/data/traits tests.
Added:
trunk/boost/polygon/detail/voronoi_ctypes.hpp (contents, props changed)
trunk/boost/polygon/detail/voronoi_predicates.hpp (contents, props changed)
trunk/boost/polygon/detail/voronoi_robust_fpt.hpp (contents, props changed)
trunk/boost/polygon/detail/voronoi_structures.hpp (contents, props changed)
trunk/boost/polygon/segment_concept.hpp (contents, props changed)
trunk/boost/polygon/segment_data.hpp (contents, props changed)
trunk/boost/polygon/segment_traits.hpp (contents, props changed)
trunk/boost/polygon/voronoi.hpp (contents, props changed)
trunk/boost/polygon/voronoi_builder.hpp (contents, props changed)
trunk/boost/polygon/voronoi_diagram.hpp (contents, props changed)
trunk/boost/polygon/voronoi_utils.hpp (contents, props changed)
trunk/libs/polygon/test/polygon_segment_test.cpp (contents, props changed)
trunk/libs/polygon/test/voronoi_builder_test.cpp (contents, props changed)
trunk/libs/polygon/test/voronoi_ctypes_test.cpp (contents, props changed)
trunk/libs/polygon/test/voronoi_predicates_test.cpp (contents, props changed)
trunk/libs/polygon/test/voronoi_robust_fpt_test.cpp (contents, props changed)
trunk/libs/polygon/test/voronoi_structures_test.cpp (contents, props changed)
trunk/libs/polygon/test/voronoi_test_helper.hpp (contents, props changed)
Removed:
trunk/boost/polygon/directed_line_segment_concept.hpp
trunk/boost/polygon/directed_line_segment_data.hpp
trunk/boost/polygon/directed_line_segment_set_data.hpp
trunk/boost/polygon/directed_line_segment_traits.hpp
Text files modified:
trunk/boost/polygon/interval_concept.hpp | 252 +++++++++++++++++++++++----------------
trunk/boost/polygon/point_3d_concept.hpp | 28 ++--
trunk/boost/polygon/point_concept.hpp | 199 +++++++++++++++++--------------
trunk/boost/polygon/polygon.hpp | 7
trunk/boost/polygon/polygon_90_set_concept.hpp | 17 +-
trunk/boost/polygon/polygon_traits.hpp | 2
trunk/boost/polygon/rectangle_concept.hpp | 214 ++++++++++++++++----------------
trunk/libs/polygon/test/Jamfile.v2 | 14 ++
trunk/libs/polygon/test/gtl_boost_unit_test.cpp | 17 +-
9 files changed, 411 insertions(+), 339 deletions(-)
Added: trunk/boost/polygon/detail/voronoi_ctypes.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/detail/voronoi_ctypes.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,713 @@
+// Boost.Polygon library detail/voronoi_ctypes.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_DETAIL_VORONOI_CTYPES
+#define BOOST_POLYGON_DETAIL_VORONOI_CTYPES
+
+#include <cmath>
+#include <cstring>
+
+#include <boost/cstdint.hpp>
+
+namespace boost {
+namespace polygon {
+namespace detail {
+
+typedef boost::int32_t int32;
+typedef boost::int64_t int64;
+typedef boost::uint32_t uint32;
+typedef boost::uint64_t uint64;
+typedef double fpt64;
+
+// If two floating-point numbers in the same format are ordered (x < y),
+// then they are ordered the same way when their bits are reinterpreted as
+// sign-magnitude integers. Values are considered to be almost equal if
+// their integer bits reinterpretations differ in not more than maxUlps units.
+template <typename _fpt>
+struct ulp_comparison;
+
+template <>
+struct ulp_comparison<fpt64> {
+ enum Result {
+ LESS = -1,
+ EQUAL = 0,
+ MORE = 1
+ };
+
+ Result operator()(fpt64 a, fpt64 b, unsigned int maxUlps) const {
+ uint64 ll_a, ll_b;
+
+ // Reinterpret double bits as 64-bit signed integer.
+ memcpy(&ll_a, &a, sizeof(fpt64));
+ memcpy(&ll_b, &b, sizeof(fpt64));
+
+ // Positive 0.0 is integer zero. Negative 0.0 is 0x8000000000000000.
+ // Map negative zero to an integer zero representation - making it
+ // identical to positive zero - the smallest negative number is
+ // represented by negative one, and downwards from there.
+ if (ll_a < 0x8000000000000000ULL)
+ ll_a = 0x8000000000000000ULL - ll_a;
+ if (ll_b < 0x8000000000000000ULL)
+ ll_b = 0x8000000000000000ULL - ll_b;
+
+ // Compare 64-bit signed integer representations of input values.
+ // Difference in 1 Ulp is equivalent to a relative error of between
+ // 1/4,000,000,000,000,000 and 1/8,000,000,000,000,000.
+ if (ll_a > ll_b)
+ return (ll_a - ll_b <= maxUlps) ? EQUAL : LESS;
+ return (ll_b - ll_a <= maxUlps) ? EQUAL : MORE;
+ }
+};
+
+// Manages exponent of the floating-point value.
+template <typename _fpt>
+struct fpt_exponent_accessor;
+
+template <>
+class fpt_exponent_accessor<fpt64> {
+public:
+ static const int64 kExponentMask;
+ static const int64 kSignedMantissaMask;
+ static const int64 kMinExponent;
+ static const int64 kMaxExponent;
+ static const int64 kMaxSignificantExpDif;
+
+ static int64 set_exponent(fpt64& value, int64 exponent) {
+ int64 bits;
+ memcpy(&bits, &value, sizeof(fpt64));
+ int64 exp = ((bits & kExponentMask) >> 52) - 1023;
+ if (exp == exponent)
+ return exp;
+ bits = (bits & kSignedMantissaMask) | ((exponent + 1023) << 52);
+ memcpy(&value, &bits, sizeof(fpt64));
+ return exp;
+ }
+};
+
+const int64 fpt_exponent_accessor<fpt64>::kExponentMask =
+ 0x7ff0000000000000LL;
+const int64 fpt_exponent_accessor<fpt64>::kSignedMantissaMask =
+ 0x800fffffffffffffLL;
+const int64 fpt_exponent_accessor<fpt64>::kMinExponent = -1023LL;
+const int64 fpt_exponent_accessor<fpt64>::kMaxExponent = 1024LL;
+const int64 fpt_exponent_accessor<fpt64>::kMaxSignificantExpDif = 54;
+
+// Floating point type wrapper. Allows to extend exponent boundaries to the
+// 64 bit integer range. This class does not handle division by zero, subnormal
+// numbers or NaNs.
+template <typename _fpt>
+class extended_exponent_fpt {
+public:
+ typedef _fpt fpt_type;
+ typedef int64 exp_type;
+ typedef fpt_exponent_accessor<fpt_type> fea;
+
+ explicit extended_exponent_fpt(fpt_type value) {
+ if (value == 0.0) {
+ exponent_ = 0;
+ value_ = 0.0;
+ } else {
+ exponent_ = fea::set_exponent(value, 0);
+ value_ = value;
+ }
+ }
+
+ extended_exponent_fpt(fpt_type value, exp_type exponent) {
+ if (value == 0.0) {
+ exponent_ = 0;
+ value_ = 0.0;
+ } else {
+ exponent_ = fea::set_exponent(value, 0) + exponent;
+ value_ = value;
+ }
+ }
+
+ bool is_pos() const {
+ return value_ > 0;
+ }
+
+ bool is_neg() const {
+ return value_ < 0;
+ }
+
+ bool is_zero() const {
+ return value_ == 0;
+ }
+
+ extended_exponent_fpt operator-() const {
+ return extended_exponent_fpt(-value_, exponent_);
+ }
+
+ extended_exponent_fpt operator+(const extended_exponent_fpt& that) const {
+ if (this->value_ == 0.0 ||
+ that.exponent_ > this->exponent_ + fea::kMaxSignificantExpDif) {
+ return that;
+ }
+ if (that.value_ == 0.0 ||
+ this->exponent_ > that.exponent_ + fea::kMaxSignificantExpDif) {
+ return *this;
+ }
+ if (this->exponent_ >= that.exponent_) {
+ exp_type exp_dif = this->exponent_ - that.exponent_;
+ fpt_type value = this->value_;
+ fea::set_exponent(value, exp_dif);
+ value += that.value_;
+ return extended_exponent_fpt(value, that.exponent_);
+ } else {
+ exp_type exp_dif = that.exponent_ - this->exponent_;
+ fpt_type value = that.value_;
+ fea::set_exponent(value, exp_dif);
+ value += this->value_;
+ return extended_exponent_fpt(value, this->exponent_);
+ }
+ }
+
+ extended_exponent_fpt operator-(const extended_exponent_fpt& that) const {
+ if (this->value_ == 0.0 ||
+ that.exponent_ > this->exponent_ + fea::kMaxSignificantExpDif) {
+ return extended_exponent_fpt(-that.value_, that.exponent_);
+ }
+ if (that.value_ == 0.0 ||
+ this->exponent_ > that.exponent_ + fea::kMaxSignificantExpDif) {
+ return *this;
+ }
+ if (this->exponent_ >= that.exponent_) {
+ exp_type exp_dif = this->exponent_ - that.exponent_;
+ fpt_type value = this->value_;
+ fea::set_exponent(value, exp_dif);
+ value -= that.value_;
+ return extended_exponent_fpt(value, that.exponent_);
+ } else {
+ exp_type exp_dif = that.exponent_ - this->exponent_;
+ fpt_type value = -that.value_;
+ fea::set_exponent(value, exp_dif);
+ value += this->value_;
+ return extended_exponent_fpt(value, this->exponent_);
+ }
+ }
+
+ extended_exponent_fpt operator*(const extended_exponent_fpt& that) const {
+ fpt_type value = this->value_ * that.value_;
+ exp_type exponent = this->exponent_ + that.exponent_;
+ return extended_exponent_fpt(value, exponent);
+ }
+
+ extended_exponent_fpt operator/(const extended_exponent_fpt& that) const {
+ fpt_type value = this->value_ / that.value_;
+ exp_type exponent = this->exponent_ - that.exponent_;
+ return extended_exponent_fpt(value, exponent);
+ }
+
+ extended_exponent_fpt& operator+=(const extended_exponent_fpt& that) {
+ return *this = *this + that;
+ }
+
+ extended_exponent_fpt& operator-=(const extended_exponent_fpt& that) {
+ return *this = *this - that;
+ }
+
+ extended_exponent_fpt& operator*=(const extended_exponent_fpt& that) {
+ return *this = *this * that;
+ }
+
+ extended_exponent_fpt& operator/=(const extended_exponent_fpt& that) {
+ return *this = *this / that;
+ }
+
+ extended_exponent_fpt sqrt() const {
+ fpt_type val = value_;
+ exp_type exp = exponent_;
+ if (exp & 1) {
+ val *= 2.0;
+ --exp;
+ }
+ return extended_exponent_fpt(std::sqrt(val), exp >> 1);
+ }
+
+ fpt_type d() const {
+ fpt_type ret_val = value_;
+ exp_type exp = exponent_;
+ if (ret_val == 0.0)
+ return ret_val;
+ if (exp >= fea::kMaxExponent) {
+ ret_val = 1.0;
+ exp = fea::kMaxExponent;
+ } else if (exp <= fea::kMinExponent) {
+ ret_val = 1.0;
+ exp = fea::kMinExponent;
+ }
+ fea::set_exponent(ret_val, exp);
+ return ret_val;
+ }
+
+private:
+ fpt_type value_;
+ exp_type exponent_;
+};
+typedef extended_exponent_fpt<double> efpt64;
+
+template <typename _fpt>
+extended_exponent_fpt<_fpt> get_sqrt(const extended_exponent_fpt<_fpt>& that) {
+ return that.sqrt();
+}
+
+template <typename _fpt>
+bool is_pos(const extended_exponent_fpt<_fpt>& that) {
+ return that.is_pos();
+}
+
+template <typename _fpt>
+bool is_neg(const extended_exponent_fpt<_fpt>& that) {
+ return that.is_neg();
+}
+
+template <typename _fpt>
+bool is_zero(const extended_exponent_fpt<_fpt>& that) {
+ return that.is_zero();
+}
+
+// Very efficient stack allocated big integer class.
+// Supports next set of arithmetic operations: +, -, *.
+template<size_t N>
+class extended_int {
+public:
+ static const uint64 kUInt64LowMask;
+ static const uint64 kUInt64HighMask;
+
+ extended_int() {}
+
+ extended_int(int32 that) {
+ if (that > 0) {
+ this->chunks_[0] = that;
+ this->count_ = 1;
+ } else if (that < 0) {
+ this->chunks_[0] = -that;
+ this->count_ = -1;
+ } else {
+ this->count_ = 0;
+ }
+ }
+
+ extended_int(int64 that) {
+ if (that > 0) {
+ this->chunks_[0] = static_cast<uint32>(that & kUInt64LowMask);
+ this->chunks_[1] = that >> 32;
+ this->count_ = this->chunks_[1] ? 2 : 1;
+ } else if (that < 0) {
+ that = -that;
+ this->chunks_[0] = static_cast<uint32>(that & kUInt64LowMask);
+ this->chunks_[1] = that >> 32;
+ this->count_ = this->chunks_[1] ? -2 : -1;
+ } else {
+ this->count_ = 0;
+ }
+ }
+
+ extended_int(const std::vector<uint32>& chunks, bool plus = true) {
+ this->count_ = static_cast<int32>((std::min)(N, chunks.size()));
+ for (int i = 0; i < this->count_; ++i)
+ this->chunks_[i] = chunks[chunks.size() - i - 1];
+ if (!plus)
+ this->count_ = -this->count_;
+ }
+
+ template <size_t M>
+ extended_int(const extended_int<M>& that) {
+ if (that.size() > N) return;
+ this->count_ = that.count();
+ memcpy(this->chunks_, that.chunks(), that.size() * sizeof(uint32));
+ }
+
+ extended_int& operator=(int32 that) {
+ if (that > 0) {
+ this->chunks_[0] = that;
+ this->count_ = 1;
+ } else if (that < 0) {
+ this->chunks_[0] = -that;
+ this->count_ = -1;
+ } else {
+ this->count_ = 0;
+ }
+ return *this;
+ }
+
+ extended_int& operator=(int64 that) {
+ if (that > 0) {
+ this->chunks_[0] = static_cast<uint32>(that & kUInt64LowMask);
+ this->chunks_[1] = that >> 32;
+ this->count_ = this->chunks_[1] ? 2 : 1;
+ } else if (that < 0) {
+ that = -that;
+ this->chunks_[0] = static_cast<uint32>(that & kUInt64LowMask);
+ this->chunks_[1] = that >> 32;
+ this->count_ = this->chunks_[1] ? -2 : -1;
+ } else {
+ this->count_ = 0;
+ }
+ return *this;
+ }
+
+ template <size_t M>
+ extended_int& operator=(const extended_int<M>& that) {
+ size_t mx = (std::max)(N, that.size());
+ this->count_ = that.count();
+ memcpy(this->chunks_, that.chunks(), mx * sizeof(uint32));
+ return *this;
+ }
+
+ bool is_pos() const {
+ return this->count_ > 0;
+ }
+
+ bool is_neg() const {
+ return this->count_ < 0;
+ }
+
+ bool is_zero() const {
+ return this->count_ == 0;
+ }
+
+ template <size_t M>
+ bool operator==(const extended_int<M>& that) const {
+ if (this->count_ != that.count())
+ return false;
+ for (size_t i = 0; i < this->size(); ++i)
+ if (this->chunks_[i] != that.chunks()[i])
+ return false;
+ return true;
+ }
+
+ template <size_t M>
+ bool operator!=(const extended_int<M>& that) const {
+ return !(*this == that);
+ }
+
+ template <size_t M>
+ bool operator<(const extended_int<M>& that) const {
+ if (this->count_ != that.count())
+ return this->count_ < that.count();
+ size_t i = this->size();
+ if (!i)
+ return false;
+ do {
+ --i;
+ if (this->chunks_[i] != that.chunks()[i])
+ return (this->chunks_[i] < that.chunks()[i]) ^ (this->count_ < 0);
+ } while (i);
+ return false;
+ }
+
+ template <size_t M>
+ bool operator>(const extended_int<M>& that) const {
+ return that < *this;
+ }
+
+ template <size_t M>
+ bool operator<=(const extended_int<M>& that) const {
+ return !(that < *this);
+ }
+
+ template <size_t M>
+ bool operator>=(const extended_int<M>& that) const {
+ return !(*this < that);
+ }
+
+ extended_int operator-() const {
+ extended_int ret_val = *this;
+ ret_val.neg();
+ return ret_val;
+ }
+
+ void neg() {
+ this->count_ = -this->count_;
+ }
+
+ template <size_t M>
+ extended_int<(N>M?N:M)> operator+(const extended_int<M>& that) const {
+ extended_int<(N>M?N:M)> ret_val;
+ ret_val.add(*this, that);
+ return ret_val;
+ }
+
+ template <size_t N1, size_t N2>
+ void add(const extended_int<N1>& e1, const extended_int<N2>& e2) {
+ if (!e1.count()) {
+ *this = e2;
+ return;
+ }
+ if (!e2.count()) {
+ *this = e1;
+ return;
+ }
+ if ((e1.count() > 0) ^ (e2.count() > 0)) {
+ dif(e1.chunks(), e1.size(), e2.chunks(), e2.size());
+ } else {
+ add(e1.chunks(), e1.size(), e2.chunks(), e2.size());
+ }
+ if (e1.count() < 0)
+ this->count_ = -this->count_;
+ }
+
+ template <size_t M>
+ extended_int<(N>M?N:M)> operator-(const extended_int<M>& that) const {
+ extended_int<(N>M?N:M)> ret_val;
+ ret_val.dif(*this, that);
+ return ret_val;
+ }
+
+ template <size_t N1, size_t N2>
+ void dif(const extended_int<N1>& e1, const extended_int<N2> &e2) {
+ if (!e1.count()) {
+ *this = e2;
+ this->count_ = -this->count_;
+ return;
+ }
+ if (!e2.count()) {
+ *this = e1;
+ return;
+ }
+ if ((e1.count() > 0) ^ (e2.count() > 0)) {
+ add(e1.chunks(), e1.size(), e2.chunks(), e2.size());
+ } else {
+ dif(e1.chunks(), e1.size(), e2.chunks(), e2.size());
+ }
+ if (e1.count() < 0)
+ this->count_ = -this->count_;
+ }
+
+ extended_int<N> operator*(int32 that) const {
+ extended_int<N> temp(that);
+ return (*this) * temp;
+ }
+
+ extended_int<N> operator*(int64 that) const {
+ extended_int<N> temp(that);
+ return (*this) * temp;
+ }
+
+ template <size_t M>
+ extended_int<(N>M?N:M)> operator*(const extended_int<M>& that) const {
+ extended_int<(N>M?N:M)> ret_val;
+ ret_val.mul(*this, that);
+ return ret_val;
+ }
+
+ template <size_t N1, size_t N2>
+ void mul(const extended_int<N1>& e1, const extended_int<N2>& e2) {
+ if (!e1.count() || !e2.count()) {
+ this->count_ = 0;
+ return;
+ }
+ mul(e1.chunks(), e1.size(), e2.chunks(), e2.size());
+ if ((e1.count() > 0) ^ (e2.count() > 0))
+ this->count_ = -this->count_;
+ }
+
+ const uint32* chunks() const {
+ return chunks_;
+ }
+
+ int32 count() const {
+ return count_;
+ }
+
+ size_t size() const {
+ return (std::abs)(count_);
+ }
+
+ std::pair<fpt64, int64> p() const {
+ std::pair<fpt64, int64> ret_val(0, 0);
+ size_t sz = this->size();
+ if (!sz) {
+ return ret_val;
+ } else {
+ if (sz == 1) {
+ ret_val.first = static_cast<fpt64>(this->chunks_[0]);
+ } else if (sz == 2) {
+ ret_val.first = static_cast<fpt64>(this->chunks_[1]) *
+ static_cast<fpt64>(0x100000000LL) +
+ static_cast<fpt64>(this->chunks_[0]);
+ } else {
+ for (size_t i = 1; i <= 3; ++i) {
+ ret_val.first *= static_cast<fpt64>(0x100000000LL);
+ ret_val.first += static_cast<fpt64>(this->chunks_[sz - i]);
+ }
+ ret_val.second = (sz - 3) << 5;
+ }
+ }
+ if (this->count_ < 0)
+ ret_val.first = -ret_val.first;
+ return ret_val;
+ }
+
+ fpt64 d() const {
+ std::pair<fpt64, int64> p = this->p();
+ extended_exponent_fpt<fpt64> efpt(p.first, p.second);
+ return efpt.d();
+ }
+
+private:
+ void add(const uint32* c1, size_t sz1, const uint32* c2, size_t sz2) {
+ if (sz1 < sz2) {
+ add(c2, sz2, c1, sz1);
+ return;
+ }
+ this->count_ = sz1;
+ uint64 temp = 0;
+ for (size_t i = 0; i < sz2; ++i) {
+ temp += static_cast<uint64>(c1[i]) + static_cast<uint64>(c2[i]);
+ this->chunks_[i] = static_cast<uint32>(temp & kUInt64LowMask);
+ temp >>= 32;
+ }
+ for (size_t i = sz2; i < sz1; ++i) {
+ temp += static_cast<uint64>(c1[i]);
+ this->chunks_[i] = static_cast<uint32>(temp & kUInt64LowMask);
+ temp >>= 32;
+ }
+ if (temp && (this->count_ != N)) {
+ this->chunks_[this->count_] = static_cast<uint32>(temp & kUInt64LowMask);
+ ++this->count_;
+ }
+ }
+
+ void dif(const uint32* c1, size_t sz1,
+ const uint32* c2, size_t sz2, bool rec = false) {
+ if (sz1 < sz2) {
+ dif(c2, sz2, c1, sz1, true);
+ this->count_ = -this->count_;
+ return;
+ } else if ((sz1 == sz2) && !rec) {
+ do {
+ --sz1;
+ if (c1[sz1] < c2[sz1]) {
+ ++sz1;
+ dif(c2, sz1, c1, sz1, true);
+ this->count_ = -this->count_;
+ return;
+ } else if (c1[sz1] > c2[sz1]) {
+ ++sz1;
+ break;
+ }
+ } while (sz1);
+ if (!sz1) {
+ this->count_ = 0;
+ return;
+ }
+ sz2 = sz1;
+ }
+ this->count_ = sz1-1;
+ bool flag = false;
+ for (size_t i = 0; i < sz2; ++i) {
+ this->chunks_[i] = c1[i] - c2[i] - (flag?1:0);
+ flag = (c1[i] < c2[i]) || ((c1[i] == c2[i]) && flag);
+ }
+ for (size_t i = sz2; i < sz1; ++i) {
+ this->chunks_[i] = c1[i] - (flag?1:0);
+ flag = !c1[i] && flag;
+ }
+ if (this->chunks_[this->count_])
+ ++this->count_;
+ }
+
+ void mul(const uint32* c1, size_t sz1, const uint32* c2, size_t sz2) {
+ uint64 cur = 0, nxt, tmp;
+ this->count_ = static_cast<int32>((std::min)(N, sz1 + sz2 - 1));
+ for (size_t shift = 0; shift < static_cast<size_t>(this->count_);
+ ++shift) {
+ nxt = 0;
+ for (size_t first = 0; first <= shift; ++first) {
+ if (first >= sz1)
+ break;
+ size_t second = shift - first;
+ if (second >= sz2)
+ continue;
+ tmp = static_cast<uint64>(c1[first]) * static_cast<uint64>(c2[second]);
+ cur += tmp & kUInt64LowMask;
+ nxt += tmp >> 32;
+ }
+ this->chunks_[shift] = static_cast<uint32>(cur & kUInt64LowMask);
+ cur = nxt + (cur >> 32);
+ }
+ if (cur && (this->count_ != N)) {
+ this->chunks_[this->count_] = static_cast<uint32>(cur & kUInt64LowMask);
+ ++this->count_;
+ }
+ }
+
+ uint32 chunks_[N];
+ int32 count_;
+};
+
+template <size_t N>
+const uint64 extended_int<N>::kUInt64LowMask = 0x00000000ffffffffULL;
+template <size_t N>
+const uint64 extended_int<N>::kUInt64HighMask = 0xffffffff00000000ULL;
+
+template <size_t N>
+bool is_pos(const extended_int<N>& that) {
+ return that.count() > 0;
+}
+
+template <size_t N>
+bool is_neg(const extended_int<N>& that) {
+ return that.count() < 0;
+}
+
+template <size_t N>
+bool is_zero(const extended_int<N>& that) {
+ return !that.count();
+}
+
+struct type_converter_fpt {
+ template <typename T>
+ fpt64 operator()(const T& that) const {
+ return static_cast<fpt64>(that);
+ }
+
+ template <size_t N>
+ fpt64 operator()(const extended_int<N>& that) const {
+ return that.d();
+ }
+
+ fpt64 operator()(const extended_exponent_fpt<fpt64>& that) const {
+ return that.d();
+ }
+};
+
+struct type_converter_efpt {
+ template <size_t N>
+ extended_exponent_fpt<fpt64> operator()(const extended_int<N>& that) const {
+ std::pair<fpt64, int64> p = that.p();
+ return extended_exponent_fpt<fpt64>(p.first, p.second);
+ }
+};
+
+// Voronoi coordinate type traits make it possible to extend algorithm
+// input coordinate range to any user provided integer type and algorithm
+// output coordinate range to any ieee-754 like floating point type.
+template <typename T>
+struct voronoi_ctype_traits;
+
+template <>
+struct voronoi_ctype_traits<int32> {
+ typedef int32 int_type;
+ typedef int64 int_x2_type;
+ typedef uint64 uint_x2_type;
+ typedef extended_int<64> big_int_type;
+ typedef fpt64 fpt_type;
+ typedef extended_exponent_fpt<fpt_type> efpt_type;
+ typedef ulp_comparison<fpt_type> ulp_cmp_type;
+ typedef type_converter_fpt to_fpt_converter_type;
+ typedef type_converter_efpt to_efpt_converter_type;
+};
+} // detail
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_DETAIL_VORONOI_CTYPES
Added: trunk/boost/polygon/detail/voronoi_predicates.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/detail/voronoi_predicates.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,1440 @@
+// Boost.Polygon library detail/voronoi_predicates.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_DETAIL_VORONOI_PREDICATES
+#define BOOST_POLYGON_DETAIL_VORONOI_PREDICATES
+
+#include "voronoi_robust_fpt.hpp"
+
+namespace boost {
+namespace polygon {
+namespace detail {
+
+// Predicate utilities. Operates with the coordinate types that could
+// be converted to the 32-bit signed integer without precision loss.
+template <typename CTYPE_TRAITS>
+class voronoi_predicates {
+public:
+ typedef typename CTYPE_TRAITS::int_type int_type;
+ typedef typename CTYPE_TRAITS::int_x2_type int_x2_type;
+ typedef typename CTYPE_TRAITS::uint_x2_type uint_x2_type;
+ typedef typename CTYPE_TRAITS::big_int_type big_int_type;
+ typedef typename CTYPE_TRAITS::fpt_type fpt_type;
+ typedef typename CTYPE_TRAITS::efpt_type efpt_type;
+ typedef typename CTYPE_TRAITS::ulp_cmp_type ulp_cmp_type;
+ typedef typename CTYPE_TRAITS::to_fpt_converter_type to_fpt_converter;
+ typedef typename CTYPE_TRAITS::to_efpt_converter_type to_efpt_converter;
+
+ enum {
+ ULPS = 64,
+ ULPSx2 = 128
+ };
+
+ template <typename Point>
+ static bool is_vertical(const Point &point1, const Point &point2) {
+ return point1.x() == point2.x();
+ }
+
+ template <typename Site>
+ static bool is_vertical(const Site &site) {
+ return is_vertical(site.point0(), site.point1());
+ }
+
+ // Compute robust cross_product: a1 * b2 - b1 * a2.
+ // It was mathematically proven that the result is correct
+ // with epsilon relative error equal to 1EPS.
+ static fpt_type robust_cross_product(int_x2_type a1_,
+ int_x2_type b1_,
+ int_x2_type a2_,
+ int_x2_type b2_) {
+ static to_fpt_converter to_fpt;
+ uint_x2_type a1 = static_cast<uint_x2_type>(is_neg(a1_) ? -a1_ : a1_);
+ uint_x2_type b1 = static_cast<uint_x2_type>(is_neg(b1_) ? -b1_ : b1_);
+ uint_x2_type a2 = static_cast<uint_x2_type>(is_neg(a2_) ? -a2_ : a2_);
+ uint_x2_type b2 = static_cast<uint_x2_type>(is_neg(b2_) ? -b2_ : b2_);
+
+ uint_x2_type l = a1 * b2;
+ uint_x2_type r = b1 * a2;
+
+ if (is_neg(a1_) ^ is_neg(b2_)) {
+ if (is_neg(a2_) ^ is_neg(b1_))
+ return (l > r) ? -to_fpt(l - r) : to_fpt(r - l);
+ else
+ return -to_fpt(l + r);
+ } else {
+ if (is_neg(a2_) ^ is_neg(b1_))
+ return to_fpt(l + r);
+ else
+ return (l < r) ? -to_fpt(r - l) : to_fpt(l - r);
+ }
+ }
+
+ typedef struct orientation_test {
+ public:
+ // Represents orientation test result.
+ enum Orientation {
+ RIGHT = -1,
+ COLLINEAR = 0,
+ LEFT = 1
+ };
+
+ // Value is a determinant of two vectors (e.g. x1 * y2 - x2 * y1).
+ // Return orientation based on the sign of the determinant.
+ template <typename T>
+ static Orientation eval(T value) {
+ if (is_zero(value)) return COLLINEAR;
+ return (is_neg(value)) ? RIGHT : LEFT;
+ }
+
+ static Orientation eval(int_x2_type dif_x1_,
+ int_x2_type dif_y1_,
+ int_x2_type dif_x2_,
+ int_x2_type dif_y2_) {
+ return eval(robust_cross_product(dif_x1_, dif_y1_, dif_x2_, dif_y2_));
+ }
+
+ template <typename Point>
+ static Orientation eval(const Point &point1,
+ const Point &point2,
+ const Point &point3) {
+ int_x2_type dx1 = static_cast<int_x2_type>(point1.x()) -
+ static_cast<int_x2_type>(point2.x());
+ int_x2_type dx2 = static_cast<int_x2_type>(point2.x()) -
+ static_cast<int_x2_type>(point3.x());
+ int_x2_type dy1 = static_cast<int_x2_type>(point1.y()) -
+ static_cast<int_x2_type>(point2.y());
+ int_x2_type dy2 = static_cast<int_x2_type>(point2.y()) -
+ static_cast<int_x2_type>(point3.y());
+ return eval(robust_cross_product(dx1, dy1, dx2, dy2));
+ }
+ } ot;
+
+ template <typename Point>
+ class point_comparison_predicate {
+ public:
+ typedef Point point_type;
+
+ bool operator()(const point_type &lhs, const point_type &rhs) const {
+ if (lhs.x() == rhs.x())
+ return lhs.y() < rhs.y();
+ return lhs.x() < rhs.x();
+ }
+ };
+
+ template <typename Site, typename Circle>
+ class event_comparison_predicate {
+ public:
+ typedef Site site_type;
+ typedef Circle circle_type;
+
+ bool operator()(const site_type &lhs, const site_type &rhs) const {
+ if (lhs.x0() != rhs.x0())
+ return lhs.x0() < rhs.x0();
+ if (!lhs.is_segment()) {
+ if (!rhs.is_segment())
+ return lhs.y0() < rhs.y0();
+ if (is_vertical(rhs))
+ return lhs.y0() <= rhs.y0();
+ return true;
+ } else {
+ if (is_vertical(rhs)) {
+ if(is_vertical(lhs))
+ return lhs.y0() < rhs.y0();
+ return false;
+ }
+ if (is_vertical(lhs))
+ return true;
+ if (lhs.y0() != rhs.y0())
+ return lhs.y0() < rhs.y0();
+ return ot::eval(lhs.point1(), lhs.point0(), rhs.point1()) == ot::LEFT;
+ }
+ }
+
+ bool operator()(const site_type &lhs, const circle_type &rhs) const {
+ typename ulp_cmp_type::Result xCmp =
+ ulp_cmp(to_fpt(lhs.x()), to_fpt(rhs.lower_x()), ULPS);
+ if (xCmp != ulp_cmp_type::EQUAL)
+ return xCmp == ulp_cmp_type::LESS;
+ typename ulp_cmp_type::Result yCmp =
+ ulp_cmp(to_fpt(lhs.y()), to_fpt(rhs.lower_y()), ULPS);
+ return yCmp == ulp_cmp_type::LESS;
+ }
+
+ bool operator()(const circle_type &lhs, const site_type &rhs) const {
+ typename ulp_cmp_type::Result xCmp =
+ ulp_cmp(to_fpt(lhs.lower_x()), to_fpt(rhs.x()), ULPS);
+ if (xCmp != ulp_cmp_type::EQUAL)
+ return xCmp == ulp_cmp_type::LESS;
+ typename ulp_cmp_type::Result yCmp =
+ ulp_cmp(to_fpt(lhs.lower_y()), to_fpt(rhs.y()), ULPS);
+ return yCmp == ulp_cmp_type::LESS;
+ }
+
+ bool operator()(const circle_type &lhs, const circle_type &rhs) const {
+ typename ulp_cmp_type::Result xCmp =
+ ulp_cmp(to_fpt(lhs.lower_x()), to_fpt(rhs.lower_x()), ULPSx2);
+ if (xCmp != ulp_cmp_type::EQUAL)
+ return xCmp == ulp_cmp_type::LESS;
+ typename ulp_cmp_type::Result yCmp =
+ ulp_cmp(to_fpt(lhs.lower_y()), to_fpt(rhs.lower_y()), ULPSx2);
+ return yCmp == ulp_cmp_type::LESS;
+ }
+
+ private:
+ ulp_cmp_type ulp_cmp;
+ to_fpt_converter to_fpt;
+ };
+
+ template <typename Site>
+ class distance_predicate {
+ public:
+ typedef Site site_type;
+
+ // Returns true if a horizontal line going through a new site intersects
+ // right arc at first, else returns false. If horizontal line goes
+ // through intersection point of the given two arcs returns false also.
+ bool operator()(const site_type &left_site,
+ const site_type &right_site,
+ const site_type &new_site) const {
+ if (!left_site.is_segment()) {
+ if (!right_site.is_segment()) {
+ return pp(left_site, right_site, new_site);
+ } else {
+ return ps(left_site, right_site, new_site, false);
+ }
+ } else {
+ if (!right_site.is_segment()) {
+ return ps(right_site, left_site, new_site, true);
+ } else {
+ return ss(left_site, right_site, new_site);
+ }
+ }
+ }
+
+ private:
+ // Represents the result of the epsilon robust predicate. If the
+ // result is undefined some further processing is usually required.
+ enum kPredicateResult {
+ LESS = -1,
+ UNDEFINED = 0,
+ MORE = 1
+ };
+
+ typedef typename Site::point_type point_type;
+
+ // Robust predicate, avoids using high-precision libraries.
+ // Returns true if a horizontal line going through the new point site
+ // intersects right arc at first, else returns false. If horizontal line
+ // goes through intersection point of the given two arcs returns false.
+ bool pp(const site_type &left_site,
+ const site_type &right_site,
+ const site_type &new_site) const {
+ const point_type &left_point = left_site.point0();
+ const point_type &right_point = right_site.point0();
+ const point_type &new_point = new_site.point0();
+ if (left_point.x() > right_point.x()) {
+ if (new_point.y() <= left_point.y())
+ return false;
+ } else if (left_point.x() < right_point.x()) {
+ if (new_point.y() >= right_point.y())
+ return true;
+ } else {
+ return static_cast<int_x2_type>(left_point.y()) +
+ static_cast<int_x2_type>(right_point.y()) <
+ static_cast<int_x2_type>(new_point.y()) * 2;
+ }
+
+ fpt_type dist1 = find_distance_to_point_arc(left_site, new_point);
+ fpt_type dist2 = find_distance_to_point_arc(right_site, new_point);
+
+ // The undefined ulp range is equal to 3EPS + 3EPS <= 6ULP.
+ return dist1 < dist2;
+ }
+
+ bool ps(const site_type &left_site, const site_type &right_site,
+ const site_type &new_site, bool reverse_order) const {
+ kPredicateResult fast_res = fast_ps(
+ left_site, right_site, new_site, reverse_order);
+ if (fast_res != UNDEFINED)
+ return (fast_res == LESS);
+
+ fpt_type dist1 = find_distance_to_point_arc(
+ left_site, new_site.point0());
+ fpt_type dist2 = find_distance_to_segment_arc(
+ right_site, new_site.point0());
+
+ // The undefined ulp range is equal to 3EPS + 7EPS <= 10ULP.
+ return reverse_order ^ (dist1 < dist2);
+ }
+
+ bool ss(const site_type &left_site,
+ const site_type &right_site,
+ const site_type &new_site) const {
+ // Handle temporary segment sites.
+ if (left_site.point0() == right_site.point0() &&
+ left_site.point1() == right_site.point1()) {
+ return ot::eval(left_site.point0(),
+ left_site.point1(),
+ new_site.point0()) == ot::LEFT;
+ }
+
+ fpt_type dist1 = find_distance_to_segment_arc(
+ left_site, new_site.point0());
+ fpt_type dist2 = find_distance_to_segment_arc(
+ right_site, new_site.point0());
+
+ // The undefined ulp range is equal to 7EPS + 7EPS <= 14ULP.
+ return dist1 < dist2;
+ }
+
+ fpt_type find_distance_to_point_arc(
+ const site_type &site, const point_type &point) const {
+ fpt_type dx = to_fpt(site.x()) - to_fpt(point.x());
+ fpt_type dy = to_fpt(site.y()) - to_fpt(point.y());
+ // The relative error is at most 3EPS.
+ return (dx * dx + dy * dy) / (to_fpt(2.0) * dx);
+ }
+
+ fpt_type find_distance_to_segment_arc(
+ const site_type &site, const point_type &point) const {
+ if (is_vertical(site)) {
+ return (to_fpt(site.x()) - to_fpt(point.x())) * to_fpt(0.5);
+ } else {
+ const point_type &segment0 = site.point0(true);
+ const point_type &segment1 = site.point1(true);
+ fpt_type a1 = to_fpt(segment1.x()) - to_fpt(segment0.x());
+ fpt_type b1 = to_fpt(segment1.y()) - to_fpt(segment0.y());
+ fpt_type k = get_sqrt(a1 * a1 + b1 * b1);
+ // Avoid subtraction while computing k.
+ if (!is_neg(b1)) {
+ k = to_fpt(1.0) / (b1 + k);
+ } else {
+ k = (k - b1) / (a1 * a1);
+ }
+ // The relative error is at most 7EPS.
+ return k * robust_cross_product(
+ static_cast<int_x2_type>(segment1.x()) - static_cast<int_x2_type>(segment0.x()),
+ static_cast<int_x2_type>(segment1.y()) - static_cast<int_x2_type>(segment0.y()),
+ static_cast<int_x2_type>(point.x()) - static_cast<int_x2_type>(segment0.x()),
+ static_cast<int_x2_type>(point.y()) - static_cast<int_x2_type>(segment0.y()));
+ }
+ }
+
+ kPredicateResult fast_ps(
+ const site_type &left_site, const site_type &right_site,
+ const site_type &new_site, bool reverse_order) const {
+ const point_type &site_point = left_site.point0();
+ const point_type &segment_start = right_site.point0(true);
+ const point_type &segment_end = right_site.point1(true);
+ const point_type &new_point = new_site.point0();
+
+ if (ot::eval(segment_start, segment_end, new_point) != ot::RIGHT)
+ return (!right_site.is_inverse()) ? LESS : MORE;
+
+ fpt_type dif_x = to_fpt(new_point.x()) - to_fpt(site_point.x());
+ fpt_type dif_y = to_fpt(new_point.y()) - to_fpt(site_point.y());
+ fpt_type a = to_fpt(segment_end.x()) - to_fpt(segment_start.x());
+ fpt_type b = to_fpt(segment_end.y()) - to_fpt(segment_start.y());
+
+ if (is_vertical(right_site)) {
+ if (new_point.y() < site_point.y() && !reverse_order)
+ return MORE;
+ else if (new_point.y() > site_point.y() && reverse_order)
+ return LESS;
+ return UNDEFINED;
+ } else {
+ typename ot::Orientation orientation = ot::eval(
+ static_cast<int_x2_type>(segment_end.x()) - static_cast<int_x2_type>(segment_start.x()),
+ static_cast<int_x2_type>(segment_end.y()) - static_cast<int_x2_type>(segment_start.y()),
+ static_cast<int_x2_type>(new_point.x()) - static_cast<int_x2_type>(site_point.x()),
+ static_cast<int_x2_type>(new_point.y()) - static_cast<int_x2_type>(site_point.y()));
+ if (orientation == ot::LEFT) {
+ if (!right_site.is_inverse())
+ return reverse_order ? LESS : UNDEFINED;
+ return reverse_order ? UNDEFINED : MORE;
+ }
+ }
+
+ fpt_type fast_left_expr = a * (dif_y + dif_x) * (dif_y - dif_x);
+ fpt_type fast_right_expr = (to_fpt(2.0) * b) * dif_x * dif_y;
+ typename ulp_cmp_type::Result expr_cmp =
+ ulp_cmp(fast_left_expr, fast_right_expr, 4);
+ if (expr_cmp != ulp_cmp_type::EQUAL) {
+ if ((expr_cmp == ulp_cmp_type::MORE) ^ reverse_order)
+ return reverse_order ? LESS : MORE;
+ return UNDEFINED;
+ }
+ return UNDEFINED;
+ }
+
+ private:
+ ulp_cmp_type ulp_cmp;
+ to_fpt_converter to_fpt;
+ };
+
+ template <typename Node>
+ class node_comparison_predicate {
+ public:
+ typedef Node node_type;
+ typedef typename Node::site_type site_type;
+ typedef typename site_type::coordinate_type coordinate_type;
+ typedef distance_predicate<site_type> distance_predicate_type;
+
+ // Compares nodes in the balanced binary search tree. Nodes are
+ // compared based on the y coordinates of the arcs intersection points.
+ // Nodes with less y coordinate of the intersection point go first.
+ // Comparison is only called during the new site events processing.
+ // That's why one of the nodes will always lie on the sweepline and may
+ // be represented as a straight horizontal line.
+ bool operator() (const node_type &node1,
+ const node_type &node2) const {
+ // Get x coordinate of the rightmost site from both nodes.
+ const site_type &site1 = get_comparison_site(node1);
+ const site_type &site2 = get_comparison_site(node2);
+
+ if (site1.x() < site2.x()) {
+ // The second node contains a new site.
+ return predicate_(node1.left_site(), node1.right_site(), site2);
+ } else if (site1.x() > site2.x()) {
+ // The first node contains a new site.
+ return !predicate_(node2.left_site(), node2.right_site(), site1);
+ } else {
+ // This checks were evaluated experimentally.
+ if (site1.index() == site2.index()) {
+ // Both nodes are new (inserted during same site event processing).
+ return get_comparison_y(node1) < get_comparison_y(node2);
+ } else if (site1.index() < site2.index()) {
+ std::pair<coordinate_type, int> y1 = get_comparison_y(node1, false);
+ std::pair<coordinate_type, int> y2 = get_comparison_y(node2, true);
+ if (y1.first != y2.first) return y1.first < y2.first;
+ return (!site1.is_segment()) ? (y1.second < 0) : false;
+ } else {
+ std::pair<coordinate_type, int> y1 = get_comparison_y(node1, true);
+ std::pair<coordinate_type, int> y2 = get_comparison_y(node2, false);
+ if (y1.first != y2.first) return y1.first < y2.first;
+ return (!site2.is_segment()) ? (y2.second > 0) : true;
+ }
+ }
+ }
+
+ private:
+ // Get the newer site.
+ const site_type &get_comparison_site(const node_type &node) const {
+ if (node.left_site().index() > node.right_site().index()) {
+ return node.left_site();
+ }
+ return node.right_site();
+ }
+
+ // Get comparison pair: y coordinate and direction of the newer site.
+ std::pair<coordinate_type, int> get_comparison_y(
+ const node_type &node, bool is_new_node = true) const {
+ if (node.left_site().index() == node.right_site().index()) {
+ return std::make_pair(node.left_site().y(), 0);
+ }
+ if (node.left_site().index() > node.right_site().index()) {
+ if (!is_new_node &&
+ node.left_site().is_segment() &&
+ is_vertical(node.left_site())) {
+ return std::make_pair(node.left_site().y1(), 1);
+ }
+ return std::make_pair(node.left_site().y(), 1);
+ }
+ return std::make_pair(node.right_site().y(), -1);
+ }
+
+ distance_predicate_type predicate_;
+ };
+
+ template <typename Site>
+ class circle_existence_predicate {
+ public:
+ typedef typename Site::point_type point_type;
+ typedef Site site_type;
+
+ bool ppp(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3) const {
+ return ot::eval(site1.point0(), site2.point0(), site3.point0()) ==
+ ot::RIGHT;
+ }
+
+ bool pps(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ int segment_index) const {
+ if (segment_index != 2) {
+ typename ot::Orientation orient1 = ot::eval(site1.point0(),
+ site2.point0(), site3.point0(true));
+ typename ot::Orientation orient2 = ot::eval(site1.point0(),
+ site2.point0(), site3.point1(true));
+ if (segment_index == 1 && site1.x0() >= site2.x0()) {
+ if (orient1 != ot::RIGHT)
+ return false;
+ } else if (segment_index == 3 && site2.x0() >= site1.x0()) {
+ if (orient2 != ot::RIGHT)
+ return false;
+ } else if (orient1 != ot::RIGHT && orient2 != ot::RIGHT) {
+ return false;
+ }
+ } else {
+ if (site3.point0(true) == site1.point0() &&
+ site3.point1(true) == site2.point0())
+ return false;
+ }
+ return true;
+ }
+
+ bool pss(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ int point_index) const {
+ if (site2.point0() == site3.point0() &&
+ site2.point1() == site3.point1()) {
+ return false;
+ }
+ if (point_index == 2) {
+ if (!site2.is_inverse() && site3.is_inverse())
+ return false;
+ if (site2.is_inverse() == site3.is_inverse() &&
+ ot::eval(site2.point0(true),
+ site1.point0(),
+ site3.point1(true)) != ot::RIGHT)
+ return false;
+ }
+ return true;
+ }
+
+ bool sss(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3) const {
+ if (site1.point0() == site2.point0() && site1.point1() == site2.point1())
+ return false;
+ if (site2.point0() == site3.point0() && site2.point1() == site3.point1())
+ return false;
+ return true;
+ }
+ };
+
+ template <typename Site, typename Circle>
+ class mp_circle_formation_functor {
+ public:
+ typedef typename Site::point_type point_type;
+ typedef Site site_type;
+ typedef Circle circle_type;
+ typedef robust_sqrt_expr<big_int_type, efpt_type, to_efpt_converter>
+ robust_sqrt_expr_type;
+
+ void ppp(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ circle_type &circle,
+ bool recompute_c_x = true,
+ bool recompute_c_y = true,
+ bool recompute_lower_x = true) {
+ big_int_type dif_x[3], dif_y[3], sum_x[2], sum_y[2];
+ dif_x[0] = static_cast<int_x2_type>(site1.x()) -
+ static_cast<int_x2_type>(site2.x());
+ dif_x[1] = static_cast<int_x2_type>(site2.x()) -
+ static_cast<int_x2_type>(site3.x());
+ dif_x[2] = static_cast<int_x2_type>(site1.x()) -
+ static_cast<int_x2_type>(site3.x());
+ dif_y[0] = static_cast<int_x2_type>(site1.y()) -
+ static_cast<int_x2_type>(site2.y());
+ dif_y[1] = static_cast<int_x2_type>(site2.y()) -
+ static_cast<int_x2_type>(site3.y());
+ dif_y[2] = static_cast<int_x2_type>(site1.y()) -
+ static_cast<int_x2_type>(site3.y());
+ sum_x[0] = static_cast<int_x2_type>(site1.x()) +
+ static_cast<int_x2_type>(site2.x());
+ sum_x[1] = static_cast<int_x2_type>(site2.x()) +
+ static_cast<int_x2_type>(site3.x());
+ sum_y[0] = static_cast<int_x2_type>(site1.y()) +
+ static_cast<int_x2_type>(site2.y());
+ sum_y[1] = static_cast<int_x2_type>(site2.y()) +
+ static_cast<int_x2_type>(site3.y());
+ fpt_type inv_denom = to_fpt(0.5) / to_fpt(static_cast<big_int_type>(
+ dif_x[0] * dif_y[1] - dif_x[1] * dif_y[0]));
+ big_int_type numer1 = dif_x[0] * sum_x[0] + dif_y[0] * sum_y[0];
+ big_int_type numer2 = dif_x[1] * sum_x[1] + dif_y[1] * sum_y[1];
+
+ if (recompute_c_x || recompute_lower_x) {
+ big_int_type c_x = numer1 * dif_y[1] - numer2 * dif_y[0];
+ circle.x(to_fpt(c_x) * inv_denom);
+
+ if (recompute_lower_x) {
+ // Evaluate radius of the circle.
+ big_int_type sqr_r = (dif_x[0] * dif_x[0] + dif_y[0] * dif_y[0]) *
+ (dif_x[1] * dif_x[1] + dif_y[1] * dif_y[1]) *
+ (dif_x[2] * dif_x[2] + dif_y[2] * dif_y[2]);
+ fpt_type r = get_sqrt(to_fpt(sqr_r));
+
+ // If c_x >= 0 then lower_x = c_x + r,
+ // else lower_x = (c_x * c_x - r * r) / (c_x - r).
+ // To guarantee epsilon relative error.
+ if (!is_neg(circle.x())) {
+ if (!is_neg(inv_denom)) {
+ circle.lower_x(circle.x() + r * inv_denom);
+ } else {
+ circle.lower_x(circle.x() - r * inv_denom);
+ }
+ } else {
+ big_int_type numer = c_x * c_x - sqr_r;
+ fpt_type lower_x = to_fpt(numer) * inv_denom / (to_fpt(c_x) + r);
+ circle.lower_x(lower_x);
+ }
+ }
+ }
+
+ if (recompute_c_y) {
+ big_int_type c_y = numer2 * dif_x[0] - numer1 * dif_x[1];
+ circle.y(to_fpt(c_y) * inv_denom);
+ }
+ }
+
+ // Recompute parameters of the circle event using high-precision library.
+ void pps(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ int segment_index,
+ circle_type &c_event,
+ bool recompute_c_x = true,
+ bool recompute_c_y = true,
+ bool recompute_lower_x = true) {
+ big_int_type cA[4], cB[4];
+ big_int_type line_a = static_cast<int_x2_type>(site3.point1(true).y()) -
+ static_cast<int_x2_type>(site3.point0(true).y());
+ big_int_type line_b = static_cast<int_x2_type>(site3.point0(true).x()) -
+ static_cast<int_x2_type>(site3.point1(true).x());
+ big_int_type segm_len = line_a * line_a + line_b * line_b;
+ big_int_type vec_x = static_cast<int_x2_type>(site2.y()) -
+ static_cast<int_x2_type>(site1.y());
+ big_int_type vec_y = static_cast<int_x2_type>(site1.x()) -
+ static_cast<int_x2_type>(site2.x());
+ big_int_type sum_x = static_cast<int_x2_type>(site1.x()) +
+ static_cast<int_x2_type>(site2.x());
+ big_int_type sum_y = static_cast<int_x2_type>(site1.y()) +
+ static_cast<int_x2_type>(site2.y());
+ big_int_type teta = line_a * vec_x + line_b * vec_y;
+ big_int_type denom = vec_x * line_b - vec_y * line_a;
+
+ big_int_type dif0 = static_cast<int_x2_type>(site3.point1().y()) -
+ static_cast<int_x2_type>(site1.y());
+ big_int_type dif1 = static_cast<int_x2_type>(site1.x()) -
+ static_cast<int_x2_type>(site3.point1().x());
+ big_int_type A = line_a * dif1 - line_b * dif0;
+ dif0 = static_cast<int_x2_type>(site3.point1().y()) -
+ static_cast<int_x2_type>(site2.y());
+ dif1 = static_cast<int_x2_type>(site2.x()) -
+ static_cast<int_x2_type>(site3.point1().x());
+ big_int_type B = line_a * dif1 - line_b * dif0;
+ big_int_type sum_AB = A + B;
+
+ if (is_zero(denom)) {
+ big_int_type numer = teta * teta - sum_AB * sum_AB;
+ big_int_type denom = teta * sum_AB;
+ cA[0] = denom * sum_x * 2 + numer * vec_x;
+ cB[0] = segm_len;
+ cA[1] = denom * sum_AB * 2 + numer * teta;
+ cB[1] = 1;
+ cA[2] = denom * sum_y * 2 + numer * vec_y;
+ fpt_type inv_denom = to_fpt(1.0) / to_fpt(denom);
+ if (recompute_c_x)
+ c_event.x(to_fpt(0.25) * to_fpt(cA[0]) * inv_denom);
+ if (recompute_c_y)
+ c_event.y(to_fpt(0.25) * to_fpt(cA[2]) * inv_denom);
+ if (recompute_lower_x) {
+ c_event.lower_x(to_fpt(0.25) * to_fpt(sqrt_expr_.eval2(cA, cB)) *
+ inv_denom / get_sqrt(to_fpt(segm_len)));
+ }
+ return;
+ }
+
+ big_int_type det = (teta * teta + denom * denom) * A * B * 4;
+ fpt_type inv_denom_sqr = to_fpt(1.0) / to_fpt(denom);
+ inv_denom_sqr *= inv_denom_sqr;
+
+ if (recompute_c_x || recompute_lower_x) {
+ cA[0] = sum_x * denom * denom + teta * sum_AB * vec_x;
+ cB[0] = 1;
+ cA[1] = (segment_index == 2) ? -vec_x : vec_x;
+ cB[1] = det;
+ if (recompute_c_x) {
+ c_event.x(to_fpt(0.5) * to_fpt(sqrt_expr_.eval2(cA, cB)) *
+ inv_denom_sqr);
+ }
+ }
+
+ if (recompute_c_y || recompute_lower_x) {
+ cA[2] = sum_y * denom * denom + teta * sum_AB * vec_y;
+ cB[2] = 1;
+ cA[3] = (segment_index == 2) ? -vec_y : vec_y;
+ cB[3] = det;
+ if (recompute_c_y) {
+ c_event.y(to_fpt(0.5) * to_fpt(sqrt_expr_.eval2(&cA[2], &cB[2])) *
+ inv_denom_sqr);
+ }
+ }
+
+ if (recompute_lower_x) {
+ cB[0] = cB[0] * segm_len;
+ cB[1] = cB[1] * segm_len;
+ cA[2] = sum_AB * (denom * denom + teta * teta);
+ cB[2] = 1;
+ cA[3] = (segment_index == 2) ? -teta : teta;
+ cB[3] = det;
+ c_event.lower_x(to_fpt(0.5) * to_fpt(sqrt_expr_.eval4(cA, cB)) *
+ inv_denom_sqr / get_sqrt(to_fpt(segm_len)));
+ }
+ }
+
+ // Recompute parameters of the circle event using high-precision library.
+ void pss(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ int point_index,
+ circle_type &c_event,
+ bool recompute_c_x = true,
+ bool recompute_c_y = true,
+ bool recompute_lower_x = true) {
+ big_int_type a[2], b[2], c[2], cA[4], cB[4];
+ const point_type &segm_start1 = site2.point1(true);
+ const point_type &segm_end1 = site2.point0(true);
+ const point_type &segm_start2 = site3.point0(true);
+ const point_type &segm_end2 = site3.point1(true);
+ a[0] = static_cast<int_x2_type>(segm_end1.x()) -
+ static_cast<int_x2_type>(segm_start1.x());
+ b[0] = static_cast<int_x2_type>(segm_end1.y()) -
+ static_cast<int_x2_type>(segm_start1.y());
+ a[1] = static_cast<int_x2_type>(segm_end2.x()) -
+ static_cast<int_x2_type>(segm_start2.x());
+ b[1] = static_cast<int_x2_type>(segm_end2.y()) -
+ static_cast<int_x2_type>(segm_start2.y());
+ big_int_type orientation = a[1] * b[0] - a[0] * b[1];
+ if (is_zero(orientation)) {
+ fpt_type denom = to_fpt(2.0) * to_fpt(
+ static_cast<big_int_type>(a[0] * a[0] + b[0] * b[0]));
+ c[0] = b[0] * (static_cast<int_x2_type>(segm_start2.x()) -
+ static_cast<int_x2_type>(segm_start1.x())) -
+ a[0] * (static_cast<int_x2_type>(segm_start2.y()) -
+ static_cast<int_x2_type>(segm_start1.y()));
+ big_int_type dx = a[0] * (static_cast<int_x2_type>(site1.y()) -
+ static_cast<int_x2_type>(segm_start1.y())) -
+ b[0] * (static_cast<int_x2_type>(site1.x()) -
+ static_cast<int_x2_type>(segm_start1.x()));
+ big_int_type dy = b[0] * (static_cast<int_x2_type>(site1.x()) -
+ static_cast<int_x2_type>(segm_start2.x())) -
+ a[0] * (static_cast<int_x2_type>(site1.y()) -
+ static_cast<int_x2_type>(segm_start2.y()));
+ cB[0] = dx * dy;
+ cB[1] = 1;
+
+ if (recompute_c_y) {
+ cA[0] = b[0] * ((point_index == 2) ? 2 : -2);
+ cA[1] = a[0] * a[0] * (static_cast<int_x2_type>(segm_start1.y()) +
+ static_cast<int_x2_type>(segm_start2.y())) -
+ a[0] * b[0] * (static_cast<int_x2_type>(segm_start1.x()) +
+ static_cast<int_x2_type>(segm_start2.x()) -
+ static_cast<int_x2_type>(site1.x()) * 2) +
+ b[0] * b[0] * (static_cast<int_x2_type>(site1.y()) * 2);
+ fpt_type c_y = to_fpt(sqrt_expr_.eval2(cA, cB));
+ c_event.y(c_y / denom);
+ }
+
+ if (recompute_c_x || recompute_lower_x) {
+ cA[0] = a[0] * ((point_index == 2) ? 2 : -2);
+ cA[1] = b[0] * b[0] * (static_cast<int_x2_type>(segm_start1.x()) +
+ static_cast<int_x2_type>(segm_start2.x())) -
+ a[0] * b[0] * (static_cast<int_x2_type>(segm_start1.y()) +
+ static_cast<int_x2_type>(segm_start2.y()) -
+ static_cast<int_x2_type>(site1.y()) * 2) +
+ a[0] * a[0] * (static_cast<int_x2_type>(site1.x()) * 2);
+
+ if (recompute_c_x) {
+ fpt_type c_x = to_fpt(sqrt_expr_.eval2(cA, cB));
+ c_event.x(c_x / denom);
+ }
+
+ if (recompute_lower_x) {
+ cA[2] = is_neg(c[0]) ? -c[0] : c[0];
+ cB[2] = a[0] * a[0] + b[0] * b[0];
+ fpt_type lower_x = to_fpt(sqrt_expr_.eval3(cA, cB));
+ c_event.lower_x(lower_x / denom);
+ }
+ }
+ return;
+ }
+ c[0] = b[0] * segm_end1.x() - a[0] * segm_end1.y();
+ c[1] = a[1] * segm_end2.y() - b[1] * segm_end2.x();
+ big_int_type ix = a[0] * c[1] + a[1] * c[0];
+ big_int_type iy = b[0] * c[1] + b[1] * c[0];
+ big_int_type dx = ix - orientation * site1.x();
+ big_int_type dy = iy - orientation * site1.y();
+ if (is_zero(dx) && is_zero(dy)) {
+ fpt_type denom = to_fpt(orientation);
+ fpt_type c_x = to_fpt(ix) / denom;
+ fpt_type c_y = to_fpt(iy) / denom;
+ c_event = circle_type(c_x, c_y, c_x);
+ return;
+ }
+
+ big_int_type sign = ((point_index == 2) ? 1 : -1) *
+ (is_neg(orientation) ? 1 : -1);
+ cA[0] = a[1] * -dx + b[1] * -dy;
+ cA[1] = a[0] * -dx + b[0] * -dy;
+ cA[2] = sign;
+ cA[3] = 0;
+ cB[0] = a[0] * a[0] + b[0] * b[0];
+ cB[1] = a[1] * a[1] + b[1] * b[1];
+ cB[2] = a[0] * a[1] + b[0] * b[1];
+ cB[3] = (a[0] * dy - b[0] * dx) * (a[1] * dy - b[1] * dx) * -2;
+ fpt_type temp = to_fpt(
+ sqrt_expr_evaluator_pss4<big_int_type, efpt_type>(cA, cB));
+ fpt_type denom = temp * to_fpt(orientation);
+
+ if (recompute_c_y) {
+ cA[0] = b[1] * (dx * dx + dy * dy) - iy * (dx * a[1] + dy * b[1]);
+ cA[1] = b[0] * (dx * dx + dy * dy) - iy * (dx * a[0] + dy * b[0]);
+ cA[2] = iy * sign;
+ fpt_type cy = to_fpt(
+ sqrt_expr_evaluator_pss4<big_int_type, efpt_type>(cA, cB));
+ c_event.y(cy / denom);
+ }
+
+ if (recompute_c_x || recompute_lower_x) {
+ cA[0] = a[1] * (dx * dx + dy * dy) - ix * (dx * a[1] + dy * b[1]);
+ cA[1] = a[0] * (dx * dx + dy * dy) - ix * (dx * a[0] + dy * b[0]);
+ cA[2] = ix * sign;
+
+ if (recompute_c_x) {
+ fpt_type cx = to_fpt(
+ sqrt_expr_evaluator_pss4<big_int_type, efpt_type>(cA, cB));
+ c_event.x(cx / denom);
+ }
+
+ if (recompute_lower_x) {
+ cA[3] = orientation * (dx * dx + dy * dy) * (is_neg(temp) ? -1 : 1);
+ fpt_type lower_x = to_fpt(
+ sqrt_expr_evaluator_pss4<big_int_type, efpt_type>(cA, cB));
+ c_event.lower_x(lower_x / denom);
+ }
+ }
+ }
+
+ // Recompute parameters of the circle event using high-precision library.
+ void sss(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ circle_type &c_event,
+ bool recompute_c_x = true,
+ bool recompute_c_y = true,
+ bool recompute_lower_x = true) {
+ big_int_type a[3], b[3], c[3], cA[4], cB[4];
+ // cA - corresponds to the cross product.
+ // cB - corresponds to the squared length.
+ a[0] = static_cast<int_x2_type>(site1.x1(true)) -
+ static_cast<int_x2_type>(site1.x0(true));
+ a[1] = static_cast<int_x2_type>(site2.x1(true)) -
+ static_cast<int_x2_type>(site2.x0(true));
+ a[2] = static_cast<int_x2_type>(site3.x1(true)) -
+ static_cast<int_x2_type>(site3.x0(true));
+
+ b[0] = static_cast<int_x2_type>(site1.y1(true)) -
+ static_cast<int_x2_type>(site1.y0(true));
+ b[1] = static_cast<int_x2_type>(site2.y1(true)) -
+ static_cast<int_x2_type>(site2.y0(true));
+ b[2] = static_cast<int_x2_type>(site3.y1(true)) -
+ static_cast<int_x2_type>(site3.y0(true));
+
+ c[0] = static_cast<int_x2_type>(site1.x0(true)) *
+ static_cast<int_x2_type>(site1.y1(true)) -
+ static_cast<int_x2_type>(site1.y0(true)) *
+ static_cast<int_x2_type>(site1.x1(true));
+ c[1] = static_cast<int_x2_type>(site2.x0(true)) *
+ static_cast<int_x2_type>(site2.y1(true)) -
+ static_cast<int_x2_type>(site2.y0(true)) *
+ static_cast<int_x2_type>(site2.x1(true));
+ c[2] = static_cast<int_x2_type>(site3.x0(true)) *
+ static_cast<int_x2_type>(site3.y1(true)) -
+ static_cast<int_x2_type>(site3.y0(true)) *
+ static_cast<int_x2_type>(site3.x1(true));
+
+ for (int i = 0; i < 3; ++i)
+ cB[i] = a[i] * a[i] + b[i] * b[i];
+
+ for (int i = 0; i < 3; ++i) {
+ int j = (i+1) % 3;
+ int k = (i+2) % 3;
+ cA[i] = a[j] * b[k] - a[k] * b[j];
+ }
+ fpt_type denom = to_fpt(sqrt_expr_.eval3(cA, cB));
+
+ if (recompute_c_y) {
+ for (int i = 0; i < 3; ++i) {
+ int j = (i+1) % 3;
+ int k = (i+2) % 3;
+ cA[i] = b[j] * c[k] - b[k] * c[j];
+ }
+ fpt_type c_y = to_fpt(sqrt_expr_.eval3(cA, cB));
+ c_event.y(c_y / denom);
+ }
+
+ if (recompute_c_x || recompute_lower_x) {
+ cA[3] = 0;
+ for (int i = 0; i < 3; ++i) {
+ int j = (i+1) % 3;
+ int k = (i+2) % 3;
+ cA[i] = a[j] * c[k] - a[k] * c[j];
+ if (recompute_lower_x) {
+ cA[3] = cA[3] + cA[i] * b[i];
+ }
+ }
+
+ if (recompute_c_x) {
+ fpt_type c_x = to_fpt(sqrt_expr_.eval3(cA, cB));
+ c_event.x(c_x / denom);
+ }
+
+ if (recompute_lower_x) {
+ cB[3] = 1;
+ fpt_type lower_x = to_fpt(sqrt_expr_.eval4(cA, cB));
+ c_event.lower_x(lower_x / denom);
+ }
+ }
+ }
+
+ private:
+ // Evaluates A[3] + A[0] * sqrt(B[0]) + A[1] * sqrt(B[1]) +
+ // A[2] * sqrt(B[3] * (sqrt(B[0] * B[1]) + B[2])).
+ template <typename _int, typename _fpt>
+ _fpt sqrt_expr_evaluator_pss4(_int *A, _int *B) {
+ _int cA[4], cB[4];
+ if (is_zero(A[3])) {
+ _fpt lh = sqrt_expr_.eval2(A, B);
+ cA[0] = 1;
+ cB[0] = B[0] * B[1];
+ cA[1] = B[2];
+ cB[1] = 1;
+ _fpt rh = sqrt_expr_.eval1(A+2, B+3) *
+ get_sqrt(sqrt_expr_.eval2(cA, cB));
+ if ((!is_neg(lh) && !is_neg(rh)) || (!is_pos(lh) && !is_pos(rh)))
+ return lh + rh;
+ cA[0] = A[0] * A[0] * B[0] + A[1] * A[1] * B[1] -
+ A[2] * A[2] * B[3] * B[2];
+ cB[0] = 1;
+ cA[1] = A[0] * A[1] * 2 - A[2] * A[2] * B[3];
+ cB[1] = B[0] * B[1];
+ _fpt numer = sqrt_expr_.eval2(cA, cB);
+ return numer / (lh - rh);
+ }
+ cA[0] = 1;
+ cB[0] = B[0] * B[1];
+ cA[1] = B[2];
+ cB[1] = 1;
+ _fpt rh = sqrt_expr_.eval1(A+2, B+3) * get_sqrt(sqrt_expr_.eval2(cA, cB));
+ cA[0] = A[0];
+ cB[0] = B[0];
+ cA[1] = A[1];
+ cB[1] = B[1];
+ cA[2] = A[3];
+ cB[2] = 1;
+ _fpt lh = sqrt_expr_.eval3(cA, cB);
+ if ((!is_neg(lh) && !is_neg(rh)) || (!is_pos(lh) && !is_pos(rh)))
+ return lh + rh;
+ cA[0] = A[3] * A[0] * 2;
+ cA[1] = A[3] * A[1] * 2;
+ cA[2] = A[0] * A[0] * B[0] + A[1] * A[1] * B[1] +
+ A[3] * A[3] - A[2] * A[2] * B[2] * B[3];
+ cA[3] = A[0] * A[1] * 2 - A[2] * A[2] * B[3];
+ cB[3] = B[0] * B[1];
+ _fpt numer = sqrt_expr_evaluator_pss3<_int, _fpt>(cA, cB);
+ return numer / (lh - rh);
+ }
+
+ template <typename _int, typename _fpt>
+ // Evaluates A[0] * sqrt(B[0]) + A[1] * sqrt(B[1]) +
+ // A[2] + A[3] * sqrt(B[0] * B[1]).
+ // B[3] = B[0] * B[1].
+ _fpt sqrt_expr_evaluator_pss3(_int *A, _int *B) {
+ _int cA[2], cB[2];
+ _fpt lh = sqrt_expr_.eval2(A, B);
+ _fpt rh = sqrt_expr_.eval2(A+2, B+2);
+ if ((!is_neg(lh) && !is_neg(rh)) || (!is_pos(lh) && !is_pos(rh)))
+ return lh + rh;
+ cA[0] = A[0] * A[0] * B[0] + A[1] * A[1] * B[1] -
+ A[2] * A[2] - A[3] * A[3] * B[0] * B[1];
+ cB[0] = 1;
+ cA[1] = (A[0] * A[1] - A[2] * A[3]) * 2;
+ cB[1] = B[3];
+ _fpt numer = sqrt_expr_.eval2(cA, cB);
+ return numer / (lh - rh);
+ }
+
+ robust_sqrt_expr_type sqrt_expr_;
+ to_fpt_converter to_fpt;
+ };
+
+ template <typename Site, typename Circle>
+ class lazy_circle_formation_functor {
+ public:
+ typedef robust_fpt<fpt_type> robust_fpt_type;
+ typedef robust_dif<robust_fpt_type> robust_dif_type;
+ typedef typename Site::point_type point_type;
+ typedef Site site_type;
+ typedef Circle circle_type;
+ typedef mp_circle_formation_functor<site_type, circle_type>
+ exact_circle_formation_functor_type;
+
+ void ppp(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ circle_type &c_event) {
+ fpt_type dif_x1 = to_fpt(site1.x()) - to_fpt(site2.x());
+ fpt_type dif_x2 = to_fpt(site2.x()) - to_fpt(site3.x());
+ fpt_type dif_y1 = to_fpt(site1.y()) - to_fpt(site2.y());
+ fpt_type dif_y2 = to_fpt(site2.y()) - to_fpt(site3.y());
+ fpt_type orientation = robust_cross_product(
+ static_cast<int_x2_type>(site1.x()) - static_cast<int_x2_type>(site2.x()),
+ static_cast<int_x2_type>(site2.x()) - static_cast<int_x2_type>(site3.x()),
+ static_cast<int_x2_type>(site1.y()) - static_cast<int_x2_type>(site2.y()),
+ static_cast<int_x2_type>(site2.y()) - static_cast<int_x2_type>(site3.y()));
+ robust_fpt_type inv_orientation(to_fpt(0.5) / orientation, to_fpt(2.0));
+ fpt_type sum_x1 = to_fpt(site1.x()) + to_fpt(site2.x());
+ fpt_type sum_x2 = to_fpt(site2.x()) + to_fpt(site3.x());
+ fpt_type sum_y1 = to_fpt(site1.y()) + to_fpt(site2.y());
+ fpt_type sum_y2 = to_fpt(site2.y()) + to_fpt(site3.y());
+ fpt_type dif_x3 = to_fpt(site1.x()) - to_fpt(site3.x());
+ fpt_type dif_y3 = to_fpt(site1.y()) - to_fpt(site3.y());
+ robust_dif_type c_x, c_y;
+ c_x += robust_fpt_type(dif_x1 * sum_x1 * dif_y2, to_fpt(2.0));
+ c_x += robust_fpt_type(dif_y1 * sum_y1 * dif_y2, to_fpt(2.0));
+ c_x -= robust_fpt_type(dif_x2 * sum_x2 * dif_y1, to_fpt(2.0));
+ c_x -= robust_fpt_type(dif_y2 * sum_y2 * dif_y1, to_fpt(2.0));
+ c_y += robust_fpt_type(dif_x2 * sum_x2 * dif_x1, to_fpt(2.0));
+ c_y += robust_fpt_type(dif_y2 * sum_y2 * dif_x1, to_fpt(2.0));
+ c_y -= robust_fpt_type(dif_x1 * sum_x1 * dif_x2, to_fpt(2.0));
+ c_y -= robust_fpt_type(dif_y1 * sum_y1 * dif_x2, to_fpt(2.0));
+ robust_dif_type lower_x(c_x);
+ lower_x -= robust_fpt_type(get_sqrt(
+ (dif_x1 * dif_x1 + dif_y1 * dif_y1) *
+ (dif_x2 * dif_x2 + dif_y2 * dif_y2) *
+ (dif_x3 * dif_x3 + dif_y3 * dif_y3)), to_fpt(5.0));
+ c_event = circle_type(
+ c_x.dif().fpv() * inv_orientation.fpv(),
+ c_y.dif().fpv() * inv_orientation.fpv(),
+ lower_x.dif().fpv() * inv_orientation.fpv());
+ bool recompute_c_x = c_x.dif().ulp() > ULPS;
+ bool recompute_c_y = c_y.dif().ulp() > ULPS;
+ bool recompute_lower_x = lower_x.dif().ulp() > ULPS;
+ if (recompute_c_x || recompute_c_y || recompute_lower_x) {
+ exact_circle_formation_functor_.ppp(
+ site1, site2, site3, c_event,
+ recompute_c_x, recompute_c_y, recompute_lower_x);
+ }
+ }
+
+ void pps(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ int segment_index,
+ circle_type &c_event) {
+ fpt_type line_a = to_fpt(site3.point1(true).y()) -
+ to_fpt(site3.point0(true).y());
+ fpt_type line_b = to_fpt(site3.point0(true).x()) -
+ to_fpt(site3.point1(true).x());
+ fpt_type vec_x = to_fpt(site2.y()) - to_fpt(site1.y());
+ fpt_type vec_y = to_fpt(site1.x()) - to_fpt(site2.x());
+ robust_fpt_type teta(robust_cross_product(
+ static_cast<int_x2_type>(site3.point1(true).y()) - static_cast<int_x2_type>(site3.point0(true).y()),
+ static_cast<int_x2_type>(site3.point0(true).x()) - static_cast<int_x2_type>(site3.point1(true).x()),
+ static_cast<int_x2_type>(site2.x()) - static_cast<int_x2_type>(site1.x()),
+ static_cast<int_x2_type>(site2.y()) - static_cast<int_x2_type>(site1.y())), to_fpt(1.0));
+ robust_fpt_type A(robust_cross_product(
+ static_cast<int_x2_type>(site3.point1(true).y()) - static_cast<int_x2_type>(site3.point0(true).y()),
+ static_cast<int_x2_type>(site3.point0(true).x()) - static_cast<int_x2_type>(site3.point1(true).x()),
+ static_cast<int_x2_type>(site3.point1().y()) - static_cast<int_x2_type>(site1.y()),
+ static_cast<int_x2_type>(site1.x()) - static_cast<int_x2_type>(site3.point1().x())), to_fpt(1.0));
+ robust_fpt_type B(robust_cross_product(
+ static_cast<int_x2_type>(site3.point1(true).y()) - static_cast<int_x2_type>(site3.point0(true).y()),
+ static_cast<int_x2_type>(site3.point0(true).x()) - static_cast<int_x2_type>(site3.point1(true).x()),
+ static_cast<int_x2_type>(site3.point1().y()) - static_cast<int_x2_type>(site2.y()),
+ static_cast<int_x2_type>(site2.x()) - static_cast<int_x2_type>(site3.point1().x())), to_fpt(1.0));
+ robust_fpt_type denom(robust_cross_product(
+ static_cast<int_x2_type>(site2.y()) - static_cast<int_x2_type>(site1.y()),
+ static_cast<int_x2_type>(site1.x()) - static_cast<int_x2_type>(site2.x()),
+ static_cast<int_x2_type>(site3.point1(true).y()) - static_cast<int_x2_type>(site3.point0(true).y()),
+ static_cast<int_x2_type>(site3.point0(true).x()) - static_cast<int_x2_type>(site3.point1(true).x())), to_fpt(1.0));
+ robust_fpt_type inv_segm_len(to_fpt(1.0) /
+ get_sqrt(line_a * line_a + line_b * line_b), to_fpt(3.0));
+ robust_dif_type t;
+ if (ot::eval(denom) == ot::COLLINEAR) {
+ t += teta / (robust_fpt_type(to_fpt(8.0)) * A);
+ t -= A / (robust_fpt_type(to_fpt(2.0)) * teta);
+ } else {
+ robust_fpt_type det = ((teta * teta + denom * denom) * A * B).sqrt();
+ if (segment_index == 2) {
+ t -= det / (denom * denom);
+ } else {
+ t += det / (denom * denom);
+ }
+ t += teta * (A + B) / (robust_fpt_type(to_fpt(2.0)) * denom * denom);
+ }
+ robust_dif_type c_x, c_y;
+ c_x += robust_fpt_type(to_fpt(0.5) * (to_fpt(site1.x()) +
+ to_fpt(site2.x())));
+ c_x += robust_fpt_type(vec_x) * t;
+ c_y += robust_fpt_type(to_fpt(0.5) * (to_fpt(site1.y()) +
+ to_fpt(site2.y())));
+ c_y += robust_fpt_type(vec_y) * t;
+ robust_dif_type r, lower_x(c_x);
+ r -= robust_fpt_type(line_a) * robust_fpt_type(site3.x0());
+ r -= robust_fpt_type(line_b) * robust_fpt_type(site3.y0());
+ r += robust_fpt_type(line_a) * c_x;
+ r += robust_fpt_type(line_b) * c_y;
+ if (r.pos().fpv() < r.neg().fpv())
+ r = -r;
+ lower_x += r * inv_segm_len;
+ c_event = circle_type(
+ c_x.dif().fpv(), c_y.dif().fpv(), lower_x.dif().fpv());
+ bool recompute_c_x = c_x.dif().ulp() > ULPS;
+ bool recompute_c_y = c_y.dif().ulp() > ULPS;
+ bool recompute_lower_x = lower_x.dif().ulp() > ULPS;
+ if (recompute_c_x || recompute_c_y || recompute_lower_x) {
+ exact_circle_formation_functor_.pps(
+ site1, site2, site3, segment_index, c_event,
+ recompute_c_x, recompute_c_y, recompute_lower_x);
+ }
+ }
+
+ void pss(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ int point_index,
+ circle_type &c_event) {
+ const point_type &segm_start1 = site2.point1(true);
+ const point_type &segm_end1 = site2.point0(true);
+ const point_type &segm_start2 = site3.point0(true);
+ const point_type &segm_end2 = site3.point1(true);
+ fpt_type a1 = to_fpt(segm_end1.x()) - to_fpt(segm_start1.x());
+ fpt_type b1 = to_fpt(segm_end1.y()) - to_fpt(segm_start1.y());
+ fpt_type a2 = to_fpt(segm_end2.x()) - to_fpt(segm_start2.x());
+ fpt_type b2 = to_fpt(segm_end2.y()) - to_fpt(segm_start2.y());
+ bool recompute_c_x, recompute_c_y, recompute_lower_x;
+ robust_fpt_type orientation(robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_end2.y()) - static_cast<int_x2_type>(segm_start2.y()),
+ static_cast<int_x2_type>(segm_end2.x()) - static_cast<int_x2_type>(segm_start2.x())), to_fpt(1.0));
+ if (ot::eval(orientation) == ot::COLLINEAR) {
+ robust_fpt_type a(a1 * a1 + b1 * b1, to_fpt(2.0));
+ robust_fpt_type c(robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_start2.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_start2.x()) - static_cast<int_x2_type>(segm_start1.x())), to_fpt(1.0));
+ robust_fpt_type det(
+ robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(site1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(site1.y()) - static_cast<int_x2_type>(segm_start1.y())) *
+ robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(site1.y()) - static_cast<int_x2_type>(segm_start2.y()),
+ static_cast<int_x2_type>(site1.x()) - static_cast<int_x2_type>(segm_start2.x())),
+ to_fpt(3.0));
+ robust_dif_type t;
+ t -= robust_fpt_type(a1) * robust_fpt_type((
+ to_fpt(segm_start1.x()) + to_fpt(segm_start2.x())) * to_fpt(0.5) -
+ to_fpt(site1.x()));
+ t -= robust_fpt_type(b1) * robust_fpt_type((
+ to_fpt(segm_start1.y()) + to_fpt(segm_start2.y())) * to_fpt(0.5) -
+ to_fpt(site1.y()));
+ if (point_index == 2) {
+ t += det.sqrt();
+ } else {
+ t -= det.sqrt();
+ }
+ t /= a;
+ robust_dif_type c_x, c_y;
+ c_x += robust_fpt_type(to_fpt(0.5) * (
+ to_fpt(segm_start1.x()) + to_fpt(segm_start2.x())));
+ c_x += robust_fpt_type(a1) * t;
+ c_y += robust_fpt_type(to_fpt(0.5) * (
+ to_fpt(segm_start1.y()) + to_fpt(segm_start2.y())));
+ c_y += robust_fpt_type(b1) * t;
+ robust_dif_type lower_x(c_x);
+ if (is_neg(c)) {
+ lower_x -= robust_fpt_type(to_fpt(0.5)) * c / a.sqrt();
+ } else {
+ lower_x += robust_fpt_type(to_fpt(0.5)) * c / a.sqrt();
+ }
+ recompute_c_x = c_x.dif().ulp() > ULPS;
+ recompute_c_y = c_y.dif().ulp() > ULPS;
+ recompute_lower_x = lower_x.dif().ulp() > ULPS;
+ c_event =
+ circle_type(c_x.dif().fpv(), c_y.dif().fpv(), lower_x.dif().fpv());
+ } else {
+ robust_fpt_type sqr_sum1(get_sqrt(a1 * a1 + b1 * b1), to_fpt(2.0));
+ robust_fpt_type sqr_sum2(get_sqrt(a2 * a2 + b2 * b2), to_fpt(2.0));
+ robust_fpt_type a(robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_start2.y()) - static_cast<int_x2_type>(segm_end2.y()),
+ static_cast<int_x2_type>(segm_end2.x()) - static_cast<int_x2_type>(segm_start2.x())), to_fpt(1.0));
+ if (!is_neg(a)) {
+ a += sqr_sum1 * sqr_sum2;
+ } else {
+ a = (orientation * orientation) / (sqr_sum1 * sqr_sum2 - a);
+ }
+ robust_fpt_type or1(robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(site1.y()),
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(site1.x())), to_fpt(1.0));
+ robust_fpt_type or2(robust_cross_product(
+ static_cast<int_x2_type>(segm_end2.x()) - static_cast<int_x2_type>(segm_start2.x()),
+ static_cast<int_x2_type>(segm_end2.y()) - static_cast<int_x2_type>(segm_start2.y()),
+ static_cast<int_x2_type>(segm_end2.x()) - static_cast<int_x2_type>(site1.x()),
+ static_cast<int_x2_type>(segm_end2.y()) - static_cast<int_x2_type>(site1.y())), to_fpt(1.0));
+ robust_fpt_type det = robust_fpt_type(to_fpt(2.0)) * a * or1 * or2;
+ robust_fpt_type c1(robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_end1.y()),
+ static_cast<int_x2_type>(segm_end1.x())), to_fpt(1.0));
+ robust_fpt_type c2(robust_cross_product(
+ static_cast<int_x2_type>(segm_end2.x()) - static_cast<int_x2_type>(segm_start2.x()),
+ static_cast<int_x2_type>(segm_end2.y()) - static_cast<int_x2_type>(segm_start2.y()),
+ static_cast<int_x2_type>(segm_end2.x()),
+ static_cast<int_x2_type>(segm_end2.y())), to_fpt(1.0));
+ robust_fpt_type inv_orientation = robust_fpt_type(to_fpt(1.0)) / orientation;
+ robust_dif_type t, b, ix, iy;
+ ix += robust_fpt_type(a2) * c1 * inv_orientation;
+ ix += robust_fpt_type(a1) * c2 * inv_orientation;
+ iy += robust_fpt_type(b1) * c2 * inv_orientation;
+ iy += robust_fpt_type(b2) * c1 * inv_orientation;
+
+ b += ix * (robust_fpt_type(a1) * sqr_sum2);
+ b += ix * (robust_fpt_type(a2) * sqr_sum1);
+ b += iy * (robust_fpt_type(b1) * sqr_sum2);
+ b += iy * (robust_fpt_type(b2) * sqr_sum1);
+ b -= sqr_sum1 * robust_fpt_type(robust_cross_product(
+ static_cast<int_x2_type>(segm_end2.x()) - static_cast<int_x2_type>(segm_start2.x()),
+ static_cast<int_x2_type>(segm_end2.y()) - static_cast<int_x2_type>(segm_start2.y()),
+ static_cast<int_x2_type>(-site1.y()),
+ static_cast<int_x2_type>(site1.x())), to_fpt(1.0));
+ b -= sqr_sum2 * robust_fpt_type(robust_cross_product(
+ static_cast<int_x2_type>(segm_end1.x()) - static_cast<int_x2_type>(segm_start1.x()),
+ static_cast<int_x2_type>(segm_end1.y()) - static_cast<int_x2_type>(segm_start1.y()),
+ static_cast<int_x2_type>(-site1.y()),
+ static_cast<int_x2_type>(site1.x())), to_fpt(1.0));
+ t -= b;
+ if (point_index == 2) {
+ t += det.sqrt();
+ } else {
+ t -= det.sqrt();
+ }
+ t /= (a * a);
+ robust_dif_type c_x(ix), c_y(iy);
+ c_x += t * (robust_fpt_type(a1) * sqr_sum2);
+ c_x += t * (robust_fpt_type(a2) * sqr_sum1);
+ c_y += t * (robust_fpt_type(b1) * sqr_sum2);
+ c_y += t * (robust_fpt_type(b2) * sqr_sum1);
+ if (t.pos().fpv() < t.neg().fpv()) {
+ t = -t;
+ }
+ robust_dif_type lower_x(c_x);
+ if (is_neg(orientation)) {
+ lower_x -= t * orientation;
+ } else {
+ lower_x += t * orientation;
+ }
+ recompute_c_x = c_x.dif().ulp() > ULPS;
+ recompute_c_y = c_y.dif().ulp() > ULPS;
+ recompute_lower_x = lower_x.dif().ulp() > ULPS;
+ c_event = circle_type(
+ c_x.dif().fpv(), c_y.dif().fpv(), lower_x.dif().fpv());
+ }
+ if (recompute_c_x || recompute_c_y || recompute_lower_x) {
+ exact_circle_formation_functor_.pss(
+ site1, site2, site3, point_index, c_event,
+ recompute_c_x, recompute_c_y, recompute_lower_x);
+ }
+ }
+
+ void sss(const site_type &site1,
+ const site_type &site2,
+ const site_type &site3,
+ circle_type &c_event) {
+ robust_fpt_type a1(to_fpt(site1.x1(true)) - to_fpt(site1.x0(true)));
+ robust_fpt_type b1(to_fpt(site1.y1(true)) - to_fpt(site1.y0(true)));
+ robust_fpt_type c1(robust_cross_product(
+ site1.x0(true), site1.y0(true),
+ site1.x1(true), site1.y1(true)), to_fpt(1.0));
+
+ robust_fpt_type a2(to_fpt(site2.x1(true)) - to_fpt(site2.x0(true)));
+ robust_fpt_type b2(to_fpt(site2.y1(true)) - to_fpt(site2.y0(true)));
+ robust_fpt_type c2(robust_cross_product(
+ site2.x0(true), site2.y0(true),
+ site2.x1(true), site2.y1(true)), to_fpt(1.0));
+
+ robust_fpt_type a3(to_fpt(site3.x1(true)) - to_fpt(site3.x0(true)));
+ robust_fpt_type b3(to_fpt(site3.y1(true)) - to_fpt(site3.y0(true)));
+ robust_fpt_type c3(robust_cross_product(
+ site3.x0(true), site3.y0(true),
+ site3.x1(true), site3.y1(true)), to_fpt(1.0));
+
+ robust_fpt_type len1 = (a1 * a1 + b1 * b1).sqrt();
+ robust_fpt_type len2 = (a2 * a2 + b2 * b2).sqrt();
+ robust_fpt_type len3 = (a3 * a3 + b3 * b3).sqrt();
+ robust_fpt_type cross_12(robust_cross_product(
+ static_cast<int_x2_type>(site1.x1(true)) - static_cast<int_x2_type>(site1.x0(true)),
+ static_cast<int_x2_type>(site1.y1(true)) - static_cast<int_x2_type>(site1.y0(true)),
+ static_cast<int_x2_type>(site2.x1(true)) - static_cast<int_x2_type>(site2.x0(true)),
+ static_cast<int_x2_type>(site2.y1(true)) - static_cast<int_x2_type>(site2.y0(true))), to_fpt(1.0));
+ robust_fpt_type cross_23(robust_cross_product(
+ static_cast<int_x2_type>(site2.x1(true)) - static_cast<int_x2_type>(site2.x0(true)),
+ static_cast<int_x2_type>(site2.y1(true)) - static_cast<int_x2_type>(site2.y0(true)),
+ static_cast<int_x2_type>(site3.x1(true)) - static_cast<int_x2_type>(site3.x0(true)),
+ static_cast<int_x2_type>(site3.y1(true)) - static_cast<int_x2_type>(site3.y0(true))), to_fpt(1.0));
+ robust_fpt_type cross_31(robust_cross_product(
+ static_cast<int_x2_type>(site3.x1(true)) - static_cast<int_x2_type>(site3.x0(true)),
+ static_cast<int_x2_type>(site3.y1(true)) - static_cast<int_x2_type>(site3.y0(true)),
+ static_cast<int_x2_type>(site1.x1(true)) - static_cast<int_x2_type>(site1.x0(true)),
+ static_cast<int_x2_type>(site1.y1(true)) - static_cast<int_x2_type>(site1.y0(true))), to_fpt(1.0));
+ robust_dif_type denom, c_x, c_y, r;
+
+ // denom = cross_12 * len3 + cross_23 * len1 + cross_31 * len2.
+ denom += cross_12 * len3;
+ denom += cross_23 * len1;
+ denom += cross_31 * len2;
+
+ // denom * r = (b2 * c_x - a2 * c_y - c2 * denom) / len2.
+ r -= cross_12 * c3;
+ r -= cross_23 * c1;
+ r -= cross_31 * c2;
+
+ c_x += a1 * c2 * len3;
+ c_x -= a2 * c1 * len3;
+ c_x += a2 * c3 * len1;
+ c_x -= a3 * c2 * len1;
+ c_x += a3 * c1 * len2;
+ c_x -= a1 * c3 * len2;
+ c_y += b1 * c2 * len3;
+ c_y -= b2 * c1 * len3;
+ c_y += b2 * c3 * len1;
+ c_y -= b3 * c2 * len1;
+ c_y += b3 * c1 * len2;
+ c_y -= b1 * c3 * len2;
+ robust_dif_type lower_x(c_x + r);
+ bool recompute_c_x = c_x.dif().ulp() > ULPS;
+ bool recompute_c_y = c_y.dif().ulp() > ULPS;
+ bool recompute_lower_x = lower_x.dif().ulp() > ULPS;
+ bool recompute_denom = denom.dif().ulp() > ULPS;
+ c_event = circle_type(
+ c_x.dif().fpv() / denom.dif().fpv(),
+ c_y.dif().fpv() / denom.dif().fpv(),
+ lower_x.dif().fpv() / denom.dif().fpv());
+ if (recompute_c_x || recompute_c_y ||
+ recompute_lower_x || recompute_denom) {
+ exact_circle_formation_functor_.sss(
+ site1, site2, site3, c_event,
+ recompute_c_x, recompute_c_y, recompute_lower_x);
+ }
+ }
+
+ private:
+ exact_circle_formation_functor_type exact_circle_formation_functor_;
+ to_fpt_converter to_fpt;
+ };
+
+ template <typename Site,
+ typename Circle,
+ typename CEP = circle_existence_predicate<Site>,
+ typename CFF = lazy_circle_formation_functor<Site, Circle> >
+ class circle_formation_predicate {
+ public:
+ typedef Site site_type;
+ typedef Circle circle_type;
+ typedef CEP circle_existence_predicate_type;
+ typedef CFF circle_formation_functor_type;
+
+ // Create a circle event from the given three sites.
+ // Returns true if the circle event exists, else false.
+ // If exists circle event is saved into the c_event variable.
+ bool operator()(const site_type &site1, const site_type &site2,
+ const site_type &site3, circle_type &circle) {
+ if (!site1.is_segment()) {
+ if (!site2.is_segment()) {
+ if (!site3.is_segment()) {
+ // (point, point, point) sites.
+ if (!circle_existence_predicate_.ppp(site1, site2, site3))
+ return false;
+ circle_formation_functor_.ppp(site1, site2, site3, circle);
+ } else {
+ // (point, point, segment) sites.
+ if (!circle_existence_predicate_.pps(site1, site2, site3, 3))
+ return false;
+ circle_formation_functor_.pps(site1, site2, site3, 3, circle);
+ }
+ } else {
+ if (!site3.is_segment()) {
+ // (point, segment, point) sites.
+ if (!circle_existence_predicate_.pps(site1, site3, site2, 2))
+ return false;
+ circle_formation_functor_.pps(site1, site3, site2, 2, circle);
+ } else {
+ // (point, segment, segment) sites.
+ if (!circle_existence_predicate_.pss(site1, site2, site3, 1))
+ return false;
+ circle_formation_functor_.pss(site1, site2, site3, 1, circle);
+ }
+ }
+ } else {
+ if (!site2.is_segment()) {
+ if (!site3.is_segment()) {
+ // (segment, point, point) sites.
+ if (!circle_existence_predicate_.pps(site2, site3, site1, 1))
+ return false;
+ circle_formation_functor_.pps(site2, site3, site1, 1, circle);
+ } else {
+ // (segment, point, segment) sites.
+ if (!circle_existence_predicate_.pss(site2, site1, site3, 2))
+ return false;
+ circle_formation_functor_.pss(site2, site1, site3, 2, circle);
+ }
+ } else {
+ if (!site3.is_segment()) {
+ // (segment, segment, point) sites.
+ if (!circle_existence_predicate_.pss(site3, site1, site2, 3))
+ return false;
+ circle_formation_functor_.pss(site3, site1, site2, 3, circle);
+ } else {
+ // (segment, segment, segment) sites.
+ if (!circle_existence_predicate_.sss(site1, site2, site3))
+ return false;
+ circle_formation_functor_.sss(site1, site2, site3, circle);
+ }
+ }
+ }
+ return true;
+ }
+
+ private:
+ circle_existence_predicate_type circle_existence_predicate_;
+ circle_formation_functor_type circle_formation_functor_;
+ };
+};
+} // detail
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_DETAIL_VORONOI_PREDICATES
Added: trunk/boost/polygon/detail/voronoi_robust_fpt.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/detail/voronoi_robust_fpt.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,515 @@
+// Boost.Polygon library detail/voronoi_robust_fpt.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_DETAIL_VORONOI_ROBUST_FPT
+#define BOOST_POLYGON_DETAIL_VORONOI_ROBUST_FPT
+
+#include <cmath>
+
+// Geometry predicates with floating-point variables usually require
+// high-precision predicates to retrieve the correct result.
+// Epsilon robust predicates give the result within some epsilon relative
+// error, but are a lot faster than high-precision predicates.
+// To make algorithm robust and efficient epsilon robust predicates are
+// used at the first step. In case of the undefined result high-precision
+// arithmetic is used to produce required robustness. This approach
+// requires exact computation of epsilon intervals within which epsilon
+// robust predicates have undefined value.
+// There are two ways to measure an error of floating-point calculations:
+// relative error and ULPs (units in the last place).
+// Let EPS be machine epsilon, then next inequalities have place:
+// 1 EPS <= 1 ULP <= 2 EPS (1), 0.5 ULP <= 1 EPS <= 1 ULP (2).
+// ULPs are good for measuring rounding errors and comparing values.
+// Relative errors are good for computation of general relative
+// error of formulas or expressions. So to calculate epsilon
+// interval within which epsilon robust predicates have undefined result
+// next schema is used:
+// 1) Compute rounding errors of initial variables using ULPs;
+// 2) Transform ULPs to epsilons using upper bound of the (1);
+// 3) Compute relative error of the formula using epsilon arithmetic;
+// 4) Transform epsilon to ULPs using upper bound of the (2);
+// In case two values are inside undefined ULP range use high-precision
+// arithmetic to produce the correct result, else output the result.
+// Look at almost_equal function to see how two floating-point variables
+// are checked to fit in the ULP range.
+// If A has relative error of r(A) and B has relative error of r(B) then:
+// 1) r(A + B) <= max(r(A), r(B)), for A * B >= 0;
+// 2) r(A - B) <= B*r(A)+A*r(B)/(A-B), for A * B >= 0;
+// 2) r(A * B) <= r(A) + r(B);
+// 3) r(A / B) <= r(A) + r(B);
+// In addition rounding error should be added, that is always equal to
+// 0.5 ULP or at most 1 epsilon. As you might see from the above formulas
+// subtraction relative error may be extremely large, that's why
+// epsilon robust comparator class is used to store floating point values
+// and compute subtraction as the final step of the evaluation.
+// For further information about relative errors and ULPs try this link:
+// http://docs.sun.com/source/806-3568/ncg_goldberg.html
+
+namespace boost {
+namespace polygon {
+namespace detail {
+
+template <typename T>
+T get_sqrt(const T& that) {
+ return (std::sqrt)(that);
+}
+
+template <typename T>
+bool is_pos(const T& that) {
+ return that > 0;
+}
+
+template <typename T>
+bool is_neg(const T& that) {
+ return that < 0;
+}
+
+template <typename T>
+bool is_zero(const T& that) {
+ return that == 0;
+}
+
+template <typename _fpt>
+class robust_fpt {
+public:
+ typedef _fpt floating_point_type;
+ typedef _fpt relative_error_type;
+
+ // Rounding error is at most 1 EPS.
+ static const relative_error_type ROUNDING_ERROR;
+
+ robust_fpt() : fpv_(0.0), re_(0.0) {}
+ robust_fpt(floating_point_type fpv) :
+ fpv_(fpv), re_(0.0) {}
+ robust_fpt(floating_point_type fpv, relative_error_type error) :
+ fpv_(fpv), re_(error) {}
+
+ floating_point_type fpv() const { return fpv_; }
+ relative_error_type re() const { return re_; }
+ relative_error_type ulp() const { return re_; }
+
+ robust_fpt& operator=(const robust_fpt &that) {
+ this->fpv_ = that.fpv_;
+ this->re_ = that.re_;
+ return *this;
+ }
+
+ bool has_pos_value() const {
+ return is_pos(fpv_);
+ }
+
+ bool has_neg_value() const {
+ return is_neg(fpv_);
+ }
+
+ bool has_zero_value() const {
+ return is_zero(fpv_);
+ }
+
+ robust_fpt operator-() const {
+ return robust_fpt(-fpv_, re_);
+ }
+
+ robust_fpt& operator+=(const robust_fpt &that) {
+ floating_point_type fpv = this->fpv_ + that.fpv_;
+ if ((!is_neg(this->fpv_) && !is_neg(that.fpv_)) ||
+ (!is_pos(this->fpv_) && !is_pos(that.fpv_)))
+ this->re_ = (std::max)(this->re_, that.re_) + ROUNDING_ERROR;
+ else {
+ floating_point_type temp =
+ (this->fpv_ * this->re_ - that.fpv_ * that.re_) / fpv;
+ if (is_neg(temp))
+ temp = -temp;
+ this->re_ = temp + ROUNDING_ERROR;
+ }
+ this->fpv_ = fpv;
+ return *this;
+ }
+
+ robust_fpt& operator-=(const robust_fpt &that) {
+ floating_point_type fpv = this->fpv_ - that.fpv_;
+ if ((!is_neg(this->fpv_) && !is_pos(that.fpv_)) ||
+ (!is_pos(this->fpv_) && !is_neg(that.fpv_)))
+ this->re_ = (std::max)(this->re_, that.re_) + ROUNDING_ERROR;
+ else {
+ floating_point_type temp =
+ (this->fpv_ * this->re_ + that.fpv_ * that.re_) / fpv;
+ if (is_neg(temp))
+ temp = -temp;
+ this->re_ = temp + ROUNDING_ERROR;
+ }
+ this->fpv_ = fpv;
+ return *this;
+ }
+
+ robust_fpt& operator*=(const robust_fpt &that) {
+ this->re_ += that.re_ + ROUNDING_ERROR;
+ this->fpv_ *= that.fpv_;
+ return *this;
+ }
+
+ robust_fpt& operator/=(const robust_fpt &that) {
+ this->re_ += that.re_ + ROUNDING_ERROR;
+ this->fpv_ /= that.fpv_;
+ return *this;
+ }
+
+ robust_fpt operator+(const robust_fpt &that) const {
+ floating_point_type fpv = this->fpv_ + that.fpv_;
+ relative_error_type re;
+ if ((!is_neg(this->fpv_) && !is_neg(that.fpv_)) ||
+ (!is_pos(this->fpv_) && !is_pos(that.fpv_)))
+ re = (std::max)(this->re_, that.re_) + ROUNDING_ERROR;
+ else {
+ floating_point_type temp =
+ (this->fpv_ * this->re_ - that.fpv_ * that.re_) / fpv;
+ if (is_neg(temp))
+ temp = -temp;
+ re = temp + ROUNDING_ERROR;
+ }
+ return robust_fpt(fpv, re);
+ }
+
+ robust_fpt operator-(const robust_fpt &that) const {
+ floating_point_type fpv = this->fpv_ - that.fpv_;
+ relative_error_type re;
+ if ((!is_neg(this->fpv_) && !is_pos(that.fpv_)) ||
+ (!is_pos(this->fpv_) && !is_neg(that.fpv_)))
+ re = (std::max)(this->re_, that.re_) + ROUNDING_ERROR;
+ else {
+ floating_point_type temp =
+ (this->fpv_ * this->re_ + that.fpv_ * that.re_) / fpv;
+ if (is_neg(temp))
+ temp = -temp;
+ re = temp + ROUNDING_ERROR;
+ }
+ return robust_fpt(fpv, re);
+ }
+
+ robust_fpt operator*(const robust_fpt &that) const {
+ floating_point_type fpv = this->fpv_ * that.fpv_;
+ relative_error_type re = this->re_ + that.re_ + ROUNDING_ERROR;
+ return robust_fpt(fpv, re);
+ }
+
+ robust_fpt operator/(const robust_fpt &that) const {
+ floating_point_type fpv = this->fpv_ / that.fpv_;
+ relative_error_type re = this->re_ + that.re_ + ROUNDING_ERROR;
+ return robust_fpt(fpv, re);
+ }
+
+ robust_fpt sqrt() const {
+ return robust_fpt(get_sqrt(fpv_),
+ re_ * static_cast<relative_error_type>(0.5) +
+ ROUNDING_ERROR);
+ }
+
+private:
+ floating_point_type fpv_;
+ relative_error_type re_;
+};
+
+template <typename T>
+const typename robust_fpt<T>::relative_error_type
+ robust_fpt<T>::ROUNDING_ERROR = 1;
+
+template <typename T>
+robust_fpt<T> get_sqrt(const robust_fpt<T>& that) {
+ return that.sqrt();
+}
+
+template <typename T>
+bool is_pos(const robust_fpt<T>& that) {
+ return that.has_pos_value();
+}
+
+template <typename T>
+bool is_neg(const robust_fpt<T>& that) {
+ return that.has_neg_value();
+}
+
+template <typename T>
+bool is_zero(const robust_fpt<T>& that) {
+ return that.has_zero_value();
+}
+
+// robust_dif consists of two not negative values: value1 and value2.
+// The resulting expression is equal to the value1 - value2.
+// Subtraction of a positive value is equivalent to the addition to value2
+// and subtraction of a negative value is equivalent to the addition to
+// value1. The structure implicitly avoids difference computation.
+template <typename T>
+class robust_dif {
+public:
+ robust_dif() :
+ positive_sum_(0),
+ negative_sum_(0) {}
+
+ robust_dif(const T &value) :
+ positive_sum_((value>0)?value:0),
+ negative_sum_((value<0)?-value:0) {}
+
+ robust_dif(const T &pos, const T &neg) :
+ positive_sum_(pos),
+ negative_sum_(neg) {}
+
+ T dif() const {
+ return positive_sum_ - negative_sum_;
+ }
+
+ T pos() const {
+ return positive_sum_;
+ }
+
+ T neg() const {
+ return negative_sum_;
+ }
+
+ robust_dif<T> operator-() const {
+ return robust_dif(negative_sum_, positive_sum_);
+ }
+
+ robust_dif<T> &operator+=(const T &val) {
+ if (!is_neg(val))
+ positive_sum_ += val;
+ else
+ negative_sum_ -= val;
+ return *this;
+ }
+
+ robust_dif<T> &operator+=(const robust_dif<T> &that) {
+ positive_sum_ += that.positive_sum_;
+ negative_sum_ += that.negative_sum_;
+ return *this;
+ }
+
+ robust_dif<T> &operator-=(const T &val) {
+ if (!is_neg(val))
+ negative_sum_ += val;
+ else
+ positive_sum_ -= val;
+ return *this;
+ }
+
+ robust_dif<T> &operator-=(const robust_dif<T> &that) {
+ positive_sum_ += that.negative_sum_;
+ negative_sum_ += that.positive_sum_;
+ return *this;
+ }
+
+ robust_dif<T> &operator*=(const T &val) {
+ if (!is_neg(val)) {
+ positive_sum_ *= val;
+ negative_sum_ *= val;
+ } else {
+ positive_sum_ *= -val;
+ negative_sum_ *= -val;
+ swap();
+ }
+ return *this;
+ }
+
+ robust_dif<T> &operator*=(const robust_dif<T> &that) {
+ T positive_sum = this->positive_sum_ * that.positive_sum_ +
+ this->negative_sum_ * that.negative_sum_;
+ T negative_sum = this->positive_sum_ * that.negative_sum_ +
+ this->negative_sum_ * that.positive_sum_;
+ positive_sum_ = positive_sum;
+ negative_sum_ = negative_sum;
+ return *this;
+ }
+
+ robust_dif<T> &operator/=(const T &val) {
+ if (!is_neg(val)) {
+ positive_sum_ /= val;
+ negative_sum_ /= val;
+ } else {
+ positive_sum_ /= -val;
+ negative_sum_ /= -val;
+ swap();
+ }
+ return *this;
+ }
+
+private:
+ void swap() {
+ (std::swap)(positive_sum_, negative_sum_);
+ }
+
+ T positive_sum_;
+ T negative_sum_;
+};
+
+template<typename T>
+robust_dif<T> operator+(const robust_dif<T>& lhs,
+ const robust_dif<T>& rhs) {
+ return robust_dif<T>(lhs.pos() + rhs.pos(), lhs.neg() + rhs.neg());
+}
+
+template<typename T>
+robust_dif<T> operator+(const robust_dif<T>& lhs, const T& rhs) {
+ if (!is_neg(rhs)) {
+ return robust_dif<T>(lhs.pos() + rhs, lhs.neg());
+ } else {
+ return robust_dif<T>(lhs.pos(), lhs.neg() - rhs);
+ }
+}
+
+template<typename T>
+robust_dif<T> operator+(const T& lhs, const robust_dif<T>& rhs) {
+ if (!is_neg(lhs)) {
+ return robust_dif<T>(lhs + rhs.pos(), rhs.neg());
+ } else {
+ return robust_dif<T>(rhs.pos(), rhs.neg() - lhs);
+ }
+}
+
+template<typename T>
+robust_dif<T> operator-(const robust_dif<T>& lhs,
+ const robust_dif<T>& rhs) {
+ return robust_dif<T>(lhs.pos() + rhs.neg(), lhs.neg() + rhs.pos());
+}
+
+template<typename T>
+robust_dif<T> operator-(const robust_dif<T>& lhs, const T& rhs) {
+ if (!is_neg(rhs)) {
+ return robust_dif<T>(lhs.pos(), lhs.neg() + rhs);
+ } else {
+ return robust_dif<T>(lhs.pos() - rhs, lhs.neg());
+ }
+}
+
+template<typename T>
+robust_dif<T> operator-(const T& lhs, const robust_dif<T>& rhs) {
+ if (!is_neg(lhs)) {
+ return robust_dif<T>(lhs + rhs.neg(), rhs.pos());
+ } else {
+ return robust_dif<T>(rhs.neg(), rhs.pos() - lhs);
+ }
+}
+
+template<typename T>
+robust_dif<T> operator*(const robust_dif<T>& lhs,
+ const robust_dif<T>& rhs) {
+ T res_pos = lhs.pos() * rhs.pos() + lhs.neg() * rhs.neg();
+ T res_neg = lhs.pos() * rhs.neg() + lhs.neg() * rhs.pos();
+ return robust_dif<T>(res_pos, res_neg);
+}
+
+template<typename T>
+robust_dif<T> operator*(const robust_dif<T>& lhs, const T& val) {
+ if (!is_neg(val)) {
+ return robust_dif<T>(lhs.pos() * val, lhs.neg() * val);
+ } else {
+ return robust_dif<T>(-lhs.neg() * val, -lhs.pos() * val);
+ }
+}
+
+template<typename T>
+robust_dif<T> operator*(const T& val, const robust_dif<T>& rhs) {
+ if (!is_neg(val)) {
+ return robust_dif<T>(val * rhs.pos(), val * rhs.neg());
+ } else {
+ return robust_dif<T>(-val * rhs.neg(), -val * rhs.pos());
+ }
+}
+
+template<typename T>
+robust_dif<T> operator/(const robust_dif<T>& lhs, const T& val) {
+ if (!is_neg(val)) {
+ return robust_dif<T>(lhs.pos() / val, lhs.neg() / val);
+ } else {
+ return robust_dif<T>(-lhs.neg() / val, -lhs.pos() / val);
+ }
+}
+
+// Used to compute expressions that operate with sqrts with predefined
+// relative error. Evaluates expressions of the next type:
+// sum(i = 1 .. n)(A[i] * sqrt(B[i])), 1 <= n <= 4.
+template <typename _int, typename _fpt, typename _converter>
+class robust_sqrt_expr {
+public:
+ static const unsigned int EVAL1_MAX_RELATIVE_ERROR;
+ static const unsigned int EVAL2_MAX_RELATIVE_ERROR;
+ static const unsigned int EVAL3_MAX_RELATIVE_ERROR;
+ static const unsigned int EVAL4_MAX_RELATIVE_ERROR;
+
+ // Evaluates expression (re = 4 EPS):
+ // A[0] * sqrt(B[0]).
+ _fpt eval1(_int *A, _int *B) {
+ _fpt a = convert(A[0]);
+ _fpt b = convert(B[0]);
+ return a * get_sqrt(b);
+ }
+
+ // Evaluates expression (re = 7 EPS):
+ // A[0] * sqrt(B[0]) + A[1] * sqrt(B[1]).
+ _fpt eval2(_int *A, _int *B) {
+ _fpt a = eval1(A, B);
+ _fpt b = eval1(A + 1, B + 1);
+ if ((!is_neg(a) && !is_neg(b)) ||
+ (!is_pos(a) && !is_pos(b)))
+ return a + b;
+ return convert(A[0] * A[0] * B[0] - A[1] * A[1] * B[1]) / (a - b);
+ }
+
+ // Evaluates expression (re = 16 EPS):
+ // A[0] * sqrt(B[0]) + A[1] * sqrt(B[1]) + A[2] * sqrt(B[2]).
+ _fpt eval3(_int *A, _int *B) {
+ _fpt a = eval2(A, B);
+ _fpt b = eval1(A + 2, B + 2);
+ if ((!is_neg(a) && !is_neg(b)) ||
+ (!is_pos(a) && !is_pos(b)))
+ return a + b;
+ tA[3] = A[0] * A[0] * B[0] + A[1] * A[1] * B[1] - A[2] * A[2] * B[2];
+ tB[3] = 1;
+ tA[4] = A[0] * A[1] * 2;
+ tB[4] = B[0] * B[1];
+ return eval2(tA + 3, tB + 3) / (a - b);
+ }
+
+
+ // Evaluates expression (re = 25 EPS):
+ // A[0] * sqrt(B[0]) + A[1] * sqrt(B[1]) +
+ // A[2] * sqrt(B[2]) + A[3] * sqrt(B[3]).
+ _fpt eval4(_int *A, _int *B) {
+ _fpt a = eval2(A, B);
+ _fpt b = eval2(A + 2, B + 2);
+ if ((!is_neg(a) && !is_neg(b)) ||
+ (!is_pos(a) && !is_pos(b)))
+ return a + b;
+ tA[0] = A[0] * A[0] * B[0] + A[1] * A[1] * B[1] -
+ A[2] * A[2] * B[2] - A[3] * A[3] * B[3];
+ tB[0] = 1;
+ tA[1] = A[0] * A[1] * 2;
+ tB[1] = B[0] * B[1];
+ tA[2] = A[2] * A[3] * -2;
+ tB[2] = B[2] * B[3];
+ return eval3(tA, tB) / (a - b);
+ }
+
+private:
+ _int tA[5];
+ _int tB[5];
+ _converter convert;
+};
+
+template <typename _int, typename _fpt, typename _converter>
+const unsigned int robust_sqrt_expr<_int, _fpt, _converter>::EVAL1_MAX_RELATIVE_ERROR = 4;
+template <typename _int, typename _fpt, typename _converter>
+const unsigned int robust_sqrt_expr<_int, _fpt, _converter>::EVAL2_MAX_RELATIVE_ERROR = 7;
+template <typename _int, typename _fpt, typename _converter>
+const unsigned int robust_sqrt_expr<_int, _fpt, _converter>::EVAL3_MAX_RELATIVE_ERROR = 16;
+template <typename _int, typename _fpt, typename _converter>
+const unsigned int robust_sqrt_expr<_int, _fpt, _converter>::EVAL4_MAX_RELATIVE_ERROR = 25;
+} // detail
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_DETAIL_VORONOI_ROBUST_FPT
Added: trunk/boost/polygon/detail/voronoi_structures.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/detail/voronoi_structures.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,451 @@
+// Boost.Polygon library detail/voronoi_structures.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_DETAIL_VORONOI_STRUCTURES
+#define BOOST_POLYGON_DETAIL_VORONOI_STRUCTURES
+
+#include <list>
+#include <queue>
+#include <vector>
+
+namespace boost {
+namespace polygon {
+namespace detail {
+
+// Cartesian 2D point data structure.
+template <typename T>
+class point_2d {
+public:
+ typedef T coordinate_type;
+
+ point_2d() {}
+
+ point_2d(coordinate_type x, coordinate_type y) :
+ x_(x),
+ y_(y) {}
+
+ bool operator==(const point_2d &that) const {
+ return (this->x_ == that.x()) && (this->y_ == that.y());
+ }
+
+ bool operator!=(const point_2d &that) const {
+ return (this->x_ != that.x()) || (this->y_ != that.y());
+ }
+
+ coordinate_type x() const {
+ return x_;
+ }
+
+ coordinate_type y() const {
+ return y_;
+ }
+
+ point_2d& x(coordinate_type x) {
+ x_ = x;
+ return *this;
+ }
+
+ point_2d& y(coordinate_type y) {
+ y_ = y;
+ return *this;
+ }
+
+private:
+ coordinate_type x_;
+ coordinate_type y_;
+};
+
+// Site event type.
+// Occurs when the sweepline sweeps over one of the initial sites:
+// 1) point site;
+// 2) start-point of the segment site;
+// 3) endpoint of the segment site.
+// Implicit segment direction is defined: the start-point of
+// the segment compares less than its endpoint.
+// Each input segment is divided onto two site events:
+// 1) One going from the start-point to the endpoint
+// (is_inverse_ = false);
+// 2) Another going from the endpoint to the start-point
+// (is_inverse_ = true).
+// In beach line data structure segment sites of the first
+// type precede sites of the second type for the same segment.
+// Variables:
+// point0_ - point site or segment's start-point;
+// point1_ - segment's endpoint if site is a segment;
+// index_ - the last bit encodes if the site is inverse;
+// the last-1 bit encodes initial site direction;
+// other bits encode site event index among the other site events.
+// Note: for all the sites is_inverse_ flag is equal to false by default.
+template <typename T>
+class site_event {
+public:
+ typedef T coordinate_type;
+ typedef point_2d<T> point_type;
+
+ site_event() :
+ point0_(0, 0),
+ point1_(0, 0),
+ site_index_(0) {}
+
+ site_event(coordinate_type x, coordinate_type y) :
+ point0_(x, y),
+ point1_(x, y),
+ site_index_(0) {}
+
+ site_event(const point_type &point) :
+ point0_(point),
+ point1_(point),
+ site_index_(0) {}
+
+ site_event(coordinate_type x1, coordinate_type y1,
+ coordinate_type x2, coordinate_type y2):
+ point0_(x1, y1),
+ point1_(x2, y2),
+ site_index_(0) {}
+
+ site_event(const point_type &point1, const point_type &point2) :
+ point0_(point1),
+ point1_(point2),
+ site_index_(0) {}
+
+ bool operator==(const site_event &that) const {
+ return (this->point0_ == that.point0_) &&
+ (this->point1_ == that.point1_) &&
+ (this->site_index_ == that.site_index_);
+ }
+
+ bool operator!=(const site_event &that) const {
+ return (this->point0_ != that.point0_) ||
+ (this->point1_ != that.point1_) ||
+ (this->site_index_ != that.site_index_);
+ }
+
+ coordinate_type x(bool oriented = false) const {
+ return x0(oriented);
+ }
+
+ coordinate_type y(bool oriented = false) const {
+ return y0(oriented);
+ }
+
+ coordinate_type x0(bool oriented = false) const {
+ if (!oriented)
+ return point0_.x();
+ return is_inverse() ? point1_.x() : point0_.x();
+ }
+
+ coordinate_type y0(bool oriented = false) const {
+ if (!oriented)
+ return point0_.y();
+ return is_inverse() ? point1_.y() : point0_.y();
+ }
+
+ coordinate_type x1(bool oriented = false) const {
+ if (!oriented)
+ return point1_.x();
+ return is_inverse() ? point0_.x() : point1_.x();
+ }
+
+ coordinate_type y1(bool oriented = false) const {
+ if (!oriented)
+ return point1_.y();
+ return is_inverse() ? point0_.y() : point1_.y();
+ }
+
+ const point_type &point0(bool oriented = false) const {
+ if (!oriented)
+ return point0_;
+ return is_inverse() ? point1_ : point0_;
+ }
+
+ const point_type &point1(bool oriented = false) const {
+ if (!oriented)
+ return point1_;
+ return is_inverse() ? point0_ : point1_;
+ }
+
+ site_event& index(int index) {
+ site_index_ = (index << 2) + (site_index_ & 3);
+ return *this;
+ }
+
+ site_event& inverse() {
+ site_index_ ^= IS_INVERSE;
+ return *this;
+ }
+
+ site_event& change_initial_direction() {
+ site_index_ ^= HAS_INITIAL_DIRECTION;
+ return *this;
+ }
+
+ size_t index() const {
+ return site_index_ >> 2;
+ }
+
+ bool is_point() const {
+ return point0_.x() == point1_.x() && point0_.y() == point1_.y();
+ }
+
+ bool is_segment() const {
+ return point0_.x() != point1_.x() || point0_.y() != point1_.y();
+ }
+
+ bool is_inverse() const {
+ return (site_index_ & IS_INVERSE) ? true : false;
+ }
+
+ bool is_initial() const {
+ return (site_index_ & HAS_INITIAL_DIRECTION) ? false : true;
+ }
+
+ bool has_initial_direction() const {
+ return is_inverse() ^ is_initial();
+ }
+
+private:
+ enum kBits {
+ IS_INVERSE = 1,
+ HAS_INITIAL_DIRECTION = 2
+ };
+
+ point_type point0_;
+ point_type point1_;
+ unsigned int site_index_;
+};
+
+// Circle event type.
+// Occurs when the sweepline sweeps over the rightmost point of the Voronoi
+// circle (with the center at the intersection point of the bisectors).
+// Circle event is made of the two consecutive nodes in the beach line data
+// structure. In case another node was inserted during algorithm execution
+// between the given two nodes circle event becomes inactive.
+// Variables:
+// center_x_ - center x-coordinate;
+// center_y_ - center y-coordinate;
+// lower_x_ - leftmost x-coordinate;
+// is_active_ - states whether circle event is still active.
+// NOTE: lower_y coordinate is always equal to center_y.
+template <typename T>
+class circle_event {
+public:
+ typedef T coordinate_type;
+
+ circle_event() : is_active_(true) {}
+
+ circle_event(coordinate_type c_x,
+ coordinate_type c_y,
+ coordinate_type lower_x) :
+ center_x_(c_x),
+ center_y_(c_y),
+ lower_x_(lower_x),
+ is_active_(true) {}
+
+ coordinate_type x() const {
+ return center_x_;
+ }
+
+ circle_event& x(coordinate_type center_x) {
+ center_x_ = center_x;
+ return *this;
+ }
+
+ coordinate_type y() const {
+ return center_y_;
+ }
+
+ circle_event& y(coordinate_type center_y) {
+ center_y_ = center_y;
+ return *this;
+ }
+
+ coordinate_type lower_x() const {
+ return lower_x_;
+ }
+
+ circle_event& lower_x(coordinate_type lower_x) {
+ lower_x_ = lower_x;
+ return *this;
+ }
+
+ coordinate_type lower_y() const {
+ return center_y_;
+ }
+
+ bool is_active() const {
+ return is_active_;
+ }
+
+ circle_event& deactivate() {
+ is_active_ = false;
+ return *this;
+ }
+
+private:
+ coordinate_type center_x_;
+ coordinate_type center_y_;
+ coordinate_type lower_x_;
+ bool is_active_;
+};
+
+// Event queue data structure, holds circle events.
+// During algorithm run, some of the circle events disappear (become
+// inactive). Priority queue data structure doesn't support
+// iterators (there is no direct ability to modify its elements).
+// Instead list is used to store all the circle events and priority queue
+// of the iterators to the list elements is used to keep the correct circle
+// events ordering.
+template <typename T, typename Predicate>
+class ordered_queue {
+public:
+ ordered_queue() {}
+
+ bool empty() const {
+ return c_.empty();
+ }
+
+ const T &top() const {
+ return *c_.top();
+ }
+
+ void pop() {
+ list_iterator_type it = c_.top();
+ c_.pop();
+ c_list_.erase(it);
+ }
+
+ T &push(const T &e) {
+ c_list_.push_front(e);
+ c_.push(c_list_.begin());
+ return c_list_.front();
+ }
+
+ void clear() {
+ while (!c_.empty())
+ c_.pop();
+ c_list_.clear();
+ }
+
+private:
+ typedef typename std::list<T>::iterator list_iterator_type;
+
+ struct comparison {
+ bool operator() (const list_iterator_type &it1,
+ const list_iterator_type &it2) const {
+ return cmp_(*it1, *it2);
+ }
+ Predicate cmp_;
+ };
+
+ std::priority_queue< list_iterator_type,
+ std::vector<list_iterator_type>,
+ comparison > c_;
+ std::list<T> c_list_;
+
+ //Disallow copy constructor and operator=
+ ordered_queue(const ordered_queue&);
+ void operator=(const ordered_queue&);
+};
+
+// Represents a bisector node made by two arcs that correspond to the left
+// and right sites. Arc is defined as a curve with points equidistant from
+// the site and from the sweepline. If the site is a point then arc is
+// a parabola, otherwise it's a line segment. A segment site event will
+// produce different bisectors based on its direction.
+// In general case two sites will create two opposite bisectors. That's
+// why the order of the sites is important to define the unique bisector.
+// The one site is considered to be newer than the other one if it was
+// processed by the algorithm later (has greater index).
+template <typename Site>
+class beach_line_node_key {
+public:
+ typedef Site site_type;
+
+ // Constructs degenerate bisector, used to search an arc that is above
+ // the given site. The input to the constructor is the new site point.
+ explicit beach_line_node_key(const site_type &new_site) :
+ left_site_(new_site),
+ right_site_(new_site) {}
+
+ // Constructs a new bisector. The input to the constructor is the two
+ // sites that create the bisector. The order of sites is important.
+ beach_line_node_key(const site_type &left_site,
+ const site_type &right_site) :
+ left_site_(left_site),
+ right_site_(right_site) {}
+
+ const site_type &left_site() const {
+ return left_site_;
+ }
+
+ site_type &left_site() {
+ return left_site_;
+ }
+
+ beach_line_node_key& left_site(const site_type &site) {
+ left_site_ = site;
+ return *this;
+ }
+
+ const site_type &right_site() const {
+ return right_site_;
+ }
+
+ site_type &right_site() {
+ return right_site_;
+ }
+
+ beach_line_node_key& right_site(const site_type &site) {
+ right_site_ = site;
+ return *this;
+ }
+
+private:
+ site_type left_site_;
+ site_type right_site_;
+};
+
+// Represents edge data structure from the Voronoi output, that is
+// associated as a value with beach line bisector in the beach
+// line. Contains pointer to the circle event in the circle event
+// queue if the edge corresponds to the right bisector of the circle event.
+template <typename Edge, typename Circle>
+class beach_line_node_data {
+public:
+ explicit beach_line_node_data(Edge *new_edge) :
+ circle_event_(NULL),
+ edge_(new_edge) {}
+
+ Circle *circle_event() const {
+ return circle_event_;
+ }
+
+ beach_line_node_data& circle_event(Circle *circle_event) {
+ circle_event_ = circle_event;
+ return *this;
+ }
+
+ Edge *edge() const {
+ return edge_;
+ }
+
+ beach_line_node_data& edge(Edge *new_edge) {
+ edge_ = new_edge;
+ return *this;
+ }
+
+private:
+ Circle *circle_event_;
+ Edge *edge_;
+};
+} // detail
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_DETAIL_VORONOI_STRUCTURES
Deleted: trunk/boost/polygon/directed_line_segment_concept.hpp
==============================================================================
--- trunk/boost/polygon/directed_line_segment_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
+++ (empty file)
@@ -1,453 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef BOOST_POLYGON_DIRECTED_LINE_SEGMENT_CONCEPT_HPP
-#define BOOST_POLYGON_DIRECTED_LINE_SEGMENT_CONCEPT_HPP
-#include "isotropy.hpp"
-#include "directed_line_segment_data.hpp"
-#include "directed_line_segment_traits.hpp"
-#include "rectangle_concept.hpp"
-#include "detail/polygon_arbitrary_formation.hpp"
-
-namespace boost { namespace polygon{
- struct directed_line_segment_concept {};
-
- template <typename T>
- struct is_directed_line_segment_concept { typedef gtl_no type; };
- template <>
- struct is_directed_line_segment_concept<directed_line_segment_concept> { typedef gtl_yes type; };
-
- template <typename T>
- struct is_mutable_directed_line_segment_concept { typedef gtl_no type; };
- template <>
- struct is_mutable_directed_line_segment_concept<directed_line_segment_concept> { typedef gtl_yes type; };
-
- template <typename T, typename CT>
- struct directed_line_segment_distance_type_by_concept { typedef void type; };
- template <typename T>
- struct directed_line_segment_distance_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename directed_line_segment_traits<T>::coordinate_type>::coordinate_distance type; };
-
- template <typename T>
- struct directed_line_segment_distance_type {
- typedef typename directed_line_segment_distance_type_by_concept<
- T, typename is_directed_line_segment_concept<typename geometry_concept<T>::type>::type>::type type;
- };
-
- template <typename T, typename CT>
- struct directed_line_segment_point_type_by_concept { typedef void type; };
- template <typename T>
- struct directed_line_segment_point_type_by_concept<T, gtl_yes> {
- typedef typename directed_line_segment_traits<T>::point_type type; };
-
- template <typename T>
- struct directed_line_segment_point_type {
- typedef typename directed_line_segment_point_type_by_concept<
- T, typename is_directed_line_segment_concept<typename geometry_concept<T>::type>::type>::type type;
- };
-
- template <typename T, typename CT>
- struct directed_line_segment_coordinate_type_by_concept { typedef void type; };
- template <typename T>
- struct directed_line_segment_coordinate_type_by_concept<T, gtl_yes> {
- typedef typename directed_line_segment_traits<T>::coordinate_type type; };
-
- template <typename T>
- struct directed_line_segment_coordinate_type {
- typedef typename directed_line_segment_coordinate_type_by_concept<
- T, typename is_directed_line_segment_concept<typename geometry_concept<T>::type>::type>::type type;
- };
-
- template <typename T>
- typename directed_line_segment_point_type<T>::type
- get(const T& segment, direction_1d dir,
- typename enable_if<typename gtl_if<typename is_directed_line_segment_concept<typename geometry_concept<T>::type>::type>::type>::type * = 0
- ) {
- return directed_line_segment_traits<T>::get(segment, dir);
- }
-
- template <typename T, typename point_type>
- void
- set(T& segment, direction_1d dir, point_type value,
- typename enable_if<typename is_mutable_directed_line_segment_concept<typename geometry_concept<T>::type>::type>::type * = 0
- ) {
- directed_line_segment_mutable_traits<T>::set(segment, dir, value);
- }
-
- template <typename T, typename T2, typename T3>
- T
- construct(T2 low_value, T3 high_value,
- typename enable_if<typename is_mutable_directed_line_segment_concept<typename geometry_concept<T>::type>::type>::type * = 0
- ) {
- return directed_line_segment_mutable_traits<T>::construct(low_value, high_value);
- }
-
- template <typename T, typename T2>
- T
- copy_construct(const T2& segment,
- typename enable_if< typename gtl_and<typename is_mutable_directed_line_segment_concept<typename geometry_concept<T>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
- ) {
- return construct<T>
- (get(segment, LOW ),
- get(segment, HIGH));
- }
-
- template <typename T1, typename T2>
- T1 &
- assign(T1& lvalue, const T2& rvalue,
- typename enable_if< typename gtl_and< typename is_mutable_directed_line_segment_concept<typename geometry_concept<T1>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0) {
- lvalue = copy_construct<T1>(rvalue);
- return lvalue;
- }
-
- template <typename T, typename T2>
- bool
- equivalence(const T& segment1, const T2& segment2,
- typename enable_if< typename gtl_and< typename is_directed_line_segment_concept<typename geometry_concept<T>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
- ) {
- return get(segment1, LOW) ==
- get(segment2, LOW) &&
- get(segment1, HIGH) ==
- get(segment2, HIGH);
- }
-
- struct y_dls_on_above_or_below : gtl_yes {};
-
- //-1 for below, 0 for on and 1 for above
- template <typename segment_type>
- typename enable_if< typename gtl_and< y_dls_on_above_or_below, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type >::type, bool>::type
- on_above_or_below(const segment_type& segment,
- typename directed_line_segment_traits<segment_type>::point_type value) {
- typedef polygon_arbitrary_formation<typename directed_line_segment_traits<segment_type>::coordinate_type> paf;
- typename paf::Point pt, l, h;
- assign(pt, value);
- assign(l, low(segment));
- assign(h, high(segment));
- return paf::on_above_or_below(pt, typename paf::half_edge(l, h));
- }
-
- struct y_dls_contains : gtl_yes {};
-
- template <typename segment_type>
- typename enable_if< typename gtl_and< y_dls_contains, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type >::type, bool>::type
- contains(const segment_type& segment,
- typename directed_line_segment_traits<segment_type>::point_type value,
- bool consider_touch = true ) {
- if(on_above_or_below(segment, value) == 0) {
- rectangle_data<typename directed_line_segment_traits<segment_type>::coordinate_type> rect;
- set_points(rect, low(segment), high(segment));
- if(area(rect) == 0.0) {
- if(!consider_touch) {
- return !equivalence(value, low(segment)) && !equivalence(value, high(segment));
- }
- }
- return contains(rect, value, consider_touch);
- }
- return false;
- }
-
- template <typename segment_type, typename segment_type_2>
- bool
- contains(const segment_type& segment,
- const segment_type_2& value, bool consider_touch = true,
- typename enable_if< typename gtl_and< typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type>::type>::type * = 0
- ) {
- return contains(segment, get(value, LOW), consider_touch) &&
- contains(segment, get(value, HIGH), consider_touch);
- }
-
- // get the low point
- template <typename segment_type>
- typename directed_line_segment_point_type<segment_type>::type
- low(const segment_type& segment,
- typename enable_if< typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type * = 0
- ) { return get(segment, LOW); }
-
- // get the high point
- template <typename segment_type>
- typename directed_line_segment_point_type<segment_type>::type
- high(const segment_type& segment,
- typename enable_if< typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type * = 0
- ) { return get(segment, HIGH); }
-
- // get the center point
- template <typename segment_type>
- typename directed_line_segment_point_type<segment_type>::type
- center(const segment_type& segment,
- typename enable_if< typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type * = 0
- ) {
- return construct<typename directed_line_segment_traits<segment_type>::point_type>((x(high(segment)) + x(low(segment)))/2,
- (y(high(segment)) + y(low(segment)))/2);
-
- }
-
- struct y_dls_low : gtl_yes {};
-
- // set the low point to v
- template <typename segment_type>
- typename enable_if<typename gtl_and<y_dls_low, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, void>::type
- low(segment_type& segment,
- typename directed_line_segment_traits<segment_type>::point_type v) { set(segment, LOW, v); }
-
- struct y_dls_high : gtl_yes {};
-
- // set the high coordinate to v
- template <typename segment_type>
- typename enable_if<typename gtl_and<y_dls_high, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, void>::type
- high(segment_type& segment,
- typename directed_line_segment_traits<segment_type>::point_type v) { set(segment, HIGH, v); }
-
- template <typename segment_type>
- typename directed_line_segment_distance_type<segment_type>::type
- length(const segment_type& segment,
- typename enable_if< typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type * = 0
- ) { return euclidean_distance(low(segment), high(segment)); }
-
- struct y_dls_flip : gtl_yes {};
-
- struct y_dls_scale_up : gtl_yes {};
-
- // scale segment by factor
- template <typename segment_type>
- typename enable_if<typename gtl_and<y_dls_scale_up, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, segment_type>::type &
- scale_up(segment_type& segment,
- typename coordinate_traits<typename directed_line_segment_traits<segment_type>::coordinate_type>::unsigned_area_type factor) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, scale_up(l, factor));
- high(segment, scale_up(h, factor));
- return segment;
- }
-
- struct y_dls_scale_down : gtl_yes {};
-
- template <typename segment_type>
- typename enable_if<typename gtl_and<y_dls_scale_down, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, segment_type>::type &
- scale_down(segment_type& segment,
- typename coordinate_traits<typename directed_line_segment_traits<segment_type>::coordinate_type>::unsigned_area_type factor) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, scale_down(l, factor));
- high(segment, scale_down(h, factor));
- return segment;
- }
-
- struct y_dls_scale : gtl_yes {};
-
- template <typename segment_type, typename scaling_type>
- typename enable_if<typename gtl_and<y_dls_scale, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, segment_type>::type &
- scale(segment_type& segment, scaling_type factor) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, scale(l, factor));
- high(segment, scale(h, factor));
- return segment;
- }
-
-
- struct y_dls_transform : gtl_yes {};
-
- template <typename segment_type, typename transform_type>
- typename enable_if<typename gtl_and<y_dls_transform, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, segment_type>::type &
- transform(segment_type& segment, const transform_type& val) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, transform(l, val));
- high(segment, transform(h, val));
- return segment;
- }
- // move segment by delta
- template <typename segment_type>
- segment_type&
- move(segment_type& segment, orientation_2d orient,
- typename directed_line_segment_coordinate_type<segment_type>::type displacement,
- typename enable_if<typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type * = 0
- ) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, move(l, orient, displacement));
- high(segment, move(h, orient, displacement));
- return segment;
- }
-
- struct y_dls_convolve : gtl_yes {};
-
- // convolve this with b
- template <typename segment_type>
- typename enable_if<typename gtl_and<y_dls_convolve, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, segment_type>::type &
- convolve(segment_type& segment,
- const typename directed_line_segment_traits<segment_type>::point_type& b) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, convolve(l, b));
- high(segment, convolve(h, b));
- return segment;
- }
-
- struct y_dls_deconvolve : gtl_yes {};
-
- // deconvolve this with b
- template <typename segment_type>
- typename enable_if<typename gtl_and<y_dls_deconvolve, typename is_mutable_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type, segment_type>::type &
- deconvolve(segment_type& segment,
- const typename directed_line_segment_traits<segment_type>::point_type& b) {
- typename directed_line_segment_point_type<segment_type>::type l = low(segment), h = high(segment);
- low(segment, deconvolve(l, b));
- high(segment, deconvolve(h, b));
- return segment;
- }
-
- struct y_dls_e_dist1 : gtl_yes {};
-
- // distance from a point to a segment
- template <typename segment_type>
- typename enable_if< typename gtl_and<y_dls_e_dist1, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type>::type,
- typename directed_line_segment_distance_type<segment_type>::type>::type
- euclidean_distance(const segment_type& segment,
- typename directed_line_segment_traits<segment_type>::point_type position) {
- typedef typename directed_line_segment_distance_type<segment_type>::type Unit;
- Unit x1 = x(low(segment));
- Unit y1 = y(low(segment));
- Unit x2 = x(high(segment));
- Unit y2 = y(high(segment));
- Unit X = x(position);
- Unit Y = y(position);
- Unit A = X - x1;
- Unit B = Y - y1;
- Unit C = x2 - x1;
- Unit D = y2 - y1;
- Unit length_sq = C * C + D * D;
- Unit param = (A * C + B * D)/length_sq;
- if(param > 1.0) {
- return euclidean_distance(high(segment), position);
- } else if(param < 0.0) {
- return euclidean_distance(low(segment), position);
- }
- Unit denom = sqrt(length_sq);
- if(denom == 0.0)
- return 0.0;
- Unit result = (A * D - C * B) / denom;
- if(result < 0.0)
- result *= -1;
- return result;
- }
-
- struct y_dls_e_dist2 : gtl_yes {};
-
- // distance between two segments
- template <typename segment_type, typename segment_type_2>
- typename enable_if<
- typename gtl_and_3<y_dls_e_dist2, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type>::type,
- typename directed_line_segment_distance_type<segment_type>::type>::type
- euclidean_distance(const segment_type& segment,
- const segment_type_2& b) {
- typename directed_line_segment_distance_type<segment_type>::type result1 = euclidean_distance(segment, low(b)),
- result2 = euclidean_distance(segment, high(b));
- if(result2 < result1) result1 = result2;
- return result1;
- }
-
- struct y_dls_e_intersects : gtl_yes {};
-
- // check if Interval b intersects `this` Interval
- template <typename segment_type, typename segment_type_2>
- typename enable_if< typename gtl_and_3<y_dls_e_intersects,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type
- >::type, bool> ::type
- intersects(const segment_type& segment, const segment_type_2& b, bool consider_touch = true) {
- if(consider_touch) {
- if(low(segment) == low(b) || low(segment) == high(b) || high(segment) == low(b) || high(segment) == high(b))
- return true;
- }
- typedef polygon_arbitrary_formation<typename directed_line_segment_traits<segment_type>::coordinate_type> paf;
- typename paf::Point l, h, l2, h2;
- assign(l, low(segment));
- assign(h, high(segment));
- assign(l2, low(b));
- assign(h2, high(b));
- return paf::intersects(typename paf::half_edge(l, h), typename paf::half_edge(l2, h2));
- }
-
- struct y_dls_e_bintersect : gtl_yes {};
-
- // check if Interval b partially overlaps `this` Interval
- template <typename segment_type, typename segment_type_2>
- typename enable_if<
- typename gtl_and_3<y_dls_e_bintersect, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type>::type,
- bool>::type
- boundaries_intersect(const segment_type& segment, const segment_type_2& b,
- bool consider_touch = true) {
- return (contains(segment, low(b), consider_touch) ||
- contains(segment, high(b), consider_touch)) &&
- (contains(b, low(segment), consider_touch) ||
- contains(b, high(segment), consider_touch));
- }
-
- struct y_dls_abuts1 : gtl_yes {};
-
- // check if they are end to end
- template <typename segment_type, typename segment_type_2>
- typename enable_if< typename gtl_and_3<y_dls_abuts1, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type>::type,
- bool>::type
- abuts(const segment_type& segment, const segment_type_2& b, direction_1d dir) {
- return dir.to_int() ? equivalence(low(b) , high(segment)) : equivalence(low(segment) , high(b));
- }
-
- struct y_dls_abuts2 : gtl_yes {};
-
- // check if they are end to end
- template <typename segment_type, typename segment_type_2>
- typename enable_if<
- typename gtl_and_3<y_dls_abuts2, typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type>::type,
- bool>::type
- abuts(const segment_type& segment, const segment_type_2& b) {
- return abuts(segment, b, HIGH) || abuts(segment, b, LOW);
- }
-
- struct y_dls_intersect : gtl_yes {};
-
- // set point to the intersection of segment and b
- template <typename point_type, typename segment_type, typename segment_type_2>
- typename enable_if< typename gtl_and_4<y_dls_intersect, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type>::type>::type,
- typename is_directed_line_segment_concept<typename geometry_concept<segment_type_2>::type>::type>::type,
- bool>::type
- intersection(point_type& intersection, const segment_type& segment, const segment_type_2& b,
- bool projected = false, bool round_closest = false) {
- typedef polygon_arbitrary_formation<typename directed_line_segment_traits<segment_type>::coordinate_type> paf;
- typename paf::Point pt;
- typename paf::Point l, h, l2, h2;
- assign(l, low(segment));
- assign(h, high(segment));
- assign(l2, low(b));
- assign(h2, high(b));
- typename paf::half_edge he1(l, h), he2(l2, h2);
- typename paf::compute_intersection_pack pack;
- if(pack.compute_intersection(pt, he1, he2, projected, round_closest)) {
- assign(intersection, pt);
- return true;
- }
- return false;
- }
-
- template <class T>
- template <class T2>
- directed_line_segment_data<T>& directed_line_segment_data<T>::operator=(const T2& rvalue) {
- assign(*this, rvalue);
- return *this;
- }
-
- template <typename T>
- struct geometry_concept<directed_line_segment_data<T> > {
- typedef directed_line_segment_concept type;
- };
-}
-}
-#endif
Deleted: trunk/boost/polygon/directed_line_segment_data.hpp
==============================================================================
--- trunk/boost/polygon/directed_line_segment_data.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
+++ (empty file)
@@ -1,69 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef BOOST_POLYGON_DIRECTED_LINE_SEGMENT_DATA_HPP
-#define BOOST_POLYGON_DIRECTED_LINE_SEGMENT_DATA_HPP
-#include "isotropy.hpp"
-#include "point_data.hpp"
-namespace boost { namespace polygon{
- template <typename T>
- class directed_line_segment_data {
- public:
- typedef T coordinate_type;
- typedef point_data<T> point_type;
- inline directed_line_segment_data()
-#ifndef BOOST_POLYGON_MSVC
- :points_()
-#endif
- {}
- inline directed_line_segment_data(point_type low, point_type high)
-#ifndef BOOST_POLYGON_MSVC
- :points_()
-#endif
- {
- points_[LOW] = low; points_[HIGH] = high;
- }
- inline directed_line_segment_data(const directed_line_segment_data& that)
-#ifndef BOOST_POLYGON_MSVC
- :points_()
-#endif
- {
- (*this) = that;
- }
- inline directed_line_segment_data& operator=(const directed_line_segment_data& that) {
- points_[0] = that.points_[0]; points_[1] = that.points_[1]; return *this;
- }
- template <typename T2>
- inline directed_line_segment_data& operator=(const T2& rvalue);
- inline point_type get(direction_1d dir) const {
- return points_[dir.to_int()];
- }
- inline point_type low() const { return points_[0]; }
- inline point_type high() const { return points_[1]; }
- inline bool operator==(const directed_line_segment_data& that) const {
- return low() == that.low() && high() == that.high(); }
- inline bool operator!=(const directed_line_segment_data& that) const {
- return low() != that.low() || high() != that.high(); }
- inline bool operator<(const directed_line_segment_data& that) const {
- if(points_[0] < that.points_[0]) return true;
- if(points_[0] > that.points_[0]) return false;
- if(points_[1] < that.points_[1]) return true;
- return false;
- }
- inline bool operator<=(const directed_line_segment_data& that) const { return !(that < *this); }
- inline bool operator>(const directed_line_segment_data& that) const { return that < *this; }
- inline bool operator>=(const directed_line_segment_data& that) const { return !((*this) < that); }
- inline void set(direction_1d dir, point_type value) {
- points_[dir.to_int()] = value;
- }
-private:
- point_type points_[2];
-};
-
-}
-}
-#endif
Deleted: trunk/boost/polygon/directed_line_segment_set_data.hpp
==============================================================================
--- trunk/boost/polygon/directed_line_segment_set_data.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
+++ (empty file)
@@ -1,270 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef BOOST_POLYGON_DIRECTED_LINE_SEGMENT_SET_DATA_HPP
-#define BOOST_POLYGON_DIRECTED_LINE_SEGMENT_SET_DATA_HPP
-
-namespace boost { namespace polygon{
- template <typename T>
- class directed_line_segment_set_data {
- public:
- typedef T coordinate_type;
- typedef point_data<T> point_type;
- typedef directed_line_segment_data<T> directed_line_segment_type;
- typedef std::vector<directed_line_segment_type> value_type;
- typedef typename std::vector<directed_line_segment_type>::const_iterator iterator_type;
-
- inline directed_line_segment_set_data() : data_(), dirty_(false), unsorted_(false) {}
- inline directed_line_segment_set_data(const directed_line_segment_set_data& that):
- data_(that.data_), dirty_(that.dirty_), unsorted_(that.unsorted_) {}
- inline directed_line_segment_set_data& operator=(const directed_line_segment_set_data& that) {
- if(this == &that) return *this;
- data_ = that.data_;
- dirty_ = that.dirty_;
- unsorted_ = that.unsorted_;
- return *this;
- }
- template <typename T2>
- inline directed_line_segment_set_data& operator=(const T2& rvalue) {
- data_.clear();
- bool unsorted = !sorted(rvalue);
- bool dirty = !dirty(rvalue);
- insert(begin(rvalue), end(rvalue));
- unsorted_ = unsorted;
- dirty_ = dirty;
- return *this;
- }
-
- inline bool operator==(const directed_line_segment_set_data& that) const {
- clean();
- that.clean();
- sort();
- that.sort();
- return data_ == that.data_;
- }
- inline bool operator!=(const directed_line_segment_set_data& that) const {
- return !(*this == that);
- }
-
- template <typename iT>
- inline void insert(iT begin_segments, iT end_segments) {
- data_.clear();
- for(; begin_segments != end_segments; ++begin_segments) {
- insert(*begin_segments);
- }
- }
-
- template <typename ST>
- inline void insert(ST segment) {
- unsorted_ = true;
- dirty_ = true;
- directed_line_segment_type tmp_seg;
- assign(tmp_seg, segment);
- data_.push_back(tmp_seg);
- }
-
- inline void clear() { data_.clear(); unsorted_ = false; dirty_ = false; }
-
- inline iterator_type begin() const {
- return data_.begin();
- }
-
- inline iterator_type end() const {
- return data_.end();
- }
-
- const value_type& value() const {
- return data_;
- }
-
- template <typename output_container>
- inline void get(output_container& output) const {
- for(std::size_t i = 0; i < size(); ++i) {
- output.push_back(typename output_container::value_type());
- assign(output.back(), data_[i]);
- }
- }
-
- inline bool empty() const { return data_.empty(); }
-
- inline std::size_t size() const { clean(); return data_.size(); }
-
- inline std::size_t capacity() const { return data_.capacity(); }
-
- inline void reserve(std::size_t size) { return data_.reserve(size); }
-
- inline bool sorted() const { return !unsorted_; }
-
- inline bool dirty() const { return dirty_; }
-
- void clean() const {
- typedef T Unit;
- typedef typename scanline_base<Unit>::Point Point;
- typedef typename scanline_base<Unit>::half_edge half_edge;
- typedef int segment_id;
- std::vector<std::pair<half_edge, segment_id> > half_edges;
- std::vector<std::pair<half_edge, segment_id> > half_edges_out;
- segment_id id = 0;
- half_edges.reserve(data_.size());
- for(iterator_type itr = begin(); itr != end(); ++itr) {
- Point l = (*itr).low();
- Point h = (*itr).high();
- half_edges.push_back(std::make_pair(half_edge(l, h), id++));
- }
- half_edges_out.reserve(half_edges.size());
- //apparently no need to pre-sort data when calling validate_scan
- line_intersection<Unit>::validate_scan(half_edges_out, half_edges.begin(), half_edges.end());
- value_type result;
- result.reserve(half_edges_out.size());
- for(std::size_t i = 0; i < half_edges_out.size(); ++i) {
- id = half_edges_out[i].second;
- Point l = half_edges_out[i].first.first;
- Point h = half_edges_out[i].first.second;
- directed_line_segment_type orig_seg = data_[id];
- if(orig_seg.high() < orig_seg.low())
- std::swap(l, h);
- result.push_back(directed_line_segment_type(l, h));
- }
- std::swap(result, data_);
- dirty_ = false;
- unsorted_ = true;
- };
-
- void sort() const{
- if(unsorted_) {
- polygon_sort(data_.begin(), data_.end());
- unsorted_ = false;
- }
- }
-
- template <typename input_iterator_type>
- void set(input_iterator_type input_begin, input_iterator_type input_end) {
- clear();
- reserve(std::distance(input_begin,input_end));
- insert(input_begin, input_end);
- dirty_ = true;
- unsorted_ = true;
- }
-
- void set(const value_type& value) {
- data_ = value;
- dirty_ = true;
- unsorted_ = true;
- }
-
- template <typename rectangle_type>
- bool extents(rectangle_type& rect) {
- if(empty()) return false;
- bool first_iteration = true;
- for(iterator_type itr = begin();
- itr != end(); ++itr) {
- rectangle_type edge_box;
- set_points(edge_box, (*itr).low(), (*itr).high());
- if(first_iteration)
- rect = edge_box;
- else
- encompass(rect, edge_box);
- first_iteration = false;
- }
- return true;
- }
-
- template <typename transform_type>
- inline directed_line_segment_set_data&
- transform(const transform_type& tr) {
- for(typename value_type::iterator itr = data_.begin(); itr != data_.end(); ++itr) {
- point_type l = (*itr).low();
- point_type h = (*itr).high();
- ::boost::polygon::transform(l, tr);
- ::boost::polygon::transform(h, tr);
- (*itr).low(l);
- (*itr).high(h);
- }
- unsorted_ = true;
- return *this;
- }
-
- inline directed_line_segment_set_data&
- scale_up(typename coordinate_traits<coordinate_type>::unsigned_area_type factor) {
- for(typename value_type::iterator itr = data_.begin(); itr != data_.end(); ++itr) {
- point_type l = (*itr).low();
- point_type h = (*itr).high();
- ::boost::polygon::scale_up(l, factor);
- ::boost::polygon::scale_up(h, factor);
- (*itr).low(l);
- (*itr).high(h);
- }
- return *this;
- }
-
- inline directed_line_segment_set_data&
- scale_down(typename coordinate_traits<coordinate_type>::unsigned_area_type factor) {
- for(typename value_type::iterator itr = data_.begin(); itr != data_.end(); ++itr) {
- point_type l = (*itr).low();
- point_type h = (*itr).high();
- ::boost::polygon::scale_down(l, factor);
- ::boost::polygon::scale_down(h, factor);
- (*itr).low(l);
- (*itr).high(h);
- }
- return *this;
- }
-
- template <typename scaling_type>
- inline directed_line_segment_set_data& scale(const scaling_type& scaling) {
- for(typename value_type::iterator itr = data_.begin(); itr != data_.end(); ++itr) {
- point_type l = (*itr).low();
- point_type h = (*itr).high();
- ::boost::polygon::scale(l, scaling);
- ::boost::polygon::scale(h, scaling);
- (*itr).low(l);
- (*itr).high(h);
- }
- return *this;
- }
-
- template <typename cT>
- std::size_t get_intersection_points(cT& output_points) const {
- typedef T Unit;
- typedef typename scanline_base<Unit>::Point Point;
- typedef typename scanline_base<Unit>::half_edge half_edge;
- typedef int segment_id;
- std::vector<std::pair<half_edge, segment_id> > half_edges;
- std::vector<std::pair<half_edge, segment_id> > half_edges_out;
- segment_id id = 0;
- half_edges.reserve(data_.size());
- for(iterator_type itr = begin(); itr != end(); ++itr) {
- Point l = (*itr).low();
- Point h = (*itr).high();
- half_edges.push_back(std::make_pair(half_edge(l, h), id++));
- }
- half_edges_out.reserve(half_edges.size());
- std::vector<std::set<Point> > intersection_points(half_edges.size(), std::set<Point>());
- line_intersection<Unit>::validate_scan_divide_and_conquer(intersection_points, half_edges.begin(), half_edges.end());
- std::vector<Point> tmp_points;
- for(std::size_t i = 0; i < intersection_points.size(); ++i) {
- typename std::set<Point>::iterator itr2 = intersection_points[i].begin();
- for(; itr2 != intersection_points[i].end(); ++itr2)
- if(data_[i].low() != *itr2 && data_[i].high() != *itr2)
- tmp_points.push_back(*itr2);
- }
- polygon_sort(tmp_points.begin(), tmp_points.end());
- typename std::vector<Point>::iterator new_end = std::unique(tmp_points.begin(), tmp_points.end());
- output_points.insert(output_points.end(), tmp_points.begin(), new_end);
- return std::distance(tmp_points.begin(), new_end);
- };
-
-
-private:
- mutable value_type data_;
- mutable bool dirty_;
- mutable bool unsorted_;
-};
-
-}
-}
-#endif
Deleted: trunk/boost/polygon/directed_line_segment_traits.hpp
==============================================================================
--- trunk/boost/polygon/directed_line_segment_traits.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
+++ (empty file)
@@ -1,42 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef BOOST_POLYGON_DIRECTED_LINE_SEGMENT_TRAITS_HPP
-#define BOOST_POLYGON_DIRECTED_LINE_SEGMENT_TRAITS_HPP
-namespace boost { namespace polygon{
- template <typename T>
- struct directed_line_segment_traits {
- typedef typename T::coordinate_type coordinate_type;
- typedef typename T::point_type point_type;
-
- static inline point_type get(const T& segment, direction_1d dir) {
- return segment.get(dir);
- }
- };
-
- template <typename T>
- struct directed_line_segment_mutable_traits {
- template <typename Point1>
- static inline void set(T& segment, direction_1d dir, const Point1& value) {
- typename directed_line_segment_traits<T>::point_type p1;
- assign(p1, value);
- segment.set(dir, value);
- }
-
- template <typename Point1, typename Point2>
- static inline T construct(const Point1& low_value,
- const Point2& high_value) {
- typename directed_line_segment_traits<T>::point_type p1, p2;
- assign(p1, low_value);
- assign(p2, high_value);
- return T(p1, p2);
- }
- };
-}
-}
-#endif
-
Modified: trunk/boost/polygon/interval_concept.hpp
==============================================================================
--- trunk/boost/polygon/interval_concept.hpp (original)
+++ trunk/boost/polygon/interval_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -47,65 +47,79 @@
T, typename is_interval_concept<typename geometry_concept<T>::type>::type>::type type;
};
+ struct y_i_get : gtl_yes {};
template <typename T>
- typename interval_coordinate_type<T>::type
- get(const T& interval, direction_1d dir,
- typename enable_if<typename gtl_if<typename is_interval_concept<typename geometry_concept<T>::type>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<
+ y_i_get,
+ typename is_interval_concept<typename geometry_concept<T>::type>::type>::type,
+ typename interval_coordinate_type<T>::type>::type
+ get(const T& interval, direction_1d dir) {
return interval_traits<T>::get(interval, dir);
}
+ struct y_i_set : gtl_yes {};
+
template <typename T, typename coordinate_type>
- void
- set(T& interval, direction_1d dir, coordinate_type value,
- typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<
+ y_i_set,
+ typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type>::type,
+ void>::type
+ set(T& interval, direction_1d dir, coordinate_type value) {
//this may need to be refined
interval_mutable_traits<T>::set(interval, dir, value);
if(high(interval) < low(interval))
interval_mutable_traits<T>::set(interval, dir.backward(), value);
}
+
+ struct y_i_construct : gtl_yes {};
template <typename T, typename T2, typename T3>
- T
- construct(T2 low_value, T3 high_value,
- typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<
+ y_i_construct,
+ typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type>::type,
+ T>::type
+ construct(T2 low_value, T3 high_value) {
if(low_value > high_value) std::swap(low_value, high_value);
return interval_mutable_traits<T>::construct(low_value, high_value);
}
+
+ struct y_i_copy_construct : gtl_yes {};
template <typename T, typename T2>
- T
- copy_construct(const T2& interval,
- typename enable_if< typename gtl_and<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type,
- typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
- ) {
- return construct<T>
- (get(interval, LOW ),
- get(interval, HIGH));
+ typename enable_if< typename gtl_and_3<
+ y_i_copy_construct,
+ typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type,
+ T>::type
+ copy_construct(const T2& interval) {
+ return construct<T>(get(interval, LOW ), get(interval, HIGH));
}
+ struct y_i_assign : gtl_yes {};
+
template <typename T1, typename T2>
- T1 &
- assign(T1& lvalue, const T2& rvalue,
- typename enable_if< typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<T1>::type>::type,
- typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0) {
+ typename enable_if< typename gtl_and_3<
+ y_i_assign,
+ typename is_mutable_interval_concept<typename geometry_concept<T1>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type,
+ T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
lvalue = copy_construct<T1>(rvalue);
return lvalue;
}
+ struct y_i_equivalence : gtl_yes {};
+
template <typename T, typename T2>
- bool
- equivalence(const T& interval1, const T2& interval2,
- typename enable_if< typename gtl_and< typename is_interval_concept<typename geometry_concept<T>::type>::type,
- typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
- ) {
- return get(interval1, LOW) ==
- get(interval2, LOW) &&
- get(interval1, HIGH) ==
- get(interval2, HIGH);
+ typename enable_if< typename gtl_and_3<
+ y_i_equivalence,
+ typename is_interval_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type,
+ bool>::type
+ equivalence(const T& interval1, const T2& interval2) {
+ return get(interval1, LOW) == get(interval2, LOW) &&
+ get(interval1, HIGH) == get(interval2, HIGH);
}
struct y_i_contains : gtl_yes {};
@@ -113,7 +127,7 @@
template <typename interval_type>
typename enable_if< typename gtl_and< y_i_contains, typename is_interval_concept<typename geometry_concept<interval_type>::type>::type >::type, bool>::type
contains(const interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type value,
+ typename interval_coordinate_type<interval_type>::type value,
bool consider_touch = true ) {
if(consider_touch) {
return value <= high(interval) && value >= low(interval);
@@ -121,63 +135,85 @@
return value < high(interval) && value > low(interval);
}
}
-
+
+ struct y_i_contains2 : gtl_yes {};
+
template <typename interval_type, typename interval_type_2>
- bool
+ typename enable_if< typename gtl_and_3<
+ y_i_contains2,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
+ bool>::type
contains(const interval_type& interval,
- const interval_type_2& value, bool consider_touch = true,
- typename enable_if< typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type>::type * = 0
- ) {
+ const interval_type_2& value,
+ bool consider_touch = true) {
return contains(interval, get(value, LOW), consider_touch) &&
contains(interval, get(value, HIGH), consider_touch);
}
-
+
+ struct y_i_low : gtl_yes {};
+
// get the low coordinate
template <typename interval_type>
- typename interval_traits<interval_type>::coordinate_type
- low(const interval_type& interval,
- typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
- ) { return get(interval, LOW); }
+ typename enable_if< typename gtl_and<
+ y_i_low,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ typename interval_coordinate_type<interval_type>::type>::type
+ low(const interval_type& interval) { return get(interval, LOW); }
+
+ struct y_i_high : gtl_yes {};
// get the high coordinate
template <typename interval_type>
- typename interval_traits<interval_type>::coordinate_type
- high(const interval_type& interval,
- typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
- ) { return get(interval, HIGH); }
+ typename enable_if< typename gtl_and<
+ y_i_high,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ typename interval_coordinate_type<interval_type>::type>::type
+ high(const interval_type& interval) { return get(interval, HIGH); }
+
+ struct y_i_center : gtl_yes {};
// get the center coordinate
template <typename interval_type>
- typename interval_traits<interval_type>::coordinate_type
- center(const interval_type& interval,
- typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
- ) { return (high(interval) + low(interval))/2; }
+ typename enable_if< typename gtl_and<
+ y_i_center,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ typename interval_coordinate_type<interval_type>::type>::type
+ center(const interval_type& interval) { return (high(interval) + low(interval))/2; }
- struct y_i_low : gtl_yes {};
+ struct y_i_low2 : gtl_yes {};
// set the low coordinate to v
template <typename interval_type>
- typename enable_if<typename gtl_and<y_i_low, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, void>::type
+ typename enable_if<typename gtl_and<
+ y_i_low2,
+ typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ void>::type
low(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type v) { set(interval, LOW, v); }
+ typename interval_coordinate_type<interval_type>::type v) { set(interval, LOW, v); }
- struct y_i_high : gtl_yes {};
+ struct y_i_high2 : gtl_yes {};
// set the high coordinate to v
template <typename interval_type>
- typename enable_if<typename gtl_and<y_i_high, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, void>::type
+ typename enable_if<typename gtl_and<
+ y_i_high2,
+ typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ void>::type
high(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type v) { set(interval, HIGH, v); }
-
+ typename interval_coordinate_type<interval_type>::type v) { set(interval, HIGH, v); }
+
+ struct y_i_delta : gtl_yes {};
+
// get the magnitude of the interval
template <typename interval_type>
- typename interval_difference_type<interval_type>::type
- delta(const interval_type& interval,
- typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
- ) {
- typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference diffT;
+ typename enable_if< typename gtl_and<
+ y_i_delta,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ typename interval_difference_type<interval_type>::type >::type
+ delta(const interval_type& interval) {
+ typedef typename coordinate_traits<typename interval_coordinate_type<interval_type>::type>::coordinate_difference diffT;
return (diffT)high(interval) - (diffT)low(interval); }
struct y_i_flip : gtl_yes {};
@@ -186,8 +222,8 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_flip, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
flip(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type axis = 0) {
- typename interval_traits<interval_type>::coordinate_type newLow, newHigh;
+ typename interval_coordinate_type<interval_type>::type axis = 0) {
+ typename interval_coordinate_type<interval_type>::type newLow, newHigh;
newLow = 2 * axis - high(interval);
newHigh = 2 * axis - low(interval);
low(interval, newLow);
@@ -201,8 +237,8 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_scale_up, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
scale_up(interval_type& interval,
- typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::unsigned_area_type factor) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typename coordinate_traits<typename interval_coordinate_type<interval_type>::type>::unsigned_area_type factor) {
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newHigh = high(interval) * (Unit)factor;
low(interval, low(interval) * (Unit)factor);
high(interval, (newHigh));
@@ -214,8 +250,8 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_scale_down, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
scale_down(interval_type& interval,
- typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::unsigned_area_type factor) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typename coordinate_traits<typename interval_coordinate_type<interval_type>::type>::unsigned_area_type factor) {
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
typedef typename coordinate_traits<Unit>::coordinate_distance dt;
Unit newHigh = scaling_policy<Unit>::round((dt)(high(interval)) / (dt)factor);
low(interval, scaling_policy<Unit>::round((dt)(low(interval)) / (dt)factor));
@@ -228,21 +264,23 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_scale, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
scale(interval_type& interval, double factor) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newHigh = scaling_policy<Unit>::round((double)(high(interval)) * factor);
low(interval, scaling_policy<Unit>::round((double)low(interval)* factor));
high(interval, (newHigh));
return interval;
}
-
+
+ struct y_i_move : gtl_yes {};
+
// move interval by delta
template <typename interval_type>
- interval_type&
- move(interval_type& interval,
- typename interval_difference_type<interval_type>::type displacement,
- typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
- ) {
- typedef typename interval_traits<interval_type>::coordinate_type ctype;
+ typename enable_if< typename gtl_and<
+ y_i_move,
+ typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ interval_type>::type &
+ move(interval_type& interval, typename interval_difference_type<interval_type>::type displacement) {
+ typedef typename interval_coordinate_type<interval_type>::type ctype;
typedef typename coordinate_traits<ctype>::coordinate_difference Unit;
Unit len = delta(interval);
low(interval, static_cast<ctype>(static_cast<Unit>(low(interval)) + displacement));
@@ -256,8 +294,8 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_convolve, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
convolve(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typename interval_coordinate_type<interval_type>::type b) {
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newLow = low(interval) + b;
Unit newHigh = high(interval) + b;
low(interval, newLow);
@@ -271,8 +309,8 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_deconvolve, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
deconvolve(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typename interval_coordinate_type<interval_type>::type b) {
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newLow = low(interval) - b;
Unit newHigh = high(interval) - b;
low(interval, newLow);
@@ -291,7 +329,7 @@
interval_type>::type &
convolve(interval_type& interval,
const interval_type_2& b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newLow = low(interval) + low(b);
Unit newHigh = high(interval) + high(b);
low(interval, newLow);
@@ -310,7 +348,7 @@
interval_type>::type &
deconvolve(interval_type& interval,
const interval_type_2& b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newLow = low(interval) - low(b);
Unit newHigh = high(interval) - high(b);
low(interval, newLow);
@@ -329,7 +367,7 @@
interval_type>::type &
reflected_convolve(interval_type& interval,
const interval_type_2& b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newLow = low(interval) - high(b);
Unit newHigh = high(interval) - low(b);
low(interval, newLow);
@@ -348,7 +386,7 @@
interval_type>::type &
reflected_deconvolve(interval_type& interval,
const interval_type_2& b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit newLow = low(interval) + high(b);
Unit newHigh = high(interval) + low(b);
low(interval, newLow);
@@ -363,8 +401,8 @@
typename enable_if< typename gtl_and<y_i_e_dist1, typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
typename interval_difference_type<interval_type>::type>::type
euclidean_distance(const interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type position) {
- typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
+ typename interval_coordinate_type<interval_type>::type position) {
+ typedef typename coordinate_traits<typename interval_difference_type<interval_type>::type>::coordinate_difference Unit;
Unit dist[3] = {0, (Unit)low(interval) - (Unit)position, (Unit)position - (Unit)high(interval)};
return dist[ (dist[1] > 0) + ((dist[2] > 0) << 1) ];
}
@@ -379,7 +417,7 @@
typename interval_difference_type<interval_type>::type>::type
euclidean_distance(const interval_type& interval,
const interval_type_2& b) {
- typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
+ typedef typename coordinate_traits<typename interval_difference_type<interval_type>::type>::coordinate_difference Unit;
Unit dist[3] = {0, (Unit)low(interval) - (Unit)high(b), (Unit)low(b) - (Unit)high(interval)};
return dist[ (dist[1] > 0) + ((dist[2] > 0) << 1) ];
}
@@ -446,7 +484,7 @@
typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
bool>::type
intersect(interval_type& interval, const interval_type_2& b, bool consider_touch = true) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit lowVal = (std::max)(low(interval), low(b));
Unit highVal = (std::min)(high(interval), high(b));
bool valid = consider_touch ?
@@ -468,7 +506,7 @@
typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
interval_type>::type &
generalized_intersect(interval_type& interval, const interval_type_2& b) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit coords[4] = {low(interval), high(interval), low(b), high(b)};
//consider implementing faster sorting of small fixed length range
polygon_sort(coords, coords+4);
@@ -483,7 +521,7 @@
template <typename interval_type>
typename enable_if< typename gtl_and<y_i_bloat, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
interval_type>::type &
- bloat(interval_type& interval, typename interval_traits<interval_type>::coordinate_type bloating) {
+ bloat(interval_type& interval, typename interval_coordinate_type<interval_type>::type bloating) {
low(interval, low(interval)-bloating);
high(interval, high(interval)+bloating);
return interval;
@@ -495,7 +533,7 @@
template <typename interval_type>
typename enable_if< typename gtl_and<y_i_bloat2, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
interval_type>::type &
- bloat(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type bloating) {
+ bloat(interval_type& interval, direction_1d dir, typename interval_coordinate_type<interval_type>::type bloating) {
set(interval, dir, get(interval, dir) + dir.get_sign() * bloating);
return interval;
}
@@ -506,7 +544,7 @@
template <typename interval_type>
typename enable_if< typename gtl_and<y_i_shrink, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
interval_type>::type &
- shrink(interval_type& interval, typename interval_traits<interval_type>::coordinate_type shrinking) {
+ shrink(interval_type& interval, typename interval_coordinate_type<interval_type>::type shrinking) {
return bloat(interval, -shrinking);
}
@@ -516,31 +554,33 @@
template <typename interval_type>
typename enable_if< typename gtl_and<y_i_shrink2, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
interval_type>::type &
- shrink(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type shrinking) {
+ shrink(interval_type& interval, direction_1d dir, typename interval_coordinate_type<interval_type>::type shrinking) {
return bloat(interval, dir, -shrinking);
}
+ struct y_i_encompass : gtl_yes {};
+
// Enlarge `this` Interval to encompass the specified Interval
template <typename interval_type, typename interval_type_2>
- bool
- encompass(interval_type& interval, const interval_type_2& b,
- typename enable_if<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and_3<
+ y_i_encompass,
+ typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
+ bool>::type
+ encompass(interval_type& interval, const interval_type_2& b) {
bool retval = !contains(interval, b, true);
low(interval, (std::min)(low(interval), low(b)));
high(interval, (std::max)(high(interval), high(b)));
return retval;
}
- struct y_i_encompass : gtl_yes {};
+ struct y_i_encompass2 : gtl_yes {};
// Enlarge `this` Interval to encompass the specified Interval
template <typename interval_type>
- typename enable_if< typename gtl_and<y_i_encompass, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_i_encompass2, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
bool>::type
- encompass(interval_type& interval, typename interval_traits<interval_type>::coordinate_type b) {
+ encompass(interval_type& interval, typename interval_coordinate_type<interval_type>::type b) {
bool retval = !contains(interval, b, true);
low(interval, (std::min)(low(interval), b));
high(interval, (std::max)(high(interval), b));
@@ -553,7 +593,7 @@
template <typename interval_type>
typename enable_if<typename gtl_and<y_i_get_half, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type
get_half(const interval_type& interval, direction_1d d1d) {
- typedef typename interval_traits<interval_type>::coordinate_type Unit;
+ typedef typename interval_coordinate_type<interval_type>::type Unit;
Unit c = (get(interval, LOW) + get(interval, HIGH)) / 2;
return construct<interval_type>((d1d == LOW) ? get(interval, LOW) : c,
(d1d == LOW) ? c : get(interval, HIGH));
Modified: trunk/boost/polygon/point_3d_concept.hpp
==============================================================================
--- trunk/boost/polygon/point_3d_concept.hpp (original)
+++ trunk/boost/polygon/point_3d_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -39,7 +39,7 @@
struct point_3d_difference_type_by_concept { typedef void type; };
template <typename T>
struct point_3d_difference_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename point_3d_traits<T>::coordinate_type>::coordinate_difference type; };
+ typedef typename coordinate_traits<typename point_3d_coordinate_type<T>::type>::coordinate_difference type; };
template <typename T>
struct point_3d_difference_type {
@@ -51,7 +51,7 @@
struct point_3d_distance_type_by_concept { typedef void type; };
template <typename T>
struct point_3d_distance_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename point_3d_traits<T>::coordinate_type>::coordinate_distance type; };
+ typedef typename coordinate_traits<typename point_3d_coordinate_type<T>::type>::coordinate_distance type; };
template <typename T>
struct point_3d_distance_type {
@@ -62,7 +62,7 @@
struct y_p3d_get : gtl_yes {};
template <typename T>
- typename enable_if< typename gtl_and<y_p3d_get, typename gtl_if<typename is_point_3d_concept<typename geometry_concept<T>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_p3d_get, typename is_point_3d_concept<typename geometry_concept<T>::type>::type>::type,
typename point_3d_coordinate_type<T>::type >::type
get(const T& point, orientation_3d orient) { return point_3d_traits<T>::get(point, orient); }
@@ -103,7 +103,7 @@
template <typename point_type>
typename enable_if< typename gtl_and<y_p3d_z, typename is_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type,
- typename point_3d_traits<point_type>::coordinate_type >::type
+ typename point_3d_coordinate_type<point_type>::type >::type
z(const point_type& point) { return get(point, PROXIMAL); }
struct y_p3d_x : gtl_yes {};
@@ -142,7 +142,7 @@
typename is_point_3d_concept<typename geometry_concept<point_type_2>::type>::type>::type,
typename point_3d_difference_type<point_type_1>::type>::type
euclidean_distance(const point_type_1& point1, const point_type_2& point2, orientation_3d orient) {
- typedef typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_difference return_type;
+ typedef typename coordinate_traits<typename point_3d_coordinate_type<point_type_1>::type>::coordinate_difference return_type;
return_type return_value =
(return_type)get(point1, orient) - (return_type)get(point2, orient);
return return_value < 0 ? -return_value : return_value;
@@ -167,7 +167,7 @@
typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_2>::type>::type>::type,
typename point_3d_distance_type<point_type_1>::type>::type
euclidean_distance(const point_type_1& point1, const point_type_2& point2) {
- typedef typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_distance return_value;
+ typedef typename coordinate_traits<typename point_3d_coordinate_type<point_type_1>::type>::coordinate_distance return_value;
return_value pdist = (return_value)euclidean_distance(point1, point2, PROXIMAL);
pdist *= pdist;
return sqrt((double)(distance_squared(point1, point2) + pdist));
@@ -207,10 +207,10 @@
typename enable_if< typename gtl_and<y_p3d_scale_up, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type,
point_type>::type &
scale_up(point_type& point,
- typename coordinate_traits<typename point_3d_traits<point_type>::coordinate_type>::unsigned_area_type factor) {
- x(point, x(point) * (typename point_3d_traits<point_type>::coordinate_type)factor);
- y(point, y(point) * (typename point_3d_traits<point_type>::coordinate_type)factor);
- z(point, z(point) * (typename point_3d_traits<point_type>::coordinate_type)factor);
+ typename coordinate_traits<typename point_3d_coordinate_type<point_type>::type>::unsigned_area_type factor) {
+ x(point, x(point) * (typename point_3d_coordinate_type<point_type>::type)factor);
+ y(point, y(point) * (typename point_3d_coordinate_type<point_type>::type)factor);
+ z(point, z(point) * (typename point_3d_coordinate_type<point_type>::type)factor);
return point;
}
@@ -220,8 +220,8 @@
typename enable_if< typename gtl_and<y_p3d_scale_down, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type,
point_type>::type &
scale_down(point_type& point,
- typename coordinate_traits<typename point_3d_traits<point_type>::coordinate_type>::unsigned_area_type factor) {
- typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+ typename coordinate_traits<typename point_3d_coordinate_type<point_type>::type>::unsigned_area_type factor) {
+ typedef typename point_3d_coordinate_type<point_type>::type Unit;
typedef typename coordinate_traits<Unit>::coordinate_distance dt;
x(point, scaling_policy<Unit>::round((dt)(x(point)) / (dt)factor));
y(point, scaling_policy<Unit>::round((dt)(y(point)) / (dt)factor));
@@ -236,7 +236,7 @@
point_type>::type &
scale(point_type& point,
const scaling_type& scaling) {
- typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+ typedef typename point_3d_coordinate_type<point_type>::type Unit;
Unit x_(x(point)), y_(y(point)), z_(z(point));
scaling.scale(x_, y_, z_);
x(point, x_);
@@ -251,7 +251,7 @@
typename enable_if< typename gtl_and<y_p3d_transform, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type,
point_type>::type &
transform(point_type& point, const transformation_type& transformation) {
- typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+ typedef typename point_3d_coordinate_type<point_type>::type Unit;
Unit x_(x(point)), y_(y(point)), z_(z(point));
transformation.transform(x_, y_, z_);
x(point, x_);
Modified: trunk/boost/polygon/point_concept.hpp
==============================================================================
--- trunk/boost/polygon/point_concept.hpp (original)
+++ trunk/boost/polygon/point_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -42,7 +42,7 @@
struct point_difference_type_by_concept { typedef void type; };
template <typename T>
struct point_difference_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename point_traits<T>::coordinate_type>::coordinate_difference type; };
+ typedef typename coordinate_traits<typename point_coordinate_type<T>::type>::coordinate_difference type; };
template <typename T>
struct point_difference_type {
@@ -54,7 +54,7 @@
struct point_distance_type_by_concept { typedef void type; };
template <typename T>
struct point_distance_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename point_traits<T>::coordinate_type>::coordinate_distance type; };
+ typedef typename coordinate_traits<typename point_coordinate_type<T>::type>::coordinate_distance type; };
template <typename T>
struct point_distance_type {
@@ -62,36 +62,42 @@
T, typename is_point_concept<typename geometry_concept<T>::type>::type>::type type;
};
+ struct y_pt_get : gtl_yes {};
+
template <typename T>
- typename point_coordinate_type<T>::type
- get(const T& point, orientation_2d orient,
- typename enable_if< typename gtl_if<typename is_point_concept<typename geometry_concept<T>::type>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<y_pt_get, typename is_point_concept<typename geometry_concept<T>::type>::type>::type,
+ typename point_coordinate_type<T>::type >::type
+ get(const T& point, orientation_2d orient) {
return point_traits<T>::get(point, orient);
}
-
+
+ struct y_pt_set : gtl_yes {};
+
template <typename T, typename coordinate_type>
- void
- set(T& point, orientation_2d orient, coordinate_type value,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<T>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<y_pt_set, typename is_mutable_point_concept<typename geometry_concept<T>::type>::type>::type,
+ void>::type
+ set(T& point, orientation_2d orient, coordinate_type value) {
point_mutable_traits<T>::set(point, orient, value);
}
-
+
+ struct y_pt_construct : gtl_yes {};
+
template <typename T, typename coordinate_type1, typename coordinate_type2>
- T
- construct(coordinate_type1 x_value, coordinate_type2 y_value,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<T>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<y_pt_construct, typename is_mutable_point_concept<typename geometry_concept<T>::type>::type>::type,
+ T>::type
+ construct(coordinate_type1 x_value, coordinate_type2 y_value) {
return point_mutable_traits<T>::construct(x_value, y_value);
}
+ struct y_pt_assign : gtl_yes {};
+
template <typename T1, typename T2>
- T1&
- assign(T1& lvalue, const T2& rvalue,
- typename enable_if< typename gtl_and< typename is_mutable_point_concept<typename geometry_concept<T1>::type>::type,
- typename is_point_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
- ) {
+ typename enable_if<typename gtl_and_3<
+ y_pt_assign,
+ typename is_mutable_point_concept<typename geometry_concept<T1>::type>::type,
+ typename is_point_concept<typename geometry_concept<T2>::type>::type>::type,
+ T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
set(lvalue, VERTICAL, get(rvalue, VERTICAL));
return lvalue;
@@ -101,7 +107,7 @@
template <typename point_type>
typename enable_if< typename gtl_and<y_p_x, typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
- typename point_traits<point_type>::coordinate_type >::type
+ typename point_coordinate_type<point_type>::type >::type
x(const point_type& point) {
return get(point, HORIZONTAL);
}
@@ -110,7 +116,7 @@
template <typename point_type>
typename enable_if< typename gtl_and<y_p_y, typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
- typename point_traits<point_type>::coordinate_type >::type
+ typename point_coordinate_type<point_type>::type >::type
y(const point_type& point) {
return get(point, VERTICAL);
}
@@ -133,57 +139,66 @@
set(point, VERTICAL, value);
}
+ struct y_pt_equiv : gtl_yes {};
+
template <typename T, typename T2>
- bool
- equivalence(const T& point1, const T2& point2,
- typename enable_if< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<T>::type>::type,
- typename is_point_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
- ) {
- typename point_traits<T>::coordinate_type x1 = x(point1);
- typename point_traits<T2>::coordinate_type x2 = get(point2, HORIZONTAL);
- typename point_traits<T>::coordinate_type y1 = get(point1, VERTICAL);
- typename point_traits<T2>::coordinate_type y2 = y(point2);
+ typename enable_if<typename gtl_and_3<y_pt_equiv,
+ typename gtl_same_type<point_concept, typename geometry_concept<T>::type>::type,
+ typename is_point_concept<typename geometry_concept<T2>::type>::type>::type,
+ bool>::type
+ equivalence(const T& point1, const T2& point2) {
+ typename point_coordinate_type<T>::type x1 = x(point1);
+ typename point_coordinate_type<T2>::type x2 = get(point2, HORIZONTAL);
+ typename point_coordinate_type<T>::type y1 = get(point1, VERTICAL);
+ typename point_coordinate_type<T2>::type y2 = y(point2);
return x1 == x2 && y1 == y2;
}
+ struct y_pt_man_dist : gtl_yes {};
+
template <typename point_type_1, typename point_type_2>
- typename point_difference_type<point_type_1>::type
- manhattan_distance(const point_type_1& point1, const point_type_2& point2,
- typename enable_if< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0) {
+ typename enable_if< typename gtl_and_3<
+ y_pt_man_dist,
+ typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
+ typename point_difference_type<point_type_1>::type>::type
+ manhattan_distance(const point_type_1& point1, const point_type_2& point2) {
return euclidean_distance(point1, point2, HORIZONTAL) + euclidean_distance(point1, point2, VERTICAL);
}
- struct y_i_ed1 : gtl_yes {};
+ struct y_pt_ed1 : gtl_yes {};
template <typename point_type_1, typename point_type_2>
- typename enable_if< typename gtl_and_3<y_i_ed1, typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename enable_if< typename gtl_and_3<y_pt_ed1, typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
typename point_difference_type<point_type_1>::type>::type
euclidean_distance(const point_type_1& point1, const point_type_2& point2, orientation_2d orient) {
- typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference return_value =
+ typename coordinate_traits<typename point_coordinate_type<point_type_1>::type>::coordinate_difference return_value =
get(point1, orient) - get(point2, orient);
- return return_value < 0 ? (typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference)-return_value : return_value;
+ return return_value < 0 ? (typename coordinate_traits<typename point_coordinate_type<point_type_1>::type>::coordinate_difference)-return_value : return_value;
}
- struct y_i_ed2 : gtl_yes {};
+ struct y_pt_ed2 : gtl_yes {};
template <typename point_type_1, typename point_type_2>
- typename enable_if< typename gtl_and_3<y_i_ed2, typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
+ typename enable_if< typename gtl_and_3<y_pt_ed2, typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
typename gtl_same_type<point_concept, typename geometry_concept<point_type_2>::type>::type>::type,
typename point_distance_type<point_type_1>::type>::type
euclidean_distance(const point_type_1& point1, const point_type_2& point2) {
- typedef typename point_traits<point_type_1>::coordinate_type Unit;
+ typedef typename point_coordinate_type<point_type_1>::type Unit;
return sqrt((double)(distance_squared(point1, point2)));
}
+
+ struct y_pt_eds : gtl_yes {};
template <typename point_type_1, typename point_type_2>
- typename point_difference_type<point_type_1>::type
- distance_squared(const point_type_1& point1, const point_type_2& point2,
- typename enable_if< typename gtl_and<typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0
- ) {
- typedef typename point_traits<point_type_1>::coordinate_type Unit;
+ typename enable_if< typename gtl_and_3<
+ y_pt_eds,
+ typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
+ typename point_difference_type<point_type_1>::type>::type
+ distance_squared(const point_type_1& point1, const point_type_2& point2) {
+ typedef typename point_coordinate_type<point_type_1>::type Unit;
typename coordinate_traits<Unit>::coordinate_difference dx = euclidean_distance(point1, point2, HORIZONTAL);
typename coordinate_traits<Unit>::coordinate_difference dy = euclidean_distance(point1, point2, VERTICAL);
dx *= dx;
@@ -191,58 +206,66 @@
return dx + dy;
}
+ struct y_pt_convolve : gtl_yes {};
+
template <typename point_type_1, typename point_type_2>
- point_type_1 &
- convolve(point_type_1& lvalue, const point_type_2& rvalue,
- typename enable_if< typename gtl_and<typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and_3<
+ y_pt_convolve,
+ typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
+ point_type_1>::type &
+ convolve(point_type_1& lvalue, const point_type_2& rvalue) {
x(lvalue, x(lvalue) + x(rvalue));
y(lvalue, y(lvalue) + y(rvalue));
return lvalue;
}
-
+
+ struct y_pt_deconvolve : gtl_yes {};
+
template <typename point_type_1, typename point_type_2>
- point_type_1 &
- deconvolve(point_type_1& lvalue, const point_type_2& rvalue,
- typename enable_if< typename gtl_and<typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and_3<
+ y_pt_deconvolve,
+ typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
+ point_type_1>::type &
+ deconvolve(point_type_1& lvalue, const point_type_2& rvalue) {
x(lvalue, x(lvalue) - x(rvalue));
y(lvalue, y(lvalue) - y(rvalue));
return lvalue;
}
+
+ struct y_pt_scale_up : gtl_yes {};
template <typename point_type, typename coord_type>
- point_type &
- scale_up(point_type& point, coord_type factor,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
- ) {
- typedef typename point_traits<point_type>::coordinate_type Unit;
+ typename enable_if< typename gtl_and<y_pt_scale_up, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+ point_type>::type &
+ scale_up(point_type& point, coord_type factor) {
+ typedef typename point_coordinate_type<point_type>::type Unit;
x(point, x(point) * (Unit)factor);
y(point, y(point) * (Unit)factor);
return point;
}
+ struct y_pt_scale_down : gtl_yes {};
+
template <typename point_type, typename coord_type>
- point_type &
- scale_down(point_type& point, coord_type factor,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
- ) {
- typedef typename point_traits<point_type>::coordinate_type Unit;
+ typename enable_if< typename gtl_and<y_pt_scale_down, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+ point_type>::type &
+ scale_down(point_type& point, coord_type factor) {
+ typedef typename point_coordinate_type<point_type>::type Unit;
typedef typename coordinate_traits<Unit>::coordinate_distance dt;
x(point, scaling_policy<Unit>::round((dt)((dt)(x(point)) / (dt)factor)));
y(point, scaling_policy<Unit>::round((dt)((dt)(y(point)) / (dt)factor)));
return point;
}
+ struct y_pt_scale : gtl_yes {};
+
template <typename point_type, typename scaling_type>
- point_type &
- scale(point_type& point,
- const scaling_type& scaling,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
- ) {
- typedef typename point_traits<point_type>::coordinate_type Unit;
+ typename enable_if< typename gtl_and<y_pt_scale, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+ point_type>::type &
+ scale(point_type& point, const scaling_type& scaling) {
+ typedef typename point_coordinate_type<point_type>::type Unit;
Unit x_(x(point)), y_(y(point));
scaling.scale(x_, y_);
x(point, x_);
@@ -250,12 +273,13 @@
return point;
}
+ struct y_pt_transform : gtl_yes {};
+
template <typename point_type, typename transformation_type>
- point_type &
- transform(point_type& point, const transformation_type& transformation,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
- ) {
- typedef typename point_traits<point_type>::coordinate_type Unit;
+ typename enable_if< typename gtl_and<y_pt_transform, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+ point_type>::type &
+ transform(point_type& point, const transformation_type& transformation) {
+ typedef typename point_coordinate_type<point_type>::type Unit;
Unit x_(x(point)), y_(y(point));
transformation.transform(x_, y_);
x(point, x_);
@@ -266,16 +290,11 @@
struct y_pt_move : gtl_yes {};
template <typename point_type>
- typename enable_if<
- typename gtl_and< y_pt_move,
- typename is_mutable_point_concept<
- typename geometry_concept<point_type>::type>::type>::type,
- point_type>::type &
+ typename enable_if< typename gtl_and<y_pt_move, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+ point_type>::type &
move(point_type& point, orientation_2d orient,
- typename point_traits<point_type>::coordinate_type displacement,
- typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
- ) {
- typedef typename point_traits<point_type>::coordinate_type Unit;
+ typename point_coordinate_type<point_type>::type displacement) {
+ typedef typename point_coordinate_type<point_type>::type Unit;
Unit v(get(point, orient));
set(point, orient, v + displacement);
return point;
Modified: trunk/boost/polygon/polygon.hpp
==============================================================================
--- trunk/boost/polygon/polygon.hpp (original)
+++ trunk/boost/polygon/polygon.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -88,8 +88,9 @@
#include "polygon_set_concept.hpp"
-#include "directed_line_segment_data.hpp"
-#include "directed_line_segment_traits.hpp"
-#include "directed_line_segment_concept.hpp"
+//segment
+#include "segment_data.hpp"
+#include "segment_traits.hpp"
+#include "segment_concept.hpp"
#endif
Modified: trunk/boost/polygon/polygon_90_set_concept.hpp
==============================================================================
--- trunk/boost/polygon/polygon_90_set_concept.hpp (original)
+++ trunk/boost/polygon/polygon_90_set_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -460,24 +460,27 @@
return polygon_set;
}
+ struct y_p_s_move : gtl_yes {};
+
//move
template <typename polygon_set_type>
- polygon_set_type&
+ typename enable_if< typename gtl_and<y_p_s_move, typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type>::type,
+ polygon_set_type>::type &
move(polygon_set_type& polygon_set,
- orientation_2d orient, typename polygon_90_set_traits<polygon_set_type>::coordinate_type displacement,
- typename enable_if< typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type * = 0) {
+ orientation_2d orient, typename polygon_90_set_traits<polygon_set_type>::coordinate_type displacement) {
if(orient == HORIZONTAL)
return move(polygon_set, displacement, 0);
else
return move(polygon_set, 0, displacement);
}
+ struct y_p_s_move2 : gtl_yes {};
+
template <typename polygon_set_type>
- polygon_set_type&
+ typename enable_if< typename gtl_and<y_p_s_move2, typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type>::type,
+ polygon_set_type>::type &
move(polygon_set_type& polygon_set, typename polygon_90_set_traits<polygon_set_type>::coordinate_type x_displacement,
- typename polygon_90_set_traits<polygon_set_type>::coordinate_type y_displacement,
- typename enable_if< typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type * = 0
- ) {
+ typename polygon_90_set_traits<polygon_set_type>::coordinate_type y_displacement) {
typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
polygon_90_set_data<Unit> ps;
assign(ps, polygon_set);
Modified: trunk/boost/polygon/polygon_traits.hpp
==============================================================================
--- trunk/boost/polygon/polygon_traits.hpp (original)
+++ trunk/boost/polygon/polygon_traits.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -756,8 +756,6 @@
void snap_point_vector_to_45(std::vector<point_data<Unit> >& pts) {
typedef point_data<Unit> Point;
if(pts.size() < 3) { pts.clear(); return; }
- Point firstPt = pts.front();
- Point prevPt = firstPt;
typename std::vector<point_data<Unit> >::iterator endLocation = std::unique(pts.begin(), pts.end());
if(endLocation != pts.end()){
pts.resize(endLocation - pts.begin());
Modified: trunk/boost/polygon/rectangle_concept.hpp
==============================================================================
--- trunk/boost/polygon/rectangle_concept.hpp (original)
+++ trunk/boost/polygon/rectangle_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -63,7 +63,7 @@
struct rectangle_difference_type_by_concept { typedef void type; };
template <typename T>
struct rectangle_difference_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename rectangle_traits<T>::coordinate_type>::coordinate_difference type; };
+ typedef typename coordinate_traits<typename rectangle_traits<T>::coordinate_type>::coordinate_difference type; };
template <typename T>
struct rectangle_difference_type {
@@ -75,7 +75,7 @@
struct rectangle_distance_type_by_concept { typedef void type; };
template <typename T>
struct rectangle_distance_type_by_concept<T, gtl_yes> {
- typedef typename coordinate_traits<typename rectangle_traits<T>::coordinate_type>::coordinate_distance type; };
+ typedef typename coordinate_traits<typename rectangle_coordinate_type<T>::type>::coordinate_distance type; };
template <typename T>
struct rectangle_distance_type {
@@ -83,19 +83,20 @@
T, typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type type;
};
+ struct y_r_get_interval : gtl_yes {};
+
template <typename T>
- typename rectangle_interval_type<T>::type
- get(const T& rectangle, orientation_2d orient,
- typename enable_if< typename gtl_if<typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type>::type * = 0
- ) {
- return rectangle_traits<T>::get(rectangle, orient);
+ typename enable_if< typename gtl_and<y_r_get_interval, typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type,
+ typename rectangle_interval_type<T>::type>::type
+ get(const T& rectangle, orientation_2d orient) {
+ return rectangle_traits<T>::get(rectangle, orient);
}
struct y_r_h : gtl_yes {};
template <typename T>
- typename enable_if< typename gtl_and<y_r_h, typename gtl_if<typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type>::type,
- typename rectangle_traits<T>::interval_type>::type
+ typename enable_if< typename gtl_and<y_r_h, typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type,
+ typename rectangle_interval_type<T>::type>::type
horizontal(const T& rectangle) {
return rectangle_traits<T>::get(rectangle, HORIZONTAL);
}
@@ -103,8 +104,8 @@
struct y_r_v : gtl_yes {};
template <typename T>
- typename enable_if< typename gtl_and<y_r_v, typename gtl_if<typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type>::type,
- typename rectangle_traits<T>::interval_type>::type
+ typename enable_if< typename gtl_and<y_r_v, typename is_rectangle_concept<typename geometry_concept<T>::type>::type>::type,
+ typename rectangle_interval_type<T>::type>::type
vertical(const T& rectangle) {
return rectangle_traits<T>::get(rectangle, VERTICAL);
}
@@ -210,7 +211,7 @@
struct y_r_get : gtl_yes {};
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_get, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_get, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_coordinate_type<rectangle_type>::type>::type
get(const rectangle_type& rectangle, orientation_2d orient, direction_1d dir) {
return get(rectangle_traits<rectangle_type>::get(rectangle, orient), dir);
@@ -221,8 +222,8 @@
template <typename rectangle_type>
typename enable_if<typename gtl_and<y_r_set3, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type, void>::type
set(rectangle_type& rectangle, orientation_2d orient, direction_1d dir,
- typename rectangle_traits<rectangle_type>::coordinate_type value) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orient);
+ typename rectangle_coordinate_type<rectangle_type>::type value) {
+ typename rectangle_interval_type<rectangle_type>::type ivl = get(rectangle, orient);
set(ivl, dir, value);
set(rectangle, orient, ivl);
}
@@ -230,7 +231,7 @@
struct y_r_xl : gtl_yes {};
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_xl, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_xl, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_coordinate_type<rectangle_type>::type>::type
xl(const rectangle_type& rectangle) {
return get(rectangle, HORIZONTAL, LOW);
@@ -240,14 +241,14 @@
template <typename rectangle_type>
typename enable_if<typename gtl_and<y_r_xl2, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type, void>::type
- xl(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ xl(rectangle_type& rectangle, typename rectangle_coordinate_type<rectangle_type>::type value) {
return set(rectangle, HORIZONTAL, LOW, value);
}
struct y_r_xh : gtl_yes {};
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_xh, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_xh, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_coordinate_type<rectangle_type>::type>::type
xh(const rectangle_type& rectangle) {
return get(rectangle, HORIZONTAL, HIGH);
@@ -257,14 +258,14 @@
template <typename rectangle_type>
typename enable_if<typename gtl_and<y_r_xh2, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type, void>::type
- xh(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ xh(rectangle_type& rectangle, typename rectangle_coordinate_type<rectangle_type>::type value) {
return set(rectangle, HORIZONTAL, HIGH, value);
}
struct y_r_yl : gtl_yes {};
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_yl, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_yl, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_coordinate_type<rectangle_type>::type>::type
yl(const rectangle_type& rectangle) {
return get(rectangle, VERTICAL, LOW);
@@ -274,14 +275,14 @@
template <typename rectangle_type>
typename enable_if<typename gtl_and<y_r_yl2, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type, void>::type
- yl(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ yl(rectangle_type& rectangle, typename rectangle_coordinate_type<rectangle_type>::type value) {
return set(rectangle, VERTICAL, LOW, value);
}
struct y_r_yh : gtl_yes {};
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_yh, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_yh, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_coordinate_type<rectangle_type>::type>::type
yh(const rectangle_type& rectangle) {
return get(rectangle, VERTICAL, HIGH);
@@ -291,44 +292,44 @@
template <typename rectangle_type>
typename enable_if<typename gtl_and<y_r_yh2, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type, void>::type
- yh(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ yh(rectangle_type& rectangle, typename rectangle_coordinate_type<rectangle_type>::type value) {
return set(rectangle, VERTICAL, HIGH, value);
}
struct y_r_ll : gtl_yes {};
template <typename rectangle_type>
- typename enable_if<typename gtl_and<y_r_ll, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ typename enable_if<typename gtl_and<y_r_ll, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> >::type
ll(const rectangle_type& rectangle) {
- return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xl(rectangle), yl(rectangle));
+ return point_data<typename rectangle_coordinate_type<rectangle_type>::type> (xl(rectangle), yl(rectangle));
}
struct y_r_lr : gtl_yes {};
template <typename rectangle_type>
- typename enable_if<typename gtl_and<y_r_lr, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ typename enable_if<typename gtl_and<y_r_lr, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> >::type
lr(const rectangle_type& rectangle) {
- return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xh(rectangle), yl(rectangle));
+ return point_data<typename rectangle_coordinate_type<rectangle_type>::type> (xh(rectangle), yl(rectangle));
}
struct y_r_ul : gtl_yes {};
template <typename rectangle_type>
- typename enable_if<typename gtl_and<y_r_ul, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ typename enable_if<typename gtl_and<y_r_ul, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> >::type
ul(const rectangle_type& rectangle) {
- return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xl(rectangle), yh(rectangle));
+ return point_data<typename rectangle_coordinate_type<rectangle_type>::type> (xl(rectangle), yh(rectangle));
}
struct y_r_ur : gtl_yes {};
template <typename rectangle_type>
- typename enable_if<typename gtl_and<y_r_ur, typename gtl_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ typename enable_if<typename gtl_and<y_r_ur, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> >::type
ur(const rectangle_type& rectangle) {
- return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xh(rectangle), yh(rectangle));
+ return point_data<typename rectangle_coordinate_type<rectangle_type>::type> (xh(rectangle), yh(rectangle));
}
struct y_r_contains : gtl_yes {};
@@ -365,24 +366,25 @@
rectangle_type>::type &
set_points(rectangle_type& rectangle, const point_type_1& p1,
const point_type_2& p2) {
- typedef typename rectangle_traits<rectangle_type>::coordinate_type Unit;
+ typedef typename rectangle_coordinate_type<rectangle_type>::type Unit;
Unit x1(x(p1));
Unit x2(x(p2));
Unit y1(y(p1));
Unit y2(y(p2));
- horizontal(rectangle, construct<typename rectangle_traits<rectangle_type>::interval_type>(x1, x2));
- vertical(rectangle, construct<typename rectangle_traits<rectangle_type>::interval_type>(y1, y2));
+ horizontal(rectangle, construct<typename rectangle_interval_type<rectangle_type>::type>(x1, x2));
+ vertical(rectangle, construct<typename rectangle_interval_type<rectangle_type>::type>(y1, y2));
return rectangle;
}
-
+
+ struct y_r_move : gtl_yes {};
+
// move rectangle by delta in orient
template <typename rectangle_type>
- rectangle_type&
+ typename enable_if< typename gtl_and<y_r_move, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
+ rectangle_type>::type &
move(rectangle_type& rectangle, orientation_2d orient,
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference delta,
- typename enable_if<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type * = 0
- ) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orient);
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::coordinate_difference delta) {
+ typename rectangle_interval_type<rectangle_type>::type ivl = get(rectangle, orient);
move(ivl, delta);
set(rectangle, orient, ivl);
return rectangle;
@@ -399,7 +401,7 @@
rectangle_type_1>::type &
convolve(rectangle_type_1& rectangle,
const rectangle_type_2& convolution_rectangle) {
- typename rectangle_traits<rectangle_type_1>::interval_type ivl = horizontal(rectangle);
+ typename rectangle_interval_type<rectangle_type_1>::type ivl = horizontal(rectangle);
horizontal(rectangle, convolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
vertical(rectangle, convolve(ivl, vertical(convolution_rectangle)));
@@ -415,7 +417,7 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type>::type,
rectangle_type_1>::type &
deconvolve(rectangle_type_1& rectangle, const rectangle_type_2& convolution_rectangle) {
- typename rectangle_traits<rectangle_type_1>::interval_type ivl = horizontal(rectangle);
+ typename rectangle_interval_type<rectangle_type_1>::type ivl = horizontal(rectangle);
horizontal(rectangle, deconvolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
vertical(rectangle, deconvolve(ivl, vertical(convolution_rectangle)));
@@ -431,7 +433,7 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type>::type,
rectangle_type_1>::type &
reflected_convolve(rectangle_type_1& rectangle, const rectangle_type_2& convolution_rectangle) {
- typename rectangle_traits<rectangle_type_1>::interval_type ivl = horizontal(rectangle);
+ typename rectangle_interval_type<rectangle_type_1>::type ivl = horizontal(rectangle);
horizontal(rectangle, reflected_convolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
vertical(rectangle, reflected_convolve(ivl, vertical(convolution_rectangle)));
@@ -448,7 +450,7 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type>::type,
rectangle_type_1>::type &
reflected_deconvolve(rectangle_type_1& rectangle, const rectangle_type_2& convolution_rectangle) {
- typename rectangle_traits<rectangle_type_1>::interval_type ivl = horizontal(rectangle);
+ typename rectangle_interval_type<rectangle_type_1>::type ivl = horizontal(rectangle);
horizontal(rectangle, reflected_deconvolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
vertical(rectangle, reflected_deconvolve(ivl, vertical(convolution_rectangle)));
@@ -463,7 +465,7 @@
typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
rectangle_type>::type &
convolve(rectangle_type& rectangle, const point_type& convolution_point) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = horizontal(rectangle);
+ typename rectangle_interval_type<rectangle_type>::type ivl = horizontal(rectangle);
horizontal(rectangle, convolve(ivl, x(convolution_point)));
ivl = vertical(rectangle);
vertical(rectangle, convolve(ivl, y(convolution_point)));
@@ -478,7 +480,7 @@
typename gtl_and_3<y_r_deconvolve2, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type, rectangle_type>::type &
deconvolve(rectangle_type& rectangle, const point_type& convolution_point) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = horizontal(rectangle);
+ typename rectangle_interval_type<rectangle_type>::type ivl = horizontal(rectangle);
horizontal(rectangle, deconvolve(ivl, x(convolution_point)));
ivl = vertical(rectangle);
vertical(rectangle, deconvolve(ivl, y(convolution_point)));
@@ -489,7 +491,7 @@
// get the magnitude of the interval range depending on orient
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_delta, typename gtl_if<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_delta, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
delta(const rectangle_type& rectangle, orientation_2d orient) {
return delta(get(rectangle, orient));
@@ -500,9 +502,9 @@
// get the area of the rectangle
template <typename rectangle_type>
typename enable_if< typename gtl_and<y_r_area, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::manhattan_area_type>::type
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::manhattan_area_type>::type
area(const rectangle_type& rectangle) {
- typedef typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::manhattan_area_type area_type;
+ typedef typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::manhattan_area_type area_type;
return (area_type)delta(rectangle, HORIZONTAL) * (area_type)delta(rectangle, VERTICAL);
}
@@ -521,18 +523,19 @@
// get the half perimeter of the rectangle
template <typename rectangle_type>
- typename enable_if< typename gtl_and<y_r_half_p, typename gtl_if<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type>::type,
+ typename enable_if< typename gtl_and<y_r_half_p, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
half_perimeter(const rectangle_type& rectangle) {
return delta(rectangle, HORIZONTAL) + delta(rectangle, VERTICAL);
}
-
+
+ struct y_r_perimeter : gtl_yes {};
+
// get the perimeter of the rectangle
template <typename rectangle_type>
- typename rectangle_difference_type<rectangle_type>::type
- perimeter(const rectangle_type& rectangle,
- typename enable_if< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and<y_r_perimeter, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
+ typename rectangle_difference_type<rectangle_type>::type>::type
+ perimeter(const rectangle_type& rectangle) {
return 2 * half_perimeter(rectangle);
}
@@ -623,7 +626,7 @@
bool>::type
intersect(rectangle_type& rectangle, const interval_type& b,
orientation_2d orient, bool consider_touch = true) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orient);
+ typename rectangle_interval_type<rectangle_type>::type ivl = get(rectangle, orient);
if(intersect(ivl, b, consider_touch)) {
set(rectangle, orient, ivl);
return true;
@@ -656,7 +659,7 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type>::type,
rectangle_type_1>::type &
generalized_intersect(rectangle_type_1& rectangle, const rectangle_type_2& b) {
- typename rectangle_traits<rectangle_type_1>::interval_type ivl = get(rectangle, HORIZONTAL);
+ typename rectangle_interval_type<rectangle_type_1>::type ivl = get(rectangle, HORIZONTAL);
generalized_intersect(ivl, horizontal(b));
horizontal(rectangle, ivl);
ivl = vertical(rectangle);
@@ -672,8 +675,8 @@
typename enable_if<typename gtl_and<y_r_bloat, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
bloat(rectangle_type& rectangle, orientation_2d orient,
- typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orient);
+ typename rectangle_coordinate_type<rectangle_type>::type bloating) {
+ typename rectangle_interval_type<rectangle_type>::type ivl = get(rectangle, orient);
bloat(ivl, bloating);
set(rectangle, orient, ivl);
return rectangle;
@@ -686,7 +689,7 @@
typename enable_if<typename gtl_and<y_r_bloat2, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
bloat(rectangle_type& rectangle,
- typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
+ typename rectangle_coordinate_type<rectangle_type>::type bloating) {
bloat(rectangle, HORIZONTAL, bloating);
return bloat(rectangle, VERTICAL, bloating);
}
@@ -698,8 +701,8 @@
typename enable_if<typename gtl_and<y_r_bloat3, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
bloat(rectangle_type& rectangle, direction_2d dir,
- typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orientation_2d(dir));
+ typename rectangle_coordinate_type<rectangle_type>::type bloating) {
+ typename rectangle_interval_type<rectangle_type>::type ivl = get(rectangle, orientation_2d(dir));
bloat(ivl, direction_1d(dir), bloating);
set(rectangle, orientation_2d(dir), ivl);
return rectangle;
@@ -712,7 +715,7 @@
typename enable_if<typename gtl_and<y_r_shrink, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
shrink(rectangle_type& rectangle, orientation_2d orient,
- typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
+ typename rectangle_coordinate_type<rectangle_type>::type shrinking) {
return bloat(rectangle, orient, -shrinking);
}
@@ -723,7 +726,7 @@
typename enable_if<typename gtl_and<y_r_shrink2, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
shrink(rectangle_type& rectangle,
- typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
+ typename rectangle_coordinate_type<rectangle_type>::type shrinking) {
return bloat(rectangle, -shrinking);
}
@@ -734,7 +737,7 @@
typename enable_if<typename gtl_and<y_r_shrink3, typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
shrink(rectangle_type& rectangle, direction_2d dir,
- typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
+ typename rectangle_coordinate_type<rectangle_type>::type shrinking) {
return bloat(rectangle, dir, -shrinking);
}
@@ -742,13 +745,13 @@
// encompass interval on orient
template <typename rectangle_type, typename interval_type>
- typename enable_if<
- typename gtl_and_3<y_r_encompass, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
- bool>::type
- encompass(rectangle_type& rectangle, const interval_type& b,
- orientation_2d orient) {
- typename rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orient);
+ typename enable_if<typename gtl_and_3<
+ y_r_encompass,
+ typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+ bool>::type
+ encompass(rectangle_type& rectangle, const interval_type& b, orientation_2d orient) {
+ typename rectangle_interval_type<rectangle_type>::type ivl = get(rectangle, orient);
if(encompass(ivl, b)) {
set(rectangle, orient, ivl);
return true;
@@ -760,12 +763,12 @@
// enlarge rectangle to encompass the Rectangle b
template <typename rectangle_type_1, typename rectangle_type_2>
- bool
- encompass(rectangle_type_1& rectangle, const rectangle_type_2& b,
- typename enable_if< typename gtl_and_3<y_r_encompass2,
- typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
- typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type >::type>::type * = 0
- ) {
+ typename enable_if< typename gtl_and_3<
+ y_r_encompass2,
+ typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type >::type,
+ bool>::type
+ encompass(rectangle_type_1& rectangle, const rectangle_type_2& b) {
//note that operator | is intentional because both should be called regardless
return encompass(rectangle, horizontal(b), HORIZONTAL) |
encompass(rectangle, vertical(b), VERTICAL);
@@ -775,16 +778,13 @@
// enlarge rectangle to encompass the point b
template <typename rectangle_type_1, typename point_type>
- typename enable_if<
- typename gtl_and_3<y_r_encompass3, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
- bool>::type
- encompass(rectangle_type_1& rectangle, const point_type& b,
- typename enable_if<
- typename gtl_and< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type>::type * = 0
- ) {
- typename rectangle_traits<rectangle_type_1>::interval_type hivl, vivl;
+ typename enable_if<typename gtl_and_3<
+ y_r_encompass3,
+ typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+ bool>::type
+ encompass(rectangle_type_1& rectangle, const point_type& b) {
+ typename rectangle_interval_type<rectangle_type_1>::type hivl, vivl;
hivl = horizontal(rectangle);
vivl = vertical(rectangle);
//note that operator | is intentional because both should be called regardless
@@ -818,7 +818,7 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
bool>::type
get_corner(point_type& corner_point, const rectangle_type& rectangle, direction_2d direction_facing, direction_1d direction_turning) {
- typedef typename rectangle_traits<rectangle_type>::coordinate_type Unit;
+ typedef typename rectangle_coordinate_type<rectangle_type>::type Unit;
Unit u1 = get(rectangle, direction_facing);
Unit u2 = get(rectangle, direction_facing.turn(direction_turning));
if(orientation_2d(direction_facing).to_int()) std::swap(u1, u2);
@@ -844,8 +844,8 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type>::type,
bool>::type
join_with(rectangle_type_1& rectangle, const rectangle_type_2& b) {
- typedef typename rectangle_traits<rectangle_type_1>::interval_type Interval1;
- typedef typename rectangle_traits<rectangle_type_2>::interval_type Interval2;
+ typedef typename rectangle_interval_type<rectangle_type_1>::type Interval1;
+ typedef typename rectangle_interval_type<rectangle_type_2>::type Interval2;
Interval1 hi1 = get(rectangle, HORIZONTAL);
Interval1 vi1 = get(rectangle, VERTICAL);
Interval2 hi2 = get(b, HORIZONTAL), vi2 = get(b, VERTICAL);
@@ -887,12 +887,12 @@
struct y_r_sed : gtl_yes {};
template <typename rectangle_type, typename point_type>
- typename enable_if< typename gtl_if< typename gtl_and_3<y_r_sed,
+ typename enable_if< typename gtl_and_3<y_r_sed,
typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
square_euclidean_distance(rectangle_type& lvalue, const point_type& rvalue) {
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference xdist, ydist;
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::coordinate_difference xdist, ydist;
xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
return (xdist * xdist) + (ydist * ydist);
@@ -906,7 +906,7 @@
typename is_rectangle_concept< typename geometry_concept<rectangle_type_2>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
square_euclidean_distance(const rectangle_type& lvalue, const rectangle_type_2& rvalue) {
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference xdist, ydist;
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::coordinate_difference xdist, ydist;
xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
return (xdist * xdist) + (ydist * ydist);
@@ -942,7 +942,7 @@
typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
manhattan_distance(rectangle_type& lvalue, const point_type& rvalue) {
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference xdist, ydist;
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::coordinate_difference xdist, ydist;
xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
return xdist + ydist;
@@ -956,7 +956,7 @@
typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type>::type,
typename rectangle_difference_type<rectangle_type>::type>::type
manhattan_distance(const rectangle_type& lvalue, const rectangle_type_2& rvalue) {
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference xdist, ydist;
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::coordinate_difference xdist, ydist;
xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
return xdist + ydist;
@@ -968,7 +968,7 @@
typename enable_if<typename gtl_and<y_r_scale_up, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
scale_up(rectangle_type& rectangle,
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::unsigned_area_type factor) {
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::unsigned_area_type factor) {
horizontal(rectangle, scale_up(horizontal(rectangle), factor));
vertical(rectangle, scale_up(vertical(rectangle), factor));
return rectangle;
@@ -980,7 +980,7 @@
typename enable_if<typename gtl_and<y_r_scale_down, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
scale_down(rectangle_type& rectangle,
- typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::unsigned_area_type factor) {
+ typename coordinate_traits<typename rectangle_coordinate_type<rectangle_type>::type>::unsigned_area_type factor) {
horizontal(rectangle, scale_down(horizontal(rectangle), factor));
vertical(rectangle, scale_down(vertical(rectangle), factor));
return rectangle;
@@ -992,8 +992,8 @@
typename enable_if<typename gtl_and<y_r_scale, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
scale(rectangle_type& rectangle, const scaling_type& scaling) {
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> llp(xl(rectangle), yl(rectangle));
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> urp(xl(rectangle), yl(rectangle));
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> llp(xl(rectangle), yl(rectangle));
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> urp(xl(rectangle), yl(rectangle));
scale(llp, scaling);
scale(urp, scaling);
set_points(rectangle, llp, urp);
@@ -1006,8 +1006,8 @@
typename enable_if<typename gtl_and<y_r_transform, typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
rectangle_type>::type &
transform(rectangle_type& rectangle, const transformation_type& transformation) {
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> llp(xl(rectangle), yl(rectangle));
- point_data<typename rectangle_traits<rectangle_type>::coordinate_type> urp(xh(rectangle), yh(rectangle));
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> llp(xl(rectangle), yl(rectangle));
+ point_data<typename rectangle_coordinate_type<rectangle_type>::type> urp(xh(rectangle), yh(rectangle));
transform(llp, transformation);
transform(urp, transformation);
set_points(rectangle, llp, urp);
@@ -1026,7 +1026,7 @@
bool>::type
operator () (const rectangle_type_1& a,
const rectangle_type_2& b) const {
- typedef typename rectangle_traits<rectangle_type_1>::coordinate_type Unit;
+ typedef typename rectangle_coordinate_type<rectangle_type_1>::type Unit;
Unit vl1 = get(get(a, orient_), LOW);
Unit vl2 = get(get(b, orient_), LOW);
if(vl1 > vl2) return false;
Added: trunk/boost/polygon/segment_concept.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/segment_concept.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,735 @@
+/*
+ Copyright 2008 Intel Corporation
+
+ Use, modification and distribution are subject to the Boost Software License,
+ Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_SEGMENT_CONCEPT_HPP
+#define BOOST_POLYGON_SEGMENT_CONCEPT_HPP
+#include "isotropy.hpp"
+#include "segment_data.hpp"
+#include "segment_traits.hpp"
+#include "rectangle_concept.hpp"
+#include "detail/polygon_arbitrary_formation.hpp"
+
+namespace boost { namespace polygon{
+ struct segment_concept {};
+
+ template <typename Segment>
+ struct is_segment_concept { typedef gtl_no type; };
+
+ template <>
+ struct is_segment_concept<segment_concept> {
+ typedef gtl_yes type;
+ };
+
+ template <typename Segment>
+ struct is_mutable_segment_concept { typedef gtl_no type; };
+
+ template <>
+ struct is_mutable_segment_concept<segment_concept> {
+ typedef gtl_yes type;
+ };
+
+ template <typename Segment, typename CT>
+ struct segment_distance_type_by_concept {
+ typedef void type;
+ };
+
+ template <typename Segment>
+ struct segment_distance_type_by_concept<Segment, gtl_yes> {
+ typedef typename coordinate_traits<
+ typename segment_traits<Segment>::coordinate_type
+ >::coordinate_distance type;
+ };
+
+ template <typename Segment>
+ struct segment_distance_type {
+ typedef typename segment_distance_type_by_concept<
+ Segment,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type type;
+ };
+
+ template <typename Segment, typename CT>
+ struct segment_point_type_by_concept { typedef void type; };
+
+ template <typename Segment>
+ struct segment_point_type_by_concept<Segment, gtl_yes> {
+ typedef typename segment_traits<Segment>::point_type type;
+ };
+
+ template <typename Segment>
+ struct segment_point_type {
+ typedef typename segment_point_type_by_concept<
+ Segment,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type type;
+ };
+
+ template <typename Segment, typename CT>
+ struct segment_coordinate_type_by_concept {
+ typedef void type;
+ };
+
+ template <typename Segment>
+ struct segment_coordinate_type_by_concept<Segment, gtl_yes> {
+ typedef typename segment_traits<Segment>::coordinate_type type;
+ };
+
+ template <typename Segment>
+ struct segment_coordinate_type {
+ typedef typename segment_coordinate_type_by_concept<
+ Segment,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type type;
+ };
+
+ struct y_s_get : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_get,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ typename segment_point_type<Segment>::type
+ >::type
+ get(const Segment& segment, direction_1d dir) {
+ return segment_traits<Segment>::get(segment, dir);
+ }
+
+ struct y_s_set : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_set,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ void
+ >::type
+ set(Segment& segment, direction_1d dir, const Point& point) {
+ segment_mutable_traits<Segment>::set(segment, dir, point);
+ }
+
+ struct y_s_construct : gtl_yes {};
+
+ template <typename Segment, typename Point1, typename Point2>
+ typename enable_if<
+ typename gtl_and_4<
+ y_s_construct,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point1>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point2>::type
+ >::type
+ >::type,
+ Segment
+ >::type
+ construct(const Point1& low, const Point2& high) {
+ return segment_mutable_traits<Segment>::construct(low, high);
+ }
+
+ struct y_s_copy_construct : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_copy_construct,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ Segment1
+ >::type
+ copy_construct(const Segment2& segment) {
+ return construct<Segment1>(get(segment, LOW), get(segment, HIGH));
+ }
+
+ struct y_s_assign : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_assign,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ Segment1
+ >::type &
+ assign(Segment1& segment1, const Segment2& segment2) {
+ return segment1 = copy_construct<Segment1>(segment2);
+ }
+
+ struct y_s_equivalence : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_equivalence,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ equivalence(const Segment1& segment1, const Segment2& segment2) {
+ return get(segment1, LOW) == get(segment2, LOW) &&
+ get(segment1, HIGH) == get(segment2, HIGH);
+ }
+
+ struct y_s_low : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_low,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ typename segment_point_type<Segment>::type
+ >::type
+ low(const Segment& segment) {
+ return get(segment, LOW);
+ }
+
+ struct y_s_high : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_high,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ typename segment_point_type<Segment>::type
+ >::type
+ high(const Segment& segment) {
+ return get(segment, HIGH);
+ }
+
+ struct y_s_center : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_center,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ typename segment_point_type<Segment>::type
+ >::type
+ center(const Segment& segment) {
+ return construct<typename segment_point_type<Segment>::type>(
+ (x(high(segment)) + x(low(segment)))/2,
+ (y(high(segment)) + y(low(segment)))/2);
+ }
+
+ struct y_s_low2 : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_low2,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ void
+ >::type
+ low(Segment& segment, const Point& point) {
+ set(segment, LOW, point);
+ }
+
+ struct y_s_high2 : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_high2,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ void
+ >::type
+ high(Segment& segment, const Point& point) {
+ set(segment, HIGH, point);
+ }
+
+ struct y_s_on_above_or_below : gtl_yes {};
+
+ // -1 for below, 0 for on and 1 for above
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_on_above_or_below,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ int
+ >::type
+ on_above_or_below(const Segment& segment, const Point& point) {
+ typedef polygon_arbitrary_formation<
+ typename segment_coordinate_type<Segment>::type
+ > paf;
+ typename paf::Point pt, l, h;
+ assign(pt, point);
+ assign(l, low(segment));
+ assign(h, high(segment));
+ return paf::on_above_or_below(pt, typename paf::half_edge(l, h));
+ }
+
+ struct y_s_contains : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_contains,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ contains(const Segment& segment, const Point& point, bool consider_touch = true ) {
+ if (!on_above_or_below(segment, point)) {
+ rectangle_data<typename segment_coordinate_type<Segment>::type> rect;
+ set_points(rect, low(segment), high(segment));
+ if (area(rect) == 0.0) {
+ if (!consider_touch) {
+ return !equivalence(point, low(segment)) &&
+ !equivalence(point, high(segment));
+ }
+ }
+ return contains(rect, point, consider_touch);
+ }
+ return false;
+ }
+
+ struct y_s_contains2 : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_contains2,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ contains(const Segment1& segment1, const Segment2& segment2, bool consider_touch = true) {
+ return contains(segment1, get(segment2, LOW), consider_touch) &&
+ contains(segment1, get(segment2, HIGH), consider_touch);
+ }
+
+ struct y_s_length : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_length,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ typename segment_distance_type<Segment>::type
+ >::type
+ length(const Segment& segment) {
+ return euclidean_distance(low(segment), high(segment));
+ }
+
+ struct y_s_scale_up : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_scale_up,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ scale_up(Segment& segment,
+ typename coordinate_traits<
+ typename segment_coordinate_type<Segment>::type
+ >::unsigned_area_type factor) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, scale_up(l, factor));
+ high(segment, scale_up(h, factor));
+ return segment;
+ }
+
+ struct y_s_scale_down : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_scale_down,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ scale_down(Segment& segment,
+ typename coordinate_traits<
+ typename segment_coordinate_type<Segment>::type
+ >::unsigned_area_type factor) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, scale_down(l, factor));
+ high(segment, scale_down(h, factor));
+ return segment;
+ }
+
+ struct y_s_scale : gtl_yes {};
+
+ template <typename Segment, typename Scale>
+ typename enable_if<
+ typename gtl_and<
+ y_s_scale,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ scale(Segment& segment, const Scale& sc) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, scale(l, sc));
+ high(segment, scale(h, sc));
+ return segment;
+ }
+
+ struct y_s_transform : gtl_yes {};
+
+ template <typename Segment, typename Transform>
+ typename enable_if<
+ typename gtl_and<
+ y_s_transform,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ transform(Segment& segment, const Transform& tr) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, transform(l, tr));
+ high(segment, transform(h, tr));
+ return segment;
+ }
+
+ struct y_s_move : gtl_yes {};
+
+ template <typename Segment>
+ typename enable_if<
+ typename gtl_and<
+ y_s_move,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ move(Segment& segment, orientation_2d orient,
+ typename segment_coordinate_type<Segment>::type displacement) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, move(l, orient, displacement));
+ high(segment, move(h, orient, displacement));
+ return segment;
+ }
+
+ struct y_s_convolve : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_convolve,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ convolve(Segment& segment, const Point& point) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, convolve(l, point));
+ high(segment, convolve(h, point));
+ return segment;
+ }
+
+ struct y_s_deconvolve : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_deconvolve,
+ typename is_mutable_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ Segment
+ >::type &
+ deconvolve(Segment& segment, const Point& point) {
+ typename segment_point_type<Segment>::type l = low(segment), h = high(segment);
+ low(segment, deconvolve(l, point));
+ high(segment, deconvolve(h, point));
+ return segment;
+ }
+
+ struct y_s_abuts1 : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_abuts1,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ abuts(const Segment1& segment1, const Segment2& segment2, direction_1d dir) {
+ return dir.to_int() ? equivalence(low(segment2) , high(segment1)) :
+ equivalence(low(segment1) , high(segment2));
+ }
+
+ struct y_s_abuts2 : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_abuts2,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ abuts(const Segment1& segment1, const Segment2& segment2) {
+ return abuts(segment1, segment2, HIGH) || abuts(segment1, segment2, LOW);
+ }
+
+ struct y_s_e_intersects : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_e_intersects,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ intersects(const Segment1& segment1, const Segment2& segment2,
+ bool consider_touch = true) {
+ if (consider_touch) {
+ if (low(segment1) == low(segment2) || low(segment1) == high(segment2) ||
+ high(segment1) == low(segment2) || high(segment1) == high(segment2))
+ return true;
+ }
+ typedef polygon_arbitrary_formation<
+ typename segment_coordinate_type<Segment1>::type
+ > paf;
+ typename paf::Point l1, h1, l2, h2;
+ assign(l1, low(segment1));
+ assign(h1, high(segment1));
+ assign(l2, low(segment2));
+ assign(h2, high(segment2));
+ return paf::intersects(typename paf::half_edge(l1, h1),
+ typename paf::half_edge(l2, h2));
+ }
+
+ struct y_s_intersect : gtl_yes {};
+
+ // Set point to the intersection of segment and b
+ template <typename Point, typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_4<
+ y_s_intersect,
+ typename is_mutable_point_concept<
+ typename geometry_concept<Point>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ intersection(Point& intersection,
+ const Segment1& segment1,
+ const Segment2& segment2,
+ bool projected = false,
+ bool round_closest = false) {
+ typedef polygon_arbitrary_formation<
+ typename segment_coordinate_type<Segment1>::type
+ > paf;
+ typename paf::Point pt;
+ typename paf::Point l1, h1, l2, h2;
+ assign(l1, low(segment1));
+ assign(h1, high(segment1));
+ assign(l2, low(segment2));
+ assign(h2, high(segment2));
+ typename paf::half_edge he1(l1, h1), he2(l2, h2);
+ typename paf::compute_intersection_pack pack;
+ if (pack.compute_intersection(pt, he1, he2, projected, round_closest)) {
+ assign(intersection, pt);
+ return true;
+ }
+ return false;
+ }
+
+ struct y_s_e_dist : gtl_yes {};
+
+ template <typename Segment, typename Point>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_e_dist,
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type,
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ typename segment_distance_type<Segment>::type
+ >::type
+ euclidean_distance(const Segment& segment, const Point& point) {
+ typedef typename segment_distance_type<Segment>::type Unit;
+ Unit x1 = x(low(segment));
+ Unit y1 = y(low(segment));
+ Unit x2 = x(high(segment));
+ Unit y2 = y(high(segment));
+ Unit X = x(point);
+ Unit Y = y(point);
+ Unit A = X - x1;
+ Unit B = Y - y1;
+ Unit C = x2 - x1;
+ Unit D = y2 - y1;
+ Unit param = (A * C + B * D);
+ Unit length_sq = C * C + D * D;
+ if (param > length_sq) {
+ return euclidean_distance(high(segment), point);
+ } else if (param < 0.0) {
+ return euclidean_distance(low(segment), point);
+ }
+ if (length_sq == 0.0)
+ return 0.0;
+ Unit denom = sqrt(length_sq);
+ Unit result = (A * D - C * B) / denom;
+ return (result < 0.0) ? -result : result;
+ }
+
+ struct y_s_e_dist2 : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_e_dist2,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ typename segment_distance_type<Segment1>::type
+ >::type
+ euclidean_distance(const Segment1& segment1, const Segment2& segment2) {
+ if (intersects(segment1, segment2))
+ return 0.0;
+ typename segment_distance_type<Segment1>::type
+ result1 = euclidean_distance(segment1, low(segment2)),
+ result2 = euclidean_distance(segment1, high(segment2)),
+ result3 = euclidean_distance(segment2, low(segment1)),
+ result4 = euclidean_distance(segment2, high(segment1));
+ typename segment_distance_type<Segment1>::type
+ subres1 = (result1 < result2) ? result1 : result2,
+ subres2 = (result3 < result4) ? result3 : result4;
+ return (subres1 < subres2) ? subres1 : subres2;
+ }
+
+ template <class T>
+ template <class Segment>
+ segment_data<T>& segment_data<T>::operator=(const Segment& rvalue) {
+ assign(*this, rvalue);
+ return *this;
+ }
+
+ template <typename T>
+ struct geometry_concept<segment_data<T> > {
+ typedef segment_concept type;
+ };
+}
+}
+#endif
Added: trunk/boost/polygon/segment_data.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/segment_data.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,106 @@
+/*
+ Copyright 2008 Intel Corporation
+
+ Use, modification and distribution are subject to the Boost Software License,
+ Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_SEGMENT_DATA_HPP
+#define BOOST_POLYGON_SEGMENT_DATA_HPP
+
+#include "isotropy.hpp"
+
+namespace boost { namespace polygon{
+ template <typename T>
+ class segment_data {
+ public:
+ typedef T coordinate_type;
+ typedef point_data<T> point_type;
+
+ inline segment_data()
+#ifndef BOOST_POLYGON_MSVC
+ :points_()
+#endif
+ {}
+
+ inline segment_data(const point_type& low, const point_type& high)
+#ifndef BOOST_POLYGON_MSVC
+ :points_()
+#endif
+ {
+ points_[LOW] = low; points_[HIGH] = high;
+ }
+
+ inline segment_data(const segment_data& that)
+#ifndef BOOST_POLYGON_MSVC
+ :points_()
+#endif
+ {
+ (*this) = that;
+ }
+
+ inline segment_data& operator=(const segment_data& that) {
+ points_[0] = that.points_[0];
+ points_[1] = that.points_[1];
+ return *this;
+ }
+
+ template <typename Segment>
+ inline segment_data& operator=(const Segment& that);
+
+ inline point_type get(direction_1d dir) const {
+ return points_[dir.to_int()];
+ }
+
+ inline void set(direction_1d dir, const point_type& point) {
+ points_[dir.to_int()] = point;
+ }
+
+ inline point_type low() const { return points_[0]; }
+
+ inline segment_data& low(const point_type& point) {
+ points_[0] = point;
+ return *this;
+ }
+
+ inline point_type high() const {return points_[1]; }
+
+ inline segment_data& high(const point_type& point) {
+ points_[1] = point;
+ return *this;
+ }
+
+ inline bool operator==(const segment_data& that) const {
+ return low() == that.low() && high() == that.high();
+ }
+
+ inline bool operator!=(const segment_data& that) const {
+ return low() != that.low() || high() != that.high();
+ }
+
+ inline bool operator<(const segment_data& that) const {
+ if (points_[0] < that.points_[0])
+ return true;
+ if (points_[0] > that.points_[0])
+ return false;
+ return points_[1] < that.points_[1];
+ }
+
+ inline bool operator<=(const segment_data& that) const {
+ return !(that < *this);
+ }
+
+ inline bool operator>(const segment_data& that) const {
+ return that < *this;
+ }
+
+ inline bool operator>=(const segment_data& that) const {
+ return !((*this) < that);
+ }
+
+ private:
+ point_type points_[2];
+};
+}
+}
+#endif
Added: trunk/boost/polygon/segment_traits.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/segment_traits.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,35 @@
+/*
+ Copyright 2008 Intel Corporation
+
+ Use, modification and distribution are subject to the Boost Software License,
+ Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_SEGMENT_TRAITS_HPP
+#define BOOST_POLYGON_SEGMENT_TRAITS_HPP
+namespace boost { namespace polygon{
+ template <typename Segment>
+ struct segment_traits {
+ typedef typename Segment::coordinate_type coordinate_type;
+ typedef typename Segment::point_type point_type;
+
+ static inline point_type get(const Segment& segment, direction_1d dir) {
+ return segment.get(dir);
+ }
+ };
+
+ template <typename Segment>
+ struct segment_mutable_traits {
+ typedef typename segment_traits<Segment>::point_type point_type;
+
+ static inline void set(Segment& segment, direction_1d dir, const point_type& point) {
+ segment.set(dir, point);
+ }
+
+ static inline Segment construct(const point_type& low, const point_type& high) {
+ return Segment(low, high);
+ }
+ };
+}
+}
+#endif
Added: trunk/boost/polygon/voronoi.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/voronoi.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,164 @@
+// Boost.Polygon library voronoi.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_VORONOI
+#define BOOST_POLYGON_VORONOI
+
+#include "polygon.hpp"
+#include "voronoi_builder.hpp"
+#include "voronoi_diagram.hpp"
+
+// Public methods to compute Voronoi diagram.
+// PC - container of input points (should supports forward iterator).
+// SC - container of input segments (should supports forward iterator).
+// output - Voronoi output data structure to hold Voronoi diagram.
+// Segment class should provide low(), high() methods to access its endpoints.
+// The assumption is made that input doesn't contain segments that intersect
+// or points lying on the segments. Also coordinates of the points and of the
+// endpoints of the segments should belong to the signed integer range
+// [-2^31, 2^31-1]. To use wider input coordinate range use voronoi_builder
+// structure with user provided coordinate type traits.
+// Complexity - O(N*logN), memory usage - O(N),
+// where N is the total number of points and segments.
+namespace boost {
+namespace polygon {
+
+template <typename Point, typename VB>
+static inline
+typename enable_if<
+ typename gtl_if<
+ typename is_point_concept<
+ typename geometry_concept<Point>::type
+ >::type
+ >::type,
+ void
+>::type
+insert(const Point &point, VB *vb) {
+ vb->insert_point(x(point), y(point));
+}
+
+
+template <typename PointIterator, typename VB>
+static inline
+typename enable_if<
+ typename gtl_if<
+ typename is_point_concept<
+ typename geometry_concept<
+ typename std::iterator_traits<PointIterator>::value_type
+ >::type
+ >::type
+ >::type,
+ void
+>::type
+insert(PointIterator first, const PointIterator last, VB *vb) {
+ for (PointIterator it = first; it != last; ++it) {
+ insert(*it, vb);
+ }
+}
+
+template <typename Segment, typename VB>
+static inline
+typename enable_if<
+ typename gtl_if<
+ typename is_segment_concept<
+ typename geometry_concept<Segment>::type
+ >::type
+ >::type,
+ void
+>::type
+insert(const Segment &segment, VB *vb) {
+ vb->insert_segment(x(low(segment)), y(low(segment)), x(high(segment)), y(high(segment)));
+}
+
+template <typename SegmentIterator, typename VB>
+static inline
+typename enable_if<
+ typename gtl_if<
+ typename is_segment_concept<
+ typename geometry_concept<
+ typename std::iterator_traits<SegmentIterator>::value_type
+ >::type
+ >::type
+ >::type,
+ void
+>::type
+insert(SegmentIterator first, SegmentIterator last, VB *vb) {
+ for (SegmentIterator it = first; it != last; ++it) {
+ insert(*it, vb);
+ }
+}
+
+template <typename PointIterator, typename VD>
+static inline
+typename enable_if<
+ typename gtl_if<
+ typename is_point_concept<
+ typename geometry_concept<
+ typename std::iterator_traits<PointIterator>::value_type
+ >::type
+ >::type
+ >::type,
+ void
+>::type
+construct_voronoi(PointIterator first, PointIterator last, VD *vd) {
+ default_voronoi_builder builder;
+ insert(first, last, &builder);
+ builder.construct(vd);
+}
+
+template <typename SegmentIterator, typename VD>
+static inline
+typename enable_if<
+ typename gtl_if<
+ typename is_segment_concept<
+ typename geometry_concept<
+ typename std::iterator_traits<SegmentIterator>::value_type
+ >::type
+ >::type
+ >::type,
+ void
+>::type
+construct_voronoi(SegmentIterator first, SegmentIterator last, VD *vd) {
+ default_voronoi_builder builder;
+ insert(first, last, &builder);
+ builder.construct(vd);
+}
+
+template <typename PointIterator, typename SegmentIterator, typename VD>
+static inline
+typename enable_if<
+ typename gtl_and<
+ typename gtl_if<
+ typename is_point_concept<
+ typename geometry_concept<
+ typename std::iterator_traits<PointIterator>::value_type
+ >::type
+ >::type
+ >::type,
+ typename gtl_if<
+ typename is_segment_concept<
+ typename geometry_concept<
+ typename std::iterator_traits<SegmentIterator>::value_type
+ >::type
+ >::type
+ >::type
+ >::type,
+ void
+>::type
+construct_voronoi(PointIterator p_first, PointIterator p_last,
+ SegmentIterator s_first, SegmentIterator s_last, VD *vd) {
+ default_voronoi_builder builder;
+ insert(p_first, p_last, &builder);
+ insert(s_first, s_last, &builder);
+ builder.construct(vd);
+}
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_VORONOI
Added: trunk/boost/polygon/voronoi_builder.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/voronoi_builder.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,506 @@
+// Boost.Polygon library voronoi_builder.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_VORONOI_BUILDER
+#define BOOST_POLYGON_VORONOI_BUILDER
+
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include "detail/voronoi_ctypes.hpp"
+#include "detail/voronoi_predicates.hpp"
+#include "detail/voronoi_structures.hpp"
+
+namespace boost {
+namespace polygon {
+// GENERAL INFO:
+// The sweepline algorithm implementation to compute Voronoi diagram of
+// points and non-intersecting segments (except endpoints).
+// Complexity - O(N*logN), memory usage - O(N), where N is the total number
+// of input geometries. Input geometries should have integer coordinate type.
+//
+// IMPLEMENTATION DETAILS:
+// Each input point creates one site event. Each input segment creates three
+// site events: two for its endpoints and one for the segment itself (this is
+// made to simplify output construction). All the site events are constructed
+// and sorted at the algorithm initialization step. Priority queue is used to
+// dynamically hold circle events. At each step of the algorithm execution the
+// leftmost event is retrieved by comparing the current site event and the
+// topmost element from the circle event queue. STL map (red-black tree)
+// container was chosen to hold state of the beach line. The keys of the map
+// correspond to the neighboring sites that form a bisector and values to the
+// corresponding Voronoi edge in the output data structure.
+template <typename T,
+ typename CTT = detail::voronoi_ctype_traits<T>,
+ typename VP = detail::voronoi_predicates<CTT> >
+class voronoi_builder {
+public:
+ typedef typename CTT::int_type int_type;
+ typedef typename CTT::fpt_type fpt_type;
+
+ voronoi_builder() {}
+
+ // Each point creates a single site event.
+ void insert_point(const int_type& x, const int_type& y) {
+ site_events_.push_back(site_event_type(x, y));
+ }
+
+ // Each segment creates three site events that correspond to:
+ // 1) the start point of the segment;
+ // 2) the end point of the segment;
+ // 3) the segment itself defined by its start point.
+ void insert_segment(const int_type& x1, const int_type& y1,
+ const int_type& x2, const int_type& y2) {
+ point_type p1(x1, y1);
+ point_type p2(x2, y2);
+ site_events_.push_back(site_event_type(p1));
+ site_events_.push_back(site_event_type(p2));
+ if (point_comparison_(p1, p2)) {
+ site_events_.push_back(site_event_type(p1, p2));
+ } else {
+ site_events_.push_back(site_event_type(p2, p1));
+ }
+ }
+
+ // Run sweepline algorithm and fill output data structure.
+ template <typename OUTPUT>
+ void construct(OUTPUT *output) {
+ // Init structures.
+ output->builder()->reserve(site_events_.size());
+ init_sites_queue();
+ if (!circle_events_.empty())
+ circle_events_.clear();
+ while (!end_points_.empty())
+ end_points_.pop();
+ init_beach_line(output);
+
+ // The algorithm stops when there are no events to process.
+ event_comparison_predicate event_comparison;
+ while (!circle_events_.empty() ||
+ !(site_event_iterator_ == site_events_.end())) {
+ if (circle_events_.empty()) {
+ process_site_event(output);
+ } else if (site_event_iterator_ == site_events_.end()) {
+ process_circle_event(output);
+ } else {
+ if (event_comparison(*site_event_iterator_,
+ circle_events_.top().first)) {
+ process_site_event(output);
+ } else {
+ process_circle_event(output);
+ }
+ }
+ while (!circle_events_.empty() &&
+ !circle_events_.top().first.is_active()) {
+ circle_events_.pop();
+ }
+ }
+ beach_line_.clear();
+
+ // Finish construction.
+ output->builder()->build();
+ }
+
+ void clear() {
+ site_events_.clear();
+ if (!beach_line_.empty())
+ beach_line_.clear();
+ if (!circle_events_.empty())
+ circle_events_.clear();
+ while (!end_points_.empty())
+ end_points_.pop();
+ }
+
+private:
+ typedef detail::point_2d<int_type> point_type;
+ typedef detail::site_event<int_type> site_event_type;
+ typedef typename std::vector<site_event_type>::const_iterator
+ site_event_iterator_type;
+ typedef detail::circle_event<fpt_type> circle_event_type;
+ typedef typename VP::template point_comparison_predicate<point_type>
+ point_comparison_predicate;
+ typedef typename VP::
+ template event_comparison_predicate<site_event_type, circle_event_type>
+ event_comparison_predicate;
+ typedef typename VP::
+ template circle_formation_predicate<site_event_type, circle_event_type>
+ circle_formation_predicate_type;
+ typedef void edge_type;
+ typedef detail::beach_line_node_key<site_event_type> key_type;
+ typedef detail::beach_line_node_data<edge_type, circle_event_type>
+ value_type;
+ typedef typename VP::template node_comparison_predicate<key_type>
+ node_comparer_type;
+ typedef std::map< key_type, value_type, node_comparer_type > beach_line_type;
+ typedef typename beach_line_type::iterator beach_line_iterator;
+ typedef std::pair<circle_event_type, beach_line_iterator> event_type;
+ typedef struct {
+ bool operator()(const event_type &lhs, const event_type &rhs) const {
+ return predicate(rhs.first, lhs.first);
+ }
+ event_comparison_predicate predicate;
+ } event_comparison_type;
+ typedef detail::ordered_queue<event_type, event_comparison_type>
+ circle_event_queue_type;
+ typedef std::pair<point_type, beach_line_iterator> end_point_type;
+
+ void init_sites_queue() {
+ // Sort site events.
+ sort(site_events_.begin(), site_events_.end(),
+ event_comparison_predicate());
+
+ // Remove duplicates.
+ site_events_.erase(unique(
+ site_events_.begin(), site_events_.end()), site_events_.end());
+
+ // Index sites.
+ for (size_t cur = 0; cur < site_events_.size(); ++cur)
+ site_events_[cur].index(cur);
+
+ // Init site iterator.
+ site_event_iterator_ = site_events_.begin();
+ }
+
+ template <typename OUTPUT>
+ void init_beach_line(OUTPUT *output) {
+ if (!beach_line_.empty())
+ beach_line_.clear();
+ if (site_events_.empty())
+ return;
+ if (site_events_.size() == 1) {
+ // Handle single site event case.
+ output->builder()->process_single_site(site_events_[0]);
+ ++site_event_iterator_;
+ } else {
+ int skip = 0;
+
+ while(site_event_iterator_ != site_events_.end() &&
+ VP::is_vertical(site_event_iterator_->point0(),
+ site_events_.begin()->point0()) &&
+ VP::is_vertical(*site_event_iterator_)) {
+ ++site_event_iterator_;
+ ++skip;
+ }
+
+ if (skip == 1) {
+ // Init beach line with the first two sites.
+ init_beach_line_default(output);
+ } else {
+ // Init beach line with collinear vertical sites.
+ init_beach_line_collinear_sites(output);
+ }
+ }
+ }
+
+ // Init beach line with the two first sites.
+ // The first site is always a point.
+ template <typename OUTPUT>
+ void init_beach_line_default(OUTPUT *output) {
+ // Get the first and the second site event.
+ site_event_iterator_type it_first = site_events_.begin();
+ site_event_iterator_type it_second = site_events_.begin();
+ ++it_second;
+ insert_new_arc(
+ *it_first, *it_first, *it_second, beach_line_.end(), output);
+ // The second site was already processed. Move the iterator.
+ ++site_event_iterator_;
+ }
+
+ // Init beach line with collinear sites.
+ template <typename OUTPUT>
+ void init_beach_line_collinear_sites(OUTPUT *output) {
+ site_event_iterator_type it_first = site_events_.begin();
+ site_event_iterator_type it_second = site_events_.begin();
+ ++it_second;
+ while (it_second != site_event_iterator_) {
+ // Create a new beach line node.
+ key_type new_node(*it_first, *it_second);
+
+ // Update the output.
+ edge_type *edge =
+ output->builder()->insert_new_edge(*it_first, *it_second).first;
+
+ // Insert a new bisector into the beach line.
+ beach_line_.insert(beach_line_.end(),
+ std::pair<key_type, value_type>(new_node, value_type(edge)));
+
+ // Update iterators.
+ ++it_first;
+ ++it_second;
+ }
+ }
+
+ void deactivate_circle_event(value_type &value) {
+ if (value.circle_event()) {
+ value.circle_event()->deactivate();
+ value.circle_event(NULL);
+ }
+ }
+
+ template <typename OUTPUT>
+ void process_site_event(OUTPUT *output) {
+ // Get next site event to process.
+ site_event_type site_event = *site_event_iterator_;
+
+ // Move site iterator.
+ site_event_iterator_type last = site_event_iterator_ + 1;
+
+ // If a new site is an end point of some segment,
+ // remove temporary nodes from the beach line data structure.
+ if (!site_event.is_segment()) {
+ while (!end_points_.empty() &&
+ end_points_.top().first == site_event.point0()) {
+ beach_line_iterator b_it = end_points_.top().second;
+ end_points_.pop();
+ beach_line_.erase(b_it);
+ }
+ } else {
+ while (last != site_events_.end() &&
+ last->is_segment() && last->point0() == site_event.point0())
+ ++last;
+ }
+
+ // Find the node in the binary search tree with left arc
+ // lying above the new site point.
+ key_type new_key(*site_event_iterator_);
+ beach_line_iterator right_it = beach_line_.lower_bound(new_key);
+
+ for (; site_event_iterator_ != last; ++site_event_iterator_) {
+ site_event = *site_event_iterator_;
+ beach_line_iterator left_it = right_it;
+
+ // Do further processing depending on the above node position.
+ // For any two neighboring nodes the second site of the first node
+ // is the same as the first site of the second node.
+ if (right_it == beach_line_.end()) {
+ // The above arc corresponds to the second arc of the last node.
+ // Move the iterator to the last node.
+ --left_it;
+
+ // Get the second site of the last node
+ const site_event_type &site_arc = left_it->first.right_site();
+
+ // Insert new nodes into the beach line. Update the output.
+ right_it = insert_new_arc(
+ site_arc, site_arc, site_event, right_it, output);
+
+ // Add a candidate circle to the circle event queue.
+ // There could be only one new circle event formed by
+ // a new bisector and the one on the left.
+ activate_circle_event(left_it->first.left_site(),
+ left_it->first.right_site(),
+ site_event, right_it);
+ } else if (right_it == beach_line_.begin()) {
+ // The above arc corresponds to the first site of the first node.
+ const site_event_type &site_arc = right_it->first.left_site();
+
+ // Insert new nodes into the beach line. Update the output.
+ left_it = insert_new_arc(
+ site_arc, site_arc, site_event, right_it, output);
+
+ // If the site event is a segment, update its direction.
+ if (site_event.is_segment()) {
+ site_event.inverse();
+ }
+
+ // Add a candidate circle to the circle event queue.
+ // There could be only one new circle event formed by
+ // a new bisector and the one on the right.
+ activate_circle_event(site_event, right_it->first.left_site(),
+ right_it->first.right_site(), right_it);
+ right_it = left_it;
+ } else {
+ // The above arc corresponds neither to the first,
+ // nor to the last site in the beach line.
+ const site_event_type &site_arc2 = right_it->first.left_site();
+ const site_event_type &site3 = right_it->first.right_site();
+
+ // Remove the candidate circle from the event queue.
+ deactivate_circle_event(right_it->second);
+ --left_it;
+ const site_event_type &site_arc1 = left_it->first.right_site();
+ const site_event_type &site1 = left_it->first.left_site();
+
+ // Insert new nodes into the beach line. Update the output.
+ beach_line_iterator new_node_it =
+ insert_new_arc(site_arc1, site_arc2, site_event, right_it, output);
+
+ // Add candidate circles to the circle event queue.
+ // There could be up to two circle events formed by
+ // a new bisector and the one on the left or right.
+ activate_circle_event(site1, site_arc1, site_event, new_node_it);
+
+ // If the site event is a segment, update its direction.
+ if (site_event.is_segment()) {
+ site_event.inverse();
+ }
+ activate_circle_event(site_event, site_arc2, site3, right_it);
+ right_it = new_node_it;
+ }
+ }
+ }
+
+ // In general case circle event is made of the three consecutive sites
+ // that form two bisectors in the beach line data structure.
+ // Let circle event sites be A, B, C, two bisectors that define
+ // circle event are (A, B), (B, C). During circle event processing
+ // we remove (A, B), (B, C) and insert (A, C). As beach line comparison
+ // works correctly only if one of the nodes is a new one we remove
+ // (B, C) bisector and change (A, B) bisector to the (A, C). That's
+ // why we use const_cast there and take all the responsibility that
+ // map data structure keeps correct ordering.
+ template <typename OUTPUT>
+ void process_circle_event(OUTPUT *output) {
+ // Get the topmost circle event.
+ const event_type &e = circle_events_.top();
+ const circle_event_type &circle_event = e.first;
+ beach_line_iterator it_first = e.second;
+ beach_line_iterator it_last = it_first;
+
+ // Get the C site.
+ site_event_type site3 = it_first->first.right_site();
+
+ // Get the half-edge corresponding to the second bisector - (B, C).
+ edge_type *bisector2 = it_first->second.edge();
+
+ // Get the half-edge corresponding to the first bisector - (A, B).
+ --it_first;
+ edge_type *bisector1 = it_first->second.edge();
+
+ // Get the A site.
+ site_event_type site1 = it_first->first.left_site();
+
+ if (!site1.is_segment() && site3.is_segment() &&
+ site3.point1(true) == site1.point0()) {
+ site3.inverse();
+ }
+
+ // Change the (A, B) bisector node to the (A, C) bisector node.
+ const_cast<key_type &>(it_first->first).right_site(site3);
+
+ // Insert the new bisector into the beach line.
+ it_first->second.edge(output->builder()->insert_new_edge(
+ site1, site3, circle_event, bisector1, bisector2).first);
+
+ // Remove the (B, C) bisector node from the beach line.
+ beach_line_.erase(it_last);
+ it_last = it_first;
+
+ // Pop the topmost circle event from the event queue.
+ circle_events_.pop();
+
+ // Check new triplets formed by the neighboring arcs
+ // to the left for potential circle events.
+ if (it_first != beach_line_.begin()) {
+ deactivate_circle_event(it_first->second);
+ --it_first;
+ const site_event_type &site_l1 = it_first->first.left_site();
+ activate_circle_event(site_l1, site1, site3, it_last);
+ }
+
+ // Check the new triplet formed by the neighboring arcs
+ // to the right for potential circle events.
+ ++it_last;
+ if (it_last != beach_line_.end()) {
+ deactivate_circle_event(it_last->second);
+ const site_event_type &site_r1 = it_last->first.right_site();
+ activate_circle_event(site1, site3, site_r1, it_last);
+ }
+ }
+
+ // Insert new nodes into the beach line. Update the output.
+ template <typename OUTPUT>
+ beach_line_iterator insert_new_arc(
+ const site_event_type &site_arc1, const site_event_type &site_arc2,
+ const site_event_type &site_event, beach_line_iterator position,
+ OUTPUT *output) {
+ // Create two new bisectors with opposite directions.
+ key_type new_left_node(site_arc1, site_event);
+ key_type new_right_node(site_event, site_arc2);
+
+ // Set correct orientation for the first site of the second node.
+ if (site_event.is_segment()) {
+ new_right_node.left_site().inverse();
+ }
+
+ // Update the output.
+ std::pair<edge_type*, edge_type*> edges =
+ output->builder()->insert_new_edge(site_arc2, site_event);
+ position = beach_line_.insert(position,
+ typename beach_line_type::value_type(
+ new_right_node, value_type(edges.second)));
+
+ if (site_event.is_segment()) {
+ // Update the beach line with temporary bisector, that will
+ // disappear after processing site event corresponding to the
+ // second endpoint of the segment site.
+ key_type new_node(site_event, site_event);
+ new_node.right_site().inverse();
+ position = beach_line_.insert(position,
+ typename beach_line_type::value_type(new_node, value_type(NULL)));
+
+ // Update the data structure that holds temporary bisectors.
+ end_points_.push(std::make_pair(site_event.point1(), position));
+ }
+
+ position = beach_line_.insert(position,
+ typename beach_line_type::value_type(
+ new_left_node, value_type(edges.first)));
+
+ return position;
+ }
+
+ // Add a new circle event to the event queue.
+ // bisector_node corresponds to the (site2, site3) bisector.
+ void activate_circle_event(const site_event_type &site1,
+ const site_event_type &site2,
+ const site_event_type &site3,
+ beach_line_iterator bisector_node) {
+ circle_event_type c_event;
+ // Check if the three input sites create a circle event.
+ if (circle_formation_predicate_(site1, site2, site3, c_event)) {
+ // Add the new circle event to the circle events queue.
+ // Update bisector's circle event iterator to point to the
+ // new circle event in the circle event queue.
+ event_type &e = circle_events_.push(
+ std::pair<circle_event_type, beach_line_iterator>(
+ c_event, bisector_node));
+ bisector_node->second.circle_event(&e.first);
+ }
+ }
+
+private:
+ point_comparison_predicate point_comparison_;
+ struct end_point_comparison {
+ bool operator() (const end_point_type &end1,
+ const end_point_type &end2) const {
+ return point_comparison(end2.first, end1.first);
+ }
+ point_comparison_predicate point_comparison;
+ };
+
+ std::vector<site_event_type> site_events_;
+ site_event_iterator_type site_event_iterator_;
+ std::priority_queue< end_point_type, std::vector<end_point_type>,
+ end_point_comparison > end_points_;
+ circle_event_queue_type circle_events_;
+ beach_line_type beach_line_;
+ circle_formation_predicate_type circle_formation_predicate_;
+
+ //Disallow copy constructor and operator=
+ voronoi_builder(const voronoi_builder&);
+ void operator=(const voronoi_builder&);
+};
+
+typedef voronoi_builder<detail::int32> default_voronoi_builder;
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_VORONOI_BUILDER
Added: trunk/boost/polygon/voronoi_diagram.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/voronoi_diagram.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,650 @@
+// Boost.Polygon library voronoi_diagram.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_VORONOI_DIAGRAM
+#define BOOST_POLYGON_VORONOI_DIAGRAM
+
+#include <vector>
+
+#include "detail/voronoi_ctypes.hpp"
+#include "detail/voronoi_structures.hpp"
+
+namespace boost {
+namespace polygon {
+
+// Forward declarations.
+template <typename T>
+class voronoi_edge;
+
+// Represents Voronoi cell.
+// Data members:
+// 1) pointer to the incident edge;
+// 2) site inside cell;
+// 3) data associated with a cell.
+// Cell may contain point or segment site inside.
+template <typename T>
+class voronoi_cell {
+public:
+ typedef T coordinate_type;
+ typedef detail::point_2d<coordinate_type> point_type;
+ typedef voronoi_edge<coordinate_type> voronoi_edge_type;
+
+ voronoi_cell(const point_type &p1, voronoi_edge_type *edge) :
+ point0_(p1),
+ point1_(p1),
+ incident_edge_(edge),
+ data_(NULL) {}
+
+ voronoi_cell(const point_type &p1,
+ const point_type &p2,
+ voronoi_edge_type *edge) :
+ point0_(p1),
+ point1_(p2),
+ incident_edge_(edge),
+ data_(NULL) {}
+
+ // Returns true if the cell contains point site, false else.
+ bool contains_point() const { return point0_ == point1_; }
+
+ // Returns true if the cell contains segment site, false else.
+ bool contains_segment() const { return point0_ != point1_; }
+
+ // Degenerate cells don't have any incident edges.
+ bool is_degenerate() const { return incident_edge_ == NULL; }
+
+ // Returns site point in case cell contains point site,
+ // the first endpoint of the segment site else.
+ const point_type &point0() const { return point0_; }
+
+ // Returns site point in case cell contains point site,
+ // the second endpoint of the segment site else.
+ const point_type &point1() const { return point1_; }
+
+ voronoi_edge_type *incident_edge() { return incident_edge_; }
+ const voronoi_edge_type *incident_edge() const { return incident_edge_; }
+ void incident_edge(voronoi_edge_type *e) { incident_edge_ = e; }
+
+#ifndef NO_VORONOI_CELL_DATA
+ void *data() const { return data_; }
+ void data(void *d) const { data_ = d; }
+#endif
+
+private:
+ point_type point0_;
+ point_type point1_;
+ voronoi_edge_type *incident_edge_;
+#ifndef NO_VORONOI_CELL_DATA
+ mutable void *data_;
+#endif
+};
+
+// Represents Voronoi vertex.
+// Data members:
+// 1) vertex point itself;
+// 2) pointer to the incident edge;
+// 3) data associated with vertex.
+template <typename T>
+class voronoi_vertex {
+public:
+ typedef T coordinate_type;
+ typedef detail::point_2d<T> point_type;
+ typedef voronoi_edge<coordinate_type> voronoi_edge_type;
+
+ voronoi_vertex(const point_type &vertex, voronoi_edge_type *edge) :
+ vertex_(vertex),
+ incident_edge_(edge),
+ data_(NULL) {}
+
+ const point_type &vertex() const { return vertex_; }
+
+ bool is_degenerate() const { return incident_edge_ == NULL; }
+
+ voronoi_edge_type *incident_edge() { return incident_edge_; }
+ const voronoi_edge_type *incident_edge() const { return incident_edge_; }
+ void incident_edge(voronoi_edge_type *e) { incident_edge_ = e; }
+
+#ifndef NO_VORONOI_VERTEX_DATA
+ void *data() const { return data_; }
+ void data(void *d) const { data_ = d; }
+#endif
+
+private:
+ point_type vertex_;
+ voronoi_edge_type *incident_edge_;
+#ifndef NO_VORONOI_VERTEX_DATA
+ mutable void *data_;
+#endif
+};
+
+// Half-edge data structure. Represents Voronoi edge.
+// Data members:
+// 1) pointer to the corresponding cell;
+// 2) pointer to the vertex that is the starting
+// point of the half-edge;
+// 3) pointer to the twin edge;
+// 4) pointer to the CCW next edge;
+// 5) pointer to the CCW prev edge;
+// 6) pointer to data associated with edge.
+template <typename T>
+class voronoi_edge {
+public:
+ typedef T coordinate_type;
+ typedef voronoi_cell<coordinate_type> voronoi_cell_type;
+ typedef voronoi_vertex<coordinate_type> voronoi_vertex_type;
+ typedef voronoi_edge<coordinate_type> voronoi_edge_type;
+
+ voronoi_edge() :
+ cell_(NULL),
+ vertex_(NULL),
+ twin_(NULL),
+ next_(NULL),
+ prev_(NULL),
+ data_(NULL) {}
+
+ voronoi_cell_type *cell() { return cell_; }
+ const voronoi_cell_type *cell() const { return cell_; }
+ void cell(voronoi_cell_type *c) { cell_ = c; }
+
+ voronoi_vertex_type *vertex0() { return vertex_; }
+ const voronoi_vertex_type *vertex0() const { return vertex_; }
+ void vertex0(voronoi_vertex_type *v) { vertex_ = v; }
+
+ voronoi_vertex_type *vertex1() { return twin_->vertex0(); }
+ const voronoi_vertex_type *vertex1() const { return twin_->vertex0(); }
+ void vertex1(voronoi_vertex_type *v) { twin_->vertex0(v); }
+
+ voronoi_edge_type *twin() { return twin_; }
+ const voronoi_edge_type *twin() const { return twin_; }
+ void twin(voronoi_edge_type *e) { twin_ = e; }
+
+ voronoi_edge_type *next() { return next_; }
+ const voronoi_edge_type *next() const { return next_; }
+ void next(voronoi_edge_type *e) { next_ = e; }
+
+ voronoi_edge_type *prev() { return prev_; }
+ const voronoi_edge_type *prev() const { return prev_; }
+ void prev(voronoi_edge_type *e) { prev_ = e; }
+
+#ifndef NO_VORONOI_EDGE_DATA
+ void *data() const { return data_; }
+ void data(void *d) const { data_ = d; }
+#endif
+
+ // Returns a pointer to the rotation next edge
+ // over the starting point of the half-edge.
+ voronoi_edge_type *rot_next() {
+ return (vertex_) ? prev_->twin() : NULL;
+ }
+ const voronoi_edge_type *rot_next() const {
+ return (vertex_) ? prev_->twin() : NULL;
+ }
+
+ // Returns a pointer to the rotation prev edge
+ // over the starting point of the half-edge.
+ voronoi_edge_type *rot_prev() {
+ return (vertex_) ? twin_->next() : NULL;
+ }
+ const voronoi_edge_type *rot_prev() const {
+ return (vertex_) ? twin_->next() : NULL;
+ }
+
+ // Returns true if the edge is finite (segment, parabolic arc).
+ // Returns false if the edge is infinite (ray, line).
+ bool is_finite() const { return vertex0() && vertex1(); }
+
+ // Returns true if the edge is linear (segment, ray, line).
+ // Returns false if the edge is curved (parabolic arc).
+ bool is_linear() const {
+ if (!is_primary())
+ return true;
+ return !(cell()->contains_segment() ^ twin()->cell()->contains_segment());
+ }
+
+ // Returns true if the edge is curved (parabolic arc).
+ // Returns false if the edge is linear (segment, ray, line).
+ bool is_curved() const {
+ if (!is_primary())
+ return false;
+ return (cell()->contains_segment() ^ twin()->cell()->contains_segment());
+ }
+
+ // Returns false if edge goes through the endpoint of the segment.
+ // Returns true else.
+ bool is_primary() const {
+ bool flag1 = cell_->contains_segment();
+ bool flag2 = twin_->cell()->contains_segment();
+ if (flag1 && !flag2) {
+ return cell_->point0() != twin_->cell()->point0() &&
+ cell_->point1() != twin_->cell()->point0();
+ }
+ if (!flag1 && flag2) {
+ return twin_->cell()->point0() != cell_->point0() &&
+ twin_->cell()->point1() != cell_->point0();
+ }
+ return true;
+ }
+
+private:
+ voronoi_cell_type *cell_;
+ voronoi_vertex_type *vertex_;
+ voronoi_edge_type *twin_;
+ voronoi_edge_type *next_;
+ voronoi_edge_type *prev_;
+#ifndef NO_VORONOI_EDGE_DATA
+ mutable void *data_;
+#endif
+};
+
+template <typename T>
+struct voronoi_diagram_traits {
+ typedef T coordinate_type;
+ typedef struct {
+ template <typename CT>
+ coordinate_type operator()(const CT& value) {
+ return static_cast<coordinate_type>(value);
+ }
+ } ctype_converter_type;
+ typedef detail::point_2d<coordinate_type> point_type;
+ typedef voronoi_cell<coordinate_type> cell_type;
+ typedef voronoi_vertex<coordinate_type> vertex_type;
+ typedef voronoi_edge<coordinate_type> edge_type;
+ typedef class {
+ public:
+ enum { ULPS = 128 };
+ bool operator()(const point_type &v1, const point_type &v2) const {
+ return (ulp_cmp(v1.x(), v2.x(), ULPS) ==
+ detail::ulp_comparison<T>::EQUAL) &&
+ (ulp_cmp(v1.y(), v2.y(), ULPS) ==
+ detail::ulp_comparison<T>::EQUAL);
+ }
+ private:
+ typename detail::ulp_comparison<T> ulp_cmp;
+ } vertex_equality_predicate_type;
+};
+
+// Voronoi output data structure.
+// CCW ordering is used on the faces perimeter and around the vertices.
+template <typename T, typename TRAITS = voronoi_diagram_traits<T> >
+class voronoi_diagram {
+public:
+ typedef typename TRAITS::coordinate_type coordinate_type;
+ typedef typename TRAITS::point_type point_type;
+ typedef typename TRAITS::cell_type cell_type;
+ typedef typename TRAITS::vertex_type vertex_type;
+ typedef typename TRAITS::edge_type edge_type;
+
+ typedef std::vector<cell_type> cell_container_type;
+ typedef typename cell_container_type::iterator cell_iterator;
+ typedef typename cell_container_type::const_iterator const_cell_iterator;
+
+ typedef std::vector<vertex_type> vertex_container_type;
+ typedef typename vertex_container_type::iterator vertex_iterator;
+ typedef typename vertex_container_type::const_iterator const_vertex_iterator;
+
+ typedef std::vector<edge_type> edge_container_type;
+ typedef typename edge_container_type::iterator edge_iterator;
+ typedef typename edge_container_type::const_iterator const_edge_iterator;
+
+ // This builder class is mainly used to hide from the user methods that
+ // construct the Voronoi diagram.
+ class voronoi_diagram_builder {
+ public:
+ void vd(voronoi_diagram *vd) {
+ vd_ = vd;
+ }
+
+ bool done() {
+ return vd_ == NULL;
+ }
+
+ void reserve(int num_sites) {
+ vd_->reserve(num_sites);
+ }
+
+ template <typename SEvent>
+ void process_single_site(const SEvent &site) {
+ vd_->process_single_site(site);
+ }
+
+ template <typename SEvent>
+ std::pair<void*, void*> insert_new_edge(
+ const SEvent &site1, const SEvent &site2) {
+ return vd_->insert_new_edge(site1, site2);
+ }
+
+ template <typename SEvent, typename CEvent>
+ std::pair<void *, void *> insert_new_edge(
+ const SEvent &site1, const SEvent &site3, const CEvent &circle,
+ void *data12, void *data23) {
+ return vd_->insert_new_edge(site1, site3, circle, data12, data23);
+ }
+
+ void build() {
+ vd_->build();
+ vd_ = NULL;
+ }
+
+ private:
+ voronoi_diagram *vd_;
+ };
+
+ voronoi_diagram() {
+ builder_.vd(&(*this));
+ }
+
+ void clear() {
+ cells_.clear();
+ vertices_.clear();
+ edges_.clear();
+ builder_.vd(&(*this));
+ }
+
+ const cell_container_type &cells() const {
+ return cells_;
+ }
+
+ const vertex_container_type &vertices() const {
+ return vertices_;
+ }
+
+ const edge_container_type &edges() const {
+ return edges_;
+ }
+
+ unsigned int num_cells() const {
+ return cells_.size();
+ }
+
+ unsigned int num_edges() const {
+ return edges_.size() >> 1;
+ }
+
+ unsigned int num_vertices() const {
+ return vertices_.size();
+ }
+
+ voronoi_diagram_builder *builder() {
+ if (builder_.done()) {
+ return NULL;
+ } else {
+ return &builder_;
+ }
+ }
+
+private:
+ typedef typename TRAITS::ctype_converter_type ctype_converter_type;
+ typedef typename TRAITS::vertex_equality_predicate_type
+ vertex_equality_predicate_type;
+
+ friend class voronoi_diagram_builder;
+
+ void reserve(int num_sites) {
+ cells_.reserve(num_sites);
+ vertices_.reserve(num_sites << 1);
+ edges_.reserve((num_sites << 2) + (num_sites << 1));
+ }
+
+ // Update the Voronoi output in case of a single point input.
+ template <typename SEvent>
+ void process_single_site(const SEvent &site) {
+ // Update cell records.
+ point_type p = prepare_point(site.point0());
+ cells_.push_back(cell_type(p, NULL));
+ }
+
+ // Insert a new half-edge into the output data structure.
+ // Takes as input left and right sites that form a new bisector.
+ // Returns a pair of pointers to a new half-edges.
+ template <typename SEvent>
+ std::pair<void*, void*> insert_new_edge(
+ const SEvent &site1, const SEvent &site2) {
+ // Get sites' indexes.
+ int site_index1 = site1.index();
+ int site_index2 = site2.index();
+
+ // Create a new half-edge that belongs to the first site.
+ edges_.push_back(edge_type());
+ edge_type &edge1 = edges_.back();
+
+ // Create a new half-edge that belongs to the second site.
+ edges_.push_back(edge_type());
+ edge_type &edge2 = edges_.back();
+
+ // Add the initial cell during the first edge insertion.
+ if (cells_.empty()) {
+ process_single_site(site1);
+ }
+
+ // The second site represents a new site during site event
+ // processing. Add a new cell to the cell records.
+ cells_.push_back(cell_type(prepare_point(site2.point0()),
+ prepare_point(site2.point1()),
+ NULL));
+
+ // Set up pointers to cells.
+ edge1.cell(&cells_[site_index1]);
+ edge2.cell(&cells_[site_index2]);
+
+ // Set up twin pointers.
+ edge1.twin(&edge2);
+ edge2.twin(&edge1);
+
+ // Return a pointer to the new half-edge.
+ return std::make_pair(&edge1, &edge2);
+ }
+
+ // Insert a new half-edge into the output data structure with the
+ // start at the point where two previously added half-edges intersect.
+ // Takes as input two sites that create a new bisector, circle event
+ // that corresponds to the intersection point of the two old half-edges,
+ // pointers to those half-edges. Half-edges' direction goes out of the
+ // new Voronoi vertex point. Returns a pair of pointers to a new half-edges.
+ template <typename SEvent, typename CEvent>
+ std::pair<void *, void *> insert_new_edge(
+ const SEvent &site1, const SEvent &site3, const CEvent &circle,
+ void *data12, void *data23) {
+ edge_type *edge12 = static_cast<edge_type*>(data12);
+ edge_type *edge23 = static_cast<edge_type*>(data23);
+
+ // Add a new Voronoi vertex.
+ vertices_.push_back(vertex_type(prepare_point(circle), NULL));
+ vertex_type &new_vertex = vertices_.back();
+
+ // Update vertex pointers of the old edges.
+ edge12->vertex0(&new_vertex);
+ edge23->vertex0(&new_vertex);
+
+ // Add a new half-edge.
+ edges_.push_back(edge_type());
+ edge_type &new_edge1 = edges_.back();
+ new_edge1.cell(&cells_[site1.index()]);
+
+ // Add a new half-edge.
+ edges_.push_back(edge_type());
+ edge_type &new_edge2 = edges_.back();
+ new_edge2.cell(&cells_[site3.index()]);
+
+ // Update twin pointers.
+ new_edge1.twin(&new_edge2);
+ new_edge2.twin(&new_edge1);
+
+ // Update vertex pointer.
+ new_edge2.vertex0(&new_vertex);
+
+ // Update Voronoi prev/next pointers.
+ edge12->prev(&new_edge1);
+ new_edge1.next(edge12);
+ edge12->twin()->next(edge23);
+ edge23->prev(edge12->twin());
+ edge23->twin()->next(&new_edge2);
+ new_edge2.prev(edge23->twin());
+
+ // Return a pointer to the new half-edge.
+ return std::make_pair(&new_edge1, &new_edge2);
+ }
+
+ void build() {
+ // Remove degenerate edges.
+ edge_iterator last_edge = edges_.begin();
+ for (edge_iterator it = edges_.begin(); it != edges_.end(); it += 2) {
+ const vertex_type *v1 = it->vertex0();
+ const vertex_type *v2 = it->vertex1();
+ if (v1 && v2 && vertex_equality_predicate_(v1->vertex(), v2->vertex())) {
+ remove_edge(&(*it));
+ } else {
+ if (it != last_edge) {
+ edge_type *e1 = &(*last_edge = *it);
+ edge_type *e2 = &(*(last_edge + 1) = *(it + 1));
+ e1->twin(e2);
+ e2->twin(e1);
+ if (e1->prev()) {
+ e1->prev()->next(e1);
+ e2->next()->prev(e2);
+ }
+ if (e2->prev()) {
+ e1->next()->prev(e1);
+ e2->prev()->next(e2);
+ }
+ }
+ last_edge += 2;
+ }
+ }
+ edges_.erase(last_edge, edges_.end());
+
+ // Set up incident edge pointers for cells and vertices.
+ for (edge_iterator it = edges_.begin(); it != edges_.end(); ++it) {
+ it->cell()->incident_edge(&(*it));
+ if (it->vertex0()) {
+ it->vertex0()->incident_edge(&(*it));
+ }
+ }
+
+ // Remove degenerate vertices.
+ vertex_iterator last_vertex = vertices_.begin();
+ for (vertex_iterator it = vertices_.begin(); it != vertices_.end(); ++it) {
+ if (it->incident_edge()) {
+ if (it != last_vertex) {
+ *last_vertex = *it;
+ vertex_type *v = &(*last_vertex);
+ edge_type *e = v->incident_edge();
+ do {
+ e->vertex0(v);
+ e = e->rot_next();
+ } while (e != v->incident_edge());
+ }
+ ++last_vertex;
+ }
+ }
+ vertices_.erase(last_vertex, vertices_.end());
+
+ // Set up next/prev pointers for infinite edges.
+ if (vertices_.empty()) {
+ if (!edges_.empty()) {
+ // Update prev/next pointers for the line edges.
+ edge_iterator edge_it = edges_.begin();
+ edge_type *edge1 = &(*edge_it);
+ edge1->next(edge1);
+ edge1->prev(edge1);
+ ++edge_it;
+ edge1 = &(*edge_it);
+ ++edge_it;
+
+ while (edge_it != edges_.end()) {
+ edge_type *edge2 = &(*edge_it);
+ ++edge_it;
+
+ edge1->next(edge2);
+ edge1->prev(edge2);
+ edge2->next(edge1);
+ edge2->prev(edge1);
+
+ edge1 = &(*edge_it);
+ ++edge_it;
+ }
+
+ edge1->next(edge1);
+ edge1->prev(edge1);
+ }
+ } else {
+ // Update prev/next pointers for the ray edges.
+ for (cell_iterator cell_it = cells_.begin();
+ cell_it != cells_.end(); ++cell_it) {
+ if (cell_it->is_degenerate())
+ continue;
+ // Move to the previous edge while
+ // it is possible in the CW direction.
+ edge_type *left_edge = cell_it->incident_edge();
+ while (left_edge->prev() != NULL) {
+ left_edge = left_edge->prev();
+ // Terminate if this is not a boundary cell.
+ if (left_edge == cell_it->incident_edge())
+ break;
+ }
+
+ if (left_edge->prev() != NULL)
+ continue;
+
+ edge_type *right_edge = cell_it->incident_edge();
+ while (right_edge->next() != NULL)
+ right_edge = right_edge->next();
+ left_edge->prev(right_edge);
+ right_edge->next(left_edge);
+ }
+ }
+ }
+
+ template <typename P>
+ point_type prepare_point(const P& p) {
+ coordinate_type nx = convert_(p.x());
+ coordinate_type ny = convert_(p.y());
+ return point_type(nx, ny);
+ }
+
+ // Remove degenerate edge.
+ void remove_edge(edge_type *edge) {
+ // Update the endpoints of the incident edges to the second vertex.
+ vertex_type *vertex = edge->vertex0();
+ edge_type *updated_edge = edge->twin()->rot_next();
+ while (updated_edge != edge->twin()) {
+ updated_edge->vertex0(vertex);
+ updated_edge = updated_edge->rot_next();
+ }
+
+ edge_type *edge1 = edge;
+ edge_type *edge2 = edge->twin();
+
+ edge_type *edge1_rot_prev = edge1->rot_prev();
+ edge_type *edge1_rot_next = edge1->rot_next();
+
+ edge_type *edge2_rot_prev = edge2->rot_prev();
+ edge_type *edge2_rot_next = edge2->rot_next();
+
+ // Update prev/next pointers for the incident edges.
+ edge1_rot_next->twin()->next(edge2_rot_prev);
+ edge2_rot_prev->prev(edge1_rot_next->twin());
+ edge1_rot_prev->prev(edge2_rot_next->twin());
+ edge2_rot_next->twin()->next(edge1_rot_prev);
+ }
+
+ cell_container_type cells_;
+ vertex_container_type vertices_;
+ edge_container_type edges_;
+
+ voronoi_diagram_builder builder_;
+ ctype_converter_type convert_;
+ vertex_equality_predicate_type vertex_equality_predicate_;
+
+ // Disallow copy constructor and operator=
+ voronoi_diagram(const voronoi_diagram&);
+ void operator=(const voronoi_diagram&);
+};
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_VORONOI_DIAGRAM
Added: trunk/boost/polygon/voronoi_utils.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/polygon/voronoi_utils.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,479 @@
+// Boost.Polygon library voronoi_utils.hpp header file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POLYGON_VORONOI_UTILS
+#define BOOST_POLYGON_VORONOI_UTILS
+
+#include <cmath>
+#include <stack>
+#include <vector>
+
+#include "voronoi_diagram.hpp"
+
+namespace boost {
+namespace polygon {
+
+// Bounding rectangle data structure. Contains coordinates
+// of the bottom left and upper right corners of rectangle.
+template <typename T>
+class bounding_rectangle {
+public:
+ typedef T coordinate_type;
+
+ bounding_rectangle() : x_min_(1), x_max_(0) {}
+
+ bounding_rectangle(coordinate_type x1, coordinate_type y1,
+ coordinate_type x2, coordinate_type y2) {
+ x_min_ = (std::min)(x1, x2);
+ y_min_ = (std::min)(y1, y2);
+ x_max_ = (std::max)(x1, x2);
+ y_max_ = (std::max)(y1, y2);
+ }
+
+ // Update bounding rectangle.
+ void update(coordinate_type x, coordinate_type y) {
+ if (x_min_ > x_max_) {
+ x_min_ = x_max_ = x;
+ y_min_ = y_max_ = y;
+ } else {
+ x_min_ = (std::min)(x_min_, x);
+ y_min_ = (std::min)(y_min_, y);
+ x_max_ = (std::max)(x_max_, x);
+ y_max_ = (std::max)(y_max_, y);
+ }
+ }
+
+ bool is_empty() const {
+ return x_min_ > x_max_;
+ }
+
+ void clear() {
+ x_min_ = 1;
+ x_max_ = 0;
+ }
+
+ bool contains(coordinate_type x, coordinate_type y) const {
+ return x > x_min_ && x < x_max_ && y > y_min_ && y < y_max_;
+ }
+
+ // Return the x-coordinate of the bottom left point of the rectangle.
+ coordinate_type x_min() const {
+ return x_min_;
+ }
+
+ // Return the y-coordinate of the bottom left point of the rectangle.
+ coordinate_type y_min() const {
+ return y_min_;
+ }
+
+ // Return the x-coordinate of the upper right point of the rectangle.
+ coordinate_type x_max() const {
+ return x_max_;
+ }
+
+ // Return the y-coordinate of the upper right point of the rectangle.
+ coordinate_type y_max() const {
+ return y_max_;
+ }
+
+private:
+ coordinate_type x_min_;
+ coordinate_type y_min_;
+ coordinate_type x_max_;
+ coordinate_type y_max_;
+};
+
+template <typename fpt>
+struct voronoi_utils_traits {
+ typedef fpt coordinate_type;
+ typedef detail::point_2d<coordinate_type> point_type;
+ typedef std::vector<point_type> point_set_type;
+ typedef bounding_rectangle<coordinate_type> brect_type;
+ typedef struct {
+ template <typename CT>
+ coordinate_type operator()(const CT& value) const {
+ return static_cast<coordinate_type>(value);
+ }
+ } ctype_converter_type;
+};
+
+// Voronoi output post-processing tools.
+template <typename T, typename TRAITS = voronoi_utils_traits<T> >
+class voronoi_utils {
+public:
+ typedef typename TRAITS::coordinate_type coordinate_type;
+ typedef typename TRAITS::point_type point_type;
+ typedef typename TRAITS::point_set_type point_set_type;
+ typedef typename TRAITS::brect_type brect_type;
+
+ // Get scaled by a factor bounding rectangle.
+ template <typename CT>
+ static brect_type scale(const bounding_rectangle<CT> &brect,
+ coordinate_type factor) {
+ coordinate_type x_len = to_fpt(brect.x_max()) - to_fpt(brect.x_min());
+ coordinate_type y_len = to_fpt(brect.y_max()) - to_fpt(brect.y_min());
+ coordinate_type x_mid = to_fpt(brect.x_max()) + to_fpt(brect.x_min());
+ coordinate_type y_mid = to_fpt(brect.y_max()) + to_fpt(brect.y_min());
+ x_mid *= to_fpt(0.5);
+ y_mid *= to_fpt(0.5);
+ coordinate_type offset = (std::max)(x_len, y_len) * factor * to_fpt(0.5);
+ brect_type new_brect(x_mid - offset, y_mid - offset,
+ x_mid + offset, y_mid + offset);
+ return new_brect;
+ }
+
+ // Discretizes finite Voronoi edge.
+ // Discretization absolute error is defined by max_error value.
+ template <typename CT>
+ static void discretize(const voronoi_edge<CT> &edge,
+ coordinate_type max_error, point_set_type &discretization) {
+ // Don't process infinite edges.
+ if (!edge.is_finite())
+ return;
+
+ // Retrieve the cell to the left of the current edge.
+ const typename voronoi_edge<CT>::voronoi_cell_type *cell1 = edge.cell();
+ // Retrieve the cell to the right of the current edge.
+ const typename voronoi_edge<CT>::voronoi_cell_type *cell2 =
+ edge.twin()->cell();
+
+ discretization.push_back(get_point(edge.vertex0()->vertex()));
+ discretization.push_back(get_point(edge.vertex1()->vertex()));
+ if (edge.is_curved()) {
+ bool flag = cell1->contains_segment();
+ // point1 - site point;
+ point_type point1 = flag ?
+ get_point(cell2->point0()) : get_point(cell1->point0());
+ // point2 - start-point of the segment site;
+ point_type point2 = flag ?
+ get_point(cell1->point0()) : get_point(cell2->point0());
+ // point3 - endpoint of the segment site;
+ point_type point3 = flag ?
+ get_point(cell1->point1()) : get_point(cell2->point1());
+ fill_intermediate_points(
+ point1, point2, point3, max_error, discretization);
+ }
+ }
+
+ // Clip a linear Voronoi edge with a given rectangle.
+ template <typename CT>
+ static void clip(const voronoi_edge<CT> &edge,
+ const brect_type &brect, point_set_type &clipped_edge) {
+ // Don't process curved edges.
+ if (edge.is_curved())
+ return;
+
+ if (edge.is_finite()) {
+ clip(edge.vertex0()->vertex(), edge.vertex1()->vertex(),
+ brect, clipped_edge);
+ } else {
+ const typename voronoi_edge<CT>::voronoi_cell_type *cell1 = edge.cell();
+ const typename voronoi_edge<CT>::voronoi_cell_type *cell2 =
+ edge.twin()->cell();
+ point_type point1 = get_point(cell1->point0());
+ point_type point2 = get_point(cell2->point0());
+ if (point1 == point2) {
+ if (cell1->contains_segment())
+ point1 = get_point(cell1->point1());
+ else
+ point2 = get_point(cell2->point1());
+ }
+
+ if (edge.vertex0()) {
+ // Ray edge.
+ point_type origin = get_point(edge.vertex0()->vertex());
+ point_type direction(point1.y() - point2.y(), point2.x() - point1.x());
+ if (brect.contains(origin.x(), origin.y()))
+ clipped_edge.push_back(origin);
+ intersect(origin, direction, RAY, brect, clipped_edge);
+ } else if (edge.vertex1()) {
+ // Ray edge.
+ point_type origin = get_point(edge.vertex1()->vertex());
+ point_type direction(point2.y() - point1.y(), point1.x() - point2.x());
+ if (brect.contains(origin.x(), origin.y()))
+ clipped_edge.push_back(origin);
+ intersect(origin, direction, RAY, brect, clipped_edge);
+ // Keep correct ordering.
+ (std::reverse)(clipped_edge.begin(), clipped_edge.end());
+ } else if (cell1->contains_point() && cell2->contains_point()) {
+ // Primary line edge.
+ point_type origin((point1.x() + point2.x()) * 0.5, (point1.y() + point2.y()) * 0.5);
+ point_type direction(point1.y() - point2.y(), point2.x() - point1.x());
+ intersect(origin, direction, LINE, brect, clipped_edge);
+ } else {
+ point_type origin = cell1->contains_point() ? point1 : point2;
+ point_type direction(point1.y() - point2.y(), point2.x() - point1.x());
+ intersect(origin, direction, LINE, brect, clipped_edge);
+ }
+ }
+ }
+
+ // Clip an edge with the given rectangle.
+ template <typename PointType>
+ static void clip(const PointType &p1, const PointType &p2,
+ const brect_type &brect, point_set_type &clipped_edge) {
+ point_type start = get_point(p1);
+ point_type end = get_point(p2);
+ point_type direction(end.x() - start.x(), end.y() - start.y());
+ if (brect.contains(start.x(), start.y()))
+ clipped_edge.push_back(start);
+ if (p1 != p2)
+ intersect(start, direction, SEGMENT, brect, clipped_edge);
+ if (brect.contains(end.x(), end.y()))
+ clipped_edge.push_back(end);
+ }
+
+private:
+ typedef typename TRAITS::ctype_converter_type ctype_converter_type;
+
+ voronoi_utils();
+
+ // There are three different types of linear primitive:
+ // 1) SEGMENT - has two finite endpoints;
+ // 2) RAY - has one finite and one infinite endpoint;
+ // 3) LINE - has two infinite endpoints.
+ enum EdgeType {
+ SEGMENT = 0,
+ RAY = 1,
+ LINE = 2
+ };
+
+ template <typename P>
+ static point_type get_point(const P &point) {
+ coordinate_type x = to_fpt(point.x());
+ coordinate_type y = to_fpt(point.y());
+ return point_type(x, y);
+ }
+
+ static void intersect(
+ const point_type &origin, const point_type &direction,
+ EdgeType edge_type, const brect_type &brect,
+ point_set_type &clipped_edge) {
+ // Find the center of the rectangle.
+ coordinate_type center_x = (brect.x_min() + brect.x_max()) * to_fpt(0.5);
+ coordinate_type center_y = (brect.y_min() + brect.y_max()) * to_fpt(0.5);
+
+ // Find the half-diagonal vector of the rectangle.
+ coordinate_type len_x = brect.x_max() - center_x;
+ coordinate_type len_y = brect.y_max() - center_y;
+
+ // Find the vector between the origin and the center of the
+ // rectangle.
+ coordinate_type diff_x = origin.x() - center_x;
+ coordinate_type diff_y = origin.y() - center_y;
+
+ // Find the vector perpendicular to the direction vector.
+ coordinate_type perp_x = direction.y();
+ coordinate_type perp_y = -direction.x();
+
+ // Projection of the vector between the origin and the center of
+ // the rectangle on the line perpendicular to the direction vector.
+ coordinate_type lexpr = magnitude(perp_x * diff_x + perp_y * diff_y);
+
+ // Maximum projection among any of the half-diagonals of the
+ // rectangle on the line perpendicular to the direction vector.
+ coordinate_type rexpr =
+ magnitude(perp_x * len_x) + magnitude(perp_y * len_y);
+
+ // Intersection check. Compare projections.
+ if (lexpr > rexpr)
+ return;
+
+ // Intersection parameters. If fT[i]_used is true than:
+ // origin + fT[i] * direction = intersection point, i = 0 .. 1.
+ // For different edge types next fT values are acceptable:
+ // Segment: [0; 1];
+ // Ray: [0; infinity];
+ // Line: [-infinity; infinity].
+ bool fT0_used = false;
+ bool fT1_used = false;
+ coordinate_type fT0 = 0;
+ coordinate_type fT1 = 0;
+
+ // Check for the intersections with the lines
+ // going through the sides of the bounding rectangle.
+ clip_line(+direction.x(), -diff_x - len_x, fT0_used, fT1_used, fT0, fT1);
+ clip_line(-direction.x(), +diff_x - len_x, fT0_used, fT1_used, fT0, fT1);
+ clip_line(+direction.y(), -diff_y - len_y, fT0_used, fT1_used, fT0, fT1);
+ clip_line(-direction.y(), +diff_y - len_y, fT0_used, fT1_used, fT0, fT1);
+
+ // Update intersections vector.
+ if (fT0_used && check_extent(fT0, edge_type))
+ clipped_edge.push_back(point_type(
+ origin.x() + fT0 * direction.x(), origin.y() + fT0 * direction.y()));
+ if (fT1_used && fT0 != fT1 && check_extent(fT1, edge_type))
+ clipped_edge.push_back(point_type(
+ origin.x() + fT1 * direction.x(), origin.y() + fT1 * direction.y()));
+ }
+
+ // Find intermediate points of the parabola.
+ // Parabola is a locus of points equidistant from the point and segment
+ // sites. intermediate_points should contain two initial endpoints
+ // of the edge (Voronoi vertices). Intermediate points are inserted
+ // between the given two endpoints.
+ // Max_dist is the maximum distance allowed between parabola and line
+ // segments that discretize it.
+ static void fill_intermediate_points(
+ point_type point_site, point_type segment_site_start,
+ point_type segment_site_end, coordinate_type max_dist,
+ point_set_type &intermediate_points) {
+ // Apply the linear transformation to move start point of the
+ // segment to the point with coordinates (0, 0) and the direction
+ // of the segment to coincide the positive direction of the x-axis.
+ coordinate_type segm_vec_x =
+ segment_site_end.x() - segment_site_start.x();
+ coordinate_type segm_vec_y =
+ segment_site_end.y() - segment_site_start.y();
+ coordinate_type sqr_segment_length =
+ segm_vec_x * segm_vec_x + segm_vec_y * segm_vec_y;
+
+ // Compute x-coordinates of the endpoints of the edge
+ // in the transformed space.
+ coordinate_type projection_start = sqr_segment_length *
+ get_point_projection(
+ intermediate_points[0], segment_site_start, segment_site_end);
+ coordinate_type projection_end = sqr_segment_length *
+ get_point_projection(
+ intermediate_points[1], segment_site_start, segment_site_end);
+
+ // Compute parabola parameters in the transformed space.
+ // Parabola has next representation:
+ // f(x) = ((x-rot_x)^2 + rot_y^2) / (2.0*rot_y).
+ coordinate_type point_vec_x = point_site.x() - segment_site_start.x();
+ coordinate_type point_vec_y = point_site.y() - segment_site_start.y();
+ coordinate_type rot_x =
+ segm_vec_x * point_vec_x + segm_vec_y * point_vec_y;
+ coordinate_type rot_y =
+ segm_vec_x * point_vec_y - segm_vec_y * point_vec_x;
+
+ // Save the last point.
+ point_type last_point = intermediate_points[1];
+ intermediate_points.pop_back();
+
+ // Use stack to avoid recursion.
+ std::stack<coordinate_type> point_stack;
+ point_stack.push(projection_end);
+ coordinate_type cur_x = projection_start;
+ coordinate_type cur_y = parabola_y(cur_x, rot_x, rot_y);
+
+ // Adjust max_dist parameter in the transformed space.
+ max_dist *= max_dist * sqr_segment_length;
+
+ while (!point_stack.empty()) {
+ coordinate_type new_x = point_stack.top();
+ coordinate_type new_y = parabola_y(new_x, rot_x, rot_y);
+
+ // Compute coordinates of the point of the parabola that is
+ // furthest from the current line segment.
+ coordinate_type mid_x =
+ (new_y - cur_y) / (new_x - cur_x) * rot_y + rot_x;
+ coordinate_type mid_y = parabola_y(mid_x, rot_x, rot_y);
+
+ // Compute maximum distance between the given parabolic arc
+ // and line segment that discretize it.
+ coordinate_type dist = (new_y - cur_y) * (mid_x - cur_x) -
+ (new_x - cur_x) * (mid_y - cur_y);
+ dist = dist * dist / ((new_y - cur_y) * (new_y - cur_y) +
+ (new_x - cur_x) * (new_x - cur_x));
+ if (dist <= max_dist) {
+ // Distance between parabola and line segment is
+ // not greater than max_dist.
+ point_stack.pop();
+ coordinate_type inter_x = (segm_vec_x * new_x - segm_vec_y * new_y) /
+ sqr_segment_length + segment_site_start.x();
+ coordinate_type inter_y = (segm_vec_x * new_y + segm_vec_y * new_x) /
+ sqr_segment_length + segment_site_start.y();
+ intermediate_points.push_back(point_type(inter_x, inter_y));
+ cur_x = new_x;
+ cur_y = new_y;
+ } else {
+ point_stack.push(mid_x);
+ }
+ }
+
+ // Update last point.
+ intermediate_points.back() = last_point;
+ }
+
+ // Compute y(x) = ((x - a) * (x - a) + b * b) / (2 * b).
+ static coordinate_type parabola_y(
+ coordinate_type x, coordinate_type a, coordinate_type b) {
+ return ((x - a) * (x - a) + b * b) / (to_fpt(2.0) * b);
+ }
+
+ // Check whether extent is compatible with the edge type.
+ static bool check_extent(coordinate_type extent, EdgeType etype) {
+ switch (etype) {
+ case SEGMENT: return extent >= to_fpt(0.0) && extent <= to_fpt(1.0);
+ case RAY: return extent >= to_fpt(0.0);
+ case LINE: return true;
+ }
+ return true;
+ }
+
+ // Compute the absolute value.
+ static inline coordinate_type magnitude(coordinate_type value) {
+ return (value >= to_fpt(0.0)) ? value : -value;
+ }
+
+ // Find fT min and max values: fT = numer / denom.
+ static void clip_line(
+ coordinate_type denom, coordinate_type numer,
+ bool &fT0_used, bool &fT1_used,
+ coordinate_type &fT0, coordinate_type &fT1) {
+ if (denom > to_fpt(0.0)) {
+ if (fT1_used && numer > denom * fT1)
+ return;
+ if (!fT0_used || numer > denom * fT0) {
+ fT0_used = true;
+ fT0 = numer / denom;
+ }
+ } else if (denom < to_fpt(0.0)) {
+ if (fT0_used && numer > denom * fT0)
+ return;
+ if (!fT1_used || numer > denom * fT1) {
+ fT1_used = true;
+ fT1 = numer / denom;
+ }
+ }
+ }
+
+ // Get normalized length of the distance between:
+ // 1) point projection onto the segment;
+ // 2) start point of the segment.
+ // Return this length divided by the segment length.
+ // This is made to avoid sqrt computation during transformation from
+ // the initial space to the transformed one and vice versa.
+ // Assumption is made that projection of the point lies
+ // between the start-point and endpoint of the segment.
+ static coordinate_type get_point_projection(
+ const point_type &point,
+ const point_type &segment_start,
+ const point_type &segment_end) {
+ coordinate_type segment_vec_x = segment_end.x() - segment_start.x();
+ coordinate_type segment_vec_y = segment_end.y() - segment_start.y();
+ coordinate_type point_vec_x = point.x() - segment_start.x();
+ coordinate_type point_vec_y = point.y() - segment_start.y();
+ coordinate_type sqr_segment_length =
+ segment_vec_x * segment_vec_x + segment_vec_y * segment_vec_y;
+ coordinate_type vec_dot =
+ segment_vec_x * point_vec_x + segment_vec_y * point_vec_y;
+ return vec_dot / sqr_segment_length;
+ }
+
+ template <typename CT>
+ static coordinate_type to_fpt(const CT& value) {
+ static ctype_converter_type converter;
+ return converter(value);
+ }
+};
+} // polygon
+} // boost
+
+#endif // BOOST_POLYGON_VORONOI_UTILS
Modified: trunk/libs/polygon/test/Jamfile.v2
==============================================================================
--- trunk/libs/polygon/test/Jamfile.v2 (original)
+++ trunk/libs/polygon/test/Jamfile.v2 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -13,10 +13,22 @@
requirements
<include>.
<toolset>msvc:<asynch-exceptions>on
+ <library>/boost/test//boost_unit_test_framework
;
test-suite polygon-unit
:
- [ run gtl_boost_unit_test.cpp ]
+ [ run polygon_segment_test.cpp ]
+ [ run gtl_boost_unit_test.cpp ]
;
+test-suite voronoi-unit
+ :
+ [ run voronoi_builder_test.cpp ]
+ [ run voronoi_ctypes_test.cpp ]
+ [ run voronoi_predicates_test.cpp ]
+ [ run voronoi_robust_fpt_test.cpp ]
+ [ run voronoi_structures_test.cpp ]
+ ;
+
+
Modified: trunk/libs/polygon/test/gtl_boost_unit_test.cpp
==============================================================================
--- trunk/libs/polygon/test/gtl_boost_unit_test.cpp (original)
+++ trunk/libs/polygon/test/gtl_boost_unit_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -194,7 +194,7 @@
return o << r.get(HORIZONTAL) << ' ' << r.get(VERTICAL);
}
template <class T>
- std::ostream& operator << (std::ostream& o, const directed_line_segment_data<T>& r)
+ std::ostream& operator << (std::ostream& o, const segment_data<T>& r)
{
return o << r.get(LOW) << ' ' << r.get(HIGH);
}
@@ -3649,15 +3649,15 @@
{
using namespace gtl;
typedef point_data<int> Point;
- typedef directed_line_segment_data<int> Dls;
+ typedef segment_data<int> Segment;
Point pt1(0, 0);
Point pt2(10, 10);
Point pt3(20, 20);
Point pt4(20, 0);
- Dls dls1(pt1, pt2);
- Dls dls2(pt1, pt3);
- Dls dls3(pt1, pt4);
- Dls dls4(pt2, pt1);
+ Segment dls1(pt1, pt2);
+ Segment dls2(pt1, pt3);
+ Segment dls3(pt1, pt4);
+ Segment dls4(pt2, pt1);
bool b1 = equivalence(dls1, dls1);
bool b2 = equivalence(dls1, dls2);
bool b3 = equivalence(dls1, dls3);
@@ -3704,10 +3704,9 @@
std::cout << euclidean_distance(dls1, Point(5, 6)) << std::endl;
std::cout << euclidean_distance(dls1, Point(5, 3)) << std::endl;
std::cout << euclidean_distance(dls1, dls3) << std::endl;
- std::cout << euclidean_distance(dls1, directed_line_segment_data<int>(Point(2, 0), Point(3, 0))) << std::endl;
+ std::cout << euclidean_distance(dls1, segment_data<int>(Point(2, 0), Point(3, 0))) << std::endl;
assert_s(intersects(dls1, dls3), "intersects1");
- assert_s(!intersects(dls1, directed_line_segment_data<int>(Point(2, 0), Point(3, 0))), "intersects2");
- assert_s(boundaries_intersect(dls1, dls2), "bi");
+ assert_s(!intersects(dls1, segment_data<int>(Point(2, 0), Point(3, 0))), "intersects2");
assert_s(abuts(dls1, dls2), "abuts");
Point p;
bool ir = intersection(p, dls1, dls2);
Added: trunk/libs/polygon/test/polygon_segment_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/polygon_segment_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,367 @@
+// Boost.Polygon library polygon_segment_test.cpp file
+
+// Copyright Andrii Sydorchuk 2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#define BOOST_TEST_MODULE POLYGON_SEGMENT_TEST
+#include <boost/mpl/list.hpp>
+#include <boost/test/test_case_template.hpp>
+
+#include "boost/polygon/polygon.hpp"
+using namespace boost::polygon;
+
+typedef boost::mpl::list<int> test_types;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_data_test, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef segment_data<T> segment_type;
+ point_type point1(1, 2);
+ point_type point2(3, 4);
+ segment_type segment1(point1, point2);
+ segment_type segment2 = segment1;
+
+ BOOST_CHECK(segment1.low() == point1);
+ BOOST_CHECK(segment1.high() == point2);
+ BOOST_CHECK(segment1.get(LOW) == point1);
+ BOOST_CHECK(segment1.get(HIGH) == point2);
+ BOOST_CHECK(segment1 == segment2);
+ BOOST_CHECK(!(segment1 != segment2));
+ BOOST_CHECK(!(segment1 < segment2));
+ BOOST_CHECK(!(segment1 > segment1));
+ BOOST_CHECK(segment1 <= segment2);
+ BOOST_CHECK(segment1 >= segment2);
+
+ segment1.low(point2);
+ segment1.high(point1);
+ BOOST_CHECK(segment1.low() == point2);
+ BOOST_CHECK(segment1.high() == point1);
+ BOOST_CHECK(!(segment1 == segment2));
+ BOOST_CHECK(segment1 != segment2);
+
+ segment2.set(LOW, point2);
+ segment2.set(HIGH, point1);
+ BOOST_CHECK(segment1 == segment2);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_traits_test, T, test_types) {
+ typedef point_data<T> point_type ;
+ typedef segment_data<T> segment_type;
+
+ point_type point1(1, 2);
+ point_type point2(3, 4);
+ segment_type segment = segment_mutable_traits<segment_type>::construct(point1, point2);
+
+ BOOST_CHECK(segment_traits<segment_type>::get(segment, LOW) == point1);
+ BOOST_CHECK(segment_traits<segment_type>::get(segment, HIGH) == point2);
+
+ segment_mutable_traits<segment_type>::set(segment, LOW, point2);
+ segment_mutable_traits<segment_type>::set(segment, HIGH, point1);
+
+ BOOST_CHECK(segment_traits<segment_type>::get(segment, LOW) == point2);
+ BOOST_CHECK(segment_traits<segment_type>::get(segment, HIGH) == point1);
+}
+
+template <typename T>
+struct Segment {
+ point_data<T> p0;
+ point_data<T> p1;
+};
+
+namespace boost {
+namespace polygon {
+ template <typename T>
+ struct geometry_concept< Segment<T> > { typedef segment_concept type; };
+
+ template <typename T>
+ struct segment_traits< Segment<T> > {
+ typedef T coordinate_type;
+ typedef point_data<T> point_type;
+
+ static point_type get(const Segment<T>& segment, direction_1d dir) {
+ return dir.to_int() ? segment.p1 : segment.p0;
+ }
+ };
+
+ template <typename T>
+ struct segment_mutable_traits< Segment<T> > {
+ typedef point_data<T> point_type;
+
+ static inline void set(Segment<T>& segment, direction_1d dir, const point_type& point) {
+ if (dir.to_int()) {
+ segment.p1 = point;
+ } else {
+ segment.p0 = point;
+ }
+ }
+
+ static inline Segment<T> construct(const point_type& point1, const point_type& point2) {
+ Segment<T> segment;
+ segment.p0 = point1;
+ segment.p1 = point2;
+ return segment;
+ }
+ };
+}
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test1, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(1, 2);
+ point_type point2(3, 4);
+ point_type point3(2, 3);
+ segment_type segment1 = construct<segment_type>(point1, point2);
+ BOOST_CHECK(segment1.p0 == point1);
+ BOOST_CHECK(segment1.p1 == point2);
+ BOOST_CHECK(get(segment1, LOW) == point1);
+ BOOST_CHECK(low(segment1) == point1);
+ BOOST_CHECK(get(segment1, HIGH) == point2);
+ BOOST_CHECK(high(segment1) == point2);
+ BOOST_CHECK(center(segment1) == point3);
+
+ set(segment1, LOW, point2);
+ set(segment1, HIGH, point1);
+ BOOST_CHECK(segment1.p0 == point2);
+ BOOST_CHECK(segment1.p1 == point1);
+ BOOST_CHECK(get(segment1, LOW) == point2);
+ BOOST_CHECK(get(segment1, HIGH) == point1);
+ low(segment1, point1);
+ high(segment1, point2);
+ BOOST_CHECK(segment1.p0 == point1);
+ BOOST_CHECK(segment1.p1 == point2);
+
+ segment_data<T> segment2 = copy_construct< segment_data<T> >(segment1);
+ BOOST_CHECK(segment1.p0 == segment2.low());
+ BOOST_CHECK(segment1.p1 == segment2.high());
+ BOOST_CHECK(equivalence(segment1, segment2));
+
+ segment_data<T> segment3 = construct< segment_data<T> >(point2, point1);
+ assign(segment1, segment3);
+ BOOST_CHECK(segment1.p0 == point2);
+ BOOST_CHECK(segment1.p1 == point1);
+ BOOST_CHECK(!equivalence(segment1, segment2));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test2, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(1, 2);
+ point_type point2(2, 4);
+ point_type point3(0, 0);
+ point_type point4(5, 10);
+ point_type point5(1, 3);
+ point_type point6(2, 3);
+ point_type point7(100, 201);
+ point_type point8(100, 200);
+ point_type point9(100, 199);
+ segment_type segment = construct<segment_type>(point1, point2);
+
+ BOOST_CHECK(on_above_or_below(segment, point1) == 0);
+ BOOST_CHECK(on_above_or_below(segment, point2) == 0);
+ BOOST_CHECK(on_above_or_below(segment, point3) == 0);
+ BOOST_CHECK(on_above_or_below(segment, point4) == 0);
+ BOOST_CHECK(on_above_or_below(segment, point5) == 1);
+ BOOST_CHECK(on_above_or_below(segment, point6) == -1);
+ BOOST_CHECK(on_above_or_below(segment, point7) == 1);
+ BOOST_CHECK(on_above_or_below(segment, point8) == 0);
+ BOOST_CHECK(on_above_or_below(segment, point9) == -1);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test3, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(1, 2);
+ point_type point2(3, 6);
+ point_type point3(2, 4);
+ point_type point4(4, 8);
+ point_type point5(0, 0);
+ segment_type segment = construct<segment_type>(point1, point2);
+
+ BOOST_CHECK(contains(segment, point1, true));
+ BOOST_CHECK(contains(segment, point2, true));
+ BOOST_CHECK(!contains(segment, point1, false));
+ BOOST_CHECK(!contains(segment, point2, false));
+ BOOST_CHECK(contains(segment, point3, false));
+ BOOST_CHECK(!contains(segment, point4, true));
+ BOOST_CHECK(!contains(segment, point5, true));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test4, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(0, 0);
+ point_type point2(10, 0);
+ point_type point3(5, 0);
+ point_type point4(-1, 0);
+ point_type point5(11, 0);
+ segment_type segment = construct<segment_type>(point1, point2);
+
+ BOOST_CHECK(contains(segment, point1, true));
+ BOOST_CHECK(contains(segment, point2, true));
+ BOOST_CHECK(!contains(segment, point1, false));
+ BOOST_CHECK(!contains(segment, point2, false));
+ BOOST_CHECK(contains(segment, point3, false));
+ BOOST_CHECK(!contains(segment, point4, true));
+ BOOST_CHECK(!contains(segment, point5, true));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test5, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(0, 0);
+ point_type point2(1, 2);
+ point_type point3(2, 4);
+ point_type point4(3, 6);
+ point_type point5(4, 8);
+ point_type point6(5, 10);
+ segment_type segment1 = construct<segment_type>(point2, point5);
+ segment_type segment2 = construct<segment_type>(point3, point4);
+ segment_type segment3 = construct<segment_type>(point1, point3);
+ segment_type segment4 = construct<segment_type>(point4, point6);
+
+ BOOST_CHECK(contains(segment1, segment2, false));
+ BOOST_CHECK(!contains(segment2, segment1, true));
+ BOOST_CHECK(!contains(segment1, segment3, true));
+ BOOST_CHECK(!contains(segment1, segment4, true));
+ BOOST_CHECK(contains(segment1, segment1, true));
+ BOOST_CHECK(!contains(segment1, segment1, false));
+}
+
+template<typename T>
+struct Transformer {
+ void scale(T& x, T& y) const {
+ x *= 2;
+ y *= 2;
+ }
+
+ void transform(T& x, T& y) const {
+ T tmp = x;
+ x = y;
+ y = tmp;
+ }
+};
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test6, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(1, 2);
+ point_type point2(4, 6);
+ segment_type segment1 = construct<segment_type>(point1, point2);
+
+ scale_up(segment1, 3);
+ BOOST_CHECK(low(segment1) == point_type(3, 6));
+ BOOST_CHECK(high(segment1) == point_type(12, 18));
+
+ scale_down(segment1, 3);
+ BOOST_CHECK(low(segment1) == point1);
+ BOOST_CHECK(high(segment1) == point2);
+ BOOST_CHECK(length(segment1) == 5);
+
+ move(segment1, HORIZONTAL, 1);
+ move(segment1, VERTICAL, 2);
+ BOOST_CHECK(low(segment1) == point_type(2, 4));
+ BOOST_CHECK(high(segment1) == point_type(5, 8));
+ BOOST_CHECK(length(segment1) == 5);
+
+ convolve(segment1, point_type(1, 2));
+ BOOST_CHECK(low(segment1) == point_type(3, 6));
+ BOOST_CHECK(high(segment1) == point_type(6, 10));
+
+ deconvolve(segment1, point_type(2, 4));
+ BOOST_CHECK(low(segment1) == point1);
+ BOOST_CHECK(high(segment1) == point2);
+
+ scale(segment1, Transformer<T>());
+ BOOST_CHECK(low(segment1) == point_type(2, 4));
+ BOOST_CHECK(high(segment1) == point_type(8, 12));
+ transform(segment1, Transformer<T>());
+ BOOST_CHECK(low(segment1) == point_type(4, 2));
+ BOOST_CHECK(high(segment1) == point_type(12, 8));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test7, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ segment_type segment1 = construct<segment_type>(point_type(0, 0), point_type(1, 2));
+ segment_type segment2 = construct<segment_type>(point_type(1, 2), point_type(2, 4));
+ segment_type segment3 = construct<segment_type>(point_type(2, 4), point_type(0, 4));
+ segment_type segment4 = construct<segment_type>(point_type(0, 4), point_type(0, 0));
+
+ BOOST_CHECK(abuts(segment1, segment2, HIGH));
+ BOOST_CHECK(abuts(segment2, segment3, HIGH));
+ BOOST_CHECK(abuts(segment3, segment4, HIGH));
+ BOOST_CHECK(abuts(segment4, segment1, HIGH));
+
+ BOOST_CHECK(!abuts(segment1, segment2, LOW));
+ BOOST_CHECK(!abuts(segment2, segment3, LOW));
+ BOOST_CHECK(!abuts(segment3, segment4, LOW));
+ BOOST_CHECK(!abuts(segment4, segment1, LOW));
+
+ BOOST_CHECK(abuts(segment2, segment1));
+ BOOST_CHECK(abuts(segment3, segment2));
+ BOOST_CHECK(abuts(segment4, segment3));
+ BOOST_CHECK(abuts(segment1, segment4));
+
+ BOOST_CHECK(!abuts(segment1, segment3));
+ BOOST_CHECK(!abuts(segment2, segment4));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test8, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point;
+ segment_type segment1 = construct<segment_type>(point_type(0, 0), point_type(2, 2));
+ segment_type segment2 = construct<segment_type>(point_type(1, 1), point_type(3, 3));
+
+ BOOST_CHECK(!intersection(point, segment1, segment2));
+ BOOST_CHECK(intersects(segment1, segment2));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test9, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point1(1, 2);
+ point_type point2(7, 10);
+ segment_type segment1 = construct<segment_type>(point1, point2);
+
+ BOOST_CHECK(euclidean_distance(segment1, point1) == 0.0);
+ BOOST_CHECK(euclidean_distance(segment1, point2) == 0.0);
+ BOOST_CHECK(euclidean_distance(segment1, point_type(10, 14)) == 5.0);
+ BOOST_CHECK(euclidean_distance(segment1, point_type(-3, -1)) == 5.0);
+ BOOST_CHECK(euclidean_distance(segment1, point_type(0, 9)) == 5.0);
+ BOOST_CHECK(euclidean_distance(segment1, point_type(8, 3)) == 5.0);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test10, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ segment_type segment1 = construct<segment_type>(point_type(0, 0), point_type(3, 4));
+ segment_type segment2 = construct<segment_type>(point_type(2, 0), point_type(0, 2));
+ segment_type segment3 = construct<segment_type>(point_type(1, -7), point_type(10, 5));
+ segment_type segment4 = construct<segment_type>(point_type(7, 7), point_type(10, 11));
+ segment_type segment5 = construct<segment_type>(point_type(1, 1), point_type(-1, 3));
+ segment_type segment6 = construct<segment_type>(point_type(0, 0), point_type(1, 1));
+
+ BOOST_CHECK(intersects(segment1, segment2, false));
+ BOOST_CHECK(euclidean_distance(segment1, segment2) == 0.0);
+ BOOST_CHECK(!intersects(segment1, segment3, true));
+ BOOST_CHECK(euclidean_distance(segment1, segment3) == 5.0);
+ BOOST_CHECK(!intersects(segment1, segment4, true));
+ BOOST_CHECK(euclidean_distance(segment1, segment4) == 5.0);
+ BOOST_CHECK(intersects(segment2, segment5, false));
+ BOOST_CHECK(intersects(segment2, segment6, false));
+}
Added: trunk/libs/polygon/test/voronoi_builder_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/voronoi_builder_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,608 @@
+// Boost.Polygon library voronoi_builder_test.cpp file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ctime>
+
+#define BOOST_TEST_MODULE voronoi_builder_test
+#include <boost/mpl/list.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/test/test_case_template.hpp>
+
+#include <boost/polygon/polygon.hpp>
+#include <boost/polygon/voronoi.hpp>
+using namespace boost::polygon;
+#include "voronoi_test_helper.hpp"
+
+typedef boost::mpl::list<int> test_types;
+typedef voronoi_diagram<double> vd_type;
+typedef vd_type::coordinate_type coordinate_type;
+typedef vd_type::edge_type voronoi_edge_type;
+typedef vd_type::const_cell_iterator const_cell_iterator;
+typedef vd_type::const_vertex_iterator const_vertex_iterator;
+
+#define CHECK_EQUAL_POINTS(p1, p2) \
+ BOOST_CHECK(p1.x() == static_cast<T>(p2.x())); \
+ BOOST_CHECK(p1.y() == static_cast<T>(p2.y()))
+
+#define CHECK_OUTPUT_SIZE(output, cells, vertices, edges) \
+ BOOST_CHECK(output.num_cells() == cells); \
+ BOOST_CHECK(output.num_vertices() == vertices); \
+ BOOST_CHECK(output.num_edges() == edges)
+
+#define VERIFY_OUTPUT(output) \
+ BOOST_CHECK(voronoi_test_helper::verify_output(output, \
+ voronoi_test_helper::HALF_EDGE_ORIENTATION)); \
+ BOOST_CHECK(voronoi_test_helper::verify_output(output, \
+ voronoi_test_helper::CELL_CONVEXITY)); \
+ BOOST_CHECK(voronoi_test_helper::verify_output(output, \
+ voronoi_test_helper::INCIDENT_EDGES_CCW_ORDER)); \
+ BOOST_CHECK(voronoi_test_helper::verify_output(output, \
+ voronoi_test_helper::NO_HALF_EDGE_INTERSECTIONS))
+
+#define VERIFY_NO_HALF_EDGE_INTERSECTIONS(output) \
+ BOOST_CHECK(voronoi_test_helper::verify_output(output, \
+ voronoi_test_helper::NO_HALF_EDGE_INTERSECTIONS))
+
+// Sites: (0, 0).
+BOOST_AUTO_TEST_CASE_TEMPLATE(single_site_test, T, test_types) {
+ std::vector< point_data<T> > points;
+ points.push_back(point_data<T>(0, 0));
+ vd_type test_output;
+ construct_voronoi(points.begin(), points.end(), &test_output);
+ VERIFY_OUTPUT(test_output);
+
+ BOOST_CHECK(test_output.cells().size() == 1);
+ CHECK_OUTPUT_SIZE(test_output, 1, 0, 0);
+
+ const_cell_iterator it = test_output.cells().begin();
+ BOOST_CHECK(it->incident_edge() == NULL);
+}
+
+// Sites: (0, 0), (0, 1).
+BOOST_AUTO_TEST_CASE_TEMPLATE(collinear_sites_test1, T, test_types) {
+ std::vector< point_data<T> > points;
+ points.push_back(point_data<T>(0, 0));
+ points.push_back(point_data<T>(0, 1));
+ vd_type test_output;
+ construct_voronoi(points.begin(), points.end(), &test_output);
+ VERIFY_OUTPUT(test_output);
+ CHECK_OUTPUT_SIZE(test_output, 2, 0, 1);
+
+ const_cell_iterator cell_it = test_output.cells().begin();
+ cell_it++;
+
+ const voronoi_edge_type *edge1_1 = cell_it->incident_edge();
+ const voronoi_edge_type *edge1_2 = edge1_1->twin();
+
+ BOOST_CHECK_EQUAL(edge1_1->twin() == edge1_2, true);
+ BOOST_CHECK_EQUAL(edge1_2->twin() == edge1_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->next() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge1_1->prev() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge1_1->rot_next() == NULL, true);
+ BOOST_CHECK_EQUAL(edge1_1->rot_prev() == NULL, true);
+
+ BOOST_CHECK_EQUAL(edge1_2->next() == edge1_2, true);
+ BOOST_CHECK_EQUAL(edge1_2->prev() == edge1_2, true);
+ BOOST_CHECK_EQUAL(edge1_2->rot_next() == NULL, true);
+ BOOST_CHECK_EQUAL(edge1_2->rot_prev() == NULL, true);
+}
+
+// Sites: (0, 0), (1, 1), (2, 2).
+BOOST_AUTO_TEST_CASE_TEMPLATE(collinear_sites_test2, T, test_types) {
+ std::vector< point_data<T> > points;
+ points.push_back(point_data<T>(0, 0));
+ points.push_back(point_data<T>(1, 1));
+ points.push_back(point_data<T>(2, 2));
+ vd_type test_output;
+ construct_voronoi(points.begin(), points.end(), &test_output);
+ VERIFY_OUTPUT(test_output);
+ CHECK_OUTPUT_SIZE(test_output, 3, 0, 2);
+
+ const_cell_iterator cell_it = test_output.cells().begin();
+ const voronoi_edge_type *edge1_1 = cell_it->incident_edge();
+ const voronoi_edge_type *edge1_2 = edge1_1->twin();
+ cell_it++;
+ cell_it++;
+ const voronoi_edge_type *edge2_2 = cell_it->incident_edge();
+ const voronoi_edge_type *edge2_1 = edge2_2->twin();
+
+ BOOST_CHECK_EQUAL(edge1_1->twin() == edge1_2 && edge1_2->twin() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge2_1->twin() == edge2_2 && edge2_2->twin() == edge2_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->next() == edge1_1 && edge1_1->prev() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge1_1->rot_next() == NULL && edge1_1->rot_prev() == NULL, true);
+ BOOST_CHECK_EQUAL(edge1_2->rot_next() == NULL && edge1_2->rot_prev() == NULL, true);
+ BOOST_CHECK_EQUAL(edge2_1->rot_next() == NULL && edge2_1->rot_prev() == NULL, true);
+ BOOST_CHECK_EQUAL(edge2_2->next() == edge2_2 && edge2_2->prev() == edge2_2, true);
+ BOOST_CHECK_EQUAL(edge2_2->rot_next() == NULL && edge2_2->rot_prev() == NULL, true);
+
+ BOOST_CHECK_EQUAL(edge1_2->next() == edge2_1 && edge1_2->prev() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_1->next() == edge1_2 && edge2_1->prev() == edge1_2, true);
+}
+
+// Sites: (0, 0), (0, 4), (2, 1).
+BOOST_AUTO_TEST_CASE_TEMPLATE(triangle_test1, T, test_types) {
+ point_data<T> point1(0, 0);
+ point_data<T> point2(0, 4);
+ point_data<T> point3(2, 1);
+ std::vector< point_data<T> > points;
+ points.push_back(point1);
+ points.push_back(point2);
+ points.push_back(point3);
+ vd_type test_output;
+ construct_voronoi(points.begin(), points.end(), &test_output);
+ VERIFY_OUTPUT(test_output);
+ CHECK_OUTPUT_SIZE(test_output, 3, 1, 3);
+
+ const_vertex_iterator it = test_output.vertices().begin();
+ BOOST_CHECK_EQUAL(it->vertex().x() == static_cast<coordinate_type>(0.25) &&
+ it->vertex().y() == static_cast<coordinate_type>(2.0), true);
+
+ const voronoi_edge_type *edge1_1 = it->incident_edge();
+ const voronoi_edge_type *edge1_2 = edge1_1->twin();
+ CHECK_EQUAL_POINTS(edge1_1->cell()->point0(), point2);
+ CHECK_EQUAL_POINTS(edge1_2->cell()->point0(), point3);
+
+ const voronoi_edge_type *edge2_1 = edge1_1->rot_prev();
+ const voronoi_edge_type *edge2_2 = edge2_1->twin();
+ CHECK_EQUAL_POINTS(edge2_1->cell()->point0(), point3);
+ CHECK_EQUAL_POINTS(edge2_2->cell()->point0(), point1);
+
+ const voronoi_edge_type *edge3_1 = edge2_1->rot_prev();
+ const voronoi_edge_type *edge3_2 = edge3_1->twin();
+ CHECK_EQUAL_POINTS(edge3_1->cell()->point0(), point1);
+ CHECK_EQUAL_POINTS(edge3_2->cell()->point0(), point2);
+
+ BOOST_CHECK_EQUAL(edge1_2->twin() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge2_2->twin() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge3_2->twin() == edge3_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->prev() == edge3_2 && edge1_1->next() == edge3_2, true);
+ BOOST_CHECK_EQUAL(edge2_1->prev() == edge1_2 && edge2_1->next() == edge1_2, true);
+ BOOST_CHECK_EQUAL(edge3_1->prev() == edge2_2 && edge3_1->next() == edge2_2, true);
+
+ BOOST_CHECK_EQUAL(edge1_2->next() == edge2_1 && edge1_2->prev() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_2->next() == edge3_1 && edge2_2->prev() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge3_2->next() == edge1_1 && edge3_2->prev() == edge1_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->rot_next() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge3_1->rot_next() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_1->rot_next() == edge1_1, true);
+}
+
+// Sites: (0, 1), (2, 0), (2, 4).
+BOOST_AUTO_TEST_CASE_TEMPLATE(triangle_test2, T, test_types) {
+ point_data<T> point1(0, 1);
+ point_data<T> point2(2, 0);
+ point_data<T> point3(2, 4);
+ std::vector< point_data<T> > points;
+ points.push_back(point1);
+ points.push_back(point2);
+ points.push_back(point3);
+ vd_type test_output;
+ construct_voronoi(points.begin(), points.end(), &test_output);
+ VERIFY_OUTPUT(test_output);
+ CHECK_OUTPUT_SIZE(test_output, 3, 1, 3);
+
+ const_vertex_iterator it = test_output.vertices().begin();
+ BOOST_CHECK_EQUAL(it->vertex().x() == static_cast<coordinate_type>(1.75) &&
+ it->vertex().y() == static_cast<coordinate_type>(2.0), true);
+
+ const voronoi_edge_type *edge1_1 = it->incident_edge();
+ const voronoi_edge_type *edge1_2 = edge1_1->twin();
+ CHECK_EQUAL_POINTS(edge1_1->cell()->point0(), point3);
+ CHECK_EQUAL_POINTS(edge1_2->cell()->point0(), point2);
+
+ const voronoi_edge_type *edge2_1 = edge1_1->rot_prev();
+ const voronoi_edge_type *edge2_2 = edge2_1->twin();
+ CHECK_EQUAL_POINTS(edge2_1->cell()->point0(), point2);
+ CHECK_EQUAL_POINTS(edge2_2->cell()->point0(), point1);
+
+ const voronoi_edge_type *edge3_1 = edge2_1->rot_prev();
+ const voronoi_edge_type *edge3_2 = edge3_1->twin();
+ CHECK_EQUAL_POINTS(edge3_1->cell()->point0(), point1);
+ CHECK_EQUAL_POINTS(edge3_2->cell()->point0(), point3);
+
+ BOOST_CHECK_EQUAL(edge1_2->twin() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge2_2->twin() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge3_2->twin() == edge3_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->prev() == edge3_2 && edge1_1->next() == edge3_2, true);
+ BOOST_CHECK_EQUAL(edge2_1->prev() == edge1_2 && edge2_1->next() == edge1_2, true);
+ BOOST_CHECK_EQUAL(edge3_1->prev() == edge2_2 && edge3_1->next() == edge2_2, true);
+
+ BOOST_CHECK_EQUAL(edge1_2->next() == edge2_1 && edge1_2->prev() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_2->next() == edge3_1 && edge2_2->prev() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge3_2->next() == edge1_1 && edge3_2->prev() == edge1_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->rot_next() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge3_1->rot_next() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_1->rot_next() == edge1_1, true);
+}
+
+// Sites: (0, 0), (0, 1), (1, 0), (1, 1).
+BOOST_AUTO_TEST_CASE_TEMPLATE(square_test1, T, test_types) {
+ point_data<T> point1(0, 0);
+ point_data<T> point2(0, 1);
+ point_data<T> point3(1, 0);
+ point_data<T> point4(1, 1);
+ std::vector< point_data<T> > points;
+ points.push_back(point1);
+ points.push_back(point2);
+ points.push_back(point3);
+ points.push_back(point4);
+ vd_type test_output;
+ construct_voronoi(points.begin(), points.end(), &test_output);
+ VERIFY_OUTPUT(test_output);
+ CHECK_OUTPUT_SIZE(test_output, 4, 1, 4);
+
+ // Check voronoi vertex.
+ const_vertex_iterator it = test_output.vertices().begin();
+ BOOST_CHECK_EQUAL(it->vertex().x() == static_cast<coordinate_type>(0.5) &&
+ it->vertex().y() == static_cast<coordinate_type>(0.5), true);
+
+ // Check voronoi edges.
+ const voronoi_edge_type *edge1_1 = it->incident_edge();
+ const voronoi_edge_type *edge1_2 = edge1_1->twin();
+ CHECK_EQUAL_POINTS(edge1_1->cell()->point0(), points[3]);
+ CHECK_EQUAL_POINTS(edge1_2->cell()->point0(), points[2]);
+
+ const voronoi_edge_type *edge2_1 = edge1_1->rot_prev();
+ const voronoi_edge_type *edge2_2 = edge2_1->twin();
+ CHECK_EQUAL_POINTS(edge2_1->cell()->point0(), points[2]);
+ CHECK_EQUAL_POINTS(edge2_2->cell()->point0(), points[0]);
+
+ const voronoi_edge_type *edge3_1 = edge2_1->rot_prev();
+ const voronoi_edge_type *edge3_2 = edge3_1->twin();
+ CHECK_EQUAL_POINTS(edge3_1->cell()->point0(), points[0]);
+ CHECK_EQUAL_POINTS(edge3_2->cell()->point0(), points[1]);
+
+ const voronoi_edge_type *edge4_1 = edge3_1->rot_prev();
+ const voronoi_edge_type *edge4_2 = edge4_1->twin();
+ CHECK_EQUAL_POINTS(edge4_1->cell()->point0(), points[1]);
+ CHECK_EQUAL_POINTS(edge4_2->cell()->point0(), points[3]);
+
+ BOOST_CHECK_EQUAL(edge1_2->twin() == edge1_1, true);
+ BOOST_CHECK_EQUAL(edge2_2->twin() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge3_2->twin() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge4_2->twin() == edge4_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->prev() == edge4_2 && edge1_1->next() == edge4_2, true);
+ BOOST_CHECK_EQUAL(edge2_1->prev() == edge1_2 && edge2_1->next() == edge1_2, true);
+ BOOST_CHECK_EQUAL(edge3_1->prev() == edge2_2 && edge3_1->next() == edge2_2, true);
+ BOOST_CHECK_EQUAL(edge4_1->prev() == edge3_2 && edge4_1->next() == edge3_2, true);
+
+ BOOST_CHECK_EQUAL(edge1_2->next() == edge2_1 && edge1_2->prev() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_2->next() == edge3_1 && edge2_2->prev() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge3_2->next() == edge4_1 && edge3_2->prev() == edge4_1, true);
+ BOOST_CHECK_EQUAL(edge4_2->next() == edge1_1 && edge4_2->prev() == edge1_1, true);
+
+ BOOST_CHECK_EQUAL(edge1_1->rot_next() == edge4_1, true);
+ BOOST_CHECK_EQUAL(edge4_1->rot_next() == edge3_1, true);
+ BOOST_CHECK_EQUAL(edge3_1->rot_next() == edge2_1, true);
+ BOOST_CHECK_EQUAL(edge2_1->rot_next() == edge1_1, true);
+}
+
+#ifdef NDEBUG
+BOOST_AUTO_TEST_CASE_TEMPLATE(grid_test, T, test_types) {
+ vd_type test_output_small, test_output_large;
+ std::vector< point_data<T> > point_vec_small, point_vec_large;
+ int grid_size[] = {10, 33, 101};
+ int max_value[] = {10, 33, 101};
+ int array_length = sizeof(grid_size) / sizeof(int);
+ for (int k = 0; k < array_length; k++) {
+ test_output_small.clear();
+ test_output_large.clear();
+ point_vec_small.clear();
+ point_vec_large.clear();
+ int koef = std::numeric_limits<int>::max() / max_value[k];
+ for (int i = 0; i < grid_size[k]; i++)
+ for (int j = 0; j < grid_size[k]; j++) {
+ point_vec_small.push_back(point_data<T>(i, j));
+ point_vec_large.push_back(point_data<T>(koef * i, koef * j));
+ }
+ construct_voronoi(point_vec_small.begin(), point_vec_small.end(), &test_output_small);
+ construct_voronoi(point_vec_large.begin(), point_vec_large.end(), &test_output_large);
+ VERIFY_OUTPUT(test_output_small);
+ VERIFY_OUTPUT(test_output_large);
+ unsigned int num_cells = grid_size[k] * grid_size[k];
+ unsigned int num_vertices = num_cells - 2 * grid_size[k] + 1;
+ unsigned int num_edges = 2 * num_cells - 2 * grid_size[k];
+ CHECK_OUTPUT_SIZE(test_output_small, num_cells, num_vertices, num_edges);
+ CHECK_OUTPUT_SIZE(test_output_large, num_cells, num_vertices, num_edges);
+ }
+}
+#endif
+
+#ifdef NDEBUG
+BOOST_AUTO_TEST_CASE_TEMPLATE(random_test, T, test_types) {
+ boost::mt19937 gen(static_cast<unsigned int>(time(NULL)));
+ vd_type test_output_small, test_output_large;
+ std::vector< point_data<T> > point_vec_small, point_vec_large;
+ int num_points[] = {10, 100, 1000, 10000};
+ int num_runs[] = {1000, 100, 10, 1};
+ int mod_koef[] = {10, 100, 100, 1000};
+ int max_value[] = {5, 50, 50, 5000};
+ int array_length = sizeof(num_points) / sizeof(int);
+ for (int k = 0; k < array_length; k++) {
+ int koef = std::numeric_limits<int>::max() / max_value[k];
+ for (int i = 0; i < num_runs[k]; i++) {
+ test_output_small.clear();
+ test_output_large.clear();
+ point_vec_small.clear();
+ point_vec_large.clear();
+ for (int j = 0; j < num_points[k]; j++) {
+ T x = gen() % mod_koef[k] - mod_koef[k] / 2;
+ T y = gen() % mod_koef[k] - mod_koef[k] / 2;
+ point_vec_small.push_back(point_data<T>(x, y));
+ point_vec_large.push_back(point_data<T>(koef * x, koef * y));
+ }
+ construct_voronoi(point_vec_small.begin(), point_vec_small.end(), &test_output_small);
+ construct_voronoi(point_vec_large.begin(), point_vec_large.end(), &test_output_large);
+ VERIFY_OUTPUT(test_output_small);
+ VERIFY_OUTPUT(test_output_large);
+ BOOST_CHECK_EQUAL(test_output_small.num_cells(), test_output_large.num_cells());
+ BOOST_CHECK_EQUAL(test_output_small.num_vertices(), test_output_large.num_vertices());
+ BOOST_CHECK_EQUAL(test_output_small.num_edges(), test_output_large.num_edges());
+ }
+ }
+}
+#endif
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_sites_test1, T, test_types) {
+ vd_type test_output;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(0, 0);
+ point_data<T> point2(1, 1);
+ segments.push_back(segment_data<T>(point1, point2));
+ construct_voronoi(segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 3, 0, 2);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_sites_test2, T, test_types) {
+ vd_type test_output;
+ std::vector< point_data<T> > points;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(0, 0);
+ point_data<T> point2(4, 4);
+ point_data<T> point3(3, 1);
+ point_data<T> point4(1, 3);
+ segments.push_back(segment_data<T>(point1, point2));
+ points.push_back(point3);
+ points.push_back(point4);
+ construct_voronoi(points.begin(), points.end(), segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 5, 4, 8);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_sites_test3, T, test_types) {
+ vd_type test_output;
+ std::vector< point_data<T> > points;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(4, 0);
+ point_data<T> point2(0, 4);
+ point_data<T> point3(3, 3);
+ point_data<T> point4(1, 1);
+ segments.push_back(segment_data<T>(point1, point2));
+ points.push_back(point3);
+ points.push_back(point4);
+ construct_voronoi(points.begin(), points.end(), segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 5, 4, 8);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_sites_test4, T, test_types) {
+ vd_type test_output;
+ std::vector< point_data<T> > points;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(4, 0);
+ point_data<T> point2(0, 4);
+ point_data<T> point3(3, 2);
+ point_data<T> point4(2, 3);
+ segments.push_back(segment_data<T>(point1, point2));
+ points.push_back(point3);
+ points.push_back(point4);
+ construct_voronoi(points.begin(), points.end(), segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 5, 3, 7);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_site_test5, T, test_types) {
+ vd_type test_output;
+ std::vector< point_data<T> > points;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(0, 0);
+ point_data<T> point2(0, 8);
+ point_data<T> point3(-2, -2);
+ point_data<T> point4(-2, 4);
+ point_data<T> point5(-2, 10);
+ segments.push_back(segment_data<T>(point1, point2));
+ points.push_back(point3);
+ points.push_back(point4);
+ points.push_back(point5);
+ construct_voronoi(points.begin(), points.end(), segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 6, 4, 9);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_site_test6, T, test_types) {
+ vd_type test_output;
+ std::vector< point_data<T> > points;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(-1, 1);
+ point_data<T> point2(1, 0);
+ point_data<T> point3(1, 2);
+ segments.push_back(segment_data<T>(point2, point3));
+ points.push_back(point1);
+ construct_voronoi(points.begin(), points.end(), segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 4, 2, 5);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_site_test7, T, test_types) {
+ vd_type test_output;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(0, 0);
+ point_data<T> point2(4, 0);
+ point_data<T> point3(0, 4);
+ point_data<T> point4(4, 4);
+ segments.push_back(segment_data<T>(point1, point2));
+ segments.push_back(segment_data<T>(point2, point3));
+ segments.push_back(segment_data<T>(point3, point4));
+ construct_voronoi(segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 7, 6, 12);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_site_test8, T, test_types) {
+ vd_type test_output;
+ std::vector< segment_data<T> > segments;
+ point_data<T> point1(0, 0);
+ point_data<T> point2(4, 0);
+ point_data<T> point3(4, 4);
+ point_data<T> point4(0, 4);
+ segments.push_back(segment_data<T>(point1, point2));
+ segments.push_back(segment_data<T>(point2, point3));
+ segments.push_back(segment_data<T>(point3, point4));
+ segments.push_back(segment_data<T>(point4, point1));
+ construct_voronoi(segments.begin(), segments.end(), &test_output);
+ CHECK_OUTPUT_SIZE(test_output, 8, 5, 12);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+}
+
+#ifdef NDEBUG
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_grid_test, T, test_types) {
+ vd_type test_output_small, test_output_large;
+ std::vector< segment_data<T> > segments_small, segments_large;
+ int grid_size[] = {10, 27, 53};
+ int max_value[] = {100, 330, 1000};
+ int array_length = sizeof(grid_size) / sizeof(int);
+ for (int k = 0; k < array_length; k++) {
+ test_output_small.clear();
+ test_output_large.clear();
+ segments_small.clear();
+ segments_large.clear();
+ int cur_sz = grid_size[k];
+ int koef = std::numeric_limits<int>::max() / max_value[k];
+ for (int i = 0; i < cur_sz + 1; i++)
+ for (int j = 0; j < cur_sz; j++) {
+ point_data<T> point1_1(10 * i, 10 * j);
+ point_data<T> point1_2(koef * 10 * i, koef * 10 * j);
+ point_data<T> point2_1(10 * i, 10 * j + 10);
+ point_data<T> point2_2(koef * 10 * i, koef * (10 * j + 10));
+ segments_small.push_back(segment_data<T>(point1_1, point2_1));
+ segments_large.push_back(segment_data<T>(point1_2, point2_2));
+ point_data<T> point3_1(10 * j, 10 * i);
+ point_data<T> point3_2(koef * 10 * j, koef * 10 * i);
+ point_data<T> point4_1(10 * j + 10, 10 * i);
+ point_data<T> point4_2(koef * (10 * j + 10), koef * 10 * i);
+ segments_small.push_back(segment_data<T>(point3_1, point4_1));
+ segments_large.push_back(segment_data<T>(point3_2, point4_2));
+ }
+ construct_voronoi(segments_small.begin(), segments_small.end(), &test_output_small);
+ construct_voronoi(segments_large.begin(), segments_large.end(), &test_output_large);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output_small);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output_large);
+ BOOST_CHECK_EQUAL(test_output_small.num_cells(), test_output_large.num_cells());
+ BOOST_CHECK_EQUAL(test_output_small.num_vertices(), test_output_large.num_vertices());
+ BOOST_CHECK_EQUAL(test_output_small.num_edges(), test_output_large.num_edges());
+ }
+}
+#endif
+
+#ifdef NDEBUG
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_random_test1, T, test_types) {
+ boost::mt19937 gen(static_cast<unsigned int>(time(NULL)));
+ vd_type test_output;
+ std::vector< point_data<T> > points;
+ std::vector< segment_data<T> > segments;
+ int num_runs = 1000;
+ int num_segments = 10;
+ points.push_back(point_data<T>(-100, -100));
+ points.push_back(point_data<T>(-100, 100));
+ points.push_back(point_data<T>(100, -100));
+ points.push_back(point_data<T>(100, 100));
+ for (int i = 0; i < num_runs; i++) {
+ test_output.clear();
+ segments.clear();
+ for (int j = 0; j < num_segments; j++) {
+ T x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+ while (x1 == x2 && y1 == y2) {
+ x1 = (gen() % 100) - 50;
+ y1 = (gen() % 100) - 50;
+ x2 = (gen() % 100) - 50;
+ y2 = (gen() % 100) - 50;
+ }
+ point_data<T> point1(x1, y1);
+ point_data<T> point2(x2, y2);
+ segments.push_back(segment_data<T>(point1, point2));
+ }
+ voronoi_test_helper::clean_segment_set(segments);
+ construct_voronoi(points.begin(), points.end(), segments.begin(), segments.end(), &test_output);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output);
+ }
+}
+#endif
+
+#ifdef NDEBUG
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_random_test2, T, test_types) {
+ boost::mt19937 gen(static_cast<unsigned int>(time(NULL)));
+ vd_type test_output_small, test_output_large;
+ std::vector< segment_data<T> > segments_small, segments_large;
+ int num_segments[] = {5, 25, 125, 625};
+ int num_runs[] = {1000, 100, 10, 1};
+ int mod_koef1[] = {10, 100, 200, 300};
+ int mod_koef2[] = {10, 20, 50, 100};
+ int max_value[] = {10, 60, 125, 200};
+ int array_length = sizeof(num_segments) / sizeof(int);
+ for (int k = 0; k < array_length; k++) {
+ int koef = std::numeric_limits<int>::max() / max_value[k];
+ for (int i = 0; i < num_runs[k]; i++) {
+ test_output_small.clear();
+ test_output_large.clear();
+ segments_small.clear();
+ segments_large.clear();
+ for (int j = 0; j < num_segments[k]; j++) {
+ T x1 = (gen() % mod_koef1[k]) - mod_koef1[k] / 2;
+ T y1 = (gen() % mod_koef1[k]) - mod_koef1[k] / 2;
+ T dx = 0, dy = 0;
+ while (dx == 0 && dy == 0) {
+ dx = (gen() % mod_koef2[k]) - mod_koef2[k] / 2;
+ dy = (gen() % mod_koef2[k]) - mod_koef2[k] / 2;
+ }
+ T x2 = x1 + dx;
+ T y2 = y1 + dy;
+ point_data<T> point1_small(x1, y1);
+ point_data<T> point2_small(x2, y2);
+ segments_small.push_back(segment_data<T>(point1_small, point2_small));
+ }
+ voronoi_test_helper::clean_segment_set(segments_small);
+ for (typename std::vector< segment_data<T> >::iterator it = segments_small.begin();
+ it != segments_small.end(); ++it) {
+ T x1 = it->low().x() * koef;
+ T y1 = it->low().y() * koef;
+ T x2 = it->high().x() * koef;
+ T y2 = it->high().y() * koef;
+ point_data<T> point1_large(x1, y1);
+ point_data<T> point2_large(x2, y2);
+ segments_large.push_back(segment_data<T>(point1_large, point2_large));
+ }
+ construct_voronoi(segments_small.begin(), segments_small.end(), &test_output_small);
+ construct_voronoi(segments_large.begin(), segments_large.end(), &test_output_large);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output_small);
+ VERIFY_NO_HALF_EDGE_INTERSECTIONS(test_output_large);
+ BOOST_CHECK_EQUAL(test_output_small.num_cells(), test_output_large.num_cells());
+ BOOST_CHECK_EQUAL(test_output_small.num_vertices(), test_output_large.num_vertices());
+ BOOST_CHECK_EQUAL(test_output_small.num_edges(), test_output_large.num_edges());
+ }
+ }
+}
+#endif
Added: trunk/libs/polygon/test/voronoi_ctypes_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/voronoi_ctypes_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,314 @@
+// Boost.Polygon library voronoi_ctypes_test.cpp file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <ctime>
+
+#define BOOST_TEST_MODULE voronoi_ctypes_test
+#include <boost/mpl/list.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/test/test_case_template.hpp>
+
+#include <boost/polygon/detail/voronoi_ctypes.hpp>
+using namespace boost::polygon::detail;
+
+type_converter_fpt to_fpt;
+
+BOOST_AUTO_TEST_CASE(ulp_comparison_test1) {
+ ulp_comparison<double> ulp_cmp;
+ uint64 a = 22;
+ uint64 b = 27;
+ fpt64 da, db;
+ memcpy(&da, &a, sizeof(uint64));
+ memcpy(&db, &b, sizeof(uint64));
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 1), ulp_cmp.LESS);
+ BOOST_CHECK_EQUAL(ulp_cmp(db, da, 1), ulp_cmp.MORE);
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 4), ulp_cmp.LESS);
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 5), ulp_cmp.EQUAL);
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 6), ulp_cmp.EQUAL);
+}
+
+BOOST_AUTO_TEST_CASE(ulp_comparison_test2) {
+ ulp_comparison<fpt64> ulp_cmp;
+ uint64 a = 0ULL;
+ uint64 b = 0x8000000000000002ULL;
+ fpt64 da, db;
+ memcpy(&da, &a, sizeof(uint64));
+ memcpy(&db, &b, sizeof(uint64));
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 1), ulp_cmp.MORE);
+ BOOST_CHECK_EQUAL(ulp_cmp(db, da, 1), ulp_cmp.LESS);
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 2), ulp_cmp.EQUAL);
+ BOOST_CHECK_EQUAL(ulp_cmp(da, db, 3), ulp_cmp.EQUAL);
+}
+
+BOOST_AUTO_TEST_CASE(fpt_exponent_accessor_test) {
+ typedef fpt_exponent_accessor<fpt64> fpt_ea;
+ fpt64 value = 15;
+ BOOST_CHECK_EQUAL(fpt_ea::set_exponent(value, 0), 3);
+ BOOST_CHECK_EQUAL(value, 1.875);
+ value = 0.0625;
+ BOOST_CHECK_EQUAL(fpt_ea::set_exponent(value, 0), -4);
+ BOOST_CHECK_EQUAL(value, 1.0);
+ value = -1.5;
+ BOOST_CHECK_EQUAL(fpt_ea::set_exponent(value, 4), 0);
+ BOOST_CHECK_EQUAL(value, -24.0);
+ value = 0.0;
+ BOOST_CHECK_EQUAL(fpt_ea::set_exponent(value, 4), fpt_ea::kMinExponent);
+ BOOST_CHECK_EQUAL(value, 16.0);
+ value = std::pow(2.0, 2000);
+ BOOST_CHECK_EQUAL(fpt_ea::set_exponent(value, 4), fpt_ea::kMaxExponent);
+ BOOST_CHECK_EQUAL(value, 16.0);
+}
+
+BOOST_AUTO_TEST_CASE(extended_exponent_fpt_test1) {
+ boost::mt19937_64 gen(static_cast<uint32>(time(NULL)));
+ fpt64 b = 0.0;
+ efpt64 eeb(b);
+ for (int i = 0; i < 1000; ++i) {
+ fpt64 a = to_fpt(static_cast<int64>(gen()));
+ efpt64 eea(a);
+ efpt64 neg = -eea;
+ efpt64 sum = eea + eeb;
+ efpt64 dif = eea - eeb;
+ efpt64 mul = eea * eeb;
+ BOOST_CHECK_EQUAL(to_fpt(neg), -a);
+ BOOST_CHECK_EQUAL(to_fpt(sum), a + b);
+ BOOST_CHECK_EQUAL(to_fpt(dif), a - b);
+ BOOST_CHECK_EQUAL(to_fpt(mul), a * b);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_exponent_fpt_test2) {
+ boost::mt19937_64 gen(static_cast<uint32>(time(NULL)));
+ fpt64 a = 0.0;
+ efpt64 eea(a);
+ for (int i = 0; i < 1000; ++i) {
+ fpt64 b = to_fpt(static_cast<int64>(gen()));
+ if (b == 0.0)
+ continue;
+ efpt64 eeb(b);
+ efpt64 neg = -eea;
+ efpt64 sum = eea + eeb;
+ efpt64 dif = eea - eeb;
+ efpt64 mul = eea * eeb;
+ efpt64 div = eea / eeb;
+ BOOST_CHECK_EQUAL(to_fpt(neg), -a);
+ BOOST_CHECK_EQUAL(to_fpt(sum), a + b);
+ BOOST_CHECK_EQUAL(to_fpt(dif), a - b);
+ BOOST_CHECK_EQUAL(to_fpt(mul), a * b);
+ BOOST_CHECK_EQUAL(to_fpt(div), a / b);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_exponent_fpt_test3) {
+ boost::mt19937_64 gen(static_cast<uint32>(time(NULL)));
+ for (int i = 0; i < 1000; ++i) {
+ fpt64 a = to_fpt(static_cast<int64>(gen()));
+ fpt64 b = to_fpt(static_cast<int64>(gen()));
+ if (b == 0.0)
+ continue;
+ efpt64 eea(a);
+ efpt64 eeb(b);
+ efpt64 neg = -eea;
+ efpt64 sum = eea + eeb;
+ efpt64 dif = eea - eeb;
+ efpt64 mul = eea * eeb;
+ efpt64 div = eea / eeb;
+ BOOST_CHECK_EQUAL(to_fpt(neg), -a);
+ BOOST_CHECK_EQUAL(to_fpt(sum), a + b);
+ BOOST_CHECK_EQUAL(to_fpt(dif), a - b);
+ BOOST_CHECK_EQUAL(to_fpt(mul), a * b);
+ BOOST_CHECK_EQUAL(to_fpt(div), a / b);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_exponent_fpt_test4) {
+ for (int exp = 0; exp < 64; ++exp)
+ for (int i = 1; i < 100; ++i) {
+ fpt64 a = i;
+ fpt64 b = to_fpt(1LL << exp);
+ efpt64 eea(a);
+ efpt64 eeb(b);
+ efpt64 neg = -eea;
+ efpt64 sum = eea + eeb;
+ efpt64 dif = eea - eeb;
+ efpt64 mul = eea * eeb;
+ efpt64 div = eea / eeb;
+ BOOST_CHECK_EQUAL(to_fpt(neg), -a);
+ BOOST_CHECK_EQUAL(to_fpt(sum), a + b);
+ BOOST_CHECK_EQUAL(to_fpt(dif), a - b);
+ BOOST_CHECK_EQUAL(to_fpt(mul), a * b);
+ BOOST_CHECK_EQUAL(to_fpt(div), a / b);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_exponent_fpt_test5) {
+ for (int i = 0; i < 100; ++i) {
+ efpt64 a(to_fpt(i * i));
+ efpt64 b = a.sqrt();
+ BOOST_CHECK_EQUAL(to_fpt(b), to_fpt(i));
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_exponent_fpt_test6) {
+ for (int i = -10; i <= 10; ++i) {
+ efpt64 a(to_fpt(i));
+ BOOST_CHECK_EQUAL(is_pos(a), i > 0);
+ BOOST_CHECK_EQUAL(is_neg(a), i < 0);
+ BOOST_CHECK_EQUAL(is_zero(a), !i);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test1) {
+ typedef extended_int<1> eint32;
+ eint32 e1(0), e2(32), e3(-32);
+ BOOST_CHECK_EQUAL(e1.count(), 0);
+ BOOST_CHECK_EQUAL(e1.size(), 0U);
+ BOOST_CHECK_EQUAL(e2.count(), 1);
+ BOOST_CHECK_EQUAL(e2.chunks()[0], 32U);
+ BOOST_CHECK_EQUAL(e2.size(), 1U);
+ BOOST_CHECK_EQUAL(e3.count(), -1);
+ BOOST_CHECK_EQUAL(e3.chunks()[0], 32U);
+ BOOST_CHECK_EQUAL(e3.size(), 1U);
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test2) {
+ typedef extended_int<2> eint64;
+ int64 val64 = 0x7fffffffffffffffLL;
+ eint64 e1(0), e2(32), e3(-32), e4(val64), e5(-val64);
+ BOOST_CHECK_EQUAL(e1.count(), 0);
+ BOOST_CHECK_EQUAL(e2.count(), 1);
+ BOOST_CHECK_EQUAL(e2.chunks()[0], 32U);
+ BOOST_CHECK_EQUAL(e3.count(), -1);
+ BOOST_CHECK_EQUAL(e3.chunks()[0], 32U);
+ BOOST_CHECK_EQUAL(e4.count(), 2);
+ BOOST_CHECK_EQUAL(e4.chunks()[0], 0xffffffff);
+ BOOST_CHECK_EQUAL(e4.chunks()[1], val64 >> 32);
+ BOOST_CHECK_EQUAL(e5.count(), -2);
+ BOOST_CHECK_EQUAL(e5.chunks()[0], 0xffffffff);
+ BOOST_CHECK_EQUAL(e5.chunks()[1], val64 >> 32);
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test3) {
+ typedef extended_int<2> eint64;
+ std::vector<uint32> chunks;
+ chunks.push_back(1);
+ chunks.push_back(2);
+ eint64 e1(chunks, true), e2(chunks, false);
+ BOOST_CHECK_EQUAL(e1.count(), 2);
+ BOOST_CHECK_EQUAL(e1.chunks()[0], 2U);
+ BOOST_CHECK_EQUAL(e1.chunks()[1], 1U);
+ BOOST_CHECK_EQUAL(e2.count(), -2);
+ BOOST_CHECK_EQUAL(e2.chunks()[0], 2U);
+ BOOST_CHECK_EQUAL(e2.chunks()[1], 1U);
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test4) {
+ typedef extended_int<2> eint64;
+ std::vector<uint32> chunks;
+ chunks.push_back(1);
+ chunks.push_back(2);
+ eint64 e1(chunks, true), e2(chunks, false);
+ BOOST_CHECK_EQUAL(e1 == e2, false);
+ BOOST_CHECK_EQUAL(e1 == -e2, true);
+ BOOST_CHECK_EQUAL(e1 != e2, true);
+ BOOST_CHECK_EQUAL(e1 != -e2, false);
+ BOOST_CHECK_EQUAL(e1 < e2, false);
+ BOOST_CHECK_EQUAL(e1 < -e2, false);
+ BOOST_CHECK_EQUAL(e1 <= e2, false);
+ BOOST_CHECK_EQUAL(e1 <= -e2, true);
+ BOOST_CHECK_EQUAL(e1 > e2, true);
+ BOOST_CHECK_EQUAL(e1 > -e2, false);
+ BOOST_CHECK_EQUAL(e1 >= e2, true);
+ BOOST_CHECK_EQUAL(e1 >= -e2, true);
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test5) {
+ typedef extended_int<2> eint64;
+ boost::mt19937_64 gen(static_cast<uint32>(time(NULL)));
+ for (int i = 0; i < 1000; ++i) {
+ int64 i1 = static_cast<int64>(gen());
+ int64 i2 = static_cast<int64>(gen());
+ eint64 e1(i1), e2(i2);
+ BOOST_CHECK_EQUAL(e1 == e2, i1 == i2);
+ BOOST_CHECK_EQUAL(e1 != e2, i1 != i2);
+ BOOST_CHECK_EQUAL(e1 > e2, i1 > i2);
+ BOOST_CHECK_EQUAL(e1 >= e2, i1 >= i2);
+ BOOST_CHECK_EQUAL(e1 < e2, i1 < i2);
+ BOOST_CHECK_EQUAL(e1 <= e2, i1 <= i2);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test6) {
+ typedef extended_int<1> eint32;
+ eint32 e1(32);
+ eint32 e2 = -e1;
+ BOOST_CHECK_EQUAL(e2.count(), -1);
+ BOOST_CHECK_EQUAL(e2.size(), 1U);
+ BOOST_CHECK_EQUAL(e2.chunks()[0], 32U);
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test7) {
+ typedef extended_int<2> eint64;
+ boost::mt19937_64 gen(static_cast<uint32>(time(NULL)));
+ for (int i = 0; i < 1000; ++i) {
+ int64 i1 = static_cast<int64>(gen()) >> 2;
+ int64 i2 = static_cast<int64>(gen()) >> 2;
+ eint64 e1(i1), e2(i2), e3(i1 + i2), e4(i1 - i2);
+ BOOST_CHECK(e1 + e2 == e3);
+ BOOST_CHECK(e1 - e2 == e4);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test8) {
+ typedef extended_int<2> eint64;
+ boost::mt19937 gen(static_cast<uint32>(time(NULL)));
+ for (int i = 0; i < 1000; ++i) {
+ int64 i1 = static_cast<int32>(gen());
+ int64 i2 = static_cast<int32>(gen());
+ eint64 e1(i1), e2(i2), e3(i1 * i2);
+ BOOST_CHECK(e1 * e2 == e3);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(exnteded_int_test9) {
+ typedef extended_int<1> eint32;
+ for (int i = -10; i <= 10; ++i) {
+ for (int j = -10; j <= 10; ++j) {
+ eint32 e1(i), e2(j), e3(i+j), e4(i-j), e5(i*j);
+ BOOST_CHECK(e1 + e2 == e3);
+ BOOST_CHECK(e1 - e2 == e4);
+ BOOST_CHECK(e1 * e2 == e5);
+ }
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extended_int_test10) {
+ typedef extended_int<2> eint64;
+ boost::mt19937_64 gen(static_cast<uint32>(time(NULL)));
+ for (int i = 0; i < 100; ++i) {
+ int64 i1 = static_cast<int64>(gen()) >> 20;
+ int64 i2 = i1 >> 32;
+ eint64 e1(i1), e2(i2);
+ BOOST_CHECK(to_fpt(e1) == static_cast<fpt64>(i1));
+ BOOST_CHECK(to_fpt(e2) == static_cast<fpt64>(i2));
+ }
+}
+
+BOOST_AUTO_TEST_CASE(extened_int_test11) {
+ typedef extended_int<1> eint32;
+ typedef extended_int<64> eint2048;
+ eint32 two(2), one(1);
+ eint2048 value(1);
+ for (int i = 0; i < 1024; ++i)
+ value = value * two;
+ BOOST_CHECK_EQUAL(value.count(), 33);
+ for (size_t i = 1; i < value.size(); ++i)
+ BOOST_CHECK_EQUAL(value.chunks()[i-1], 0U);
+ BOOST_CHECK_EQUAL(value.chunks()[32], 1U);
+}
Added: trunk/libs/polygon/test/voronoi_predicates_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/voronoi_predicates_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,459 @@
+// Boost.Polygon library voronoi_predicates_test.cpp file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <map>
+
+#define BOOST_TEST_MODULE voronoi_predicates_test
+#include <boost/test/test_case_template.hpp>
+
+#include <boost/polygon/detail/voronoi_ctypes.hpp>
+#include <boost/polygon/detail/voronoi_predicates.hpp>
+#include <boost/polygon/detail/voronoi_structures.hpp>
+using namespace boost::polygon::detail;
+
+ulp_comparison<double> ulp_cmp;
+
+typedef voronoi_predicates< voronoi_ctype_traits<int> > VP;
+typedef point_2d<int> point_type;
+typedef site_event<int> site_type;
+typedef circle_event<double> circle_type;
+VP::event_comparison_predicate<site_type, circle_type> event_comparison;
+
+typedef beach_line_node_key<site_type> key_type;
+typedef VP::distance_predicate<site_type> distance_predicate_type;
+typedef VP::node_comparison_predicate<key_type> node_comparison_type;
+typedef std::map<key_type, int, node_comparison_type> beach_line_type;
+typedef beach_line_type::iterator bieach_line_iterator;
+distance_predicate_type distance_predicate;
+node_comparison_type node_comparison;
+
+typedef VP::circle_existence_predicate<site_type> CEP_type;
+typedef VP::mp_circle_formation_functor<site_type, circle_type> MP_CFF_type;
+typedef VP::lazy_circle_formation_functor<site_type, circle_type> lazy_CFF_type;
+VP::circle_formation_predicate<site_type, circle_type, CEP_type, MP_CFF_type> mp_predicate;
+VP::circle_formation_predicate<site_type, circle_type, CEP_type, lazy_CFF_type> lazy_predicate;
+
+#define CHECK_ORIENTATION(P1, P2, P3, R1, R2) \
+ BOOST_CHECK_EQUAL(VP::ot::eval(P1, P2, P3) == R1, true); \
+ BOOST_CHECK_EQUAL(VP::ot::eval(P1, P3, P2) == R2, true); \
+ BOOST_CHECK_EQUAL(VP::ot::eval(P2, P1, P3) == R2, true); \
+ BOOST_CHECK_EQUAL(VP::ot::eval(P2, P3, P1) == R1, true); \
+ BOOST_CHECK_EQUAL(VP::ot::eval(P3, P1, P2) == R1, true); \
+ BOOST_CHECK_EQUAL(VP::ot::eval(P3, P2, P1) == R2, true)
+
+#define CHECK_EVENT_COMPARISON(A, B, R1, R2) \
+ BOOST_CHECK_EQUAL(event_comparison(A, B), R1); \
+ BOOST_CHECK_EQUAL(event_comparison(B, A), R2)
+
+#define CHECK_DISTANCE_PREDICATE(S1, S2, S3, RES) \
+ BOOST_CHECK_EQUAL(distance_predicate(S1, S2, S3), RES)
+
+#define CHECK_NODE_COMPARISON(node, nodes, res, sz) \
+ for (int i = 0; i < sz; ++i) { \
+ BOOST_CHECK_EQUAL(node_comparison(node, nodes[i]), res[i]); \
+ BOOST_CHECK_EQUAL(node_comparison(nodes[i], node), !res[i]); \
+ }
+
+#define CHECK_CIRCLE(circle, c_x, c_y, l_x) \
+ BOOST_CHECK_EQUAL(ulp_cmp(c1.x(), c_x, 10), ulp_comparison<double>::EQUAL); \
+ BOOST_CHECK_EQUAL(ulp_cmp(c1.y(), c_y, 10), ulp_comparison<double>::EQUAL); \
+ BOOST_CHECK_EQUAL(ulp_cmp(c1.lower_x(), l_x, 10), ulp_comparison<double>::EQUAL)
+
+#define CHECK_CIRCLE_EXISTENCE(s1, s2, s3, RES) \
+ { circle_type c1; \
+ BOOST_CHECK_EQUAL(lazy_predicate(s1, s2, s3, c1), RES); }
+
+#define CHECK_CIRCLE_FORMATION_PREDICATE(s1, s2, s3, c_x, c_y, l_x) \
+ { circle_type c1, c2; \
+ BOOST_CHECK_EQUAL(mp_predicate(s1, s2, s3, c1), true); \
+ BOOST_CHECK_EQUAL(lazy_predicate(s1, s2, s3, c2), true); \
+ CHECK_CIRCLE(c1, c_x, c_y, l_x); \
+ CHECK_CIRCLE(c2, c_x, c_y, l_x); }
+
+BOOST_AUTO_TEST_CASE(orientation_test) {
+ int min_int = std::numeric_limits<int>::min();
+ int max_int = std::numeric_limits<int>::max();
+ point_type point1(min_int, min_int);
+ point_type point2(0, 0);
+ point_type point3(max_int, max_int);
+ point_type point4(min_int, max_int);
+ point_type point5(max_int-1, max_int);
+ CHECK_ORIENTATION(point1, point2, point3, VP::ot::COLLINEAR, VP::ot::COLLINEAR);
+ CHECK_ORIENTATION(point1, point4, point3, VP::ot::RIGHT, VP::ot::LEFT);
+ CHECK_ORIENTATION(point1, point5, point3, VP::ot::RIGHT, VP::ot::LEFT);
+}
+
+BOOST_AUTO_TEST_CASE(event_comparison_test1) {
+ site_type site(1, 2);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 2), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(1, 3), true, false);
+ CHECK_EVENT_COMPARISON(site, site_type(1, 2), false, false);
+}
+
+BOOST_AUTO_TEST_CASE(event_comparison_test2) {
+ site_type site(0, 0, 0, 2);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 2), true, false);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 0), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, -2, 0, -1), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, -2, 1, 1), true, false);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 0, 1, 1), true, false);
+}
+
+BOOST_AUTO_TEST_CASE(event_comparison_test3) {
+ site_type site(0, 0, 10, 10);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 0), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, -1), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 1), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 1, 0, 10), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, -10, 0, -1), false, true);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 0, 10, 9), true, false);
+ CHECK_EVENT_COMPARISON(site, site_type(0, 0, 9, 10), false, true);
+}
+
+BOOST_AUTO_TEST_CASE(event_comparison_test4) {
+ circle_type circle(1, 2, 3);
+ CHECK_EVENT_COMPARISON(circle, circle_type(1, 2, 3), false, false);
+ CHECK_EVENT_COMPARISON(circle, circle_type(1, 3, 3), true, false);
+ CHECK_EVENT_COMPARISON(circle, circle_type(1, 2, 4), true, false);
+ CHECK_EVENT_COMPARISON(circle, circle_type(0, 2, 2), false, true);
+ CHECK_EVENT_COMPARISON(circle, circle_type(-1, 2, 3), false, false);
+}
+
+BOOST_AUTO_TEST_CASE(event_comparison_test5) {
+ circle_type circle(1, 2, 3);
+ CHECK_EVENT_COMPARISON(circle, site_type(0, 100), false, true);
+ CHECK_EVENT_COMPARISON(circle, site_type(3, 0), false, true);
+ CHECK_EVENT_COMPARISON(circle, site_type(3, 2), false, false);
+ CHECK_EVENT_COMPARISON(circle, site_type(3, 3), true, false);
+ CHECK_EVENT_COMPARISON(circle, site_type(4, 2), true, false);
+}
+
+BOOST_AUTO_TEST_CASE(distance_predicate_test1) {
+ site_type site1(-5, 0);
+ site_type site2(-8, 9);
+ site_type site3(-2, 1);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 5), false);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, 5), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 4), false);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, 4), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 6), true);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, 6), true);
+}
+
+BOOST_AUTO_TEST_CASE(distance_predicate_test2) {
+ site_type site1(-4, 0, -4, 20);
+ site_type site2(-2, 10);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, 11), false);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, 9), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 11), true);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 9), true);
+}
+
+BOOST_AUTO_TEST_CASE(disntace_predicate_test3) {
+ site_type site1(-5, 5, 2, -2);
+ site1.inverse();
+ site_type site2(-2, 4);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, -1), false);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, -1), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 1), false);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, 1), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 4), true);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, 4), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 5), true);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, 5), false);
+}
+
+BOOST_AUTO_TEST_CASE(distance_predicate_test4) {
+ site_type site1(-5, 5, 2, -2);
+ site_type site2(-2, -4);
+ site_type site3(-4, 1);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, 1), true);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, 1), true);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site_type(0, 1), true);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, 1), true);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, -2), true);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, -2), false);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site_type(0, -2), true);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, -2), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, -8), true);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, -8), false);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site_type(0, -8), true);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, -8), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(0, -9), true);
+ CHECK_DISTANCE_PREDICATE(site2, site1, site_type(0, -9), false);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site_type(0, -9), true);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site_type(0, -9), false);
+}
+
+BOOST_AUTO_TEST_CASE(disntace_predicate_test5) {
+ site_type site1(-5, 5, 2, -2);
+ site_type site2 = site1;
+ site2.inverse();
+ site_type site3(-2, 4);
+ site_type site4(-2, -4);
+ site_type site5(-4, 1);
+ CHECK_DISTANCE_PREDICATE(site3, site2, site_type(0, 1), false);
+ CHECK_DISTANCE_PREDICATE(site3, site2, site_type(0, 4), false);
+ CHECK_DISTANCE_PREDICATE(site3, site2, site_type(0, 5), false);
+ CHECK_DISTANCE_PREDICATE(site3, site2, site_type(0, 7), true);
+ CHECK_DISTANCE_PREDICATE(site4, site1, site_type(0, -2), false);
+ CHECK_DISTANCE_PREDICATE(site5, site1, site_type(0, -2), false);
+ CHECK_DISTANCE_PREDICATE(site4, site1, site_type(0, -8), false);
+ CHECK_DISTANCE_PREDICATE(site5, site1, site_type(0, -8), false);
+ CHECK_DISTANCE_PREDICATE(site4, site1, site_type(0, -9), false);
+ CHECK_DISTANCE_PREDICATE(site5, site1, site_type(0, -9), false);
+ CHECK_DISTANCE_PREDICATE(site4, site1, site_type(0, -18), false);
+ CHECK_DISTANCE_PREDICATE(site5, site1, site_type(0, -18), false);
+ CHECK_DISTANCE_PREDICATE(site4, site1, site_type(0, -1), true);
+ CHECK_DISTANCE_PREDICATE(site5, site1, site_type(0, -1), true);
+}
+
+BOOST_AUTO_TEST_CASE(distance_predicate_test6) {
+ site_type site1(-5, 0, 2, 7);
+ site_type site2 = site1;
+ site2.inverse();
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(2, 7), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(1, 5), false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(-1, 5), true);
+}
+
+BOOST_AUTO_TEST_CASE(distance_predicate_test7) {
+ site_type site1(-5, 5, 2, -2);
+ site1.inverse();
+ site_type site2(-5, 5, 0, 6);
+ site_type site3(-2, 4, 0, 4);
+ site_type site4(0, 2);
+ site_type site5(0, 5);
+ site_type site6(0, 6);
+ site_type site7(0, 8);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site4, false);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site5, true);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site6, true);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site7, true);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site4, false);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site5, true);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site6, true);
+ CHECK_DISTANCE_PREDICATE(site1, site3, site7, true);
+ site3.inverse();
+ CHECK_DISTANCE_PREDICATE(site3, site1, site4, false);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site5, false);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site6, false);
+ CHECK_DISTANCE_PREDICATE(site3, site1, site7, true);
+}
+
+BOOST_AUTO_TEST_CASE(distatnce_predicate_test8) {
+ site_type site1(-5, 3, -2, 2);
+ site1.inverse();
+ site_type site2(-5, 5, -2, 2);
+ CHECK_DISTANCE_PREDICATE(site1, site2, site_type(-4, 2), false);
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test1) {
+ beach_line_type beach_line;
+ site_type site1(0, 0);
+ site1.index(0);
+ site_type site2(0, 2);
+ site2.index(1);
+ site_type site3(1, 0);
+ site3.index(2);
+ beach_line[key_type(site1, site2)] = 2;
+ beach_line[key_type(site1, site3)] = 0;
+ beach_line[key_type(site3, site1)] = 1;
+ int cur_index = 0;
+ for (bieach_line_iterator it = beach_line.begin();
+ it != beach_line.end(); ++it, ++cur_index) {
+ BOOST_CHECK_EQUAL(it->second, cur_index);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test2) {
+ beach_line_type beach_line;
+ site_type site1(0, 1);
+ site1.index(0);
+ site_type site2(2, 0);
+ site2.index(1);
+ site_type site3(2, 4);
+ site3.index(2);
+ beach_line[key_type(site1, site2)] = 0;
+ beach_line[key_type(site2, site1)] = 1;
+ beach_line[key_type(site1, site3)] = 2;
+ beach_line[key_type(site3, site1)] = 3;
+ int cur_index = 0;
+ for (bieach_line_iterator it = beach_line.begin();
+ it != beach_line.end(); ++it, ++cur_index) {
+ BOOST_CHECK_EQUAL(it->second, cur_index);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test3) {
+ key_type node(site_type(1, 0).index(1), site_type(0, 2).index(0));
+ key_type nodes[] = {
+ key_type(site_type(2, -10).index(2)),
+ key_type(site_type(2, -1).index(2)),
+ key_type(site_type(2, 0).index(2)),
+ key_type(site_type(2, 1).index(2)),
+ key_type(site_type(2, 2).index(2)),
+ key_type(site_type(2, 3).index(2)),
+ };
+ bool res[] = {false, false, false, false, true, true};
+ CHECK_NODE_COMPARISON(node, nodes, res, 6);
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test4) {
+ key_type node(site_type(0, 1).index(0), site_type(1, 0).index(1));
+ key_type nodes[] = {
+ key_type(site_type(2, -3).index(2)),
+ key_type(site_type(2, -2).index(2)),
+ key_type(site_type(2, -1).index(2)),
+ key_type(site_type(2, 0).index(2)),
+ key_type(site_type(2, 1).index(2)),
+ key_type(site_type(2, 3).index(2)),
+ };
+ bool res[] = {false, true, true, true, true, true};
+ CHECK_NODE_COMPARISON(node, nodes, res, 6);
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test5) {
+ key_type node(site_type(0, 0).index(0), site_type(1, 2).index(1));
+ key_type nodes[] = {
+ key_type(site_type(2, -10).index(2)),
+ key_type(site_type(2, 0).index(2)),
+ key_type(site_type(2, 1).index(2)),
+ key_type(site_type(2, 2).index(2)),
+ key_type(site_type(2, 5).index(2)),
+ key_type(site_type(2, 20).index(2)),
+ };
+ bool res[] = {false, false, true, true, true, true};
+ CHECK_NODE_COMPARISON(node, nodes, res, 6);
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test6) {
+ key_type node(site_type(1, 1).index(1), site_type(0, 0).index(0));
+ key_type nodes [] = {
+ key_type(site_type(2, -3).index(2)),
+ key_type(site_type(2, -2).index(2)),
+ key_type(site_type(2, 0).index(2)),
+ key_type(site_type(2, 1).index(2)),
+ key_type(site_type(2, 2).index(2)),
+ key_type(site_type(2, 3).index(2)),
+ key_type(site_type(2, 5).index(2)),
+ };
+ bool res[] = {false, false, false, false, false, false, true};
+ CHECK_NODE_COMPARISON(node, nodes, res, 7);
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test7) {
+ key_type node(site_type(0, 0).index(0), site_type(0, 2).index(1));
+ key_type nodes[] = {
+ key_type(site_type(1, 0).index(2)),
+ key_type(site_type(1, 1).index(2)),
+ key_type(site_type(1, 2).index(2)),
+ };
+ bool res[] = {false, false, true};
+ CHECK_NODE_COMPARISON(node, nodes, res, 3);
+}
+
+BOOST_AUTO_TEST_CASE(node_comparison_test8) {
+ key_type node(site_type(0, 0).index(0), site_type(1, 1).index(2));
+ key_type nodes[] = {
+ key_type(site_type(1, 0).index(1)),
+ key_type(site_type(1, 1).index(2)),
+ key_type(site_type(1, 2).index(3)),
+ key_type(site_type(1, 1).index(2), site_type(0, 0).index(0)),
+ };
+ bool res[] = {false, true, true, true};
+ CHECK_NODE_COMPARISON(node, nodes, res, 4);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test1) {
+ site_type site1(0, 0);
+ site_type site2(-8, 0);
+ site_type site3(0, 6);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site1, site2, site3, -4.0, 3.0, 1.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test2) {
+ int min_int = std::numeric_limits<int>::min();
+ int max_int = std::numeric_limits<int>::max();
+ site_type site1(min_int, min_int);
+ site_type site2(min_int, max_int);
+ site_type site3(max_int-1, max_int-1);
+ site_type site4(max_int, max_int);
+ CHECK_CIRCLE_EXISTENCE(site1, site2, site4, true);
+ CHECK_CIRCLE_EXISTENCE(site1, site3, site4, false);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test3) {
+ site_type site1(-4, 0);
+ site_type site2(0, 4);
+ site_type site3(site1.point0(), site2.point0());
+ CHECK_CIRCLE_EXISTENCE(site1, site3, site2, false);
+ site_type site4(-2, 0);
+ site_type site5(0, 2);
+ CHECK_CIRCLE_EXISTENCE(site3, site4, site5, false);
+ CHECK_CIRCLE_EXISTENCE(site4, site5, site3, false);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test4) {
+ site_type site1(-4, 0, -4, 20);
+ site_type site2(-2, 10);
+ site_type site3(4, 10);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site1, site2, site3, 1.0, 6.0, 6.0);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site3, site2, site1, 1.0, 14.0, 6.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test5) {
+ site_type site1(1, 0, 7, 0);
+ site1.inverse();
+ site_type site2(-2, 4, 10, 4);
+ site_type site3(6, 2);
+ site_type site4(1, 0);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site3, site1, site2, 4.0, 2.0, 6.0);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site4, site2, site1, 1.0, 2.0, 3.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test6) {
+ site_type site1(-1, 2, 8, -10);
+ site1.inverse();
+ site_type site2(-1, 0, 8, 12);
+ site_type site3(1, 1);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site3, site2, site1, 6.0, 1.0, 11.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test7) {
+ site_type site1(1, 0, 6, 0);
+ site1.inverse();
+ site_type site2(-6, 4, 0, 12);
+ site_type site3(1, 0);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site3, site2, site1, 1.0, 5.0, 6.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test8) {
+ site_type site1(1, 0, 5, 0);
+ site1.inverse();
+ site_type site2(0, 12, 8, 6);
+ site_type site3(1, 0);
+ CHECK_CIRCLE_FORMATION_PREDICATE(site3, site2, site1, 1.0, 5.0, 6.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test9) {
+ site_type site1(0, 0, 4, 0);
+ site_type site2(0, 0, 0, 4);
+ site_type site3(0, 4, 4, 4);
+ site1.inverse();
+ CHECK_CIRCLE_FORMATION_PREDICATE(site1, site2, site3, 2.0, 2.0, 4.0);
+}
+
+BOOST_AUTO_TEST_CASE(circle_formation_predicate_test10) {
+ site_type site1(1, 0, 41, 30);
+ site_type site2(-39, 30, 1, 60);
+ site_type site3(1, 60, 41, 30);
+ site1.inverse();
+ CHECK_CIRCLE_FORMATION_PREDICATE(site1, site2, site3, 1.0, 30.0, 25.0);
+}
Added: trunk/libs/polygon/test/voronoi_robust_fpt_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/voronoi_robust_fpt_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,342 @@
+// Boost.Polygon library voronoi_robust_fpt_test.cpp file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cmath>
+#include <ctime>
+
+#define BOOST_TEST_MODULE voronoi_robust_fpt_test
+#include <boost/mpl/list.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/test/test_case_template.hpp>
+
+#include <boost/polygon/detail/voronoi_ctypes.hpp>
+#include <boost/polygon/detail/voronoi_robust_fpt.hpp>
+using namespace boost::polygon::detail;
+
+typedef robust_fpt<double> rfpt_type;
+typedef type_converter_fpt to_fpt_type;
+typedef type_converter_efpt to_efpt_type;
+type_converter_fpt to_fpt;
+
+BOOST_AUTO_TEST_CASE(robust_fpt_constructors_test1) {
+ rfpt_type a = rfpt_type();
+ BOOST_CHECK_EQUAL(a.fpv(), 0.0);
+ BOOST_CHECK_EQUAL(a.re(), 0.0);
+ BOOST_CHECK_EQUAL(a.ulp(), 0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_constructors_test2) {
+ rfpt_type a(10.0, 1.0);
+ BOOST_CHECK_EQUAL(a.fpv(), 10.0);
+ BOOST_CHECK_EQUAL(a.re(), 1.0);
+ BOOST_CHECK_EQUAL(a.ulp(), 1.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_constructors_test3) {
+ rfpt_type a(10.0);
+ BOOST_CHECK_EQUAL(a.fpv(), 10.0);
+ BOOST_CHECK_EQUAL(a.re(), 0.0);
+ BOOST_CHECK_EQUAL(a.ulp(), 0.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_constructors_test4) {
+ rfpt_type a(10.0, 3.0);
+ BOOST_CHECK_EQUAL(a.fpv(), 10.0);
+ BOOST_CHECK_EQUAL(a.re(), 3.0);
+ BOOST_CHECK_EQUAL(a.ulp(), 3.0);
+
+ rfpt_type b(10.0, 2.75);
+ BOOST_CHECK_EQUAL(b.fpv(), 10.0);
+ BOOST_CHECK_EQUAL(b.re(), 2.75);
+ BOOST_CHECK_EQUAL(b.ulp(), 2.75);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_sum_test1) {
+ rfpt_type a(2.0, 5.0);
+ rfpt_type b(3.0, 4.0);
+ rfpt_type c = a + b;
+ BOOST_CHECK_EQUAL(c.fpv(), 5.0);
+ BOOST_CHECK_EQUAL(c.re(), 6.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 6.0);
+
+ c += b;
+ BOOST_CHECK_EQUAL(c.fpv(), 8.0);
+ BOOST_CHECK_EQUAL(c.re(), 7.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 7.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_sum_test2) {
+ rfpt_type a(3.0, 2.0);
+ rfpt_type b(-2.0, 3.0);
+ rfpt_type c = a + b;
+ BOOST_CHECK_EQUAL(c.fpv(), 1.0);
+ BOOST_CHECK_EQUAL(c.re(), 13.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 13.0);
+
+ c += b;
+ BOOST_CHECK_EQUAL(c.fpv(), -1.0);
+ BOOST_CHECK_EQUAL(c.re(), 20.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 20.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_dif_test1) {
+ rfpt_type a(2.0, 5.0);
+ rfpt_type b(-3.0, 4.0);
+ rfpt_type c = a - b;
+ BOOST_CHECK_EQUAL(c.fpv(), 5.0);
+ BOOST_CHECK_EQUAL(c.re(), 6.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 6.0);
+
+ c -= b;
+ BOOST_CHECK_EQUAL(c.fpv(), 8.0);
+ BOOST_CHECK_EQUAL(c.re(), 7.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 7.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_dif_test2) {
+ rfpt_type a(3.0, 2.0);
+ rfpt_type b(2.0, 3.0);
+ rfpt_type c = a - b;
+ BOOST_CHECK_EQUAL(c.fpv(), 1.0);
+ BOOST_CHECK_EQUAL(c.re(), 13.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 13.0);
+
+ c -= b;
+ BOOST_CHECK_EQUAL(c.fpv(), -1.0);
+ BOOST_CHECK_EQUAL(c.re(), 20.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 20.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_mult_test3) {
+ rfpt_type a(2.0, 3.0);
+ rfpt_type b(4.0, 1.0);
+ rfpt_type c = a * b;
+ BOOST_CHECK_EQUAL(c.fpv(), 8.0);
+ BOOST_CHECK_EQUAL(c.re(), 5.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 5.0);
+
+ c *= b;
+ BOOST_CHECK_EQUAL(c.fpv(), 32.0);
+ BOOST_CHECK_EQUAL(c.re(), 7.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 7.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_fpt_div_test1) {
+ rfpt_type a(2.0, 3.0);
+ rfpt_type b(4.0, 1.0);
+ rfpt_type c = a / b;
+ BOOST_CHECK_EQUAL(c.fpv(), 0.5);
+ BOOST_CHECK_EQUAL(c.re(), 5.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 5.0);
+
+ c /= b;
+ BOOST_CHECK_EQUAL(c.fpv(), 0.125);
+ BOOST_CHECK_EQUAL(c.re(), 7.0);
+ BOOST_CHECK_EQUAL(c.ulp(), 7.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_dif_constructors_test) {
+ robust_dif<int> rd1;
+ BOOST_CHECK_EQUAL(rd1.pos(), 0);
+ BOOST_CHECK_EQUAL(rd1.neg(), 0);
+ BOOST_CHECK_EQUAL(rd1.dif(), 0);
+
+ robust_dif<int> rd2(1);
+ BOOST_CHECK_EQUAL(rd2.pos(), 1);
+ BOOST_CHECK_EQUAL(rd2.neg(), 0);
+ BOOST_CHECK_EQUAL(rd2.dif(), 1);
+
+ robust_dif<int> rd3(-1);
+ BOOST_CHECK_EQUAL(rd3.pos(), 0);
+ BOOST_CHECK_EQUAL(rd3.neg(), 1);
+ BOOST_CHECK_EQUAL(rd3.dif(), -1);
+
+ robust_dif<int> rd4(1, 2);
+ BOOST_CHECK_EQUAL(rd4.pos(), 1);
+ BOOST_CHECK_EQUAL(rd4.neg(), 2);
+ BOOST_CHECK_EQUAL(rd4.dif(), -1);
+}
+
+BOOST_AUTO_TEST_CASE(robust_dif_operators_test1) {
+ robust_dif<int> a(5, 2), b(1, 10);
+ int dif_a = a.dif();
+ int dif_b = b.dif();
+ robust_dif<int> sum = a + b;
+ robust_dif<int> dif = a - b;
+ robust_dif<int> mult = a * b;
+ robust_dif<int> umin = -a;
+ BOOST_CHECK_EQUAL(sum.dif(), dif_a + dif_b);
+ BOOST_CHECK_EQUAL(dif.dif(), dif_a - dif_b);
+ BOOST_CHECK_EQUAL(mult.dif(), dif_a * dif_b);
+ BOOST_CHECK_EQUAL(umin.dif(), -dif_a);
+}
+
+BOOST_AUTO_TEST_CASE(robust_dif_operators_test2) {
+ robust_dif<int> a(5, 2);
+ for (int b = -3; b <= 3; b += 6) {
+ int dif_a = a.dif();
+ int dif_b = b;
+ robust_dif<int> sum = a + b;
+ robust_dif<int> dif = a - b;
+ robust_dif<int> mult = a * b;
+ robust_dif<int> div = a / b;
+ BOOST_CHECK_EQUAL(sum.dif(), dif_a + dif_b);
+ BOOST_CHECK_EQUAL(dif.dif(), dif_a - dif_b);
+ BOOST_CHECK_EQUAL(mult.dif(), dif_a * dif_b);
+ BOOST_CHECK_EQUAL(div.dif(), dif_a / dif_b);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(robust_dif_operators_test3) {
+ robust_dif<int> b(5, 2);
+ for (int a = -3; a <= 3; a += 6) {
+ int dif_a = a;
+ int dif_b = b.dif();
+ robust_dif<int> sum = a + b;
+ robust_dif<int> dif = a - b;
+ robust_dif<int> mult = a * b;
+ BOOST_CHECK_EQUAL(sum.dif(), dif_a + dif_b);
+ BOOST_CHECK_EQUAL(dif.dif(), dif_a - dif_b);
+ BOOST_CHECK_EQUAL(mult.dif(), dif_a * dif_b);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(robust_dif_operators_test4) {
+ std::vector< robust_dif<int> > a4(4, robust_dif<int>(5, 2));
+ std::vector< robust_dif<int> > b4(4, robust_dif<int>(1, 2));
+ std::vector< robust_dif<int> > c4 = a4;
+ c4[0] += b4[0];
+ c4[1] -= b4[1];
+ c4[2] *= b4[2];
+ BOOST_CHECK_EQUAL(c4[0].dif(), a4[0].dif() + b4[0].dif());
+ BOOST_CHECK_EQUAL(c4[1].dif(), a4[1].dif() - b4[1].dif());
+ BOOST_CHECK_EQUAL(c4[2].dif(), a4[2].dif() * b4[2].dif());
+ a4[0] += b4[0].dif();
+ a4[1] -= b4[1].dif();
+ a4[2] *= b4[2].dif();
+ a4[3] /= b4[3].dif();
+ BOOST_CHECK_EQUAL(c4[0].dif(), a4[0].dif());
+ BOOST_CHECK_EQUAL(c4[1].dif(), a4[1].dif());
+ BOOST_CHECK_EQUAL(c4[2].dif(), a4[2].dif());
+ BOOST_CHECK_EQUAL(c4[3].dif() / b4[3].dif(), a4[3].dif());
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test1) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[1] = {10};
+ int32 B[1] = {100};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval1(A, B), 100.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test2) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[2] = {10, 30};
+ int32 B[2] = {400, 100};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval2(A, B), 500.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test3) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[2] = {10, -30};
+ int32 B[2] = {400, 100};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval2(A, B), -100.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test4) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[3] = {10, 30, 20};
+ int32 B[3] = {4, 1, 9};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval3(A, B), 110.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test5) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[3] = {10, 30, -20};
+ int32 B[3] = {4, 1, 9};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval3(A, B), -10.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test6) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[4] = {10, 30, 20, 5};
+ int32 B[4] = {4, 1, 9, 16};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval4(A, B), 130.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test7) {
+ robust_sqrt_expr<int32, fpt64, to_fpt_type> sqrt_expr;
+ int32 A[4] = {10, 30, -20, -5};
+ int32 B[4] = {4, 1, 9, 16};
+ BOOST_CHECK_EQUAL(sqrt_expr.eval4(A, B), -30.0);
+}
+
+BOOST_AUTO_TEST_CASE(robust_sqrt_expr_test8) {
+ typedef extended_int<16> eint512;
+ robust_sqrt_expr<eint512, efpt64, to_efpt_type> sqrt_expr;
+ int32 A[4] = {1000, 3000, -2000, -500};
+ int32 B[4] = {400, 100, 900, 1600};
+ eint512 AA[4], BB[4];
+ for (size_t i = 0; i < 4; ++i) {
+ AA[i] = A[i];
+ BB[i] = B[i];
+ }
+ BOOST_CHECK_EQUAL(to_fpt(sqrt_expr.eval4(AA, BB)), -30000.0);
+}
+
+template <typename _int, typename _fpt>
+class sqrt_expr_tester {
+public:
+ static const size_t MX_SQRTS = 4;
+
+ bool run() {
+ static boost::mt19937 gen(static_cast<uint32>(time(NULL)));
+ bool ret_val = true;
+ for (size_t i = 0; i < MX_SQRTS; ++i) {
+ a[i] = gen() & 1048575;
+ int64 temp = gen() & 1048575;
+ b[i] = temp * temp;
+ }
+ uint32 mask = (1 << MX_SQRTS);
+ for (size_t i = 0; i < mask; i++) {
+ fpt64 expected_val = 0.0;
+ for (size_t j = 0; j < MX_SQRTS; j++) {
+ if (i & (1 << j)) {
+ A[j] = a[j];
+ B[j] = b[j];
+ expected_val += static_cast<fpt64>(a[j]) *
+ sqrt(static_cast<fpt64>(b[j]));
+ } else {
+ A[j] = -a[j];
+ B[j] = b[j];
+ expected_val -= static_cast<fpt64>(a[j]) *
+ sqrt(static_cast<fpt64>(b[j]));
+ }
+ }
+ fpt64 received_val = to_fpt(sqrt_expr_.eval4(A, B));
+ ret_val &= ulp_cmp(expected_val, received_val, 25) ==
+ ulp_comparison<fpt64>::EQUAL;
+ }
+ return ret_val;
+ }
+
+private:
+ robust_sqrt_expr<_int, _fpt, to_efpt_type> sqrt_expr_;
+ ulp_comparison<fpt64> ulp_cmp;
+ _int A[MX_SQRTS];
+ _int B[MX_SQRTS];
+ int64 a[MX_SQRTS];
+ int64 b[MX_SQRTS];
+};
+
+BOOST_AUTO_TEST_CASE(mpz_sqrt_evaluator_test) {
+ typedef extended_int<16> eint512;
+ sqrt_expr_tester<eint512, efpt64> tester;
+ for (int i = 0; i < 2000; ++i)
+ BOOST_CHECK(tester.run());
+}
Added: trunk/libs/polygon/test/voronoi_structures_test.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/voronoi_structures_test.cpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,133 @@
+// Boost.Polygon library voronoi_structures_test.cpp file
+
+// Copyright Andrii Sydorchuk 2010-2012.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#define BOOST_TEST_MODULE voronoi_structures_test
+
+#include <boost/test/test_case_template.hpp>
+#include <boost/polygon/detail/voronoi_structures.hpp>
+using namespace boost::polygon::detail;
+
+typedef point_2d<int> point_type;
+typedef site_event<int> site_type;
+typedef circle_event<int> circle_type;
+typedef ordered_queue<int, std::greater<int> > ordered_queue_type;
+typedef beach_line_node_key<int> node_key_type;
+typedef beach_line_node_data<int, int> node_data_type;
+
+BOOST_AUTO_TEST_CASE(point_2d_test1) {
+ point_type p(1, 2);
+ BOOST_CHECK_EQUAL(p.x(), 1);
+ BOOST_CHECK_EQUAL(p.y(), 2);
+ p.x(3);
+ BOOST_CHECK_EQUAL(p.x(), 3);
+ p.y(4);
+ BOOST_CHECK_EQUAL(p.y(), 4);
+}
+
+BOOST_AUTO_TEST_CASE(site_event_test2) {
+ site_type s(1, 2);
+ BOOST_CHECK(s.x0() == s.x1() && s.x1() == 1);
+ BOOST_CHECK(s.y0() == s.y1() && s.y1() == 2);
+ BOOST_CHECK(s.index() == 0);
+ BOOST_CHECK(!s.is_segment());
+ BOOST_CHECK(!s.is_inverse());
+ s.index(1);
+ BOOST_CHECK(s.index() == 1);
+ BOOST_CHECK(!s.is_inverse());
+}
+
+BOOST_AUTO_TEST_CASE(site_event_test3) {
+ site_type s(1, 2, 3, 4);
+ BOOST_CHECK(s.x0(true) == 1 && s.x0() == 1);
+ BOOST_CHECK(s.y0(true) == 2 && s.y0() == 2);
+ BOOST_CHECK(s.x1(true) == 3 && s.x1() == 3);
+ BOOST_CHECK(s.y1(true) == 4 && s.y1() == 4);
+ BOOST_CHECK(s.index() == 0);
+ BOOST_CHECK(s.is_segment());
+ BOOST_CHECK(!s.is_inverse());
+ s.inverse();
+ BOOST_CHECK(s.x1(true) == 1 && s.x0() == 1);
+ BOOST_CHECK(s.y1(true) == 2 && s.y0() == 2);
+ BOOST_CHECK(s.x0(true) == 3 && s.x1() == 3);
+ BOOST_CHECK(s.y0(true) == 4 && s.y1() == 4);
+ BOOST_CHECK(s.is_inverse());
+}
+
+BOOST_AUTO_TEST_CASE(site_event_test4) {
+ site_type s(1, 2, 3, 4);
+ s.index(27);
+ BOOST_CHECK(s.is_initial());
+ BOOST_CHECK(s.has_initial_direction());
+ BOOST_CHECK(s.index() == 27);
+ s.inverse();
+ BOOST_CHECK(!s.has_initial_direction());
+ BOOST_CHECK(s.is_initial());
+ BOOST_CHECK(s.index() == 27);
+ s.change_initial_direction();
+ BOOST_CHECK(s.has_initial_direction());
+ BOOST_CHECK(!s.is_initial());
+ BOOST_CHECK(s.index() == 27);
+}
+
+BOOST_AUTO_TEST_CASE(circle_event_test) {
+ circle_type c(0, 1, 2);
+ BOOST_CHECK_EQUAL(c.x(), 0);
+ BOOST_CHECK_EQUAL(c.y(), 1);
+ BOOST_CHECK_EQUAL(c.lower_x(), 2);
+ BOOST_CHECK_EQUAL(c.lower_y(), 1);
+ BOOST_CHECK(c.is_active());
+ c.x(3);
+ c.y(4);
+ c.lower_x(5);
+ BOOST_CHECK_EQUAL(c.x(), 3);
+ BOOST_CHECK_EQUAL(c.y(), 4);
+ BOOST_CHECK_EQUAL(c.lower_x(), 5);
+ BOOST_CHECK_EQUAL(c.lower_y(), 4);
+ c.deactivate();
+ BOOST_CHECK(!c.is_active());
+}
+
+BOOST_AUTO_TEST_CASE(ordered_queue_test) {
+ ordered_queue_type q;
+ BOOST_CHECK(q.empty());
+ std::vector<int*> vi;
+ for (int i = 0; i < 20; ++i)
+ vi.push_back(&q.push(i));
+ for (int i = 0; i < 20; ++i)
+ *vi[i] <<= 1;
+ BOOST_CHECK(!q.empty());
+ for (int i = 0; i < 20; ++i, q.pop())
+ BOOST_CHECK_EQUAL(q.top(), i << 1);
+ BOOST_CHECK(q.empty());
+}
+
+BOOST_AUTO_TEST_CASE(beach_line_node_key_test) {
+ node_key_type key(1);
+ BOOST_CHECK_EQUAL(key.left_site(), 1);
+ BOOST_CHECK_EQUAL(key.right_site(), 1);
+ key.left_site(2);
+ BOOST_CHECK_EQUAL(key.left_site(), 2);
+ BOOST_CHECK_EQUAL(key.right_site(), 1);
+ key.right_site(3);
+ BOOST_CHECK_EQUAL(key.left_site(), 2);
+ BOOST_CHECK_EQUAL(key.right_site(), 3);
+}
+
+BOOST_AUTO_TEST_CASE(beach_line_node_data_test) {
+ node_data_type node_data(NULL);
+ BOOST_CHECK_EQUAL(node_data.edge() == NULL, true);
+ BOOST_CHECK_EQUAL(node_data.circle_event() == NULL, true);
+ int data = 4;
+ node_data.circle_event(&data);
+ BOOST_CHECK_EQUAL(node_data.edge() == NULL, true);
+ BOOST_CHECK_EQUAL(node_data.circle_event() == &data, true);
+ node_data.edge(&data);
+ BOOST_CHECK_EQUAL(node_data.edge() == &data, true);
+ BOOST_CHECK_EQUAL(node_data.circle_event() == &data, true);
+}
Added: trunk/libs/polygon/test/voronoi_test_helper.hpp
==============================================================================
--- (empty file)
+++ trunk/libs/polygon/test/voronoi_test_helper.hpp 2012-05-05 10:29:08 EDT (Sat, 05 May 2012)
@@ -0,0 +1,272 @@
+// Boost.Polygon library voronoi_test_helper.hpp file
+
+// Copyright Andrii Sydorchuk 2010-2011.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef VORONOI_TEST_HELPER
+#define VORONOI_TEST_HELPER
+
+#include <iostream>
+#include <iterator>
+#include <fstream>
+#include <map>
+#include <vector>
+
+#include <boost/polygon/polygon.hpp>
+using namespace boost::polygon;
+
+namespace voronoi_test_helper {
+
+enum kOrientation {
+ RIGHT = -1,
+ COLLINEAR = 0,
+ LEFT = 1
+};
+
+template <typename Point2D>
+kOrientation get_orientation(const Point2D &point1,
+ const Point2D &point2,
+ const Point2D &point3) {
+ typename Point2D::coordinate_type a = (point2.x() - point1.x()) * (point3.y() - point2.y());
+ typename Point2D::coordinate_type b = (point2.y() - point1.y()) * (point3.x() - point2.x());
+ if (a == b)
+ return COLLINEAR;
+ return (a < b) ? RIGHT : LEFT;
+}
+
+template <typename Output>
+bool verify_half_edge_orientation(const Output &output) {
+ typedef typename Output::point_type point_type;
+ typename Output::const_edge_iterator edge_it;
+ for (edge_it = output.edges().begin();
+ edge_it != output.edges().end(); edge_it++) {
+ if (edge_it->is_finite()) {
+ const point_type &site_point = edge_it->cell()->point0();
+ const point_type &start_point = edge_it->vertex0()->vertex();
+ const point_type &end_point = edge_it->vertex1()->vertex();
+ if (get_orientation(start_point, end_point, site_point) != LEFT)
+ return false;
+ }
+ }
+ return true;
+}
+
+template <typename Output>
+bool verify_cell_convexity(const Output &output) {
+ typedef typename Output::point_type point_type;
+ typename Output::const_cell_iterator cell_it;
+ for (cell_it = output.cells().begin();
+ cell_it != output.cells().end(); cell_it++) {
+ const typename Output::edge_type *edge = cell_it->incident_edge();
+ if (edge)
+ do {
+ if (edge->next()->prev() != edge)
+ return false;
+ if (edge->cell() != &(*cell_it))
+ return false;
+ if (edge->vertex0() != NULL &&
+ edge->vertex1() != NULL &&
+ edge->vertex1() == edge->next()->vertex0() &&
+ edge->next()->vertex1() != NULL) {
+ const point_type &vertex1 = edge->vertex0()->vertex();
+ const point_type &vertex2 = edge->vertex1()->vertex();
+ const point_type &vertex3 = edge->next()->vertex1()->vertex();
+ if (get_orientation(vertex1, vertex2, vertex3) != LEFT)
+ return false;
+ }
+ edge = edge->next();
+ } while(edge != cell_it->incident_edge());
+ }
+ return true;
+}
+
+template <typename Output>
+bool verify_incident_edges_ccw_order(const Output &output) {
+ typedef typename Output::point_type point_type;
+ typedef typename Output::edge_type voronoi_edge_type;
+ typename Output::const_vertex_iterator vertex_it;
+ for (vertex_it = output.vertices().begin();
+ vertex_it != output.vertices().end(); vertex_it++) {
+ if (vertex_it->is_degenerate())
+ continue;
+ const voronoi_edge_type *edge = vertex_it->incident_edge();
+ do {
+ const voronoi_edge_type *edge_next1 = edge->rot_next();
+ const voronoi_edge_type *edge_next2 = edge_next1->rot_next();
+ const point_type &site1 = edge->cell()->point0();
+ const point_type &site2 = edge_next1->cell()->point0();
+ const point_type &site3 = edge_next2->cell()->point0();
+
+ if (get_orientation(site1, site2, site3) != LEFT)
+ return false;
+
+ edge = edge->rot_next();
+ } while (edge != vertex_it->incident_edge());
+ }
+ return true;
+}
+
+template <typename P>
+struct cmp {
+ bool operator()(const P& p1, const P& p2) const {
+ if (p1.x() != p2.x())
+ return p1.x() < p2.x();
+ return p1.y() < p2.y();
+ }
+};
+
+template <typename Output>
+bool verfiy_no_line_edge_intersections(const Output &output) {
+ // Create map from edges with first point less than the second one.
+ // Key is the first point of the edge, value is a vector of second points
+ // with the same first point.
+ typedef typename Output::point_type point_type;
+ cmp<point_type> comparator;
+ std::map< point_type, std::vector<point_type>, cmp<point_type> > edge_map;
+ typename Output::const_edge_iterator edge_it;
+ for (edge_it = output.edges().begin();
+ edge_it != output.edges().end(); edge_it++) {
+ if (edge_it->is_finite()) {
+ const point_type &vertex0 = edge_it->vertex0()->vertex();
+ const point_type &vertex1 = edge_it->vertex1()->vertex();
+ if (comparator(vertex0, vertex1))
+ edge_map[vertex0].push_back(vertex1);
+ }
+ }
+ return !intersection_check(edge_map);
+}
+
+template <typename Point2D>
+bool intersection_check(const std::map< Point2D, std::vector<Point2D>, cmp<Point2D> > &edge_map) {
+ // Iterate over map of edges and check if there are any intersections.
+ // All the edges are stored by the low x value. That's why we iterate
+ // left to right checking for intersections between all pairs of edges
+ // that overlap in the x dimension.
+ // Complexity. Approximately N*sqrt(N). Worst case N^2.
+ typedef Point2D point_type;
+ typedef typename point_type::coordinate_type coordinate_type;
+ typedef typename std::map< point_type, std::vector<point_type>, cmp<Point2D> >::const_iterator
+ edge_map_iterator;
+ typedef typename std::vector<point_type>::size_type size_type;
+ edge_map_iterator edge_map_it1, edge_map_it2, edge_map_it_bound;
+ for (edge_map_it1 = edge_map.begin();
+ edge_map_it1 != edge_map.end(); edge_map_it1++) {
+ const point_type &point1 = edge_map_it1->first;
+ for (size_type i = 0; i < edge_map_it1->second.size(); i++) {
+ const point_type &point2 = edge_map_it1->second[i];
+ coordinate_type min_y1 = std::min(point1.y(), point2.y());
+ coordinate_type max_y1 = std::max(point1.y(), point2.y());
+
+ // Find the first edge with greater or equal first point.
+ edge_map_it_bound = edge_map.lower_bound(point2);
+
+ edge_map_it2 = edge_map_it1;
+ edge_map_it2++;
+ for (; edge_map_it2 != edge_map_it_bound; edge_map_it2++) {
+ const point_type &point3 = edge_map_it2->first;
+ for (size_type j = 0; j < edge_map_it2->second.size(); j++) {
+ const point_type &point4 = edge_map_it2->second[j];
+ coordinate_type min_y2 = std::min(point3.y(), point4.y());
+ coordinate_type max_y2 = std::max(point3.y(), point4.y());
+
+ // In most cases it is enought to make
+ // simple intersection check in the y dimension.
+ if (!(max_y1 > min_y2 && max_y2 > min_y1))
+ continue;
+
+ // Intersection check.
+ if (get_orientation(point1, point2, point3) *
+ get_orientation(point1, point2, point4) == RIGHT &&
+ get_orientation(point3, point4, point1) *
+ get_orientation(point3, point4, point2) == RIGHT)
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+enum kVerification {
+ HALF_EDGE_ORIENTATION = 1,
+ CELL_CONVEXITY = 2,
+ INCIDENT_EDGES_CCW_ORDER = 4,
+ NO_HALF_EDGE_INTERSECTIONS = 8,
+ FAST_VERIFICATION = 7,
+ COMPLETE_VERIFICATION = 15
+};
+
+template <typename Output>
+bool verify_output(const Output &output, kVerification mask) {
+ bool result = true;
+ if (mask & HALF_EDGE_ORIENTATION)
+ result &= verify_half_edge_orientation(output);
+ if (mask & CELL_CONVEXITY)
+ result &= verify_cell_convexity(output);
+ if (mask & INCIDENT_EDGES_CCW_ORDER)
+ result &= verify_incident_edges_ccw_order(output);
+ if (mask & NO_HALF_EDGE_INTERSECTIONS)
+ result &= verfiy_no_line_edge_intersections(output);
+ return result;
+}
+
+template <typename PointIterator>
+void save_points(PointIterator first, PointIterator last, const char *file_name) {
+ std::ofstream ofs(file_name);
+ ofs << std::distance(first, last) << std::endl;
+ for (PointIterator it = first; it != last; ++it) {
+ ofs << it->x() << " " << it->y() << std::endl;
+ }
+ ofs.close();
+}
+
+template <typename SegmentIterator>
+void save_segments(SegmentIterator first, SegmentIterator last, const char *file_name) {
+ std::ofstream ofs(file_name);
+ ofs << std::distance(first, last) << std::endl;
+ for (SegmentIterator it = first; it != last; ++it) {
+ ofs << it->low().x() << " " << it->low().y() << " ";
+ ofs << it->high().x() << " " << it->high().y() << std::endl;
+ }
+ ofs.close();
+}
+
+template <typename T>
+void clean_segment_set(std::vector< segment_data<T> > &data) {
+ typedef T Unit;
+ typedef typename scanline_base<Unit>::Point Point;
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+ typedef int segment_id;
+ std::vector<std::pair<half_edge, segment_id> > half_edges;
+ std::vector<std::pair<half_edge, segment_id> > half_edges_out;
+ segment_id id = 0;
+ half_edges.reserve(data.size());
+ for (typename std::vector< segment_data<T> >::iterator it = data.begin(); it != data.end(); ++it) {
+ Point l = it->low();
+ Point h = it->high();
+ half_edges.push_back(std::make_pair(half_edge(l, h), id++));
+ }
+ half_edges_out.reserve(half_edges.size());
+ //apparently no need to pre-sort data when calling validate_scan
+ line_intersection<Unit>::validate_scan(half_edges_out, half_edges.begin(), half_edges.end());
+ std::vector< segment_data<T> > result;
+ result.reserve(half_edges_out.size());
+ for (std::size_t i = 0; i < half_edges_out.size(); ++i) {
+ id = half_edges_out[i].second;
+ Point l = half_edges_out[i].first.first;
+ Point h = half_edges_out[i].first.second;
+ segment_data<T> orig_seg = data[id];
+ if (orig_seg.high() < orig_seg.low())
+ std::swap(l, h);
+ result.push_back(segment_data<T>(l, h));
+ }
+ std::swap(result, data);
+}
+
+} // voronoi_test_helper
+
+#endif
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk