|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r50517 - sandbox/gtl/gtl
From: lucanus.j.simonson_at_[hidden]
Date: 2009-01-08 12:02:14
Author: ljsimons
Date: 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
New Revision: 50517
URL: http://svn.boost.org/trac/boost/changeset/50517
Log:
updated gtl checkin
Added:
sandbox/gtl/gtl/boolean_op_45.hpp (contents, props changed)
sandbox/gtl/gtl/max_cover.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_45_formation.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_45_set_concept.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_45_set_data.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_45_set_traits.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_45_set_view.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_90_set_concept.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_90_set_data.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_90_set_traits.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_90_set_view.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_90_touch.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_arbitrary_formation.hpp (contents, props changed)
sandbox/gtl/gtl/polygon_set_concept.hpp (contents, props changed)
sandbox/gtl/gtl/transform.hpp (contents, props changed)
sandbox/gtl/gtl/transform_detail.hpp (contents, props changed)
Text files modified:
sandbox/gtl/gtl/boolean_op.hpp | 201 --
sandbox/gtl/gtl/gtl.hpp | 651 --------
sandbox/gtl/gtl/interval_concept.hpp | 354 +++-
sandbox/gtl/gtl/interval_data.hpp | 62
sandbox/gtl/gtl/interval_traits.hpp | 31
sandbox/gtl/gtl/isotropy.hpp | 410 ++++-
sandbox/gtl/gtl/iterator_compact_to_points.hpp | 12
sandbox/gtl/gtl/iterator_geometry_to_set.hpp | 115 -
sandbox/gtl/gtl/iterator_points_to_compact.hpp | 4
sandbox/gtl/gtl/point_3d_concept.hpp | 175 ++
sandbox/gtl/gtl/point_3d_data.hpp | 50
sandbox/gtl/gtl/point_3d_traits.hpp | 27
sandbox/gtl/gtl/point_concept.hpp | 234 ++-
sandbox/gtl/gtl/point_data.hpp | 94
sandbox/gtl/gtl/point_traits.hpp | 31
sandbox/gtl/gtl/polygon_45_data.hpp | 40
sandbox/gtl/gtl/polygon_45_with_holes_concept.hpp | 123 +
sandbox/gtl/gtl/polygon_45_with_holes_data.hpp | 28
sandbox/gtl/gtl/polygon_90_data.hpp | 69 +
sandbox/gtl/gtl/polygon_90_with_holes_concept.hpp | 248 +++
sandbox/gtl/gtl/polygon_90_with_holes_data.hpp | 2
sandbox/gtl/gtl/polygon_data.hpp | 15
sandbox/gtl/gtl/polygon_formation.hpp | 186 +-
sandbox/gtl/gtl/polygon_set_data.hpp | 410 +++--
sandbox/gtl/gtl/polygon_set_traits.hpp | 108 +
sandbox/gtl/gtl/polygon_set_view.hpp | 346 +---
sandbox/gtl/gtl/polygon_traits.hpp | 1092 +++++++++++++++
sandbox/gtl/gtl/polygon_with_holes_concept.hpp | 150 ++
sandbox/gtl/gtl/polygon_with_holes_data.hpp | 45
sandbox/gtl/gtl/rectangle_concept.hpp | 781 +++++++----
sandbox/gtl/gtl/rectangle_data.hpp | 17
sandbox/gtl/gtl/rectangle_formation.hpp | 19
sandbox/gtl/gtl/rectangle_traits.hpp | 33
sandbox/gtl/gtl/scan_arbitrary.hpp | 2652 ++++++++++++++++++++++++++++++++++-----
34 files changed, 6226 insertions(+), 2589 deletions(-)
Modified: sandbox/gtl/gtl/boolean_op.hpp
==============================================================================
--- sandbox/gtl/gtl/boolean_op.hpp (original)
+++ sandbox/gtl/gtl/boolean_op.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -10,169 +10,6 @@
namespace gtl {
namespace boolean_op {
- template <typename Unit>
- class ScanEventNew{
- private:
- typedef std::vector<std::pair<Unit, int> > EventData;
- mutable EventData eventData_;
- mutable bool dirty_;
- class lessEventDataElement : public std::binary_function<const std::pair<Unit, int>&, const std::pair<Unit, int>&, bool> {
- public:
- inline lessEventDataElement() {}
- inline bool operator () (const std::pair<Unit, int>& elem1, const std::pair<Unit, int>& elem2) const {
- return elem1.first < elem2.first;
- }
- };
- public:
-
- // The ScanEvent::iterator is a lazy algorithm that accumulates
- // polygon intersection count as it is incremented through the
- // scan event data structure.
- // The iterator provides a forward iterator semantic only.
- class iterator {
- private:
- typename EventData::const_iterator i_;
- Unit prevPos_;
- int count_;
- public:
- inline iterator() {}
- inline iterator(typename EventData::const_iterator i,
- Unit prevPos, int count) : i_(i),
- prevPos_(prevPos),
- count_(count) {}
- inline iterator(const iterator& that) : i_(that.i_),
- prevPos_(that.prevPos_),
- count_(that.count_) {}
- inline iterator& operator=(const iterator& that) {
- //std::cout << "iterator assign\n";
- i_ = that.i_;
- prevPos_ = that.prevPos_;
- count_ = that.count_;
- return *this;
- }
- inline bool operator==(const iterator& that) { return i_ == that.i_; }
- inline bool operator!=(const iterator& that) { return i_ != that.i_; }
- inline iterator& operator++() {
- //std::cout << "iterator increment\n";
- prevPos_ = (*i_).first;
- count_ += (*i_).second;
- ++i_;
- return *this;
- }
- inline iterator operator++(int) {
- iterator tmp = *this;
- ++(*this);
- return tmp;
- }
- inline std::pair<interval_data<Unit>, int> operator*() {
- //std::cout << "iterator dereference\n";
- if(count_ == 0) ++(*this);
- std::pair<interval_data<Unit>, int> retVal;
- retVal.first = interval_data<Unit>(prevPos_, (*i_).first);
- retVal.second = count_;
- return retVal;
- }
- };
-
- inline ScanEventNew() {}
- template<class iT>
- inline ScanEventNew(iT begin, iT end){
- for( ; begin != end; ++begin){
- insert(*begin);
- }
- }
- inline ScanEventNew(const ScanEventNew& that) : eventData_(that.eventData_), dirty_(that.dirty_) {}
- inline ScanEventNew& operator=(const ScanEventNew& that) {
- if(that.dirty_) that.clean();
- eventData_ = that.eventData_;
- dirty_ = that.dirty_;
- return *this;
- }
-
- //Insert and interval intersection count change into the EventData
- inline void insert(const std::pair<interval_data<Unit>, int>& intervalCount) {
- insert(intervalCount.first.low(), intervalCount.second);
- insert(intervalCount.first.high(), -intervalCount.second);
- }
-
- //Insert and position and change int change in intersection count into EventData
- inline void insert(Unit pos, int count) {
- eventData_.push_back(std::pair<Unit, int>());
- eventData_.back().first = pos;
- eventData_.back().second = count;
- //std::cout << "Insert: " << eventData_.size() << std::endl;
- dirty_ = true;
- }
-
- //merge this scan event with that by inserting its data
- inline void insert(const ScanEventNew& that) {
- typename EventData::const_iterator itr;
- for(itr = that.eventData_.begin(); itr != that.eventData_.end(); ++itr) {
- insert((*itr).first, (*itr).second);
- }
- }
-
- inline void clean() const {
- //std::cout << "Clean\n";
- if(eventData_.empty()) return;
- std::sort(eventData_.begin(), eventData_.end(), lessEventDataElement());
- std::vector<std::pair<Unit, int> > collapse;
- collapse.reserve(eventData_.size());
- Unit pos = eventData_[0].first;
- int count = eventData_[0].second;
- unsigned int i = 1;
- for( ; i < eventData_.size(); ++i) {
- if(pos == eventData_[i].first) {
- count += eventData_[i].second;
- } else {
- if(count != 0) {
- //std::cout << "collapse insert\n";
- collapse.push_back(std::pair<Unit, int>());
- collapse.back().first = pos;
- collapse.back().second = count;
- }
- pos = eventData_[i].first;
- count = eventData_[i].second;
- }
- }
- //std::cout << "collapse insert\n";
- if(count != 0) {
- collapse.push_back(std::pair<Unit, int>());
- collapse.back().first = pos;
- collapse.back().second = count;
- }
- //std::cout << "data size: " << eventData_.size() << std::endl;
- //std::cout << "collapse size: " << collapse.size() << std::endl;
- eventData_ = std::vector<std::pair<Unit, int> >();
- eventData_.insert(eventData_.end(), collapse.begin(), collapse.end());
- dirty_ = false;
- }
-
- //Get the begin iterator over event data
- inline iterator begin() const {
- if(dirty_) clean();
- if(eventData_.empty()) return end();
- Unit pos = eventData_[0].first;
- int count = eventData_[0].second;
- typename EventData::const_iterator itr = eventData_.begin();
- ++itr;
- return iterator(itr, pos, count);
- }
-
- //Get the end iterator over event data
- inline iterator end() const {
- if(dirty_) clean();
- return iterator(eventData_.end(), 0, 0);
- }
-
- inline void clear() { eventData_.clear(); }
-
- inline interval_data<Unit> extents() const {
- if(eventData_.empty()) return interval_data<Unit>();
- return interval_data<Unit>((*(eventData_.begin())).first, (*(eventData_.rbegin())).first);
- }
- };
-
//BooleanOp is the generic boolean operation scanline algorithm that provides
//all the simple boolean set operations on manhattan data. By templatizing
//the intersection count of the input and algorithm internals it is extensible
@@ -516,16 +353,18 @@
return true;
}
- template <class T, typename Unit>
+ template <class T, typename Unit, typename iterator_type_1, typename iterator_type_2>
inline void applyBooleanBinaryOp(std::vector<std::pair<Unit, std::pair<Unit, int> > >& output,
- const std::vector<std::pair<Unit, std::pair<Unit, int> > >& input1,
- const std::vector<std::pair<Unit, std::pair<Unit, int> > >& input2,
+ //const std::vector<std::pair<Unit, std::pair<Unit, int> > >& input1,
+ //const std::vector<std::pair<Unit, std::pair<Unit, int> > >& input2,
+ iterator_type_1 itr1, iterator_type_1 itr1_end,
+ iterator_type_2 itr2, iterator_type_2 itr2_end,
T defaultCount) {
BooleanOp<T, Unit> boolean(defaultCount);
- typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::const_iterator itr1 = input1.begin();
- typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::const_iterator itr2 = input2.begin();
+ //typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::const_iterator itr1 = input1.begin();
+ //typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::const_iterator itr2 = input2.begin();
std::vector<std::pair<interval_data<Unit>, int> > container;
- output.reserve(std::max(input1.size(), input2.size()));
+ //output.reserve(std::max(input1.size(), input2.size()));
//consider eliminating dependecy on limits with bool flag for initial state
Unit UnitMax = std::numeric_limits<Unit>::max();
@@ -533,12 +372,12 @@
Unit prevPosition = UnitMax;
T count(defaultCount);
//define the starting point
- if(itr1 != input1.end()) {
+ if(itr1 != itr1_end) {
prevCoord = (*itr1).first;
prevPosition = (*itr1).second.first;
count[0] += (*itr1).second.second;
}
- if(itr2 != input2.end()) {
+ if(itr2 != itr2_end) {
if((*itr2).first < prevCoord ||
((*itr2).first == prevCoord && (*itr2).second.first < prevPosition)) {
prevCoord = (*itr2).first;
@@ -549,24 +388,24 @@
} else if((*itr2).first == prevCoord && (*itr2).second.first == prevPosition) {
count[1] += (*itr2).second.second;
++itr2;
- if(itr1 != input1.end())++itr1;
+ if(itr1 != itr1_end) ++itr1;
} else {
- if(itr1 != input1.end())++itr1;
+ if(itr1 != itr1_end) ++itr1;
}
} else {
- if(itr1 != input1.end())++itr1;
+ if(itr1 != itr1_end) ++itr1;
}
-
- while(itr1 != input1.end() || itr2 != input2.end()) {
+
+ while(itr1 != itr1_end || itr2 != itr2_end) {
Unit curCoord = UnitMax;
Unit curPosition = UnitMax;
T curCount(defaultCount);
- if(itr1 != input1.end()) {
+ if(itr1 != itr1_end) {
curCoord = (*itr1).first;
curPosition = (*itr1).second.first;
curCount[0] += (*itr1).second.second;
}
- if(itr2 != input2.end()) {
+ if(itr2 != itr2_end) {
if((*itr2).first < curCoord ||
((*itr2).first == curCoord && (*itr2).second.first < curPosition)) {
curCoord = (*itr2).first;
@@ -577,9 +416,9 @@
} else if((*itr2).first == curCoord && (*itr2).second.first == curPosition) {
curCount[1] += (*itr2).second.second;
++itr2;
- if(itr1 != input1.end())++itr1;
+ if(itr1 != itr1_end) ++itr1;
} else {
- if(itr1 != input1.end())++itr1;
+ if(itr1 != itr1_end) ++itr1;
}
} else {
++itr1;
@@ -680,7 +519,7 @@
input.insert(input.end(), output.begin(), output.end());
}
-};
+}
}
#endif
Added: sandbox/gtl/gtl/boolean_op_45.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/boolean_op_45.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,1544 @@
+/*
+ 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 GTL_BOOLEAN_OP_45_HPP
+#define GTL_BOOLEAN_OP_45_HPP
+namespace gtl {
+
+ template <typename Unit>
+ struct boolean_op_45 {
+ typedef point_data<Unit> Point;
+ typedef typename coordinate_traits<Unit>::manhattan_area_type LongUnit;
+
+ class Count2 {
+ public:
+ inline Count2() { counts[0] = counts[1] = 0; }
+ //inline Count2(int count) { counts[0] = counts[1] = count; }
+ inline Count2(int count1, int count2) { counts[0] = count1; counts[1] = count2; }
+ inline Count2(const Count2& count) { counts[0] = count.counts[0]; counts[1] = count.counts[1]; }
+ inline bool operator==(const Count2& count) const { return counts[0] == count.counts[0] && counts[1] == count.counts[1]; }
+ inline bool operator!=(const Count2& count) const { return !((*this) == count); }
+ inline Count2& operator=(int count) { counts[0] = counts[1] = count; return *this; }
+ inline Count2& operator=(const Count2& count) { counts[0] = count.counts[0]; counts[1] = count.counts[1]; return *this; }
+ inline int& operator[](bool index) { return counts[index]; }
+ inline int operator[](bool index) const {return counts[index]; }
+ inline Count2& operator+=(const Count2& count){
+ counts[0] += count[0];
+ counts[1] += count[1];
+ return *this;
+ }
+ inline Count2& operator-=(const Count2& count){
+ counts[0] -= count[0];
+ counts[1] -= count[1];
+ return *this;
+ }
+ inline Count2 operator+(const Count2& count) const {
+ return Count2(*this)+=count;
+ }
+ inline Count2 operator-(const Count2& count) const {
+ return Count2(*this)-=count;
+ }
+ inline Count2 invert() const {
+ return Count2(-counts[0], -counts[1]);
+ }
+ private:
+ int counts[2];
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const Count2& c) {
+// o << c[0] << " " << c[1];
+// return o;
+// }
+
+ class Scan45Element {
+ public:
+ Unit x;
+ Unit y;
+ int rise; //-1, 0, +1
+ mutable Count2 count;
+ inline Scan45Element(){}
+ inline Scan45Element(Unit xIn, Unit yIn, int riseIn, Count2 countIn = Count2(0, 0)) :
+ x(xIn), y(yIn), rise(riseIn), count(countIn) {}
+ inline Scan45Element(const Scan45Element& that) :
+ x(that.x), y(that.y), rise(that.rise), count(that.count) {}
+ inline Scan45Element& operator=(const Scan45Element& that) {
+ x = that.x; y = that.y; rise = that.rise; count = that.count;
+ return *this;
+ }
+ inline Unit evalAtX(Unit xIn) const {
+ return y + rise * (xIn - x);
+ }
+
+ inline bool cross(Point& crossPoint, const Scan45Element& edge, Unit currentX) const {
+ Unit y1 = evalAtX(currentX);
+ Unit y2 = edge.evalAtX(currentX);
+ int rise1 = rise;
+ int rise2 = edge.rise;
+ if(rise > edge.rise){
+ if(y1 > y2) return false;
+ } else if(rise < edge.rise){
+ if(y2 > y1) return false;
+ std::swap(y1, y2);
+ std::swap(rise1, rise2);
+ } else { return false; }
+ if(rise1 == 1) {
+ if(rise2 == 0) {
+ crossPoint = Point(currentX + y2 - y1, y2);
+ } else {
+ //rise2 == -1
+ Unit delta = (y2 - y1)/2;
+ crossPoint = Point(currentX + delta, y1 + delta);
+ }
+ } else {
+ //rise1 == 0 and rise2 == -1
+ crossPoint = Point(currentX + y2 - y1, y1);
+ }
+ return true;
+ }
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const Scan45Element& c) {
+// o << c.x << " " << c.y << " " << c.rise << " " << c.count;
+// return o;
+// }
+
+ class lessScan45ElementRise : public std::binary_function<Scan45Element, Scan45Element, bool> {
+ public:
+ inline lessScan45ElementRise() {} //default constructor is only constructor
+ inline bool operator () (Scan45Element elm1, Scan45Element elm2) const {
+ return elm1.rise < elm2.rise;
+ }
+ };
+
+ class lessScan45Element : public std::binary_function<Scan45Element, Scan45Element, bool> {
+ private:
+ Unit *x_; //x value at which to apply comparison
+ int *justBefore_;
+ public:
+ inline lessScan45Element() : x_(0) {}
+ inline lessScan45Element(Unit *x, int *justBefore) : x_(x), justBefore_(justBefore) {}
+ inline lessScan45Element(const lessScan45Element& that) : x_(that.x_), justBefore_(that.justBefore_) {}
+ inline lessScan45Element& operator=(const lessScan45Element& that) { x_ = that.x_; justBefore_ = that.justBefore_; return *this; }
+ inline bool operator () (const Scan45Element& elm1, const Scan45Element& elm2) const {
+ Unit y1 = elm1.evalAtX(*x_);
+ Unit y2 = elm2.evalAtX(*x_);
+ if(y1 < y2) return true;
+ if(y1 == y2) {
+ //if justBefore is true we invert the result of the comparison of slopes
+ if(*justBefore_) {
+ return elm1.rise > elm2.rise;
+ } else {
+ return elm1.rise < elm2.rise;
+ }
+ }
+ return false;
+ }
+ };
+
+ class Scan45Count {
+ public:
+ inline Scan45Count() { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
+ inline Scan45Count(Count2 count) { counts[0] = counts[1] = counts[2] = counts[3] = count; }
+ inline Scan45Count(const Count2& count1, const Count2& count2, const Count2& count3,
+ const Count2& count4) {
+ counts[0] = count1;
+ counts[1] = count2;
+ counts[2] = count3;
+ counts[3] = count4;
+ }
+ inline Scan45Count(const Scan45Count& count) {
+ (*this) = count;
+ }
+ inline bool operator==(const Scan45Count& count) const {
+ for(unsigned int i = 0; i < 4; ++i) {
+ if(counts[i] != count.counts[i]) return false;
+ }
+ return true;
+ }
+ inline bool operator!=(const Scan45Count& count) const { return !((*this) == count); }
+ inline Scan45Count& operator=(Count2 count) {
+ counts[0] = counts[1] = counts[2] = counts[3] = count; return *this; }
+ inline Scan45Count& operator=(const Scan45Count& count) {
+ for(unsigned int i = 0; i < 4; ++i) {
+ counts[i] = count.counts[i];
+ }
+ return *this;
+ }
+ inline Count2& operator[](int index) { return counts[index]; }
+ inline Count2 operator[](int index) const {return counts[index]; }
+ inline Scan45Count& operator+=(const Scan45Count& count){
+ for(unsigned int i = 0; i < 4; ++i) {
+ counts[i] += count.counts[i];
+ }
+ return *this;
+ }
+ inline Scan45Count& operator-=(const Scan45Count& count){
+ for(unsigned int i = 0; i < 4; ++i) {
+ counts[i] -= count.counts[i];
+ }
+ return *this;
+ }
+ inline Scan45Count operator+(const Scan45Count& count) const {
+ return Scan45Count(*this)+=count;
+ }
+ inline Scan45Count operator-(const Scan45Count& count) const {
+ return Scan45Count(*this)-=count;
+ }
+ inline Scan45Count invert() const {
+ return Scan45Count(Count2(0,0))-=(*this);
+ }
+ inline Scan45Count& operator+=(const Scan45Element& element){
+ counts[element.rise+1] += element.count; return *this;
+ }
+ private:
+ Count2 counts[4];
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const Scan45Count& c) {
+// o << c[0] << ", " << c[1] << ", ";
+// o << c[2] << ", " << c[3];
+// return o;
+// }
+
+ typedef std::pair<Point, Scan45Count> Scan45Vertex;
+
+// inline std::ostream& operator<< (std::ostream& o, const Scan45Vertex& c) {
+// o << c.first << ": " << c.second;
+// return o;
+// }
+
+ //index is the index into the vertex
+ static inline Scan45Element getElement(const Scan45Vertex& vertex, int index) {
+ return Scan45Element(vertex.first.x(), vertex.first.y(), index - 1, vertex.second[index]);
+ }
+
+ class lessScan45Point : public std::binary_function<Point, Point, bool> {
+ public:
+ inline lessScan45Point() {} //default constructor is only constructor
+ inline bool operator () (const Point& v1, const Point& v2) const {
+ return (v1.x() < v2.x()) || (v1.x() == v2.x() && v1.y() < v2.y());
+ }
+ };
+
+ class lessScan45Vertex : public std::binary_function<Scan45Vertex, Scan45Vertex, bool> {
+ public:
+ inline lessScan45Vertex() {} //default constructor is only constructor
+ inline bool operator () (const Scan45Vertex& v1, const Scan45Vertex& v2) const {
+ return (v1.first.x() < v2.first.x()) || (v1.first.x() == v2.first.x() && v1.first.y() < v2.first.y());
+ }
+ };
+
+ typedef std::vector<Scan45Vertex> Scan45Vector;
+
+ static inline void sortScan45Vector(Scan45Vector& vec) {
+ std::sort(vec.begin(), vec.end(), lessScan45Vertex());
+ }
+
+ //vetex45 is sortable
+ class Vertex45 {
+ public:
+ Point pt;
+ int rise; // 1, 0 or -1
+ int count; //dxdydTheta
+ inline Vertex45() {}
+ inline Vertex45(const Point& point, int riseIn, int countIn) : pt(point), rise(riseIn), count(countIn) {}
+ inline Vertex45(const Vertex45& vertex) : pt(vertex.pt), rise(vertex.rise), count(vertex.count) {}
+ inline Vertex45& operator=(const Vertex45& vertex){
+ pt = vertex.pt; rise = vertex.rise; count = vertex.count; return *this; }
+ inline Vertex45(const std::pair<Point, Point>& vertex) {}
+ inline Vertex45& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+ inline bool operator==(const Vertex45& vertex) const {
+ return pt == vertex.pt && rise == vertex.rise && count == vertex.count; }
+ inline bool operator!=(const Vertex45& vertex) const { return !((*this) == vertex); }
+ inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+ inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
+ inline bool operator<(const Vertex45& vertex) const {
+ if(pt.x() < vertex.pt.x()) return true;
+ if(pt.x() == vertex.pt.x()) {
+ if(pt.y() < vertex.pt.y()) return true;
+ if(pt.y() == vertex.pt.y()) { return rise < vertex.rise; }
+ }
+ return false;
+ }
+ inline bool operator>(const Vertex45& vertex) const { return vertex < (*this); }
+ inline bool operator<=(const Vertex45& vertex) const { return !((*this) > vertex); }
+ inline bool operator>=(const Vertex45& vertex) const { return !((*this) < vertex); }
+ inline Unit evalAtX(Unit xIn) const { return pt.y() + rise * (xIn - pt.x()); }
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const Vertex45& c) {
+// o << c.pt << " " << c.rise << " " << c.count;
+// return o;
+// }
+
+ //when scanning Vertex45 for polygon formation we need a scanline comparator functor
+ class lessVertex45 : public std::binary_function<Vertex45, Vertex45, bool> {
+ private:
+ Unit *x_; //x value at which to apply comparison
+ int *justBefore_;
+ public:
+ inline lessVertex45() : x_(0) {}
+ inline lessVertex45(Unit *x, int *justBefore) : x_(x), justBefore_(justBefore) {}
+ inline lessVertex45(const lessVertex45& that) : x_(that.x_), justBefore_(that.justBefore_) {}
+ inline lessVertex45& operator=(const lessVertex45& that) { x_ = that.x_; justBefore_ = that.justBefore_; return *this; }
+ inline bool operator () (const Vertex45& elm1, const Vertex45& elm2) const {
+ Unit y1 = elm1.evalAtX(*x_);
+ Unit y2 = elm2.evalAtX(*x_);
+ if(y1 < y2) return true;
+ if(y1 == y2) {
+ //if justBefore is true we invert the result of the comparison of slopes
+ if(*justBefore_) {
+ return elm1.rise > elm2.rise;
+ } else {
+ return elm1.rise < elm2.rise;
+ }
+ }
+ return false;
+ }
+ };
+
+ // 0 right to left
+ // 1 upper right to lower left
+ // 2 high to low
+ // 3 upper left to lower right
+ // 4 left to right
+ // 5 lower left to upper right
+ // 6 low to high
+ // 7 lower right to upper left
+ static inline int classifyEdge45(const Point& prevPt, const Point& nextPt) {
+ if(prevPt.x() == nextPt.x()) {
+ //2 or 6
+ return predicated_value(prevPt.y() < nextPt.y(), 6, 2);
+ }
+ if(prevPt.y() == nextPt.y()) {
+ //0 or 4
+ return predicated_value(prevPt.x() < nextPt.x(), 4, 0);
+ }
+ if(prevPt.x() < nextPt.x()) {
+ //3 or 5
+ return predicated_value(prevPt.y() < nextPt.y(), 5, 3);
+ }
+ //prevPt.x() > nextPt.y()
+ //1 or 7
+ return predicated_value(prevPt.y() < nextPt.y(), 7, 1);
+ }
+
+ class Scan45 {
+ private:
+ //definitions
+ typedef std::set<Scan45Element, lessScan45Element> Scan45Data;
+ typedef typename Scan45Data::iterator iterator;
+ typedef typename Scan45Data::const_iterator const_iterator;
+ typedef std::set<Point, lessScan45Point> CrossQueue;
+
+ //data
+ Scan45Data scanData_;
+ CrossQueue crossQueue_;
+ Scan45Vector crossVector_;
+ Scan45Vector nonIntegerIntersectionVector_;
+ Unit x_;
+ int justBefore_;
+ int op_; // 0 for OR, 1 for AND, 2 for subtract and 3 for xor
+ public:
+ inline Scan45() : x_((std::numeric_limits<Unit>::min)()), justBefore_(false), op_(0) {
+ lessScan45Element lessElm(&x_, &justBefore_);
+ scanData_ = std::set<Scan45Element, lessScan45Element>(lessElm);
+ }
+ inline Scan45(int op) : x_((std::numeric_limits<Unit>::min)()), justBefore_(false), op_(op) {
+ lessScan45Element lessElm(&x_, &justBefore_);
+ scanData_ = std::set<Scan45Element, lessScan45Element>(lessElm);
+ }
+ inline Scan45(const Scan45& that) { (*this) = that; }
+ inline Scan45& operator=(const Scan45& that) {
+ x_ = that.x_;
+ justBefore_ = that.justBefore_;
+ crossQueue_ = that.crossQueue_;
+ crossVector_ = that.crossVector_;
+ op_ = that.op_;
+ lessScan45Element lessElm(&x_, &justBefore_);
+ scanData_ = std::set<Scan45Element, lessScan45Element>(lessElm);
+ for(const_iterator itr = that.scanData_.begin(); itr != that.scanData_.end(); ++itr){
+ scanData_.insert(scanData_.end(), *itr);
+ }
+ return *this;
+ }
+
+// bool check_invariant() {
+// lessScan45Element lessElm(&x_, &justBefore_);
+// typename Scan45Data::iterator previtr = scanData_.begin();
+// for(typename Scan45Data::iterator itr = scanData_.begin(); itr != scanData_.end(); ++itr) {
+// if(itr != scanData_.begin()) {
+// if(lessElm(*itr, *previtr)) return false;
+// }
+// previtr = itr;
+// }
+// return true;
+// }
+// void assert_invariant() {
+// if(!check_invariant()) {
+// std::cout << "tree invariant violated at " << x_ << " just before is " << justBefore_ << std::endl; //break here
+// }
+// }
+
+ //cT is an output container of Vertex45
+ //iT is an iterator over Scan45Vertex elements
+ template <class cT, class iT>
+ void scan(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "1\n";
+ while(inputBegin != inputEnd) {
+ //std::cout << "2\n";
+ //std::cout << "x_ = " << x_ << std::endl;
+ //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ //for(iterator iter = scanData_.begin();
+ // iter != scanData_.end(); ++iter) {
+ // std::cout << "scan element\n";
+ // std::cout << *iter << " " << iter->evalAtX(x_) << std::endl;
+ // }
+ // std::cout << "cross queue size: " << crossQueue_.size() << std::endl;
+ // std::cout << "cross vector size: " << crossVector_.size() << std::endl;
+ //for(CrossQueue::iterator cqitr = crossQueue_.begin(); cqitr != crossQueue_.end(); ++cqitr) {
+ // std::cout << *cqitr << " ";
+ //} std::cout << std::endl;
+ Unit nextX = (*inputBegin).first.x();
+ if(!crossVector_.empty() && crossVector_[0].first.x() < nextX) nextX = crossVector_[0].first.x();
+ if(nextX != x_) {
+ //std::cout << "3\n";
+ //we need to move to the next scanline stop
+ //we need to process cross events, set scanline to the lowest x of the cross events
+ //if(nextX == 48032) { //48031
+ //std::cout << "at bad x, current x is " << x_ << std::endl; //break here
+ //}
+ if(!crossQueue_.empty() &&
+ (*crossQueue_.begin()).x() < nextX) {
+ //std::cout << "4\n";
+ nextX = std::min(nextX, (*crossQueue_.begin()).x());
+ }
+ //set scanline to the x of the nonIntegerEvents (should be x_ + 1)
+ if(!nonIntegerIntersectionVector_.empty() &&
+ (*nonIntegerIntersectionVector_.begin()).first.x() < nextX) {
+ nextX = (*nonIntegerIntersectionVector_.begin()).first.x();
+ }
+ //std::cout << "6\n";
+ //assert_invariant();
+ justBefore_ = true;
+ x_ = nextX;
+ //assert_invariant();
+ advance_(output);
+ //merge the non integer intersection events with the cross events
+ mergeCross_(nonIntegerIntersectionVector_.begin(), nonIntegerIntersectionVector_.end());
+ nonIntegerIntersectionVector_.clear();
+ //assert_invariant();
+ justBefore_ = false;
+ //assert_invariant();
+ if(!crossVector_.empty() &&
+ nextX == (*inputBegin).first.x()) {
+ inputBegin = mergeCross_(inputBegin, inputEnd);
+ }
+ processEvent_(output, crossVector_.begin(), crossVector_.end());
+ crossVector_.clear();
+ } else {
+ //std::cout << "7\n";
+ //our scanline has progressed to the event that is next in the queue
+ inputBegin = processEvent_(output, inputBegin, inputEnd);
+ }
+ }
+ //std::cout << "done scanning\n";
+ }
+
+ private:
+ //functions
+
+ template <class cT>
+ inline void advance_(cT& output) {
+ //process all cross points on the cross queue at the current x_
+ //std::cout << "advance_\n";
+ std::vector<iterator> eraseVec;
+ while(!crossQueue_.empty() &&
+ (*crossQueue_.begin()).x() == x_){
+ //std::cout << "loop\n";
+ //pop point off the cross queue
+ Point crossPoint = *(crossQueue_.begin());
+ //std::cout << crossPoint << std::endl;
+ //for(iterator iter = scanData_.begin();
+ // iter != scanData_.end(); ++iter) {
+ // std::cout << "scan element\n";
+ // std::cout << *iter << " " << iter->evalAtX(x_) << std::endl;
+ //}
+ crossQueue_.erase(crossQueue_.begin());
+ Scan45Vertex vertex(crossPoint, Scan45Count());
+ iterator lowIter = lookUp_(vertex.first.y());
+ //std::cout << "searching at: " << vertex.first.y() << std::endl;
+ //if(lowIter == scanData_.end()) std::cout << "could not find\n";
+ //else std::cout << "found: " << *lowIter << std::endl;
+ if(lowIter == scanData_.end() ||
+ lowIter->evalAtX(x_) != vertex.first.y()) {
+ // std::cout << "skipping\n";
+ //there weren't any edges at this potential cross point
+ continue;
+ }
+ Count2 countBelow(0, 0);
+ iterator searchDownItr = lowIter;
+ while(searchDownItr != scanData_.begin()
+ && searchDownItr->evalAtX(x_) == vertex.first.y()) {
+ //get count from below
+ --searchDownItr;
+ countBelow = searchDownItr->count;
+ }
+ //std::cout << "Below Count: " << countBelow << std::endl;
+ Scan45Count count(countBelow);
+ unsigned int numEdges = 0;
+ iterator eraseItrs[3];
+ while(lowIter != scanData_.end() &&
+ lowIter->evalAtX(x_) == vertex.first.y()) {
+ for(int index = lowIter->rise +1; index >= 0; --index)
+ count[index] = lowIter->count;
+ //std::cout << count << std::endl;
+ eraseItrs[numEdges] = lowIter;
+ ++numEdges;
+ ++lowIter;
+ }
+ if(numEdges == 1) {
+ //look for the next crossing point and continue
+ //std::cout << "found only one edge\n";
+ //if findCross_ returns true it means the iterator is about to cross its neighbor at non integer
+ //point, we need to handle this by faking an event
+ if(!findCross_(eraseItrs[0])) {
+ continue;
+ }
+ }
+ //before we erase the elements we need to decide if they should be written out
+ Count2 currentCount = countBelow;
+ for(unsigned int i = 0; i < numEdges; ++i) {
+ int edgeType = applyLogic(currentCount, eraseItrs[i]->count);
+ //std::cout << "cross logic: " << edgeType << std::endl;
+ if(edgeType == 1) {
+ output.insert(output.end(), Vertex45(crossPoint, eraseItrs[i]->rise, -1));
+ //output.insert(output.end(), std::pair<Point, Point>(Point(eraseItrs[i]->x, eraseItrs[i]->y),
+ // crossPoint));
+ //std::cout << "write out: " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << " " << crossPoint << std::endl;
+ } else if(edgeType == -1) {
+ output.insert(output.end(), Vertex45(crossPoint, eraseItrs[i]->rise, 1));
+ //output.insert(output.end(), std::pair<Point, Point>(crossPoint,
+ // Point(eraseItrs[i]->x, eraseItrs[i]->y)));
+ //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << std::endl;
+ }
+ currentCount = eraseItrs[i]->count;
+ }
+ //schedule erase of the elements
+ for(unsigned int i = 0; i < numEdges; ++i) {
+ eraseVec.push_back(eraseItrs[i]);
+ }
+
+ //take the derivative wrt theta of the count at the crossing point
+ vertex.second[2] = count[2] - countBelow;
+ vertex.second[1] = count[1] - count[2];
+ vertex.second[0] = count[0] - count[1];
+ //add the point, deriviative pair into the cross vector
+ //std::cout << "LOOK HERE!\n";
+ //std::cout << count << std::endl;
+ //std::cout << vertex << std::endl;
+ crossVector_.push_back(vertex);
+ }
+ //erase crossing elements
+ std::vector<iterator> searchVec;
+ //assert_invariant();
+ for(unsigned int i = 0; i < eraseVec.size(); ++i) {
+ //when erasing an element we need to see if the previous element will cross
+ //the next element, so add the previous element to the search list
+ if(eraseVec[i] != scanData_.begin()) {
+ iterator searchItr = eraseVec[i];
+ --searchItr;
+ if(searchVec.empty() ||
+ searchVec.back() != searchItr)
+ searchVec.push_back(searchItr);
+ }
+ scanData_.erase(eraseVec[i]);
+ }
+ //assert_invariant();
+ //have to search for edges on either side of removed elements
+ //crossing only after all elements were removed because two
+ //removed elements may be adjacent
+ for(unsigned int i = 0; i < searchVec.size(); ++i) {
+ findCross_(searchVec[i]);
+ }
+ }
+
+ template <class iT>
+ inline iT mergeCross_(iT inputBegin, iT inputEnd) {
+ Scan45Vector vec;
+ std::swap(vec, crossVector_);
+ iT mergeEnd = inputBegin;
+ unsigned int mergeCount = 0;
+ while(mergeEnd != inputEnd &&
+ (*mergeEnd).first.x() == x_) {
+ ++mergeCount;
+ ++mergeEnd;
+ }
+ crossVector_.reserve(std::max(vec.capacity(), vec.size() + mergeCount));
+ for(unsigned int i = 0; i < vec.size(); ++i){
+ while(inputBegin != mergeEnd &&
+ (*inputBegin).first.y() < vec[i].first.y()) {
+ crossVector_.push_back(*inputBegin);
+ ++inputBegin;
+ }
+ crossVector_.push_back(vec[i]);
+ }
+ while(inputBegin != mergeEnd){
+ crossVector_.push_back(*inputBegin);
+ ++inputBegin;
+ }
+ return inputBegin;
+ }
+
+ template <class cT, class iT>
+ inline iT processEvent_(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "processEvent_\n";
+ //if(x_ == 48031) {
+ // std::cout << "processing bad x event 48031\n";
+ //}
+ Count2 verticalCount = Count2(0, 0);
+ Point prevPoint;
+ iterator prevIter = scanData_.end();
+ Scan45Vertex niip_0, niip_1, niip_2;
+ bool prevNonIntegerIntersection = false;
+ Count2 upwardSlopingCount(0, 0);
+ bool downwardSlash = false;
+ Count2 downwardSlopingCount;
+ Count2 downwardSlopingCountFromScanline;
+ bool routeThroughUpperLeft = false;
+ bool haveDeferredVertex = false;
+ Scan45Vertex deferredVertex;
+ Unit prevY = std::numeric_limits<Unit>::max();
+ while(prevNonIntegerIntersection || haveDeferredVertex || (inputBegin != inputEnd && (*inputBegin).first.x() == x_)) {
+ //std::cout << (*inputBegin) << std::endl;
+ //std::cout << "loop\n";
+ Scan45Vertex vertex;
+ if(inputBegin != inputEnd)
+ vertex = *inputBegin;
+ //std::cout << vertex.first << std::endl;
+ //if vertical count propigating up fake a null event at the next element
+ if(haveDeferredVertex) {
+ vertex = deferredVertex;
+ haveDeferredVertex = false;
+ } else {
+ if(inputBegin == inputEnd ||
+ (prevNonIntegerIntersection && (*inputBegin).first.y() > prevY+1) ||
+ (verticalCount != Count2(0, 0) && (prevIter != scanData_.end() &&
+ prevIter->evalAtX(x_) < (*inputBegin).first.y()))) {
+ //std::cout << "faking null event\n";
+ vertex = Scan45Vertex(Point(x_, prevIter->evalAtX(x_)), Scan45Count());
+ } else {
+ ++inputBegin;
+ //std::cout << "after increment\n";
+ //accumulate overlapping changes in Scan45Count
+ while(inputBegin != inputEnd &&
+ (*inputBegin).first.x() == x_ &&
+ (*inputBegin).first.y() == vertex.first.y()) {
+ //std::cout << "accumulate\n";
+ vertex.second += (*inputBegin).second;
+ ++inputBegin;
+ }
+ }
+ }
+ Scan45Vertex t_niip_1, t_niip_2;
+ bool currentNonIntegerIntersection = false;
+ //check for down sloping input and up sloping
+ //scanline element below it
+ if(prevNonIntegerIntersection) {
+ if(!downwardSlash) {
+ //modify the input vertex here to re-route the downward sloping 45 edge
+ //insert events at x_ + 1 to complete re-routing the downward sloping 45 edge
+ //down sloping edge reroutes to the right, then down, then downward sloping
+ vertex.second[0] = Count2(0, 0);
+ vertex.second[0] -= downwardSlopingCountFromScanline;
+ vertex.second[1] += downwardSlopingCount;
+ niip_1.second[1] -= downwardSlopingCount;
+ niip_1.second[3] -= downwardSlopingCount;
+ niip_0.second[3] += downwardSlopingCount;
+ niip_0.second[0] += downwardSlopingCount;
+ }
+ if(routeThroughUpperLeft) {
+ vertex.second[3] += upwardSlopingCount;
+ vertex.second[1] += upwardSlopingCount;
+ }
+ downwardSlopingCount = Count2(0, 0);
+ } else {
+ //check for down sloping input and up sloping
+ //scanline element below it
+ downwardSlopingCount = Count2(0, 0);
+ if(vertex.second[0] != Count2(0, 0)) {
+ iterator lowIter = lookUp_(vertex.first.y());
+ if(lowIter != scanData_.begin()) {
+ //get count from below
+ --lowIter;
+ if(vertex.first.y() - 1 != prevY && lowIter->rise == 1 && lowIter->evalAtX(x_) == vertex.first.y() - 1) {
+ //we have a upward sloping element in the scanline just below the input
+ //downward sloping edge at vertex
+ deferredVertex = vertex;
+ downwardSlopingCount = deferredVertex.second[0];
+ haveDeferredVertex = true;
+ vertex.first = Point(x_, vertex.first.y() - 1);
+ //prevY = vertex.first.y();
+ vertex.second = Scan45Count();
+ prevIter = lowIter;
+// while(lowIter->evalAtX(x_) == vertex.first.y()) {
+// unsigned int indexAt = lowIter->rise+1;
+// vertex.second[indexAt] = lowIter->count;
+// if(lowIter == scanData_.begin()) break;
+// --lowIter;
+// vertex.second[indexAt] -= lowIter->count;
+// }
+ //while(!output.empty() &&
+ // output.back().pt == vertex.first)
+ // output.pop_back();
+ }
+ }
+ }
+ }
+ prevY = vertex.first.y();
+ if(!haveDeferredVertex)
+ prevIter = lookUp_(vertex.first.y()-1);
+ if(vertex.second[2] != Count2(0, 0) ||
+ (prevIter != scanData_.end() && prevIter->rise == 1 &&
+ prevIter->evalAtX(x_) == vertex.first.y())) {
+ //look up any downward sloping edge in the tree
+ downwardSlopingCountFromScanline = Count2(0, 0);
+ iterator upIter = lookUp_(vertex.first.y() + 1);
+ if(upIter != scanData_.end() && upIter->evalAtX(x_) == vertex.first.y() + 1) {
+ if(upIter->rise == -1) {
+ downwardSlopingCountFromScanline += upIter->count;
+ if(upIter != scanData_.begin()) {
+ --upIter;
+ //we want the change in count at the edge
+ downwardSlopingCountFromScanline -= (upIter->count - verticalCount);
+ }
+ }
+ }
+ downwardSlopingCount += downwardSlopingCountFromScanline;
+ if(downwardSlopingCount != Count2(0, 0) ||
+ (inputBegin != inputEnd && //not at end of input range
+ (*inputBegin).first.x() == x_ && //at current scanline stop
+ (*inputBegin).first.y() == vertex.first.y() + 1)) { //at next integral y position
+ iT tmpInputItr = inputBegin;
+ while(tmpInputItr != inputEnd && //not at end of input range
+ (*tmpInputItr).first.x() == x_ && //at current scanline stop
+ (*tmpInputItr).first.y() == vertex.first.y() + 1) { //at next integral y position
+ downwardSlopingCount += (*tmpInputItr).second[0];
+ ++tmpInputItr;
+ }
+ if(downwardSlopingCount != Count2(0, 0)) {
+ //we have hit a non integer intersection between 45 edges at this point in scanning
+ //we need to massage the input to "route traffic" around the non-integer point
+ //we can insert new input events into nonIntegerIntersectionVector_ to be handled at x_ + 1
+ //we can modify the input events at the current vertex, next vertex and vertical count
+ currentNonIntegerIntersection = true;
+ prevY = vertex.first.y();
+ upwardSlopingCount = vertex.second[2];
+ Count2 countBelow;
+ iterator lowIter = lookUp_(vertex.first.y());
+ Count2 upwardSlopingCountFromScanline = Count2(0, 0);
+ bool foundUpwardElement = false;
+ if(lowIter != scanData_.end() &&
+ lowIter->rise == 1) {
+ upwardSlopingCountFromScanline = lowIter->count;
+ foundUpwardElement = true;
+ }
+ if(lowIter != scanData_.begin()) {
+ //get count from below
+ --lowIter;
+ countBelow = lowIter->count;
+ ++lowIter;
+ }
+ if(foundUpwardElement)
+ upwardSlopingCountFromScanline -= (countBelow - verticalCount);
+ upwardSlopingCount += upwardSlopingCountFromScanline;
+ //if there is an up sloping edge in the scanline
+ //at this y location then we may need to include
+ //it in our calculations of counts
+ Count2 countOnBottom(countBelow);
+ countOnBottom += vertex.second[0];
+ countOnBottom += vertex.second[1];
+ Count2 countOnLeft = countOnBottom + upwardSlopingCount;
+ Count2 countOnTop = countOnLeft + downwardSlopingCount;
+ Count2 countOnRight = countOnBottom + downwardSlopingCount;
+ bool lb = applyLogic(countOnBottom);
+ bool lt = applyLogic(countOnTop);
+ bool ll = applyLogic(countOnLeft);
+ bool lr = applyLogic(countOnRight);
+ if(lb == ll && lt == lr && lt != lb) {
+ downwardSlash = true;
+ } else {
+ downwardSlash = false;
+ }
+ //modify the input vertex here to re-route the upward sloping 45 edge
+ //insert events at x_ + 1 to complete re-routing the upward sloping 45 edge
+ t_niip_1.first = Point(x_ + 1, vertex.first.y());
+ t_niip_2.first = Point(x_ + 1, vertex.first.y() + 1);
+ routeThroughUpperLeft = false;
+ if((lb && lr && !ll && !lt) ||
+ (!lb && !lr && ll && lt)) {
+ //upward slash case, no rerouting needed
+ lb = lr; //break here if needed
+ } else {
+ if((!ll && !lr) ||
+ (ll && lt && lr && !lb) ||
+ (ll && lt && !lr && lb) ||
+ (ll && !lt && lr && lb) ||
+ (!ll && !lt && lr && !lb)) {
+ //route right then up then upward sloping
+ vertex.second[2] = Count2(0, 0);
+ vertex.second[2] -= upwardSlopingCountFromScanline;
+ vertex.second[1] += upwardSlopingCount;
+ t_niip_1.second[1] -= upwardSlopingCount;
+ t_niip_1.second[3] -= upwardSlopingCount;
+ t_niip_2.second[3] += upwardSlopingCount;
+ t_niip_2.second[2] += upwardSlopingCount;
+ } else {
+ //route up then right then upward sloping
+ routeThroughUpperLeft = true;
+ vertex.second[2] = Count2(0, 0);
+ vertex.second[2] -= upwardSlopingCountFromScanline;
+ vertex.second[3] -= upwardSlopingCount;
+ t_niip_2.second[1] -= upwardSlopingCount;
+ t_niip_2.second[2] += upwardSlopingCount;
+ }
+ }
+
+ }
+ }
+ }
+ //write out non integer intersection events
+ if(currentNonIntegerIntersection || prevNonIntegerIntersection) {
+ if(niip_0.second != Scan45Count()) {
+ //write out count below current y
+ nonIntegerIntersectionVector_.push_back(niip_0);
+ niip_0 = Scan45Vertex();
+ }
+ if(!currentNonIntegerIntersection) {
+ if(niip_1.second != Scan45Count()) {
+ //write out count at y
+ nonIntegerIntersectionVector_.push_back(niip_1);
+ niip_1 = Scan45Vertex();
+ }
+ }
+ //rotate right side non integer intersection point outputs downward
+ niip_0 = t_niip_1;
+ niip_1 = t_niip_2;
+ niip_2 = Scan45Vertex();
+ }
+ //std::cout << vertex.second << std::endl;
+ //integrate vertex
+ Count2 currentCount = verticalCount;// + vertex.second[0];
+ for(unsigned int i = 0; i < 3; ++i) {
+ vertex.second[i] = currentCount += vertex.second[i];
+ }
+ //std::cout << vertex.second << std::endl;
+ //vertex represents the change in state at this point
+
+ //get counts at current vertex
+ Count2 countBelow;
+ iterator lowIter = lookUp_(vertex.first.y());
+ if(lowIter != scanData_.begin()) {
+ //get count from below
+ --lowIter;
+ countBelow = lowIter->count;
+ ++lowIter;
+ }
+ //std::cout << "Count Below: " << countBelow[0] << " " << countBelow[1] << std::endl;
+ //std::cout << "vertical count: " << verticalCount[0] << " " << verticalCount[1] << std::endl;
+ Scan45Count countAt(countBelow - verticalCount);
+ //check if the vertical edge should be written out
+ if(verticalCount != Count2(0, 0)) {
+ int edgeType = applyLogic(countBelow - verticalCount, countBelow);
+ //std::cout << "vertical logic: " << edgeType << std::endl;
+ if(edgeType == 1) {
+ //std::cout << "write out: " << vertex.first << " " << prevPoint << std::endl;
+ output.insert(output.end(), Vertex45(prevPoint, 2, 1));
+ output.insert(output.end(), Vertex45(vertex.first, 2, -1));
+ //output.insert(output.end(), std::pair<Point, Point>(vertex.first, prevPoint));
+ } else if(edgeType == -1){
+ //std::cout << "write out: " << prevPoint << " " << vertex.first << std::endl;
+ output.insert(output.end(), Vertex45(prevPoint, 2, -1));
+ output.insert(output.end(), Vertex45(vertex.first, 2, 1));
+ //output.insert(output.end(), std::pair<Point, Point>(prevPoint, vertex.first));
+ }
+ }
+ currentCount = countBelow - verticalCount;
+ while(lowIter != scanData_.end() &&
+ lowIter->evalAtX(x_) == vertex.first.y()) {
+ for(unsigned int i = lowIter->rise + 1; i < 3; ++i) {
+ countAt[i] = lowIter->count;
+ }
+ Point lp(lowIter->x, lowIter->y);
+ if(lp != vertex.first) {
+ int edgeType = applyLogic(currentCount, lowIter->count);
+ //std::cout << "edge logic: " << edgeType << std::endl;
+ if(edgeType == 1) {
+ //std::cout << "write out: " << lp << " " << vertex.first << std::endl;
+ output.insert(output.end(), Vertex45(vertex.first, lowIter->rise, -1));
+ //output.insert(output.end(), std::pair<Point, Point>(lp, vertex.first));
+ } else if(edgeType == -1) {
+ //std::cout << "write out: " << vertex.first << " " << lp << std::endl;
+ output.insert(output.end(), Vertex45(vertex.first, lowIter->rise, 1));
+ //output.insert(output.end(), std::pair<Point, Point>(vertex.first, lp));
+ }
+ }
+ currentCount = lowIter->count;
+ iterator nextIter = lowIter;
+ ++nextIter;
+ //std::cout << "erase\n";
+ scanData_.erase(lowIter);
+ lowIter = nextIter;
+ }
+ //assert_invariant();
+ prevNonIntegerIntersection = currentNonIntegerIntersection;
+ verticalCount += vertex.second[3];
+ prevPoint = vertex.first;
+ //std::cout << "new vertical count: " << verticalCount[0] << " " << verticalCount[1] << std::endl;
+ prevIter = lowIter;
+ //count represents the current state at this point
+ //std::cout << vertex.second << std::endl;
+ //std::cout << countAt << std::endl;
+ //std::cout << "ADD\n";
+ vertex.second += countAt;
+ //std::cout << vertex.second << std::endl;
+
+ //add elements to the scanline
+ for(int i = 0; i < 3; ++i) {
+ if(vertex.second[i] != countBelow) {
+ //std::cout << "insert: " << vertex.first.x() << " " << vertex.first.y() << " " << i-1 <<
+ // " " << vertex.second[i][0] << " " << vertex.second[i][1] << std::endl;
+ iterator insertIter = scanData_.insert(scanData_.end(),
+ Scan45Element(vertex.first.x(),
+ vertex.first.y(),
+ i - 1, vertex.second[i]));
+ findCross_(insertIter);
+ int edgeType = applyLogic(countBelow, vertex.second[i]);
+ if(edgeType)
+ output.insert(output.end(), Vertex45(vertex.first, i - 1, edgeType));
+ //assert_invariant();
+ }
+ countBelow = vertex.second[i];
+ }
+ }
+ //std::cout << "end processEvent\n";
+ return inputBegin;
+ }
+
+ //iter1 is horizontal
+ inline void scheduleCross0_(iterator iter1, iterator iter2) {
+ //std::cout << "0, ";
+ Unit y1 = iter1->evalAtX(x_);
+ Unit y2 = iter2->evalAtX(x_);
+ LongUnit delta = (LongUnit)abs((LongUnit)y1 - (LongUnit)y2);
+ if(delta + x_ <= (std::numeric_limits<Unit>::max)())
+ crossQueue_.insert(crossQueue_.end(), Point(x_ + delta, y1));
+ //std::cout << Point(x_ + delta, y1);
+ }
+
+ //neither iter is horizontal
+ inline bool scheduleCross1_(iterator iter1, iterator iter2) {
+ //std::cout << "1, ";
+ Unit y1 = iter1->evalAtX(x_);
+ Unit y2 = iter2->evalAtX(x_);
+ //std::cout << y1 << " " << y2 << ": ";
+ //note that half the delta cannot exceed the positive inter range
+ LongUnit delta = y1;
+ delta -= y2;
+ Unit UnitMax = (std::numeric_limits<Unit>::max)();
+ if(delta & 1) {
+ //delta is odd, division by 2 will result in integer trunctaion
+ if(delta == 1) {
+ //the cross point is not on the integer grid and cannot be represented
+ // //we must throw an exception
+ //std::string msg = "GTL 45 Boolean error, precision insufficient to represent edge intersection coordinate value.";
+ //throw(msg);
+ return true;
+ } else {
+ //note that result of this subtraction is always positive because itr1 is above itr2 in scanline
+ LongUnit halfDelta2 = (LongUnit)((((LongUnit)y1) - y2)/2);
+ //note that halfDelta2 has been truncated
+ if(halfDelta2 + x_ <= UnitMax && halfDelta2 + y2 <= UnitMax) {
+ crossQueue_.insert(crossQueue_.end(), Point(x_+halfDelta2, y2+halfDelta2));
+ crossQueue_.insert(crossQueue_.end(), Point(x_+halfDelta2, y2+halfDelta2+1));
+ }
+ }
+ } else {
+ LongUnit halfDelta = (LongUnit)((((LongUnit)y1) - y2)/2);
+ if(halfDelta + x_ <= UnitMax && halfDelta + y2 <= UnitMax)
+ crossQueue_.insert(crossQueue_.end(), Point(x_+halfDelta, y2+halfDelta));
+ //std::cout << Point(x_+halfDelta, y2+halfDelta);
+ }
+ return false;
+ }
+
+ inline bool findCross_(iterator iter) {
+ //std::cout << "find cross ";
+ iterator iteratorBelow = iter;
+ iterator iteratorAbove = iter;
+ if(iter != scanData_.begin() && iter->rise < 1) {
+ --iteratorBelow;
+ if(iter->rise == 0){
+ if(iteratorBelow->rise == 1) {
+ scheduleCross0_(iter, iteratorBelow);
+ }
+ } else {
+ //iter->rise == -1
+ if(iteratorBelow->rise == 1) {
+ return scheduleCross1_(iter, iteratorBelow);
+ } else if(iteratorBelow->rise == 0) {
+ scheduleCross0_(iteratorBelow, iter);
+ }
+ }
+ }
+ ++iteratorAbove;
+ if(iteratorAbove != scanData_.end() && iter->rise > -1) {
+ if(iter->rise == 0) {
+ if(iteratorAbove->rise == -1) {
+ scheduleCross0_(iter, iteratorAbove);
+ }
+ } else {
+ //iter->rise == 1
+ if(iteratorAbove->rise == -1) {
+ return scheduleCross1_(iteratorAbove, iter);
+ } else if(iteratorAbove->rise == 0) {
+ scheduleCross0_(iteratorAbove, iter);
+ }
+ }
+ }
+ //std::cout << std::endl;
+ return false;
+ }
+
+ inline iterator lookUp_(Unit y){
+ //if just before then we need to look from 1 not -1
+ return scanData_.lower_bound(Scan45Element(x_, y, -1+2*justBefore_));
+ }
+
+ int applyLogic(Count2 count1, Count2 count2){
+ bool l1 = applyLogic(count1);
+ bool l2 = applyLogic(count2);
+ if(l1 && !l2)
+ return -1; //was true before and became false like a trailing edge
+ if(!l1 && l2)
+ return 1; //was false before and became true like a leading edge
+ return 0; //no change in logic between the two counts
+ }
+ bool applyLogic(Count2 count) {
+ if(op_ == 0) { //apply or
+ return count[0] > 0 || count[1] > 0;
+ }
+ if(op_ == 1) { //apply and
+ return count[0] > 0 && count[1] > 0;
+ }
+ if(op_ == 2) { //apply not
+ return count[0] > 0 && !(count[1] > 0);
+ }
+ if(op_ == 3) { //apply xor
+ return (count[0] > 0) ^ (count[1] > 0);
+ }
+ return false;
+ }
+ };
+
+
+ static inline void print45Data(const std::set<Scan45Element, lessScan45Element>& data) {
+ typename std::set<Scan45Element, lessScan45Element>::const_iterator iter;
+ for(iter = data.begin(); iter != data.end(); ++iter) {
+ std::cout << iter->x << " " << iter->y << " " << iter->rise << std::endl;
+ }
+ }
+
+ static inline bool testScan45Data() {
+ Unit x = 0;
+ int justBefore = false;
+ lessScan45Element lessElm(&x, &justBefore);
+ std::set<Scan45Element, lessScan45Element> testData(lessElm);
+ //Unit size = testData.size();
+ typedef std::set<Scan45Element, lessScan45Element> Scan45Data;
+ typename Scan45Data::iterator itr10 = testData.insert(testData.end(), Scan45Element(0, 10, 1));
+ typename Scan45Data::iterator itr20 = testData.insert(testData.end(), Scan45Element(0, 20, 1));
+ typename Scan45Data::iterator itr30 = testData.insert(testData.end(), Scan45Element(0, 30, -1));
+ typename Scan45Data::iterator itr40 = testData.insert(testData.end(), Scan45Element(0, 40, -1));
+ typename Scan45Data::iterator itrA = testData.lower_bound(Scan45Element(0, 29, -1));
+ typename Scan45Data::iterator itr1 = testData.lower_bound(Scan45Element(0, 10, -1));
+ x = 4;
+ //now at 14 24 26 36
+ typename Scan45Data::iterator itrB = testData.lower_bound(Scan45Element(4, 29, -1));
+ typename Scan45Data::iterator itr2 = testData.lower_bound(Scan45Element(4, 14, -1));
+ if(itr1 != itr2) std::cout << "test1 failed\n";
+ if(itrA == itrB) std::cout << "test2 failed\n";
+ //remove crossing elements
+ testData.erase(itr20);
+ testData.erase(itr30);
+ x = 5;
+ itr20 = testData.insert(testData.end(), Scan45Element(0, 20, 1));
+ itr30 = testData.insert(testData.end(), Scan45Element(0, 30, -1));
+ //now at 15 25 25 35
+ typename Scan45Data::iterator itr = testData.begin();
+ if(itr != itr10) std::cout << "test3 failed\n";
+ ++itr;
+ if(itr != itr30) std::cout << "test4 failed\n";
+ ++itr;
+ if(itr != itr20) std::cout << "test5 failed\n";
+ ++itr;
+ if(itr != itr40) std::cout << "test6 failed\n";
+ std::cout << "done testing Scan45Data\n";
+ return true;
+ }
+
+ static inline bool testScan45Rect() {
+ std::cout << "testing Scan45Rect\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,0), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ vertices.push_back(Scan45Vertex(Point(0,10), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(10,0), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(10,10), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 8
+ // result == 0 0 0 1
+ // result == 0 0 2 1
+ // result == 0 10 2 -1
+ // result == 0 10 0 -1
+ // result == 10 0 0 -1
+ // result == 10 0 2 -1
+ // result == 10 10 2 1
+ // result == 10 10 0 1
+ std::vector<Vertex45> reference;
+ reference.push_back(Vertex45(Point(0, 0), 0, 1));
+ reference.push_back(Vertex45(Point(0, 0), 2, 1));
+ reference.push_back(Vertex45(Point(0, 10), 2, -1));
+ reference.push_back(Vertex45(Point(0, 10), 0, -1));
+ reference.push_back(Vertex45(Point(10, 0), 0, -1));
+ reference.push_back(Vertex45(Point(10, 0), 2, -1));
+ reference.push_back(Vertex45(Point(10, 10), 2, 1));
+ reference.push_back(Vertex45(Point(10, 10), 0, 1));
+ if(result != reference) {
+ std::cout << "result size == " << result.size() << std::endl;
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ //std::cout << "result == " << result[i]<< std::endl;
+ }
+ std::cout << "reference size == " << reference.size() << std::endl;
+ for(unsigned int i = 0; i < reference.size(); ++i) {
+ //std::cout << "reference == " << reference[i]<< std::endl;
+ }
+ return false;
+ }
+ std::cout << "done testing Scan45Rect\n";
+ return true;
+ }
+
+ static inline bool testScan45P1() {
+ std::cout << "testing Scan45P1\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,0), Scan45Count(Count2(0, 0), Count2(0, 0), count, count)));
+ vertices.push_back(Scan45Vertex(Point(0,10), Scan45Count(Count2(0, 0), Count2(0, 0), ncount, ncount)));
+ vertices.push_back(Scan45Vertex(Point(10,10), Scan45Count(Count2(0, 0), Count2(0, 0), ncount, ncount)));
+ vertices.push_back(Scan45Vertex(Point(10,20), Scan45Count(Count2(0, 0), Count2(0, 0), count, count)));
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 8
+ // result == 0 0 1 1
+ // result == 0 0 2 1
+ // result == 0 10 2 -1
+ // result == 0 10 1 -1
+ // result == 10 10 1 -1
+ // result == 10 10 2 -1
+ // result == 10 20 2 1
+ // result == 10 20 1 1
+ std::vector<Vertex45> reference;
+ reference.push_back(Vertex45(Point(0, 0), 1, 1));
+ reference.push_back(Vertex45(Point(0, 0), 2, 1));
+ reference.push_back(Vertex45(Point(0, 10), 2, -1));
+ reference.push_back(Vertex45(Point(0, 10), 1, -1));
+ reference.push_back(Vertex45(Point(10, 10), 1, -1));
+ reference.push_back(Vertex45(Point(10, 10), 2, -1));
+ reference.push_back(Vertex45(Point(10, 20), 2, 1));
+ reference.push_back(Vertex45(Point(10, 20), 1, 1));
+ if(result != reference) {
+ std::cout << "result size == " << result.size() << std::endl;
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ //std::cout << "result == " << result[i]<< std::endl;
+ }
+ std::cout << "reference size == " << reference.size() << std::endl;
+ for(unsigned int i = 0; i < reference.size(); ++i) {
+ //std::cout << "reference == " << reference[i]<< std::endl;
+ }
+ return false;
+ }
+ std::cout << "done testing Scan45P1\n";
+ return true;
+ }
+
+ static inline bool testScan45P2() {
+ std::cout << "testing Scan45P2\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,0), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(10,0), Scan45Count(Count2(0, 0), ncount, count, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(10,10), Scan45Count(Count2(0, 0), ncount, count, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(20,10), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 8
+ // result == 0 0 0 1
+ // result == 0 0 1 -1
+ // result == 10 0 0 -1
+ // result == 10 0 1 1
+ // result == 10 10 1 1
+ // result == 10 10 0 -1
+ // result == 20 10 1 -1
+ // result == 20 10 0 1
+ std::vector<Vertex45> reference;
+ reference.push_back(Vertex45(Point(0, 0), 0, 1));
+ reference.push_back(Vertex45(Point(0, 0), 1, -1));
+ reference.push_back(Vertex45(Point(10, 0), 0, -1));
+ reference.push_back(Vertex45(Point(10, 0), 1, 1));
+ reference.push_back(Vertex45(Point(10, 10), 1, 1));
+ reference.push_back(Vertex45(Point(10, 10), 0, -1));
+ reference.push_back(Vertex45(Point(20, 10), 1, -1));
+ reference.push_back(Vertex45(Point(20, 10), 0, 1));
+ if(result != reference) {
+ std::cout << "result size == " << result.size() << std::endl;
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ //std::cout << "result == " << result[i]<< std::endl;
+ }
+ std::cout << "reference size == " << reference.size() << std::endl;
+ for(unsigned int i = 0; i < reference.size(); ++i) {
+ //std::cout << "reference == " << reference[i]<< std::endl;
+ }
+ return false;
+ }
+ std::cout << "done testing Scan45P2\n";
+ return true;
+ }
+
+ static inline bool testScan45And() {
+ std::cout << "testing Scan45And\n";
+ Scan45 scan45(1);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,0), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ vertices.push_back(Scan45Vertex(Point(0,10), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(10,0), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(10,10), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(2,2), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ vertices.push_back(Scan45Vertex(Point(2,12), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(12,2), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(12,12), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ //result size == 8
+ //result == 2 2 0 1
+ //result == 2 2 2 1
+ //result == 2 10 2 -1
+ //result == 2 10 0 -1
+ //result == 10 2 0 -1
+ //result == 10 2 2 -1
+ //result == 10 10 2 1
+ //result == 10 10 0 1
+ std::vector<Vertex45> reference;
+ reference.push_back(Vertex45(Point(2, 2), 0, 1));
+ reference.push_back(Vertex45(Point(2, 2), 2, 1));
+ reference.push_back(Vertex45(Point(2, 10), 2, -1));
+ reference.push_back(Vertex45(Point(2, 10), 0, -1));
+ reference.push_back(Vertex45(Point(10, 2), 0, -1));
+ reference.push_back(Vertex45(Point(10, 2), 2, -1));
+ reference.push_back(Vertex45(Point(10, 10), 2, 1));
+ reference.push_back(Vertex45(Point(10, 10), 0, 1));
+ if(result != reference) {
+ std::cout << "result size == " << result.size() << std::endl;
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ //std::cout << "result == " << result[i]<< std::endl;
+ }
+ std::cout << "reference size == " << reference.size() << std::endl;
+ for(unsigned int i = 0; i < reference.size(); ++i) {
+ //std::cout << "reference == " << reference[i]<< std::endl;
+ }
+ return false;
+ }
+ std::cout << "done testing Scan45And\n";
+ return true;
+ }
+
+ static inline bool testScan45Star1() {
+ std::cout << "testing Scan45Star1\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,8), Scan45Count(count, Count2(0, 0), ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,0), Scan45Count(ncount, Count2(0, 0), Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(8,16), Scan45Count(Count2(0, 0), Count2(0, 0), count, count)));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(12,8), Scan45Count(count, Count2(0, 0), ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(4,0), Scan45Count(Count2(0, 0), Count2(0, 0), count, count)));
+ vertices.push_back(Scan45Vertex(Point(4,16), Scan45Count(ncount, Count2(0, 0), Count2(0, 0), ncount)));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 24
+ // result == 0 8 -1 1
+ // result == 0 8 1 -1
+ // result == 4 0 1 1
+ // result == 4 0 2 1
+ // result == 4 4 2 -1
+ // result == 4 4 -1 -1
+ // result == 4 12 1 1
+ // result == 4 12 2 1
+ // result == 4 16 2 -1
+ // result == 4 16 -1 -1
+ // result == 6 2 1 -1
+ // result == 6 14 -1 1
+ // result == 6 2 -1 1
+ // result == 6 14 1 -1
+ // result == 8 0 -1 -1
+ // result == 8 0 2 -1
+ // result == 8 4 2 1
+ // result == 8 4 1 1
+ // result == 8 12 -1 -1
+ // result == 8 12 2 -1
+ // result == 8 16 2 1
+ // result == 8 16 1 1
+ // result == 12 8 1 -1
+ // result == 12 8 -1 1
+ if(result.size() != 24) {
+ //std::cout << "result size == " << result.size() << std::endl;
+ //std::cout << "reference size == " << 24 << std::endl;
+ return false;
+ }
+ std::cout << "done testing Scan45Star1\n";
+ return true;
+ }
+
+ static inline bool testScan45Star2() {
+ std::cout << "testing Scan45Star2\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,4), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,4), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,12), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(0,8), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,8), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,0), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 24
+ // result == 0 4 0 1
+ // result == 0 4 1 -1
+ // result == 0 8 -1 1
+ // result == 0 8 0 -1
+ // result == 2 6 1 1
+ // result == 2 6 -1 -1
+ // result == 4 4 0 -1
+ // result == 4 8 0 1
+ // result == 4 4 -1 1
+ // result == 4 8 1 -1
+ // result == 8 0 -1 -1
+ // result == 8 0 1 1
+ // result == 8 12 1 1
+ // result == 8 12 -1 -1
+ // result == 12 4 1 -1
+ // result == 12 8 -1 1
+ // result == 12 4 0 1
+ // result == 12 8 0 -1
+ // result == 14 6 -1 -1
+ // result == 14 6 1 1
+ // result == 16 4 0 -1
+ // result == 16 4 -1 1
+ // result == 16 8 1 -1
+ // result == 16 8 0 1
+ if(result.size() != 24) {
+ //std::cout << "result size == " << result.size() << std::endl;
+ //std::cout << "reference size == " << 24 << std::endl;
+ return false;
+ }
+ std::cout << "done testing Scan45Star2\n";
+ return true;
+ }
+
+ static inline bool testScan45Star3() {
+ std::cout << "testing Scan45Star3\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,8), Scan45Count(count, Count2(0, 0), ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,0), Scan45Count(ncount, Count2(0, 0), Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(8,16), Scan45Count(Count2(0, 0), Count2(0, 0), count, count)));
+
+ vertices.push_back(Scan45Vertex(Point(6,0), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ vertices.push_back(Scan45Vertex(Point(6,14), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(12,0), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(12,14), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(12,8), Scan45Count(count, Count2(0, 0), ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(4,0), Scan45Count(Count2(0, 0), Count2(0, 0), count, count)));
+ vertices.push_back(Scan45Vertex(Point(4,16), Scan45Count(ncount, Count2(0, 0), Count2(0, 0), ncount)));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 28
+ // result == 0 8 -1 1
+ // result == 0 8 1 -1
+ // result == 4 0 1 1
+ // result == 4 0 2 1
+ // result == 4 4 2 -1
+ // result == 4 4 -1 -1
+ // result == 4 12 1 1
+ // result == 4 12 2 1
+ // result == 4 16 2 -1
+ // result == 4 16 -1 -1
+ // result == 6 2 1 -1
+ // result == 6 14 -1 1
+ // result == 6 0 0 1
+ // result == 6 0 2 1
+ // result == 6 2 2 -1
+ // result == 6 14 1 -1
+ // result == 8 0 0 -1
+ // result == 8 0 0 1
+ // result == 8 14 0 -1
+ // result == 8 14 2 -1
+ // result == 8 16 2 1
+ // result == 8 16 1 1
+ // result == 12 0 0 -1
+ // result == 12 0 2 -1
+ // result == 12 8 2 1
+ // result == 12 8 2 -1
+ // result == 12 14 2 1
+ // result == 12 14 0 1
+ if(result.size() != 28) {
+ //std::cout << "result size == " << result.size() << std::endl;
+ //std::cout << "reference size == " << 28 << std::endl;
+ return false;
+ }
+
+ std::cout << "done testing Scan45Star3\n";
+ return true;
+ }
+
+ static inline bool testScan45Star4() {
+ std::cout << "testing Scan45Star4\n";
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,4), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,4), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,12), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+
+ vertices.push_back(Scan45Vertex(Point(0,6), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ vertices.push_back(Scan45Vertex(Point(0,12), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(16,6), Scan45Count(Count2(0, 0), ncount, Count2(0, 0), ncount)));
+ vertices.push_back(Scan45Vertex(Point(16,12), Scan45Count(Count2(0, 0), count, Count2(0, 0), count)));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(0,8), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,8), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,0), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+ std::cout << "done scanning\n";
+ // result size == 28
+ // result == 0 4 0 1
+ // result == 0 4 1 -1
+ // result == 0 6 0 1
+ // result == 0 6 2 1
+ // result == 0 8 2 -1
+ // result == 0 8 2 1
+ // result == 0 12 2 -1
+ // result == 0 12 0 -1
+ // result == 2 6 1 1
+ // result == 2 6 0 -1
+ // result == 4 4 0 -1
+ // result == 4 4 -1 1
+ // result == 8 12 0 1
+ // result == 8 0 -1 -1
+ // result == 8 0 1 1
+ // result == 8 12 0 -1
+ // result == 12 4 1 -1
+ // result == 12 4 0 1
+ // result == 14 6 -1 -1
+ // result == 14 6 0 1
+ // result == 16 4 0 -1
+ // result == 16 4 -1 1
+ // result == 16 6 0 -1
+ // result == 16 6 2 -1
+ // result == 16 8 2 1
+ // result == 16 8 2 -1
+ // result == 16 12 2 1
+ // result == 16 12 0 1
+ if(result.size() != 28) {
+ //std::cout << "result size == " << result.size() << std::endl;
+ //std::cout << "reference size == " << 28 << std::endl;
+ return false;
+ }
+
+ std::cout << "done testing Scan45Star4\n";
+ return true;
+ }
+
+ static inline bool testScan45() {
+ if(!testScan45Rect()) return false;
+ if(!testScan45P1()) return false;
+ if(!testScan45P2()) return false;
+ if(!testScan45And()) return false;
+ if(!testScan45Star1()) return false;
+ if(!testScan45Star2()) return false;
+ if(!testScan45Star3()) return false;
+ if(!testScan45Star4()) return false;
+ return true;
+ }
+
+ };
+
+}
+#endif
Modified: sandbox/gtl/gtl/gtl.hpp
==============================================================================
--- sandbox/gtl/gtl/gtl.hpp (original)
+++ sandbox/gtl/gtl/gtl.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,6 +7,7 @@
*/
#ifndef GTL_GTL_HPP
#define GTL_GTL_HPP
+
//external
#include <math.h>
#include <vector>
@@ -19,632 +20,90 @@
#include <limits>
#include <iterator>
-//isotropy types
+#ifdef __ICC
+#pragma warning (disable:1125)
+#endif
+
#include "isotropy.hpp"
-//data types
+//point
#include "point_data.hpp"
-#include "interval_data.hpp"
-#include "rectangle_data.hpp"
-#include "point_3d_data.hpp"
-
-//traits types
#include "point_traits.hpp"
-#include "interval_traits.hpp"
-#include "rectangle_traits.hpp"
+#include "point_concept.hpp"
+
+//point 3d
+#include "point_3d_data.hpp"
#include "point_3d_traits.hpp"
-#include "polygon_traits.hpp"
-#include "polygon_with_holes_traits.hpp"
+#include "point_3d_concept.hpp"
-//concept types
-#include "point_concept.hpp"
+#include "transform.hpp"
+#include "transform_detail.hpp"
+
+//interval
+#include "interval_data.hpp"
+#include "interval_traits.hpp"
#include "interval_concept.hpp"
+
+//rectangle
+#include "rectangle_data.hpp"
+#include "rectangle_traits.hpp"
#include "rectangle_concept.hpp"
-#include "point_3d_concept.hpp"
//algorithms needed by polygon types
#include "iterator_points_to_compact.hpp"
#include "iterator_compact_to_points.hpp"
+//polygons
+#include "polygon_45_data.hpp"
+#include "polygon_data.hpp"
#include "polygon_90_data.hpp"
#include "polygon_90_with_holes_data.hpp"
-#include "polygon_45_data.hpp"
#include "polygon_45_with_holes_data.hpp"
-#include "polygon_data.hpp"
#include "polygon_with_holes_data.hpp"
+#include "polygon_traits.hpp"
-//polygon concept types
-#include "polygon_90_concept.hpp"
-#include "polygon_90_with_holes_concept.hpp"
-#include "polygon_45_concept.hpp"
-#include "polygon_45_with_holes_concept.hpp"
-#include "polygon_concept.hpp"
-#include "polygon_with_holes_concept.hpp"
-
-//definitions
-#include "post_concept_definitions.hpp"
-
-//manhattan boolean op algorithms
+//manhattan boolean algorithms
#include "boolean_op.hpp"
#include "polygon_formation.hpp"
#include "rectangle_formation.hpp"
+#include "max_cover.hpp"
#include "property_merge.hpp"
-#include "iterator_vertex_orient_conversion.hpp"
+#include "polygon_90_touch.hpp"
#include "iterator_geometry_to_set.hpp"
-//geometry traits
-#include "geometry_concept.hpp"
+//45 boolean op algorithms
+#include "boolean_op_45.hpp"
+#include "polygon_45_formation.hpp"
+//polygon set data types
+#include "polygon_90_set_data.hpp"
//polygon set trait types
-#include "polygon_set_traits.hpp"
+#include "polygon_90_set_traits.hpp"
//polygon set concepts
-#include "polygon_set_view.hpp"
-//polygon set data types
-#include "polygon_set_wrapper.hpp"
-#include "polygon_set_data.hpp"
-
+#include "polygon_90_set_concept.hpp"
+//boolean operator syntax
+#include "polygon_90_set_view.hpp"
+
+//45 boolean op algorithms
+#include "boolean_op_45.hpp"
+#include "polygon_45_formation.hpp"
+#include "polygon_45_set_data.hpp"
+#include "polygon_45_set_traits.hpp"
+#include "polygon_45_set_concept.hpp"
+#include "polygon_45_set_view.hpp"
-//defintions
-#include "post_geometry_traits_definitions.hpp"
+//arbitrary polygon algorithms
+#include "polygon_arbitrary_formation.hpp"
+#include "polygon_set_data.hpp"
//general scanline
-//#include "scan_arbitrary.hpp"
-
-namespace gtl {
-
-//immutable unary functions
-
-//accepts: point rectangle point_3d prism
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-get(const geometry_type& geometry_object, orientation_2d orient) {
- return geometry_concept<geometry_type>::type::get(geometry_object, orient);
-}
-
-//accepts: point_3d prism
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-get(const geometry_type& geometry_object, orientation_3d orient) {
- return geometry_concept<geometry_type>::type::get(geometry_object, orient);
-}
-
-//accepts: interval
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-get(const geometry_type& geometry_object, direction_1d dir) {
- return geometry_concept<geometry_type>::type::get(geometry_object, dir);
-}
-
-//accepts: interval
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-high(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::high(geometry_object);
-}
-
-//accepts: interval
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-low(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::low(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-horizontal(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::horizontal(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename component_type<geometry_type>::type
-vertical(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::vertical(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename coordinate_type<geometry_type>::type
-xl(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::xl(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename coordinate_type<geometry_type>::type
-yl(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::yl(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename coordinate_type<geometry_type>::type
-xh(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::xh(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename coordinate_type<geometry_type>::type
-yh(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::yh(geometry_object);
-}
-
-//accepts: interval
-template <typename geometry_type>
-typename center_type<geometry_type>::type
-center(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::center(geometry_object);
-}
-
-//accepts: interval
-template <typename geometry_type>
-typename coordinate_difference<geometry_type>::type
-delta(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::delta(geometry_object);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-typename coordinate_difference<geometry_type>::type
-delta(const geometry_type& geometry_object, orientation_2d orient) {
- return geometry_concept<geometry_type>::type::delta(geometry_object, orient);
-}
-
-//accepts: prism
-template <typename geometry_type>
-typename coordinate_difference<geometry_type>::type
-delta(const geometry_type& geometry_object, orientation_3d orient) {
- return geometry_concept<geometry_type>::type::delta(geometry_object, orient);
-}
-
-//accepts: rectangle, polygon
-template <typename geometry_type>
-typename area_type<geometry_type>::type
-area(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::area(geometry_object);
-}
-
-//accepts: rectangle
-template <typename geometry_type>
-typename coordinate_distance<geometry_type>::type
-half_perimeter(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::half_perimeter(geometry_object);
-}
-
-//accepts: rectangle, polygon
-template <typename geometry_type>
-typename coordinate_distance<geometry_type>::type
-perimeter(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::perimeter(geometry_object);
-}
-
-template <typename geometry_type>
-orientation_2d guess_orientation(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::guess_orientation(geometry_object);
-}
-
-
-//mutable unary functions
-
-template <typename geometry_type>
-void set(geometry_type& geometry_object, direction_1d dir, typename component_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::set(geometry_object, dir, value);
-}
-
-//accepts: point,coordinate point_3d,coordinate rectangle,interval prism,interval
-template <typename geometry_type_1, typename geometry_type_2>
-void set(geometry_type_1& geometry_object, orientation_2d orient, const geometry_type_2& value) {
- geometry_concept<geometry_type_1>::type::set(geometry_object, orient, value);
-}
-
-//accepts: point_3d,coordinate prism,interval
-template <typename geometry_type_1, typename geometry_type_2>
-void set(geometry_type_1& geometry_object, orientation_3d orient, const geometry_type_2& value) {
- geometry_concept<geometry_type_1>::type::set(geometry_object, orient, value);
-}
-
-template <typename geometry_type, typename point_type_1, typename point_type_2>
-geometry_type& set_points(geometry_type& geometry_object, const point_type_1& point1, const point_type_2& point2) {
- return geometry_concept<geometry_type>::type::set_points(geometry_object, point1, point2);
-}
-
-template <typename geometry_type>
-void high(geometry_type& geometry_object, typename component_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::high(geometry_object, value);
-}
-
-template <typename geometry_type>
-void low(geometry_type& geometry_object, typename component_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::low(geometry_object, value);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-void xl(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::xl(geometry_object, value);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-void xh(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::xh(geometry_object, value);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-void yl(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::yl(geometry_object, value);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type>
-void yh(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type value) {
- geometry_concept<geometry_type>::type::yh(geometry_object, value);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type_1, typename geometry_type_2>
-void horizontal(geometry_type_1& geometry_object, const geometry_type_2& value) {
- geometry_concept<geometry_type_1>::type::horizontal(geometry_object, value);
-}
-
-//accepts: rectangle prism
-template <typename geometry_type_1, typename geometry_type_2>
-void vertical(geometry_type_1& geometry_object, const geometry_type_2& value) {
- geometry_concept<geometry_type_1>::type::vertical(geometry_object, value);
-}
-
-//immutable binary functions
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool contains(const geometry_type_1& geometry_object, const geometry_type_2& contained_geometry_object,
- bool consider_touch = true) {
- return geometry_concept<geometry_type_1>::type::contains(geometry_object, contained_geometry_object,
- consider_touch, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool equivalence(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- typename geometry_concept<geometry_type_1>::type concept_instantiation;
- return concept_instantiation.equivalence(lvalue, rvalue);
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool intersects(geometry_type_1& lvalue, geometry_type_2& rvalue, bool consider_touch = true) {
- return geometry_concept<geometry_type_1>::type::intersects(lvalue, rvalue, consider_touch, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool boundaries_intersect(geometry_type_1& lvalue, const geometry_type_2& rvalue, bool consider_touch = true) {
- return geometry_concept<geometry_type_1>::type::boundaries_intersect(lvalue, rvalue, consider_touch, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool abuts(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::abuts(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool abuts(geometry_type_1& lvalue, const geometry_type_2& rvalue, direction_1d dir) {
- return geometry_concept<geometry_type_1>::type::abuts(lvalue, rvalue, dir, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type>
-geometry_type get_half(const geometry_type& geometry_object, direction_1d dir) {
- return geometry_concept<geometry_type>::type::get_half(geometry_object, dir);
-}
-
-//mutable binary functions
-
-template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& assign(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::assign(lvalue, rvalue);
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& convolve(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::convolve(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& deconvolve(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::deconvolve(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& reflected_convolve(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::reflected_convolve(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& reflected_deconvolve(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::reflected_deconvolve(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-typename coordinate_distance<geometry_type_1>::type euclidean_distance(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::euclidean_distance(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool encompass(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::encompass(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool intersect(geometry_type_1& lvalue, geometry_type_2& rvalue, bool consider_touch = true) {
- return geometry_concept<geometry_type_1>::type::intersect(lvalue, rvalue, consider_touch, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-geometry_type_1& generalized_intersect(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::generalized_intersect(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-bool join_with(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return geometry_concept<geometry_type_1>::type::join_with(lvalue, rvalue);
-}
-
-template <typename geometry_type>
-geometry_type& flip(geometry_type& geometry_object, typename center_type<geometry_type>::type pivot) {
- return geometry_concept<geometry_type>::type::flip(geometry_object, pivot);
-}
-
-template <typename geometry_type>
-geometry_type& scale(geometry_type& geometry_object, double factor) {
- return geometry_concept<geometry_type>::type::scale(geometry_object, factor);
-}
-
-template <typename geometry_type>
-geometry_type& move(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type displacement) {
- return geometry_concept<geometry_type>::type::move(geometry_object, displacement);
-}
-
-//accepts: point point_3d rectangle prism
-template <typename geometry_type>
-geometry_type& move(geometry_type& geometry_object, orientation_2d orient,
- typename coordinate_type<geometry_type>::type displacement) {
- return geometry_concept<geometry_type>::type::move(geometry_object, orient, displacement);
-}
-
-//accepts: point_3d prism
-template <typename geometry_type>
-geometry_type& move(geometry_type& geometry_object, orientation_3d orient,
- typename coordinate_type<geometry_type>::type displacement) {
- int untested = 0;
- return geometry_concept<geometry_type>::type::move(geometry_object, orient, displacement);
-}
-
-template <typename geometry_type>
-geometry_type& bloat(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type bloating) {
- return geometry_concept<geometry_type>::type::bloat(geometry_object, bloating);
-}
-
-template <typename geometry_type>
-geometry_type& shrink(geometry_type& geometry_object, typename coordinate_type<geometry_type>::type shrinking) {
- return geometry_concept<geometry_type>::type::shrink(geometry_object, shrinking);
-}
-
-//polygonal functions
-
-template <typename geometry_type>
-rectangle_data<typename coordinate_type<geometry_type>::type>
-bounding_box(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::bounding_box(geometry_object);
-}
-
-template <typename geometry_type>
-direction_1d winding(const geometry_type& geometry_object) {
- return geometry_concept<geometry_type>::type::winding(geometry_object);
-}
-
-template <typename geometry_type, typename rectangle_type>
-void set_rectangle(geometry_type& geometry_object, const rectangle_type& rectangle) {
- geometry_concept<geometry_type>::type::set_rectangle(geometry_object, rectangle);
-}
-
-template <typename geometry_type, typename iterator_type>
-void set_vertices(geometry_type& geometry_object, iterator_type input_begin, iterator_type input_end) {
- geometry_concept<geometry_type>::type::set(geometry_object, input_begin, input_end);
-}
-
-template <typename geometry_type, typename iterator_type>
-void set_compact(geometry_type& geometry_object, iterator_type input_begin, iterator_type input_end) {
- geometry_concept<geometry_type>::type::set_compact(geometry_object, input_begin, input_end);
-}
-
-//boolean operator functions
-
-template <typename geometry_type_1, typename geometry_type_2>
-polygon_set_view<typename polygon_set_traits<geometry_type_1>::operator_arg_type,
- typename polygon_set_traits<geometry_type_2>::operator_arg_type,
- boolean_op::BinaryOr,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>
-operator|(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return polygon_set_view<geometry_type_1, geometry_type_2,
- boolean_op::BinaryOr,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>(lvalue, rvalue,
- polygon_set_traits<geometry_type_1>::orient(lvalue),
- boolean_op::BinaryOr());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-polygon_set_view<typename polygon_set_traits<geometry_type_1>::operator_arg_type,
- typename polygon_set_traits<geometry_type_2>::operator_arg_type,
- boolean_op::BinaryOr,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>
-operator+(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return polygon_set_view<geometry_type_1, geometry_type_2,
- boolean_op::BinaryOr,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>(lvalue, rvalue,
- polygon_set_traits<geometry_type_1>::orient(lvalue),
- boolean_op::BinaryOr());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-polygon_set_view<typename polygon_set_traits<geometry_type_1>::operator_arg_type,
- typename polygon_set_traits<geometry_type_2>::operator_arg_type,
- boolean_op::BinaryAnd,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>
-operator*(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return polygon_set_view<geometry_type_1, geometry_type_2,
- boolean_op::BinaryAnd,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>(lvalue, rvalue,
- polygon_set_traits<geometry_type_1>::orient(lvalue),
- boolean_op::BinaryAnd());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-polygon_set_view<typename polygon_set_traits<geometry_type_1>::operator_arg_type,
- typename polygon_set_traits<geometry_type_2>::operator_arg_type,
- boolean_op::BinaryAnd,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>
-operator&(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return polygon_set_view<geometry_type_1, geometry_type_2,
- boolean_op::BinaryAnd,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>(lvalue, rvalue,
- polygon_set_traits<geometry_type_1>::orient(lvalue),
- boolean_op::BinaryAnd());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-polygon_set_view<typename polygon_set_traits<geometry_type_1>::operator_arg_type,
- typename polygon_set_traits<geometry_type_2>::operator_arg_type,
- boolean_op::BinaryXor,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>
-operator^(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return polygon_set_view<geometry_type_1, geometry_type_2,
- boolean_op::BinaryXor,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>(lvalue, rvalue,
- polygon_set_traits<geometry_type_1>::orient(lvalue),
- boolean_op::BinaryXor());
-}
-
-template <typename geometry_type_1, typename geometry_type_2>
-polygon_set_view<typename polygon_set_traits<geometry_type_1>::operator_arg_type,
- typename polygon_set_traits<geometry_type_2>::operator_arg_type,
- boolean_op::BinaryNot,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>
-operator-(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
- return polygon_set_view<geometry_type_1, geometry_type_2,
- boolean_op::BinaryNot,
- typename polygon_set_traits<geometry_type_1>::operator_storage_tag,
- typename polygon_set_traits<geometry_type_2>::operator_storage_tag>(lvalue, rvalue,
- polygon_set_traits<geometry_type_1>::orient(lvalue),
- boolean_op::BinaryNot());
-}
-
- template <typename T>
- struct polygon_set_traits<std::vector<rectangle_data<T> > > {
- typedef T coordinate_type;
- typedef typename polygon_set_const_wrapper<std::vector<rectangle_data<T> > >::iterator_type iterator_type;
- typedef typename std::vector<rectangle_data<T> > operator_arg_type;
- typedef operator_requires_copy operator_storage_tag;
-
- static inline iterator_type begin(const std::vector<rectangle_data<T> >& polygon_set) {
- return wrap_const(polygon_set).begin();
- }
-
- static inline iterator_type end(const std::vector<rectangle_data<T> >& polygon_set) {
- return wrap_const(polygon_set).end();
- }
-
- template <typename input_iterator_type>
- static inline void set(std::vector<rectangle_data<T> >& polygon_set,
- input_iterator_type input_begin, input_iterator_type input_end,
- orientation_2d orient) {
- wrap(polygon_set).set(input_begin, input_end, orient);
- }
-
- static inline orientation_2d orient(const std::vector<rectangle_data<T> >& polygon_set) { return HORIZONTAL; }
-
- static inline bool dirty(const std::vector<rectangle_data<T> >& polygon_set) { return true; }
-
- static inline bool sorted(const std::vector<rectangle_data<T> >& polygon_set) { return false; }
-
- };
-
- template <typename T>
- struct polygon_set_traits<std::vector<polygon_90_data<T> > > {
- typedef T coordinate_type;
- typedef typename polygon_set_const_wrapper<std::vector<polygon_90_data<T> > >::iterator_type iterator_type;
- typedef typename std::vector<polygon_90_data<T> > operator_arg_type;
- typedef operator_requires_copy operator_storage_tag;
-
- static inline iterator_type begin(const std::vector<polygon_90_data<T> >& polygon_set) {
- return wrap_const(polygon_set).begin();
- }
-
- static inline iterator_type end(const std::vector<polygon_90_data<T> >& polygon_set) {
- return wrap_const(polygon_set).end();
- }
-
- template <typename input_iterator_type>
- static inline void set(std::vector<polygon_90_data<T> >& polygon_set,
- input_iterator_type input_begin, input_iterator_type input_end,
- orientation_2d orient) {
- wrap(polygon_set).set(input_begin, input_end, orient);
- }
-
- static inline orientation_2d orient(const std::vector<polygon_90_data<T> >& polygon_set) { return HORIZONTAL; }
-
- static inline bool dirty(const std::vector<polygon_90_data<T> >& polygon_set) { return true; }
-
- static inline bool sorted(const std::vector<polygon_90_data<T> >& polygon_set) { return false; }
-
- };
-
-// template <typename T>
-// struct polygon_set_traits<std::vector<polygon_90_with_holes_data<T> > > {
-// typedef T coordinate_type;
-// typedef typename polygon_set_const_wrapper<std::vector<polygon_90_with_holes_data<T> > >::iterator_type iterator_type;
-// typedef typename std::vector<polygon_90_with_holes_data<T> > operator_arg_type;
-// typedef operator_requires_copy operator_storage_tag;
-
-// static inline iterator_type begin(const std::vector<polygon_90_with_holes_data<T> >& polygon_set) {
-// return wrap_const(polygon_set).begin();
-// }
-
-// static inline iterator_type end(const std::vector<polygon_90_with_holes_data<T> >& polygon_set) {
-// return wrap_const(polygon_set).end();
-// }
-
-// template <typename input_iterator_type>
-// static inline void set(std::vector<polygon_90_with_holes_data<T> >& polygon_set,
-// input_iterator_type input_begin, input_iterator_type input_end,
-// orientation_2d orient) {
-// wrap(polygon_set).set(input_begin, input_end, orient);
-// }
-
-// static inline orientation_2d orient(const std::vector<polygon_90_with_holes_data<T> >& polygon_set) { return HORIZONTAL; }
-
-// static inline bool dirty(const std::vector<polygon_90_with_holes_data<T> >& polygon_set) { return true; }
-
-// static inline bool sorted(const std::vector<polygon_90_with_holes_data<T> >& polygon_set) { return false; }
-
-// };
-
- template <typename T>
- struct polygon_set_traits<std::vector<polygon_90_with_holes_data<T> > > : public
- polygon_set_traits<polygon_set_wrapper<std::vector<polygon_90_with_holes_data<T> > > > {};
- // template <typename T>
- // struct polygon_set_traits<const std::vector<polygon_90_with_holes_data<T> > > : public
-// polygon_set_traits<polygon_set_const_wrapper<const std::vector<polygon_90_with_holes_data<T> > > > {};
+#include "scan_arbitrary.hpp"
+#include "polygon_set_traits.hpp"
+#include "polygon_set_view.hpp"
+#include "polygon_set_concept.hpp"
-}
+#if __ICC
+#pragma warning (default:1125)
+#endif
#endif
Modified: sandbox/gtl/gtl/interval_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/interval_concept.hpp (original)
+++ sandbox/gtl/gtl/interval_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,145 +7,144 @@
*/
#ifndef GTL_INTERVAL_CONCEPT_HPP
#define GTL_INTERVAL_CONCEPT_HPP
-namespace gtl {
-struct interval_concept {
- interval_concept() {}
-
- template <typename T>
- struct coordinate_type {
- typedef typename interval_traits<T>::coordinate_type type;
- };
-
- template <typename T>
- struct component_type {
- typedef typename interval_traits<T>::coordinate_type type;
- };
+#include "isotropy.hpp"
+#include "interval_data.hpp"
+#include "interval_traits.hpp"
+namespace gtl {
+ struct interval_concept {};
+
template <typename T>
- struct center_type {
- typedef typename interval_traits<T>::coordinate_type type;
- };
+ struct is_interval_concept {};
+ template <>
+ struct is_interval_concept<interval_concept> { typedef void type; };
template <typename T>
- struct coordinate_difference {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_difference type;
- };
+ struct is_mutable_interval_concept {};
+ template <>
+ struct is_mutable_interval_concept<interval_concept> { typedef void type; };
template <typename T>
- struct coordinate_distance {
- //1D distance is difference
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_difference type;
- };
-
-
- template <direction_1d_enum dir, typename T>
- static inline typename interval_traits<T>::coordinate_type
- get(const T& interval) {
- return interval_traits<T>::get(interval, dir);
- }
-
- template <typename T>
static inline typename interval_traits<T>::coordinate_type
get(const T& interval, direction_1d dir) {
return interval_traits<T>::get(interval, dir);
}
- template <direction_1d_enum dir, typename T, typename coordinate_type>
- static inline void set(T& interval, coordinate_type value) {
- set(interval, dir, value);
- }
-
template <typename T, typename coordinate_type>
- static inline void set(T& interval, direction_1d dir, coordinate_type value) {
- interval_traits<T>::set(interval, dir, value);
- if(get<HIGH>(interval) < get<LOW>(interval))
- interval_traits<T>::set(interval, dir.backward(), value);
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<T>::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);
}
- template <typename T, typename coordinate_type1, typename coordinate_type2>
- static inline T construct(coordinate_type1 low_value, coordinate_type2 high_value) {
+ template <typename T>
+ typename requires_1<
+ typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type,
+ T>::type
+ construct(typename interval_traits<T>::coordinate_type low_value, typename interval_traits<T>::coordinate_type high_value) {
if(low_value > high_value) std::swap(low_value, high_value);
- return interval_traits<T>::construct(low_value, high_value);
+ return interval_mutable_traits<T>::construct(low_value, high_value);
}
template <typename T, typename T2>
- static T copy_construct(const T2& interval) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ T>::type
+ copy_construct(const T2& interval) {
return construct<T>
(get(interval, LOW ),
get(interval, HIGH));
}
- template <typename interval_type_1, typename interval_type_2>
- static interval_type_1& assign(interval_type_1& lvalue, const interval_type_2& rvalue) {
- set(lvalue, LOW, get(rvalue, LOW));
- set(lvalue, HIGH, get(rvalue, HIGH));
+ template <typename T1, typename T2>
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<T1>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ lvalue = copy_construct<T1>(rvalue);
return lvalue;
}
template <typename T, typename T2>
- static bool equivalence(const T& interval1, const T2& interval2) {
+ typename requires_2< typename is_interval_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ bool>::type
+ equivalence(const T& interval1, const T2& interval2) {
return get(interval1, LOW) ==
get(interval2, LOW) &&
get(interval1, HIGH) ==
get(interval2, HIGH);
}
-
+
template <typename interval_type>
- static bool contains(const interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type value,
- bool consider_touch, coordinate_concept tag) {
+ typename requires_1< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ bool>::type
+ contains(const interval_type& interval,
+ typename interval_traits<interval_type>::coordinate_type value,
+ bool consider_touch = true) {
if(consider_touch) {
- return value <= get<HIGH>(interval) && value >= get<LOW>(interval);
+ return value <= high(interval) && value >= low(interval);
} else {
- return value < get<HIGH>(interval) && value > get<LOW>(interval);
+ return value < high(interval) && value > low(interval);
}
}
-
+
template <typename interval_type, typename interval_type_2>
- static bool contains(const interval_type& interval,
- const interval_type_2& value, bool consider_touch, interval_concept tag) {
- return contains(interval, get(value, LOW), consider_touch, coordinate_concept()) &&
- contains(interval, get(value, HIGH), consider_touch, coordinate_concept());
+ typename requires_2< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ bool>::type
+ contains(const interval_type& interval,
+ const interval_type_2& value, bool consider_touch = true) {
+ return contains(interval, get(value, LOW), consider_touch) &&
+ contains(interval, get(value, HIGH), consider_touch);
}
-
- /// get the low coordinate
+
+ /// get the low coordinate
template <typename interval_type>
- static inline typename interval_traits<interval_type>::coordinate_type
+ typename requires_1< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename interval_traits<interval_type>::coordinate_type >::type
low(const interval_type& interval) { return get(interval, LOW); }
/// get the high coordinate
template <typename interval_type>
- static inline typename interval_traits<interval_type>::coordinate_type
+ typename requires_1< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename interval_traits<interval_type>::coordinate_type >::type
high(const interval_type& interval) { return get(interval, HIGH); }
/// get the center coordinate
template <typename interval_type>
- static inline typename interval_traits<interval_type>::coordinate_type
+ typename requires_1< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename interval_traits<interval_type>::coordinate_type >::type
center(const interval_type& interval) { return (high(interval) + low(interval))/2; }
/// set the low coordinate to v
template <typename interval_type>
- static interval_type& low(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type v) {
- set(interval, LOW, v); return interval; }
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type, void>::type
+ low(interval_type& interval,
+ typename interval_traits<interval_type>::coordinate_type v) {
+ set(interval, LOW, v); }
/// set the high coordinate to v
template <typename interval_type>
- static interval_type& high(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type v) {
- set(interval, HIGH, v); return interval; }
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type, void>::type
+ high(interval_type& interval,
+ typename interval_traits<interval_type>::coordinate_type v) {
+ set(interval, HIGH, v); }
/// get the magnitude of the interval
template <typename interval_type>
- static inline typename coordinate_difference<interval_type>::type
+ typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference
delta(const interval_type& interval) {
- typedef typename coordinate_difference<interval_type>::type diffT;
+ typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference diffT;
return (diffT)high(interval) - (diffT)low(interval); }
-
+
/// flip this about coordinate
template <typename interval_type>
- static interval_type& flip(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type axis = 0) {
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_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;
newLow = axis - high(interval);
newHigh = axis - low(interval);
@@ -156,20 +155,44 @@
/// scale interval by factor
template <typename interval_type>
- static interval_type& scale(interval_type& interval,
- double factor) {
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_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;
- Unit newHigh = (Unit)(high(interval) * factor);
- low(interval, (Unit)(low(interval)*factor));
- high(interval, (Unit)(newHigh));
+ Unit newHigh = high(interval) * (Unit)factor;
+ low(interval, low(interval) * (Unit)factor);
+ high(interval, (newHigh));
+ return interval;
+ }
+
+ template <typename interval_type>
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_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;
+ 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));
+ high(interval, (newHigh));
+ return interval;
+ }
+
+ template <typename interval_type>
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type, interval_type>::type &
+ scale(interval_type& interval, double factor) {
+ typedef typename interval_traits<interval_type>::coordinate_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;
}
/// move interval by delta
template <typename interval_type>
- static interval_type& move(interval_type& interval,
- typename coordinate_difference<interval_type>::type displacement) {
- typedef typename coordinate_difference<interval_type>::type Unit;
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type, interval_type>::type &
+ move(interval_type& interval,
+ typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference displacement) {
+ typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
Unit len = delta(interval);
low(interval, (Unit)low(interval) + displacement);
high(interval, (Unit)low(interval) + len);
@@ -178,8 +201,9 @@
/// convolve this with b
template <typename interval_type>
- static interval_type& convolve(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type b, coordinate_concept tag) {
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_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;
Unit newLow = low(interval) + b;
Unit newHigh = high(interval) + b;
@@ -190,8 +214,9 @@
/// deconvolve this with b
template <typename interval_type>
- static interval_type& deconvolve(interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type b, coordinate_concept tag) {
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_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;
Unit newLow = low(interval) - b;
Unit newHigh = high(interval) - b;
@@ -202,8 +227,10 @@
/// convolve this with b
template <typename interval_type, typename interval_type_2>
- static interval_type& convolve(interval_type& interval,
- const interval_type_2& b, interval_concept tag) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type, interval_type>::type &
+ convolve(interval_type& interval,
+ const interval_type_2& b) {
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit newLow = low(interval) + low(b);
Unit newHigh = high(interval) + high(b);
@@ -214,8 +241,11 @@
/// deconvolve this with b
template <typename interval_type, typename interval_type_2>
- static interval_type& deconvolve(interval_type& interval,
- const interval_type_2& b, interval_concept tag) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ interval_type>::type &
+ deconvolve(interval_type& interval,
+ const interval_type_2& b) {
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit newLow = low(interval) - low(b);
Unit newHigh = high(interval) - high(b);
@@ -226,8 +256,11 @@
/// reflected convolve this with b
template <typename interval_type, typename interval_type_2>
- static interval_type& reflected_convolve(interval_type& interval,
- const interval_type_2& b, interval_concept tag) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ interval_type>::type &
+ reflected_convolve(interval_type& interval,
+ const interval_type_2& b) {
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit newLow = low(interval) - high(b);
Unit newHigh = high(interval) - low(b);
@@ -238,8 +271,10 @@
/// reflected deconvolve this with b
template <typename interval_type, typename interval_type_2>
- static interval_type& reflected_deconvolve(interval_type& interval,
- const interval_type_2& b, interval_concept tag) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type, interval_type>::type &
+ reflected_deconvolve(interval_type& interval,
+ const interval_type_2& b) {
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit newLow = low(interval) + high(b);
Unit newHigh = high(interval) + low(b);
@@ -250,29 +285,35 @@
/// distance from a coordinate to an interval
template <typename interval_type>
- static inline typename coordinate_distance<interval_type>::type
+ typename requires_1< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference>::type
euclidean_distance(const interval_type& interval,
- typename interval_traits<interval_type>::coordinate_type position, coordinate_concept tag) {
- typedef typename coordinate_distance<interval_type>::type Unit;
+ typename interval_traits<interval_type>::coordinate_type position) {
+ typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_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) ];
}
-
-
+
+
/// distance between two intervals
template <typename interval_type, typename interval_type_2>
- static inline typename coordinate_distance<interval_type>::type
+ typename requires_2< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference>::type
euclidean_distance(const interval_type& interval,
- const interval_type_2& b, interval_concept tag) {
- typedef typename coordinate_distance<interval_type>::type Unit;
+ const interval_type_2& b) {
+ typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_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) ];
}
-
+
/// check if Interval b intersects `this` Interval
template <typename interval_type, typename interval_type_2>
- static bool intersects(const interval_type& interval, const interval_type_2& b,
- bool consider_touch, interval_concept tag) {
+ typename requires_2< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ bool>::type
+ intersects(const interval_type& interval, const interval_type_2& b,
+ bool consider_touch = true) {
return consider_touch ?
(low(interval) <= high(b)) & (high(interval) >= low(b)) :
(low(interval) < high(b)) & (high(interval) > low(b));
@@ -280,30 +321,42 @@
/// check if Interval b partially overlaps `this` Interval
template <typename interval_type, typename interval_type_2>
- static bool boundaries_intersect(const interval_type& interval, const interval_type_2& b,
- bool consider_touch, interval_concept tag) {
- return (contains(interval, low(b), consider_touch, coordinate_concept()) ||
- contains(interval, high(b), consider_touch, coordinate_concept())) &&
- (contains(b, low(interval), consider_touch, coordinate_concept()) ||
- contains(b, high(interval), consider_touch, coordinate_concept()));
+ typename requires_2< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ bool>::type
+ boundaries_intersect(const interval_type& interval, const interval_type_2& b,
+ bool consider_touch = true) {
+ return (contains(interval, low(b), consider_touch) ||
+ contains(interval, high(b), consider_touch)) &&
+ (contains(b, low(interval), consider_touch) ||
+ contains(b, high(interval), consider_touch));
}
/// check if they are end to end
template <typename interval_type, typename interval_type_2>
- static bool abuts(const interval_type& interval, const interval_type_2& b, direction_1d dir, interval_concept tag) {
+ typename requires_2< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ bool>::type
+ abuts(const interval_type& interval, const interval_type_2& b, direction_1d dir) {
return dir.to_int() ? low(b) == high(interval) : low(interval) == high(b);
}
/// check if they are end to end
template <typename interval_type, typename interval_type_2>
- static bool abuts(const interval_type& interval, const interval_type_2& b, interval_concept tag) {
- return abuts(interval, b, HIGH, interval_concept()) || abuts(interval, b, LOW, interval_concept());
+ typename requires_2< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ bool>::type
+ abuts(const interval_type& interval, const interval_type_2& b) {
+ return abuts(interval, b, HIGH) || abuts(interval, b, LOW);
}
/// set 'this' interval to the intersection of 'this' and b
template <typename interval_type, typename interval_type_2>
- static bool intersect(interval_type& interval, const interval_type_2& b, bool consider_touch, interval_concept tag) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::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;
Unit lowVal = std::max(low(interval), low(b));
Unit highVal = std::min(high(interval), high(b));
@@ -319,7 +372,10 @@
/// set 'this' interval to the generalized intersection of 'this' and b
template <typename interval_type, typename interval_type_2>
- static interval_type& generalized_intersect(interval_type& interval, const interval_type_2& b, interval_concept tag) {
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ interval_type>::type &
+ generalized_intersect(interval_type& interval, const interval_type_2& b) {
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit coords[4] = {low(interval), high(interval), low(b), high(b)};
//consider implementing faster sorting of small fixed length range
@@ -331,7 +387,9 @@
/// bloat the Interval
template <typename interval_type>
- static interval_type& bloat(interval_type& interval, typename interval_traits<interval_type>::coordinate_type bloating) {
+ typename requires_1< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ interval_type>::type &
+ bloat(interval_type& interval, typename interval_traits<interval_type>::coordinate_type bloating) {
low(interval, low(interval)-bloating);
high(interval, high(interval)+bloating);
return interval;
@@ -339,7 +397,9 @@
/// bloat the specified side of `this` Interval
template <typename interval_type>
- static interval_type& bloat(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type bloating) {
+ typename requires_1< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ interval_type>::type &
+ bloat(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type bloating) {
set(interval, dir, get(interval, dir) + dir.get_sign() * bloating);
return interval;
}
@@ -347,28 +407,47 @@
/// shrink the Interval
template <typename interval_type>
- static interval_type& shrink(interval_type& interval, typename interval_traits<interval_type>::coordinate_type shrinking) {
+ typename requires_1< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ interval_type>::type &
+ shrink(interval_type& interval, typename interval_traits<interval_type>::coordinate_type shrinking) {
return bloat(interval, -shrinking);
}
/// shrink the specified side of `this` Interval
template <typename interval_type>
- static interval_type& shrink(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type shrinking) {
+ typename requires_1< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ interval_type>::type &
+ shrink(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type shrinking) {
return bloat(interval, dir, -shrinking);
}
/// Enlarge `this` Interval to encompass the specified Interval
template <typename interval_type, typename interval_type_2>
- static bool encompass(interval_type& interval, const interval_type_2& b, interval_concept tag) {
- bool retval = !contains(interval, b, true, interval_concept());
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::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;
}
+ /// Enlarge `this` Interval to encompass the specified Interval
+ template <typename interval_type>
+ typename requires_1< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ bool>::type
+ encompass(interval_type& interval, typename interval_traits<interval_type>::coordinate_type b) {
+ bool retval = !contains(interval, b, true);
+ low(interval, std::min(low(interval), b));
+ high(interval, std::max(high(interval), b));
+ return retval;
+ }
+
/// gets the half of the interval as an interval
template <typename interval_type>
- static interval_type get_half(const interval_type& interval, direction_1d d1d) {
+ typename requires_1<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type, interval_type>::type
+ get_half(const interval_type& interval, direction_1d d1d) {
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit c = (get(interval, LOW) + get(interval, HIGH)) / 2;
return construct<interval_type>((d1d == LOW) ? get(interval, LOW) : c,
@@ -378,15 +457,28 @@
/// returns true if the 2 intervals exactly touch at one value, like in l1 <= h1 == l2 <= h2
/// sets the argument to the joined interval
template <typename interval_type, typename interval_type_2>
- static bool join_with(interval_type& interval, const interval_type_2& b) {
- if(abuts(interval, b, interval_concept())) {
- encompass(interval, b, interval_concept());
+ typename requires_2< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type,
+ bool>::type
+ join_with(interval_type& interval, const interval_type_2& b) {
+ if(abuts(interval, b)) {
+ encompass(interval, b);
return true;
}
return false;
}
-
-};
+
+ template <class T>
+ template <class T2>
+ interval_data<T>& interval_data<T>::operator=(const T2& rvalue) {
+ assign(*this, rvalue);
+ return *this;
+ }
+
+ template <typename T>
+ struct geometry_concept<interval_data<T> > {
+ typedef interval_concept type;
+ };
}
#endif
Modified: sandbox/gtl/gtl/interval_data.hpp
==============================================================================
--- sandbox/gtl/gtl/interval_data.hpp (original)
+++ sandbox/gtl/gtl/interval_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,34 +7,42 @@
*/
#ifndef GTL_INTERVAL_DATA_HPP
#define GTL_INTERVAL_DATA_HPP
+#include "isotropy.hpp"
namespace gtl {
-struct interval_concept;
-template <typename T>
-class interval_data {
-public:
- typedef interval_concept geometry_type;
- typedef T coordinate_type;
- inline interval_data(){}
- inline interval_data(coordinate_type low, coordinate_type high) {
- coords_[LOW] = low; coords_[HIGH] = high;
- }
- inline interval_data(const interval_data& that) {
- (*this) = that;
- }
- inline interval_data& operator=(const interval_data& that) {
- coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
- }
- template <typename T2>
- inline interval_data& operator=(const T2& rvalue);
- inline coordinate_type get(direction_1d dir) const {
- return coords_[dir.to_int()];
- }
- inline coordinate_type low() const { return coords_[0]; }
- inline coordinate_type high() const { return coords_[1]; }
- inline bool operator==(const interval_data& that) const {
- return low() == that.low() && high() == that.high(); }
- inline bool operator!=(const interval_data& that) const {
- return low() != that.low() || high() != that.high(); }
+ template <typename T>
+ class interval_data {
+ public:
+ typedef T coordinate_type;
+ inline interval_data(){}
+ inline interval_data(coordinate_type low, coordinate_type high) {
+ coords_[LOW] = low; coords_[HIGH] = high;
+ }
+ inline interval_data(const interval_data& that) {
+ (*this) = that;
+ }
+ inline interval_data& operator=(const interval_data& that) {
+ coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
+ }
+ template <typename T2>
+ inline interval_data& operator=(const T2& rvalue);
+ inline coordinate_type get(direction_1d dir) const {
+ return coords_[dir.to_int()];
+ }
+ inline coordinate_type low() const { return coords_[0]; }
+ inline coordinate_type high() const { return coords_[1]; }
+ inline bool operator==(const interval_data& that) const {
+ return low() == that.low() && high() == that.high(); }
+ inline bool operator!=(const interval_data& that) const {
+ return low() != that.low() || high() != that.high(); }
+ inline bool operator<(const interval_data& that) const {
+ if(coords_[0] < that.coords_[0]) return true;
+ if(coords_[0] > that.coords_[0]) return false;
+ if(coords_[1] < that.coords_[1]) return true;
+ return false;
+ }
+ inline bool operator<=(const interval_data& that) const { return !(that < *this); }
+ inline bool operator>(const interval_data& that) const { return that < *this; }
+ inline bool operator>=(const interval_data& that) const { return !((*this) < that); }
inline void set(direction_1d dir, coordinate_type value) {
coords_[dir.to_int()] = value;
}
Modified: sandbox/gtl/gtl/interval_traits.hpp
==============================================================================
--- sandbox/gtl/gtl/interval_traits.hpp (original)
+++ sandbox/gtl/gtl/interval_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,22 +8,25 @@
#ifndef GTL_INTERVAL_TRAITS_HPP
#define GTL_INTERVAL_TRAITS_HPP
namespace gtl {
-template <typename T>
-struct interval_traits {
- typedef typename T::coordinate_type coordinate_type;
+ template <typename T>
+ struct interval_traits {
+ typedef typename T::coordinate_type coordinate_type;
- static inline coordinate_type get(const T& interval, direction_1d dir) {
- return interval.get(dir);
- }
+ static inline coordinate_type get(const T& interval, direction_1d dir) {
+ return interval.get(dir);
+ }
+ };
- static inline void set(T& interval, direction_1d dir, coordinate_type value) {
- interval.set(dir, value);
- }
-
- static inline T construct(coordinate_type low_value, coordinate_type high_value) {
- return T(low_value, high_value);
- }
-};
+ template <typename T>
+ struct interval_mutable_traits {
+ static inline void set(T& interval, direction_1d dir, typename interval_traits<T>::coordinate_type value) {
+ interval.set(dir, value);
+ }
+ static inline T construct(typename interval_traits<T>::coordinate_type low_value,
+ typename interval_traits<T>::coordinate_type high_value) {
+ return T(low_value, high_value);
+ }
+ };
}
#endif
Modified: sandbox/gtl/gtl/isotropy.hpp
==============================================================================
--- sandbox/gtl/gtl/isotropy.hpp (original)
+++ sandbox/gtl/gtl/isotropy.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -10,55 +10,229 @@
#define GTL_ISOTROPY_HPP
namespace gtl {
-template <typename T>
-struct coordinate_traits {
- typedef T coordinate_type;
- typedef T area_type;
- typedef T coordinate_difference;
- typedef T coordinate_distance;
-};
+ enum GEOMETRY_CONCEPT_ID {
+ COORDINATE_CONCEPT,
+ INTERVAL_CONCEPT,
+ POINT_CONCEPT,
+ POINT_3D_CONCEPT,
+ RECTANGLE_CONCEPT,
+ POLYGON_90_CONCEPT,
+ POLYGON_90_WITH_HOLES_CONCEPT,
+ POLYGON_45_CONCEPT,
+ POLYGON_45_WITH_HOLES_CONCEPT,
+ POLYGON_CONCEPT,
+ POLYGON_WITH_HOLES_CONCEPT,
+ POLYGON_90_SET_CONCEPT,
+ POLYGON_45_SET_CONCEPT,
+ POLYGON_SET_CONCEPT
+ };
-template <>
-struct coordinate_traits<int> {
- typedef int coordinate_type;
- typedef long long area_type;
- typedef long long coordinate_difference;
- typedef double coordinate_distance;
-};
+ struct undefined_concept {};
-template <>
-struct coordinate_traits<long long> {
- typedef long long coordinate_type;
- typedef long long area_type;
- typedef long long coordinate_difference;
- typedef double coordinate_distance;
-};
+ template <typename T>
+ struct geometry_concept { typedef undefined_concept type; };
-struct coordinate_concept {
template <typename T>
- struct coordinate_type {
- typedef typename coordinate_traits<T>::coordinate_type type;
- };
+ struct coordinate_traits {};
+
template <typename T>
- struct area_type {
- typedef typename coordinate_traits<T>::area_type type;
+ struct high_precision_type {
+ typedef long double type;
};
- template <typename T>
- struct coordinate_difference {
- typedef typename coordinate_traits<T>::coordinate_difference type;
+
+ template <>
+ struct coordinate_traits<int> {
+ typedef int coordinate_type;
+ typedef long double area_type;
+ typedef long long manhattan_area_type;
+ typedef unsigned long long unsigned_area_type;
+ typedef long long coordinate_difference;
+ typedef long double coordinate_distance;
};
+
+ template <>
+ struct coordinate_traits<long long> {
+ typedef long long coordinate_type;
+ typedef long double area_type;
+ typedef long long manhattan_area_type;
+ typedef unsigned long long unsigned_area_type;
+ typedef long long coordinate_difference;
+ typedef long double coordinate_distance;
+ };
+
+ template <>
+ struct coordinate_traits<float> {
+ typedef float coordinate_type;
+ typedef float area_type;
+ typedef float manhattan_area_type;
+ typedef float unsigned_area_type;
+ typedef float coordinate_difference;
+ typedef float coordinate_distance;
+ };
+
+ template <>
+ struct coordinate_traits<double> {
+ typedef double coordinate_type;
+ typedef double area_type;
+ typedef double manhattan_area_type;
+ typedef double unsigned_area_type;
+ typedef double coordinate_difference;
+ typedef double coordinate_distance;
+ };
+
template <typename T>
- struct coordinate_distance {
- typedef typename coordinate_traits<T>::coordinate_distance type;
+ struct scaling_policy {
+ template <typename T2>
+ static inline T round(T2 t2) {
+ return (T)floor(t2+0.5);
+ }
+
+ static inline T round(T t2) {
+ return t2;
+ }
};
+ struct coordinate_concept {};
+
+ template <>
+ struct geometry_concept<int> { typedef coordinate_concept type; };
+ template <>
+ struct geometry_concept<long long> { typedef coordinate_concept type; };
+ template <>
+ struct geometry_concept<float> { typedef coordinate_concept type; };
+ template <>
+ struct geometry_concept<double> { typedef coordinate_concept type; };
+
+ template <typename T1, typename T2, typename T3>
+ struct requires { };
+
+ template <typename T1, typename T3>
+ struct requires<T1, T1, T3> {
+ typedef T3 type;
+ };
+
+ struct gtl_no {};
+ struct gtl_yes { typedef void type; };
+
+ template <typename T, typename T2>
+ struct gtl_and { typedef gtl_no type; };
+ template <typename T>
+ struct gtl_and<T, T> { typedef T type; };
+
+ template <typename T, typename T2>
+ struct gtl_or { typedef gtl_yes type; };
+ template <typename T>
+ struct gtl_or<T, T> { typedef T type; };
+
+ template <typename T, typename T2, typename T3>
+ struct gtl_and_3 { typedef gtl_no type; };
+ template <typename T>
+ struct gtl_and_3<T, T, T> { typedef T type; };
+
+ template <typename T, typename T2, typename T3>
+ struct gtl_or_3 { typedef gtl_yes type; };
+ template <typename T>
+ struct gtl_or_3<T, T, T> { typedef T type; };
+
+ template <typename T, typename T2, typename T3, typename T4>
+ struct gtl_and_4 { typedef gtl_no type; };
+ template <typename T>
+ struct gtl_and_4<T, T, T, T> { typedef T type; };
+
+ template <typename T, typename T2, typename T3, typename T4>
+ struct gtl_or_4 { typedef gtl_yes type; };
+ template <typename T>
+ struct gtl_or_4<T, T, T, T> { typedef T type; };
+
+ template <typename T>
+ struct gtl_not { typedef gtl_no type; };
+ template <>
+ struct gtl_not<gtl_no> { typedef gtl_yes type; };
+
+ template <typename T>
+ struct gtl_if { typedef T type; };
+ template <>
+ struct gtl_if<gtl_no> {};
+
+ template <typename T, typename T2>
+ struct gtl_same_type { typedef gtl_no type; };
+ template <typename T>
+ struct gtl_same_type<T, T> { typedef gtl_yes type; };
+
+ template <typename T1, typename T2>
+ struct requires_type { typedef T2 type; };
+
+ template <typename T, typename T2>
+ struct is_same_type_SFINAE {};
+ template <typename T>
+ struct is_same_type_SFINAE<T, T> { typedef void type; };
+
+ template <typename T, typename T2>
+ struct is_different_type_SFINAE { typedef void type; };
+ template <typename T>
+ struct is_different_type_SFINAE<T, T> {};
+
+ template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+ struct requires_5 { typedef T6 type; };
+
+ template <typename T1, typename T2, typename T3, typename T4, typename T5>
+ struct requires_4 { typedef T5 type; };
+
+ template <typename T1, typename T2, typename T3, typename T4>
+ struct requires_3 { typedef T4 type; };
+
+ template <typename T1, typename T2, typename T3>
+ struct requires_2 { typedef T3 type; };
+
+ template <typename T1, typename T2>
+ struct requires_1 { typedef T2 type; };
+
+ struct manhattan_domain {};
+ struct forty_five_domain {};
+ struct general_domain {};
+
+ template <typename T>
+ struct geometry_domain { typedef general_domain type; };
+
+ template <typename domain_type, typename coordinate_type>
+ struct area_type_by_domain { typedef typename coordinate_traits<coordinate_type>::area_type type; };
+ template <typename coordinate_type>
+ struct area_type_by_domain<manhattan_domain, coordinate_type> {
+ typedef typename coordinate_traits<coordinate_type>::manhattan_area_type type; };
+
template <typename coordinate_type_1, typename coordinate_type_2>
- static typename coordinate_difference<coordinate_type_1>::type
+ typename requires_2< typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ typename coordinate_traits<coordinate_type_1>::coordinate_difference>::type
euclidean_distance(const coordinate_type_1& lvalue, const coordinate_type_2& rvalue) {
- typedef typename coordinate_difference<coordinate_type_1>::type Unit;
+ typedef typename coordinate_traits<coordinate_type_1>::coordinate_difference Unit;
return (lvalue < rvalue) ? (Unit)rvalue - (Unit)lvalue : (Unit)lvalue - (Unit)rvalue;
}
-};
+
+
+
+/// predicated_swap swaps a and b if pred is true
+
+/// predicated_swap is garenteed to behave the same as
+/// if(pred){
+/// T tmp = a;
+/// a = b;
+/// b = tmp;
+/// }
+/// but will not generate a branch instruction.
+/// predicated_swap always creates a temp copy of a, but does not
+/// create more than one temp copy of an input.
+/// predicated_swap can be used to optimize away branch instructions in C++
+template <class T>
+inline bool predicated_swap(const bool& pred,
+ T& a,
+ T& b) {
+ const T tmp = a;
+ const T* input[2] = {&b, &tmp};
+ a = *input[!pred];
+ b = *input[pred];
+ return pred;
+}
enum direction_1d_enum { LOW = 0, HIGH = 1,
LEFT = 0, RIGHT = 1,
@@ -68,6 +242,7 @@
enum orientation_2d_enum { HORIZONTAL = 0, VERTICAL = 1 };
enum direction_2d_enum { WEST = 0, EAST = 1, SOUTH = 2, NORTH = 3 };
enum orientation_3d_enum { PROXIMAL = 2 };
+enum direction_3d_enum { DOWN = 4, UP = 5 };
enum winding_direction {
clockwise_winding = 0,
counterclockwise_winding = 1,
@@ -75,6 +250,7 @@
};
class direction_2d;
+class direction_3d;
class orientation_2d;
class direction_1d {
@@ -82,17 +258,18 @@
unsigned int val_;
explicit direction_1d(int d);
public:
- direction_1d() { val_ = LOW; }
- direction_1d(const direction_1d& that) : val_(that.val_) {}
- direction_1d(const direction_1d_enum val) : val_(val) {}
- explicit direction_1d(const direction_2d& that);
- const direction_1d& operator = (const direction_1d& d) {
+ inline direction_1d() { val_ = LOW; }
+ inline direction_1d(const direction_1d& that) : val_(that.val_) {}
+ inline direction_1d(const direction_1d_enum val) : val_(val) {}
+ explicit inline direction_1d(const direction_2d& that);
+ explicit inline direction_1d(const direction_3d& that);
+ inline direction_1d& operator = (const direction_1d& d) {
val_ = d.val_; return * this; }
- bool operator==(direction_1d d) const { return (val_ == d.val_); }
- bool operator!=(direction_1d d) const { return !((*this) == d); }
- unsigned int to_int(void) const { return val_; }
- direction_1d& backward() { val_ ^= 1; return *this; }
- int get_sign() const { return val_ * 2 - 1; }
+ inline bool operator==(direction_1d d) const { return (val_ == d.val_); }
+ inline bool operator!=(direction_1d d) const { return !((*this) == d); }
+ inline unsigned int to_int(void) const { return val_; }
+ inline direction_1d& backward() { val_ ^= 1; return *this; }
+ inline int get_sign() const { return val_ * 2 - 1; }
};
class direction_2d;
@@ -100,24 +277,24 @@
class orientation_2d {
private:
unsigned int val_;
- explicit orientation_2d(int o);
+ explicit inline orientation_2d(int o);
public:
- orientation_2d() : val_(HORIZONTAL) {}
- orientation_2d(const orientation_2d& ori) : val_(ori.val_) {}
- orientation_2d(const orientation_2d_enum val) : val_(val) {}
- explicit orientation_2d(const direction_2d& that);
- const orientation_2d& operator=(const orientation_2d& ori) {
+ inline orientation_2d() : val_(HORIZONTAL) {}
+ inline orientation_2d(const orientation_2d& ori) : val_(ori.val_) {}
+ inline orientation_2d(const orientation_2d_enum val) : val_(val) {}
+ explicit inline orientation_2d(const direction_2d& that);
+ inline orientation_2d& operator=(const orientation_2d& ori) {
val_ = ori.val_; return * this; }
- bool operator==(orientation_2d that) const { return (val_ == that.val_); }
- bool operator!=(orientation_2d that) const { return (val_ != that.val_); }
- unsigned int to_int() const { return (val_); }
- void turn_90() { val_ = val_^ 1; }
- orientation_2d get_perpendicular() const {
+ inline bool operator==(orientation_2d that) const { return (val_ == that.val_); }
+ inline bool operator!=(orientation_2d that) const { return (val_ != that.val_); }
+ inline unsigned int to_int() const { return (val_); }
+ inline void turn_90() { val_ = val_^ 1; }
+ inline orientation_2d get_perpendicular() const {
orientation_2d retval = *this;
retval.turn_90();
return retval;
}
- direction_2d get_direction(direction_1d dir) const;
+ inline direction_2d get_direction(direction_1d dir) const;
};
class direction_2d {
@@ -126,49 +303,49 @@
public:
- direction_2d() { val_ = WEST; }
+ inline direction_2d() { val_ = WEST; }
- direction_2d(const direction_2d& that) : val_(that.val_) {}
+ inline direction_2d(const direction_2d& that) : val_(that.val_) {}
- direction_2d(const direction_2d_enum val) : val_(val) {}
+ inline direction_2d(const direction_2d_enum val) : val_(val) {}
- const direction_2d& operator=(const direction_2d& d) {
+ inline direction_2d& operator=(const direction_2d& d) {
val_ = d.val_;
return * this;
}
- ~direction_2d() { }
+ inline ~direction_2d() { }
- bool operator==(direction_2d d) const { return (val_ == d.val_); }
- bool operator!=(direction_2d d) const { return !((*this) == d); }
- bool operator< (direction_2d d) const { return (val_ < d.val_); }
- bool operator<=(direction_2d d) const { return (val_ <= d.val_); }
- bool operator> (direction_2d d) const { return (val_ > d.val_); }
- bool operator>=(direction_2d d) const { return (val_ >= d.val_); }
+ inline bool operator==(direction_2d d) const { return (val_ == d.val_); }
+ inline bool operator!=(direction_2d d) const { return !((*this) == d); }
+ inline bool operator< (direction_2d d) const { return (val_ < d.val_); }
+ inline bool operator<=(direction_2d d) const { return (val_ <= d.val_); }
+ inline bool operator> (direction_2d d) const { return (val_ > d.val_); }
+ inline bool operator>=(direction_2d d) const { return (val_ >= d.val_); }
/// Casting to int
- unsigned int to_int(void) const { return val_; }
+ inline unsigned int to_int(void) const { return val_; }
- direction_2d backward() const {
+ inline direction_2d backward() const {
// flip the LSB, toggles 0 - 1 and 2 - 3
return direction_2d(direction_2d_enum(val_ ^ 1));
}
/// Returns a direction 90 degree left (LOW) or right(HIGH) to this one
- direction_2d turn(direction_1d t) const {
+ inline direction_2d turn(direction_1d t) const {
return direction_2d(direction_2d_enum(val_ ^ 3 ^ (val_ >> 1) ^ t.to_int()));
}
/// Returns a direction 90 degree left to this one
- direction_2d left() const {return turn(HIGH);}
+ inline direction_2d left() const {return turn(HIGH);}
/// Returns a direction 90 degree right to this one
- direction_2d right() const {return turn(LOW);}
+ inline direction_2d right() const {return turn(LOW);}
/// N, E are positive, S, W are negative
- bool is_positive() const {return (val_ & 1);}
- bool is_negative() const {return !is_positive();}
- int get_sign() const {return ((is_positive()) << 1) -1;}
+ inline bool is_positive() const {return (val_ & 1);}
+ inline bool is_negative() const {return !is_positive();}
+ inline int get_sign() const {return ((is_positive()) << 1) -1;}
};
@@ -186,20 +363,81 @@
class orientation_3d {
private:
unsigned int val_;
- explicit orientation_3d(int o);
+ explicit inline orientation_3d(int o);
public:
- orientation_3d() : val_((int)HORIZONTAL) {}
- orientation_3d(const orientation_3d& ori) : val_(ori.val_) {}
- orientation_3d(const orientation_2d& ori) { val_ = ori.to_int(); }
- orientation_3d(const orientation_3d_enum val) : val_(val) {}
- ~orientation_3d() { }
- const orientation_3d& operator=(const orientation_3d& ori) {
+ inline orientation_3d() : val_((int)HORIZONTAL) {}
+ inline orientation_3d(const orientation_3d& ori) : val_(ori.val_) {}
+ inline orientation_3d(orientation_2d ori) { val_ = ori.to_int(); }
+ inline orientation_3d(const orientation_3d_enum val) : val_(val) {}
+ explicit inline orientation_3d(const direction_2d& that);
+ explicit inline orientation_3d(const direction_3d& that);
+ inline ~orientation_3d() { }
+ inline orientation_3d& operator=(const orientation_3d& ori) {
val_ = ori.val_; return * this; }
- bool operator==(orientation_3d that) const { return (val_ == that.val_); }
- bool operator!=(orientation_3d that) const { return (val_ != that.val_); }
- unsigned int to_int() const { return (val_); }
+ inline bool operator==(orientation_3d that) const { return (val_ == that.val_); }
+ inline bool operator!=(orientation_3d that) const { return (val_ != that.val_); }
+ inline unsigned int to_int() const { return (val_); }
+ inline direction_3d get_direction(direction_1d dir) const;
+};
+
+class direction_3d {
+private:
+ int val_;
+
+public:
+
+ inline direction_3d() { val_ = WEST; }
+
+ inline direction_3d(direction_2d that) : val_(that.to_int()) {}
+ inline direction_3d(const direction_3d& that) : val_(that.val_) {}
+
+ inline direction_3d(const direction_2d_enum val) : val_(val) {}
+ inline direction_3d(const direction_3d_enum val) : val_(val) {}
+
+ inline direction_3d& operator=(direction_3d d) {
+ val_ = d.val_;
+ return * this;
+ }
+
+ inline ~direction_3d() { }
+
+ inline bool operator==(direction_3d d) const { return (val_ == d.val_); }
+ inline bool operator!=(direction_3d d) const { return !((*this) == d); }
+ inline bool operator< (direction_3d d) const { return (val_ < d.val_); }
+ inline bool operator<=(direction_3d d) const { return (val_ <= d.val_); }
+ inline bool operator> (direction_3d d) const { return (val_ > d.val_); }
+ inline bool operator>=(direction_3d d) const { return (val_ >= d.val_); }
+
+ /// Casting to int
+ inline unsigned int to_int(void) const { return val_; }
+
+ inline direction_3d backward() const {
+ // flip the LSB, toggles 0 - 1 and 2 - 3 and 4 - 5
+ return direction_2d(direction_2d_enum(val_ ^ 1));
+ }
+
+ /// N, E are positive, S, W are negative
+ inline bool is_positive() const {return (val_ & 1);}
+ inline bool is_negative() const {return !is_positive();}
+ inline int get_sign() const {return ((is_positive()) << 1) -1;}
+
};
+direction_1d::direction_1d(const direction_3d& that) {
+ val_ = that.to_int() & 1;
+}
+orientation_3d::orientation_3d(const direction_3d& that) {
+ val_ = that.to_int() >> 1;
+}
+orientation_3d::orientation_3d(const direction_2d& that) {
+ val_ = that.to_int() >> 1;
+}
+
+direction_3d orientation_3d::get_direction(direction_1d dir) const {
+ return direction_3d(direction_3d_enum((val_ << 1) + dir.to_int()));
+}
+
+
}
#endif
Modified: sandbox/gtl/gtl/iterator_compact_to_points.hpp
==============================================================================
--- sandbox/gtl/gtl/iterator_compact_to_points.hpp (original)
+++ sandbox/gtl/gtl/iterator_compact_to_points.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -28,10 +28,10 @@
iter_(iter), iter_end_(iter_end), orient_(HORIZONTAL) {
if(iter_ != iter_end_) {
firstX_ = *iter_;
- point_concept::set<HORIZONTAL>(pt_, firstX_);
+ x(pt_, firstX_);
++iter_;
if(iter_ != iter_end_) {
- point_concept::set<VERTICAL>(pt_, *iter_);
+ y(pt_, *iter_);
}
}
}
@@ -40,17 +40,17 @@
iterator_type prev_iter = iter_;
++iter_;
if(iter_ == iter_end_) {
- if(point_concept::get<HORIZONTAL>(pt_) != firstX_) {
+ if(x(pt_) != firstX_) {
iter_ = prev_iter;
- point_concept::set<HORIZONTAL>(pt_, firstX_);
+ x(pt_, firstX_);
}
} else {
- point_concept::set(pt_, orient_, *iter_);
+ set(pt_, orient_, *iter_);
orient_.turn_90();
}
return *this;
}
- inline iterator_compact_to_points operator++(int) {
+ inline const iterator_compact_to_points operator++(int) {
iterator_compact_to_points tmp(*this);
++(*this);
return tmp;
Modified: sandbox/gtl/gtl/iterator_geometry_to_set.hpp
==============================================================================
--- sandbox/gtl/gtl/iterator_geometry_to_set.hpp (original)
+++ sandbox/gtl/gtl/iterator_geometry_to_set.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -11,62 +11,6 @@
template <typename concept_type, typename geometry_type>
class iterator_geometry_to_set {};
-template <typename concept_type, typename iterator_type>
-class iterator_geometry_range_to_set {
-public:
- typedef typename std::iterator_traits<iterator_type>::value_type geometry_type;
- typedef iterator_geometry_to_set<concept_type, geometry_type> internal_iterator_type;
- typedef typename internal_iterator_type::value_type value_type;
- typedef std::forward_iterator_tag iterator_category;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type* pointer; //immutable
- typedef const value_type& reference; //immutable
-private:
- iterator_type itr_;
- mutable internal_iterator_type itrb_, itre_;
- mutable bool dereferenced_;
- orientation_2d orient_;
-public:
- iterator_geometry_range_to_set() {}
- iterator_geometry_range_to_set(iterator_type itr,
- orientation_2d orient = HORIZONTAL) :
- itr_(itr), dereferenced_(false), orient_(orient) {}
-
- inline iterator_geometry_range_to_set& operator++() {
- if(!dereferenced_) **this;
- if(itrb_ == itre_) {
- ++itr_;
- dereferenced_ = false;
- } else {
- ++itrb_;
- if(itrb_ == itre_) {
- ++itr_;
- dereferenced_ = false;
- }
- }
- return *this;
- }
- inline iterator_geometry_range_to_set operator++(int) {
- iterator_geometry_range_to_set tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator_geometry_range_to_set& that) const {
- return (itr_ == that.itr_);
- }
- inline bool operator!=(const iterator_geometry_range_to_set& that) const {
- return !(*this == that);
- }
- inline reference operator*() const {
- if(!dereferenced_) {
- itrb_ = iterator_geometry_to_set<concept_type, geometry_type>(*itr_, LOW, orient_);
- itre_ = iterator_geometry_to_set<concept_type, geometry_type>(*itr_, HIGH, orient_);
- dereferenced_ = true;
- }
- return *itrb_;
- }
-};
-
template <typename rectangle_type>
class iterator_geometry_to_set<rectangle_concept, rectangle_type> {
public:
@@ -81,18 +25,19 @@
mutable value_type vertex_;
unsigned int corner_;
orientation_2d orient_;
+ bool is_hole_;
public:
iterator_geometry_to_set() : corner_(4) {}
iterator_geometry_to_set(const rectangle_type& rectangle, direction_1d dir,
- orientation_2d orient = HORIZONTAL) : corner_(0), orient_(orient) {
- rectangle_concept::assign(rectangle_, rectangle);
+ orientation_2d orient = HORIZONTAL, bool is_hole = false) : corner_(0), orient_(orient), is_hole_(is_hole) {
+ assign(rectangle_, rectangle);
if(dir == HIGH) corner_ = 4;
}
inline iterator_geometry_to_set& operator++() {
++corner_;
return *this;
}
- inline iterator_geometry_to_set operator++(int) {
+ inline const iterator_geometry_to_set operator++(int) {
iterator_geometry_to_set tmp(*this);
++(*this);
return tmp;
@@ -105,18 +50,21 @@
}
inline reference operator*() const {
if(corner_ == 0) {
- vertex_.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_.get_perpendicular()), LOW);
- vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), LOW);
+ vertex_.first = get(get(rectangle_, orient_.get_perpendicular()), LOW);
+ vertex_.second.first = get(get(rectangle_, orient_), LOW);
vertex_.second.second = 1;
+ if(is_hole_) vertex_.second.second *= -1;
} else if(corner_ == 1) {
- vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), HIGH);
+ vertex_.second.first = get(get(rectangle_, orient_), HIGH);
vertex_.second.second = -1;
+ if(is_hole_) vertex_.second.second *= -1;
} else if(corner_ == 2) {
- vertex_.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_.get_perpendicular()), HIGH);
- vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), LOW);
+ vertex_.first = get(get(rectangle_, orient_.get_perpendicular()), HIGH);
+ vertex_.second.first = get(get(rectangle_, orient_), LOW);
} else {
- vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), HIGH);
+ vertex_.second.first = get(get(rectangle_, orient_), HIGH);
vertex_.second.second = 1;
+ if(is_hole_) vertex_.second.second *= -1;
}
return vertex_;
}
@@ -146,13 +94,13 @@
iterator_geometry_to_set() : polygon_index(-1) {}
iterator_geometry_to_set(const polygon_type& polygon, direction_1d dir, orientation_2d orient = HORIZONTAL, bool is_hole = false) :
is_hole_(is_hole), orient_(orient), polygon_index(0) {
- itrb = polygon_90_concept::begin(polygon);
- itre = polygon_90_concept::end(polygon);
+ itrb = begin_points(polygon);
+ itre = end_points(polygon);
use_wrap = false;
- if(itrb == itre || dir == HIGH || polygon_90_concept::size(polygon) < 4) {
+ if(itrb == itre || dir == HIGH || size(polygon) < 4) {
polygon_index = -1;
} else {
- direction_1d wdir = polygon_90_concept::winding(polygon);
+ direction_1d wdir = winding(polygon);
multiplier_ = wdir == LOW ? -1 : 1;
if(is_hole_) multiplier_ *= -1;
first_pt = pts[0] = *itrb;
@@ -194,7 +142,7 @@
evaluate_();
return *this;
}
- inline iterator_geometry_to_set operator++(int) {
+ inline const iterator_geometry_to_set operator++(int) {
iterator_geometry_to_set tmp(*this);
++(*this);
return tmp;
@@ -224,7 +172,7 @@
template <typename polygon_with_holes_type>
class iterator_geometry_to_set<polygon_90_with_holes_concept, polygon_with_holes_type> {
public:
- typedef typename rectangle_traits<polygon_with_holes_type>::coordinate_type coordinate_type;
+ typedef typename polygon_90_traits<polygon_with_holes_type>::coordinate_type coordinate_type;
typedef std::forward_iterator_tag iterator_category;
typedef std::pair<coordinate_type, std::pair<coordinate_type, int> > value_type;
typedef std::ptrdiff_t difference_type;
@@ -235,20 +183,21 @@
iterator_geometry_to_set<polygon_90_concept, typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type> itrhib, itrhie;
typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type itrhb, itrhe;
orientation_2d orient_;
+ bool is_hole_;
bool started_holes;
public:
iterator_geometry_to_set() {}
iterator_geometry_to_set(const polygon_with_holes_type& polygon, direction_1d dir,
- orientation_2d orient = HORIZONTAL) : orient_(orient) {
- itre = iterator_geometry_to_set<polygon_90_concept, polygon_with_holes_type>(polygon, HIGH, orient);
- itrhe = polygon_90_with_holes_concept::end_holes(polygon);
+ orientation_2d orient = HORIZONTAL, bool is_hole = false) : orient_(orient), is_hole_(is_hole) {
+ itre = iterator_geometry_to_set<polygon_90_concept, polygon_with_holes_type>(polygon, HIGH, orient, is_hole_);
+ itrhe = end_holes(polygon);
if(dir == HIGH) {
itrb = itre;
itrhb = itrhe;
started_holes = true;
} else {
- itrb = iterator_geometry_to_set<polygon_90_concept, polygon_with_holes_type>(polygon, LOW, orient);
- itrhb = polygon_90_with_holes_concept::begin_holes(polygon);
+ itrb = iterator_geometry_to_set<polygon_90_concept, polygon_with_holes_type>(polygon, LOW, orient, is_hole_);
+ itrhb = begin_holes(polygon);
started_holes = false;
}
}
@@ -258,9 +207,9 @@
if(itrhib == itrhie) {
if(itrhb != itrhe) {
itrhib = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, true);
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, !is_hole_);
itrhie = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, true);
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, !is_hole_);
++itrhb;
} else {
itrhib = itrhie = iterator_geometry_to_set<polygon_90_concept,
@@ -271,9 +220,9 @@
if(itrhib == itrhie) {
if(itrhb != itrhe) {
itrhib = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, true);
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, !is_hole_);
itrhie = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, true);
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, !is_hole_);
++itrhb;
} else {
itrhib = itrhie = iterator_geometry_to_set<polygon_90_concept,
@@ -286,16 +235,16 @@
if(itrb == itre) {
if(itrhb != itrhe) {
itrhib = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, true);
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, !is_hole_);
itrhie = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, true);
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, !is_hole_);
++itrhb;
}
}
}
return *this;
}
- inline iterator_geometry_to_set operator++(int) {
+ inline const iterator_geometry_to_set operator++(int) {
iterator_geometry_to_set tmp(*this);
++(*this);
return tmp;
Modified: sandbox/gtl/gtl/iterator_points_to_compact.hpp
==============================================================================
--- sandbox/gtl/gtl/iterator_points_to_compact.hpp (original)
+++ sandbox/gtl/gtl/iterator_points_to_compact.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -33,7 +33,7 @@
orient_.turn_90();
return *this;
}
- inline iterator_points_to_compact operator++(int) {
+ inline const iterator_points_to_compact operator++(int) {
iT tmp(*this);
++(*this);
return tmp;
@@ -44,7 +44,7 @@
inline bool operator!=(const iterator_points_to_compact& that) const {
return (iter_ != that.iter_);
}
- inline reference operator*() const { return coord_ = point_concept::get(*iter_, orient_); }
+ inline reference operator*() const { return coord_ = get(*iter_, orient_); }
};
}
Added: sandbox/gtl/gtl/max_cover.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/max_cover.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,177 @@
+/*
+ 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 GTL_MAX_COVER_HPP
+#define GTL_MAX_COVER_HPP
+namespace gtl {
+
+ template <typename Unit>
+ struct MaxCover {
+ typedef interval_data<Unit> Interval;
+ typedef rectangle_data<Unit> Rectangle;
+
+ class Node {
+ private:
+ std::vector<Node*> children_;
+ std::set<Interval> tracedPaths_;
+ public:
+ Rectangle rect;
+ Node() {}
+ Node(const Rectangle rectIn) : rect(rectIn) {}
+ typedef typename std::vector<Node*>::iterator iterator;
+ inline iterator begin() { return children_.begin(); }
+ inline iterator end() { return children_.end(); }
+ inline void add(Node* child) { children_.push_back(child); }
+ inline bool tracedPath(const Interval& ivl) const {
+ return tracedPaths_.find(ivl) != tracedPaths_.end();
+ }
+ inline void addPath(const Interval& ivl) {
+ tracedPaths_.insert(tracedPaths_.end(), ivl);
+ }
+ };
+
+ typedef std::pair<std::pair<Unit, Interval>, Node* > EdgeAssociation;
+
+ class lessEdgeAssociation : public std::binary_function<const EdgeAssociation&, const EdgeAssociation&, bool> {
+ public:
+ inline lessEdgeAssociation() {}
+ inline bool operator () (const EdgeAssociation& elem1, const EdgeAssociation& elem2) const {
+ if(elem1.first.first < elem2.first.first) return true;
+ if(elem1.first.first > elem2.first.first) return false;
+ return elem1.first.second < elem2.first.second;
+ }
+ };
+
+ template <class cT>
+ static inline void getMaxCover(cT& outputContainer, Node* node, orientation_2d orient) {
+ Interval rectIvl = node->rect.get(orient);
+ if(node->tracedPath(rectIvl)) {
+ return;
+ }
+ node->addPath(rectIvl);
+ if(node->begin() == node->end()) {
+ outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(node->rect));
+ return;
+ }
+ bool writeOut = true;
+ for(typename Node::iterator itr = node->begin(); itr != node->end(); ++itr) {
+ getMaxCover(outputContainer, *itr, orient, node->rect); //get rectangles down path
+ Interval nodeIvl = (*itr)->rect.get(orient);
+ if(contains(nodeIvl, rectIvl, true)) writeOut = false;
+ }
+ if(writeOut) {
+ outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(node->rect));
+ }
+ }
+
+ template <class cT>
+ static inline void getMaxCover(cT& outputContainer, Node* node, orientation_2d orient,
+ const Rectangle& rect) {
+ Interval rectIvl = rect.get(orient);
+ Interval nodeIvl = node->rect.get(orient);
+ if(!intersect(rectIvl, nodeIvl, false)) {
+ return;
+ }
+ if(node->tracedPath(rectIvl)) {
+ return;
+ }
+ node->addPath(rectIvl);
+ Rectangle nextRect(rectIvl, rectIvl);
+ Unit low = rect.get(orient.get_perpendicular()).low();
+ Unit high = node->rect.get(orient.get_perpendicular()).high();
+ nextRect.set(orient.get_perpendicular(), Interval(low, high));
+ bool writeOut = true;
+ rectIvl = nextRect.get(orient);
+ for(typename Node::iterator itr = node->begin(); itr != node->end(); ++itr) {
+ nodeIvl = (*itr)->rect.get(orient);
+ if(contains(nodeIvl, rectIvl, true)) writeOut = false;
+ getMaxCover(outputContainer, *itr, orient, nextRect);
+ }
+ if(writeOut) {
+ outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
+ }
+ }
+
+ //computeDag populates the node of the iterator range of Nodes with parent child
+ //relationships by adding the child node to the parent node's list of children
+ //iterator range is assummed to be in topological order meaning all node's trailing
+ //edges are in sorted order
+ template <class iT>
+ static inline void computeDag(iT beginNode, iT endNode, orientation_2d orient,
+ unsigned int size) {
+ std::vector<EdgeAssociation> leadingEdges;
+ leadingEdges.reserve(size);
+ for(iT iter = beginNode; iter != endNode; ++iter) {
+ Node* nodep = &(*iter);
+ Unit leading = nodep->rect.get(orient.get_perpendicular()).low();
+ Interval rectIvl = nodep->rect.get(orient);
+ leadingEdges.push_back(EdgeAssociation(std::pair<Unit, Interval>(leading, rectIvl), nodep));
+ }
+ std::sort(leadingEdges.begin(), leadingEdges.end(), lessEdgeAssociation());
+ typename std::vector<EdgeAssociation>::iterator leadingBegin = leadingEdges.begin();
+ iT trailingBegin = beginNode;
+ while(leadingBegin != leadingEdges.end()) {
+ EdgeAssociation& leadingSegment = (*leadingBegin);
+ Unit trailing = (*trailingBegin).rect.get(orient.get_perpendicular()).high();
+ Interval ivl = (*trailingBegin).rect.get(orient);
+ std::pair<Unit, Interval> trailingSegment(trailing, ivl);
+ if(leadingSegment.first.first < trailingSegment.first) {
+ ++leadingBegin;
+ continue;
+ }
+ if(leadingSegment.first.first > trailingSegment.first) {
+ ++trailingBegin;
+ continue;
+ }
+ if(leadingSegment.first.second.high() <= trailingSegment.second.low()) {
+ ++leadingBegin;
+ continue;
+ }
+ if(trailingSegment.second.high() <= leadingSegment.first.second.low()) {
+ ++trailingBegin;
+ continue;
+ }
+ //leading segment intersects trailing segment
+ (*trailingBegin).add((*leadingBegin).second);
+ if(leadingSegment.first.second.high() > trailingSegment.second.high()) {
+ ++trailingBegin;
+ continue;
+ }
+ if(trailingSegment.second.high() > leadingSegment.first.second.high()) {
+ ++leadingBegin;
+ continue;
+ }
+ ++leadingBegin;
+ ++trailingBegin;
+ }
+ }
+
+ template <class cT>
+ static inline void getMaxCover(cT& outputContainer,
+ const std::vector<Rectangle>& rects, orientation_2d orient) {
+ if(rects.empty()) return;
+ std::vector<Node> nodes;
+ {
+ if(rects.size() == 1) {
+ outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(rects[0]));
+ return;
+ }
+ nodes.reserve(rects.size());
+ for(unsigned int i = 0; i < rects.size(); ++i) { nodes.push_back(Node(rects[i])); }
+ }
+ computeDag(nodes.begin(), nodes.end(), orient, nodes.size());
+ for(unsigned int i = 0; i < nodes.size(); ++i) {
+ getMaxCover(outputContainer, &(nodes[i]), orient);
+ }
+ }
+
+
+ };
+
+}
+
+#endif
Modified: sandbox/gtl/gtl/point_3d_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/point_3d_concept.hpp (original)
+++ sandbox/gtl/gtl/point_3d_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,40 +8,179 @@
#ifndef GLT_POINT_3D_CONCEPT_HPP
#define GLT_POINT_3D_CONCEPT_HPP
namespace gtl {
-struct point_3d_concept : point_concept {
- point_3d_concept() {}
+ struct point_3d_concept {};
+
+ template <typename T>
+ struct is_point_3d_concept {};
+ template <>
+ struct is_point_3d_concept<point_3d_concept> { typedef void type; };
+ //template <>
+ //struct is_point_concept<point_3d_concept> { typedef void type; };
- template <orientation_3d_enum orient, typename T>
- static inline typename point_3d_traits<T>::coordinate_type get(const T& point) {
- return point_3d_traits<T>::get(point, orient); }
+ template <typename T>
+ struct is_mutable_point_3d_concept {};
+ template <>
+ struct is_mutable_point_3d_concept<point_3d_concept> { typedef void type; };
template <typename T>
- static inline typename point_3d_traits<T>::coordinate_type get(const T& point, orientation_3d orient) {
- return point_3d_traits<T>::get(point, orient); }
+ typename requires_1< typename is_point_3d_concept<typename geometry_concept<T>::type>::type,
+ typename point_3d_traits<T>::coordinate_type >::type
+ get(const T& point, orientation_3d orient) { return point_3d_traits<T>::get(point, orient); }
- template <orientation_3d_enum orient, typename T, typename coordinate_type>
- static inline void set(T& point, coordinate_type value) {
- point_traits<T>::set(point, orient, value); }
template <typename T, typename coordinate_type>
- static inline void set(T& point, orientation_3d orient, coordinate_type value) {
- point_3d_traits<T>::set(point, orient, value); }
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<T>::type>::type, void>::type
+ set(T& point, orientation_3d orient, coordinate_type value) { point_3d_mutable_traits<T>::set(point, orient, value); }
+ template <typename T, typename coordinate_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<T>::type>::type, void>::type
+ set(T& point, orientation_2d orient, coordinate_type value) { point_3d_mutable_traits<T>::set(point, orient, value); }
template <typename T, typename coordinate_type1, typename coordinate_type2, typename coordinate_type3>
- static inline T construct(coordinate_type1 x_value,
- coordinate_type2 y_value,
- coordinate_type3 z_value) {
- return point_3d_traits<T>::construct(x_value, y_value, z_value); }
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<T>::type>::type, T>::type
+ construct(coordinate_type1 x_value, coordinate_type2 y_value, coordinate_type3 z_value) {
+ return point_3d_mutable_traits<T>::construct(x_value, y_value, z_value); }
template <typename point_3d_type_1, typename point_3d_type_2>
- static point_3d_type_1& assign(point_3d_type_1& lvalue, const point_3d_type_2& rvalue) {
+ typename requires_2< typename is_mutable_point_3d_concept<typename geometry_concept<point_3d_type_1>::type>::type,
+ typename is_point_3d_concept<typename geometry_concept<point_3d_type_2>::type>::type,
+ point_3d_type_1>::type &
+ assign(point_3d_type_1& lvalue, const point_3d_type_2& rvalue) {
set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
set(lvalue, VERTICAL, get(rvalue, VERTICAL));
set(lvalue, PROXIMAL, get(rvalue, PROXIMAL));
return lvalue;
}
+ template <typename point_type>
+ typename requires_1< typename is_point_3d_concept<typename geometry_concept<point_type>::type>::type,
+ typename point_3d_traits<point_type>::coordinate_type >::type
+ z(const point_type& point) { return get(point, PROXIMAL); }
+
+ template <typename point_type, typename coordinate_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type, void>::type
+ x(point_type& point, coordinate_type value) { set(point, HORIZONTAL, value); }
+ template <typename point_type, typename coordinate_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type, void>::type
+ y(point_type& point, coordinate_type value) { set(point, VERTICAL, value); }
+ template <typename point_type, typename coordinate_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type, void>::type
+ z(point_type& point, coordinate_type value) { set(point, PROXIMAL, value); }
+
+ template <typename T, typename T2>
+ typename requires_2< typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<T>::type>::type,
+ typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<T2>::type>::type,
+ bool>::type
+ equivalence(const T& point1, const T2& point2) {
+ return x(point1) == x(point2) && y(point1) == y(point2) && z(point1) == z(point2);
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2< typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<point_type_1>::type>::type,
+ typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_difference>::type
+ manhattan_distance(const point_type_1& point1, const point_type_2& point2) {
+ return euclidean_distance(point1, point2, HORIZONTAL) + euclidean_distance(point1, point2, VERTICAL)
+ + euclidean_distance(point1, point2, PROXIMAL);
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2< typename is_point_3d_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_3d_concept<typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_difference>::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;
+ return_type return_value =
+ (return_type)get(point1, orient) - (return_type)get(point2, orient);
+ return return_value < 0 ? -return_value : return_value;
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2< typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<point_type_1>::type>::type,
+ typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_distance>::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;
+ return_value pdist = (return_value)euclidean_distance(point1, point2, PROXIMAL);
+ pdist *= pdist;
+ return sqrt((return_value)distance_squared(point1, point2) + pdist);
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2< typename is_mutable_point_3d_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<point_type_2>::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));
+ z(lvalue, z(lvalue) + z(rvalue));
+ return lvalue;
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2< typename is_mutable_point_3d_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_same_type_SFINAE<point_3d_concept, typename geometry_concept<point_type_2>::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));
+ z(lvalue, z(lvalue) - z(rvalue));
+ return lvalue;
+ }
+
+ template <typename point_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_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);
+ return point;
+ }
+
+ template <typename point_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_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;
+ 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));
+ z(point, scaling_policy<Unit>::round((dt)(z(point)) / (dt)factor));
+ return point;
+ }
+
+ template <typename point_type, typename scaling_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ scale(point_type& point,
+ const scaling_type& scaling) {
+ typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+ Unit x_(x(point)), y_(y(point)), z_(z(point));
+ scaling.scale(x_, y_, z_);
+ x(point, x_);
+ y(point, y_);
+ z(point, z_);
+ return point;
+ }
-};
+ template <typename point_type, typename transformation_type>
+ typename requires_1< typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ transform(point_type& point, const transformation_type& transformation) {
+ typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+ Unit x_(x(point)), y_(y(point)), z_(z(point));
+ transformation.transform(x_, y_, z_);
+ x(point, x_);
+ y(point, y_);
+ z(point, z_);
+ return point;
+ }
+
+ template <typename T>
+ struct geometry_concept<point_3d_data<T> > {
+ typedef point_3d_concept type;
+ };
}
#endif
Modified: sandbox/gtl/gtl/point_3d_data.hpp
==============================================================================
--- sandbox/gtl/gtl/point_3d_data.hpp (original)
+++ sandbox/gtl/gtl/point_3d_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,30 +8,32 @@
#ifndef GTL_POINT_3D_DATA_HPP
#define GTL_POINT_3D_DATA_HPP
namespace gtl {
-struct point_3d_concept;
-template <typename T>
-class point_3d_data {
-public:
- typedef point_3d_concept geometry_type;
- typedef T coordinate_type;
- inline point_3d_data(){}
- inline point_3d_data(coordinate_type x, coordinate_type y) {
- coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = 0; }
- inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z) {
- coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = z; }
- inline point_3d_data(const point_3d_data& that) { (*this) = that; }
- inline point_3d_data& operator=(const point_3d_data& that) {
- coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1];
- coords_[2] = that.coords_[2]; return *this; }
- template <typename T2>
- inline point_3d_data& operator=(const T2& rvalue);
- inline coordinate_type get(orientation_3d orient) const {
- return coords_[orient.to_int()]; }
- inline void set(orientation_3d orient, coordinate_type value) {
- coords_[orient.to_int()] = value; }
-private:
- coordinate_type coords_[3];
-};
+ template <typename T>
+ class point_3d_data {
+ public:
+ typedef T coordinate_type;
+ inline point_3d_data(){}
+ inline point_3d_data(coordinate_type x, coordinate_type y) {
+ coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = 0; }
+ inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z) {
+ coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = z; }
+ inline point_3d_data(const point_3d_data& that) { (*this) = that; }
+ inline point_3d_data& operator=(const point_3d_data& that) {
+ coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1];
+ coords_[2] = that.coords_[2]; return *this; }
+ template <typename T2>
+ inline point_3d_data& operator=(const T2& rvalue);
+ inline coordinate_type get(orientation_2d orient) const {
+ return coords_[orient.to_int()]; }
+ inline coordinate_type get(orientation_3d orient) const {
+ return coords_[orient.to_int()]; }
+ inline void set(orientation_2d orient, coordinate_type value) {
+ coords_[orient.to_int()] = value; }
+ inline void set(orientation_3d orient, coordinate_type value) {
+ coords_[orient.to_int()] = value; }
+ private:
+ coordinate_type coords_[3];
+ };
}
#endif
Modified: sandbox/gtl/gtl/point_3d_traits.hpp
==============================================================================
--- sandbox/gtl/gtl/point_3d_traits.hpp (original)
+++ sandbox/gtl/gtl/point_3d_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,21 +8,24 @@
#ifndef GTL_POINT_3D_TRAITS_HPP
#define GTL_POINT_3D_TRAITS_HPP
namespace gtl {
-template <typename T>
-struct point_3d_traits {
- typedef typename T::coordinate_type coordinate_type;
+ template <typename T>
+ struct point_3d_traits {
+ typedef typename T::coordinate_type coordinate_type;
- static inline coordinate_type get(const T& point, orientation_3d orient) {
- return point.get(orient); }
+ static inline coordinate_type get(const T& point, orientation_3d orient) {
+ return point.get(orient); }
+ };
- static inline void set(T& point, orientation_3d orient, coordinate_type value) {
- point.set(orient, value); }
+ template <typename T>
+ struct point_3d_mutable_traits {
+ static inline void set(T& point, orientation_3d orient, typename point_3d_traits<T>::coordinate_type value) {
+ point.set(orient, value); }
- static inline T construct(coordinate_type x_value,
- coordinate_type y_value,
- coordinate_type z_value) {
- return T(x_value, y_value, z_value); }
-};
+ static inline T construct(typename point_3d_traits<T>::coordinate_type x_value,
+ typename point_3d_traits<T>::coordinate_type y_value,
+ typename point_3d_traits<T>::coordinate_type z_value) {
+ return T(x_value, y_value, z_value); }
+ };
}
#endif
Modified: sandbox/gtl/gtl/point_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/point_concept.hpp (original)
+++ sandbox/gtl/gtl/point_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,131 +7,225 @@
*/
#ifndef GTL_POINT_CONCEPT_HPP
#define GTL_POINT_CONCEPT_HPP
-namespace gtl {
-struct point_concept {
- point_concept() {}
-
- template <typename T>
- struct coordinate_type {
- typedef typename point_traits<T>::coordinate_type type;
- };
-
- template <typename T>
- struct component_type {
- typedef typename point_traits<T>::coordinate_type type;
- };
+#include "isotropy.hpp"
+#include "point_data.hpp"
+#include "point_traits.hpp"
+namespace gtl {
+ struct point_concept {};
+
template <typename T>
- struct area_type {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::area_type type;
- };
+ struct is_point_concept {};
+ template <>
+ struct is_point_concept<point_concept> { typedef void type; };
- template <typename T>
- struct coordinate_difference {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_difference type;
- };
+ struct point_3d_concept;
+ template <>
+ struct is_point_concept<point_3d_concept> { typedef void type; };
template <typename T>
- struct coordinate_distance {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_distance type;
- };
+ struct is_mutable_point_concept {};
+ template <>
+ struct is_mutable_point_concept<point_concept> { typedef void type; };
template <typename T>
- static inline typename point_traits<T>::coordinate_type get(const T& point, orientation_2d orient) {
+ typename requires_1< typename is_point_concept<typename geometry_concept<T>::type>::type,
+ typename point_traits<T>::coordinate_type >::type
+ get(const T& point, orientation_2d orient) {
return point_traits<T>::get(point, orient);
}
- template <orientation_2d_enum orient, typename T>
- static inline typename point_traits<T>::coordinate_type get(const T& point) {
- return get(point, orient);
- }
-
template <typename T, typename coordinate_type>
- static inline void set(T& point, orientation_2d orient, coordinate_type value) {
- point_traits<T>::set(point, orient, value);
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<T>::type>::type, void>::type
+ set(T& point, orientation_2d orient, coordinate_type value) {
+ point_mutable_traits<T>::set(point, orient, value);
}
- template <orientation_2d_enum orient, typename T, typename coordinate_type>
- static inline void set(T& point, coordinate_type value) {
- set(point, orient, value);
+ template <typename T, typename coordinate_type1, typename coordinate_type2>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<T>::type>::type,
+ T>::type
+ construct(coordinate_type1 x_value, coordinate_type2 y_value) {
+ return point_mutable_traits<T>::construct(x_value, y_value);
}
- template <typename point_type>
- static typename point_traits<point_type>::coordinate_type
- x(point_type& point) {
- return get<HORIZONTAL>(point);
+ template <typename T1, typename T2>
+ typename requires_2<
+ typename is_mutable_point_concept<typename geometry_concept<T1>::type>::type,
+ typename is_point_concept<typename geometry_concept<T2>::type>::type,
+ T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
+ set(lvalue, VERTICAL, get(rvalue, VERTICAL));
+ return lvalue;
}
template <typename point_type>
- static typename point_traits<point_type>::coordinate_type
- y(point_type& point) {
- return get<VERTICAL>(point);
+ typename requires_1< typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename point_traits<point_type>::coordinate_type >::type
+ x(const point_type& point) {
+ return get(point, HORIZONTAL);
}
- template <typename point_type, typename coordinate_type>
- static void x(point_type& point, coordinate_type value) {
- set<HORIZONTAL>(point, value);
+ template <typename point_type>
+ typename requires_1< typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename point_traits<point_type>::coordinate_type >::type
+ y(const point_type& point) {
+ return get(point, VERTICAL);
}
template <typename point_type, typename coordinate_type>
- static void y(point_type& point, coordinate_type value) {
- set<VERTICAL>(point, value);
- }
-
- template <typename T, typename coordinate_type1, typename coordinate_type2>
- static inline T construct(coordinate_type1 x_value, coordinate_type2 y_value) {
- return point_traits<T>::construct(x_value, y_value);
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ void>::type
+ x(point_type& point, coordinate_type value) {
+ set(point, HORIZONTAL, value);
}
- template <typename point_type_1, typename point_type_2>
- static point_type_1& assign(point_type_1& lvalue, const point_type_2& rvalue) {
- set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
- set(lvalue, VERTICAL, get(rvalue, VERTICAL));
- return lvalue;
+ template <typename point_type, typename coordinate_type>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ void>::type
+ y(point_type& point, coordinate_type value) {
+ set(point, VERTICAL, value);
}
template <typename T, typename T2>
- static inline bool equivalence(const T& point1, const T2& point2) {
- typename point_traits<T>::coordinate_type x1 = get<HORIZONTAL>(point1);
+ typename requires_2<typename is_same_type_SFINAE<point_concept, typename geometry_concept<T>::type>::type,
+ typename is_point_concept<typename geometry_concept<T2>::type>::type,
+ bool>::type
+ equivalence(const T& point1, const T2& point2) {
+ 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 = get<VERTICAL>(point2);
+ typename point_traits<T2>::coordinate_type y2 = y(point2);
return x1 == x2 && y1 == y2;
}
template <typename point_type_1, typename point_type_2>
- static typename coordinate_difference<point_type_1>::type
+ typename requires_2<typename is_same_type_SFINAE<point_concept, typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference>::type
manhattan_distance(const point_type_1& point1, const point_type_2& point2) {
return euclidean_distance(point1, point2, HORIZONTAL) + euclidean_distance(point1, point2, VERTICAL);
}
-
+
template <typename point_type_1, typename point_type_2>
- static typename coordinate_difference<point_type_1>::type
+ typename requires_2<typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference>::type
euclidean_distance(const point_type_1& point1, const point_type_2& point2, orientation_2d orient) {
- typename point_traits<point_type_1>::coordinate_type return_value =
+ typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference return_value =
get(point1, orient) - get(point2, orient);
return return_value < 0 ? -return_value : return_value;
}
-
+
template <typename point_type_1, typename point_type_2>
- static typename coordinate_distance<point_type_1>::type
+ typename requires_2<typename is_same_type_SFINAE<point_concept, typename geometry_concept<point_type_1>::type>::type,
+ typename is_same_type_SFINAE<point_concept, typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_distance>::type
euclidean_distance(const point_type_1& point1, const point_type_2& point2) {
- return sqrt((typename coordinate_distance<point_type_1>::type)(distance_squared(point1, point2)));
+ typedef typename point_traits<point_type_1>::coordinate_type Unit;
+ return sqrt((typename coordinate_traits<Unit>::coordinate_distance)(distance_squared(point1, point2)));
}
template <typename point_type_1, typename point_type_2>
- static typename coordinate_difference<point_type_1>::type
+ typename requires_2<typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type,
+ typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference>::type
distance_squared(const point_type_1& point1, const point_type_2& point2) {
- typename coordinate_difference<point_type_1>::type dx = euclidean_distance(point1, point2, HORIZONTAL);
- typename coordinate_difference<point_type_1>::type dy = euclidean_distance(point1, point2, VERTICAL);
+ typedef typename point_traits<point_type_1>::coordinate_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;
dy *= dy;
return dx + dy;
}
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2<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, 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;
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ typename requires_2<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, 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;
+ }
-};
+ template <typename point_type, typename coord_type>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ scale_up(point_type& point, coord_type factor) {
+ typedef typename point_traits<point_type>::coordinate_type Unit;
+ x(point, x(point) * (Unit)factor);
+ y(point, y(point) * (Unit)factor);
+ return point;
+ }
+
+ template <typename point_type, typename coord_type>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ scale_down(point_type& point, coord_type factor) {
+ typedef typename point_traits<point_type>::coordinate_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));
+ return point;
+ }
+
+ template <typename point_type, typename scaling_type>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ scale(point_type& point,
+ const scaling_type& scaling) {
+ typedef typename point_traits<point_type>::coordinate_type Unit;
+ Unit x_(x(point)), y_(y(point));
+ scaling.scale(x_, y_);
+ x(point, x_);
+ y(point, y_);
+ return point;
+ }
+
+ template <typename point_type, typename transformation_type>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ transform(point_type& point, const transformation_type& transformation) {
+ typedef typename point_traits<point_type>::coordinate_type Unit;
+ Unit x_(x(point)), y_(y(point));
+ transformation.transform(x_, y_);
+ x(point, x_);
+ y(point, y_);
+ return point;
+ }
+ template <typename point_type>
+ typename requires_1<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ point_type>::type &
+ move(point_type& point, orientation_2d orient,
+ typename point_traits<point_type>::coordinate_type displacement) {
+ typedef typename point_traits<point_type>::coordinate_type Unit;
+ Unit v(get(point, orient));
+ set(point, orient, v + displacement);
+ return point;
+ }
+
+ template <class T>
+ template <class T2>
+ point_data<T>& point_data<T>::operator=(const T2& rvalue) {
+ assign(*this, rvalue);
+ return *this;
+ }
+
+ template <typename T>
+ struct geometry_concept<point_data<T> > {
+ typedef point_concept type;
+ };
}
#endif
Modified: sandbox/gtl/gtl/point_data.hpp
==============================================================================
--- sandbox/gtl/gtl/point_data.hpp (original)
+++ sandbox/gtl/gtl/point_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,50 +7,64 @@
*/
#ifndef GTLPOINT_DATA_HPP
#define GTLPOINT_DATA_HPP
+
+#include "isotropy.hpp"
+
namespace gtl {
-struct point_concept;
+ template <typename T>
+ class point_data {
+ public:
+ typedef T coordinate_type;
+ inline point_data(){}
+ inline point_data(coordinate_type x, coordinate_type y) {
+ coords_[HORIZONTAL] = x; coords_[VERTICAL] = y;
+ }
+ inline point_data(const point_data& that) { (*this) = that; }
+ inline point_data& operator=(const point_data& that) {
+ coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
+ }
+ template <typename T2>
+ inline point_data& operator=(const T2& rvalue);
+ inline bool operator==(const point_data& that) const {
+ return coords_[0] == that.coords_[0] && coords_[1] == that.coords_[1];
+ }
+ inline bool operator!=(const point_data& that) const {
+ return !((*this) == that);
+ }
+ inline bool operator<(const point_data& that) const {
+ return coords_[0] < that.coords_[0] ||
+ (coords_[0] == that.coords_[0] && coords_[1] < that.coords_[1]);
+ }
+ inline coordinate_type get(orientation_2d orient) const {
+ return coords_[orient.to_int()];
+ }
+ inline void set(orientation_2d orient, coordinate_type value) {
+ coords_[orient.to_int()] = value;
+ }
+ inline coordinate_type x() const {
+ return coords_[HORIZONTAL];
+ }
+ inline coordinate_type y() const {
+ return coords_[VERTICAL];
+ }
+ inline point_data& x(coordinate_type value) {
+ coords_[HORIZONTAL] = value;
+ return *this;
+ }
+ inline point_data& y(coordinate_type value) {
+ coords_[VERTICAL] = value;
+ return *this;
+ }
+ private:
+ coordinate_type coords_[2];
+ };
-template <typename T>
-class point_data {
-public:
- typedef point_concept geometry_type;
- typedef T coordinate_type;
- inline point_data(){}
- inline point_data(coordinate_type x, coordinate_type y) {
- coords_[HORIZONTAL] = x; coords_[VERTICAL] = y;
- }
- inline point_data(const point_data& that) { (*this) = that; }
- inline point_data& operator=(const point_data& that) {
- coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
- }
- template <typename T2>
- inline point_data& operator=(const T2& rvalue);
- inline bool operator==(const point_data& that) const {
- return coords_[0] == that.coords_[0] && coords_[1] == that.coords_[1];
- }
- inline bool operator!=(const point_data& that) const {
- return !((*this) == that);
+ template <class T>
+ std::ostream& operator << (std::ostream& o, const point_data<T>& r)
+ {
+ return o << r.get(HORIZONTAL) << ' ' << r.get(VERTICAL);
}
- inline bool operator<(const point_data& that) const {
- return coords_[0] < that.coords_[0] ||
- (coords_[0] == that.coords_[0] && coords_[1] < that.coords_[1]);
- }
- inline coordinate_type get(orientation_2d orient) const {
- return coords_[orient.to_int()];
- }
- inline void set(orientation_2d orient, coordinate_type value) {
- coords_[orient.to_int()] = value;
- }
-private:
- coordinate_type coords_[2];
-};
-
-template <class T>
-std::ostream& operator << (std::ostream& o, const point_data<T>& r)
-{
- return o << r.get(HORIZONTAL) << ' ' << r.get(VERTICAL);
-}
}
#endif
Modified: sandbox/gtl/gtl/point_traits.hpp
==============================================================================
--- sandbox/gtl/gtl/point_traits.hpp (original)
+++ sandbox/gtl/gtl/point_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,21 +7,26 @@
*/
#ifndef GTL_POINT_TRAITS_HPP
#define GTL_POINT_TRAITS_HPP
+
namespace gtl {
-template <typename T>
-struct point_traits {
- typedef typename T::coordinate_type coordinate_type;
+ template <typename T>
+ struct point_traits {
+ typedef typename T::coordinate_type coordinate_type;
- static inline coordinate_type get(const T& point, orientation_2d orient) {
- return point.get(orient);
- }
- static inline void set(T& point, orientation_2d orient, coordinate_type value) {
- point.set(orient, value);
- }
- static inline T construct(coordinate_type x_value, coordinate_type y_value) {
- return T(x_value, y_value);
- }
-};
+ static inline coordinate_type get(const T& point, orientation_2d orient) {
+ return point.get(orient);
+ }
+ };
+
+ template <typename T>
+ struct point_mutable_traits {
+ static inline void set(T& point, orientation_2d orient, typename point_traits<T>::coordinate_type value) {
+ point.set(orient, value);
+ }
+ static inline T construct(typename point_traits<T>::coordinate_type x_value, typename point_traits<T>::coordinate_type y_value) {
+ return T(x_value, y_value);
+ }
+ };
}
#endif
Modified: sandbox/gtl/gtl/polygon_45_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -15,23 +15,21 @@
typedef polygon_45_concept geometry_type;
typedef T coordinate_type;
typedef typename std::vector<point_data<coordinate_type> >::const_iterator iterator_type;
- typedef iterator_points_to_compact<iterator_type, point_data<coordinate_type> > compact_iterator_type;
+ typedef typename coordinate_traits<T>::coordinate_distance area_type;
+ typedef point_data<T> point_type;
inline polygon_45_data(){;} //do nothing default constructor
template<class iT>
+ inline polygon_45_data(iT input_begin, iT input_end) : coords_(input_begin, input_end) {}
+
+ template<class iT>
inline polygon_45_data& set(iT input_begin, iT input_end) {
coords_.clear(); //just in case there was some old data there
coords_.insert(coords_.end(), input_begin, input_end);
return *this;
}
- template<typename iT>
- inline polygon_45_data& set_compact(iT input_begin, iT input_end) {
- typedef iterator_compact_to_points<iT, point_data<coordinate_type> > iTC;
- return set(iTC(input_begin, input_end), iTC(input_end, input_end));
- }
-
/// copy constructor (since we have dynamic memory)
inline polygon_45_data(const polygon_45_data& that) : coords_(that.coords_) {}
@@ -44,17 +42,21 @@
template <typename T2>
inline polygon_45_data& operator=(const T2& rvalue);
- /// get begin iterator, returns a pointer to a const Unit
- inline iterator_type begin() const { return coords_.begin(); }
+ inline bool operator==(const polygon_45_data& that) const {
+ if(coords_.size() != that.coords_.size()) return false;
+ for(unsigned int i = 0; i < coords_.size(); ++i) {
+ if(coords_[i] != that.coords_[i]) return false;
+ }
+ return true;
+ }
- /// get end iterator, returns a pointer to a const Unit
- inline iterator_type end() const { return coords_.end(); }
+ inline bool operator!=(const polygon_45_data& that) const { return !((*this) == that); }
/// get begin iterator, returns a pointer to a const Unit
- inline compact_iterator_type begin_compact() const { return compact_iterator_type(begin()); }
+ inline iterator_type begin() const { return coords_.begin(); }
/// get end iterator, returns a pointer to a const Unit
- inline compact_iterator_type end_compact() const { return compact_iterator_type(begin()); }
+ inline iterator_type end() const { return coords_.end(); }
inline std::size_t size() const { return coords_.size(); }
@@ -62,6 +64,18 @@
std::vector<point_data<coordinate_type> > coords_;
};
+ template <typename T>
+ std::ostream& operator<<(std::ostream& o, const polygon_45_data<T>& poly) {
+ o << "Polygon { ";
+ for(typename polygon_45_data<T>::iterator_type itr = poly.begin();
+ itr != poly.end(); ++itr) {
+ if(itr != poly.begin()) o << ", ";
+ o << (*itr).get(HORIZONTAL) << " " << (*itr).get(VERTICAL);
+ }
+ o << " } ";
+ return o;
+ }
}
+
#endif
Added: sandbox/gtl/gtl/polygon_45_formation.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_45_formation.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,2200 @@
+/*
+ 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 GTL_POLYGON_45_FORMATION_HPP
+#define GTL_POLYGON_45_FORMATION_HPP
+namespace gtl {
+
+ template <typename T, typename T2>
+ struct PolyLineByConcept {};
+
+ template <typename T>
+ class PolyLine45PolygonData;
+ template <typename T>
+ class PolyLine45HoleData;
+
+ //polygon45formation algorithm
+ template <typename Unit>
+ struct polygon_45_formation : public boolean_op_45<Unit> {
+ typedef point_data<int> Point;
+ typedef polygon_45_data<int> Polygon45;
+ typedef polygon_45_with_holes_data<int> Polygon45WithHoles;
+ typedef typename boolean_op_45<Unit>::Vertex45 Vertex45;
+ typedef typename boolean_op_45<Unit>::lessVertex45 lessVertex45;
+ typedef typename boolean_op_45<Unit>::Scan45Count Scan45Count;
+ typedef std::pair<Point, Scan45Count> Scan45Vertex;
+ typedef typename boolean_op_45<Unit>::Count2 Count2;
+ typedef typename boolean_op_45<Unit>::Scan45 Scan45;
+
+ class PolyLine45 {
+ public:
+ typedef std::list<Point>::const_iterator iterator;
+
+ /// default constructor of point does not initialize x and y
+ inline PolyLine45(){;} //do nothing default constructor
+
+ /// initialize a polygon from x,y values, it is assumed that the first is an x
+ /// and that the input is a well behaved polygon
+ template<class iT>
+ inline PolyLine45& set(iT inputBegin, iT inputEnd) {
+ points.clear(); //just in case there was some old data there
+ while(inputBegin != inputEnd) {
+ points.insert(points.end(), *inputBegin);
+ ++inputBegin;
+ }
+ return *this;
+ }
+
+ /// copy constructor (since we have dynamic memory)
+ inline PolyLine45(const PolyLine45& that) : points(that.points) {}
+
+ /// assignment operator (since we have dynamic memory do a deep copy)
+ inline PolyLine45& operator=(const PolyLine45& that) {
+ points = that.points;
+ return *this;
+ }
+
+ /// get begin iterator, returns a pointer to a const Unit
+ inline iterator begin() const { return points.begin(); }
+
+ /// get end iterator, returns a pointer to a const Unit
+ inline iterator end() const { return points.end(); }
+
+ inline std::size_t size() const { return points.size(); }
+
+ //public data member
+ std::list<Point> points;
+ };
+
+ class ActiveTail45 {
+ private:
+ //data
+ PolyLine45* tailp_;
+ ActiveTail45 *otherTailp_;
+ std::list<ActiveTail45*> holesList_;
+ bool head_;
+ public:
+
+ /**
+ * @brief iterator over coordinates of the figure
+ */
+ typedef typename PolyLine45::iterator iterator;
+
+ /**
+ * @brief iterator over holes contained within the figure
+ */
+ typedef typename std::list<ActiveTail45*>::const_iterator iteratorHoles;
+
+ //default constructor
+ inline ActiveTail45() : tailp_(0), otherTailp_(0), head_(0) {}
+
+ //constructor
+ inline ActiveTail45(const Vertex45& vertex, ActiveTail45* otherTailp = 0) {
+ tailp_ = new PolyLine45;
+ tailp_->points.push_back(vertex.pt);
+ bool headArray[4] = {false, true, true, true};
+ bool inverted = vertex.count == -1;
+ head_ = headArray[vertex.rise+1] ^ inverted;
+ otherTailp_ = otherTailp;
+ }
+
+ inline ActiveTail45(Point point, ActiveTail45* otherTailp, bool head = true) {
+ tailp_ = new PolyLine45;
+ tailp_->points.push_back(point);
+ head_ = head;
+ otherTailp_ = otherTailp;
+
+ }
+ inline ActiveTail45(ActiveTail45* otherTailp) {
+ tailp_ = otherTailp->tailp_;
+ otherTailp_ = otherTailp;
+ }
+
+ //copy constructor
+ inline ActiveTail45(const ActiveTail45& that) { (*this) = that; }
+
+ //destructor
+ inline ~ActiveTail45() {
+ destroyContents();
+ }
+
+ //assignment operator
+ inline ActiveTail45& operator=(const ActiveTail45& that) {
+ tailp_ = new PolyLine45(*(that.tailp_));
+ head_ = that.head_;
+ otherTailp_ = that.otherTailp_;
+ holesList_ = that.holesList_;
+ return *this;
+ }
+
+ //equivalence operator
+ inline bool operator==(const ActiveTail45& b) const {
+ return tailp_ == b.tailp_ && head_ == b.head_;
+ }
+
+ /**
+ * @brief get the pointer to the polyline that this is an active tail of
+ */
+ inline PolyLine45* getTail() const { return tailp_; }
+
+ /**
+ * @brief get the pointer to the polyline at the other end of the chain
+ */
+ inline PolyLine45* getOtherTail() const { return otherTailp_->tailp_; }
+
+ /**
+ * @brief get the pointer to the activetail at the other end of the chain
+ */
+ inline ActiveTail45* getOtherActiveTail() const { return otherTailp_; }
+
+ /**
+ * @brief test if another active tail is the other end of the chain
+ */
+ inline bool isOtherTail(const ActiveTail45& b) const { return &b == otherTailp_; }
+
+ /**
+ * @brief update this end of chain pointer to new polyline
+ */
+ inline ActiveTail45& updateTail(PolyLine45* newTail) { tailp_ = newTail; return *this; }
+
+ inline bool join(ActiveTail45* tail) {
+ if(tail == otherTailp_) {
+ //std::cout << "joining to other tail!\n";
+ return false;
+ }
+ if(tail->head_ == head_) {
+ //std::cout << "joining head to head!\n";
+ return false;
+ }
+ if(!tailp_) {
+ //std::cout << "joining empty tail!\n";
+ return false;
+ }
+ if(!(otherTailp_->head_)) {
+ otherTailp_->copyHoles(*tail);
+ otherTailp_->copyHoles(*this);
+ } else {
+ tail->otherTailp_->copyHoles(*this);
+ tail->otherTailp_->copyHoles(*tail);
+ }
+ PolyLine45* tail1 = tailp_;
+ PolyLine45* tail2 = tail->tailp_;
+ if(head_) std::swap(tail1, tail2);
+ tail1->points.splice(tail1->points.end(), tail2->points);
+ delete tail2;
+ otherTailp_->tailp_ = tail1;
+ tail->otherTailp_->tailp_ = tail1;
+ otherTailp_->otherTailp_ = tail->otherTailp_;
+ tail->otherTailp_->otherTailp_ = otherTailp_;
+ tailp_ = 0;
+ tail->tailp_ = 0;
+ tail->otherTailp_ = 0;
+ otherTailp_ = 0;
+ return true;
+ }
+
+ /**
+ * @brief associate a hole to this active tail by the specified policy
+ */
+ inline ActiveTail45* addHole(ActiveTail45* hole) {
+ holesList_.push_back(hole);
+ copyHoles(*hole);
+ copyHoles(*(hole->otherTailp_));
+ return this;
+ }
+
+ /**
+ * @brief get the list of holes
+ */
+ inline const std::list<ActiveTail45*>& getHoles() const { return holesList_; }
+
+ /**
+ * @brief copy holes from that to this
+ */
+ inline void copyHoles(ActiveTail45& that) { holesList_.splice(holesList_.end(), that.holesList_); }
+
+ /**
+ * @brief find out if solid to right
+ */
+ inline bool solidToRight() const { return !head_; }
+ inline bool solidToLeft() const { return head_; }
+
+ /**
+ * @brief get vertex
+ */
+ inline Point getPoint() const {
+ if(head_) return tailp_->points.front();
+ return tailp_->points.back();
+ }
+
+ /**
+ * @brief add a coordinate to the polygon at this active tail end, properly handle degenerate edges by removing redundant coordinate
+ */
+ inline void pushPoint(Point point) {
+ if(head_) {
+ //if(tailp_->points.size() < 2) {
+ // tailp_->points.push_front(point);
+ // return;
+ //}
+ typename std::list<Point>::iterator iter = tailp_->points.begin();
+ if(iter == tailp_->points.end()) {
+ tailp_->points.push_front(point);
+ return;
+ }
+ Unit firstY = (*iter).y();
+ ++iter;
+ if(iter == tailp_->points.end()) {
+ tailp_->points.push_front(point);
+ return;
+ }
+ if(iter->y() == point.y() && firstY == point.y()) {
+ --iter;
+ *iter = point;
+ } else {
+ tailp_->points.push_front(point);
+ }
+ return;
+ }
+ //if(tailp_->points.size() < 2) {
+ // tailp_->points.push_back(point);
+ // return;
+ //}
+ typename std::list<Point>::reverse_iterator iter = tailp_->points.rbegin();
+ if(iter == tailp_->points.rend()) {
+ tailp_->points.push_back(point);
+ return;
+ }
+ Unit firstY = (*iter).y();
+ ++iter;
+ if(iter == tailp_->points.rend()) {
+ tailp_->points.push_back(point);
+ return;
+ }
+ if(iter->y() == point.y() && firstY == point.y()) {
+ --iter;
+ *iter = point;
+ } else {
+ tailp_->points.push_back(point);
+ }
+ }
+
+ /**
+ * @brief joins the two chains that the two active tail tails are ends of
+ * checks for closure of figure and writes out polygons appropriately
+ * returns a handle to a hole if one is closed
+ */
+
+ template <class cT>
+ static inline ActiveTail45* joinChains(Point point, ActiveTail45* at1, ActiveTail45* at2, bool solid,
+ cT& output) {
+ if(at1->otherTailp_ == at2) {
+ //if(at2->otherTailp_ != at1) std::cout << "half closed error\n";
+ //we are closing a figure
+ at1->pushPoint(point);
+ at2->pushPoint(point);
+ if(solid) {
+ //we are closing a solid figure, write to output
+ //std::cout << "test1\n";
+ at1->copyHoles(*(at1->otherTailp_));
+ //std::cout << "test2\n";
+ //Polygon45WithHolesImpl<PolyLine45PolygonData> poly(polyData);
+ //std::cout << poly << std::endl;
+ //std::cout << "test3\n";
+ typedef typename cT::value_type pType;
+ output.push_back(pType());
+ typedef typename geometry_concept<pType>::type cType;
+ typename PolyLineByConcept<Unit, cType>::type polyData(at1);
+ assign(output.back(), polyData);
+ //std::cout << "test4\n";
+ //std::cout << "delete " << at1->otherTailp_ << std::endl;
+ //at1->print();
+ //at1->otherTailp_->print();
+ delete at1->otherTailp_;
+ //at1->print();
+ //at1->otherTailp_->print();
+ //std::cout << "test5\n";
+ //std::cout << "delete " << at1 << std::endl;
+ delete at1;
+ //std::cout << "test6\n";
+ return 0;
+ } else {
+ //we are closing a hole, return the tail end active tail of the figure
+ return at1;
+ }
+ }
+ //we are not closing a figure
+ at1->pushPoint(point);
+ at1->join(at2);
+ delete at1;
+ delete at2;
+ return 0;
+ }
+
+ inline void destroyContents() {
+ if(otherTailp_) {
+ //std::cout << "delete p " << tailp_ << std::endl;
+ if(tailp_) delete tailp_;
+ tailp_ = 0;
+ otherTailp_->otherTailp_ = 0;
+ otherTailp_->tailp_ = 0;
+ otherTailp_ = 0;
+ }
+ for(typename std::list<ActiveTail45*>::iterator itr = holesList_.begin(); itr != holesList_.end(); ++itr) {
+ //std::cout << "delete p " << (*itr) << std::endl;
+ if(*itr) {
+ if((*itr)->otherTailp_) {
+ delete (*itr)->otherTailp_;
+ (*itr)->otherTailp_ = 0;
+ }
+ delete (*itr);
+ }
+ (*itr) = 0;
+ }
+ holesList_.clear();
+ }
+
+ inline void print() {
+ std::cout << this << " " << tailp_ << " " << otherTailp_ << " " << holesList_.size() << " " << head_ << std::endl;
+ }
+
+ static inline std::pair<ActiveTail45*, ActiveTail45*> createActiveTail45sAsPair(Point point, bool solid,
+ ActiveTail45* phole, bool fractureHoles) {
+ ActiveTail45* at1;
+ ActiveTail45* at2;
+ if(phole && fractureHoles) {
+ //std::cout << "adding hole\n";
+ at1 = phole;
+ //assert solid == false, we should be creating a corner with solid below and to the left if there was a hole
+ at2 = at1->getOtherActiveTail();
+ at2->pushPoint(point);
+ at1->pushPoint(point);
+ } else {
+ at1 = new ActiveTail45(point, at2, solid);
+ at2 = new ActiveTail45(at1);
+ at1->otherTailp_ = at2;
+ at2->head_ = !solid;
+ if(phole)
+ at2->addHole(phole); //assert fractureHoles == false
+ }
+ return std::pair<ActiveTail45*, ActiveTail45*>(at1, at2);
+ }
+
+ };
+
+
+
+ class Vertex45Count {
+ public:
+ inline Vertex45Count() { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
+ inline Vertex45Count(int count) { counts[0] = counts[1] = counts[2] = counts[3] = count; }
+ inline Vertex45Count(const int& count1, const int& count2, const int& count3,
+ const int& count4) {
+ counts[0] = count1;
+ counts[1] = count2;
+ counts[2] = count3;
+ counts[3] = count4;
+ }
+ inline Vertex45Count(const Vertex45& vertex) {
+ counts[0] = counts[1] = counts[2] = counts[3] = 0;
+ (*this) += vertex;
+ }
+ inline Vertex45Count(const Vertex45Count& count) {
+ (*this) = count;
+ }
+ inline bool operator==(const Vertex45Count& count) const {
+ for(unsigned int i = 0; i < 4; ++i) {
+ if(counts[i] != count.counts[i]) return false;
+ }
+ return true;
+ }
+ inline bool operator!=(const Vertex45Count& count) const { return !((*this) == count); }
+ inline Vertex45Count& operator=(int count) {
+ counts[0] = counts[1] = counts[2] = counts[3] = count; return *this; }
+ inline Vertex45Count& operator=(const Vertex45Count& count) {
+ for(unsigned int i = 0; i < 4; ++i) {
+ counts[i] = count.counts[i];
+ }
+ return *this;
+ }
+ inline int& operator[](int index) { return counts[index]; }
+ inline int operator[](int index) const {return counts[index]; }
+ inline Vertex45Count& operator+=(const Vertex45Count& count){
+ for(unsigned int i = 0; i < 4; ++i) {
+ counts[i] += count.counts[i];
+ }
+ return *this;
+ }
+ inline Vertex45Count& operator-=(const Vertex45Count& count){
+ for(unsigned int i = 0; i < 4; ++i) {
+ counts[i] -= count.counts[i];
+ }
+ return *this;
+ }
+ inline Vertex45Count operator+(const Vertex45Count& count) const {
+ return Vertex45Count(*this)+=count;
+ }
+ inline Vertex45Count operator-(const Vertex45Count& count) const {
+ return Vertex45Count(*this)-=count;
+ }
+ inline Vertex45Count invert() const {
+ return Vertex45Count(0)-=(*this);
+ }
+ inline Vertex45Count& operator+=(const Vertex45& element){
+ counts[element.rise+1] += element.count; return *this;
+ }
+ inline bool is_45() const {
+ return counts[0] != 0 || counts[2] != 0;
+ }
+ private:
+ int counts[4];
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const Vertex45Count& c) {
+// o << c[0] << ", " << c[1] << ", ";
+// o << c[2] << ", " << c[3];
+// return o;
+// }
+
+ class Vertex45Compact {
+ public:
+ Point pt;
+ Vertex45Count count;
+ inline Vertex45Compact() {}
+ inline Vertex45Compact(const Point& point, int riseIn, int countIn) : pt(point) {
+ count[riseIn+1] = countIn;
+ }
+ inline Vertex45Compact(const Vertex45& vertex) : pt(vertex.pt) {
+ count[vertex.rise+1] = vertex.count;
+ }
+ inline Vertex45Compact(const Vertex45Compact& vertex) : pt(vertex.pt), count(vertex.count) {}
+ inline Vertex45Compact& operator=(const Vertex45Compact& vertex){
+ pt = vertex.pt; count = vertex.count; return *this; }
+ inline Vertex45Compact(const std::pair<Point, Point>& vertex) {}
+ inline Vertex45Compact& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+ inline bool operator==(const Vertex45Compact& vertex) const {
+ return pt == vertex.pt && count == vertex.count; }
+ inline bool operator!=(const Vertex45Compact& vertex) const { return !((*this) == vertex); }
+ inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+ inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
+ inline bool operator<(const Vertex45Compact& vertex) const {
+ if(pt.x() < vertex.pt.x()) return true;
+ if(pt.x() == vertex.pt.x()) {
+ return pt.y() < vertex.pt.y();
+ }
+ return false;
+ }
+ inline bool operator>(const Vertex45Compact& vertex) const { return vertex < (*this); }
+ inline bool operator<=(const Vertex45Compact& vertex) const { return !((*this) > vertex); }
+ inline bool operator>=(const Vertex45Compact& vertex) const { return !((*this) < vertex); }
+ inline bool haveVertex45(int index) const { return count[index]; }
+ inline Vertex45 operator[](int index) const { return Vertex45(pt, index-1, count[index]); }
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const Vertex45Compact& c) {
+// o << c.pt << ", " << c.count;
+// return o;
+// }
+
+ class Polygon45Formation {
+ private:
+ //definitions
+ typedef std::map<Vertex45, ActiveTail45*, lessVertex45> Polygon45FormationData;
+ typedef typename Polygon45FormationData::iterator iterator;
+ typedef typename Polygon45FormationData::const_iterator const_iterator;
+
+ //data
+ Polygon45FormationData scanData_;
+ Unit x_;
+ int justBefore_;
+ int fractureHoles_;
+ public:
+ inline Polygon45Formation() : x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(0) {
+ lessVertex45 lessElm(&x_, &justBefore_);
+ scanData_ = Polygon45FormationData(lessElm);
+ }
+ inline Polygon45Formation(bool fractureHoles) : x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(fractureHoles) {
+ lessVertex45 lessElm(&x_, &justBefore_);
+ scanData_ = Polygon45FormationData(lessElm);
+ }
+ inline Polygon45Formation(const Polygon45Formation& that) { (*this) = that; }
+ inline Polygon45Formation& operator=(const Polygon45Formation& that) {
+ x_ = that.x_;
+ justBefore_ = that.justBefore_;
+ fractureHoles_ = that.fractureHoles_;
+ lessVertex45 lessElm(&x_, &justBefore_);
+ scanData_ = Polygon45FormationData(lessElm);
+ for(const_iterator itr = that.scanData_.begin(); itr != that.scanData_.end(); ++itr){
+ scanData_.insert(scanData_.end(), *itr);
+ }
+ return *this;
+ }
+
+ //cT is an output container of Polygon45 or Polygon45WithHoles
+ //iT is an iterator over Vertex45 elements
+ //inputBegin - inputEnd is a range of sorted iT that represents
+ //one or more scanline stops worth of data
+ template <class cT, class iT>
+ void scan(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "1\n";
+ while(inputBegin != inputEnd) {
+ //std::cout << "2\n";
+ x_ = (*inputBegin).pt.x();
+ //std::cout << "SCAN FORMATION " << x_ << std::endl;
+ //std::cout << "x_ = " << x_ << std::endl;
+ //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ inputBegin = processEvent_(output, inputBegin, inputEnd);
+ }
+ }
+
+ private:
+ //functions
+ template <class cT, class cT2>
+ inline std::pair<int, ActiveTail45*> processPoint_(cT& output, cT2& elements, Point point,
+ Vertex45Count& counts, ActiveTail45** tails, Vertex45Count& incoming) {
+ //std::cout << point << std::endl;
+ //std::cout << counts[0] << " ";
+ //std::cout << counts[1] << " ";
+ //std::cout << counts[2] << " ";
+ //std::cout << counts[3] << "\n";
+ //std::cout << incoming[0] << " ";
+ //std::cout << incoming[1] << " ";
+ //std::cout << incoming[2] << " ";
+ //std::cout << incoming[3] << "\n";
+ //join any closing solid corners
+ ActiveTail45* returnValue = 0;
+ int returnCount = 0;
+ for(int i = 0; i < 3; ++i) {
+ //std::cout << i << std::endl;
+ if(counts[i] == -1) {
+ //std::cout << "fixed i\n";
+ for(int j = i + 1; j < 4; ++j) {
+ //std::cout << j << std::endl;
+ if(counts[j]) {
+ if(counts[j] == 1) {
+ //std::cout << "case1: " << i << " " << j << std::endl;
+ //if a figure is closed it will be written out by this function to output
+ ActiveTail45::joinChains(point, tails[i], tails[j], true, output);
+ counts[i] = 0;
+ counts[j] = 0;
+ tails[i] = 0;
+ tails[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+ //find any pairs of incoming edges that need to create pair for leading solid
+ //std::cout << "checking case2\n";
+ for(int i = 0; i < 3; ++i) {
+ //std::cout << i << std::endl;
+ if(incoming[i] == 1) {
+ //std::cout << "fixed i\n";
+ for(int j = i + 1; j < 4; ++j) {
+ //std::cout << j << std::endl;
+ if(incoming[j]) {
+ if(incoming[j] == -1) {
+ //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "creating active tail pair\n";
+ std::pair<ActiveTail45*, ActiveTail45*> tailPair =
+ ActiveTail45::createActiveTail45sAsPair(point, true, 0, fractureHoles_);
+ //tailPair.first->print();
+ //tailPair.second->print();
+ if(j == 3) {
+ //vertical active tail becomes return value
+ returnValue = tailPair.first;
+ returnCount = 1;
+ } else {
+ Vertex45 vertex(point, i -1, incoming[i]);
+ //std::cout << "new element " << j-1 << " " << -1 << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, -1), tailPair.first));
+ }
+ //std::cout << "new element " << i-1 << " " << 1 << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, 1), tailPair.second));
+ incoming[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ //find any active tail that needs to pass through to an incoming edge
+ //we expect to find no more than two pass through
+
+ //find pass through with solid on top
+ //std::cout << "checking case 3\n";
+ for(int i = 0; i < 4; ++i) {
+ //std::cout << i << std::endl;
+ if(counts[i] != 0) {
+ if(counts[i] == 1) {
+ //std::cout << "fixed i\n";
+ for(int j = 3; j >= 0; --j) {
+ if(incoming[j] != 0) {
+ if(incoming[j] == 1) {
+ //std::cout << "case3: " << i << " " << j << std::endl;
+ //tails[i]->print();
+ //pass through solid on top
+ tails[i]->pushPoint(point);
+ //std::cout << "after push\n";
+ if(j == 3) {
+ returnValue = tails[i];
+ returnCount = -1;
+ } else {
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tails[i]));
+ }
+ tails[i] = 0;
+ counts[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+ //std::cout << "checking case 4\n";
+ //find pass through with solid on bottom
+ for(int i = 3; i >= 0; --i) {
+ if(counts[i] != 0) {
+ if(counts[i] == -1) {
+ for(int j = 0; j < 4; ++j) {
+ if(incoming[j] != 0) {
+ if(incoming[j] == -1) {
+ //std::cout << "case4: " << i << " " << j << std::endl;
+ //pass through solid on bottom
+ tails[i]->pushPoint(point);
+ if(j == 3) {
+ returnValue = tails[i];
+ returnCount = 1;
+ } else {
+ //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tails[i]));
+ }
+ tails[i] = 0;
+ counts[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ //find the end of a hole or the beginning of a hole
+
+ //find end of a hole
+ for(int i = 0; i < 3; ++i) {
+ if(counts[i] != 0) {
+ for(int j = i+1; j < 4; ++j) {
+ if(counts[j] != 0) {
+ //std::cout << "case5: " << i << " " << j << std::endl;
+ //we are ending a hole and may potentially close a figure and have to handle the hole
+ returnValue = ActiveTail45::joinChains(point, tails[i], tails[j], false, output);
+ tails[i] = 0;
+ tails[j] = 0;
+ counts[i] = 0;
+ counts[j] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ //find beginning of a hole
+ for(int i = 0; i < 3; ++i) {
+ if(incoming[i] != 0) {
+ for(int j = i+1; j < 4; ++j) {
+ if(incoming[j] != 0) {
+ //std::cout << "case6: " << i << " " << j << std::endl;
+ //we are beginning a empty space
+ ActiveTail45* holep = 0;
+ if(counts[3] == 0) holep = tails[3];
+ std::pair<ActiveTail45*, ActiveTail45*> tailPair =
+ ActiveTail45::createActiveTail45sAsPair(point, false, holep, fractureHoles_);
+ if(j == 3) {
+ returnValue = tailPair.first;
+ returnCount = -1;
+ } else {
+ //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tailPair.first));
+ }
+ //std::cout << "new element " << i-1 << " " << incoming[i] << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, incoming[i]), tailPair.second));
+ incoming[i] = 0;
+ incoming[j] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ //assert that tails, counts and incoming are all null
+ return std::pair<int, ActiveTail45*>(returnCount, returnValue);
+ }
+
+ template <class cT, class iT>
+ inline iT processEvent_(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "processEvent_\n";
+ justBefore_ = true;
+ //collect up all elements from the tree that are at the y
+ //values of events in the input queue
+ //create vector of new elements to add into tree
+ ActiveTail45* verticalTail = 0;
+ int verticalCount = 0;
+ iT currentIter = inputBegin;
+ std::vector<iterator> elementIters;
+ std::vector<std::pair<Vertex45, ActiveTail45*> > elements;
+ while(currentIter != inputEnd && currentIter->pt.x() == x_) {
+ //std::cout << "loop\n";
+ Unit currentY = (*currentIter).pt.y();
+ iterator iter = lookUp_(currentY);
+ //int counts[4] = {0, 0, 0, 0};
+ Vertex45Count counts;
+ ActiveTail45* tails[4] = {0, 0, 0, verticalTail};
+ //std::cout << "finding elements in tree\n";
+ while(iter != scanData_.end() &&
+ iter->first.evalAtX(x_) == currentY) {
+ //std::cout << "loop2\n";
+ elementIters.push_back(iter);
+ int index = iter->first.rise + 1;
+ //std::cout << index << " " << iter->first.count << std::endl;
+ counts[index] = iter->first.count;
+ tails[index] = iter->second;
+ ++iter;
+ }
+ //int incoming[4] = {0, 0, 0, 0};
+ Vertex45Count incoming;
+ //std::cout << "aggregating\n";
+ do {
+ //std::cout << "loop3\n";
+ Vertex45Compact currentVertex(*currentIter);
+ incoming += currentVertex.count;
+ ++currentIter;
+ } while(currentIter != inputEnd && currentIter->pt.y() == currentY &&
+ currentIter->pt.x() == x_);
+ //now counts and tails have the data from the left and
+ //incoming has the data from the right at this point
+ //cancel out any end points
+ //std::cout << counts[0] << " ";
+ //std::cout << counts[1] << " ";
+ //std::cout << counts[2] << " ";
+ //std::cout << counts[3] << "\n";
+ //std::cout << incoming[0] << " ";
+ //std::cout << incoming[1] << " ";
+ //std::cout << incoming[2] << " ";
+ //std::cout << incoming[3] << "\n";
+ if(verticalTail) {
+ counts[3] = -verticalCount;
+ }
+ incoming[3] *= -1;
+ for(unsigned int i = 0; i < 4; ++i) incoming[i] += counts[i];
+ //std::cout << "calling processPoint_\n";
+ std::pair<int, ActiveTail45*> result = processPoint_(output, elements, Point(x_, currentY), counts, tails, incoming);
+ verticalCount = result.first;
+ verticalTail = result.second;
+ //if(verticalTail) std::cout << "have vertical tail\n";
+ //std::cout << "verticalCount: " << verticalCount << std::endl;
+ if(verticalTail && !verticalCount) {
+ //we got a hole out of the point we just processed
+ //iter is still at the next y element above the current y value in the tree
+ //std::cout << "checking whether ot handle hole\n";
+ if(currentIter == inputEnd ||
+ currentIter->pt.x() != x_ ||
+ currentIter->pt.y() >= iter->first.evalAtX(x_)) {
+ //std::cout << "handle hole here\n";
+ if(fractureHoles_) {
+ //std::cout << "fracture hole here\n";
+ //we need to handle the hole now and not at the next input vertex
+ ActiveTail45* at = iter->second;
+ Point point(x_, iter->first.evalAtX(x_));
+ verticalTail->getOtherActiveTail()->pushPoint(point);
+ iter->second = verticalTail->getOtherActiveTail();
+ at->pushPoint(point);
+ verticalTail->join(at);
+ delete at;
+ delete verticalTail;
+ verticalTail = 0;
+ } else {
+ //std::cout << "push hole onto list\n";
+ iter->second->addHole(verticalTail);
+ verticalTail = 0;
+ }
+ }
+ }
+ }
+ //std::cout << "erasing\n";
+ //erase all elements from the tree
+ for(typename std::vector<iterator>::iterator iter = elementIters.begin();
+ iter != elementIters.end(); ++iter) {
+ //std::cout << "erasing loop\n";
+ scanData_.erase(*iter);
+ }
+ //switch comparison tie breaking policy
+ justBefore_ = false;
+ //add new elements into tree
+ //std::cout << "inserting\n";
+ for(typename std::vector<std::pair<Vertex45, ActiveTail45*> >::iterator iter = elements.begin();
+ iter != elements.end(); ++iter) {
+ //std::cout << "inserting loop\n";
+ scanData_.insert(scanData_.end(), *iter);
+ }
+ //std::cout << "end processEvent\n";
+ return currentIter;
+ }
+
+ inline iterator lookUp_(Unit y){
+ //if just before then we need to look from 1 not -1
+ return scanData_.lower_bound(Vertex45(Point(x_, y), -1+2*justBefore_, 0));
+ }
+
+ };
+
+ static inline bool testPolygon45FormationRect() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(true);
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 2, 1));
+ data.push_back(Vertex45(Point(10, 10), 0, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygon45FormationP1() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(true);
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 1, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 1, -1));
+ data.push_back(Vertex45(Point(10, 10), 1, -1));
+ data.push_back(Vertex45(Point(10, 10), 2, -1));
+ data.push_back(Vertex45(Point(10, 20), 2, 1));
+ data.push_back(Vertex45(Point(10, 20), 1, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+ //polygon45set class
+
+ static inline bool testPolygon45FormationP2() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(true);
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 1, -1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 1, 1));
+ data.push_back(Vertex45(Point(10, 10), 1, 1));
+ data.push_back(Vertex45(Point(10, 10), 0, -1));
+ data.push_back(Vertex45(Point(20, 10), 1, -1));
+ data.push_back(Vertex45(Point(20, 10), 0, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+ //polygon45set class
+
+ static inline bool testPolygon45FormationStar1() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(true);
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ // result == 0 8 -1 1
+ data.push_back(Vertex45(Point(0, 8), -1, 1));
+ // result == 0 8 1 -1
+ data.push_back(Vertex45(Point(0, 8), 1, -1));
+ // result == 4 0 1 1
+ data.push_back(Vertex45(Point(4, 0), 1, 1));
+ // result == 4 0 2 1
+ data.push_back(Vertex45(Point(4, 0), 2, 1));
+ // result == 4 4 2 -1
+ data.push_back(Vertex45(Point(4, 4), 2, -1));
+ // result == 4 4 -1 -1
+ data.push_back(Vertex45(Point(4, 4), -1, -1));
+ // result == 4 12 1 1
+ data.push_back(Vertex45(Point(4, 12), 1, 1));
+ // result == 4 12 2 1
+ data.push_back(Vertex45(Point(4, 12), 2, 1));
+ // result == 4 16 2 -1
+ data.push_back(Vertex45(Point(4, 16), 2, 1));
+ // result == 4 16 -1 -1
+ data.push_back(Vertex45(Point(4, 16), -1, -1));
+ // result == 6 2 1 -1
+ data.push_back(Vertex45(Point(6, 2), 1, -1));
+ // result == 6 14 -1 1
+ data.push_back(Vertex45(Point(6, 14), -1, 1));
+ // result == 6 2 -1 1
+ data.push_back(Vertex45(Point(6, 2), -1, 1));
+ // result == 6 14 1 -1
+ data.push_back(Vertex45(Point(6, 14), 1, -1));
+ // result == 8 0 -1 -1
+ data.push_back(Vertex45(Point(8, 0), -1, -1));
+ // result == 8 0 2 -1
+ data.push_back(Vertex45(Point(8, 0), 2, -1));
+ // result == 8 4 2 1
+ data.push_back(Vertex45(Point(8, 4), 2, 1));
+ // result == 8 4 1 1
+ data.push_back(Vertex45(Point(8, 4), 1, 1));
+ // result == 8 12 -1 -1
+ data.push_back(Vertex45(Point(8, 12), -1, -1));
+ // result == 8 12 2 -1
+ data.push_back(Vertex45(Point(8, 12), 2, -1));
+ // result == 8 16 2 1
+ data.push_back(Vertex45(Point(8, 16), 2, 1));
+ // result == 8 16 1 1
+ data.push_back(Vertex45(Point(8, 16), 1, 1));
+ // result == 12 8 1 -1
+ data.push_back(Vertex45(Point(12, 8), 1, -1));
+ // result == 12 8 -1 1
+ data.push_back(Vertex45(Point(12, 8), -1, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygon45FormationStar2() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(true);
+ std::vector<Polygon45> polys;
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,4), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,4), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,12), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(0,8), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,8), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,0), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+
+ std::sort(result.begin(), result.end());
+ pf.scan(polys, result.begin(), result.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygon45FormationStarHole1() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(true);
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ // result == 0 8 -1 1
+ data.push_back(Vertex45(Point(0, 8), -1, 1));
+ // result == 0 8 1 -1
+ data.push_back(Vertex45(Point(0, 8), 1, -1));
+ // result == 4 0 1 1
+ data.push_back(Vertex45(Point(4, 0), 1, 1));
+ // result == 4 0 2 1
+ data.push_back(Vertex45(Point(4, 0), 2, 1));
+ // result == 4 4 2 -1
+ data.push_back(Vertex45(Point(4, 4), 2, -1));
+ // result == 4 4 -1 -1
+ data.push_back(Vertex45(Point(4, 4), -1, -1));
+ // result == 4 12 1 1
+ data.push_back(Vertex45(Point(4, 12), 1, 1));
+ // result == 4 12 2 1
+ data.push_back(Vertex45(Point(4, 12), 2, 1));
+ // result == 4 16 2 -1
+ data.push_back(Vertex45(Point(4, 16), 2, 1));
+ // result == 4 16 -1 -1
+ data.push_back(Vertex45(Point(4, 16), -1, -1));
+ // result == 6 2 1 -1
+ data.push_back(Vertex45(Point(6, 2), 1, -1));
+ // result == 6 14 -1 1
+ data.push_back(Vertex45(Point(6, 14), -1, 1));
+ // result == 6 2 -1 1
+ data.push_back(Vertex45(Point(6, 2), -1, 1));
+ // result == 6 14 1 -1
+ data.push_back(Vertex45(Point(6, 14), 1, -1));
+ // result == 8 0 -1 -1
+ data.push_back(Vertex45(Point(8, 0), -1, -1));
+ // result == 8 0 2 -1
+ data.push_back(Vertex45(Point(8, 0), 2, -1));
+ // result == 8 4 2 1
+ data.push_back(Vertex45(Point(8, 4), 2, 1));
+ // result == 8 4 1 1
+ data.push_back(Vertex45(Point(8, 4), 1, 1));
+ // result == 8 12 -1 -1
+ data.push_back(Vertex45(Point(8, 12), -1, -1));
+ // result == 8 12 2 -1
+ data.push_back(Vertex45(Point(8, 12), 2, -1));
+ // result == 8 16 2 1
+ data.push_back(Vertex45(Point(8, 16), 2, 1));
+ // result == 8 16 1 1
+ data.push_back(Vertex45(Point(8, 16), 1, 1));
+ // result == 12 8 1 -1
+ data.push_back(Vertex45(Point(12, 8), 1, -1));
+ // result == 12 8 -1 1
+ data.push_back(Vertex45(Point(12, 8), -1, 1));
+
+ data.push_back(Vertex45(Point(6, 4), 1, -1));
+ data.push_back(Vertex45(Point(6, 4), 2, -1));
+ data.push_back(Vertex45(Point(6, 8), -1, 1));
+ data.push_back(Vertex45(Point(6, 8), 2, 1));
+ data.push_back(Vertex45(Point(8, 6), -1, -1));
+ data.push_back(Vertex45(Point(8, 6), 1, 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygon45FormationStarHole2() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(false);
+ std::vector<Polygon45WithHoles> polys;
+ std::vector<Vertex45> data;
+ // result == 0 8 -1 1
+ data.push_back(Vertex45(Point(0, 8), -1, 1));
+ // result == 0 8 1 -1
+ data.push_back(Vertex45(Point(0, 8), 1, -1));
+ // result == 4 0 1 1
+ data.push_back(Vertex45(Point(4, 0), 1, 1));
+ // result == 4 0 2 1
+ data.push_back(Vertex45(Point(4, 0), 2, 1));
+ // result == 4 4 2 -1
+ data.push_back(Vertex45(Point(4, 4), 2, -1));
+ // result == 4 4 -1 -1
+ data.push_back(Vertex45(Point(4, 4), -1, -1));
+ // result == 4 12 1 1
+ data.push_back(Vertex45(Point(4, 12), 1, 1));
+ // result == 4 12 2 1
+ data.push_back(Vertex45(Point(4, 12), 2, 1));
+ // result == 4 16 2 -1
+ data.push_back(Vertex45(Point(4, 16), 2, 1));
+ // result == 4 16 -1 -1
+ data.push_back(Vertex45(Point(4, 16), -1, -1));
+ // result == 6 2 1 -1
+ data.push_back(Vertex45(Point(6, 2), 1, -1));
+ // result == 6 14 -1 1
+ data.push_back(Vertex45(Point(6, 14), -1, 1));
+ // result == 6 2 -1 1
+ data.push_back(Vertex45(Point(6, 2), -1, 1));
+ // result == 6 14 1 -1
+ data.push_back(Vertex45(Point(6, 14), 1, -1));
+ // result == 8 0 -1 -1
+ data.push_back(Vertex45(Point(8, 0), -1, -1));
+ // result == 8 0 2 -1
+ data.push_back(Vertex45(Point(8, 0), 2, -1));
+ // result == 8 4 2 1
+ data.push_back(Vertex45(Point(8, 4), 2, 1));
+ // result == 8 4 1 1
+ data.push_back(Vertex45(Point(8, 4), 1, 1));
+ // result == 8 12 -1 -1
+ data.push_back(Vertex45(Point(8, 12), -1, -1));
+ // result == 8 12 2 -1
+ data.push_back(Vertex45(Point(8, 12), 2, -1));
+ // result == 8 16 2 1
+ data.push_back(Vertex45(Point(8, 16), 2, 1));
+ // result == 8 16 1 1
+ data.push_back(Vertex45(Point(8, 16), 1, 1));
+ // result == 12 8 1 -1
+ data.push_back(Vertex45(Point(12, 8), 1, -1));
+ // result == 12 8 -1 1
+ data.push_back(Vertex45(Point(12, 8), -1, 1));
+
+ data.push_back(Vertex45(Point(6, 4), 1, -1));
+ data.push_back(Vertex45(Point(6, 4), 2, -1));
+ data.push_back(Vertex45(Point(6, 12), -1, 1));
+ data.push_back(Vertex45(Point(6, 12), 2, 1));
+ data.push_back(Vertex45(Point(10, 8), -1, -1));
+ data.push_back(Vertex45(Point(10, 8), 1, 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygon45Formation() {
+ std::cout << "testing polygon formation\n";
+ Polygon45Formation pf(false);
+ std::vector<Polygon45WithHoles> polys;
+ std::vector<Vertex45> data;
+
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 100), 2, -1));
+ data.push_back(Vertex45(Point(0, 100), 0, -1));
+ data.push_back(Vertex45(Point(100, 0), 0, -1));
+ data.push_back(Vertex45(Point(100, 0), 2, -1));
+ data.push_back(Vertex45(Point(100, 100), 2, 1));
+ data.push_back(Vertex45(Point(100, 100), 0, 1));
+
+ data.push_back(Vertex45(Point(2, 2), 0, -1));
+ data.push_back(Vertex45(Point(2, 2), 2, -1));
+ data.push_back(Vertex45(Point(2, 10), 2, 1));
+ data.push_back(Vertex45(Point(2, 10), 0, 1));
+ data.push_back(Vertex45(Point(10, 2), 0, 1));
+ data.push_back(Vertex45(Point(10, 2), 2, 1));
+ data.push_back(Vertex45(Point(10, 10), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 0, -1));
+
+ data.push_back(Vertex45(Point(2, 12), 0, -1));
+ data.push_back(Vertex45(Point(2, 12), 2, -1));
+ data.push_back(Vertex45(Point(2, 22), 2, 1));
+ data.push_back(Vertex45(Point(2, 22), 0, 1));
+ data.push_back(Vertex45(Point(10, 12), 0, 1));
+ data.push_back(Vertex45(Point(10, 12), 2, 1));
+ data.push_back(Vertex45(Point(10, 22), 2, -1));
+ data.push_back(Vertex45(Point(10, 22), 0, -1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+
+ class Polygon45Tiling {
+ private:
+ //definitions
+ typedef std::map<Vertex45, ActiveTail45*, lessVertex45> Polygon45FormationData;
+ typedef typename Polygon45FormationData::iterator iterator;
+ typedef typename Polygon45FormationData::const_iterator const_iterator;
+
+ //data
+ Polygon45FormationData scanData_;
+ Unit x_;
+ int justBefore_;
+ public:
+ inline Polygon45Tiling() : x_((std::numeric_limits<Unit>::min())), justBefore_(false) {
+ lessVertex45 lessElm(&x_, &justBefore_);
+ scanData_ = Polygon45FormationData(lessElm);
+ }
+ inline Polygon45Tiling(const Polygon45Tiling& that) { (*this) = that; }
+ inline Polygon45Tiling& operator=(const Polygon45Tiling& that) {
+ x_ = that.x_;
+ justBefore_ = that.justBefore_;
+ lessVertex45 lessElm(&x_, &justBefore_);
+ scanData_ = Polygon45FormationData(lessElm);
+ for(const_iterator itr = that.scanData_.begin(); itr != that.scanData_.end(); ++itr){
+ scanData_.insert(scanData_.end(), *itr);
+ }
+ return *this;
+ }
+
+ //cT is an output container of Polygon45 or Polygon45WithHoles
+ //iT is an iterator over Vertex45 elements
+ //inputBegin - inputEnd is a range of sorted iT that represents
+ //one or more scanline stops worth of data
+ template <class cT, class iT>
+ void scan(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "1\n";
+ while(inputBegin != inputEnd) {
+ //std::cout << "2\n";
+ x_ = (*inputBegin).pt.x();
+ //std::cout << "SCAN FORMATION " << x_ << std::endl;
+ //std::cout << "x_ = " << x_ << std::endl;
+ //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ inputBegin = processEvent_(output, inputBegin, inputEnd);
+ }
+ }
+
+ private:
+ //functions
+
+ inline void getVerticalPair_(std::pair<ActiveTail45*, ActiveTail45*>& verticalPair,
+ iterator previter) {
+ ActiveTail45* iterTail = (*previter).second;
+ Point prevPoint(x_, previter->first.evalAtX(x_));
+ iterTail->pushPoint(prevPoint);
+ std::pair<ActiveTail45*, ActiveTail45*> tailPair =
+ ActiveTail45::createActiveTail45sAsPair(prevPoint, true, 0, false);
+ verticalPair.first = iterTail;
+ verticalPair.second = tailPair.first;
+ (*previter).second = tailPair.second;
+ }
+
+ template <class cT, class cT2>
+ inline std::pair<int, ActiveTail45*> processPoint_(cT& output, cT2& elements,
+ std::pair<ActiveTail45*, ActiveTail45*>& verticalPair,
+ iterator previter, Point point,
+ Vertex45Count& counts, ActiveTail45** tails, Vertex45Count& incoming) {
+ //std::cout << point << std::endl;
+ //std::cout << counts[0] << " ";
+ //std::cout << counts[1] << " ";
+ //std::cout << counts[2] << " ";
+ //std::cout << counts[3] << "\n";
+ //std::cout << incoming[0] << " ";
+ //std::cout << incoming[1] << " ";
+ //std::cout << incoming[2] << " ";
+ //std::cout << incoming[3] << "\n";
+ //join any closing solid corners
+ ActiveTail45* returnValue = 0;
+ std::pair<ActiveTail45*, ActiveTail45*> verticalPairOut;
+ verticalPairOut.first = 0;
+ verticalPairOut.second = 0;
+ int returnCount = 0;
+ for(int i = 0; i < 3; ++i) {
+ //std::cout << i << std::endl;
+ if(counts[i] == -1) {
+ //std::cout << "fixed i\n";
+ for(int j = i + 1; j < 4; ++j) {
+ //std::cout << j << std::endl;
+ if(counts[j]) {
+ if(counts[j] == 1) {
+ //std::cout << "case1: " << i << " " << j << std::endl;
+ //if a figure is closed it will be written out by this function to output
+ ActiveTail45::joinChains(point, tails[i], tails[j], true, output);
+ counts[i] = 0;
+ counts[j] = 0;
+ tails[i] = 0;
+ tails[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+ //find any pairs of incoming edges that need to create pair for leading solid
+ //std::cout << "checking case2\n";
+ for(int i = 0; i < 3; ++i) {
+ //std::cout << i << std::endl;
+ if(incoming[i] == 1) {
+ //std::cout << "fixed i\n";
+ for(int j = i + 1; j < 4; ++j) {
+ //std::cout << j << std::endl;
+ if(incoming[j]) {
+ if(incoming[j] == -1) {
+ //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "creating active tail pair\n";
+ std::pair<ActiveTail45*, ActiveTail45*> tailPair =
+ ActiveTail45::createActiveTail45sAsPair(point, true, 0, false);
+ //tailPair.first->print();
+ //tailPair.second->print();
+ if(j == 3) {
+ //vertical active tail becomes return value
+ returnValue = tailPair.first;
+ returnCount = 1;
+ } else {
+ Vertex45 vertex(point, i -1, incoming[i]);
+ //std::cout << "new element " << j-1 << " " << -1 << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, -1), tailPair.first));
+ }
+ //std::cout << "new element " << i-1 << " " << 1 << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, 1), tailPair.second));
+ incoming[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ //find any active tail that needs to pass through to an incoming edge
+ //we expect to find no more than two pass through
+
+ //find pass through with solid on top
+ //std::cout << "checking case 3\n";
+ for(int i = 0; i < 4; ++i) {
+ //std::cout << i << std::endl;
+ if(counts[i] != 0) {
+ if(counts[i] == 1) {
+ //std::cout << "fixed i\n";
+ for(int j = 3; j >= 0; --j) {
+ if(incoming[j] != 0) {
+ if(incoming[j] == 1) {
+ //std::cout << "case3: " << i << " " << j << std::endl;
+ //tails[i]->print();
+ //pass through solid on top
+ if(i != 3)
+ tails[i]->pushPoint(point);
+ //std::cout << "after push\n";
+ if(j == 3) {
+ returnValue = tails[i];
+ returnCount = -1;
+ } else {
+ verticalPairOut.first = tails[i];
+ std::pair<ActiveTail45*, ActiveTail45*> tailPair =
+ ActiveTail45::createActiveTail45sAsPair(point, true, 0, false);
+ verticalPairOut.second = tailPair.first;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]),
+ tailPair.second));
+ }
+ tails[i] = 0;
+ counts[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+ //std::cout << "checking case 4\n";
+ //find pass through with solid on bottom
+ for(int i = 3; i >= 0; --i) {
+ if(counts[i] != 0) {
+ if(counts[i] == -1) {
+ for(int j = 0; j < 4; ++j) {
+ if(incoming[j] != 0) {
+ if(incoming[j] == -1) {
+ //std::cout << "case4: " << i << " " << j << std::endl;
+ //pass through solid on bottom
+ if(i == 3) {
+ //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ if(j == 3) {
+ returnValue = tails[i];
+ returnCount = 1;
+ } else {
+ tails[i]->pushPoint(point);
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tails[i]));
+ }
+ } else if(j == 3) {
+ if(verticalPair.first == 0) {
+ getVerticalPair_(verticalPair, previter);
+ }
+ ActiveTail45::joinChains(point, tails[i], verticalPair.first, true, output);
+ returnValue = verticalPair.second;
+ returnCount = 1;
+ } else {
+ if(verticalPair.first == 0) {
+ getVerticalPair_(verticalPair, previter);
+ }
+ ActiveTail45::joinChains(point, tails[i], verticalPair.first, true, output);
+ verticalPair.second->pushPoint(point);
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]),
+ verticalPair.second));
+ }
+ tails[i] = 0;
+ counts[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ //find the end of a hole or the beginning of a hole
+
+ //find end of a hole
+ for(int i = 0; i < 3; ++i) {
+ if(counts[i] != 0) {
+ for(int j = i+1; j < 4; ++j) {
+ if(counts[j] != 0) {
+ //std::cout << "case5: " << i << " " << j << std::endl;
+ //we are ending a hole and may potentially close a figure and have to handle the hole
+ tails[i]->pushPoint(point);
+ verticalPairOut.first = tails[i];
+ if(j == 3) {
+ verticalPairOut.second = tails[j];
+ } else {
+ if(verticalPair.first == 0) {
+ getVerticalPair_(verticalPair, previter);
+ }
+ ActiveTail45::joinChains(point, tails[j], verticalPair.first, true, output);
+ verticalPairOut.second = verticalPair.second;
+ }
+ tails[i] = 0;
+ tails[j] = 0;
+ counts[i] = 0;
+ counts[j] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ //find beginning of a hole
+ for(int i = 0; i < 3; ++i) {
+ if(incoming[i] != 0) {
+ for(int j = i+1; j < 4; ++j) {
+ if(incoming[j] != 0) {
+ //std::cout << "case6: " << i << " " << j << std::endl;
+ //we are beginning a empty space
+ if(verticalPair.first == 0) {
+ getVerticalPair_(verticalPair, previter);
+ }
+ verticalPair.second->pushPoint(point);
+ if(j == 3) {
+ returnValue = verticalPair.first;
+ returnCount = -1;
+ } else {
+ std::pair<ActiveTail45*, ActiveTail45*> tailPair =
+ ActiveTail45::createActiveTail45sAsPair(point, true, 0, false);
+ //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, j -1, incoming[j]), tailPair.second));
+ verticalPairOut.second = tailPair.first;
+ verticalPairOut.first = verticalPair.first;
+ }
+ //std::cout << "new element " << i-1 << " " << incoming[i] << std::endl;
+ elements.push_back(std::pair<Vertex45, ActiveTail45*>(Vertex45(point, i -1, incoming[i]), verticalPair.second));
+ incoming[i] = 0;
+ incoming[j] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ verticalPair = verticalPairOut;
+ //assert that verticalPair is either both null, or neither null
+ //assert that returnValue is null if verticalPair is not null
+ //assert that tails, counts and incoming are all null
+ return std::pair<int, ActiveTail45*>(returnCount, returnValue);
+ }
+
+ template <class cT, class iT>
+ inline iT processEvent_(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "processEvent_\n";
+ justBefore_ = true;
+ //collect up all elements from the tree that are at the y
+ //values of events in the input queue
+ //create vector of new elements to add into tree
+ ActiveTail45* verticalTail = 0;
+ std::pair<ActiveTail45*, ActiveTail45*> verticalPair;
+ verticalPair.first = 0;
+ verticalPair.second = 0;
+ int verticalCount = 0;
+ iT currentIter = inputBegin;
+ std::vector<iterator> elementIters;
+ std::vector<std::pair<Vertex45, ActiveTail45*> > elements;
+ while(currentIter != inputEnd && currentIter->pt.x() == x_) {
+ //std::cout << "loop\n";
+ Unit currentY = (*currentIter).pt.y();
+ iterator iter = lookUp_(currentY);
+ //int counts[4] = {0, 0, 0, 0};
+ Vertex45Count counts;
+ ActiveTail45* tails[4] = {0, 0, 0, verticalTail};
+ //std::cout << "finding elements in tree\n";
+ iterator previter = iter;
+ if(previter != scanData_.end() &&
+ previter->first.evalAtX(x_) >= currentY &&
+ previter != scanData_.begin())
+ --previter;
+ while(iter != scanData_.end() &&
+ iter->first.evalAtX(x_) == currentY) {
+ //std::cout << "loop2\n";
+ elementIters.push_back(iter);
+ int index = iter->first.rise + 1;
+ //std::cout << index << " " << iter->first.count << std::endl;
+ counts[index] = iter->first.count;
+ tails[index] = iter->second;
+ ++iter;
+ }
+ //int incoming[4] = {0, 0, 0, 0};
+ Vertex45Count incoming;
+ //std::cout << "aggregating\n";
+ do {
+ //std::cout << "loop3\n";
+ Vertex45Compact currentVertex(*currentIter);
+ incoming += currentVertex.count;
+ ++currentIter;
+ } while(currentIter != inputEnd && currentIter->pt.y() == currentY &&
+ currentIter->pt.x() == x_);
+ //now counts and tails have the data from the left and
+ //incoming has the data from the right at this point
+ //cancel out any end points
+ //std::cout << counts[0] << " ";
+ //std::cout << counts[1] << " ";
+ //std::cout << counts[2] << " ";
+ //std::cout << counts[3] << "\n";
+ //std::cout << incoming[0] << " ";
+ //std::cout << incoming[1] << " ";
+ //std::cout << incoming[2] << " ";
+ //std::cout << incoming[3] << "\n";
+ if(verticalTail) {
+ counts[3] = -verticalCount;
+ }
+ incoming[3] *= -1;
+ for(unsigned int i = 0; i < 4; ++i) incoming[i] += counts[i];
+ //std::cout << "calling processPoint_\n";
+ std::pair<int, ActiveTail45*> result = processPoint_(output, elements, verticalPair, previter,
+ Point(x_, currentY), counts, tails, incoming);
+ verticalCount = result.first;
+ verticalTail = result.second;
+ if(verticalPair.first != 0 && iter != scanData_.end() &&
+ (currentIter == inputEnd || currentIter->pt.x() != x_ ||
+ currentIter->pt.y() > (*iter).first.evalAtX(x_))) {
+ //splice vertical pair into edge above
+ ActiveTail45* tailabove = (*iter).second;
+ Point point(x_, (*iter).first.evalAtX(x_));
+ verticalPair.second->pushPoint(point);
+ ActiveTail45::joinChains(point, tailabove, verticalPair.first, true, output);
+ (*iter).second = verticalPair.second;
+ verticalPair.first = 0;
+ verticalPair.second = 0;
+ }
+ }
+ //std::cout << "erasing\n";
+ //erase all elements from the tree
+ for(typename std::vector<iterator>::iterator iter = elementIters.begin();
+ iter != elementIters.end(); ++iter) {
+ //std::cout << "erasing loop\n";
+ scanData_.erase(*iter);
+ }
+ //switch comparison tie breaking policy
+ justBefore_ = false;
+ //add new elements into tree
+ //std::cout << "inserting\n";
+ for(typename std::vector<std::pair<Vertex45, ActiveTail45*> >::iterator iter = elements.begin();
+ iter != elements.end(); ++iter) {
+ //std::cout << "inserting loop\n";
+ scanData_.insert(scanData_.end(), *iter);
+ }
+ //std::cout << "end processEvent\n";
+ return currentIter;
+ }
+
+ inline iterator lookUp_(Unit y){
+ //if just before then we need to look from 1 not -1
+ return scanData_.lower_bound(Vertex45(Point(x_, y), -1+2*justBefore_, 0));
+ }
+
+ };
+
+ static inline bool testPolygon45TilingRect() {
+ std::cout << "testing polygon tiling\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 2, 1));
+ data.push_back(Vertex45(Point(10, 10), 0, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingP1() {
+ std::cout << "testing polygon tiling\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 1, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 1, -1));
+ data.push_back(Vertex45(Point(10, 10), 1, -1));
+ data.push_back(Vertex45(Point(10, 10), 2, -1));
+ data.push_back(Vertex45(Point(10, 20), 2, 1));
+ data.push_back(Vertex45(Point(10, 20), 1, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingP2() {
+ std::cout << "testing polygon tiling\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 1, -1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 1, 1));
+ data.push_back(Vertex45(Point(10, 10), 1, 1));
+ data.push_back(Vertex45(Point(10, 10), 0, -1));
+ data.push_back(Vertex45(Point(20, 10), 1, -1));
+ data.push_back(Vertex45(Point(20, 10), 0, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingP3() {
+ std::cout << "testing polygon tiling\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 0, -1));
+ data.push_back(Vertex45(Point(20, 0), 0, -1));
+ data.push_back(Vertex45(Point(20, 0), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 1, -1));
+ data.push_back(Vertex45(Point(10, 10), 0, 1));
+ data.push_back(Vertex45(Point(20, 20), 1, 1));
+ data.push_back(Vertex45(Point(20, 20), 2, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingP4() {
+ std::cout << "testing polygon tiling p4\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), -1, 1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(20, 10), 2, 1));
+ data.push_back(Vertex45(Point(20, 10), 0, 1));
+ data.push_back(Vertex45(Point(20, -10), -1, -1));
+ data.push_back(Vertex45(Point(20, -10), 2, -1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingP5() {
+ std::cout << "testing polygon tiling P5\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 2, 1));
+ data.push_back(Vertex45(Point(10, 10), 0, 1));
+
+ data.push_back(Vertex45(Point(1, 1), 0, -1));
+ data.push_back(Vertex45(Point(1, 1), 1, 1));
+ data.push_back(Vertex45(Point(2, 1), 0, 1));
+ data.push_back(Vertex45(Point(2, 1), 1, -1));
+ data.push_back(Vertex45(Point(2, 2), 1, -1));
+ data.push_back(Vertex45(Point(2, 2), 0, 1));
+ data.push_back(Vertex45(Point(3, 2), 1, 1));
+ data.push_back(Vertex45(Point(3, 2), 0, -1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingP6() {
+ std::cout << "testing polygon tiling P6\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 10), 2, -1));
+ data.push_back(Vertex45(Point(0, 10), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 0, -1));
+ data.push_back(Vertex45(Point(10, 0), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 2, 1));
+ data.push_back(Vertex45(Point(10, 10), 0, 1));
+
+ data.push_back(Vertex45(Point(1, 1), 0, -1));
+ data.push_back(Vertex45(Point(1, 1), 2, -1));
+ data.push_back(Vertex45(Point(1, 2), 2, 1));
+ data.push_back(Vertex45(Point(1, 2), 0, 1));
+ data.push_back(Vertex45(Point(2, 1), 0, 1));
+ data.push_back(Vertex45(Point(2, 1), 2, 1));
+ data.push_back(Vertex45(Point(2, 2), 2, -1));
+ data.push_back(Vertex45(Point(2, 2), 0, -1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingStar1() {
+ std::cout << "testing polygon tiling star1\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ // result == 0 8 -1 1
+ data.push_back(Vertex45(Point(0, 8), -1, 1));
+ // result == 0 8 1 -1
+ data.push_back(Vertex45(Point(0, 8), 1, -1));
+ // result == 4 0 1 1
+ data.push_back(Vertex45(Point(4, 0), 1, 1));
+ // result == 4 0 2 1
+ data.push_back(Vertex45(Point(4, 0), 2, 1));
+ // result == 4 4 2 -1
+ data.push_back(Vertex45(Point(4, 4), 2, -1));
+ // result == 4 4 -1 -1
+ data.push_back(Vertex45(Point(4, 4), -1, -1));
+ // result == 4 12 1 1
+ data.push_back(Vertex45(Point(4, 12), 1, 1));
+ // result == 4 12 2 1
+ data.push_back(Vertex45(Point(4, 12), 2, 1));
+ // result == 4 16 2 -1
+ data.push_back(Vertex45(Point(4, 16), 2, 1));
+ // result == 4 16 -1 -1
+ data.push_back(Vertex45(Point(4, 16), -1, -1));
+ // result == 6 2 1 -1
+ data.push_back(Vertex45(Point(6, 2), 1, -1));
+ // result == 6 14 -1 1
+ data.push_back(Vertex45(Point(6, 14), -1, 1));
+ // result == 6 2 -1 1
+ data.push_back(Vertex45(Point(6, 2), -1, 1));
+ // result == 6 14 1 -1
+ data.push_back(Vertex45(Point(6, 14), 1, -1));
+ // result == 8 0 -1 -1
+ data.push_back(Vertex45(Point(8, 0), -1, -1));
+ // result == 8 0 2 -1
+ data.push_back(Vertex45(Point(8, 0), 2, -1));
+ // result == 8 4 2 1
+ data.push_back(Vertex45(Point(8, 4), 2, 1));
+ // result == 8 4 1 1
+ data.push_back(Vertex45(Point(8, 4), 1, 1));
+ // result == 8 12 -1 -1
+ data.push_back(Vertex45(Point(8, 12), -1, -1));
+ // result == 8 12 2 -1
+ data.push_back(Vertex45(Point(8, 12), 2, -1));
+ // result == 8 16 2 1
+ data.push_back(Vertex45(Point(8, 16), 2, 1));
+ // result == 8 16 1 1
+ data.push_back(Vertex45(Point(8, 16), 1, 1));
+ // result == 12 8 1 -1
+ data.push_back(Vertex45(Point(12, 8), 1, -1));
+ // result == 12 8 -1 1
+ data.push_back(Vertex45(Point(12, 8), -1, 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingStar2() {
+ std::cout << "testing polygon tiling\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+
+ Scan45 scan45(0);
+ std::vector<Vertex45 > result;
+ std::vector<Scan45Vertex> vertices;
+ //is a Rectnagle(0, 0, 10, 10);
+ Count2 count(1, 0);
+ Count2 ncount(-1, 0);
+ vertices.push_back(Scan45Vertex(Point(0,4), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,4), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,12), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ count = Count2(0, 1);
+ ncount = count.invert();
+ vertices.push_back(Scan45Vertex(Point(0,8), Scan45Count(count, ncount, Count2(0, 0), Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(16,8), Scan45Count(Count2(0, 0), count, ncount, Count2(0, 0))));
+ vertices.push_back(Scan45Vertex(Point(8,0), Scan45Count(ncount, Count2(0, 0), count, Count2(0, 0))));
+ sortScan45Vector(vertices);
+ std::cout << "scanning\n";
+ scan45.scan(result, vertices.begin(), vertices.end());
+
+ std::sort(result.begin(), result.end());
+ pf.scan(polys, result.begin(), result.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingStarHole1() {
+ std::cout << "testing polygon tiling star hole 1\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45> polys;
+ std::vector<Vertex45> data;
+ // result == 0 8 -1 1
+ data.push_back(Vertex45(Point(0, 8), -1, 1));
+ // result == 0 8 1 -1
+ data.push_back(Vertex45(Point(0, 8), 1, -1));
+ // result == 4 0 1 1
+ data.push_back(Vertex45(Point(4, 0), 1, 1));
+ // result == 4 0 2 1
+ data.push_back(Vertex45(Point(4, 0), 2, 1));
+ // result == 4 4 2 -1
+ data.push_back(Vertex45(Point(4, 4), 2, -1));
+ // result == 4 4 -1 -1
+ data.push_back(Vertex45(Point(4, 4), -1, -1));
+ // result == 4 12 1 1
+ data.push_back(Vertex45(Point(4, 12), 1, 1));
+ // result == 4 12 2 1
+ data.push_back(Vertex45(Point(4, 12), 2, 1));
+ // result == 4 16 2 -1
+ data.push_back(Vertex45(Point(4, 16), 2, 1));
+ // result == 4 16 -1 -1
+ data.push_back(Vertex45(Point(4, 16), -1, -1));
+ // result == 6 2 1 -1
+ data.push_back(Vertex45(Point(6, 2), 1, -1));
+ // result == 6 14 -1 1
+ data.push_back(Vertex45(Point(6, 14), -1, 1));
+ // result == 6 2 -1 1
+ data.push_back(Vertex45(Point(6, 2), -1, 1));
+ // result == 6 14 1 -1
+ data.push_back(Vertex45(Point(6, 14), 1, -1));
+ // result == 8 0 -1 -1
+ data.push_back(Vertex45(Point(8, 0), -1, -1));
+ // result == 8 0 2 -1
+ data.push_back(Vertex45(Point(8, 0), 2, -1));
+ // result == 8 4 2 1
+ data.push_back(Vertex45(Point(8, 4), 2, 1));
+ // result == 8 4 1 1
+ data.push_back(Vertex45(Point(8, 4), 1, 1));
+ // result == 8 12 -1 -1
+ data.push_back(Vertex45(Point(8, 12), -1, -1));
+ // result == 8 12 2 -1
+ data.push_back(Vertex45(Point(8, 12), 2, -1));
+ // result == 8 16 2 1
+ data.push_back(Vertex45(Point(8, 16), 2, 1));
+ // result == 8 16 1 1
+ data.push_back(Vertex45(Point(8, 16), 1, 1));
+ // result == 12 8 1 -1
+ data.push_back(Vertex45(Point(12, 8), 1, -1));
+ // result == 12 8 -1 1
+ data.push_back(Vertex45(Point(12, 8), -1, 1));
+
+ data.push_back(Vertex45(Point(6, 4), 1, -1));
+ data.push_back(Vertex45(Point(6, 4), 2, -1));
+ data.push_back(Vertex45(Point(6, 8), -1, 1));
+ data.push_back(Vertex45(Point(6, 8), 2, 1));
+ data.push_back(Vertex45(Point(8, 6), -1, -1));
+ data.push_back(Vertex45(Point(8, 6), 1, 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45TilingStarHole2() {
+ std::cout << "testing polygon tiling star hole 2\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45WithHoles> polys;
+ std::vector<Vertex45> data;
+ // result == 0 8 -1 1
+ data.push_back(Vertex45(Point(0, 8), -1, 1));
+ // result == 0 8 1 -1
+ data.push_back(Vertex45(Point(0, 8), 1, -1));
+ // result == 4 0 1 1
+ data.push_back(Vertex45(Point(4, 0), 1, 1));
+ // result == 4 0 2 1
+ data.push_back(Vertex45(Point(4, 0), 2, 1));
+ // result == 4 4 2 -1
+ data.push_back(Vertex45(Point(4, 4), 2, -1));
+ // result == 4 4 -1 -1
+ data.push_back(Vertex45(Point(4, 4), -1, -1));
+ // result == 4 12 1 1
+ data.push_back(Vertex45(Point(4, 12), 1, 1));
+ // result == 4 12 2 1
+ data.push_back(Vertex45(Point(4, 12), 2, 1));
+ // result == 4 16 2 -1
+ data.push_back(Vertex45(Point(4, 16), 2, 1));
+ // result == 4 16 -1 -1
+ data.push_back(Vertex45(Point(4, 16), -1, -1));
+ // result == 6 2 1 -1
+ data.push_back(Vertex45(Point(6, 2), 1, -1));
+ // result == 6 14 -1 1
+ data.push_back(Vertex45(Point(6, 14), -1, 1));
+ // result == 6 2 -1 1
+ data.push_back(Vertex45(Point(6, 2), -1, 1));
+ // result == 6 14 1 -1
+ data.push_back(Vertex45(Point(6, 14), 1, -1));
+ // result == 8 0 -1 -1
+ data.push_back(Vertex45(Point(8, 0), -1, -1));
+ // result == 8 0 2 -1
+ data.push_back(Vertex45(Point(8, 0), 2, -1));
+ // result == 8 4 2 1
+ data.push_back(Vertex45(Point(8, 4), 2, 1));
+ // result == 8 4 1 1
+ data.push_back(Vertex45(Point(8, 4), 1, 1));
+ // result == 8 12 -1 -1
+ data.push_back(Vertex45(Point(8, 12), -1, -1));
+ // result == 8 12 2 -1
+ data.push_back(Vertex45(Point(8, 12), 2, -1));
+ // result == 8 16 2 1
+ data.push_back(Vertex45(Point(8, 16), 2, 1));
+ // result == 8 16 1 1
+ data.push_back(Vertex45(Point(8, 16), 1, 1));
+ // result == 12 8 1 -1
+ data.push_back(Vertex45(Point(12, 8), 1, -1));
+ // result == 12 8 -1 1
+ data.push_back(Vertex45(Point(12, 8), -1, 1));
+
+ data.push_back(Vertex45(Point(6, 4), 1, -1));
+ data.push_back(Vertex45(Point(6, 4), 2, -1));
+ data.push_back(Vertex45(Point(6, 12), -1, 1));
+ data.push_back(Vertex45(Point(6, 12), 2, 1));
+ data.push_back(Vertex45(Point(10, 8), -1, -1));
+ data.push_back(Vertex45(Point(10, 8), 1, 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+
+ static inline bool testPolygon45Tiling() {
+ std::cout << "testing polygon tiling\n";
+ Polygon45Tiling pf;
+ std::vector<Polygon45WithHoles> polys;
+ std::vector<Vertex45> data;
+
+ data.push_back(Vertex45(Point(0, 0), 0, 1));
+ data.push_back(Vertex45(Point(0, 0), 2, 1));
+ data.push_back(Vertex45(Point(0, 100), 2, -1));
+ data.push_back(Vertex45(Point(0, 100), 0, -1));
+ data.push_back(Vertex45(Point(100, 0), 0, -1));
+ data.push_back(Vertex45(Point(100, 0), 2, -1));
+ data.push_back(Vertex45(Point(100, 100), 2, 1));
+ data.push_back(Vertex45(Point(100, 100), 0, 1));
+
+ data.push_back(Vertex45(Point(2, 2), 0, -1));
+ data.push_back(Vertex45(Point(2, 2), 2, -1));
+ data.push_back(Vertex45(Point(2, 10), 2, 1));
+ data.push_back(Vertex45(Point(2, 10), 0, 1));
+ data.push_back(Vertex45(Point(10, 2), 0, 1));
+ data.push_back(Vertex45(Point(10, 2), 2, 1));
+ data.push_back(Vertex45(Point(10, 10), 2, -1));
+ data.push_back(Vertex45(Point(10, 10), 0, -1));
+
+ data.push_back(Vertex45(Point(2, 12), 0, -1));
+ data.push_back(Vertex45(Point(2, 12), 2, -1));
+ data.push_back(Vertex45(Point(2, 22), 2, 1));
+ data.push_back(Vertex45(Point(2, 22), 0, 1));
+ data.push_back(Vertex45(Point(10, 12), 0, 1));
+ data.push_back(Vertex45(Point(10, 12), 2, 1));
+ data.push_back(Vertex45(Point(10, 22), 2, -1));
+ data.push_back(Vertex45(Point(10, 22), 0, -1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon tiling\n";
+ return true;
+ }
+ };
+
+ template <typename Unit>
+ class PolyLine45HoleData {
+ public:
+ typedef typename polygon_45_formation<Unit>::ActiveTail45 ActiveTail45;
+ typedef typename ActiveTail45::iterator iterator;
+
+ typedef polygon_45_concept geometry_type;
+ typedef Unit coordinate_type;
+ typedef point_data<Unit> Point;
+ typedef Point point_type;
+ typedef iterator_points_to_compact<iterator, Point> compact_iterator_type;
+ typedef iterator iterator_type;
+ typedef typename coordinate_traits<Unit>::area_type area_type;
+
+ inline PolyLine45HoleData() : p_(0) {}
+ inline PolyLine45HoleData(ActiveTail45* p) : p_(p) {}
+ //use default copy and assign
+ inline iterator begin() const { return p_->getTail()->begin(); }
+ inline iterator end() const { return p_->getTail()->end(); }
+ inline unsigned int size() const { return 0; }
+ template<class iT>
+ inline PolyLine45HoleData& set(iT inputBegin, iT inputEnd) {
+ return *this;
+ }
+ private:
+ ActiveTail45* p_;
+ };
+
+ template <typename Unit>
+ class PolyLine45PolygonData {
+ public:
+ typedef typename polygon_45_formation<Unit>::ActiveTail45 ActiveTail45;
+ typedef typename ActiveTail45::iterator iterator;
+ typedef PolyLine45HoleData<Unit> holeType;
+
+ typedef polygon_45_with_holes_concept geometry_type;
+ typedef Unit coordinate_type;
+ typedef point_data<Unit> Point;
+ typedef Point point_type;
+ typedef iterator_points_to_compact<iterator, Point> compact_iterator_type;
+ typedef iterator iterator_type;
+ typedef holeType hole_type;
+ typedef typename coordinate_traits<Unit>::area_type area_type;
+ class iteratorHoles {
+ private:
+ typename ActiveTail45::iteratorHoles itr_;
+ public:
+ typedef PolyLine45HoleData<Unit> holeType;
+ typedef holeType value_type;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type* pointer; //immutable
+ typedef const value_type& reference; //immutable
+ inline iteratorHoles() {}
+ inline iteratorHoles(typename ActiveTail45::iteratorHoles itr) : itr_(itr) {}
+ inline iteratorHoles(const iteratorHoles& that) : itr_(that.itr_) {}
+ inline iteratorHoles& operator=(const iteratorHoles& that) {
+ itr_ = that.itr_;
+ return *this;
+ }
+ inline bool operator==(const iteratorHoles& that) { return itr_ == that.itr_; }
+ inline bool operator!=(const iteratorHoles& that) { return itr_ != that.itr_; }
+ inline iteratorHoles& operator++() {
+ ++itr_;
+ return *this;
+ }
+ inline const iteratorHoles operator++(int) {
+ iteratorHoles tmp = *this;
+ ++(*this);
+ return tmp;
+ }
+ inline holeType operator*() {
+ return *itr_;
+ }
+ };
+ typedef iteratorHoles iterator_holes_type;
+
+
+ inline PolyLine45PolygonData() : p_(0) {}
+ inline PolyLine45PolygonData(ActiveTail45* p) : p_(p) {}
+ //use default copy and assign
+ inline iterator begin() const { return p_->getTail()->begin(); }
+ inline iterator end() const { return p_->getTail()->end(); }
+ inline iteratorHoles begin_holes() const { return iteratorHoles(p_->getHoles().begin()); }
+ inline iteratorHoles end_holes() const { return iteratorHoles(p_->getHoles().end()); }
+ inline ActiveTail45* yield() { return p_; }
+ //stub out these four required functions that will not be used but are needed for the interface
+ inline unsigned int size_holes() const { return 0; }
+ inline unsigned int size() const { return 0; }
+ template<class iT>
+ inline PolyLine45PolygonData& set(iT inputBegin, iT inputEnd) {
+ return *this;
+ }
+
+ /// initialize a polygon from x,y values, it is assumed that the first is an x
+ /// and that the input is a well behaved polygon
+ template<class iT>
+ inline PolyLine45PolygonData& set_holes(iT inputBegin, iT inputEnd) {
+ return *this;
+ }
+ private:
+ ActiveTail45* p_;
+ };
+
+ template <typename T>
+ struct PolyLineByConcept<T, polygon_45_with_holes_concept> { typedef PolyLine45PolygonData<T> type; };
+ template <typename T>
+ struct PolyLineByConcept<T, polygon_with_holes_concept> { typedef PolyLine45PolygonData<T> type; };
+ template <typename T>
+ struct PolyLineByConcept<T, polygon_45_concept> { typedef PolyLine45HoleData<T> type; };
+ template <typename T>
+ struct PolyLineByConcept<T, polygon_concept> { typedef PolyLine45HoleData<T> type; };
+
+ template <typename T>
+ struct geometry_concept<PolyLine45PolygonData<T> > { typedef polygon_45_with_holes_concept type; };
+ template <typename T>
+ struct geometry_concept<PolyLine45HoleData<T> > { typedef polygon_45_concept type; };
+}
+#endif
Added: sandbox/gtl/gtl/polygon_45_set_concept.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_45_set_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,279 @@
+/*
+ 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 GTL_POLYGON_45_SET_CONCEPT_HPP
+#define GTL_POLYGON_45_SET_CONCEPT_HPP
+namespace gtl {
+
+ template <typename T, typename T2>
+ struct is_either_polygon_45_set_type {
+ typedef typename gtl_or<typename is_polygon_45_set_type<T>::type, typename is_polygon_45_set_type<T2>::type >::type type;
+ };
+
+ template <typename T>
+ struct is_polygon_45_or_90_set_type {
+ typedef typename gtl_or<typename is_polygon_45_set_type<T>::type, typename is_polygon_90_set_type<T>::type >::type type;
+ };
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_45_or_90_set_type<polygon_set_type>::type>::type,
+ typename polygon_45_set_traits<polygon_set_type>::iterator_type>::type
+ begin_45_set_data(const polygon_set_type& polygon_set) {
+ return polygon_45_set_traits<polygon_set_type>::begin(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_45_or_90_set_type<polygon_set_type>::type>::type,
+ typename polygon_45_set_traits<polygon_set_type>::iterator_type>::type
+ end_45_set_data(const polygon_set_type& polygon_set) {
+ return polygon_45_set_traits<polygon_set_type>::end(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_45_set_type<polygon_set_type>::type>::type,
+ bool>::type
+ clean(const polygon_set_type& polygon_set) {
+ return polygon_45_set_traits<polygon_set_type>::clean(polygon_set);
+ }
+
+ //assign
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<polygon_set_type_2>::type>::type,
+ polygon_set_type_1>::type &
+ assign(polygon_set_type_1& lvalue, const polygon_set_type_2& rvalue) {
+ if(clean(rvalue))
+ polygon_45_set_mutable_traits<polygon_set_type_1>::set(lvalue, begin_45_set_data(rvalue), end_45_set_data(rvalue));
+ else {
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type_2>::coordinate_type> ps;
+ ps.insert(begin_45_set_data(rvalue), end_45_set_data(rvalue));
+ ps.clean();
+ polygon_45_set_mutable_traits<polygon_set_type_1>::set(lvalue, ps.begin(), ps.end());
+ }
+ return lvalue;
+ }
+
+ //get trapezoids
+ template <typename output_container_type, typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_45_set_type<polygon_set_type>::type>::type,
+ void>::type
+ get_trapezoids(output_container_type& output, const polygon_set_type& polygon_set) {
+ clean(polygon_set);
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(ps, polygon_set);
+ ps.get_trapezoids(output);
+ }
+
+ //equivalence
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_45_or_90_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<polygon_set_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_45_set_type<polygon_set_type_1, polygon_set_type_2>::type>::type,
+ bool>::type
+ equivalence(const polygon_set_type_1& lvalue,
+ const polygon_set_type_2& rvalue) {
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type_1>::coordinate_type> ps1;
+ assign(ps1, lvalue);
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type_2>::coordinate_type> ps2;
+ assign(ps2, rvalue);
+ return ps1 == ps2;
+ }
+
+ //clear
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ void>::type
+ clear(polygon_set_type& polygon_set) {
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(polygon_set, ps);
+ }
+
+ //empty
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ bool>::type
+ empty(const polygon_set_type& polygon_set) {
+ if(clean(polygon_set)) return begin_45_set_data(polygon_set) == end_45_set_data(polygon_set);
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(ps, polygon_set);
+ ps.clean();
+ return ps.empty();
+ }
+
+ //extents
+ template <typename polygon_set_type, typename rectangle_type>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ bool>::type
+ extents(rectangle_type& extents_rectangle,
+ const polygon_set_type& polygon_set) {
+ clean(polygon_set);
+ polygon_45_set_data<typename polygon_45_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(ps, polygon_set);
+ return ps.extents(extents_rectangle);
+ }
+
+ //area
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::area_type>::type
+ area(const polygon_set_type& polygon_set) {
+ typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef polygon_45_with_holes_data<Unit> p_type;
+ typedef typename coordinate_traits<Unit>::area_type area_type;
+ std::vector<p_type> polys;
+ assign(polys, polygon_set);
+ area_type retval = (area_type)0;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ retval += area(polys[i]);
+ }
+ return retval;
+ }
+
+// //self_intersect
+// template <typename polygon_set_type>
+// typename requires_1< typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+// polygon_set_type>::type &
+// self_intersect(polygon_set_type& polygon_set) {
+// typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+// //TODO
+// }
+
+ template <typename polygon_set_type, typename coord_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ resize(polygon_set_type& polygon_set, coord_type resizing,
+ RoundingOption rounding = CLOSEST, CornerOption corner = INTERSECTION) {
+ typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_45_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.resize(resizing, rounding, corner);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ bloat(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ return resize(polygon_set, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ shrink(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type shrinking) {
+ return resize(polygon_set, -(typename polygon_45_set_traits<polygon_set_type>::coordinate_type)shrinking);
+ }
+
+// template <typename polygon_set_type>
+// typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+// polygon_set_type>::type &
+// grow_and(polygon_set_type& polygon_set,
+// typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+// typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+// std::vector<polygon_45_data<Unit> > polys;
+// assign(polys, polygon_set);
+// clear(polygon_set);
+// polygon_45_set_data<Unit> ps;
+// for(unsigned int i = 0; i < polys.size(); ++i) {
+// polygon_45_set_data<Unit> tmpPs;
+// tmpPs.insert(polys[i]);
+// bloat(tmpPs, bloating);
+// tmpPs.clean(); //apply implicit OR on tmp polygon set
+// ps.insert(tmpPs);
+// }
+// self_intersect(ps);
+// assign(polygon_set, ps);
+// return polygon_set;
+// }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale_up(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type factor) {
+ typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_45_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.scale_up(factor);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale_down(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type factor) {
+ typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_45_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.scale_down(factor);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ //transform
+ template <typename polygon_set_type, typename transformation_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ transform(polygon_set_type& polygon_set,
+ const transformation_type& transformation) {
+ typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_45_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.transform(transformation);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ //keep
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_45_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ keep(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::area_type min_area,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::area_type max_area,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_width,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_width,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_height,
+ typename coordinate_traits<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_height) {
+ typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef typename coordinate_traits<Unit>::unsigned_area_type uat;
+ std::list<polygon_45_data<Unit> > polys;
+ assign(polys, polygon_set);
+ typename std::list<polygon_45_data<Unit> >::iterator itr_nxt;
+ for(typename std::list<polygon_45_data<Unit> >::iterator itr = polys.begin(); itr != polys.end(); itr = itr_nxt){
+ itr_nxt = itr;
+ ++itr_nxt;
+ rectangle_data<Unit> bbox;
+ extents(bbox, *itr);
+ uat pwidth = delta(bbox, HORIZONTAL);
+ if(pwidth > min_width && pwidth <= max_width){
+ uat pheight = delta(bbox, VERTICAL);
+ if(pheight > min_height && pheight <= max_height){
+ typename coordinate_traits<Unit>::area_type parea = area(*itr);
+ if(parea <= max_area && parea >= min_area) {
+ continue;
+ }
+ }
+ }
+ polys.erase(itr);
+ }
+ assign(polygon_set, polys);
+ return polygon_set;
+ }
+
+}
+#endif
Added: sandbox/gtl/gtl/polygon_45_set_data.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_45_set_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,1248 @@
+/*
+ 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 GTL_POLYGON_45_SET_DATA_HPP
+#define GTL_POLYGON_45_SET_DATA_HPP
+namespace gtl {
+
+ enum RoundingOption { CLOSEST = 0, OVERSIZE = 1, UNDERSIZE = 2, SQRT2 = 3 };
+ enum CornerOption { INTERSECTION = 0, ORTHOGINAL = 1 };
+
+ template <typename ltype, typename rtype, int op_type>
+ class polygon_45_set_view;
+
+ struct polygon_45_set_concept {};
+
+ template <typename Unit>
+ class polygon_45_set_data {
+ public:
+ typedef typename polygon_45_formation<Unit>::Vertex45Compact Vertex45Compact;
+ typedef std::vector<Vertex45Compact> Polygon45VertexData;
+
+ typedef Unit coordinate_type;
+ typedef Polygon45VertexData value_type;
+ typedef typename value_type::const_iterator iterator_type;
+ typedef polygon_45_set_data operator_arg_type;
+
+ /// default constructor
+ inline polygon_45_set_data() : dirty_(false), unsorted_(false), is_manhattan_(true) {}
+
+ /// constructor from a geometry object
+ template <typename geometry_type>
+ inline polygon_45_set_data(const geometry_type& that) : dirty_(false), unsorted_(false), is_manhattan_(true) {
+ insert(that);
+ }
+
+ /// copy constructor
+ inline polygon_45_set_data(const polygon_45_set_data& that) :
+ data_(that.data_), dirty_(that.dirty_), unsorted_(that.unsorted_), is_manhattan_(that.is_manhattan_) {}
+
+ /// destructor
+ inline ~polygon_45_set_data() {}
+
+ /// assignement operator
+ inline polygon_45_set_data& operator=(const polygon_45_set_data& that) {
+ if(this == &that) return *this;
+ data_ = that.data_;
+ dirty_ = that.dirty_;
+ unsorted_ = that.unsorted_;
+ is_manhattan_ = that.is_manhattan_;
+ return *this;
+ }
+
+ template <typename ltype, typename rtype, int op_type>
+ inline polygon_45_set_data& operator=(const polygon_45_set_view<ltype, rtype, op_type>& that) {
+ set(that.begin(), that.end());
+ dirty_ = that.dirty();
+ unsorted_ = !that.sorted();
+ return *this;
+ }
+
+ template <typename geometry_object>
+ inline polygon_45_set_data& operator=(const geometry_object& geometry) {
+ data_.clear();
+ insert(geometry);
+ return *this;
+ }
+
+ /// insert iterator range
+ template <typename iT>
+ inline void insert(iT input_begin, iT input_end, bool is_hole = false) {
+ if(input_begin == input_end) return;
+ dirty_ = true;
+ unsorted_ = true;
+ while(input_begin != input_end) {
+ insert(*input_begin, is_hole);
+ ++input_begin;
+ }
+ }
+
+ inline void insert(const polygon_45_set_data& polygon_set, bool is_hole = false);
+
+ template <typename geometry_type>
+ inline void insert(const geometry_type& geometry_object, bool is_hole = false) {
+ insert_dispatch(geometry_object, is_hole, typename geometry_concept<geometry_type>::type());
+ }
+
+ inline void insert_clean(const Vertex45Compact& vertex_45, bool is_hole = false) {
+ if(vertex_45.count.is_45()) is_manhattan_ = false;
+ data_.push_back(vertex_45);
+ if(is_hole) data_.back().count.invert();
+ }
+
+ inline void insert(const Vertex45Compact& vertex_45, bool is_hole = false) {
+ dirty_ = true;
+ unsorted_ = true;
+ insert_clean(vertex_45, is_hole);
+ }
+
+ template <typename coordinate_type_2>
+ inline void insert(const polygon_90_set_data<coordinate_type_2>& polygon_set, bool is_hole = false) {
+ if(polygon_set.orient() == VERTICAL) {
+ for(typename polygon_90_set_data<coordinate_type_2>::iterator_type itr = polygon_set.begin();
+ itr != polygon_set.end(); ++itr) {
+ Vertex45Compact vertex_45(point_data<Unit>((*itr).first, (*itr).second.first), 2, (*itr).second.second);
+ vertex_45.count[1] = (*itr).second.second;
+ insert_clean(vertex_45);
+ }
+ } else {
+ for(typename polygon_90_set_data<coordinate_type_2>::iterator_type itr = polygon_set.begin();
+ itr != polygon_set.end(); ++itr) {
+ Vertex45Compact vertex_45(point_data<Unit>((*itr).second.first, (*itr).first), 2, (*itr).second.second);
+ vertex_45.count[1] = (*itr).second.second;
+ insert_clean(vertex_45);
+ }
+ }
+ }
+
+ template <typename output_container>
+ inline void get(output_container& output) const {
+ get_dispatch(output, typename geometry_concept<typename output_container::value_type>::type());
+ }
+
+ /// equivalence operator
+ inline bool operator==(const polygon_45_set_data& p) const {
+ clean();
+ p.clean();
+ return data_ == p.data_;
+ }
+
+ /// inequivalence operator
+ inline bool operator!=(const polygon_45_set_data& p) const {
+ return !((*this) == p);
+ }
+
+ /// get iterator to begin vertex data
+ inline iterator_type begin() const {
+ return data_.begin();
+ }
+
+ /// get iterator to end vertex data
+ inline iterator_type end() const {
+ return data_.end();
+ }
+
+ const value_type& value() const {
+ return data_;
+ }
+
+ /// clear the contents of the polygon_45_set_data
+ inline void clear() { data_.clear(); dirty_ = unsorted_ = false; is_manhattan_ = true; }
+
+ /// find out if Polygon set is empty
+ inline bool empty() const { return data_.empty(); }
+
+ /// find out if Polygon set is sorted
+ inline bool sorted() const { return !unsorted_; }
+
+ /// find out if Polygon set is clean
+ inline bool dirty() const { return dirty_; }
+
+ /// find out if Polygon set is clean
+ inline bool is_manhattan() const { return is_manhattan_; }
+
+ bool clean() const;
+
+ void sort() const{
+ if(unsorted_) {
+ std::sort(data_.begin(), data_.end());
+ unsorted_ = false;
+ }
+ }
+
+ template <typename input_iterator_type>
+ void set(input_iterator_type input_begin, input_iterator_type input_end) {
+ data_.clear();
+ insert(input_begin, input_end);
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ void set_clean(const value_type& value) {
+ data_ = value;
+ dirty_ = false;
+ unsorted_ = false;
+ }
+
+ void set(const value_type& value) {
+ data_ = value;
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ /// append to the container cT with polygons (holes will be fractured vertically)
+ template <class cT>
+ void get_polygons(cT& container) const {
+ get_dispatch(container, polygon_45_concept());
+ }
+
+ /// append to the container cT with PolygonWithHoles objects
+ template <class cT>
+ void get_polygons_with_holes(cT& container) const {
+ get_dispatch(container, polygon_45_with_holes_concept());
+ }
+
+ /// append to the container cT with polygons of three or four verticies
+ template <class cT>
+ void get_trapezoids(cT& container) const;
+
+ /// insert vertex sequence
+ template <class iT>
+ void insert_vertex_sequence(iT begin_vertex, iT end_vertex,
+ direction_1d winding, bool is_hole = false);
+
+ /// get the external boundary rectangle
+ template <typename rectangle_type>
+ bool extents(rectangle_type& rect) const;
+
+ /// snap verticies of set to even,even or odd,odd coordinates
+ void snap() const;
+
+ /// |= &= += *= -= ^= binary operators
+ polygon_45_set_data& operator|=(const polygon_45_set_data& b);
+ polygon_45_set_data& operator&=(const polygon_45_set_data& b);
+ polygon_45_set_data& operator+=(const polygon_45_set_data& b);
+ polygon_45_set_data& operator*=(const polygon_45_set_data& b);
+ polygon_45_set_data& operator-=(const polygon_45_set_data& b);
+ polygon_45_set_data& operator^=(const polygon_45_set_data& b);
+
+ /// resizing operations
+ polygon_45_set_data& operator+=(Unit delta);
+ polygon_45_set_data& operator-=(Unit delta);
+
+ /// shrink the Polygon45Set by shrinking
+ polygon_45_set_data& resize(coordinate_type resizing, RoundingOption rounding = CLOSEST,
+ CornerOption corner = INTERSECTION);
+
+ /// transform set
+ template <typename transformation_type>
+ polygon_45_set_data& transform(const transformation_type& tr);
+
+ /// scale set
+ polygon_45_set_data& scale_up(typename coordinate_traits<Unit>::unsigned_area_type factor);
+ polygon_45_set_data& scale_down(typename coordinate_traits<Unit>::unsigned_area_type factor);
+
+ /// accumulate the bloated polygon
+ template <typename geometry_type>
+ polygon_45_set_data& insert_with_resize(const geometry_type& poly,
+ coordinate_type resizing, RoundingOption rounding = CLOSEST,
+ CornerOption corner = INTERSECTION,
+ bool hole = false) {
+ return insert_with_resize_dispatch(poly, resizing, rounding, corner, hole, typename geometry_concept<geometry_type>::type());
+ }
+
+ private:
+ mutable value_type data_;
+ mutable bool dirty_;
+ mutable bool unsorted_;
+ mutable bool is_manhattan_;
+
+ private:
+ //functions
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_45_concept tag) const {
+ get_fracture(output, true, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_45_with_holes_concept tag) const {
+ get_fracture(output, false, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_concept tag) const {
+ get_fracture(output, true, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_with_holes_concept tag) const {
+ get_fracture(output, false, tag);
+ }
+ template <typename output_container, typename concept_type>
+ void get_fracture(output_container& container, bool fracture_holes, concept_type tag) const {
+ clean();
+ typename polygon_45_formation<Unit>::Polygon45Formation pf(fracture_holes);
+ //std::cout << "FORMING POLYGONS\n";
+ pf.scan(container, data_.begin(), data_.end());
+ }
+
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, undefined_concept tag) {
+ insert(geometry_object.begin(), geometry_object.end(), is_hole);
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, rectangle_concept tag) {
+ polygon_45_data<Unit> poly;
+ assign(poly, geometry_object);
+ insert_dispatch(poly, is_hole, polygon_45_concept());
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_concept tag) {
+ insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_with_holes_concept tag) {
+ insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
+ for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
+ begin_holes(geometry_object); itr != end_holes(geometry_object);
+ ++itr) {
+ insert_vertex_sequence(begin_points(*itr), end_points(*itr), winding(*itr), !is_hole);
+ }
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_concept tag) {
+ insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_with_holes_concept tag) {
+ insert_vertex_sequence(begin_points(geometry_object), end_points(geometry_object), winding(geometry_object), is_hole);
+ for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
+ begin_holes(geometry_object); itr != end_holes(geometry_object);
+ ++itr) {
+ insert_vertex_sequence(begin_points(*itr), end_points(*itr), winding(*itr), !is_hole);
+ }
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_45_set_concept tag) {
+ polygon_45_set_data ps;
+ assign(ps, geometry_object);
+ insert(ps, is_hole);
+ }
+ template <typename geometry_type>
+ void insert_dispatch(const geometry_type& geometry_object, bool is_hole, polygon_90_set_concept tag) {
+ std::list<polygon_90_data<coordinate_type> > pl;
+ assign(pl, geometry_object);
+ insert(pl.begin(), pl.end(), is_hole);
+ }
+
+ void insert_vertex_half_edge_45_pair(const point_data<Unit>& pt1, point_data<Unit>& pt2,
+ const point_data<Unit>& pt3, direction_1d wdir);
+
+ template <typename geometry_type>
+ polygon_45_set_data& insert_with_resize_dispatch(const geometry_type& poly,
+ coordinate_type resizing, RoundingOption rounding,
+ CornerOption corner, bool hole, polygon_45_concept tag);
+
+ /// accumulate the bloated polygon with holes
+ template <typename geometry_type>
+ polygon_45_set_data& insert_with_resize_dispatch(const geometry_type& poly,
+ coordinate_type resizing, RoundingOption rounding,
+ CornerOption corner, bool hole, polygon_45_with_holes_concept tag);
+
+ static void snap_vertex_45(Vertex45Compact& vertex);
+
+ public:
+ void applyAdaptiveBoolean_(int op, const polygon_45_set_data& rvalue) const;
+ void applyAdaptiveBoolean_(polygon_45_set_data& result, int op, const polygon_45_set_data& rvalue) const;
+ //void applyBoolean_(int op, value_type& rvalue) const;
+ //void applyBoolean_(value_type& result, int op,
+ // value_type& rvalue) const;
+ //void applyBooleanException_(value_type& result, int op, value_type& rvalue) const;
+ };
+
+ template <typename T>
+ struct geometry_concept<polygon_45_set_data<T> > {
+ typedef polygon_45_set_concept type;
+ };
+
+
+ template <typename Unit>
+ template <class cT>
+ inline void polygon_45_set_data<Unit>::get_trapezoids(cT& container) const {
+ clean();
+ typename polygon_45_formation<Unit>::Polygon45Tiling pf;
+ //std::cout << "FORMING POLYGONS\n";
+ pf.scan(container, data_.begin(), data_.end());
+ //std::cout << "DONE FORMING POLYGONS\n";
+ }
+
+ template <typename Unit>
+ inline std::pair<int, int> characterizeEdge45(const point_data<Unit>& pt1, const point_data<Unit>& pt2) {
+ std::pair<int, int> retval(0, 1);
+ if(pt1.x() == pt2.x()) {
+ retval.first = 3;
+ retval.second = -1;
+ return retval;
+ }
+ //retval.second = pt1.x() < pt2.x() ? -1 : 1;
+ retval.second = 1;
+ if(pt1.y() == pt2.y()) {
+ retval.first = 1;
+ } else if(pt1.x() < pt2.x()) {
+ if(pt1.y() < pt2.y()) {
+ retval.first = 2;
+ } else {
+ retval.first = 0;
+ }
+ } else {
+ if(pt1.y() < pt2.y()) {
+ retval.first = 0;
+ } else {
+ retval.first = 2;
+ }
+ }
+ return retval;
+ }
+
+ template <typename Unit>
+ inline void polygon_45_set_data<Unit>::insert_vertex_half_edge_45_pair(const point_data<Unit>& pt1, point_data<Unit>& pt2,
+ const point_data<Unit>& pt3,
+ direction_1d wdir) {
+ int multiplier = wdir == LOW ? -1 : 1;
+ Vertex45Compact vertex(pt2, 0, 0);
+ //std::cout << pt1 << " " << pt2 << " " << pt3 << std::endl;
+ std::pair<int, int> check;
+ check = characterizeEdge45(pt1, pt2);
+ //std::cout << "index " << check.first << " " << check.second * -multiplier << std::endl;
+ vertex.count[check.first] += check.second * -multiplier;
+ check = characterizeEdge45(pt2, pt3);
+ //std::cout << "index " << check.first << " " << check.second * multiplier << std::endl;
+ vertex.count[check.first] += check.second * multiplier;
+ data_.push_back(vertex);
+ if(vertex.count.is_45()) is_manhattan_ = false;
+ }
+
+ template <typename Unit>
+ template <class iT>
+ inline void polygon_45_set_data<Unit>::insert_vertex_sequence(iT begin_vertex, iT end_vertex,
+ direction_1d winding, bool is_hole) {
+ if(begin_vertex == end_vertex) return;
+ if(is_hole) winding = winding.backward();
+ iT itr = begin_vertex;
+ if(itr == end_vertex) return;
+ point_data<Unit> firstPt = *itr;
+ ++itr;
+ point_data<Unit> secondPt(firstPt);
+ //skip any duplicate points
+ do {
+ if(itr == end_vertex) return;
+ secondPt = *itr;
+ ++itr;
+ } while(secondPt == firstPt);
+ point_data<Unit> prevPt = secondPt;
+ point_data<Unit> prevPrevPt = firstPt;
+ while(itr != end_vertex) {
+ point_data<Unit> pt = *itr;
+ //skip any duplicate points
+ if(pt == prevPt) {
+ ++itr;
+ continue;
+ }
+ //operate on the three points
+ insert_vertex_half_edge_45_pair(prevPrevPt, prevPt, pt, winding);
+ prevPrevPt = prevPt;
+ prevPt = pt;
+ ++itr;
+ }
+ if(prevPt != firstPt) {
+ insert_vertex_half_edge_45_pair(prevPrevPt, prevPt, firstPt, winding);
+ insert_vertex_half_edge_45_pair(prevPt, firstPt, secondPt, winding);
+ } else {
+ insert_vertex_half_edge_45_pair(prevPrevPt, firstPt, secondPt, winding);
+ }
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ /// insert polygon set
+ template <typename Unit>
+ inline void polygon_45_set_data<Unit>::insert(const polygon_45_set_data<Unit>& polygon_set, bool is_hole) {
+ if(is_hole) {
+ (*this) -= polygon_set;
+ return;
+ }
+ if(empty()) {
+ (*this) = polygon_set;
+ return;
+ }
+ data_.insert(data_.end(), polygon_set.data_.begin(), polygon_set.data_.end());
+ dirty_ = true;
+ unsorted_ = true;
+ if(polygon_set.is_manhattan_ == false) is_manhattan_ = false;
+ return;
+ }
+
+ /// get the external boundary rectangle
+ template <typename Unit>
+ template <typename rectangle_type>
+ inline bool polygon_45_set_data<Unit>::extents(rectangle_type& rect) const{
+ if(empty()) {
+ return false;
+ }
+ Unit low = std::numeric_limits<Unit>::max();
+ Unit high = std::numeric_limits<Unit>::min();
+ interval_data<Unit> xivl(low, high);
+ interval_data<Unit> yivl(low, high);
+ for(typename value_type::const_iterator itr = data_.begin();
+ itr != data_.end(); ++ itr) {
+ if((*itr).pt.x() > xivl.get(HIGH))
+ xivl.set(HIGH, (*itr).pt.x());
+ if((*itr).pt.x() < xivl.get(LOW))
+ xivl.set(LOW, (*itr).pt.x());
+ if((*itr).pt.y() > yivl.get(HIGH))
+ yivl.set(HIGH, (*itr).pt.y());
+ if((*itr).pt.y() < yivl.get(LOW))
+ yivl.set(LOW, (*itr).pt.y());
+ }
+ rect = construct<rectangle_type>(xivl, yivl);
+ return true;
+ }
+
+ //this function snaps the vertex and two half edges
+ //to be both even or both odd coordinate values if one of the edges is 45
+ //and throws an excpetion if an edge is non-manhattan, non-45.
+ template <typename Unit>
+ inline void polygon_45_set_data<Unit>::snap_vertex_45(typename polygon_45_set_data<Unit>::Vertex45Compact& vertex) {
+ bool plus45 = vertex.count[2] != 0;
+ bool minus45 = vertex.count[0] != 0;
+ if(plus45 || minus45) {
+ if(abs(vertex.pt.x()) % 2 != abs(vertex.pt.y()) % 2) {
+ if(vertex.count[1] != 0 ||
+ (plus45 && minus45)) {
+ //move right
+ vertex.pt.x(vertex.pt.x() + 1);
+ } else {
+ //assert that vertex.count[3] != 0
+ Unit modifier = plus45 ? -1 : 1;
+ vertex.pt.y(vertex.pt.y() + modifier);
+ }
+ }
+ }
+ }
+
+ template <typename Unit>
+ inline void polygon_45_set_data<Unit>::snap() const {
+ for(typename value_type::iterator itr = data_.begin();
+ itr != data_.end(); ++itr) {
+ snap_vertex_45(*itr);
+ }
+ }
+
+ /// |= &= += *= -= ^= binary operators
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator|=(const polygon_45_set_data<Unit>& b) {
+ insert(b);
+ return *this;
+ }
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator&=(const polygon_45_set_data<Unit>& b) {
+ //b.sort();
+ //sort();
+ applyAdaptiveBoolean_(1, b);
+ dirty_ = false;
+ unsorted_ = false;
+ return *this;
+ }
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator+=(const polygon_45_set_data<Unit>& b) {
+ return (*this) |= b;
+ }
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator*=(const polygon_45_set_data<Unit>& b) {
+ return (*this) &= b;
+ }
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator-=(const polygon_45_set_data<Unit>& b) {
+ //b.sort();
+ //sort();
+ applyAdaptiveBoolean_(2, b);
+ dirty_ = false;
+ unsorted_ = false;
+ return *this;
+ }
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator^=(const polygon_45_set_data<Unit>& b) {
+ //b.sort();
+ //sort();
+ applyAdaptiveBoolean_(3, b);
+ dirty_ = false;
+ unsorted_ = false;
+ return *this;
+ }
+
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator+=(Unit delta) {
+ return resize(delta);
+ }
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::operator-=(Unit delta) {
+ return (*this) += -delta;
+ }
+
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>&
+ polygon_45_set_data<Unit>::resize(Unit resizing, RoundingOption rounding, CornerOption corner) {
+ if(resizing == 0) return *this;
+ std::list<polygon_45_with_holes_data<Unit> > pl;
+ get_polygons_with_holes(pl);
+ clear();
+ for(typename std::list<polygon_45_with_holes_data<Unit> >::iterator itr = pl.begin(); itr != pl.end(); ++itr) {
+ insert_with_resize(*itr, resizing, rounding, corner);
+ }
+ //perterb 45 edges to prevent non-integer intersection errors upon boolean op
+ //snap();
+ return *this;
+ }
+
+ //distance is assumed to be positive
+ inline int roundClosest(double distance) {
+ int f = (int)distance;
+ if(distance - (double)f < 0.5) return f;
+ return f+1;
+ }
+
+ //distance is assumed to be positive
+ template <typename Unit>
+ inline Unit roundWithOptions(double distance, RoundingOption rounding) {
+ if(rounding == CLOSEST) {
+ return roundClosest(distance);
+ } else if(rounding == OVERSIZE) {
+ return (Unit)distance + 1;
+ } else { //UNDERSIZE
+ return (Unit)distance;
+ }
+ }
+
+ // 0 is east, 1 is northeast, 2 is north, 3 is northwest, 4 is west, 5 is southwest, 6 is south
+ // 7 is southwest
+ template <typename Unit>
+ inline point_data<Unit> bloatVertexInDirWithOptions(const point_data<Unit>& point, unsigned int dir,
+ Unit bloating, RoundingOption rounding) {
+ const double sqrt2 = 1.4142135623730950488016887242097;
+ if(dir & 1) {
+ Unit unitDistance = (Unit)bloating;
+ if(rounding != SQRT2) {
+ //45 degree bloating
+ double distance = (double)bloating;
+ distance /= sqrt2; // multiply by 1/sqrt2
+ unitDistance = roundWithOptions<Unit>(distance, rounding);
+ }
+ int xMultiplier = 1;
+ int yMultiplier = 1;
+ if(dir == 3 || dir == 5) xMultiplier = -1;
+ if(dir == 5 || dir == 7) yMultiplier = -1;
+ return point_data<Unit>(point.x()+xMultiplier*unitDistance,
+ point.y()+yMultiplier*unitDistance);
+ } else {
+ if(dir == 0)
+ return point_data<Unit>(point.x()+bloating, point.y());
+ if(dir == 2)
+ return point_data<Unit>(point.x(), point.y()+bloating);
+ if(dir == 4)
+ return point_data<Unit>(point.x()-bloating, point.y());
+ if(dir == 6)
+ return point_data<Unit>(point.x(), point.y()-bloating);
+ return point_data<Unit>();
+ }
+ }
+
+ template <typename Unit>
+ inline unsigned int getEdge45Direction(const point_data<Unit>& pt1, const point_data<Unit>& pt2) {
+ if(pt1.x() == pt2.x()) {
+ if(pt1.y() < pt2.y()) return 2;
+ return 6;
+ }
+ if(pt1.y() == pt2.y()) {
+ if(pt1.x() < pt2.x()) return 0;
+ return 4;
+ }
+ if(pt2.y() > pt1.y()) {
+ if(pt2.x() > pt1.x()) return 1;
+ return 3;
+ }
+ if(pt2.x() > pt1.x()) return 7;
+ return 5;
+ }
+
+ inline unsigned int getEdge45NormalDirection(unsigned int dir, int multiplier) {
+ if(multiplier < 0)
+ return (dir + 2) % 8;
+ return (dir + 4 + 2) % 8;
+ }
+
+ template <typename Unit>
+ inline point_data<Unit> getIntersectionPoint(const point_data<Unit>& pt1, unsigned int slope1,
+ const point_data<Unit>& pt2, unsigned int slope2) {
+ //the intention here is to use all integer arithmetic without causing overflow
+ //turncation error or divide by zero error
+ //I don't use floating point arithmetic because its precision may not be high enough
+ //at the extremes of the integer range
+ typedef typename coordinate_traits<Unit>::area_type LongUnit;
+ const Unit rises[8] = {0, 1, 1, 1, 0, -1, -1, -1};
+ const Unit runs[8] = {1, 1, 0, -1, -1, -1, 0, 1};
+ LongUnit rise1 = rises[slope1];
+ LongUnit rise2 = rises[slope2];
+ LongUnit run1 = runs[slope1];
+ LongUnit run2 = runs[slope2];
+ LongUnit x1 = (LongUnit)pt1.x();
+ LongUnit x2 = (LongUnit)pt2.x();
+ LongUnit y1 = (LongUnit)pt1.y();
+ LongUnit y2 = (LongUnit)pt2.y();
+ Unit x = 0;
+ Unit y = 0;
+ if(run1 == 0) {
+ x = pt1.x();
+ y = (Unit)(((x1 - x2) * rise2) / run2) + pt2.y();
+ } else if(run2 == 0) {
+ x = pt2.x();
+ y = (Unit)(((x2 - x1) * rise1) / run1) + pt1.y();
+ } else {
+ // y - y1 = (rise1/run1)(x - x1)
+ // y - y2 = (rise2/run2)(x - x2)
+ // y = (rise1/run1)(x - x1) + y1 = (rise2/run2)(x - x2) + y2
+ // (rise1/run1 - rise2/run2)x = y2 - y1 + rise1/run1 x1 - rise2/run2 x2
+ // x = (y2 - y1 + rise1/run1 x1 - rise2/run2 x2)/(rise1/run1 - rise2/run2)
+ // x = (y2 - y1 + rise1/run1 x1 - rise2/run2 x2)(rise1 run2 - rise2 run1)/(run1 run2)
+ x = (Unit)((y2 - y1 + ((rise1 * x1) / run1) - ((rise2 * x2) / run2)) *
+ (run1 * run2) / (rise1 * run2 - rise2 * run1));
+ if(rise1 == 0) {
+ y = pt1.y();
+ } else if(rise2 == 0) {
+ y = pt2.y();
+ } else {
+ // y - y1 = (rise1/run1)(x - x1)
+ // (run1/rise1)(y - y1) = x - x1
+ // x = (run1/rise1)(y - y1) + x1 = (run2/rise2)(y - y2) + x2
+ y = (Unit)((x2 - x1 + ((run1 * y1) / rise1) - ((run2 * y2) / rise2)) *
+ (rise1 * rise2) / (run1 * rise2 - run2 * rise1));
+ }
+ }
+ return point_data<Unit>(x, y);
+ }
+
+ template <typename Unit>
+ inline
+ void handleResizingEdge45(polygon_45_set_data<Unit>& sizingSet, point_data<Unit> first,
+ point_data<Unit> second, Unit resizing, RoundingOption rounding) {
+ if(first.x() == second.x()) {
+ sizingSet += rectangle_data<int>(first.x() - resizing, first.y(), first.x() + resizing, second.y());
+ return;
+ }
+ if(first.y() == second.y()) {
+ sizingSet += rectangle_data<int>(first.x(), first.y() - resizing, second.x(), first.y() + resizing);
+ return;
+ }
+ //edge is 45
+ std::vector<point_data<Unit> > pts;
+ Unit bloating = resizing < 0 ? -resizing : resizing;
+ if(second.x() < first.x()) std::swap(first, second);
+ if(first.y() < second.y()) {
+ pts.push_back(bloatVertexInDirWithOptions(first, 3, bloating, rounding));
+ pts.push_back(bloatVertexInDirWithOptions(first, 7, bloating, rounding));
+ pts.push_back(bloatVertexInDirWithOptions(second, 7, bloating, rounding));
+ pts.push_back(bloatVertexInDirWithOptions(second, 3, bloating, rounding));
+ sizingSet.insert_vertex_sequence(pts.begin(), pts.end(), HIGH, false);
+ } else {
+ pts.push_back(bloatVertexInDirWithOptions(first, 1, bloating, rounding));
+ pts.push_back(bloatVertexInDirWithOptions(first, 5, bloating, rounding));
+ pts.push_back(bloatVertexInDirWithOptions(second, 5, bloating, rounding));
+ pts.push_back(bloatVertexInDirWithOptions(second, 1, bloating, rounding));
+ sizingSet.insert_vertex_sequence(pts.begin(), pts.end(), HIGH, false);
+ }
+ }
+
+ template <typename Unit>
+ inline
+ void handleResizingVertex45(polygon_45_set_data<Unit>& sizingSet, const point_data<Unit>& first,
+ const point_data<Unit>& second, const point_data<Unit>& third, Unit resizing,
+ RoundingOption rounding, CornerOption corner,
+ int multiplier) {
+ unsigned int edge1 = getEdge45Direction(first, second);
+ unsigned int edge2 = getEdge45Direction(second, third);
+ unsigned int diffAngle;
+ if(multiplier < 0)
+ diffAngle = (edge2 + 8 - edge1) % 8;
+ else
+ diffAngle = (edge1 + 8 - edge2) % 8;
+ if(diffAngle < 4) {
+ if(resizing > 0) return; //accute interior corner
+ else multiplier *= -1; //make it appear to be an accute exterior angle
+ }
+ unsigned int normal1 = getEdge45NormalDirection(edge1, multiplier);
+ unsigned int normal2 = getEdge45NormalDirection(edge2, multiplier);
+ Unit bloating = abs(resizing);
+ point_data<Unit> edgePoint1 = bloatVertexInDirWithOptions(second, normal1, bloating, rounding);
+ point_data<Unit> edgePoint2 = bloatVertexInDirWithOptions(second, normal2, bloating, rounding);
+ //if the change in angle is 135 degrees it is an accute exterior corner
+ if((edge1+ multiplier * 3) % 8 == edge2) {
+ if(corner == ORTHOGINAL) {
+ rectangle_data<int> insertion_rect;
+ set_points(insertion_rect, edgePoint1, edgePoint2);
+ sizingSet.insert(insertion_rect);
+ return;
+ }
+ }
+ std::vector<point_data<Unit> > pts;
+ pts.push_back(edgePoint1);
+ pts.push_back(second);
+ pts.push_back(edgePoint2);
+ pts.push_back(getIntersectionPoint(edgePoint1, edge1, edgePoint2, edge2));
+ polygon_45_data<Unit> poly(pts.begin(), pts.end());
+ sizingSet += poly;
+ }
+
+ template <typename Unit>
+ template <typename geometry_type>
+ inline polygon_45_set_data<Unit>&
+ polygon_45_set_data<Unit>::insert_with_resize_dispatch(const geometry_type& poly,
+ coordinate_type resizing,
+ RoundingOption rounding,
+ CornerOption corner,
+ bool hole, polygon_45_concept tag) {
+ direction_1d wdir = winding(poly);
+ int multiplier = wdir == LOW ? -1 : 1;
+ if(hole) multiplier *= -1;
+ //if(resizing < 0) {
+ //multiplier *= -1;
+ //resizing *= -1;
+ //}
+ typedef typename polygon_45_data<Unit>::iterator_type piterator;
+ piterator first, second, third, end, real_end;
+ real_end = end_points(poly);
+ third = begin_points(poly);
+ first = third;
+ if(first == real_end) return *this;
+ ++third;
+ if(third == real_end) return *this;
+ second = end = third;
+ ++third;
+ if(third == real_end) return *this;
+ polygon_45_set_data<Unit> sizingSet;
+ //insert minkofski shapes on edges and corners
+ do {
+ handleResizingEdge45(sizingSet, *first, *second, resizing, rounding);
+ handleResizingVertex45(sizingSet, *first, *second, *third, resizing, rounding, corner, multiplier);
+ first = second;
+ second = third;
+ ++third;
+ if(third == real_end) {
+ third = begin_points(poly);
+ if(*second == *third) {
+ ++third; //skip first point if it is duplicate of last point
+ }
+ }
+ } while(second != end);
+ //sizingSet.snap();
+ polygon_45_set_data<Unit> tmp;
+ //insert original shape
+ tmp.insert(poly, hole);
+ if(hole) {
+ std::vector<point_data<Unit> > pts;
+ pts.reserve(4);
+ Unit UnitMax = std::numeric_limits<Unit>::max();
+ Unit UnitMin = std::numeric_limits<Unit>::min();
+ pts.push_back(point_data<Unit> (UnitMin, UnitMin));
+ pts.push_back(point_data<Unit> (UnitMin, UnitMax));
+ pts.push_back(point_data<Unit> (UnitMax, UnitMax));
+ pts.push_back(point_data<Unit> (UnitMax, UnitMin));
+ tmp.insert_vertex_sequence(pts.begin(), pts.end(), LOW, false);
+ //tmp.snap();
+ if(resizing < 0) tmp -= sizingSet;
+ else tmp += sizingSet;
+ tmp.clean();
+ tmp.insert_vertex_sequence(pts.begin(), pts.end(), LOW, true);
+ //tmp.snap();
+ } else {
+ if(resizing < 0) tmp -= sizingSet;
+ else tmp += sizingSet;
+ tmp.clean();
+ }
+ return (*this) += tmp;
+ }
+
+ /// accumulate the bloated polygon with holes
+ template <typename Unit>
+ template <typename geometry_type>
+ inline polygon_45_set_data<Unit>&
+ polygon_45_set_data<Unit>::insert_with_resize_dispatch(const geometry_type& poly,
+ coordinate_type resizing,
+ RoundingOption rounding,
+ CornerOption corner,
+ bool hole, polygon_45_with_holes_concept tag) {
+ insert_with_resize_dispatch(poly, resizing, rounding, corner, hole, polygon_45_concept());
+ for(typename polygon_with_holes_traits<geometry_type>::iterator_holes_type itr =
+ begin_holes(poly); itr != end_holes(poly);
+ ++itr) {
+ insert_with_resize_dispatch(*itr, resizing, rounding, corner, !hole, polygon_45_concept());
+ }
+ return *this;
+ }
+
+ /// transform set
+ template <typename Unit>
+ template <typename transformation_type>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::transform(const transformation_type& tr){
+ clean();
+ std::vector<polygon_45_with_holes_data<Unit> > polys;
+ get(polys);
+ for(typename std::vector<polygon_45_with_holes_data<Unit> >::iterator itr = polys.begin();
+ itr != polys.end(); ++itr) {
+ gtl::transform(*itr, tr);
+ }
+ clear();
+ insert(polys.begin(), polys.end());
+ dirty_ = true;
+ unsorted_ = true;
+ return *this;
+ }
+
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::scale_up(typename coordinate_traits<Unit>::unsigned_area_type factor) {
+ clean();
+ std::vector<polygon_45_with_holes_data<Unit> > polys;
+ get_polygons_with_holes(polys);
+ for(typename std::vector<polygon_45_with_holes_data<Unit> >::iterator itr = polys.begin();
+ itr != polys.end(); ++itr) {
+ gtl::scale_up(*itr, factor);
+ }
+ clear();
+ insert(polys.begin(), polys.end());
+ dirty_ = true;
+ unsorted_ = true;
+ return *this;
+ }
+
+ template <typename Unit>
+ inline polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::scale_down(typename coordinate_traits<Unit>::unsigned_area_type factor) {
+ clean();
+ std::vector<polygon_45_with_holes_data<Unit> > polys;
+ get_polygons_with_holes(polys);
+ for(typename std::vector<polygon_45_with_holes_data<Unit> >::iterator itr = polys.begin();
+ itr != polys.end(); ++itr) {
+ gtl::scale_down(*itr, factor);
+ }
+ clear();
+ insert(polys.begin(), polys.end());
+ dirty_ = true;
+ unsorted_ = true;
+ return *this;
+ }
+
+ template <typename Unit>
+ inline bool polygon_45_set_data<Unit>::clean() const {
+ if(unsorted_) sort();
+ if(dirty_) {
+ polygon_45_set_data<Unit> empty;
+ applyAdaptiveBoolean_(0, empty);
+ dirty_ = false;
+ }
+ return true;
+ }
+
+ template <typename Unit>
+ inline void polygon_45_set_data<Unit>::applyAdaptiveBoolean_(int op, const polygon_45_set_data<Unit>& rvalue) const {
+ polygon_45_set_data<Unit> tmp;
+ applyAdaptiveBoolean_(tmp, op, rvalue);
+ data_.swap(tmp.data_); //swapping vectors should be constant time operation
+ is_manhattan_ = tmp.is_manhattan_;
+ unsorted_ = false;
+ dirty_ = false;
+ }
+
+ template <typename Unit>
+ inline void polygon_45_set_data<Unit>::applyAdaptiveBoolean_(polygon_45_set_data<Unit>& result,
+ int op, const polygon_45_set_data<Unit>& rvalue) const {
+ if(is_manhattan() && rvalue.is_manhattan()) {
+ //convert each into polygon_90_set data and call boolean operations
+ polygon_90_set_data<Unit> l90sd(VERTICAL), r90sd(VERTICAL), output(VERTICAL);
+ for(typename value_type::const_iterator itr = data_.begin(); itr != data_.end(); ++itr) {
+ if((*itr).count[3] == 0) continue; //skip all non vertical edges
+ l90sd.insert(std::make_pair((*itr).pt.x(), std::make_pair((*itr).pt.y(), (*itr).count[3])), false, VERTICAL);
+ }
+ for(typename value_type::const_iterator itr = rvalue.data_.begin(); itr != rvalue.data_.end(); ++itr) {
+ if((*itr).count[3] == 0) continue; //skip all non vertical edges
+ r90sd.insert(std::make_pair((*itr).pt.x(), std::make_pair((*itr).pt.y(), (*itr).count[3])), false, VERTICAL);
+ }
+ l90sd.sort();
+ r90sd.sort();
+ if(op == 0) {
+ output.applyBooleanBinaryOp(l90sd.begin(), l90sd.end(),
+ r90sd.begin(), r90sd.end(), boolean_op::BinaryCount<boolean_op::BinaryOr>());
+ } else if (op == 1) {
+ output.applyBooleanBinaryOp(l90sd.begin(), l90sd.end(),
+ r90sd.begin(), r90sd.end(), boolean_op::BinaryCount<boolean_op::BinaryAnd>());
+ } else if (op == 2) {
+ output.applyBooleanBinaryOp(l90sd.begin(), l90sd.end(),
+ r90sd.begin(), r90sd.end(), boolean_op::BinaryCount<boolean_op::BinaryNot>());
+ } else if (op == 3) {
+ output.applyBooleanBinaryOp(l90sd.begin(), l90sd.end(),
+ r90sd.begin(), r90sd.end(), boolean_op::BinaryCount<boolean_op::BinaryXor>());
+ }
+ result.clear();
+ result.insert(output);
+ } else {
+ sort();
+ rvalue.sort();
+ typename boolean_op_45<Unit>::Scan45 scan45(op);
+ std::vector<typename boolean_op_45<Unit>::Vertex45> eventOut;
+ std::vector<typename boolean_op_45<Unit>::Scan45Vertex> eventIn;
+ typename value_type::const_iterator iter1 = data_.begin();
+ typename value_type::const_iterator iter2 = rvalue.data_.begin();
+ typename value_type::const_iterator end1 = data_.end();
+ typename value_type::const_iterator end2 = rvalue.data_.end();
+ const Unit UnitMax = std::numeric_limits<Unit>::max();
+ Unit x = UnitMax;
+ while(iter1 != end1 || iter2 != end2) {
+ Unit currentX = UnitMax;
+ if(iter1 != end1) currentX = iter1->pt.x();
+ if(iter2 != end2) currentX = std::min(currentX, iter2->pt.x());
+ if(currentX != x) {
+ //std::cout << "SCAN " << currentX << "\n";
+ //scan event
+ scan45.scan(eventOut, eventIn.begin(), eventIn.end());
+ std::sort(eventOut.begin(), eventOut.end());
+ for(unsigned int i = 0; i < eventOut.size(); ++i) {
+ if(!result.data_.empty() &&
+ result.data_.back().pt == eventOut[i].pt) {
+ result.data_.back().count += eventOut[i];
+ } else {
+ if(!result.data_.empty() &&
+ result.data_.back().count.is_45()) {
+ result.is_manhattan_ = false;
+ }
+ result.data_.push_back(eventOut[i]);
+ }
+ if(result.data_.back().count == (typename polygon_45_formation<Unit>::Vertex45Count(0, 0, 0, 0))) {
+ result.data_.pop_back();
+ }
+ }
+ eventOut.clear();
+ eventIn.clear();
+ x = currentX;
+ }
+ //std::cout << "get next\n";
+ if(iter2 != end2 && (iter1 == end1 || iter2->pt.x() < iter1->pt.x() ||
+ (iter2->pt.x() == iter1->pt.x() &&
+ iter2->pt.y() < iter1->pt.y()) )) {
+ //std::cout << "case1 next\n";
+ eventIn.push_back(typename boolean_op_45<Unit>::Scan45Vertex(iter2->pt,
+ typename polygon_45_formation<Unit>::
+ Scan45Count(typename polygon_45_formation<Unit>::Count2(0, iter2->count[0]),
+ typename polygon_45_formation<Unit>::Count2(0, iter2->count[1]),
+ typename polygon_45_formation<Unit>::Count2(0, iter2->count[2]),
+ typename polygon_45_formation<Unit>::Count2(0, iter2->count[3]))));
+ ++iter2;
+ } else if(iter1 != end1 && (iter2 == end2 || iter1->pt.x() < iter2->pt.x() ||
+ (iter1->pt.x() == iter2->pt.x() &&
+ iter1->pt.y() < iter2->pt.y()) )) {
+ //std::cout << "case2 next\n";
+ eventIn.push_back(typename boolean_op_45<Unit>::Scan45Vertex(iter1->pt,
+ typename polygon_45_formation<Unit>::
+ Scan45Count(
+ typename polygon_45_formation<Unit>::Count2(iter1->count[0], 0),
+ typename polygon_45_formation<Unit>::Count2(iter1->count[1], 0),
+ typename polygon_45_formation<Unit>::Count2(iter1->count[2], 0),
+ typename polygon_45_formation<Unit>::Count2(iter1->count[3], 0))));
+ ++iter1;
+ } else {
+ //std::cout << "case3 next\n";
+ eventIn.push_back(typename boolean_op_45<Unit>::Scan45Vertex(iter2->pt,
+ typename polygon_45_formation<Unit>::
+ Scan45Count(typename polygon_45_formation<Unit>::Count2(iter1->count[0],
+ iter2->count[0]),
+ typename polygon_45_formation<Unit>::Count2(iter1->count[1],
+ iter2->count[1]),
+ typename polygon_45_formation<Unit>::Count2(iter1->count[2],
+ iter2->count[2]),
+ typename polygon_45_formation<Unit>::Count2(iter1->count[3],
+ iter2->count[3]))));
+ ++iter1;
+ ++iter2;
+ }
+ }
+ scan45.scan(eventOut, eventIn.begin(), eventIn.end());
+ std::sort(eventOut.begin(), eventOut.end());
+ for(unsigned int i = 0; i < eventOut.size(); ++i) {
+ if(!result.data_.empty() &&
+ result.data_.back().pt == eventOut[i].pt) {
+ result.data_.back().count += eventOut[i];
+ } else {
+ if(!result.data_.empty() &&
+ result.data_.back().count.is_45()) {
+ result.is_manhattan_ = false;
+ }
+ result.data_.push_back(eventOut[i]);
+ }
+ if(result.data_.back().count == typename polygon_45_formation<Unit>::Vertex45Count(0, 0, 0, 0)) {
+ result.data_.pop_back();
+ }
+ }
+ if(!result.data_.empty() &&
+ result.data_.back().count.is_45()) {
+ result.is_manhattan_ = false;
+ }
+ //std::cout << "DONE SCANNING\n";
+ }
+ }
+
+// template <typename Unit>
+// inline void polygon_45_set_data<Unit>::applyBoolean_(int op, value_type& rvalue) const {
+// value_type tmp;
+// applyBoolean_(tmp, op, rvalue);
+// data_.swap(tmp); //swapping vectors should be constant time operation
+// unsorted_ = false;
+// dirty_ = false;
+// }
+
+// template <typename Unit>
+// inline void polygon_45_set_data<Unit>::applyBoolean_(value_type& result, int op,
+// value_type& rvalue) const {
+// unsigned int originalSize = result.size();
+// try {
+// applyBooleanException_(result, op, rvalue);
+// } catch (std::string str) {
+// std::string msg = "GTL 45 Boolean error, precision insufficient to represent edge intersection coordinate value.";
+// if(str == msg) {
+// result.resize(originalSize);
+// snap();
+// std::sort(data_.begin(), data_.end());
+// for(typename value_type::iterator itr = rvalue.begin();
+// itr != rvalue.end(); ++itr) {
+// snap_vertex_45(*itr);
+// }
+// std::sort(rvalue.begin(), rvalue.end());
+// applyBooleanException_(result, op, rvalue);
+// } else { throw str; }
+// }
+// }
+
+// template <typename Unit>
+// inline void polygon_45_set_data<Unit>::applyBooleanException_(value_type& result, int op,
+// value_type& rvalue) const {
+// typename boolean_op_45<Unit>::Scan45 scan45(op);
+// std::vector<typename boolean_op_45<Unit>::Vertex45> eventOut;
+// std::vector<typename boolean_op_45<Unit>::Scan45Vertex> eventIn;
+// typename value_type::const_iterator iter1 = data_.begin();
+// typename value_type::const_iterator iter2 = rvalue.begin();
+// typename value_type::const_iterator end1 = data_.end();
+// typename value_type::const_iterator end2 = rvalue.end();
+// const Unit UnitMax = std::numeric_limits<Unit>::max();
+// Unit x = UnitMax;
+// while(iter1 != end1 || iter2 != end2) {
+// Unit currentX = UnitMax;
+// if(iter1 != end1) currentX = iter1->pt.x();
+// if(iter2 != end2) currentX = std::min(currentX, iter2->pt.x());
+// if(currentX != x) {
+// //std::cout << "SCAN " << currentX << "\n";
+// //scan event
+// scan45.scan(eventOut, eventIn.begin(), eventIn.end());
+// std::sort(eventOut.begin(), eventOut.end());
+// for(unsigned int i = 0; i < eventOut.size(); ++i) {
+// if(!result.empty() &&
+// result.back().pt == eventOut[i].pt) {
+// result.back().count += eventOut[i];
+// } else {
+// result.push_back(eventOut[i]);
+// }
+// if(result.back().count == (typename polygon_45_formation<Unit>::Vertex45Count(0, 0, 0, 0))) {
+// result.pop_back();
+// }
+// }
+// eventOut.clear();
+// eventIn.clear();
+// x = currentX;
+// }
+// //std::cout << "get next\n";
+// if(iter2 != end2 && (iter1 == end1 || iter2->pt.x() < iter1->pt.x() ||
+// (iter2->pt.x() == iter1->pt.x() &&
+// iter2->pt.y() < iter1->pt.y()) )) {
+// //std::cout << "case1 next\n";
+// eventIn.push_back(typename boolean_op_45<Unit>::Scan45Vertex(iter2->pt,
+// typename polygon_45_formation<Unit>::
+// Scan45Count(typename polygon_45_formation<Unit>::Count2(0, iter2->count[0]),
+// typename polygon_45_formation<Unit>::Count2(0, iter2->count[1]),
+// typename polygon_45_formation<Unit>::Count2(0, iter2->count[2]),
+// typename polygon_45_formation<Unit>::Count2(0, iter2->count[3]))));
+// ++iter2;
+// } else if(iter1 != end1 && (iter2 == end2 || iter1->pt.x() < iter2->pt.x() ||
+// (iter1->pt.x() == iter2->pt.x() &&
+// iter1->pt.y() < iter2->pt.y()) )) {
+// //std::cout << "case2 next\n";
+// eventIn.push_back(typename boolean_op_45<Unit>::Scan45Vertex(iter1->pt,
+// typename polygon_45_formation<Unit>::
+// Scan45Count(
+// typename polygon_45_formation<Unit>::Count2(iter1->count[0], 0),
+// typename polygon_45_formation<Unit>::Count2(iter1->count[1], 0),
+// typename polygon_45_formation<Unit>::Count2(iter1->count[2], 0),
+// typename polygon_45_formation<Unit>::Count2(iter1->count[3], 0))));
+// ++iter1;
+// } else {
+// //std::cout << "case3 next\n";
+// eventIn.push_back(typename boolean_op_45<Unit>::Scan45Vertex(iter2->pt,
+// typename polygon_45_formation<Unit>::
+// Scan45Count(typename polygon_45_formation<Unit>::Count2(iter1->count[0],
+// iter2->count[0]),
+// typename polygon_45_formation<Unit>::Count2(iter1->count[1],
+// iter2->count[1]),
+// typename polygon_45_formation<Unit>::Count2(iter1->count[2],
+// iter2->count[2]),
+// typename polygon_45_formation<Unit>::Count2(iter1->count[3],
+// iter2->count[3]))));
+// ++iter1;
+// ++iter2;
+// }
+// }
+// scan45.scan(eventOut, eventIn.begin(), eventIn.end());
+// std::sort(eventOut.begin(), eventOut.end());
+// for(unsigned int i = 0; i < eventOut.size(); ++i) {
+// if(!result.empty() &&
+// result.back().pt == eventOut[i].pt) {
+// result.back().count += eventOut[i];
+// } else {
+// result.push_back(eventOut[i]);
+// }
+// if(result.back().count == typename polygon_45_formation<Unit>::Vertex45Count(0, 0, 0, 0)) {
+// result.pop_back();
+// }
+// }
+// //std::cout << "DONE SCANNING\n";
+// }
+
+
+ template <typename Unit>
+ inline std::ostream& operator<< (std::ostream& o, const polygon_45_set_data<Unit>& p) {
+ o << "Polygon45Set ";
+ o << " " << !p.sorted() << " " << p.dirty() << " { ";
+ for(typename polygon_45_set_data<Unit>::iterator_type itr = p.begin();
+ itr != p.end(); ++itr) {
+ o << (*itr).pt << ":";
+ for(unsigned int i = 0; i < 4; ++i) {
+ o << (*itr).count[i] << ",";
+ } o << " ";
+ //o << (*itr).first << ":" << (*itr).second << "; ";
+ }
+ o << "} ";
+ return o;
+ }
+
+ template <typename Unit>
+ inline std::istream& operator>> (std::istream& i, polygon_45_set_data<Unit>& p) {
+ //TODO
+ return i;
+ }
+
+
+}
+#endif
+
Added: sandbox/gtl/gtl/polygon_45_set_traits.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_45_set_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,136 @@
+/*
+ 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 GTL_POLYGON_45_SET_TRAITS_HPP
+#define GTL_POLYGON_45_SET_TRAITS_HPP
+namespace gtl {
+
+ //default definition of polygon 45 set traits works for any model of polygon 45, polygon 45 with holes or any vector or list thereof
+ template <typename T>
+ struct polygon_45_set_traits {
+ typedef typename get_coordinate_type<T, typename geometry_concept<T>::type >::type coordinate_type;
+ typedef typename get_iterator_type<T>::type iterator_type;
+ typedef T operator_arg_type;
+
+ static inline iterator_type begin(const T& polygon_set) {
+ return get_iterator_type<T>::begin(polygon_set);
+ }
+
+ static inline iterator_type end(const T& polygon_set) {
+ return get_iterator_type<T>::end(polygon_set);
+ }
+
+ static inline bool clean(const T& polygon_set) { return false; }
+
+ static inline bool sorted(const T& polygon_set) { return false; }
+ };
+
+ template <typename T>
+ struct is_45_polygonal_concept { typedef gtl_no type; };
+ template <>
+ struct is_45_polygonal_concept<polygon_45_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_45_polygonal_concept<polygon_45_with_holes_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_45_polygonal_concept<polygon_45_set_concept> { typedef gtl_yes type; };
+
+ template <typename T>
+ struct is_polygon_45_set_type {
+ typedef typename is_45_polygonal_concept<typename geometry_concept<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_polygon_45_set_type<std::list<T> > {
+ typedef typename is_45_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type type;
+ };
+ template <typename T>
+ struct is_polygon_45_set_type<std::vector<T> > {
+ typedef typename is_45_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_45_set_type {
+ typedef typename gtl_same_type<polygon_45_set_concept, typename geometry_concept<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_mutable_polygon_45_set_type<std::list<T> > {
+ typedef typename is_45_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type type;
+ };
+ template <typename T>
+ struct is_mutable_polygon_45_set_type<std::vector<T> > {
+ typedef typename is_45_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type type;
+ };
+
+ template <typename T>
+ bool fracture_holes_45_by_concept() { return false; }
+ template <>
+ inline bool fracture_holes_45_by_concept<polygon_45_concept>() { return true; }
+
+ template <typename T, typename iT>
+ void get_45_polygons_T(T& t, iT begin, iT end) {
+ typedef typename polygon_45_set_traits<T>::coordinate_type Unit;
+ typedef typename geometry_concept<typename T::value_type>::type CType;
+ typename polygon_45_formation<Unit>::Polygon45Formation pf(fracture_holes_45_by_concept<CType>());
+ //std::cout << "FORMING POLYGONS\n";
+ pf.scan(t, begin, end);
+ }
+
+ template <typename T>
+ struct polygon_45_set_mutable_traits {};
+ template <typename T>
+ struct polygon_45_set_mutable_traits<std::list<T> > {
+ template <typename input_iterator_type>
+ static inline void set(std::list<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end) {
+ polygon_set.clear();
+ polygon_45_set_data<typename polygon_45_set_traits<std::list<T> >::coordinate_type> ps;
+ ps.insert(input_begin, input_end);
+ ps.sort();
+ get_45_polygons_T(polygon_set, ps.begin(), ps.end());
+ }
+ };
+ template <typename T>
+ struct polygon_45_set_mutable_traits<std::vector<T> > {
+ template <typename input_iterator_type>
+ static inline void set(std::vector<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end) {
+ polygon_set.clear();
+ polygon_45_set_data<typename polygon_45_set_traits<std::list<T> >::coordinate_type> ps;
+ ps.insert(input_begin, input_end);
+ ps.sort();
+ get_45_polygons_T(polygon_set, ps.begin(), ps.end());
+ }
+ };
+
+ template <typename T>
+ struct polygon_45_set_mutable_traits<polygon_45_set_data<T> > {
+ template <typename input_iterator_type>
+ static inline void set(polygon_45_set_data<T>& polygon_set,
+ input_iterator_type input_begin, input_iterator_type input_end) {
+ polygon_set.set(input_begin, input_end);
+ }
+ };
+ template <typename T>
+ struct polygon_45_set_traits<polygon_45_set_data<T> > {
+ typedef typename polygon_45_set_data<T>::coordinate_type coordinate_type;
+ typedef typename polygon_45_set_data<T>::iterator_type iterator_type;
+ typedef typename polygon_45_set_data<T>::operator_arg_type operator_arg_type;
+
+ static inline iterator_type begin(const polygon_45_set_data<T>& polygon_set) {
+ return polygon_set.begin();
+ }
+
+ static inline iterator_type end(const polygon_45_set_data<T>& polygon_set) {
+ return polygon_set.end();
+ }
+
+ static inline bool clean(const polygon_45_set_data<T>& polygon_set) { polygon_set.clean(); return true; }
+
+ static inline bool sorted(const polygon_45_set_data<T>& polygon_set) { int untested = 0;polygon_set.sort(); return true; }
+
+ };
+
+}
+#endif
+
Added: sandbox/gtl/gtl/polygon_45_set_view.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_45_set_view.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,282 @@
+/*
+ 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 GTL_POLYGON_45_SET_VIEW_HPP
+#define GTL_POLYGON_45_SET_VIEW_HPP
+namespace gtl {
+
+ template <typename ltype, typename rtype, int op_type>
+ class polygon_45_set_view;
+
+ template <typename ltype, typename rtype, int op_type>
+ struct polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> > {
+ typedef typename polygon_45_set_view<ltype, rtype, op_type>::coordinate_type coordinate_type;
+ typedef typename polygon_45_set_view<ltype, rtype, op_type>::iterator_type iterator_type;
+ typedef typename polygon_45_set_view<ltype, rtype, op_type>::operator_arg_type operator_arg_type;
+
+ static inline iterator_type begin(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set);
+ static inline iterator_type end(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set);
+
+ template <typename input_iterator_type>
+ static inline void set(polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set,
+ input_iterator_type input_begin, input_iterator_type input_end);
+
+ static inline bool clean(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set);
+
+ };
+
+ template <typename ltype, typename rtype, int op_type>
+ class polygon_45_set_view {
+ public:
+ typedef typename polygon_45_set_traits<ltype>::coordinate_type coordinate_type;
+ typedef polygon_45_set_data<coordinate_type> value_type;
+ typedef typename value_type::iterator_type iterator_type;
+ typedef polygon_45_set_view operator_arg_type;
+ private:
+ const ltype& lvalue_;
+ const rtype& rvalue_;
+ mutable value_type output_;
+ mutable bool evaluated_;
+ public:
+ polygon_45_set_view(const ltype& lvalue,
+ const rtype& rvalue ) :
+ lvalue_(lvalue), rvalue_(rvalue), evaluated_(false) {}
+
+ /// get iterator to begin vertex data
+ public:
+ const value_type& value() const {
+ if(!evaluated_) {
+ evaluated_ = true;
+ value_type rinput_;
+ output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
+ polygon_45_set_traits<ltype>::end(lvalue_));
+ //polygon_45_set_traits<rtype>::clean(rvalue_);
+ rinput_.set(polygon_45_set_traits<rtype>::begin(rvalue_),
+ polygon_45_set_traits<rtype>::end(rvalue_));
+ if(op_type == 0)
+ output_ |= rinput_;
+ else if(op_type == 1)
+ output_ &= rinput_;
+ else if(op_type == 2)
+ output_ ^= rinput_;
+ else
+ output_ -= rinput_;
+ }
+ return output_;
+ }
+ public:
+ iterator_type begin() const { return value().begin(); }
+ iterator_type end() const { return value().end(); }
+
+ bool dirty() const { return value().dirty(); } //result of a boolean is clean
+ bool sorted() const { return value().sorted(); } //result of a boolean is sorted
+
+// template <typename input_iterator_type>
+// void set(input_iterator_type input_begin, input_iterator_type input_end,
+// orientation_2d orient) const {
+// orient_ = orient;
+// output_.clear();
+// output_.insert(output_.end(), input_begin, input_end);
+// std::sort(output_.begin(), output_.end());
+// }
+ };
+
+ template <typename ltype, typename rtype, int op_type>
+ typename polygon_45_set_view<ltype, rtype, op_type>::iterator_type
+ polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::
+ begin(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set) {
+ return polygon_45_set.begin();
+ }
+ template <typename ltype, typename rtype, int op_type>
+ typename polygon_45_set_view<ltype, rtype, op_type>::iterator_type
+ polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::
+ end(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set) {
+ return polygon_45_set.end();
+ }
+ template <typename ltype, typename rtype, int op_type>
+ bool polygon_45_set_traits<polygon_45_set_view<ltype, rtype, op_type> >::
+ clean(const polygon_45_set_view<ltype, rtype, op_type>& polygon_45_set) {
+ return polygon_45_set.value().clean(); }
+
+ template <typename geometry_type_1, typename geometry_type_2, int op_type>
+ geometry_type_1& self_assignment_boolean_op_45(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
+ typedef geometry_type_1 ltype;
+ typedef geometry_type_2 rtype;
+ typedef typename polygon_45_set_traits<ltype>::coordinate_type coordinate_type;
+ typedef polygon_45_set_data<coordinate_type> value_type;
+ value_type output_;
+ value_type rinput_;
+ output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
+ polygon_45_set_traits<ltype>::end(lvalue_));
+ rinput_.set(polygon_45_set_traits<rtype>::begin(rvalue_),
+ polygon_45_set_traits<rtype>::end(rvalue_));
+ if(op_type == 0)
+ output_ |= rinput_;
+ else if(op_type == 1)
+ output_ &= rinput_;
+ else if(op_type == 2)
+ output_ ^= rinput_;
+ else
+ output_ -= rinput_;
+ polygon_45_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end());
+ return lvalue_;
+ }
+
+ template <typename concept_type>
+ struct fracture_holes_option_by_type {
+ static const bool value = true;
+ };
+ template <>
+ struct fracture_holes_option_by_type<polygon_45_with_holes_concept> {
+ static const bool value = false;
+ };
+ template <>
+ struct fracture_holes_option_by_type<polygon_with_holes_concept> {
+ static const bool value = false;
+ };
+
+ template <typename ltype, typename rtype, int op_type>
+ struct geometry_concept<polygon_45_set_view<ltype, rtype, op_type> > { typedef polygon_45_set_concept type; };
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_45_set_view<geometry_type_1, geometry_type_2, 0> >::type
+ operator|(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_45_set_view<geometry_type_1, geometry_type_2, 0>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_45_set_view<geometry_type_1, geometry_type_2, 0> >::type
+ operator+(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_45_set_view<geometry_type_1, geometry_type_2, 0>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_45_set_view<geometry_type_1, geometry_type_2, 1> >::type
+ operator*(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_45_set_view<geometry_type_1, geometry_type_2, 1>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_45_set_view<geometry_type_1, geometry_type_2, 2> >::type
+ operator^(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_45_set_view<geometry_type_1, geometry_type_2, 2>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_45_set_view<geometry_type_1, geometry_type_2, 3> >::type
+ operator-(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_45_set_view<geometry_type_1, geometry_type_2, 3>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator+=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 0>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator|=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 0>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator*=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 1>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator&=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 1>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator^=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 2>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator-=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op_45<geometry_type_1, geometry_type_2, 3>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ polygon_45_set_data<typename polygon_90_set_traits<geometry_type_1>::coordinate_type> >::type
+ operator+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ polygon_45_set_data<typename polygon_45_set_traits<geometry_type_1>::coordinate_type> ps;
+ assign(ps, lvalue);
+ resize(ps, rvalue);
+ return ps;
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ polygon_45_set_data<typename polygon_90_set_traits<geometry_type_1>::coordinate_type> >::type
+ operator-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ polygon_45_set_data<typename polygon_45_set_traits<geometry_type_1>::coordinate_type> ps;
+ assign(ps, lvalue);
+ resize(ps, -rvalue);
+ return ps;
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ geometry_type_1>::type &
+ operator+=(geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ return resize(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ geometry_type_1>::type &
+ operator-=(geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ return resize(lvalue, -rvalue);
+ }
+}
+#endif
+
Modified: sandbox/gtl/gtl/polygon_45_with_holes_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_with_holes_concept.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_with_holes_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -9,9 +9,9 @@
#define GTL_POLYGON_45_WITH_HOLES_CONCEPT_HPP
namespace gtl {
-struct polygon_45_with_holes_concept : virtual polygon_45_concept, virtual polygon_90_with_holes_concept {
+struct polygon_45_with_holes_concept : public polygon_45_concept {
public:
- inline polygon_45_with_holes_concept() {}
+ //inline polygon_45_with_holes_concept() {}
template <typename T>
struct coordinate_type {
@@ -19,13 +19,8 @@
};
template <typename T>
- struct center_type {
- typedef point_data<typename coordinate_type<T>::type> type;
- };
-
- template <typename T>
struct area_type {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::area_type type;
+ typedef typename polygon_traits<T>::area_type type;
};
template <typename T>
@@ -38,6 +33,42 @@
typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_distance type;
};
+ template <typename T>
+ struct point_type {
+ typedef typename polygon_traits<T>::iterator_type iterator;
+ typedef typename std::iterator_traits<iterator>::value_type type;
+ };
+
+ template<typename polygon_with_holes_type, typename hole_iterator_type>
+ static void set_holes(polygon_with_holes_type& polygon, hole_iterator_type holes_begin, hole_iterator_type holes_end) {
+ polygon_with_holes_traits<polygon_with_holes_type>::set_holes(polygon, holes_begin, holes_end);
+ }
+
+ template <typename polygon_with_holes_type>
+ static typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type
+ begin_holes(const polygon_with_holes_type& polygon) {
+ return polygon_with_holes_traits<polygon_with_holes_type>::begin_holes(polygon);
+ }
+
+ template <typename polygon_with_holes_type>
+ static typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type
+ end_holes(const polygon_with_holes_type& polygon) {
+ return polygon_with_holes_traits<polygon_with_holes_type>::end_holes(polygon);
+ }
+
+ template <typename polygon_with_holes_type_1, typename polygon_with_holes_type_2>
+ static polygon_with_holes_type_1 copy_construct(const polygon_with_holes_type_2& polygon) {
+ polygon_with_holes_type_1 retval;
+ set(retval, polygon_45_concept::begin(polygon), polygon_45_concept::end(polygon));
+ set_holes(retval, begin_holes(polygon), end_holes(polygon));
+ return retval;
+ }
+
+ template <typename polygon_with_holes_type>
+ static std::size_t size_holes(const polygon_with_holes_type& polygon) {
+ return polygon_with_holes_traits<polygon_with_holes_type>::size_holes(polygon);
+ }
+
template <typename polygon_with_holes_type_1, typename polygon_with_holes_type_2>
static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const polygon_with_holes_type_2& rvalue) {
polygon_45_concept::assign(lvalue, rvalue);
@@ -49,7 +80,7 @@
static typename area_type<polygon_with_holes_type>::type
area(const polygon_with_holes_type& polygon) {
typedef typename polygon_traits<polygon_with_holes_type>::coordinate_type coordinate_type;
- typename coordinate_traits<coordinate_type>::area_type retval = polygon_45_concept::area(polygon);
+ typename area_type<polygon_with_holes_type>::type retval = polygon_45_concept::area(polygon);
typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type b, e;
e = end_holes(polygon);
for(b = begin_holes(polygon); b != e; ++b) {
@@ -119,18 +150,80 @@
return polygon_45_concept::winding(polygon);
}
+ template <typename point_type, typename polygon_type>
+ static bool
+ center(point_type& center_point, const polygon_type& polygon) {
+ return polygon_45_concept::center(center_point, polygon);
+ }
+
+ template <typename polygon_type, typename rectangle_type>
+ static bool
+ extents(rectangle_type& bounding_box, const polygon_type& polygon) {
+ return polygon_45_concept::extents(bounding_box, polygon);
+ }
+
template <typename polygon_type>
- static typename center_type<polygon_type>::type
- center(const polygon_type& polygon) {
- return polygon_45_concept::center(polygon);
+ static polygon_type& scale_down(polygon_type& polygon,
+ typename coordinate_traits<typename coordinate_type<polygon_type>::type>::unsigned_area_type factor) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ holes.push_back(*b);
+ polygon_45_concept::scale_down(holes.back(), factor);
+ }
+ set_holes(polygon, holes.begin(), holes.end());
+ polygon_45_concept::scale_down(polygon, factor);
+ return polygon;
+ }
+
+ template <typename polygon_type>
+ static polygon_type& scale_up(polygon_type& polygon,
+ typename coordinate_traits<typename coordinate_type<polygon_type>::type>::unsigned_area_type factor) {
+ return polygon_90_with_holes_concept::scale_up(polygon, factor);
+ }
+
+ template <typename polygon_type, typename scaling_type>
+ static polygon_type& scale(polygon_type& polygon,
+ const scaling_type& scaling) {
+ return polygon_90_with_holes_concept::scale(polygon, scaling);
+ }
+
+ template <typename polygon_type, typename transformation_type>
+ static polygon_type& transform(polygon_type& polygon,
+ const transformation_type& transformation) {
+ return polygon_90_with_holes_concept::transform(polygon, transformation);
}
template <typename polygon_type>
- static rectangle_data<typename polygon_traits<polygon_type>::coordinate_type>
- bounding_box(const polygon_type& polygon) {
- return polygon_45_concept::bounding_box(polygon);
+ static polygon_type&
+ snap_to_45(polygon_type& polygon) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ holes.push_back(*b);
+ polygon_45_concept::snap_to_45(holes.back());
+ }
+ set_holes(polygon, holes.begin(), holes.end());
+ polygon_45_concept::snap_to_45(polygon);
+ return polygon;
}
+ template <typename polygon_type>
+ static bool
+ is_45(const polygon_type& polygon) {
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ if(!polygon_45_concept::is_45(*b)) return false;
+ }
+ return polygon_45_concept::is_45(polygon);
+ }
};
}
Modified: sandbox/gtl/gtl/polygon_45_with_holes_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_with_holes_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_with_holes_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -15,22 +15,28 @@
typedef polygon_45_with_holes_concept geometry_type;
typedef T coordinate_type;
typedef typename polygon_45_data<T>::iterator_type iterator_type;
- typedef typename polygon_45_data<T>::compact_iterator_type compact_iterator_type;
typedef typename std::list<polygon_45_data<coordinate_type> >::const_iterator iterator_holes_type;
typedef polygon_45_data<coordinate_type> hole_type;
+ typedef typename coordinate_traits<T>::coordinate_distance area_type;
+ typedef point_data<T> point_type;
/// default constructor of point does not initialize x and y
inline polygon_45_with_holes_data(){;} //do nothing default constructor
template<class iT>
- inline polygon_45_with_holes_data& set(iT input_begin, iT input_end) {
- self_.set(input_begin, input_end);
- return *this;
+ inline polygon_45_with_holes_data(iT input_begin, iT input_end) {
+ set(input_begin, input_end);
+ }
+
+ template<class iT, typename hiT>
+ inline polygon_45_with_holes_data(iT input_begin, iT input_end, hiT holes_begin, hiT holes_end) {
+ set(input_begin, input_end);
+ set_holes(holes_begin, holes_end);
}
template<class iT>
- inline polygon_45_with_holes_data& set_compact(iT input_begin, iT input_end) {
- self_.set_compact(input_begin, input_end);
+ inline polygon_45_with_holes_data& set(iT input_begin, iT input_end) {
+ self_.set(input_begin, input_end);
return *this;
}
@@ -67,16 +73,6 @@
return self_.end();
}
- /// get begin iterator, returns a pointer to a const coordinate_type
- inline const compact_iterator_type begin_compact() const {
- return self_.begin_compact();
- }
-
- /// get end iterator, returns a pointer to a const coordinate_type
- inline const compact_iterator_type end_compact() const {
- return self_.end_compact();
- }
-
inline unsigned int size() const {
return self_.size();
}
Modified: sandbox/gtl/gtl/polygon_90_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_90_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_90_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -16,6 +16,7 @@
typedef T coordinate_type;
typedef typename std::vector<coordinate_type>::const_iterator compact_iterator_type;
typedef iterator_compact_to_points<compact_iterator_type, point_data<coordinate_type> > iterator_type;
+ typedef typename coordinate_traits<T>::area_type area_type;
inline polygon_90_data(){;} //do nothing default constructor
@@ -49,6 +50,11 @@
template <typename T2>
inline polygon_90_data& operator=(const T2& rvalue);
+ /// assignment operator (since we have dynamic memory do a deep copy)
+ inline bool operator==(const polygon_90_data& that) const {
+ return coords_ == that.coords_;
+ }
+
/// get begin iterator, returns a pointer to a const Unit
inline iterator_type begin() const { return iterator_type(coords_.begin(), coords_.end()); }
@@ -62,11 +68,72 @@
inline compact_iterator_type end_compact() const { return coords_.end(); }
inline std::size_t size() const { return coords_.size(); }
-
+
+ inline void swap(polygon_90_data& that) {
+ int INSTANTIATED = 0;
+ coords_.swap(that.coords_);
+ }
+
private:
std::vector<coordinate_type> coords_;
};
+
+template <typename T>
+std::ostream& operator << (std::ostream& o, const polygon_90_data<T>& r)
+{
+ o << "Polygon { ";
+ for(typename polygon_90_data<T>::iterator_type itr = r.begin(); itr != r.end(); ++itr) {
+ o << *itr << ", ";
+ }
+ return o << "} ";
+}
+
+template <typename T>
+std::istream& operator >> (std::istream& i, polygon_90_data<T>& r)
+{
+ unsigned int size;
+ i >> size;
+ std::vector<T> vec;
+ vec.reserve(size);
+ for(unsigned int ii = 0; ii < size; ++ii) {
+ T coord;
+ i >> coord;
+ vec.push_back(coord);
+ }
+ r.set_compact(vec.begin(), vec.end());
+ return i;
+}
+template <typename T>
+std::ostream& operator << (std::ostream& o, const std::vector<polygon_90_data<T> >& r) {
+ o << r.size() << ' ';
+ for(unsigned int ii = 0; ii < r.size(); ++ii) {
+ o << (r[ii]);
+ }
+ return o;
+}
+template <typename T>
+std::istream& operator >> (std::istream& i, std::vector<polygon_90_data<T> >& r) {
+ unsigned int size;
+ i >> size;
+ r.clear();
+ r.reserve(size);
+ for(unsigned int ii = 0; ii < size; ++ii) {
+ polygon_90_data<T> tmp;
+ i >> tmp;
+ r.push_back(tmp);
+ }
+ return i;
+}
+
+}
+
+namespace std {
+template <typename T>
+void swap(gtl::polygon_90_data<T>& l, gtl::polygon_90_data<T>& r) {
+ l.swap(r);
+}
+
}
#endif
Added: sandbox/gtl/gtl/polygon_90_set_concept.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_90_set_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,558 @@
+/*
+ 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 GTL_POLYGON_90_SET_CONCEPT_HPP
+#define GTL_POLYGON_90_SET_CONCEPT_HPP
+namespace gtl {
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
+ typename polygon_90_set_traits<polygon_set_type>::iterator_type>::type
+ begin_90_set_data(const polygon_set_type& polygon_set) {
+ return polygon_90_set_traits<polygon_set_type>::begin(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
+ typename polygon_90_set_traits<polygon_set_type>::iterator_type>::type
+ end_90_set_data(const polygon_set_type& polygon_set) {
+ return polygon_90_set_traits<polygon_set_type>::end(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
+ orientation_2d>::type
+ scanline_orientation(const polygon_set_type& polygon_set) {
+ return polygon_90_set_traits<polygon_set_type>::orient(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
+ bool>::type
+ clean(const polygon_set_type& polygon_set) {
+ return polygon_90_set_traits<polygon_set_type>::clean(polygon_set);
+ }
+
+ //assign
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<polygon_set_type_2>::type>::type,
+ polygon_set_type_1>::type &
+ assign(polygon_set_type_1& lvalue, const polygon_set_type_2& rvalue) {
+ polygon_90_set_mutable_traits<polygon_set_type_1>::set(lvalue, begin_90_set_data(rvalue), end_90_set_data(rvalue), scanline_orientation(rvalue));
+ return lvalue;
+ }
+
+ template <typename T1, typename T2>
+ struct are_not_both_rectangle_concept { typedef void type; };
+ template <>
+ struct are_not_both_rectangle_concept<rectangle_concept, rectangle_concept> {};
+
+ //equivalence
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_3< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<polygon_set_type_2>::type>::type,
+ typename are_not_both_rectangle_concept<typename geometry_concept<polygon_set_type_1>::type,
+ typename geometry_concept<polygon_set_type_2>::type>::type,
+ bool>::type
+ equivalence(const polygon_set_type_1& lvalue,
+ const polygon_set_type_2& rvalue) {
+ polygon_90_set_data<typename polygon_90_set_traits<polygon_set_type_1>::coordinate_type> ps1;
+ assign(ps1, lvalue);
+ polygon_90_set_data<typename polygon_90_set_traits<polygon_set_type_2>::coordinate_type> ps2;
+ assign(ps2, rvalue);
+ return ps1 == ps2;
+ }
+
+ //get: min_rectangles max_rectangles
+ template <typename output_container_type, typename polygon_set_type>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
+ typename is_same_type_SFINAE<rectangle_concept,
+ typename geometry_concept
+ <typename std::iterator_traits
+ <typename output_container_type::iterator>::value_type>::type>::type,
+ void>::type
+ get_max_rectangles(output_container_type& output, const polygon_set_type& polygon_set) {
+ std::vector<rectangle_data<typename polygon_90_set_traits<polygon_set_type>::coordinate_type> > rects;
+ assign(rects, polygon_set);
+ MaxCover<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::getMaxCover(output, rects, scanline_orientation(polygon_set));
+ }
+
+ //clear
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ void>::type
+ clear(polygon_set_type& polygon_set) {
+ polygon_90_set_data<typename polygon_90_set_traits<polygon_set_type>::coordinate_type> ps(scanline_orientation(polygon_set));
+ assign(polygon_set, ps);
+ }
+
+ //empty
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ bool>::type
+ empty(const polygon_set_type& polygon_set) {
+ if(clean(polygon_set)) return begin_90_set_data(polygon_set) == end_90_set_data(polygon_set);
+ polygon_90_set_data<typename polygon_90_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(ps, polygon_set);
+ ps.clean();
+ return ps.empty();
+ }
+
+ //extents
+ template <typename polygon_set_type, typename rectangle_type>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ bool>::type
+ extents(rectangle_type& extents_rectangle,
+ const polygon_set_type& polygon_set) {
+ std::vector<rectangle_type> rects;
+ assign(rects, polygon_set);
+ if(rects.empty()) return false;
+ extents_rectangle = rects[0];
+ for(unsigned int i = 1; i < rects.size(); ++i) {
+ encompass(extents_rectangle, rects[i]);
+ }
+ return true;
+ }
+
+ //area
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::manhattan_area_type>::type
+ area(const polygon_set_type& polygon_set) {
+ typedef rectangle_data<typename polygon_90_set_traits<polygon_set_type>::coordinate_type> rectangle_type;
+ typedef typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::manhattan_area_type area_type;
+ std::vector<rectangle_type> rects;
+ assign(rects, polygon_set);
+ area_type retval = (area_type)0;
+ for(unsigned int i = 0; i < rects.size(); ++i) {
+ retval += (area_type)area(rects[i]);
+ }
+ return retval;
+ }
+
+ //interact
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type_2>::type>::type,
+ polygon_set_type_1>::type
+ interact(polygon_set_type_1& polygon_set_1, const polygon_set_type_2& polygon_set_2) {
+ typedef typename polygon_90_set_traits<polygon_set_type_1>::coordinate_type Unit;
+ typename touch_90_operation<Unit>::TouchSetData tsd;
+ polygon_90_set_data<Unit> ps(scanline_orientation(polygon_set_2));
+ assign(ps, polygon_set_1);
+ touch_90_operation<Unit>::populateTouchSetData(tsd, begin_90_set_data(ps), end_90_set_data(ps), 0);
+ std::vector<polygon_90_data<Unit> > polys;
+ assign(polys, polygon_set_1);
+ std::vector<std::set<int> > graph(polys.size()+1, std::set<int>());
+ for(unsigned int i = 0; i < polys.size(); ++i){
+ polygon_90_set_data<Unit> psTmp(scanline_orientation(polygon_set_2));
+ psTmp.insert(polys[i]);
+ psTmp.clean();
+ touch_90_operation<Unit>::populateTouchSetData(tsd, psTmp.begin(), psTmp.end(), i+1);
+ }
+ touch_90_operation<Unit>::performTouch(graph, tsd);
+ clear(polygon_set_1);
+ ps.clear();
+ for(std::set<int>::iterator itr = graph[0].begin(); itr != graph[0].end(); ++itr){
+ ps.insert(polys[(*itr)-1]);
+ }
+ assign(polygon_set_1, ps);
+ return polygon_set_1;
+ }
+
+ //self_intersect
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ self_intersect(polygon_set_type& polygon_set) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ polygon_90_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ interval_data<Unit> ivl(std::numeric_limits<Unit>::min(), std::numeric_limits<Unit>::max());
+ rectangle_data<Unit> rect(ivl, ivl);
+ ps.insert(rect, true);
+ ps.clean();
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ bloat(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ return bloat(polygon_set, bloating, bloating, bloating, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ bloat(polygon_set_type& polygon_set, orientation_2d orient,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ if(orient == orientation_2d(HORIZONTAL))
+ return bloat(polygon_set, bloating, bloating, 0, 0);
+ return bloat(polygon_set, 0, 0, bloating, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ bloat(polygon_set_type& polygon_set, orientation_2d orient,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type low_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type high_bloating) {
+ if(orient == orientation_2d(HORIZONTAL))
+ return bloat(polygon_set, low_bloating, high_bloating, 0, 0);
+ return bloat(polygon_set, 0, 0, low_bloating, high_bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ bloat(polygon_set_type& polygon_set, direction_2d dir,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ if(dir == direction_2d(EAST))
+ return bloat(polygon_set, 0, bloating, 0, 0);
+ if(dir == direction_2d(WEST))
+ return bloat(polygon_set, bloating, 0, 0, 0);
+ if(dir == direction_2d(SOUTH))
+ return bloat(polygon_set, 0, 0, bloating, 0);
+ return bloat(polygon_set, 0, 0, 0, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ bloat(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type west_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type east_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type south_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type north_bloating) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ std::vector<rectangle_data<Unit> > rects;
+ if(!clean(polygon_set)) {
+ polygon_90_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ clean(ps);
+ assign(rects, ps);
+ } else {
+ assign(rects, polygon_set);
+ }
+ rectangle_data<Unit> convolutionRectangle(interval_data<Unit>(-((Unit)west_bloating), (Unit)east_bloating),
+ interval_data<Unit>(-((Unit)south_bloating), (Unit)north_bloating));
+ for(typename std::vector<rectangle_data<Unit> >::iterator itr = rects.begin();
+ itr != rects.end(); ++itr) {
+ convolve(*itr, convolutionRectangle);
+ }
+ clear(polygon_set);
+ assign(polygon_set, rects);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ shrink(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type shrinking) {
+ return shrink(polygon_set, shrinking, shrinking, shrinking, shrinking);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ shrink(polygon_set_type& polygon_set, orientation_2d orient,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type shrinking) {
+ if(orient == orientation_2d(HORIZONTAL))
+ return shrink(polygon_set, shrinking, shrinking, 0, 0);
+ return shrink(polygon_set, 0, 0, shrinking, shrinking);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ shrink(polygon_set_type& polygon_set, orientation_2d orient,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type low_shrinking,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type high_shrinking) {
+ if(orient == orientation_2d(HORIZONTAL))
+ return shrink(polygon_set, low_shrinking, high_shrinking, 0, 0);
+ return shrink(polygon_set, 0, 0, low_shrinking, high_shrinking);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ shrink(polygon_set_type& polygon_set, direction_2d dir,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type shrinking) {
+ if(dir == direction_2d(EAST))
+ return shrink(polygon_set, 0, shrinking, 0, 0);
+ if(dir == direction_2d(WEST))
+ return shrink(polygon_set, shrinking, 0, 0, 0);
+ if(dir == direction_2d(SOUTH))
+ return shrink(polygon_set, 0, 0, shrinking, 0);
+ return shrink(polygon_set, 0, 0, 0, shrinking);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ shrink(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type west_shrinking,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type east_shrinking,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type south_shrinking,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type north_shrinking) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ polygon_90_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.clean();
+ rectangle_data<Unit> externalBoundary;
+ if(!extents(externalBoundary, ps)) return polygon_set;
+ bloat(externalBoundary, 10); //bloat by diferential ammount
+ //insert a hole that encompasses the data
+ ps.insert(externalBoundary, true); //note that the set is in a dirty state now
+ ps.sort(); //does not apply implicit or operation
+ std::vector<rectangle_data<Unit> > rects;
+ //begin does not apply implicit or operation, this is a dirty range
+ get_rectangles(rects, ps.begin(), ps.end(), scanline_orientation(ps), rectangle_concept());
+ ps.clear();
+ rectangle_data<Unit> convolutionRectangle(interval_data<Unit>(-((Unit)east_shrinking), (Unit)west_shrinking),
+ interval_data<Unit>(-((Unit)north_shrinking), (Unit)south_shrinking));
+ for(typename std::vector<rectangle_data<Unit> >::iterator itr = rects.begin();
+ itr != rects.end(); ++itr) {
+ rectangle_data<Unit>& rect = *itr;
+ convolve(rect, convolutionRectangle);
+ //insert rectangle as a hole
+ ps.insert(rect, true);
+ }
+ convolve(externalBoundary, convolutionRectangle);
+ //insert duplicate of external boundary as solid to cancel out the external hole boundaries
+ ps.insert(externalBoundary);
+ ps.clean(); //we have negative values in the set, so we need to apply an OR operation to make it valid input to a boolean
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type, typename coord_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ resize(polygon_set_type& polygon_set, coord_type resizing) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ if(resizing > 0) {
+ return bloat(polygon_set, resizing);
+ }
+ if(resizing < 0) {
+ return shrink(polygon_set, -resizing);
+ }
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ grow_and(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ return grow_and(polygon_set, bloating, bloating, bloating, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ grow_and(polygon_set_type& polygon_set, orientation_2d orient,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ if(orient == orientation_2d(HORIZONTAL))
+ return grow_and(polygon_set, bloating, bloating, 0, 0);
+ return grow_and(polygon_set, 0, 0, bloating, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ grow_and(polygon_set_type& polygon_set, orientation_2d orient,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type low_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type high_bloating) {
+ if(orient == orientation_2d(HORIZONTAL))
+ return grow_and(polygon_set, low_bloating, high_bloating, 0, 0);
+ return grow_and(polygon_set, 0, 0, low_bloating, high_bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ grow_and(polygon_set_type& polygon_set, direction_2d dir,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+ if(dir == direction_2d(EAST))
+ return grow_and(polygon_set, 0, bloating, 0, 0);
+ if(dir == direction_2d(WEST))
+ return grow_and(polygon_set, bloating, 0, 0, 0);
+ if(dir == direction_2d(SOUTH))
+ return grow_and(polygon_set, 0, 0, bloating, 0);
+ return grow_and(polygon_set, 0, 0, 0, bloating);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ grow_and(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type west_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type east_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type south_bloating,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type north_bloating) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ std::vector<polygon_90_data<Unit> > polys;
+ assign(polys, polygon_set);
+ clear(polygon_set);
+ polygon_90_set_data<Unit> ps(scanline_orientation(polygon_set));
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ polygon_90_set_data<Unit> tmpPs(scanline_orientation(polygon_set));
+ tmpPs.insert(polys[i]);
+ bloat(tmpPs, west_bloating, east_bloating, south_bloating, north_bloating);
+ tmpPs.clean(); //apply implicit OR on tmp polygon set
+ ps.insert(tmpPs);
+ }
+ self_intersect(ps);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale_up(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>
+ ::unsigned_area_type factor) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ std::vector<std::pair<Unit, std::pair<Unit, int> > > tmpVec;
+ polygon_90_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ tmpVec.insert(tmpVec.begin(), ps.begin(), ps.end());
+ for(typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::iterator itr = tmpVec.begin();
+ itr != tmpVec.end(); ++itr) {
+ (*itr).first *= (Unit)factor;
+ (*itr).second.first *= (Unit)factor;
+ }
+ polygon_90_set_mutable_traits<polygon_set_type>::set(polygon_set, tmpVec.begin(), tmpVec.end(),
+ scanline_orientation(polygon_set));
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale_down(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>
+ ::unsigned_area_type factor) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef typename coordinate_traits<Unit>::coordinate_distance dt;
+ std::vector<std::pair<Unit, std::pair<Unit, int> > > tmpVec;
+ polygon_90_set_data<Unit> ps(scanline_orientation(polygon_set));
+ assign(ps, polygon_set);
+ tmpVec.insert(tmpVec.begin(), ps.begin(), ps.end());
+ for(typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::iterator itr = tmpVec.begin();
+ itr != tmpVec.end(); ++itr) {
+ (*itr).first = scaling_policy<Unit>::round((dt)((*itr).first) / (dt)factor);
+ (*itr).second.first = scaling_policy<Unit>::round((dt)((*itr).second.first) / (dt)factor);
+ }
+ ps.clear();
+ ps.insert(tmpVec.begin(), tmpVec.end(), scanline_orientation(polygon_set));
+ clean(ps);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type, typename scaling_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale(polygon_set_type& polygon_set,
+ const scaling_type& scaling) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef typename coordinate_traits<Unit>::coordinate_distance dt;
+ std::vector<std::pair<Unit, std::pair<Unit, int> > > tmpVec;
+ tmpVec.insert(tmpVec.begin(), begin_90_set_data(polygon_set), end_90_set_data(polygon_set));
+ for(typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::iterator itr = tmpVec.begin();
+ itr != tmpVec.end(); ++itr) {
+ if(scanline_orientation(polygon_set) == orientation_2d(VERTICAL)) {
+ scaling.scale((*itr).first, (*itr).second.first);
+ } else {
+ scaling.scale((*itr).second.first, (*itr).first);
+ }
+ }
+ polygon_90_set_data<Unit> ps(scanline_orientation(polygon_set));
+ ps.insert(tmpVec.begin(), tmpVec.end(), scanline_orientation(polygon_set));
+ clean(ps);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ //transform
+ template <typename polygon_set_type, typename transformation_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ transform(polygon_set_type& polygon_set,
+ const transformation_type& transformation) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef typename coordinate_traits<Unit>::coordinate_distance dt;
+ std::vector<std::pair<Unit, std::pair<Unit, int> > > tmpVec;
+ tmpVec.insert(tmpVec.begin(), begin_90_set_data(polygon_set), end_90_set_data(polygon_set));
+ direction_2d dir1, dir2;
+ transformation.get_directions(dir1, dir2);
+ int sign = dir1.get_sign() * dir2.get_sign();
+ for(typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::iterator itr = tmpVec.begin();
+ itr != tmpVec.end(); ++itr) {
+ if(scanline_orientation(polygon_set) == orientation_2d(VERTICAL)) {
+ transformation.transform((*itr).first, (*itr).second.first);
+ } else {
+ transformation.transform((*itr).second.first, (*itr).first);
+ }
+ (*itr).second.second *= sign;
+ }
+ polygon_90_set_data<Unit> ps(scanline_orientation(polygon_set));
+ ps.insert(tmpVec.begin(), tmpVec.end(), scanline_orientation(polygon_set));
+ clean(ps);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ //keep
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ keep(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_area,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_area,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_width,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_width,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_height,
+ typename coordinate_traits<typename polygon_90_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_height) {
+ typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef typename coordinate_traits<Unit>::unsigned_area_type uat;
+ std::list<polygon_90_data<Unit> > polys;
+ assign(polys, polygon_set);
+ clear(polygon_set);
+ typename std::list<polygon_90_data<Unit> >::iterator itr_nxt;
+ for(typename std::list<polygon_90_data<Unit> >::iterator itr = polys.begin(); itr != polys.end(); itr = itr_nxt){
+ itr_nxt = itr;
+ ++itr_nxt;
+ rectangle_data<Unit> bbox;
+ extents(bbox, *itr);
+ uat pwidth = delta(bbox, HORIZONTAL);
+ if(pwidth > min_width && pwidth <= max_width){
+ uat pheight = delta(bbox, VERTICAL);
+ if(pheight > min_height && pheight <= max_height){
+ uat parea = area(*itr);
+ if(parea <= max_area && parea >= min_area) {
+ continue;
+ }
+ }
+ }
+ polys.erase(itr);
+ }
+ assign(polygon_set, polys);
+ return polygon_set;
+ }
+
+}
+#endif
Added: sandbox/gtl/gtl/polygon_90_set_data.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_90_set_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,322 @@
+/*
+ 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 GTL_POLYGON_90_SET_DATA_HPP
+#define GTL_POLYGON_90_SET_DATA_HPP
+namespace gtl {
+ template <typename ltype, typename rtype, typename op_type>
+ class polygon_90_set_view;
+
+ template <typename T>
+ class polygon_90_set_data {
+ public:
+ typedef T coordinate_type;
+ typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
+ typedef typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::const_iterator iterator_type;
+ typedef polygon_90_set_data operator_arg_type;
+
+ /// default constructor
+ inline polygon_90_set_data() : orient_(HORIZONTAL), dirty_(false), unsorted_(false) {}
+
+ /// constructor
+ inline polygon_90_set_data(orientation_2d orient) : orient_(orient), dirty_(false), unsorted_(false) {}
+
+ /// constructor from an iterator pair over vertex data
+ template <typename iT>
+ inline polygon_90_set_data(orientation_2d orient, iT input_begin, iT input_end) {
+ dirty_ = true;
+ unsorted_ = true;
+ for( ; input_begin != input_end; ++input_begin) { insert(*input_begin); }
+ }
+
+ /// copy constructor
+ inline polygon_90_set_data(const polygon_90_set_data& that) :
+ orient_(that.orient_), data_(that.data_), dirty_(that.dirty_), unsorted_(that.unsorted_) {}
+
+ /// copy with orientation change constructor
+ inline polygon_90_set_data(orientation_2d orient, const polygon_90_set_data& that) :
+ orient_(orient), dirty_(false), unsorted_(false) {
+ insert(that, false, that.orient_);
+ }
+
+ /// destructor
+ inline ~polygon_90_set_data() {}
+
+ /// assignement operator
+ inline polygon_90_set_data& operator=(const polygon_90_set_data& that) {
+ if(this == &that) return *this;
+ orient_ = that.orient_;
+ data_ = that.data_;
+ dirty_ = that.dirty_;
+ unsorted_ = that.unsorted_;
+ return *this;
+ }
+
+ template <typename ltype, typename rtype, typename op_type>
+ inline polygon_90_set_data& operator=(const polygon_90_set_view<ltype, rtype, op_type>& that);
+
+ template <typename geometry_object>
+ inline polygon_90_set_data& operator=(const geometry_object& geometry) {
+ data_.clear();
+ insert(geometry);
+ return *this;
+ }
+
+// template <typename geometry_object>
+// inline polygon_90_set_data& operator=(const polygon_90_set_const_wrapper<geometry_object>& geometry) {
+// data_.clear();
+// insert(geometry.begin(), geometry.end(), geometry.orient());
+// return *this;
+// }
+
+ /// insert iterator range
+ template <typename iT>
+ inline void insert(iT input_begin, iT input_end, orientation_2d orient) {
+ if(input_begin == input_end) return;
+ dirty_ = true;
+ unsorted_ = true;
+ for( ; input_begin != input_end; ++input_begin) {
+ insert(*input_begin, false, orient);
+ }
+ }
+
+ inline void insert(const polygon_90_set_data& polygon_set) {
+ insert(polygon_set.begin(), polygon_set.end(), polygon_set.orient());
+ }
+
+ template <typename geometry_type>
+ inline void insert(const geometry_type& geometry_object, bool is_hole = false, orientation_2d orient = HORIZONTAL) {
+ iterator_geometry_to_set<typename geometry_concept<geometry_type>::type, geometry_type>
+ begin_input(geometry_object, LOW, orient_, is_hole), end_input(geometry_object, HIGH, orient_, is_hole);
+ insert(begin_input, end_input, orient_);
+ }
+
+ inline void insert(const std::pair<coordinate_type, std::pair<coordinate_type, int> >& vertex, bool is_hole = false,
+ orientation_2d orient = HORIZONTAL) {
+ data_.push_back(vertex);
+ if(orient != orient_) std::swap(data_.back().first, data_.back().second.first);
+ if(is_hole) data_.back().second.second *= -1;
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ inline void insert(coordinate_type major_coordinate, const std::pair<interval_data<coordinate_type>, int>& edge) {
+ std::pair<coordinate_type, std::pair<coordinate_type, int> > vertex;
+ vertex.first = major_coordinate;
+ vertex.second.first = edge.first.get(LOW);
+ vertex.second.second = edge.second;
+ insert(vertex);
+ vertex.second.first = edge.first.get(HIGH);
+ vertex.second.second *= -1;
+ insert(vertex);
+ }
+
+ template <typename output_container>
+ inline void get(output_container& output) const {
+ get_dispatch(output, typename geometry_concept<typename output_container::value_type>::type());
+ }
+
+ /// equivalence operator
+ inline bool operator==(const polygon_90_set_data& p) const {
+ if(orient_ == p.orient()) {
+ clean();
+ p.clean();
+ return data_ == p.data_;
+ } else {
+ return false;
+ }
+ }
+
+ /// inequivalence operator
+ inline bool operator!=(const polygon_90_set_data& p) const {
+ return !((*this) == p);
+ }
+
+ /// get iterator to begin vertex data
+ inline iterator_type begin() const {
+ return data_.begin();
+ }
+
+ /// get iterator to end vertex data
+ inline iterator_type end() const {
+ return data_.end();
+ }
+
+ const value_type& value() const {
+ return data_;
+ }
+
+ /// clear the contents of the polygon_90_set_data
+ inline void clear() { data_.clear(); dirty_ = unsorted_ = false; }
+
+ /// find out if Polygon set is empty
+ inline bool empty() const { clean(); return data_.empty(); }
+
+ /// find out if Polygon set is sorted
+ inline bool sorted() const { return !unsorted_; }
+
+ /// find out if Polygon set is clean
+ inline bool dirty() const { return dirty_; }
+
+ /// get the scanline orientation of the polygon set
+ inline orientation_2d orient() const { return orient_; }
+
+ void clean() const {
+ sort();
+ if(dirty_) {
+ boolean_op::applyBooleanOr(data_);
+ dirty_ = false;
+ }
+ }
+
+ void sort() const{
+ if(unsorted_) {
+ std::sort(data_.begin(), data_.end());
+ unsorted_ = false;
+ }
+ }
+
+ template <typename input_iterator_type>
+ void set(input_iterator_type input_begin, input_iterator_type input_end, orientation_2d orient) {
+ data_.clear();
+ data_.insert(data_.end(), input_begin, input_end);
+ orient_ = orient;
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ void set(const value_type& value, orientation_2d orient) {
+ data_ = value;
+ orient_ = orient;
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ template <class T2, typename iterator_type_1, typename iterator_type_2>
+ void applyBooleanBinaryOp(iterator_type_1 itr1, iterator_type_1 itr1_end,
+ iterator_type_2 itr2, iterator_type_2 itr2_end,
+ T2 defaultCount) {
+ data_.clear();
+ boolean_op::applyBooleanBinaryOp(data_, itr1, itr1_end, itr2, itr2_end, defaultCount);
+ }
+
+ private:
+ orientation_2d orient_;
+ mutable value_type data_;
+ mutable bool dirty_;
+ mutable bool unsorted_;
+
+ private:
+ //functions
+ template <typename output_container>
+ void get_dispatch(output_container& output, rectangle_concept tag) const {
+ clean();
+ get_rectangles(output, data_.begin(), data_.end(), orient_, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_90_concept tag) const {
+ get_fracture(output, true, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_90_with_holes_concept tag) const {
+ get_fracture(output, false, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_45_concept tag) const {
+ get_fracture(output, true, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_45_with_holes_concept tag) const {
+ get_fracture(output, false, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_concept tag) const {
+ get_fracture(output, true, tag);
+ }
+ template <typename output_container>
+ void get_dispatch(output_container& output, polygon_with_holes_concept tag) const {
+ get_fracture(output, false, tag);
+ }
+ template <typename output_container, typename concept_type>
+ void get_fracture(output_container& container, bool fracture_holes, concept_type tag) const {
+ clean();
+ get_polygons(container, data_.begin(), data_.end(), orient_, fracture_holes, tag);
+ }
+ };
+
+ template <typename coordinate_type, typename property_type>
+ class property_merge_90 {
+ private:
+ std::vector<std::pair<property_merge_point<coordinate_type>, std::pair<property_type, int> > > pmd_;
+ public:
+ inline property_merge_90() {}
+ inline property_merge_90(const property_merge_90& that) : pmd_(that.pmd_) {}
+ inline property_merge_90& operator=(const property_merge_90& that) { pmd_ = that.pmd_; }
+ inline void insert(const polygon_90_set_data<coordinate_type>& ps, const property_type& property) {
+ merge_scanline<coordinate_type, property_type, polygon_90_set_data<coordinate_type> >::
+ populate_property_merge_data(pmd_, ps.begin(), ps.end(), property, ps.orient());
+ }
+ template <class GeoObjT>
+ inline void insert(const GeoObjT& geoObj, const property_type& property) {
+ polygon_90_set_data<coordinate_type> ps;
+ ps.insert(geoObj);
+ insert(ps, property);
+ }
+ //merge properties of input geometries and store the resulting geometries of regions
+ //with unique sets of merged properties to polygons sets in a map keyed by sets of properties
+ // T = std::map<std::set<property_type>, polygon_90_set_data<coordiante_type> > or
+ // T = std::map<std::vector<property_type>, polygon_90_set_data<coordiante_type> >
+ template <typename ResultType>
+ inline void merge(ResultType& result) {
+ merge_scanline<coordinate_type, property_type, polygon_90_set_data<coordinate_type>, typename ResultType::key_type> ms;
+ ms.perform_merge(result, pmd_);
+ }
+ };
+
+ //ConnectivityExtraction computes the graph of connectivity between rectangle, polygon and
+ //polygon set graph nodes where an edge is created whenever the geometry in two nodes overlap
+ template <typename coordinate_type>
+ class connectivity_extraction {
+ private:
+ typedef typename touch_90_operation<coordinate_type>::TouchSetData tsd;
+ tsd tsd_;
+ unsigned int nodeCount_;
+ public:
+ inline connectivity_extraction() : nodeCount_(0) {}
+ inline connectivity_extraction(const connectivity_extraction& that) : tsd_(that.tsd_),
+ nodeCount_(that.nodeCount_) {}
+ inline connectivity_extraction& operator=(const connectivity_extraction& that) {
+ tsd_ = that.tsd_;
+ nodeCount_ = that.nodeCount_; {}
+ return *this;
+ }
+
+ //insert a polygon set graph node, the value returned is the id of the graph node
+ inline unsigned int insert(const polygon_90_set_data<coordinate_type>& ps) {
+ ps.clean();
+ touch_90_operation<coordinate_type>::populateTouchSetData(tsd_, ps.begin(), ps.end(), nodeCount_);
+ return nodeCount_++;
+ }
+ template <class GeoObjT>
+ inline unsigned int insert(const GeoObjT& geoObj) {
+ polygon_90_set_data<coordinate_type> ps;
+ ps.insert(geoObj);
+ return insert(ps);
+ }
+
+ //extract connectivity and store the edges in the graph
+ //graph must be indexable by graph node id and the indexed value must be a std::set of
+ //graph node id
+ template <class GraphT>
+ inline void extract(GraphT& graph) {
+ touch_90_operation<coordinate_type>::performTouch(graph, tsd_);
+ }
+ };
+
+}
+#endif
+
Added: sandbox/gtl/gtl/polygon_90_set_traits.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_90_set_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,353 @@
+/*
+ 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 GTL_POLYGON_90_SET_TRAITS_HPP
+#define GTL_POLYGON_90_SET_TRAITS_HPP
+namespace gtl {
+
+ struct polygon_90_set_concept {};
+
+ template <typename T, typename T2>
+ struct traits_by_concept {};
+ template <typename T>
+ struct traits_by_concept<T, coordinate_concept> { typedef coordinate_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, interval_concept> { typedef interval_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, point_concept> { typedef point_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, point_3d_concept> { typedef point_3d_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, rectangle_concept> { typedef rectangle_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_90_concept> { typedef polygon_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_90_with_holes_concept> { typedef polygon_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_45_concept> { typedef polygon_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_45_with_holes_concept> { typedef polygon_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_concept> { typedef polygon_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_with_holes_concept> { typedef polygon_traits<T> type; };
+
+ struct polygon_45_set_concept;
+ struct polygon_set_concept;
+ template <typename T>
+ struct polygon_90_set_traits;
+ template <typename T>
+ struct polygon_45_set_traits;
+ template <typename T>
+ struct polygon_set_traits;
+ template <typename T>
+ struct traits_by_concept<T, polygon_90_set_concept> { typedef polygon_90_set_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_45_set_concept> { typedef polygon_45_set_traits<T> type; };
+ template <typename T>
+ struct traits_by_concept<T, polygon_set_concept> { typedef polygon_set_traits<T> type; };
+
+ template <typename T, typename T2>
+ struct get_coordinate_type {
+ typedef typename traits_by_concept<T, T2>::type traits_type;
+ typedef typename traits_type::coordinate_type type;
+ };
+ //want to prevent recursive template definition syntax errors, so duplicate get_coordinate_type
+ template <typename T, typename T2>
+ struct get_coordinate_type_2 {
+ typedef typename traits_by_concept<T, T2>::type traits_type;
+ typedef typename traits_type::coordinate_type type;
+ };
+ template <typename T>
+ struct get_coordinate_type<T, undefined_concept> {
+ typedef typename get_coordinate_type_2<typename std::iterator_traits
+ <typename T::iterator>::value_type,
+ typename geometry_concept<typename std::iterator_traits
+ <typename T::iterator>::value_type>::type>::type type; };
+
+ template <typename T, typename T2>
+ struct get_iterator_type_2 {
+ typedef const T* type;
+ static type begin(const T& t) { return &t; }
+ static type end(const T& t) { const T* tp = &t; ++tp; return tp; }
+ };
+ template <typename T>
+ struct get_iterator_type {
+ typedef get_iterator_type_2<T, typename geometry_concept<T>::type> indirect_type;
+ typedef typename indirect_type::type type;
+ static type begin(const T& t) { return indirect_type::begin(t); }
+ static type end(const T& t) { return indirect_type::end(t); }
+ };
+ template <typename T>
+ struct get_iterator_type_2<T, undefined_concept> {
+ typedef typename T::const_iterator type;
+ static type begin(const T& t) { return t.begin(); }
+ static type end(const T& t) { return t.end(); }
+ };
+
+// //helpers for allowing polygon 45 and containers of polygon 45 to behave interchangably in polygon_45_set_traits
+// template <typename T, typename T2>
+// struct get_coordinate_type_45 {};
+// template <typename T, typename T2>
+// struct get_coordinate_type_2_45 {};
+// template <typename T>
+// struct get_coordinate_type_45<T, void> {
+// typedef typename get_coordinate_type_2_45< typename T::value_type, typename geometry_concept<typename T::value_type>::type >::type type; };
+// template <typename T>
+// struct get_coordinate_type_45<T, polygon_45_concept> { typedef typename polygon_traits<T>::coordinate_type type; };
+// template <typename T>
+// struct get_coordinate_type_45<T, polygon_45_with_holes_concept> { typedef typename polygon_traits<T>::coordinate_type type; };
+// template <typename T>
+// struct get_coordinate_type_2_45<T, polygon_45_concept> { typedef typename polygon_traits<T>::coordinate_type type; };
+// template <typename T>
+// struct get_coordinate_type_2_45<T, polygon_45_with_holes_concept> { typedef typename polygon_traits<T>::coordinate_type type; };
+// template <typename T, typename T2>
+// struct get_iterator_type_45 {};
+// template <typename T>
+// struct get_iterator_type_45<T, void> {
+// typedef typename T::const_iterator type;
+// static type begin(const T& t) { return t.begin(); }
+// static type end(const T& t) { return t.end(); }
+// };
+// template <typename T>
+// struct get_iterator_type_45<T, polygon_45_concept> {
+// typedef const T* type;
+// static type begin(const T& t) { return &t; }
+// static type end(const T& t) { const T* tp = &t; ++tp; return tp; }
+// };
+// template <typename T>
+// struct get_iterator_type_45<T, polygon_45_with_holes_concept> {
+// typedef const T* type;
+// static type begin(const T& t) { return &t; }
+// static type end(const T& t) { const T* tp = &t; ++tp; return tp; }
+// };
+// template <typename T>
+// struct get_iterator_type_45<T, polygon_90_set_concept> {
+// typedef const T* type;
+// static type begin(const T& t) { return &t; }
+// static type end(const T& t) { const T* tp = &t; ++tp; return tp; }
+// };
+
+ template <typename T>
+ struct polygon_90_set_traits {
+ typedef typename get_coordinate_type<T, typename geometry_concept<T>::type >::type coordinate_type;
+ typedef get_iterator_type<T> indirection_type;
+ typedef typename get_iterator_type<T>::type iterator_type;
+ typedef T operator_arg_type;
+
+ static inline iterator_type begin(const T& polygon_set) {
+ return indirection_type::begin(polygon_set);
+ }
+
+ static inline iterator_type end(const T& polygon_set) {
+ return indirection_type::end(polygon_set);
+ }
+
+ static inline orientation_2d orient(const T& polygon_set) { return HORIZONTAL; }
+
+ static inline bool clean(const T& polygon_set) { return false; }
+
+ static inline bool sorted(const T& polygon_set) { return false; }
+ };
+
+ template <typename T>
+ struct is_manhattan_polygonal_concept { typedef gtl_no type; };
+ template <>
+ struct is_manhattan_polygonal_concept<rectangle_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_manhattan_polygonal_concept<polygon_90_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_manhattan_polygonal_concept<polygon_90_with_holes_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_manhattan_polygonal_concept<polygon_90_set_concept> { typedef gtl_yes type; };
+
+ template <typename T>
+ struct is_polygon_90_set_type {
+ typedef typename is_manhattan_polygonal_concept<typename geometry_concept<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_polygon_90_set_type<std::list<T> > {
+ typedef typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type type;
+ };
+ template <typename T>
+ struct is_polygon_90_set_type<std::vector<T> > {
+ typedef typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_90_set_type {
+ typedef typename gtl_same_type<polygon_90_set_concept, typename geometry_concept<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_mutable_polygon_90_set_type<std::list<T> > {
+ typedef typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type type;
+ };
+ template <typename T>
+ struct is_mutable_polygon_90_set_type<std::vector<T> > {
+ typedef typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type type;
+ };
+
+// //specialization for rectangle, polygon_90 and polygon_90_with_holes types
+// template <typename T>
+// struct polygon_90_set_traits
+// typedef typename geometry_concept<T>::type concept_type;
+// typedef typename get_coordinate_type<T, concept_type>::type coordinate_type;
+// typedef iterator_geometry_to_set<concept_type, T> iterator_type;
+// typedef T operator_arg_type;
+
+// static inline iterator_type begin(const T& polygon_set) {
+// return iterator_geometry_to_set<concept_type, T>(polygon_set, LOW, HORIZONTAL);
+// }
+
+// static inline iterator_type end(const T& polygon_set) {
+// return iterator_geometry_to_set<concept_type, T>(polygon_set, HIGH, HORIZONTAL);
+// }
+
+// static inline orientation_2d orient(const T& polygon_set) { return HORIZONTAL; }
+
+// static inline bool clean(const T& polygon_set) { return false; }
+
+// static inline bool sorted(const T& polygon_set) { return false; }
+
+// };
+
+// //specialization for containers of recangle, polygon_90, polygon_90_with_holes
+// template <typename T>
+// struct polygon_90_set_traits<T, typename is_manhattan_polygonal_concept<typename std::iterator_traits<typename T::iterator>::value_type>::type> {
+// typedef typename std::iterator_traits<typename T::iterator>::value_type geometry_type;
+// typedef typename geometry_concept<geometry_type>::type concept_type;
+// typedef typename get_coordinate_type<geometry_type, concept_type>::type coordinate_type;
+// typedef iterator_geometry_range_to_set<concept_type, typename T::const_iterator> iterator_type;
+// typedef T operator_arg_type;
+
+// static inline iterator_type begin(const T& polygon_set) {
+// return iterator_type(polygon_set.begin(), HORIZONTAL);
+// }
+
+// static inline iterator_type end(const T& polygon_set) {
+// return iterator_type(polygon_set.end(), HORIZONTAL);
+// }
+
+// static inline orientation_2d orient(const T& polygon_set) { return HORIZONTAL; }
+
+// static inline bool clean(const T& polygon_set) { return false; }
+
+// static inline bool sorted(const T& polygon_set) { return false; }
+
+// };
+
+ //get dispatch functions
+ template <typename output_container_type, typename pst>
+ void get_90_dispatch(output_container_type& output, const pst& ps,
+ orientation_2d orient, rectangle_concept tag) {
+ get_rectangles(output, ps.begin(), ps.end(), orient, tag);
+ }
+
+ template <typename output_container_type, typename pst>
+ void get_90_dispatch(output_container_type& output, const pst& ps,
+ orientation_2d orient, polygon_90_concept tag) {
+ get_polygons(output, ps.begin(), ps.end(), orient, true, tag);
+ }
+
+ template <typename output_container_type, typename pst>
+ void get_90_dispatch(output_container_type& output, const pst& ps,
+ orientation_2d orient, polygon_90_with_holes_concept tag) {
+ get_polygons(output, ps.begin(), ps.end(), orient, false, tag);
+ }
+
+ //by default works with containers of rectangle, polygon or polygon with holes
+ //must be specialized to work with anything else
+ template <typename T>
+ struct polygon_90_set_mutable_traits {};
+ template <typename T>
+ struct polygon_90_set_mutable_traits<std::list<T> > {
+ typedef typename geometry_concept<T>::type concept_type;
+ template <typename input_iterator_type>
+ static inline void set(std::list<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end, orientation_2d orient) {
+ polygon_set.clear();
+ polygon_90_set_data<typename polygon_90_set_traits<std::list<T> >::coordinate_type> ps(orient);
+ ps.insert(input_begin, input_end, orient);
+ ps.clean();
+ get_90_dispatch(polygon_set, ps, orient, concept_type());
+ }
+ };
+ template <typename T>
+ struct polygon_90_set_mutable_traits<std::vector<T> > {
+ typedef typename geometry_concept<T>::type concept_type;
+ template <typename input_iterator_type>
+ static inline void set(std::vector<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end, orientation_2d orient) {
+ polygon_set.clear();
+ polygon_90_set_data<typename polygon_90_set_traits<std::list<T> >::coordinate_type> ps(orient);
+ ps.insert(input_begin, input_end, orient);
+ ps.clean();
+ get_90_dispatch(polygon_set, ps, orient, concept_type());
+ }
+ };
+
+ template <typename T>
+ struct polygon_90_set_mutable_traits<polygon_90_set_data<T> > {
+
+ template <typename input_iterator_type>
+ static inline void set(polygon_90_set_data<T>& polygon_set,
+ input_iterator_type input_begin, input_iterator_type input_end,
+ orientation_2d orient) {
+ polygon_set.clear();
+ polygon_set.insert(input_begin, input_end, orient);
+ }
+
+ };
+
+ template <typename T>
+ struct polygon_90_set_traits<polygon_90_set_data<T> > {
+ typedef typename polygon_90_set_data<T>::coordinate_type coordinate_type;
+ typedef typename polygon_90_set_data<T>::iterator_type iterator_type;
+ typedef typename polygon_90_set_data<T>::operator_arg_type operator_arg_type;
+
+ static inline iterator_type begin(const polygon_90_set_data<T>& polygon_set) {
+ return polygon_set.begin();
+ }
+
+ static inline iterator_type end(const polygon_90_set_data<T>& polygon_set) {
+ return polygon_set.end();
+ }
+
+ static inline orientation_2d orient(const polygon_90_set_data<T>& polygon_set) { return polygon_set.orient(); }
+
+ static inline bool clean(const polygon_90_set_data<T>& polygon_set) { polygon_set.clean(); return true; }
+
+ static inline bool sorted(const polygon_90_set_data<T>& polygon_set) { polygon_set.sort(); return true; }
+
+ };
+
+ template <typename T>
+ struct is_polygon_90_set_concept { };
+ template <>
+ struct is_polygon_90_set_concept<polygon_90_set_concept> { typedef void type; };
+ template <>
+ struct is_polygon_90_set_concept<rectangle_concept> { typedef void type; };
+ template <>
+ struct is_polygon_90_set_concept<polygon_90_concept> { typedef void type; };
+ template <>
+ struct is_polygon_90_set_concept<polygon_90_with_holes_concept> { typedef void type; };
+
+ template <typename T>
+ struct is_mutable_polygon_90_set_concept {};
+ template <>
+ struct is_mutable_polygon_90_set_concept<polygon_90_set_concept> { typedef void type; };
+
+ template <typename T>
+ struct geometry_concept<polygon_90_set_data<T> > { typedef polygon_90_set_concept type; };
+
+ template <typename T>
+ typename requires_1<typename is_polygon_90_set_type<T>::type, void>::type
+ print_is_polygon_90_set_concept(const T& t) { std::cout << "is polygon 90 set concept\n"; }
+ template <typename T>
+ typename requires_1<typename is_mutable_polygon_90_set_type<T>::type, void>::type
+ print_is_mutable_polygon_90_set_concept(const T& t) { std::cout << "is mutable polygon 90 set concept\n"; }
+}
+#endif
+
Added: sandbox/gtl/gtl/polygon_90_set_view.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_90_set_view.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,345 @@
+/*
+ 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 GTL_POLYGON_90_SET_VIEW_HPP
+#define GTL_POLYGON_90_SET_VIEW_HPP
+namespace gtl {
+ struct operator_provides_storage {};
+ struct operator_requires_copy {};
+
+ template <typename value_type, typename arg_type>
+ inline void insert_into_view_arg(value_type& dest, const arg_type& arg, orientation_2d orient);
+
+ template <typename ltype, typename rtype, typename op_type>
+ class polygon_90_set_view;
+
+ template <typename ltype, typename rtype, typename op_type>
+ struct polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> > {
+ typedef typename polygon_90_set_view<ltype, rtype, op_type>::coordinate_type coordinate_type;
+ typedef typename polygon_90_set_view<ltype, rtype, op_type>::iterator_type iterator_type;
+ typedef typename polygon_90_set_view<ltype, rtype, op_type>::operator_arg_type operator_arg_type;
+
+ static inline iterator_type begin(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set);
+ static inline iterator_type end(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set);
+
+ static inline orientation_2d orient(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set);
+
+ static inline bool clean(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set);
+
+ static inline bool sorted(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set);
+ };
+
+ template <typename ltype, typename rtype, typename op_type>
+ class polygon_90_set_view {
+ public:
+ typedef typename polygon_90_set_traits<ltype>::coordinate_type coordinate_type;
+ typedef polygon_90_set_data<coordinate_type> value_type;
+ typedef typename value_type::iterator_type iterator_type;
+ typedef polygon_90_set_view operator_arg_type;
+ private:
+ const ltype& lvalue_;
+ const rtype& rvalue_;
+ orientation_2d orient_;
+ op_type op_;
+ mutable value_type output_;
+ mutable bool evaluated_;
+ public:
+ polygon_90_set_view(const ltype& lvalue,
+ const rtype& rvalue,
+ orientation_2d orient,
+ op_type op) :
+ lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op), output_(orient), evaluated_(false) {}
+
+ /// get iterator to begin vertex data
+ private:
+ const value_type& value() const {
+ if(!evaluated_) {
+ evaluated_ = true;
+ value_type linput_(orient_);
+ value_type rinput_(orient_);
+ insert_into_view_arg(linput_, lvalue_, orient_);
+ insert_into_view_arg(rinput_, rvalue_, orient_);
+ output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
+ rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
+ }
+ return output_;
+ }
+ public:
+ iterator_type begin() const { return value().begin(); }
+ iterator_type end() const { return value().end(); }
+
+ orientation_2d orient() const { return orient_; }
+ bool dirty() const { return false; } //result of a boolean is clean
+ bool sorted() const { return true; } //result of a boolean is sorted
+
+// template <typename input_iterator_type>
+// void set(input_iterator_type input_begin, input_iterator_type input_end,
+// orientation_2d orient) const {
+// orient_ = orient;
+// output_.clear();
+// output_.insert(output_.end(), input_begin, input_end);
+// std::sort(output_.begin(), output_.end());
+// }
+ void sort() const {} //is always sorted
+ };
+
+ template <typename ltype, typename rtype, typename op_type>
+ struct geometry_concept<polygon_90_set_view<ltype, rtype, op_type> > {
+ typedef polygon_90_set_concept type;
+ };
+
+ template <typename ltype, typename rtype, typename op_type>
+ typename polygon_90_set_view<ltype, rtype, op_type>::iterator_type
+ polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
+ begin(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+ return polygon_set.begin();
+ }
+ template <typename ltype, typename rtype, typename op_type>
+ typename polygon_90_set_view<ltype, rtype, op_type>::iterator_type
+ polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
+ end(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+ return polygon_set.end();
+ }
+// template <typename ltype, typename rtype, typename op_type>
+// template <typename input_iterator_type>
+// void polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
+// set(polygon_90_set_view<ltype, rtype, op_type>& polygon_set,
+// input_iterator_type input_begin, input_iterator_type input_end,
+// orientation_2d orient) {
+// polygon_set.set(input_begin, input_end, orient);
+// }
+ template <typename ltype, typename rtype, typename op_type>
+ orientation_2d polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
+ orient(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+ return polygon_set.orient(); }
+ template <typename ltype, typename rtype, typename op_type>
+ bool polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
+ clean(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+ return true; }
+ template <typename ltype, typename rtype, typename op_type>
+ bool polygon_90_set_traits<polygon_90_set_view<ltype, rtype, op_type> >::
+ sorted(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set) {
+ return true; }
+
+ template <typename value_type, typename arg_type>
+ inline void insert_into_view_arg(value_type& dest, const arg_type& arg, orientation_2d orient) {
+ typedef typename polygon_90_set_traits<arg_type>::iterator_type literator;
+ literator itr1, itr2;
+ itr1 = polygon_90_set_traits<arg_type>::begin(arg);
+ itr2 = polygon_90_set_traits<arg_type>::end(arg);
+ dest.insert(itr1, itr2, orient);
+ dest.sort();
+ }
+
+ template <typename T>
+ template <typename ltype, typename rtype, typename op_type>
+ inline polygon_90_set_data<T>& polygon_90_set_data<T>::operator=(const polygon_90_set_view<ltype, rtype, op_type>& that) {
+ set(that.begin(), that.end(), that.orient());
+ dirty_ = false;
+ unsorted_ = false;
+ return *this;
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ struct self_assign_operator_lvalue {
+ typedef geometry_type_1& type;
+ };
+
+ template <typename type_1, typename type_2>
+ struct by_value_binary_operator {
+ typedef type_1 type;
+ };
+
+ template <typename geometry_type_1, typename geometry_type_2, typename op_type>
+ geometry_type_1& self_assignment_boolean_op(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
+ typedef geometry_type_1 ltype;
+ typedef geometry_type_2 rtype;
+ typedef typename polygon_90_set_traits<ltype>::coordinate_type coordinate_type;
+ typedef polygon_90_set_data<coordinate_type> value_type;
+ orientation_2d orient_ = polygon_90_set_traits<ltype>::orient(lvalue_);
+ value_type linput_(orient_);
+ value_type rinput_(orient_);
+ value_type output_(orient_);
+ insert_into_view_arg(linput_, lvalue_, orient_);
+ insert_into_view_arg(rinput_, rvalue_, orient_);
+ output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
+ rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
+ polygon_90_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end(), orient_);
+ return lvalue_;
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryOr> >::type
+ operator|(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryOr>
+ (lvalue, rvalue,
+ polygon_90_set_traits<geometry_type_1>::orient(lvalue),
+ boolean_op::BinaryOr());
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryOr> >::type
+ operator+(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryOr>
+ (lvalue, rvalue,
+ polygon_90_set_traits<geometry_type_1>::orient(lvalue),
+ boolean_op::BinaryOr());
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryAnd> >::type
+ operator*(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryAnd>
+ (lvalue, rvalue,
+ polygon_90_set_traits<geometry_type_1>::orient(lvalue),
+ boolean_op::BinaryAnd());
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryAnd> >::type
+ operator&(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryAnd>
+ (lvalue, rvalue,
+ polygon_90_set_traits<geometry_type_1>::orient(lvalue),
+ boolean_op::BinaryAnd());
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryXor> >::type
+ operator^(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryXor>
+ (lvalue, rvalue,
+ polygon_90_set_traits<geometry_type_1>::orient(lvalue),
+ boolean_op::BinaryXor());
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryNot> >::type
+ operator-(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_90_set_view<geometry_type_1, geometry_type_2, boolean_op::BinaryNot>
+ (lvalue, rvalue,
+ polygon_90_set_traits<geometry_type_1>::orient(lvalue),
+ boolean_op::BinaryNot());
+ }
+
+ template <typename coordinate_type_1, typename geometry_type_2>
+ typename requires_1< typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_data<coordinate_type_1> >::type &
+ operator+=(polygon_90_set_data<coordinate_type_1>& lvalue, const geometry_type_2& rvalue) {
+ lvalue.insert(polygon_90_set_traits<geometry_type_2>::begin(rvalue), polygon_90_set_traits<geometry_type_2>::end(rvalue),
+ polygon_90_set_traits<geometry_type_2>::orient(rvalue));
+ return lvalue;
+ }
+
+ //
+ template <typename coordinate_type_1, typename geometry_type_2>
+ typename requires_1< typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ polygon_90_set_data<coordinate_type_1> >::type &
+ operator|=(polygon_90_set_data<coordinate_type_1>& lvalue, const geometry_type_2& rvalue) {
+ return lvalue += rvalue;
+ }
+
+ //normal self assignment boolean operations
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator+=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, boolean_op::BinaryOr>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator|=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, boolean_op::BinaryOr>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator*=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, boolean_op::BinaryAnd>(lvalue, rvalue);
+ }
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator&=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, boolean_op::BinaryAnd>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator^=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, boolean_op::BinaryXor>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator-=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, boolean_op::BinaryNot>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ polygon_90_set_data<typename polygon_90_set_traits<geometry_type_1>::coordinate_type> >::type
+ operator+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ polygon_90_set_data<typename polygon_90_set_traits<geometry_type_1>::coordinate_type> ps;
+ assign(ps, lvalue);
+ resize(ps, rvalue);
+ return ps;
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ polygon_90_set_data<typename polygon_90_set_traits<geometry_type_1>::coordinate_type> >::type
+ operator-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ polygon_90_set_data<typename polygon_90_set_traits<geometry_type_1>::coordinate_type> ps;
+ assign(ps, lvalue);
+ resize(ps, -rvalue);
+ return ps;
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ geometry_type_1>::type &
+ operator+=(geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ return resize(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename coordinate_type_1>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
+ geometry_type_1>::type &
+ operator-=(geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+ return resize(lvalue, -rvalue);
+ }
+}
+#endif
+
Added: sandbox/gtl/gtl/polygon_90_touch.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_90_touch.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,401 @@
+/*
+ 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 GTL_POLYGON_90_TOUCH_HPP
+#define GTL_POLYGON_90_TOUCH_HPP
+namespace gtl {
+
+ template <typename Unit>
+ struct touch_90_operation {
+ typedef interval_data<Unit> Interval;
+
+ class TouchScanEvent {
+ private:
+ typedef std::map<Unit, std::set<int> > EventData;
+ EventData eventData_;
+ public:
+
+ // The TouchScanEvent::iterator is a lazy algorithm that accumulates
+ // polygon ids in a set as it is incremented through the
+ // scan event data structure.
+ // The iterator provides a forward iterator semantic only.
+ class iterator {
+ private:
+ typename EventData::const_iterator itr_;
+ std::pair<Interval, std::set<int> > ivlIds_;
+ public:
+ inline iterator() {}
+ inline iterator(typename EventData::const_iterator itr,
+ Unit prevPos, const std::set<int>& ivlIds) : itr_(itr) {
+ ivlIds_.second = ivlIds;
+ ivlIds_.first = Interval(prevPos, itr->first);
+ }
+ inline iterator(const iterator& that) { (*this) = that; }
+ inline iterator& operator=(const iterator& that) {
+ itr_ = that.itr_;
+ ivlIds_.first = that.ivlIds_.first;
+ ivlIds_.second = that.ivlIds_.second;
+ return *this;
+ };
+ inline bool operator==(const iterator& that) { return itr_ == that.itr_; }
+ inline bool operator!=(const iterator& that) { return itr_ != that.itr_; }
+ inline iterator& operator++() {
+ //std::cout << "increment\n";
+ //std::cout << "state\n";
+ //for(std::set<int>::iterator itr = ivlIds_.second.begin(); itr != ivlIds_.second.end(); ++itr) {
+ // std::cout << (*itr) << " ";
+ //} std::cout << std::endl;
+ //std::cout << "update\n";
+ for(std::set<int>::const_iterator itr = (*itr_).second.begin();
+ itr != (*itr_).second.end(); ++itr) {
+ //std::cout << (*itr) << " ";
+ std::set<int>::iterator lb = ivlIds_.second.find(*itr);
+ if(lb != ivlIds_.second.end()) {
+ ivlIds_.second.erase(lb);
+ } else {
+ ivlIds_.second.insert(*itr);
+ }
+ }
+ //std::cout << std::endl;
+ //std::cout << "new state\n";
+ //for(std::set<int>::iterator itr = ivlIds_.second.begin(); itr != ivlIds_.second.end(); ++itr) {
+ // std::cout << (*itr) << " ";
+ //} std::cout << std::endl;
+ ++itr_;
+ ivlIds_.first = Interval(ivlIds_.first.get(HIGH), itr_->first);
+ return *this;
+ }
+ inline const iterator operator++(int){
+ iterator tmpItr(*this);
+ ++(*this);
+ return tmpItr;
+ }
+ inline std::pair<Interval, std::set<int> >& operator*() { if(ivlIds_.second.empty())(++(*this)); return ivlIds_; }
+ };
+
+ inline TouchScanEvent() {}
+ template<class iT>
+ inline TouchScanEvent(iT begin, iT end) {
+ for( ; begin != end; ++begin){
+ insert(*begin);
+ }
+ }
+ inline TouchScanEvent(const TouchScanEvent& that) : eventData_(that.eventData_) {}
+ inline TouchScanEvent& operator=(const TouchScanEvent& that){
+ eventData_ = that.eventData_;
+ return *this;
+ }
+
+ //Insert an interval polygon id into the EventData
+ inline void insert(const std::pair<Interval, int>& intervalId){
+ insert(intervalId.first.low(), intervalId.second);
+ insert(intervalId.first.high(), intervalId.second);
+ }
+
+ //Insert an position and polygon id into EventData
+ inline void insert(Unit pos, int id) {
+ typename EventData::iterator lb = eventData_.lower_bound(pos);
+ if(lb != eventData_.end() && lb->first == pos) {
+ std::set<int>& mr (lb->second);
+ std::set<int>::iterator mri = mr.find(id);
+ if(mri == mr.end()) {
+ mr.insert(id);
+ } else {
+ mr.erase(id);
+ }
+ } else {
+ lb = eventData_.insert(lb, std::pair<Unit, std::set<int> >(pos, std::set<int>()));
+ (*lb).second.insert(id);
+ }
+ }
+
+ //merge this scan event with that by inserting its data
+ inline void insert(const TouchScanEvent& that){
+ typename EventData::const_iterator itr;
+ for(itr = that.eventData_.begin(); itr != that.eventData_.end(); ++itr) {
+ eventData_[(*itr).first].insert(itr->second.begin(), itr->second.end());
+ }
+ }
+
+ //Get the begin iterator over event data
+ inline iterator begin() const {
+ //std::cout << "begin\n";
+ if(eventData_.empty()) return end();
+ typename EventData::const_iterator itr = eventData_.begin();
+ Unit pos = itr->first;
+ const std::set<int>& idr = itr->second;
+ ++itr;
+ return iterator(itr, pos, idr);
+ }
+
+ //Get the end iterator over event data
+ inline iterator end() const { return iterator(eventData_.end(), 0, std::set<int>()); }
+
+ inline void clear() { eventData_.clear(); }
+
+ inline Interval extents() const {
+ if(eventData_.empty()) return Interval();
+ return Interval((*(eventData_.begin())).first, (*(eventData_.rbegin())).first);
+ }
+ };
+
+ //declaration of a map of scan events by coordinate value used to store all the
+ //polygon data for a single layer input into the scanline algorithm
+ typedef std::pair<std::map<Unit, TouchScanEvent>, std::map<Unit, TouchScanEvent> > TouchSetData;
+
+ class TouchOp {
+ public:
+ typedef std::map<Unit, std::set<int> > ScanData;
+ typedef std::pair<Unit, std::set<int> > ElementType;
+ protected:
+ ScanData scanData_;
+ typename ScanData::iterator nextItr_;
+ public:
+ inline TouchOp () { nextItr_ = scanData_.end(); }
+ inline TouchOp (const TouchOp& that) : scanData_(that.scanData_) { nextItr_ = scanData_.begin(); }
+ inline TouchOp& operator=(const TouchOp& that);
+
+ //moves scanline forward
+ inline void advanceScan() { nextItr_ = scanData_.begin(); }
+
+ //proceses the given interval and std::set<int> data
+ //the output data structre is a graph, the indicies in the vector correspond to graph nodes,
+ //the integers in the set are vector indicies and are the nodes with which that node shares an edge
+ inline void processInterval(std::vector<std::set<int> >& outputContainer, Interval ivl, const std::set<int>& ids, bool leadingEdge) {
+ //print();
+ typename ScanData::iterator lowItr = lookup_(ivl.low());
+ typename ScanData::iterator highItr = lookup_(ivl.high());
+ //std::cout << "Interval: " << ivl << std::endl;
+ //for(std::set<int>::const_iterator itr = ids.begin(); itr != ids.end(); ++itr)
+ // std::cout << (*itr) << " ";
+ //std::cout << std::endl;
+ //add interval to scan data if it is past the end
+ if(lowItr == scanData_.end()) {
+ //std::cout << "case0" << std::endl;
+ lowItr = insert_(ivl.low(), ids);
+ evaluateBorder_(outputContainer, ids, ids);
+ highItr = insert_(ivl.high(), std::set<int>());
+ return;
+ }
+ //ensure that highItr points to the end of the ivl
+ if(highItr == scanData_.end() || (*highItr).first > ivl.high()) {
+ //std::cout << "case1" << std::endl;
+ //std::cout << highItr->first << std::endl;
+ std::set<int> value = std::set<int>();
+ if(highItr != scanData_.begin()) {
+ --highItr;
+ //std::cout << highItr->first << std::endl;
+ //std::cout << "high set size " << highItr->second.size() << std::endl;
+ value = highItr->second;
+ }
+ nextItr_ = highItr;
+ highItr = insert_(ivl.high(), value);
+ } else {
+ //evaluate border with next higher interval
+ //std::cout << "case1a" << std::endl;
+ if(leadingEdge)evaluateBorder_(outputContainer, highItr->second, ids);
+ }
+ //split the low interval if needed
+ if(lowItr->first > ivl.low()) {
+ //std::cout << "case2" << std::endl;
+ if(lowItr != scanData_.begin()) {
+ //std::cout << "case3" << std::endl;
+ --lowItr;
+ nextItr_ = lowItr;
+ //std::cout << lowItr->first << " " << lowItr->second.size() << std::endl;
+ lowItr = insert_(ivl.low(), lowItr->second);
+ } else {
+ //std::cout << "case4" << std::endl;
+ nextItr_ = lowItr;
+ lowItr = insert_(ivl.low(), std::set<int>());
+ }
+ } else {
+ //evaluate border with next higher interval
+ //std::cout << "case2a" << std::endl;
+ typename ScanData::iterator nextLowerItr = lowItr;
+ if(leadingEdge && nextLowerItr != scanData_.begin()){
+ --nextLowerItr;
+ evaluateBorder_(outputContainer, nextLowerItr->second, ids);
+ }
+ }
+ //std::cout << "low: " << lowItr->first << " high: " << highItr->first << std::endl;
+ //print();
+ //process scan data intersecting interval
+ for(typename ScanData::iterator itr = lowItr; itr != highItr; ){
+ //std::cout << "case5" << std::endl;
+ //std::cout << itr->first << std::endl;
+ std::set<int>& beforeIds = itr->second;
+ ++itr;
+ evaluateInterval_(outputContainer, beforeIds, ids, leadingEdge);
+ }
+ //print();
+ //merge the bottom interval with the one below if they have the same count
+ if(lowItr != scanData_.begin()){
+ //std::cout << "case6" << std::endl;
+ typename ScanData::iterator belowLowItr = lowItr;
+ --belowLowItr;
+ if(belowLowItr->second == lowItr->second) {
+ //std::cout << "case7" << std::endl;
+ scanData_.erase(lowItr);
+ }
+ }
+ //merge the top interval with the one above if they have the same count
+ if(highItr != scanData_.begin()) {
+ //std::cout << "case8" << std::endl;
+ typename ScanData::iterator beforeHighItr = highItr;
+ --beforeHighItr;
+ if(beforeHighItr->second == highItr->second) {
+ //std::cout << "case9" << std::endl;
+ scanData_.erase(highItr);
+ highItr = beforeHighItr;
+ ++highItr;
+ }
+ }
+ //print();
+ nextItr_ = highItr;
+ }
+
+ inline void print() const {
+ for(typename ScanData::const_iterator itr = scanData_.begin(); itr != scanData_.end(); ++itr) {
+ std::cout << itr->first << ": ";
+ for(std::set<int>::const_iterator sitr = itr->second.begin();
+ sitr != itr->second.end(); ++sitr){
+ std::cout << *sitr << " ";
+ }
+ std::cout << std::endl;
+ }
+ }
+
+ private:
+ inline typename ScanData::iterator lookup_(Unit pos){
+ if(nextItr_ != scanData_.end() && nextItr_->first >= pos) {
+ return nextItr_;
+ }
+ return nextItr_ = scanData_.lower_bound(pos);
+ }
+
+ inline typename ScanData::iterator insert_(Unit pos, const std::set<int>& ids){
+ //std::cout << "inserting " << ids.size() << " ids at: " << pos << std::endl;
+ return nextItr_ = scanData_.insert(nextItr_, std::pair<Unit, std::set<int> >(pos, ids));
+ }
+
+ inline void evaluateInterval_(std::vector<std::set<int> >& outputContainer, std::set<int>& ids,
+ const std::set<int>& changingIds, bool leadingEdge) {
+ for(std::set<int>::const_iterator ciditr = changingIds.begin(); ciditr != changingIds.end(); ++ciditr){
+ //std::cout << "evaluateInterval " << (*ciditr) << std::endl;
+ evaluateId_(outputContainer, ids, *ciditr, leadingEdge);
+ }
+ }
+ inline void evaluateBorder_(std::vector<std::set<int> >& outputContainer, const std::set<int>& ids, const std::set<int>& changingIds) {
+ for(std::set<int>::const_iterator ciditr = changingIds.begin(); ciditr != changingIds.end(); ++ciditr){
+ //std::cout << "evaluateBorder " << (*ciditr) << std::endl;
+ evaluateBorderId_(outputContainer, ids, *ciditr);
+ }
+ }
+ inline void evaluateBorderId_(std::vector<std::set<int> >& outputContainer, const std::set<int>& ids, int changingId) {
+ for(std::set<int>::const_iterator scanItr = ids.begin(); scanItr != ids.end(); ++scanItr) {
+ //std::cout << "create edge: " << changingId << " " << *scanItr << std::endl;
+ if(changingId != *scanItr){
+ outputContainer[changingId].insert(*scanItr);
+ outputContainer[*scanItr].insert(changingId);
+ }
+ }
+ }
+ inline void evaluateId_(std::vector<std::set<int> >& outputContainer, std::set<int>& ids, int changingId, bool leadingEdge) {
+ //std::cout << "changingId: " << changingId << std::endl;
+ //for( std::set<int>::iterator itr = ids.begin(); itr != ids.end(); ++itr){
+ // std::cout << *itr << " ";
+ //}std::cout << std::endl;
+ std::set<int>::iterator lb = ids.lower_bound(changingId);
+ if(lb == ids.end() || (*lb) != changingId) {
+ if(leadingEdge) {
+ //std::cout << "insert\n";
+ //insert and add to output
+ for(std::set<int>::iterator scanItr = ids.begin(); scanItr != ids.end(); ++scanItr) {
+ //std::cout << "create edge: " << changingId << " " << *scanItr << std::endl;
+ if(changingId != *scanItr){
+ outputContainer[changingId].insert(*scanItr);
+ outputContainer[*scanItr].insert(changingId);
+ }
+ }
+ ids.insert(changingId);
+ }
+ } else {
+ if(!leadingEdge){
+ //std::cout << "erase\n";
+ ids.erase(lb);
+ }
+ }
+ }
+ };
+
+ static inline void processEvent(std::vector<std::set<int> >& outputContainer, TouchOp& op, const TouchScanEvent& data, bool leadingEdge) {
+ for(typename TouchScanEvent::iterator itr = data.begin(); itr != data.end(); ++itr) {
+ //std::cout << "processInterval" << std::endl;
+ op.processInterval(outputContainer, (*itr).first, (*itr).second, leadingEdge);
+ }
+ }
+
+ static inline void performTouch(std::vector<std::set<int> >& outputContainer, const TouchSetData& data) {
+ typename std::map<Unit, TouchScanEvent>::const_iterator leftItr = data.first.begin();
+ typename std::map<Unit, TouchScanEvent>::const_iterator rightItr = data.second.begin();
+ typename std::map<Unit, TouchScanEvent>::const_iterator leftEnd = data.first.end();
+ typename std::map<Unit, TouchScanEvent>::const_iterator rightEnd = data.second.end();
+ TouchOp op;
+ while(leftItr != leftEnd || rightItr != rightEnd) {
+ //std::cout << "loop" << std::endl;
+ op.advanceScan();
+ //rightItr cannont be at end if leftItr is not at end
+ if(leftItr != leftEnd && rightItr != rightEnd &&
+ leftItr->first <= rightItr->first) {
+ //std::cout << "case1" << std::endl;
+ //std::cout << leftItr ->first << std::endl;
+ processEvent(outputContainer, op, leftItr->second, true);
+ ++leftItr;
+ } else {
+ //std::cout << "case2" << std::endl;
+ //std::cout << rightItr ->first << std::endl;
+ processEvent(outputContainer, op, rightItr->second, false);
+ ++rightItr;
+ }
+ }
+ }
+
+ template <class iT>
+ static inline void populateTouchSetData(TouchSetData& data, iT beginData, iT endData, int id) {
+ Unit prevPos = (std::numeric_limits<Unit>::max());
+ Unit prevY = prevPos;
+ int count = 0;
+ for(iT itr = beginData; itr != endData; ++itr) {
+ Unit pos = (*itr).first;
+ if(pos != prevPos) {
+ prevPos = pos;
+ prevY = (*itr).second.first;
+ count = (*itr).second.second;
+ continue;
+ }
+ Unit y = (*itr).second.first;
+ if(count != 0 && y != prevY) {
+ std::pair<Interval, int> element(Interval(prevY, y), id);
+ if(count > 0) {
+ data.first[pos].insert(element);
+ } else {
+ data.second[pos].insert(element);
+ }
+ }
+ prevY = y;
+ count += (*itr).second.second;
+ }
+ }
+
+ static inline void populateTouchSetData(TouchSetData& data, const std::vector<std::pair<Unit, std::pair<Unit, int> > >& inputData, int id) {
+ populateTouchSetData(data, inputData.begin(), inputData.end(), id);
+ }
+
+ };
+}
+#endif
Modified: sandbox/gtl/gtl/polygon_90_with_holes_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_90_with_holes_concept.hpp (original)
+++ sandbox/gtl/gtl/polygon_90_with_holes_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -10,10 +10,168 @@
#define GTL_POLYGON_90_WITH_HOLES_CONCEPT_HPP
namespace gtl {
-struct polygon_90_with_holes_concept : polygon_90_concept {
+struct polygon_90_with_holes_concept {
public:
- inline polygon_90_with_holes_concept() {}
+ template <typename T>
+ struct coordinate_type {
+ typedef typename polygon_traits<T>::coordinate_type type;
+ };
+
+ template <typename T>
+ struct area_type {
+ typedef typename polygon_traits<T>::area_type type;
+ };
+
+ template <typename T>
+ struct coordinate_difference {
+ typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_difference type;
+ };
+
+ template <typename T>
+ struct coordinate_distance {
+ typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_distance type;
+ };
+
+ template <typename T>
+ struct point_type {
+ typedef typename polygon_traits<T>::iterator_type iterator;
+ typedef typename std::iterator_traits<iterator>::value_type type;
+ };
+
+ template<typename polygon_type, typename compact_iterator_type>
+ static void set_compact(polygon_type& polygon, compact_iterator_type input_begin, compact_iterator_type input_end) {
+ polygon_traits<polygon_type>::set_compact(polygon, input_begin, input_end);
+ }
+
+ template<typename polygon_type, typename rectangle_type>
+ static void set_rectangle(polygon_type& polygon, const rectangle_type& rect) {
+ typename polygon_traits<polygon_type>::coordinate_type coords[4] =
+ {rectangle_concept::xl(rect), rectangle_concept::yl(rect),
+ rectangle_concept::xh(rect), rectangle_concept::yh(rect)};
+ set_compact(polygon, coords, coords+4);
+ }
+
+ template<typename polygon_type, typename point_iterator_type>
+ static void set(polygon_type& polygon, point_iterator_type begin_point, point_iterator_type end_point) {
+ polygon_traits<polygon_type>::set(polygon, begin_point, end_point);
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::iterator_type
+ begin(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::begin(polygon);
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::iterator_type
+ end(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::end(polygon);
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::compact_iterator_type
+ begin_compact(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::begin_compact(polygon);
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::compact_iterator_type
+ end_compact(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::end_compact(polygon);
+ }
+
+ template<typename T, class iT>
+ static T construct(iT inputBegin, iT inputEnd) { return polygon_traits<T>::construct(inputBegin, inputEnd); }
+
+ template<typename polygon_type, typename rectangle_type>
+ static polygon_type construct_from_rectangle(const rectangle_type& rect) {
+ polygon_type poly;
+ set_rectangle(poly, rect);
+ return poly;
+ }
+
+ template <typename polygon_type>
+ static std::size_t size(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::size(polygon);
+ }
+
+ template <typename polygon_type>
+ static direction_1d winding(const polygon_type& polygon){
+ winding_direction wd = polygon_traits<polygon_type>::winding(polygon);
+ if(wd != unknown_winding) {
+ return wd == clockwise_winding ? LOW: HIGH;
+ }
+ direction_1d dir = HIGH;
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::compact_iterator_type iterator;
+ iterator itr = begin_compact(polygon);
+ coordinate_type firstx = *itr;
+ coordinate_type minX = firstx;
+ ++itr;
+ iterator end_itr = end_compact(polygon);
+ if(itr == end_itr) return dir;
+ coordinate_type prevy = *itr;
+ coordinate_type firsty = *itr;
+ ++itr;
+ for( ; itr != end_itr; ++itr) {
+ coordinate_type x = *itr;
+ ++itr;
+ if(itr == end_itr) break;
+ coordinate_type y = *itr;
+ if(x <= minX) {
+ minX = x;
+ //edge directed downward on left side of figure is counterclockwise
+ dir = y < prevy ? HIGH : LOW;
+ }
+ prevy = y;
+ }
+ if(firstx <= minX) {
+ dir = firsty < prevy ? HIGH : LOW;
+ }
+ return dir;
+ }
+
+ template <typename polygon_type, typename rectangle_type>
+ static bool
+ extents(rectangle_type& bounding_box, const polygon_type& polygon) {
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::compact_iterator_type iterator;
+ coordinate_type xmin = 0;
+ coordinate_type ymin = 0;
+ coordinate_type xmax = 0;
+ coordinate_type ymax = 0;
+ bool first_iteration = true;
+ iterator itr_end = end_compact(polygon);
+ for(iterator itr = begin_compact(polygon); itr != itr_end; ++itr) {
+ coordinate_type x = *itr;
+ ++itr;
+ if(itr == itr_end) break;
+ coordinate_type y = *itr;
+ if(first_iteration) {
+ xmin = xmax = x;
+ ymin = ymax = x;
+ first_iteration = false;
+ }
+ xmin = std::min(xmin, x);
+ xmax = std::max(xmax, x);
+ ymin = std::min(ymin, y);
+ ymax = std::max(ymax, y);
+ }
+ if(first_iteration) return false;
+ bounding_box = rectangle_concept::construct<rectangle_type>(xmin, ymin, xmax, ymax);
+ return true;
+ }
+
+ template <typename point_type, typename polygon_type>
+ static bool
+ center(point_type& center_point, const polygon_type& polygon) {
+ rectangle_data<typename coordinate_type<polygon_type>::type> bounding_box;
+ if(extents(bounding_box, polygon))
+ return rectangle_concept::center(center_point, bounding_box);
+ return false;
+ }
+
template<typename polygon_with_holes_type, typename hole_iterator_type>
static void set_holes(polygon_with_holes_type& polygon, hole_iterator_type holes_begin, hole_iterator_type holes_end) {
polygon_with_holes_traits<polygon_with_holes_type>::set_holes(polygon, holes_begin, holes_end);
@@ -44,13 +202,28 @@
return polygon_with_holes_traits<polygon_with_holes_type>::size_holes(polygon);
}
+ template <typename polygon_with_holes_type_1, typename geometry_type_2>
+ static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const geometry_type_2& rvalue) {
+ polygon_90_with_holes_concept::assign(lvalue, rvalue, typename geometry_concept<geometry_type_2>::type());
+ set_holes(lvalue, begin_holes(rvalue), end_holes(rvalue));
+ return lvalue;
+ }
+
template <typename polygon_with_holes_type_1, typename polygon_with_holes_type_2>
- static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const polygon_with_holes_type_2& rvalue) {
+ static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const polygon_with_holes_type_2& rvalue,
+ polygon_90_with_holes_concept tag) {
polygon_90_concept::assign(lvalue, rvalue);
set_holes(lvalue, begin_holes(rvalue), end_holes(rvalue));
return lvalue;
}
+ template <typename polygon_with_holes_type_1, typename polygon_type_2>
+ static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const polygon_type_2& rvalue,
+ polygon_90_concept tag) {
+ polygon_90_concept::assign(lvalue, rvalue);
+ return lvalue;
+ }
+
template <typename polygon_with_holes_type>
static typename area_type<polygon_with_holes_type>::type
area(const polygon_with_holes_type& polygon) {
@@ -157,6 +330,75 @@
}
return polygon;
}
+
+ template <typename polygon_type>
+ static polygon_type& scale_up(polygon_type& polygon,
+ typename coordinate_traits<typename coordinate_type<polygon_type>::type>::unsigned_area_type factor) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ holes.push_back(*b);
+ polygon_90_concept::scale_up(holes.back(), factor);
+ }
+ set_holes(polygon, holes.begin(), holes.end());
+ polygon_90_concept::scale_up(polygon, factor);
+ return polygon;
+ }
+
+ template <typename polygon_type>
+ static polygon_type& scale_down(polygon_type& polygon,
+ typename coordinate_traits<typename coordinate_type<polygon_type>::type>::unsigned_area_type factor) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ holes.push_back(*b);
+ polygon_90_concept::scale_down(holes.back(), factor);
+ }
+ set_holes(polygon, holes.begin(), holes.end());
+ polygon_90_concept::scale_down(polygon, factor);
+ return polygon;
+ }
+
+ template <typename polygon_type, typename scaling_type>
+ static polygon_type& scale(polygon_type& polygon,
+ const scaling_type& scaling) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ holes.push_back(*b);
+ polygon_90_concept::scale(holes.back(), scaling);
+ }
+ set_holes(polygon, holes.begin(), holes.end());
+ polygon_90_concept::scale(polygon, scaling);
+ return polygon;
+ }
+
+ template <typename polygon_type, typename transformation_type>
+ static polygon_type& transform(polygon_type& polygon,
+ const transformation_type& transformation) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type b, e;
+ e = end_holes(polygon);
+ for(b = begin_holes(polygon); b != e; ++b) {
+ holes.push_back(*b);
+ polygon_90_concept::transform(holes.back(), transformation);
+ }
+ set_holes(polygon, holes.begin(), holes.end());
+ polygon_90_concept::transform(polygon, transformation);
+ return polygon;
+ }
+
};
template <typename T>
Modified: sandbox/gtl/gtl/polygon_90_with_holes_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_90_with_holes_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_90_with_holes_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -18,6 +18,8 @@
typedef typename polygon_90_data<T>::compact_iterator_type compact_iterator_type;
typedef typename std::list<polygon_90_data<coordinate_type> >::const_iterator iterator_holes_type;
typedef polygon_90_data<coordinate_type> hole_type;
+ typedef typename coordinate_traits<T>::area_type area_type;
+ typedef point_data<T> point_type;
/// default constructor of point does not initialize x and y
inline polygon_90_with_holes_data(){;} //do nothing default constructor
Added: sandbox/gtl/gtl/polygon_arbitrary_formation.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_arbitrary_formation.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,1928 @@
+/*
+ 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 GTL_POLYGON_ARBITRARY_FORMATION_HPP
+#define GTL_POLYGON_ARBITRARY_FORMATION_HPP
+namespace gtl {
+ template <typename T, typename T2>
+ struct PolyLineArbitraryByConcept {};
+
+ template <typename T>
+ class poly_line_arbitrary_polygon_data;
+ template <typename T>
+ class poly_line_arbitrary_hole_data;
+
+ template <typename Unit>
+ struct scanline_base {
+
+ typedef point_data<Unit> Point;
+ typedef std::pair<Point, Point> half_edge;
+
+ class less_point : public std::binary_function<Point, Point, bool> {
+ public:
+ inline less_point() {}
+ inline bool operator () (const Point& pt1, const Point& pt2) const {
+ if(pt1.get(HORIZONTAL) < pt2.get(HORIZONTAL)) return true;
+ if(pt1.get(HORIZONTAL) == pt2.get(HORIZONTAL)) {
+ if(pt1.get(VERTICAL) < pt2.get(VERTICAL)) return true;
+ }
+ return false;
+ }
+ };
+
+ static inline bool between(Point pt, Point pt1, Point pt2) {
+ less_point lp;
+ if(lp(pt1, pt2))
+ return lp(pt, pt2) && lp(pt1, pt);
+ return lp(pt, pt1) && lp(pt2, pt);
+ }
+
+ template <typename area_type>
+ static inline Unit compute_intercept(const area_type& dy2,
+ const area_type& dx1,
+ const area_type& dx2) {
+ //intercept = dy2 * dx1 / dx2
+ //return (Unit)(((area_type)dy2 * (area_type)dx1) / (area_type)dx2);
+ area_type dx1_q = dx1 / dx2;
+ area_type dx1_r = dx1 % dx2;
+ return dx1_q * dy2 + (dy2 * dx1_r)/dx2;
+ }
+
+ template <typename area_type>
+ static inline bool equal_slope(area_type dx1, area_type dy1, area_type dx2, area_type dy2) {
+ typedef typename coordinate_traits<Unit>::unsigned_area_type unsigned_product_type;
+ unsigned_product_type cross_1 = (unsigned_product_type)(dx2 < 0 ? -dx2 :dx2) * (unsigned_product_type)(dy1 < 0 ? -dy1 : dy1);
+ unsigned_product_type cross_2 = (unsigned_product_type)(dx1 < 0 ? -dx1 :dx1) * (unsigned_product_type)(dy2 < 0 ? -dy2 : dy2);
+ int dx1_sign = dx1 < 0 ? -1 : 1;
+ int dx2_sign = dx2 < 0 ? -1 : 1;
+ int dy1_sign = dy1 < 0 ? -1 : 1;
+ int dy2_sign = dy2 < 0 ? -1 : 1;
+ int cross_1_sign = dx2_sign * dy1_sign;
+ int cross_2_sign = dx1_sign * dy2_sign;
+ return cross_1 == cross_2 && (cross_1_sign == cross_2_sign || cross_1 == 0);
+ }
+
+ static inline bool equal_slope(const Unit& x, const Unit& y,
+ const Point& pt1, const Point& pt2) {
+ const Point* pts[2] = {&pt1, &pt2};
+ typedef typename coordinate_traits<Unit>::manhattan_area_type at;
+ at dy2 = (at)pts[1]->get(VERTICAL) - (at)y;
+ at dy1 = (at)pts[0]->get(VERTICAL) - (at)y;
+ at dx2 = (at)pts[1]->get(HORIZONTAL) - (at)x;
+ at dx1 = (at)pts[0]->get(HORIZONTAL) - (at)x;
+ return equal_slope(dx1, dy1, dx2, dy2);
+ }
+
+ template <typename area_type>
+ static inline bool less_slope(area_type dx1, area_type dy1, area_type dx2, area_type dy2) {
+ //reflext x and y slopes to right hand side half plane
+ if(dx1 < 0) {
+ dy1 *= -1;
+ dx1 *= -1;
+ } else if(dx1 == 0) {
+ //if the first slope is vertical the first cannot be less
+ return false;
+ }
+ if(dx2 < 0) {
+ dy2 *= -1;
+ dx2 *= -1;
+ } else if(dx2 == 0) {
+ //if the second slope is vertical the first is always less unless it is also vertical, in which case they are equal
+ return dx1 != 0;
+ }
+ typedef typename coordinate_traits<Unit>::unsigned_area_type unsigned_product_type;
+ unsigned_product_type cross_1 = (unsigned_product_type)(dx2 < 0 ? -dx2 :dx2) * (unsigned_product_type)(dy1 < 0 ? -dy1 : dy1);
+ unsigned_product_type cross_2 = (unsigned_product_type)(dx1 < 0 ? -dx1 :dx1) * (unsigned_product_type)(dy2 < 0 ? -dy2 : dy2);
+ int dx1_sign = dx1 < 0 ? -1 : 1;
+ int dx2_sign = dx2 < 0 ? -1 : 1;
+ int dy1_sign = dy1 < 0 ? -1 : 1;
+ int dy2_sign = dy2 < 0 ? -1 : 1;
+ int cross_1_sign = dx2_sign * dy1_sign;
+ int cross_2_sign = dx1_sign * dy2_sign;
+ if(cross_1_sign < cross_2_sign) return true;
+ if(cross_2_sign < cross_1_sign) return false;
+ if(cross_1_sign == -1) return cross_2 < cross_1;
+ return cross_1 < cross_2;
+ }
+
+ static inline bool less_slope(const Unit& x, const Unit& y,
+ const Point& pt1, const Point& pt2) {
+ const Point* pts[2] = {&pt1, &pt2};
+ //compute y value on edge from pt_ to pts[1] at the x value of pts[0]
+ typedef typename coordinate_traits<Unit>::manhattan_area_type at;
+ at dy2 = (at)pts[1]->get(VERTICAL) - (at)y;
+ at dy1 = (at)pts[0]->get(VERTICAL) - (at)y;
+ at dx2 = (at)pts[1]->get(HORIZONTAL) - (at)x;
+ at dx1 = (at)pts[0]->get(HORIZONTAL) - (at)x;
+ return less_slope(dx1, dy1, dx2, dy2);
+ }
+
+ //return -1 below, 0 on and 1 above line
+ //assumes point is on x interval of segment
+ static inline int on_above_or_below(Point pt, const half_edge& he) {
+ if(pt == he.first || pt == he.second) return 0;
+ if(equal_slope(pt.get(HORIZONTAL), pt.get(VERTICAL), he.first, he.second)) return 0;
+ bool less_result = less_slope(pt.get(HORIZONTAL), pt.get(VERTICAL), he.first, he.second);
+ int retval = less_result ? -1 : 1;
+ less_point lp;
+ if(lp(he.second, he.first)) retval *= -1;
+ if(!between(pt, he.first, he.second)) retval *= -1;
+ return retval;
+ }
+
+ //returns true is the segment intersects the integer grid square with lower
+ //left corner at point
+ static inline bool intersects_grid(Point pt, const half_edge& he) {
+ if(pt == he.second) return true;
+ if(pt == he.first) return true;
+ rectangle_data<Unit> rect1;
+ set_points(rect1, he.first, he.second);
+ if(contains(rect1, pt, true)) {
+ if(is_vertical(he) || is_horizontal(he)) return true;
+ } else {
+ return false; //can't intersect a grid not within bounding box
+ }
+ Unit x = pt.get(HORIZONTAL);
+ Unit y = pt.get(VERTICAL);
+ if(equal_slope(x, y, he.first, he.second) &&
+ between(pt, he.first, he.second)) return true;
+ Point pt01(pt.get(HORIZONTAL), pt.get(VERTICAL) + 1);
+ Point pt10(pt.get(HORIZONTAL) + 1, pt.get(VERTICAL));
+ Point pt11(pt.get(HORIZONTAL) + 1, pt.get(VERTICAL) + 1);
+// if(pt01 == he.first) return true;
+// if(pt10 == he.first) return true;
+// if(pt11 == he.first) return true;
+// if(pt01 == he.second) return true;
+// if(pt10 == he.second) return true;
+// if(pt11 == he.second) return true;
+ //check non-integer intersections
+ half_edge widget1(pt, pt11);
+ //intersects but not just at pt11
+ if(intersects(widget1, he) && on_above_or_below(pt11, he)) return true;
+ half_edge widget2(pt01, pt10);
+ //intersects but not just at pt01 or 10
+ if(intersects(widget2, he) && on_above_or_below(pt01, he) && on_above_or_below(pt10, he)) return true;
+ return false;
+ }
+
+ static inline typename high_precision_type<Unit>::type evalAtXforY(Unit xIn, Point pt, Point other_pt) {
+ //y = (x - x1)dy/dx + y1
+ //y = (xIn - pt.x)*(other_pt.y-pt.y)/(other_pt.x-pt.x) + pt.y
+ //assert pt.x != other_pt.x
+ Unit x1 = pt.get(HORIZONTAL);
+ Unit y1 = pt.get(VERTICAL);
+ typedef typename high_precision_type<Unit>::type high_precision;
+ high_precision dx1 = (high_precision)xIn - (high_precision)pt.get(HORIZONTAL);
+ if(dx1 == high_precision(0)) return (high_precision)(pt.get(VERTICAL));
+ high_precision dx = (high_precision)(other_pt.get(HORIZONTAL)) - (high_precision)x1;
+ high_precision dy = (high_precision)(other_pt.get(VERTICAL)) - (high_precision)y1;
+ high_precision y = (((high_precision)dx1) * (high_precision)dy / (high_precision)dx + (high_precision)y1);
+ return y;
+ }
+
+
+ static inline bool is_vertical(const half_edge& he) {
+ return he.first.get(HORIZONTAL) == he.second.get(HORIZONTAL);
+ }
+
+ static inline bool is_horizontal(const half_edge& he) {
+ return he.first.get(VERTICAL) == he.second.get(VERTICAL);
+ }
+
+ static inline bool is_45_degree(const half_edge& he) {
+ return euclidean_distance(he.first, he.second, HORIZONTAL) == euclidean_distance(he.first, he.second, VERTICAL);
+ }
+
+ //scanline comparator functor
+ class less_half_edge : public std::binary_function<half_edge, half_edge, bool> {
+ private:
+ Unit *x_; //x value at which to apply comparison
+ int *justBefore_;
+ public:
+ inline less_half_edge() : x_(0) {}
+ inline less_half_edge(Unit *x, int *justBefore) : x_(x), justBefore_(justBefore) {}
+ inline less_half_edge(const less_half_edge& that) : x_(that.x_), justBefore_(that.justBefore_) {}
+ inline less_half_edge& operator=(const less_half_edge& that) { x_ = that.x_; justBefore_ = that.justBefore_; return *this; }
+ inline bool operator () (const half_edge& elm1, const half_edge& elm2) const {
+ //Unit y1 = evalAtXforY(*x_ + !*justBefore_, elm1.first, elm1.second);
+ //Unit y2 = evalAtXforY(*x_ + !*justBefore_, elm2.first, elm2.second);
+ typedef typename high_precision_type<Unit>::type high_precision;
+ high_precision y1 = evalAtXforY(*x_, elm1.first, elm1.second);
+ high_precision y2 = evalAtXforY(*x_, elm2.first, elm2.second);
+ if(y1 < y2) return true;
+ if(y1 == y2) {
+ //if justBefore is true we invert the result of the comparison of slopes
+ bool result = less_slope(elm1.second.get(HORIZONTAL) - elm1.first.get(HORIZONTAL),
+ elm1.second.get(VERTICAL) - elm1.first.get(VERTICAL),
+ elm2.second.get(HORIZONTAL) - elm2.first.get(HORIZONTAL),
+ elm2.second.get(VERTICAL) - elm2.first.get(VERTICAL));
+ return (*justBefore_) ^ result;
+ }
+ return false;
+ }
+ };
+
+ template <typename unsigned_product_type>
+ static inline void unsigned_mod(unsigned_product_type& result, int& result_sign, unsigned_product_type a, int a_sign, unsigned_product_type b, int b_sign) {
+ result = a % b;
+ result_sign = a_sign;
+ }
+
+ template <typename unsigned_product_type>
+ static inline void unsigned_add(unsigned_product_type& result, int& result_sign, unsigned_product_type a, int a_sign, unsigned_product_type b, int b_sign) {
+ int switcher = 0;
+ if(a_sign < 0) switcher += 1;
+ if(b_sign < 0) switcher += 2;
+ if(a < b) switcher += 4;
+ switch (switcher) {
+ case 0: //both positive
+ result = a + b;
+ result_sign = 1;
+ break;
+ case 1: //a is negative
+ result = a - b;
+ result_sign = -1;
+ break;
+ case 2: //b is negative
+ result = a - b;
+ result_sign = 1;
+ break;
+ case 3: //both negative
+ result = a + b;
+ result_sign = -1;
+ break;
+ case 4: //both positive
+ result = a + b;
+ result_sign = 1;
+ break;
+ case 5: //a is negative
+ result = b - a;
+ result_sign = 1;
+ break;
+ case 6: //b is negative
+ result = b - a;
+ result_sign = -1;
+ break;
+ case 7: //both negative
+ result = b + a;
+ result_sign = -1;
+ break;
+ };
+ }
+
+ //slower but more overflow protected way to compute coordinate of intersection
+ template <typename product_type>
+ static inline Unit compute_x_intercept(product_type x11,
+ product_type x21,
+ product_type y11,
+ product_type y21,
+ product_type dy1,
+ product_type dy2,
+ product_type dx1,
+ product_type dx2) {
+ // x = (x11 * dy1 * dx2 - x21 * dy2 * dx1 + y21 * dx1 * dx2 - y11 * dx1 * dx2) / (dy1 * dx2 - dy2 * dx1);
+ typedef typename coordinate_traits<Unit>::unsigned_area_type unsigned_product_type;
+ unsigned_product_type udy1 = dy1 < 0 ? -dy1 : dy1;
+ int dy1sign = dy1 < 0 ? -1 : 1;
+ unsigned_product_type udy2 = dy2 < 0 ? -dy2 : dy2;
+ int dy2sign = dy2 < 0 ? -1 : 1;
+ unsigned_product_type udx1 = dx1 < 0 ? -dx1 : dx1;
+ int dx1sign = dx1 < 0 ? -1 : 1;
+ unsigned_product_type udx2 = dx2 < 0 ? -dx2 : dx2;
+ int dx2sign = dx2 < 0 ? -1 : 1;
+ unsigned_product_type u_dy1dx2 = udy1 * udx2;
+ unsigned_product_type u_dy2dx1 = udy2 * udx1;
+ unsigned_product_type u_dx1dx2 = udx1 * udx2;
+ int dy1dx2sign = dy1sign * dx2sign;
+ int dy2dx1sign = dy2sign * dx1sign;
+ int dx1dx2sign = dx1sign * dx2sign;
+ unsigned_product_type u_den = 0;;
+ int den_sign = 0;;
+ unsigned_add(u_den, den_sign, u_dy1dx2, dy1dx2sign, u_dy2dx1, -dy2dx1sign);
+ product_type dy1dx2_q = u_dy1dx2 / u_den;
+ product_type dy2dx1_q = u_dy2dx1 / u_den;
+ product_type dx1dx2_q = u_dx1dx2 / u_den;
+ dy1dx2_q *= dy1dx2sign * den_sign;
+ dy2dx1_q *= dy2dx1sign * den_sign;
+ dx1dx2_q *= dx1dx2sign * den_sign;
+ unsigned_product_type u_dy1dx2_r = 0;;
+ unsigned_product_type u_dy2dx1_r = 0;;
+ unsigned_product_type u_dx1dx2_r = 0;;
+ int dy1dx2_r_sign = 0;
+ int dy2dx1_r_sign = 0;
+ int dx1dx2_r_sign = 0;
+ unsigned_mod(u_dy1dx2_r, dy1dx2_r_sign, u_dy1dx2, dy1dx2sign, u_den, den_sign);
+ unsigned_mod(u_dy2dx1_r, dy2dx1_r_sign, u_dy2dx1, dy2dx1sign, u_den, den_sign);
+ unsigned_mod(u_dx1dx2_r, dx1dx2_r_sign, u_dx1dx2, dx1dx2sign, u_den, den_sign);
+ product_type dy1dx2_r = u_dy1dx2_r;
+ product_type dy2dx1_r = u_dy2dx1_r;
+ product_type dx1dx2_r = u_dx1dx2_r;
+ dy1dx2_r *= dy1dx2_r_sign;
+ dy2dx1_r *= dy2dx1_r_sign;
+ dx1dx2_r *= dx1dx2_r_sign;
+ product_type q = x11 * dy1dx2_q - x21 * dy2dx1_q + (y21 - y11) * dx1dx2_q;
+ product_type r = x11 * dy1dx2_r - x21 * dy2dx1_r + (y21 - y11) * dx1dx2_r;
+ unsigned_product_type ur = 0;
+ int rsign = 0;;
+ if(r < 0) { ur = -r; rsign = -1; } else { ur = r; rsign = 1; }
+ //this operation performs only one truncation
+ ur /= u_den;
+ rsign *= den_sign;
+ r = ur;
+ r *= rsign;
+ return q + r;
+ }
+
+ static inline bool compute_intersection(Point& intersection, const half_edge& he1, const half_edge& he2) {
+ typedef typename high_precision_type<Unit>::type high_precision;
+ typedef rectangle_data<Unit> Rectangle;
+ Rectangle rect1, rect2;
+ set_points(rect1, he1.first, he1.second);
+ set_points(rect2, he2.first, he2.second);
+ if(!::gtl::intersects(rect1, rect2, true)) return false;
+ if(is_vertical(he1)) {
+ if(is_vertical(he2)) return false;
+ high_precision y_high = evalAtXforY(he1.first.get(HORIZONTAL), he2.first, he2.second);
+ Unit y = (Unit)y_high;
+ if(y_high < (high_precision)y) --y;
+ if(contains(rect1.get(VERTICAL), y, true)) {
+ intersection = Point(he1.first.get(HORIZONTAL), y);
+ return true;
+ } else {
+ return false;
+ }
+ } else if(is_vertical(he2)) {
+ high_precision y_high = evalAtXforY(he2.first.get(HORIZONTAL), he1.first, he1.second);
+ Unit y = (Unit)y_high;
+ if(y_high < (high_precision)y) --y;
+ if(contains(rect2.get(VERTICAL), y, true)) {
+ intersection = Point(he2.first.get(HORIZONTAL), y);
+ return true;
+ } else {
+ return false;
+ }
+ }
+ //the bounding boxes of the two line segments intersect, so we check closer to find the intersection point
+ high_precision dy2 = (high_precision)(he2.second.get(VERTICAL)) -
+ (high_precision)(he2.first.get(VERTICAL));
+ high_precision dy1 = (high_precision)(he1.second.get(VERTICAL)) -
+ (high_precision)(he1.first.get(VERTICAL));
+ high_precision dx2 = (high_precision)(he2.second.get(HORIZONTAL)) -
+ (high_precision)(he2.first.get(HORIZONTAL));
+ high_precision dx1 = (high_precision)(he1.second.get(HORIZONTAL)) -
+ (high_precision)(he1.first.get(HORIZONTAL));
+ if(equal_slope(dx1, dy1, dx2, dy2)) return false;
+ //the line segments have different slopes
+ //we can assume that the line segments are not vertical because such an intersection is handled elsewhere
+ high_precision x11 = (high_precision)(he1.first.get(HORIZONTAL));
+ high_precision x21 = (high_precision)(he2.first.get(HORIZONTAL));
+ high_precision y11 = (high_precision)(he1.first.get(VERTICAL));
+ high_precision y21 = (high_precision)(he2.first.get(VERTICAL));
+ //Unit exp_x = ((at)x11 * (at)dy1 * (at)dx2 - (at)x21 * (at)dy2 * (at)dx1 + (at)y21 * (at)dx1 * (at)dx2 - (at)y11 * (at)dx1 * (at)dx2) / ((at)dy1 * (at)dx2 - (at)dy2 * (at)dx1);
+ //Unit exp_y = ((at)y11 * (at)dx1 * (at)dy2 - (at)y21 * (at)dx2 * (at)dy1 + (at)x21 * (at)dy1 * (at)dy2 - (at)x11 * (at)dy1 * (at)dy2) / ((at)dx1 * (at)dy2 - (at)dx2 * (at)dy1);
+ high_precision x_num = (x11 * dy1 * dx2 - x21 * dy2 * dx1 + y21 * dx1 * dx2 - y11 * dx1 * dx2);
+ high_precision x_den = (dy1 * dx2 - dy2 * dx1);
+ high_precision y_num = (y11 * dx1 * dy2 - y21 * dx2 * dy1 + x21 * dy1 * dy2 - x11 * dy1 * dy2);
+ high_precision y_den = (dx1 * dy2 - dx2 * dy1);
+ high_precision x = x_num / x_den;
+ high_precision y = y_num / y_den;
+ //std::cout << "cross1 " << dy1 << " " << dx2 << " " << dy1 * dx2 << std::endl;
+ //std::cout << "cross2 " << dy2 << " " << dx1 << " " << dy2 * dx1 << std::endl;
+ //Unit exp_x = compute_x_intercept<at>(x11, x21, y11, y21, dy1, dy2, dx1, dx2);
+ //Unit exp_y = compute_x_intercept<at>(y11, y21, x11, x21, dx1, dx2, dy1, dy2);
+ Unit x_unit = (Unit)x;
+ Unit y_unit = (Unit)y;
+ //truncate downward if it went up due to negative number
+ if(x < (high_precision)x_unit) --x_unit;
+ if(y < (high_precision)y_unit) --y_unit;
+ //if(x != exp_x || y != exp_y)
+ // std::cout << exp_x << " " << exp_y << " " << x << " " << y << std::endl;
+ //Unit y1 = evalAtXforY(exp_x, he1.first, he1.second);
+ //Unit y2 = evalAtXforY(exp_x, he2.first, he2.second);
+ //std::cout << exp_x << " " << exp_y << " " << y1 << " " << y2 << std::endl;
+ Point result(x_unit, y_unit);
+ if(!contains(rect1, result, true)) return false;
+ if(!contains(rect2, result, true)) return false;
+ intersection = result;
+ return true;
+ }
+
+ static inline bool intersects(const half_edge& he1, const half_edge& he2) {
+ typedef rectangle_data<Unit> Rectangle;
+ Rectangle rect1, rect2;
+ set_points(rect1, he1.first, he1.second);
+ set_points(rect2, he2.first, he2.second);
+ if(::gtl::intersects(rect1, rect2, false)) {
+ if(he1.first == he2.first) {
+ if(he1.second != he2.second && equal_slope(he1.first.get(HORIZONTAL), he1.first.get(VERTICAL),
+ he1.second, he2.second)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ if(he1.first == he2.second) {
+ if(he1.second != he2.first && equal_slope(he1.first.get(HORIZONTAL), he1.first.get(VERTICAL),
+ he1.second, he2.first)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ if(he1.second == he2.first) {
+ if(he1.first != he2.second && equal_slope(he1.second.get(HORIZONTAL), he1.second.get(VERTICAL),
+ he1.first, he2.second)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ if(he1.second == he2.second) {
+ if(he1.first != he2.first && equal_slope(he1.second.get(HORIZONTAL), he1.second.get(VERTICAL),
+ he1.first, he2.first)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ int oab1 = on_above_or_below(he1.first, he2);
+ if(oab1 == 0 && between(he1.first, he2.first, he2.second)) return true;
+ int oab2 = on_above_or_below(he1.second, he2);
+ if(oab2 == 0 && between(he1.second, he2.first, he2.second)) return true;
+ if(oab1 == oab2 && oab1 != 0) return false; //both points of he1 are on same side of he2
+ int oab3 = on_above_or_below(he2.first, he1);
+ if(oab3 == 0 && between(he2.first, he1.first, he1.second)) return true;
+ int oab4 = on_above_or_below(he2.second, he1);
+ if(oab4 == 0 && between(he2.second, he1.first, he1.second)) return true;
+ if(oab3 == oab4) return false; //both points of he2 are on same side of he1
+ return true; //they must cross
+ }
+ if(is_vertical(he1) && is_vertical(he2) && he1.first.get(HORIZONTAL) == he2.first.get(HORIZONTAL))
+ return ::gtl::intersects(rect1.get(VERTICAL), rect2.get(VERTICAL), false) &&
+ rect1.get(VERTICAL) != rect2.get(VERTICAL);
+ if(is_horizontal(he1) && is_horizontal(he2) && he1.first.get(VERTICAL) == he2.first.get(VERTICAL))
+ return ::gtl::intersects(rect1.get(HORIZONTAL), rect2.get(HORIZONTAL), false) &&
+ rect1.get(HORIZONTAL) != rect2.get(HORIZONTAL);
+ return false;
+ }
+
+ class vertex_half_edge {
+ public:
+ typedef typename high_precision_type<Unit>::type high_precision;
+ Point pt;
+ Point other_pt; // 1, 0 or -1
+ int count; //dxdydTheta
+ inline vertex_half_edge() {}
+ inline vertex_half_edge(const Point& point, const Point& other_point, int countIn) : pt(point), other_pt(other_point), count(countIn) {}
+ inline vertex_half_edge(const vertex_half_edge& vertex) : pt(vertex.pt), other_pt(vertex.other_pt), count(vertex.count) {}
+ inline vertex_half_edge& operator=(const vertex_half_edge& vertex){
+ pt = vertex.pt; other_pt = vertex.other_pt; count = vertex.count; return *this; }
+ inline vertex_half_edge(const std::pair<Point, Point>& vertex) {}
+ inline vertex_half_edge& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+ inline bool operator==(const vertex_half_edge& vertex) const {
+ return pt == vertex.pt && other_pt == vertex.other_pt && count == vertex.count; }
+ inline bool operator!=(const vertex_half_edge& vertex) const { return !((*this) == vertex); }
+ inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+ inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
+ inline bool operator<(const vertex_half_edge& vertex) const {
+ if(pt.get(HORIZONTAL) < vertex.pt.get(HORIZONTAL)) return true;
+ if(pt.get(HORIZONTAL) == vertex.pt.get(HORIZONTAL)) {
+ if(pt.get(VERTICAL) < vertex.pt.get(VERTICAL)) return true;
+ if(pt.get(VERTICAL) == vertex.pt.get(VERTICAL)) { return less_slope(pt.get(HORIZONTAL), pt.get(VERTICAL),
+ other_pt, vertex.other_pt);
+ }
+ }
+ return false;
+ }
+ inline bool operator>(const vertex_half_edge& vertex) const { return vertex < (*this); }
+ inline bool operator<=(const vertex_half_edge& vertex) const { return !((*this) > vertex); }
+ inline bool operator>=(const vertex_half_edge& vertex) const { return !((*this) < vertex); }
+ inline high_precision evalAtX(Unit xIn) const { return evalAtXforY(xIn, pt, other_pt); }
+ inline bool is_vertical() const {
+ return pt.get(HORIZONTAL) == other_pt.get(HORIZONTAL);
+ }
+ inline bool is_begin() const {
+ return pt.get(HORIZONTAL) < other_pt.get(HORIZONTAL) ||
+ (pt.get(HORIZONTAL) == other_pt.get(HORIZONTAL) &&
+ (pt.get(VERTICAL) < other_pt.get(VERTICAL)));
+ }
+ };
+
+ //when scanning Vertex45 for polygon formation we need a scanline comparator functor
+ class less_vertex_half_edge : public std::binary_function<vertex_half_edge, vertex_half_edge, bool> {
+ private:
+ Unit *x_; //x value at which to apply comparison
+ int *justBefore_;
+ public:
+ inline less_vertex_half_edge() : x_(0) {}
+ inline less_vertex_half_edge(Unit *x, int *justBefore) : x_(x), justBefore_(justBefore) {}
+ inline less_vertex_half_edge(const less_vertex_half_edge& that) : x_(that.x_), justBefore_(that.justBefore_) {}
+ inline less_vertex_half_edge& operator=(const less_vertex_half_edge& that) { x_ = that.x_; justBefore_ = that.justBefore_; return *this; }
+ inline bool operator () (const vertex_half_edge& elm1, const vertex_half_edge& elm2) const {
+ typedef typename high_precision_type<Unit>::type high_precision;
+ high_precision y1 = elm1.evalAtX(*x_);
+ high_precision y2 = elm2.evalAtX(*x_);
+ if(y1 < y2) return true;
+ if(y1 == y2) {
+ //if justBefore is true we invert the result of the comparison of slopes
+ bool result = less_slope(elm1.other_pt.get(HORIZONTAL) - elm1.pt.get(HORIZONTAL),
+ elm1.other_pt.get(VERTICAL) - elm1.pt.get(VERTICAL),
+ elm2.other_pt.get(HORIZONTAL) - elm2.pt.get(HORIZONTAL),
+ elm2.other_pt.get(VERTICAL) - elm2.pt.get(VERTICAL));
+ return (*justBefore_) ^ result;
+ }
+ return false;
+ }
+ };
+
+ };
+
+ template <typename Unit>
+ class polygon_arbitrary_formation : public scanline_base<Unit> {
+ public:
+ typedef typename scanline_base<Unit>::Point Point;
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+ typedef typename scanline_base<Unit>::vertex_half_edge vertex_half_edge;
+ typedef typename scanline_base<Unit>::less_vertex_half_edge less_vertex_half_edge;
+
+ class poly_line_arbitrary {
+ public:
+ typedef typename std::list<Point>::const_iterator iterator;
+
+ /// default constructor of point does not initialize x and y
+ inline poly_line_arbitrary(){;} //do nothing default constructor
+
+ /// initialize a polygon from x,y values, it is assumed that the first is an x
+ /// and that the input is a well behaved polygon
+ template<class iT>
+ inline poly_line_arbitrary& set(iT inputBegin, iT inputEnd) {
+ points.clear(); //just in case there was some old data there
+ while(inputBegin != inputEnd) {
+ points.insert(points.end(), *inputBegin);
+ ++inputBegin;
+ }
+ return *this;
+ }
+
+ /// copy constructor (since we have dynamic memory)
+ inline poly_line_arbitrary(const poly_line_arbitrary& that) : points(that.points) {}
+
+ /// assignment operator (since we have dynamic memory do a deep copy)
+ inline poly_line_arbitrary& operator=(const poly_line_arbitrary& that) {
+ points = that.points;
+ return *this;
+ }
+
+ /// get begin iterator, returns a pointer to a const Unit
+ inline iterator begin() const { return points.begin(); }
+
+ /// get end iterator, returns a pointer to a const Unit
+ inline iterator end() const { return points.end(); }
+
+ inline std::size_t size() const { return points.size(); }
+
+ //public data member
+ std::list<Point> points;
+ };
+
+ class active_tail_arbitrary {
+ private:
+ //data
+ poly_line_arbitrary* tailp_;
+ active_tail_arbitrary *otherTailp_;
+ std::list<active_tail_arbitrary*> holesList_;
+ bool head_;
+ public:
+
+ /**
+ * @brief iterator over coordinates of the figure
+ */
+ typedef typename poly_line_arbitrary::iterator iterator;
+
+ /**
+ * @brief iterator over holes contained within the figure
+ */
+ typedef typename std::list<active_tail_arbitrary*>::const_iterator iteratorHoles;
+
+ //default constructor
+ inline active_tail_arbitrary() : tailp_(0), otherTailp_(0), head_(0) {}
+
+ //constructor
+ inline active_tail_arbitrary(const vertex_half_edge& vertex, active_tail_arbitrary* otherTailp = 0) {
+ tailp_ = new poly_line_arbitrary;
+ tailp_->points.push_back(vertex.pt);
+ bool headArray[4] = {false, true, true, true};
+ bool inverted = vertex.count == -1;
+ head_ = (!vertex.is_vertical) ^ inverted;
+ otherTailp_ = otherTailp;
+ }
+
+ inline active_tail_arbitrary(Point point, active_tail_arbitrary* otherTailp, bool head = true) {
+ tailp_ = new poly_line_arbitrary;
+ tailp_->points.push_back(point);
+ head_ = head;
+ otherTailp_ = otherTailp;
+
+ }
+ inline active_tail_arbitrary(active_tail_arbitrary* otherTailp) {
+ tailp_ = otherTailp->tailp_;
+ otherTailp_ = otherTailp;
+ }
+
+ //copy constructor
+ inline active_tail_arbitrary(const active_tail_arbitrary& that) { (*this) = that; }
+
+ //destructor
+ inline ~active_tail_arbitrary() {
+ destroyContents();
+ }
+
+ //assignment operator
+ inline active_tail_arbitrary& operator=(const active_tail_arbitrary& that) {
+ tailp_ = new poly_line_arbitrary(*(that.tailp_));
+ head_ = that.head_;
+ otherTailp_ = that.otherTailp_;
+ holesList_ = that.holesList_;
+ return *this;
+ }
+
+ //equivalence operator
+ inline bool operator==(const active_tail_arbitrary& b) const {
+ return tailp_ == b.tailp_ && head_ == b.head_;
+ }
+
+ /**
+ * @brief get the pointer to the polyline that this is an active tail of
+ */
+ inline poly_line_arbitrary* getTail() const { return tailp_; }
+
+ /**
+ * @brief get the pointer to the polyline at the other end of the chain
+ */
+ inline poly_line_arbitrary* getOtherTail() const { return otherTailp_->tailp_; }
+
+ /**
+ * @brief get the pointer to the activetail at the other end of the chain
+ */
+ inline active_tail_arbitrary* getOtherActiveTail() const { return otherTailp_; }
+
+ /**
+ * @brief test if another active tail is the other end of the chain
+ */
+ inline bool isOtherTail(const active_tail_arbitrary& b) const { return &b == otherTailp_; }
+
+ /**
+ * @brief update this end of chain pointer to new polyline
+ */
+ inline active_tail_arbitrary& updateTail(poly_line_arbitrary* newTail) { tailp_ = newTail; return *this; }
+
+ inline bool join(active_tail_arbitrary* tail) {
+ if(tail == otherTailp_) {
+ //std::cout << "joining to other tail!\n";
+ return false;
+ }
+ if(tail->head_ == head_) {
+ //std::cout << "joining head to head!\n";
+ return false;
+ }
+ if(!tailp_) {
+ //std::cout << "joining empty tail!\n";
+ return false;
+ }
+ if(!(otherTailp_->head_)) {
+ otherTailp_->copyHoles(*tail);
+ otherTailp_->copyHoles(*this);
+ } else {
+ tail->otherTailp_->copyHoles(*this);
+ tail->otherTailp_->copyHoles(*tail);
+ }
+ poly_line_arbitrary* tail1 = tailp_;
+ poly_line_arbitrary* tail2 = tail->tailp_;
+ if(head_) std::swap(tail1, tail2);
+ typename std::list<point_data<Unit> >::reverse_iterator riter = tail1->points.rbegin();
+ typename std::list<point_data<Unit> >::iterator iter = tail2->points.begin();
+ if(*riter == *iter) {
+ tail1->points.pop_back(); //remove duplicate point
+ }
+ tail1->points.splice(tail1->points.end(), tail2->points);
+ delete tail2;
+ otherTailp_->tailp_ = tail1;
+ tail->otherTailp_->tailp_ = tail1;
+ otherTailp_->otherTailp_ = tail->otherTailp_;
+ tail->otherTailp_->otherTailp_ = otherTailp_;
+ tailp_ = 0;
+ tail->tailp_ = 0;
+ tail->otherTailp_ = 0;
+ otherTailp_ = 0;
+ return true;
+ }
+
+ /**
+ * @brief associate a hole to this active tail by the specified policy
+ */
+ inline active_tail_arbitrary* addHole(active_tail_arbitrary* hole) {
+ holesList_.push_back(hole);
+ copyHoles(*hole);
+ copyHoles(*(hole->otherTailp_));
+ return this;
+ }
+
+ /**
+ * @brief get the list of holes
+ */
+ inline const std::list<active_tail_arbitrary*>& getHoles() const { return holesList_; }
+
+ /**
+ * @brief copy holes from that to this
+ */
+ inline void copyHoles(active_tail_arbitrary& that) { holesList_.splice(holesList_.end(), that.holesList_); }
+
+ /**
+ * @brief find out if solid to right
+ */
+ inline bool solidToRight() const { return !head_; }
+ inline bool solidToLeft() const { return head_; }
+
+ /**
+ * @brief get vertex
+ */
+ inline Point getPoint() const {
+ if(head_) return tailp_->points.front();
+ return tailp_->points.back();
+ }
+
+ /**
+ * @brief add a coordinate to the polygon at this active tail end, properly handle degenerate edges by removing redundant coordinate
+ */
+ inline void pushPoint(Point point) {
+ if(head_) {
+ //if(tailp_->points.size() < 2) {
+ // tailp_->points.push_front(point);
+ // return;
+ //}
+ typename std::list<Point>::iterator iter = tailp_->points.begin();
+ if(iter == tailp_->points.end()) {
+ tailp_->points.push_front(point);
+ return;
+ }
+ ++iter;
+ if(iter == tailp_->points.end()) {
+ tailp_->points.push_front(point);
+ return;
+ }
+ --iter;
+ if(*iter != point) {
+ tailp_->points.push_front(point);
+ }
+ return;
+ }
+ //if(tailp_->points.size() < 2) {
+ // tailp_->points.push_back(point);
+ // return;
+ //}
+ typename std::list<Point>::reverse_iterator iter = tailp_->points.rbegin();
+ if(iter == tailp_->points.rend()) {
+ tailp_->points.push_back(point);
+ return;
+ }
+ ++iter;
+ if(iter == tailp_->points.rend()) {
+ tailp_->points.push_back(point);
+ return;
+ }
+ --iter;
+ if(*iter != point) {
+ tailp_->points.push_back(point);
+ }
+ }
+
+ /**
+ * @brief joins the two chains that the two active tail tails are ends of
+ * checks for closure of figure and writes out polygons appropriately
+ * returns a handle to a hole if one is closed
+ */
+ template <class cT>
+ static inline active_tail_arbitrary* joinChains(Point point, active_tail_arbitrary* at1, active_tail_arbitrary* at2, bool solid,
+ cT& output) {
+ if(at1->otherTailp_ == at2) {
+ //if(at2->otherTailp_ != at1) std::cout << "half closed error\n";
+ //we are closing a figure
+ at1->pushPoint(point);
+ at2->pushPoint(point);
+ if(solid) {
+ //we are closing a solid figure, write to output
+ //std::cout << "test1\n";
+ at1->copyHoles(*(at1->otherTailp_));
+ typename PolyLineArbitraryByConcept<Unit, typename geometry_concept<typename cT::value_type>::type>::type polyData(at1);
+ //poly_line_arbitrary_polygon_data polyData(at1);
+ //std::cout << "test2\n";
+ //std::cout << poly << std::endl;
+ //std::cout << "test3\n";
+ typedef typename cT::value_type result_type;
+ typedef typename geometry_concept<result_type>::type result_concept;
+ output.push_back(result_type());
+ assign(output.back(), polyData);
+ //std::cout << "test4\n";
+ //std::cout << "delete " << at1->otherTailp_ << std::endl;
+ //at1->print();
+ //at1->otherTailp_->print();
+ delete at1->otherTailp_;
+ //at1->print();
+ //at1->otherTailp_->print();
+ //std::cout << "test5\n";
+ //std::cout << "delete " << at1 << std::endl;
+ delete at1;
+ //std::cout << "test6\n";
+ return 0;
+ } else {
+ //we are closing a hole, return the tail end active tail of the figure
+ return at1;
+ }
+ }
+ //we are not closing a figure
+ at1->pushPoint(point);
+ at1->join(at2);
+ delete at1;
+ delete at2;
+ return 0;
+ }
+
+ inline void destroyContents() {
+ if(otherTailp_) {
+ //std::cout << "delete p " << tailp_ << std::endl;
+ if(tailp_) delete tailp_;
+ tailp_ = 0;
+ otherTailp_->otherTailp_ = 0;
+ otherTailp_->tailp_ = 0;
+ otherTailp_ = 0;
+ }
+ for(typename std::list<active_tail_arbitrary*>::iterator itr = holesList_.begin(); itr != holesList_.end(); ++itr) {
+ //std::cout << "delete p " << (*itr) << std::endl;
+ if(*itr) {
+ if((*itr)->otherTailp_) {
+ delete (*itr)->otherTailp_;
+ (*itr)->otherTailp_ = 0;
+ }
+ delete (*itr);
+ }
+ (*itr) = 0;
+ }
+ holesList_.clear();
+ }
+
+ inline void print() {
+ std::cout << this << " " << tailp_ << " " << otherTailp_ << " " << holesList_.size() << " " << head_ << std::endl;
+ }
+
+ static inline std::pair<active_tail_arbitrary*, active_tail_arbitrary*> createActiveTailsAsPair(Point point, bool solid,
+ active_tail_arbitrary* phole, bool fractureHoles) {
+ active_tail_arbitrary* at1 = 0;
+ active_tail_arbitrary* at2 = 0;
+ if(phole && fractureHoles) {
+ //std::cout << "adding hole\n";
+ at1 = phole;
+ //assert solid == false, we should be creating a corner with solid below and to the left if there was a hole
+ at2 = at1->getOtherActiveTail();
+ at2->pushPoint(point);
+ at1->pushPoint(point);
+ } else {
+ at1 = new active_tail_arbitrary(point, at2, solid);
+ at2 = new active_tail_arbitrary(at1);
+ at1->otherTailp_ = at2;
+ at2->head_ = !solid;
+ if(phole)
+ at2->addHole(phole); //assert fractureHoles == false
+ }
+ return std::pair<active_tail_arbitrary*, active_tail_arbitrary*>(at1, at2);
+ }
+
+ };
+
+
+ typedef std::vector<std::pair<Point, int> > vertex_arbitrary_count;
+
+ class less_half_edge_count : public std::binary_function<vertex_half_edge, vertex_half_edge, bool> {
+ private:
+ Point pt_;
+ public:
+ inline less_half_edge_count() {}
+ inline less_half_edge_count(Point point) : pt_(point) {}
+ inline bool operator () (const std::pair<Point, int>& elm1, const std::pair<Point, int>& elm2) const {
+ return less_slope(pt_.get(HORIZONTAL), pt_.get(VERTICAL), elm1.first, elm2.first);
+ }
+ };
+
+ static inline void sort_vertex_arbitrary_count(vertex_arbitrary_count& count, const Point& pt) {
+ less_half_edge_count lfec(pt);
+ std::sort(count.begin(), count.end(), lfec);
+ }
+
+ typedef std::vector<std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*> > incoming_count;
+
+ class less_incoming_count : public std::binary_function<std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>,
+ std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>, bool> {
+ private:
+ Point pt_;
+ public:
+ inline less_incoming_count() {}
+ inline less_incoming_count(Point point) : pt_(point) {}
+ inline bool operator () (const std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>& elm1,
+ const std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>& elm2) const {
+ Unit dx1 = elm1.first.first.first.get(HORIZONTAL) - elm1.first.first.second.get(HORIZONTAL);
+ Unit dx2 = elm2.first.first.first.get(HORIZONTAL) - elm2.first.first.second.get(HORIZONTAL);
+ Unit dy1 = elm1.first.first.first.get(VERTICAL) - elm1.first.first.second.get(VERTICAL);
+ Unit dy2 = elm2.first.first.first.get(VERTICAL) - elm2.first.first.second.get(VERTICAL);
+ return less_slope(dx1, dy1, dx2, dy2);
+ }
+ };
+
+ static inline void sort_incoming_count(incoming_count& count, const Point& pt) {
+ less_incoming_count lfec(pt);
+ std::sort(count.begin(), count.end(), lfec);
+ }
+
+ static inline void compact_vertex_arbitrary_count(const Point& pt, vertex_arbitrary_count &count) {
+ if(count.empty()) return;
+ vertex_arbitrary_count tmp;
+ tmp.reserve(count.size());
+ tmp.push_back(count[0]);
+ //merge duplicates
+ for(unsigned int i = 1; i < count.size(); ++i) {
+ if(!equal_slope(pt.get(HORIZONTAL), pt.get(VERTICAL), tmp[i-1].first, count[i].first)) {
+ tmp.push_back(count[i]);
+ } else {
+ tmp.back().second += count[i].second;
+ }
+ }
+ count.clear();
+ count.swap(tmp);
+ }
+
+ // inline std::ostream& operator<< (std::ostream& o, const vertex_arbitrary_count& c) {
+// for(unsinged int i = 0; i < c.size(); ++i) {
+// o << c[i].first << " " << c[i].second << " ";
+// }
+// return o;
+// }
+
+ class vertex_arbitrary_compact {
+ public:
+ Point pt;
+ vertex_arbitrary_count count;
+ inline vertex_arbitrary_compact() {}
+ inline vertex_arbitrary_compact(const Point& point, const Point& other_point, int countIn) : pt(point) {
+ count.push_back(std::pair<Point, int>(other_point, countIn));
+ }
+ inline vertex_arbitrary_compact(const vertex_half_edge& vertex) : pt(vertex.pt) {
+ count.push_back(std::pair<Point, int>(vertex.other_pt, vertex.count));
+ }
+ inline vertex_arbitrary_compact(const vertex_arbitrary_compact& vertex) : pt(vertex.pt), count(vertex.count) {}
+ inline vertex_arbitrary_compact& operator=(const vertex_arbitrary_compact& vertex){
+ pt = vertex.pt; count = vertex.count; return *this; }
+ inline vertex_arbitrary_compact(const std::pair<Point, Point>& vertex) {}
+ inline vertex_arbitrary_compact& operator=(const std::pair<Point, Point>& vertex){ return *this; }
+ inline bool operator==(const vertex_arbitrary_compact& vertex) const {
+ return pt == vertex.pt && count == vertex.count; }
+ inline bool operator!=(const vertex_arbitrary_compact& vertex) const { return !((*this) == vertex); }
+ inline bool operator==(const std::pair<Point, Point>& vertex) const { return false; }
+ inline bool operator!=(const std::pair<Point, Point>& vertex) const { return !((*this) == vertex); }
+ inline bool operator<(const vertex_arbitrary_compact& vertex) const {
+ if(pt.get(HORIZONTAL) < vertex.pt.get(HORIZONTAL)) return true;
+ if(pt.get(HORIZONTAL) == vertex.pt.get(HORIZONTAL)) {
+ return pt.get(VERTICAL) < vertex.pt.get(VERTICAL);
+ }
+ return false;
+ }
+ inline bool operator>(const vertex_arbitrary_compact& vertex) const { return vertex < (*this); }
+ inline bool operator<=(const vertex_arbitrary_compact& vertex) const { return !((*this) > vertex); }
+ inline bool operator>=(const vertex_arbitrary_compact& vertex) const { return !((*this) < vertex); }
+ inline bool have_vertex_half_edge(int index) const { return count[index]; }
+ inline vertex_half_edge operator[](int index) const { return vertex_half_edge(pt, count[index]); }
+ };
+
+// inline std::ostream& operator<< (std::ostream& o, const vertex_arbitrary_compact& c) {
+// o << c.pt << ", " << c.count;
+// return o;
+// }
+
+ private:
+ //definitions
+ typedef std::map<vertex_half_edge, active_tail_arbitrary*, less_vertex_half_edge> scanline_data;
+ typedef typename scanline_data::iterator iterator;
+ typedef typename scanline_data::const_iterator const_iterator;
+
+ //data
+ scanline_data scanData_;
+ Unit x_;
+ int justBefore_;
+ int fractureHoles_;
+ public:
+ inline polygon_arbitrary_formation() : x_(std::numeric_limits<Unit>::min()), justBefore_(false), fractureHoles_(0) {
+ less_vertex_half_edge lessElm(&x_, &justBefore_);
+ scanData_ = scanline_data(lessElm);
+ }
+ inline polygon_arbitrary_formation(bool fractureHoles = false) : x_(std::numeric_limits<Unit>::min()), justBefore_(false),
+ fractureHoles_(fractureHoles) {
+ less_vertex_half_edge lessElm(&x_, &justBefore_);
+ scanData_ = scanline_data(lessElm);
+ }
+ inline polygon_arbitrary_formation(const polygon_arbitrary_formation& that) { (*this) = that; }
+ inline polygon_arbitrary_formation& operator=(const polygon_arbitrary_formation& that) {
+ x_ = that.x_;
+ justBefore_ = that.justBefore_;
+ fractureHoles_ = that.fractureHoles_;
+ less_vertex_half_edge lessElm(&x_, &justBefore_);
+ scanData_ = scanline_data(lessElm);
+ for(const_iterator itr = that.scanData_.begin(); itr != that.scanData_.end(); ++itr){
+ scanData_.insert(scanData_.end(), *itr);
+ }
+ return *this;
+ }
+
+ //cT is an output container of Polygon45 or Polygon45WithHoles
+ //iT is an iterator over vertex_half_edge elements
+ //inputBegin - inputEnd is a range of sorted iT that represents
+ //one or more scanline stops worth of data
+ template <class cT, class iT>
+ void scan(cT& output, iT inputBegin, iT inputEnd) {
+ //std::cout << "1\n";
+ while(inputBegin != inputEnd) {
+ //std::cout << "2\n";
+ x_ = (*inputBegin).pt.get(HORIZONTAL);
+ //std::cout << "SCAN FORMATION " << x_ << std::endl;
+ //std::cout << "x_ = " << x_ << std::endl;
+ //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ inputBegin = processEvent_(output, inputBegin, inputEnd);
+ }
+ //std::cout << "scan line size: " << scanData_.size() << std::endl;
+ }
+
+ private:
+ //functions
+ template <class cT, class cT2>
+ inline std::pair<std::pair<Point, int>, active_tail_arbitrary*> processPoint_(cT& output, cT2& elements, Point point,
+ incoming_count& counts_from_scanline, vertex_arbitrary_count& incoming_count) {
+ //std::cout << "\nAT POINT: " << point << std::endl;
+ //join any closing solid corners
+ std::vector<int> counts;
+ std::vector<int> incoming;
+ std::vector<active_tail_arbitrary*> tails;
+ counts.reserve(counts_from_scanline.size());
+ tails.reserve(counts_from_scanline.size());
+ incoming.reserve(incoming_count.size());
+ for(unsigned int i = 0; i < counts_from_scanline.size(); ++i) {
+ counts.push_back(counts_from_scanline[i].first.second);
+ tails.push_back(counts_from_scanline[i].second);
+ }
+ for(unsigned int i = 0; i < incoming_count.size(); ++i) {
+ incoming.push_back(incoming_count[i].second);
+ if(incoming_count[i].first < point) {
+ incoming.back() = 0;
+ }
+ }
+
+ active_tail_arbitrary* returnValue = 0;
+ std::pair<Point, int> returnCount(Point(0, 0), 0);
+ int i_size_less_1 = (int)(incoming.size()) -1;
+ int c_size_less_1 = (int)(counts.size()) -1;
+ int i_size = incoming.size();
+ int c_size = counts.size();
+
+ bool have_vertical_tail_from_below = false;
+ if(c_size &&
+ is_vertical(counts_from_scanline.back().first.first)) {
+ have_vertical_tail_from_below = true;
+ }
+ //assert size = size_less_1 + 1
+ //std::cout << tails.size() << " " << incoming.size() << " " << counts_from_scanline.size() << " " << incoming_count.size() << std::endl;
+ // for(unsigned int i = 0; i < counts.size(); ++i) {
+ // std::cout << counts_from_scanline[i].first.first.first.get(HORIZONTAL) << ",";
+ // std::cout << counts_from_scanline[i].first.first.first.get(VERTICAL) << " ";
+ // std::cout << counts_from_scanline[i].first.first.second.get(HORIZONTAL) << ",";
+ // std::cout << counts_from_scanline[i].first.first.second.get(VERTICAL) << ":";
+ // std::cout << counts_from_scanline[i].first.second << " ";
+ // } std::cout << std::endl;
+ // print(incoming_count);
+ {
+ for(int i = 0; i < c_size_less_1; ++i) {
+ //std::cout << i << std::endl;
+ if(counts[i] == -1) {
+ //std::cout << "fixed i\n";
+ for(int j = i + 1; j < c_size; ++j) {
+ //std::cout << j << std::endl;
+ if(counts[j]) {
+ if(counts[j] == 1) {
+ //std::cout << "case1: " << i << " " << j << std::endl;
+ //if a figure is closed it will be written out by this function to output
+ active_tail_arbitrary::joinChains(point, tails[i], tails[j], true, output);
+ counts[i] = 0;
+ counts[j] = 0;
+ tails[i] = 0;
+ tails[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ //find any pairs of incoming edges that need to create pair for leading solid
+ //std::cout << "checking case2\n";
+ {
+ for(int i = 0; i < i_size_less_1; ++i) {
+ //std::cout << i << std::endl;
+ if(incoming[i] == 1) {
+ //std::cout << "fixed i\n";
+ for(int j = i + 1; j < i_size; ++j) {
+ //std::cout << j << std::endl;
+ if(incoming[j]) {
+ //std::cout << incoming[j] << std::endl;
+ if(incoming[j] == -1) {
+ //std::cout << "case2: " << i << " " << j << std::endl;
+ //std::cout << "creating active tail pair\n";
+ std::pair<active_tail_arbitrary*, active_tail_arbitrary*> tailPair =
+ active_tail_arbitrary::createActiveTailsAsPair(point, true, 0, fractureHoles_);
+ //tailPair.first->print();
+ //tailPair.second->print();
+ if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
+ //vertical active tail becomes return value
+ returnValue = tailPair.first;
+ returnCount.first = point;
+ returnCount.second = 1;
+ } else {
+ //std::cout << "new element " << j-1 << " " << -1 << std::endl;
+ //std::cout << point << " " << incoming_count[j].first << std::endl;
+ elements.push_back(std::pair<vertex_half_edge,
+ active_tail_arbitrary*>(vertex_half_edge(point,
+ incoming_count[j].first, -1), tailPair.first));
+ }
+ //std::cout << "new element " << i-1 << " " << 1 << std::endl;
+ //std::cout << point << " " << incoming_count[i].first << std::endl;
+ elements.push_back(std::pair<vertex_half_edge,
+ active_tail_arbitrary*>(vertex_half_edge(point,
+ incoming_count[i].first, 1), tailPair.second));
+ incoming[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ //find any active tail that needs to pass through to an incoming edge
+ //we expect to find no more than two pass through
+
+ //find pass through with solid on top
+ {
+ //std::cout << "checking case 3\n";
+ for(int i = 0; i < c_size; ++i) {
+ //std::cout << i << std::endl;
+ if(counts[i] != 0) {
+ if(counts[i] == 1) {
+ //std::cout << "fixed i\n";
+ for(int j = i_size_less_1; j >= 0; --j) {
+ if(incoming[j] != 0) {
+ if(incoming[j] == 1) {
+ //std::cout << "case3: " << i << " " << j << std::endl;
+ //tails[i]->print();
+ //pass through solid on top
+ tails[i]->pushPoint(point);
+ //std::cout << "after push\n";
+ if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
+ returnValue = tails[i];
+ returnCount.first = point;
+ returnCount.second = -1;
+ } else {
+ elements.push_back(std::pair<vertex_half_edge,
+ active_tail_arbitrary*>(vertex_half_edge(point,
+ incoming_count[j].first, incoming[j]), tails[i]));
+ }
+ tails[i] = 0;
+ counts[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+ //std::cout << "checking case 4\n";
+ //find pass through with solid on bottom
+ {
+ for(int i = c_size_less_1; i >= 0; --i) {
+ //std::cout << "i = " << i << " with count " << counts[i] << std::endl;
+ if(counts[i] != 0) {
+ if(counts[i] == -1) {
+ for(int j = 0; j < i_size; ++j) {
+ if(incoming[j] != 0) {
+ if(incoming[j] == -1) {
+ //std::cout << "case4: " << i << " " << j << std::endl;
+ //pass through solid on bottom
+ tails[i]->pushPoint(point);
+ if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
+ returnValue = tails[i];
+ returnCount.first = point;
+ returnCount.second = 1;
+ } else {
+ //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ //std::cout << point << " " << incoming_count[j].first << std::endl;
+ elements.push_back(std::pair<vertex_half_edge,
+ active_tail_arbitrary*>(vertex_half_edge(point,
+ incoming_count[j].first, incoming[j]), tails[i]));
+ }
+ tails[i] = 0;
+ counts[i] = 0;
+ incoming[j] = 0;
+ }
+ break;
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+ //find the end of a hole or the beginning of a hole
+
+ //find end of a hole
+ {
+ for(int i = 0; i < c_size_less_1; ++i) {
+ if(counts[i] != 0) {
+ for(int j = i+1; j < c_size; ++j) {
+ if(counts[j] != 0) {
+ //std::cout << "case5: " << i << " " << j << std::endl;
+ //we are ending a hole and may potentially close a figure and have to handle the hole
+ returnValue = active_tail_arbitrary::joinChains(point, tails[i], tails[j], false, output);
+ //std::cout << returnValue << std::endl;
+ tails[i] = 0;
+ tails[j] = 0;
+ counts[i] = 0;
+ counts[j] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ }
+ //find beginning of a hole
+ {
+ for(int i = 0; i < i_size_less_1; ++i) {
+ if(incoming[i] != 0) {
+ for(int j = i+1; j < i_size; ++j) {
+ if(incoming[j] != 0) {
+ //std::cout << "case6: " << i << " " << j << std::endl;
+ //we are beginning a empty space
+ active_tail_arbitrary* holep = 0;
+ //if(c_size && counts[c_size_less_1] == 0 &&
+ // counts_from_scanline[c_size_less_1].first.first.first.get(HORIZONTAL) == point.get(HORIZONTAL))
+ if(have_vertical_tail_from_below)
+ holep = tails[c_size_less_1];
+ std::pair<active_tail_arbitrary*, active_tail_arbitrary*> tailPair =
+ active_tail_arbitrary::createActiveTailsAsPair(point, false, holep, fractureHoles_);
+ if(j == i_size_less_1 && incoming_count[j].first.get(HORIZONTAL) == point.get(HORIZONTAL)) {
+ //std::cout << "vertical element " << point << std::endl;
+ returnValue = tailPair.first;
+ returnCount.first = point;
+ //returnCount = incoming_count[j];
+ returnCount.second = -1;
+ } else {
+ //std::cout << "new element " << j-1 << " " << incoming[j] << std::endl;
+ //std::cout << point << " " << incoming_count[j].first << std::endl;
+ elements.push_back(std::pair<vertex_half_edge,
+ active_tail_arbitrary*>(vertex_half_edge(point,
+ incoming_count[j].first, incoming[j]), tailPair.first));
+ }
+ //std::cout << "new element " << i-1 << " " << incoming[i] << std::endl;
+ //std::cout << point << " " << incoming_count[i].first << std::endl;
+ elements.push_back(std::pair<vertex_half_edge,
+ active_tail_arbitrary*>(vertex_half_edge(point,
+ incoming_count[i].first, incoming[i]), tailPair.second));
+ incoming[i] = 0;
+ incoming[j] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ }
+ }
+ if(have_vertical_tail_from_below) {
+ if(tails.back()) {
+ tails.back()->pushPoint(point);
+ returnValue = tails.back();
+ returnCount.first = point;
+ returnCount.second = counts.back();
+ }
+ }
+ //assert that tails, counts and incoming are all null
+ return std::pair<std::pair<Point, int>, active_tail_arbitrary*>(returnCount, returnValue);
+ }
+
+ static inline void print(const vertex_arbitrary_count& count) {
+ for(unsigned i = 0; i < count.size(); ++i) {
+ std::cout << count[i].first.get(HORIZONTAL) << ",";
+ std::cout << count[i].first.get(VERTICAL) << ":";
+ std::cout << count[i].second << " ";
+ } std::cout << std::endl;
+ }
+
+ static inline void print(const scanline_data& data) {
+ for(typename scanline_data::const_iterator itr = data.begin(); itr != data.end(); ++itr){
+ std::cout << itr->first.pt << ", " << itr->first.other_pt << "; ";
+ } std::cout << std::endl;
+ }
+
+ template <class cT, class iT>
+ inline iT processEvent_(cT& output, iT inputBegin, iT inputEnd) {
+ typedef typename high_precision_type<Unit>::type high_precision;
+ //std::cout << "processEvent_\n";
+ justBefore_ = true;
+ //collect up all elements from the tree that are at the y
+ //values of events in the input queue
+ //create vector of new elements to add into tree
+ active_tail_arbitrary* verticalTail = 0;
+ std::pair<Point, int> verticalCount(Point(0, 0), 0);
+ iT currentIter = inputBegin;
+ std::vector<iterator> elementIters;
+ std::vector<std::pair<vertex_half_edge, active_tail_arbitrary*> > elements;
+ while(currentIter != inputEnd && currentIter->pt.get(HORIZONTAL) == x_) {
+ //std::cout << "loop\n";
+ Unit currentY = (*currentIter).pt.get(VERTICAL);
+ //std::cout << "current Y " << currentY << std::endl;
+ //std::cout << "scanline size " << scanData_.size() << std::endl;
+ //print(scanData_);
+ iterator iter = lookUp_(currentY);
+ //std::cout << "found element in scanline " << (iter != scanData_.end()) << std::endl;
+ //int counts[4] = {0, 0, 0, 0};
+ incoming_count counts_from_scanline;
+ //std::cout << "finding elements in tree\n";
+ //if(iter != scanData_.end())
+ // std::cout << "first iter y is " << iter->first.evalAtX(x_) << std::endl;
+ while(iter != scanData_.end() &&
+ iter->first.evalAtX(x_) == (high_precision)currentY) {
+ //std::cout << "loop2\n";
+ elementIters.push_back(iter);
+ counts_from_scanline.push_back(std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>
+ (std::pair<std::pair<Point, Point>, int>(std::pair<Point, Point>(iter->first.pt,
+ iter->first.other_pt),
+ iter->first.count),
+ iter->second));
+ ++iter;
+ }
+ Point currentPoint(x_, currentY);
+ //std::cout << "counts_from_scanline size " << counts_from_scanline.size() << std::endl;
+ sort_incoming_count(counts_from_scanline, currentPoint);
+
+ vertex_arbitrary_count incoming;
+ //std::cout << "aggregating\n";
+ do {
+ //std::cout << "loop3\n";
+ const vertex_half_edge& elem = *currentIter;
+ incoming.push_back(std::pair<Point, int>(elem.other_pt, elem.count));
+ ++currentIter;
+ } while(currentIter != inputEnd && currentIter->pt.get(VERTICAL) == currentY &&
+ currentIter->pt.get(HORIZONTAL) == x_);
+ //print(incoming);
+ sort_vertex_arbitrary_count(incoming, currentPoint);
+ //std::cout << currentPoint.get(HORIZONTAL) << "," << currentPoint.get(VERTICAL) << std::endl;
+ //print(incoming);
+ //std::cout << "incoming counts from input size " << incoming.size() << std::endl;
+ //compact_vertex_arbitrary_count(currentPoint, incoming);
+ vertex_arbitrary_count tmp;
+ tmp.reserve(incoming.size());
+ for(unsigned int i = 0; i < incoming.size(); ++i) {
+ if(currentPoint < incoming[i].first) {
+ tmp.push_back(incoming[i]);
+ }
+ }
+ incoming.swap(tmp);
+ //std::cout << "incoming counts from input size " << incoming.size() << std::endl;
+ //now counts_from_scanline has the data from the left and
+ //incoming has the data from the right at this point
+ //cancel out any end points
+ if(verticalTail) {
+ //std::cout << "adding vertical tail to counts from scanline\n";
+ //std::cout << -verticalCount.second << std::endl;
+ counts_from_scanline.push_back(std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*>
+ (std::pair<std::pair<Point, Point>, int>(std::pair<Point, Point>(verticalCount.first,
+ currentPoint),
+ -verticalCount.second),
+ verticalTail));
+ }
+ if(!incoming.empty() && incoming.back().first.get(HORIZONTAL) == x_) {
+ //std::cout << "inverted vertical event\n";
+ incoming.back().second *= -1;
+ }
+ //std::cout << "calling processPoint_\n";
+ std::pair<std::pair<Point, int>, active_tail_arbitrary*> result = processPoint_(output, elements, Point(x_, currentY), counts_from_scanline, incoming);
+ verticalCount = result.first;
+ verticalTail = result.second;
+ //if(verticalTail) {
+ // std::cout << "have vertical tail\n";
+ // std::cout << verticalCount.second << std::endl;
+ //}
+ if(verticalTail && !(verticalCount.second)) {
+ //we got a hole out of the point we just processed
+ //iter is still at the next y element above the current y value in the tree
+ //std::cout << "checking whether ot handle hole\n";
+ if(currentIter == inputEnd ||
+ currentIter->pt.get(HORIZONTAL) != x_ ||
+ (high_precision)(currentIter->pt.get(VERTICAL)) >= iter->first.evalAtX(x_)) {
+ //std::cout << "handle hole here\n";
+ if(fractureHoles_) {
+ //std::cout << "fracture hole here\n";
+ //we need to handle the hole now and not at the next input vertex
+ active_tail_arbitrary* at = iter->second;
+ high_precision precise_y = iter->first.evalAtX(x_);
+ Unit fracture_y = (Unit)(precise_y);
+ if(precise_y < fracture_y) --fracture_y;
+ Point point(x_, fracture_y);
+ verticalTail->getOtherActiveTail()->pushPoint(point);
+ iter->second = verticalTail->getOtherActiveTail();
+ at->pushPoint(point);
+ verticalTail->join(at);
+ delete at;
+ delete verticalTail;
+ verticalTail = 0;
+ } else {
+ //std::cout << "push hole onto list\n";
+ iter->second->addHole(verticalTail);
+ verticalTail = 0;
+ }
+ }
+ }
+ }
+ //std::cout << "erasing\n";
+ //erase all elements from the tree
+ for(typename std::vector<iterator>::iterator iter = elementIters.begin();
+ iter != elementIters.end(); ++iter) {
+ //std::cout << "erasing loop\n";
+ scanData_.erase(*iter);
+ }
+ //switch comparison tie breaking policy
+ justBefore_ = false;
+ //add new elements into tree
+ //std::cout << "inserting\n";
+ for(typename std::vector<std::pair<vertex_half_edge, active_tail_arbitrary*> >::iterator iter = elements.begin();
+ iter != elements.end(); ++iter) {
+ //std::cout << "inserting loop\n";
+ scanData_.insert(scanData_.end(), *iter);
+ }
+ //std::cout << "end processEvent\n";
+ return currentIter;
+ }
+
+ inline iterator lookUp_(Unit y){
+ //if just before then we need to look from 1 not -1
+ //std::cout << "just before " << justBefore_ << std::endl;
+ return scanData_.lower_bound(vertex_half_edge(Point(x_, y), Point(x_, y+1), 0));
+ }
+
+ public: //test functions
+
+ static inline bool testPolygonArbitraryFormationRect() {
+ std::cout << "testing polygon formation\n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(0, 0), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(0, 0), Point(0, 10), 1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(10, 10), -1));
+ data.push_back(vertex_half_edge(Point(10, 0), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(10, 0), Point(10, 10), -1));
+ data.push_back(vertex_half_edge(Point(10, 10), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygonArbitraryFormationP1() {
+ std::cout << "testing polygon formation P1\n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(0, 0), Point(10, 10), 1));
+ data.push_back(vertex_half_edge(Point(0, 0), Point(0, 10), 1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(10, 20), -1));
+ data.push_back(vertex_half_edge(Point(10, 10), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(10, 10), Point(10, 20), -1));
+ data.push_back(vertex_half_edge(Point(10, 20), Point(10, 10), 1));
+ data.push_back(vertex_half_edge(Point(10, 20), Point(0, 10), 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygonArbitraryFormationP2() {
+ std::cout << "testing polygon formation P2\n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(-3, 1), Point(2, -4), 1));
+ data.push_back(vertex_half_edge(Point(-3, 1), Point(-2, 2), -1));
+ data.push_back(vertex_half_edge(Point(-2, 2), Point(2, 4), -1));
+ data.push_back(vertex_half_edge(Point(-2, 2), Point(-3, 1), 1));
+ data.push_back(vertex_half_edge(Point(2, -4), Point(-3, 1), -1));
+ data.push_back(vertex_half_edge(Point(2, -4), Point(2, 4), -1));
+ data.push_back(vertex_half_edge(Point(2, 4), Point(-2, 2), 1));
+ data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+
+ static inline bool testPolygonArbitraryFormationPolys() {
+ std::cout << "testing polygon formation polys\n";
+ polygon_arbitrary_formation pf(false);
+ std::vector<polygon_with_holes_data<Unit> > polys;
+ polygon_arbitrary_formation pf2(true);
+ std::vector<polygon_with_holes_data<Unit> > polys2;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(0, 0), Point(100, 1), 1));
+ data.push_back(vertex_half_edge(Point(0, 0), Point(1, 100), -1));
+ data.push_back(vertex_half_edge(Point(1, 100), Point(0, 0), 1));
+ data.push_back(vertex_half_edge(Point(1, 100), Point(101, 101), -1));
+ data.push_back(vertex_half_edge(Point(100, 1), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(100, 1), Point(101, 101), 1));
+ data.push_back(vertex_half_edge(Point(101, 101), Point(100, 1), -1));
+ data.push_back(vertex_half_edge(Point(101, 101), Point(1, 100), 1));
+
+ data.push_back(vertex_half_edge(Point(2, 2), Point(10, 2), -1));
+ data.push_back(vertex_half_edge(Point(2, 2), Point(2, 10), -1));
+ data.push_back(vertex_half_edge(Point(2, 10), Point(2, 2), 1));
+ data.push_back(vertex_half_edge(Point(2, 10), Point(10, 10), 1));
+ data.push_back(vertex_half_edge(Point(10, 2), Point(2, 2), 1));
+ data.push_back(vertex_half_edge(Point(10, 2), Point(10, 10), 1));
+ data.push_back(vertex_half_edge(Point(10, 10), Point(10, 2), -1));
+ data.push_back(vertex_half_edge(Point(10, 10), Point(2, 10), -1));
+
+ data.push_back(vertex_half_edge(Point(2, 12), Point(10, 12), -1));
+ data.push_back(vertex_half_edge(Point(2, 12), Point(2, 22), -1));
+ data.push_back(vertex_half_edge(Point(2, 22), Point(2, 12), 1));
+ data.push_back(vertex_half_edge(Point(2, 22), Point(10, 22), 1));
+ data.push_back(vertex_half_edge(Point(10, 12), Point(2, 12), 1));
+ data.push_back(vertex_half_edge(Point(10, 12), Point(10, 22), 1));
+ data.push_back(vertex_half_edge(Point(10, 22), Point(10, 12), -1));
+ data.push_back(vertex_half_edge(Point(10, 22), Point(2, 22), -1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ pf2.scan(polys2, data.begin(), data.end());
+ std::cout << "result size: " << polys2.size() << std::endl;
+ for(unsigned int i = 0; i < polys2.size(); ++i) {
+ std::cout << polys2[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygonArbitraryFormationSelfTouch1() {
+ std::cout << "testing polygon formation self touch 1\n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(0, 0), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(0, 0), Point(0, 10), 1));
+
+ data.push_back(vertex_half_edge(Point(0, 10), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(5, 10), -1));
+
+ data.push_back(vertex_half_edge(Point(10, 0), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(10, 0), Point(10, 5), -1));
+
+ data.push_back(vertex_half_edge(Point(10, 5), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(10, 5), Point(5, 5), 1));
+
+ data.push_back(vertex_half_edge(Point(5, 10), Point(5, 5), 1));
+ data.push_back(vertex_half_edge(Point(5, 10), Point(0, 10), 1));
+
+ data.push_back(vertex_half_edge(Point(5, 2), Point(5, 5), -1));
+ data.push_back(vertex_half_edge(Point(5, 2), Point(7, 2), -1));
+
+ data.push_back(vertex_half_edge(Point(5, 5), Point(5, 10), -1));
+ data.push_back(vertex_half_edge(Point(5, 5), Point(5, 2), 1));
+ data.push_back(vertex_half_edge(Point(5, 5), Point(10, 5), -1));
+ data.push_back(vertex_half_edge(Point(5, 5), Point(7, 2), 1));
+
+ data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
+ data.push_back(vertex_half_edge(Point(7, 2), Point(5, 2), 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygonArbitraryFormationSelfTouch2() {
+ std::cout << "testing polygon formation self touch 2\n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(0, 0), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(0, 0), Point(0, 10), 1));
+
+ data.push_back(vertex_half_edge(Point(0, 10), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(5, 10), -1));
+
+ data.push_back(vertex_half_edge(Point(10, 0), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(10, 0), Point(10, 5), -1));
+
+ data.push_back(vertex_half_edge(Point(10, 5), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(10, 5), Point(5, 5), 1));
+
+ data.push_back(vertex_half_edge(Point(5, 10), Point(4, 1), -1));
+ data.push_back(vertex_half_edge(Point(5, 10), Point(0, 10), 1));
+
+ data.push_back(vertex_half_edge(Point(4, 1), Point(5, 10), 1));
+ data.push_back(vertex_half_edge(Point(4, 1), Point(7, 2), -1));
+
+ data.push_back(vertex_half_edge(Point(5, 5), Point(10, 5), -1));
+ data.push_back(vertex_half_edge(Point(5, 5), Point(7, 2), 1));
+
+ data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
+ data.push_back(vertex_half_edge(Point(7, 2), Point(4, 1), 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygonArbitraryFormationSelfTouch3() {
+ std::cout << "testing polygon formation self touch 3\n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(0, 0), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(0, 0), Point(0, 10), 1));
+
+ data.push_back(vertex_half_edge(Point(0, 10), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(0, 10), Point(6, 10), -1));
+
+ data.push_back(vertex_half_edge(Point(10, 0), Point(0, 0), -1));
+ data.push_back(vertex_half_edge(Point(10, 0), Point(10, 5), -1));
+
+ data.push_back(vertex_half_edge(Point(10, 5), Point(10, 0), 1));
+ data.push_back(vertex_half_edge(Point(10, 5), Point(5, 5), 1));
+
+ data.push_back(vertex_half_edge(Point(6, 10), Point(4, 1), -1));
+ data.push_back(vertex_half_edge(Point(6, 10), Point(0, 10), 1));
+
+ data.push_back(vertex_half_edge(Point(4, 1), Point(6, 10), 1));
+ data.push_back(vertex_half_edge(Point(4, 1), Point(7, 2), -1));
+
+ data.push_back(vertex_half_edge(Point(5, 5), Point(10, 5), -1));
+ data.push_back(vertex_half_edge(Point(5, 5), Point(7, 2), 1));
+
+ data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
+ data.push_back(vertex_half_edge(Point(7, 2), Point(4, 1), 1));
+
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testPolygonArbitraryFormationColinear() {
+ std::cout << "testing polygon formation colinear 3\n";
+ std::cout << "Polygon Set Data { <-3 2, -2 2>:1 <-3 2, -1 4>:-1 <-2 2, 0 2>:1 <-1 4, 0 2>:-1 } \n";
+ polygon_arbitrary_formation pf(true);
+ std::vector<polygon_data<Unit> > polys;
+ std::vector<vertex_half_edge> data;
+ data.push_back(vertex_half_edge(Point(-3, 2), Point(-2, 2), 1));
+ data.push_back(vertex_half_edge(Point(-2, 2), Point(-3, 2), -1));
+
+ data.push_back(vertex_half_edge(Point(-3, 2), Point(-1, 4), -1));
+ data.push_back(vertex_half_edge(Point(-1, 4), Point(-3, 2), 1));
+
+ data.push_back(vertex_half_edge(Point(-2, 2), Point(0, 2), 1));
+ data.push_back(vertex_half_edge(Point(0, 2), Point(-2, 2), -1));
+
+ data.push_back(vertex_half_edge(Point(-1, 4), Point(0, 2), -1));
+ data.push_back(vertex_half_edge(Point(0, 2), Point(-1, 4), 1));
+ std::sort(data.begin(), data.end());
+ pf.scan(polys, data.begin(), data.end());
+ std::cout << "result size: " << polys.size() << std::endl;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ std::cout << "done testing polygon formation\n";
+ return true;
+ }
+
+ static inline bool testSegmentIntersection() {
+ std::cout << "testing segment intersection\n";
+ half_edge he1, he2;
+ he1.first = Point(0, 0);
+ he1.second = Point(10, 10);
+ he2.first = Point(0, 0);
+ he2.second = Point(10, 20);
+ Point result;
+ bool b = compute_intersection(result, he1, he2);
+ if(!b || result != Point(0, 0)) return false;
+ he1.first = Point(0, 10);
+ b = compute_intersection(result, he1, he2);
+ if(!b || result != Point(5, 10)) return false;
+ he1.first = Point(0, 11);
+ b = compute_intersection(result, he1, he2);
+ if(!b || result != Point(5, 10)) return false;
+ he1.first = Point(0, 0);
+ he1.second = Point(1, 9);
+ he2.first = Point(0, 9);
+ he2.second = Point(1, 0);
+ b = compute_intersection(result, he1, he2);
+ if(!b || result != Point(0, 4)) return false;
+
+ he1.first = Point(0, -10);
+ he1.second = Point(1, -1);
+ he2.first = Point(0, -1);
+ he2.second = Point(1, -10);
+ b = compute_intersection(result, he1, he2);
+ if(!b || result != Point(0, -5)) return false;
+ he1.first = Point(std::numeric_limits<int>::max(), std::numeric_limits<int>::max()-1);
+ he1.second = Point(std::numeric_limits<int>::min(), std::numeric_limits<int>::max());
+ //he1.second = Point(0, std::numeric_limits<int>::max());
+ he2.first = Point(std::numeric_limits<int>::max()-1, std::numeric_limits<int>::max());
+ he2.second = Point(std::numeric_limits<int>::max(), std::numeric_limits<int>::min());
+ //he2.second = Point(std::numeric_limits<int>::max(), 0);
+ b = compute_intersection(result, he1, he2);
+ //b is false because of overflow error
+ he1.first = Point(1000, 2000);
+ he1.second = Point(1010, 2010);
+ he2.first = Point(1000, 2000);
+ he2.second = Point(1010, 2020);
+ b = compute_intersection(result, he1, he2);
+ if(!b || result != Point(1000, 2000)) return false;
+
+ return b;
+ }
+
+ };
+
+ template <typename Unit>
+ class poly_line_arbitrary_hole_data {
+ private:
+ typedef typename polygon_arbitrary_formation<Unit>::active_tail_arbitrary active_tail_arbitrary;
+ active_tail_arbitrary* p_;
+ public:
+ typedef point_data<Unit> Point;
+ typedef Point point_type;
+ typedef Unit coordinate_type;
+ typedef typename active_tail_arbitrary::iterator iterator_type;
+ typedef iterator_points_to_compact<iterator_type, Point> compact_iterator_type;
+
+ typedef iterator_type iterator;
+ inline poly_line_arbitrary_hole_data() : p_(0) {}
+ inline poly_line_arbitrary_hole_data(active_tail_arbitrary* p) : p_(p) {}
+ //use default copy and assign
+ inline iterator begin() const { return p_->getTail()->begin(); }
+ inline iterator end() const { return p_->getTail()->end(); }
+ inline compact_iterator_type begin_compact() const { return compact_iterator_type(begin()); }
+ inline compact_iterator_type end_compact() const { return compact_iterator_type(end()); }
+ inline unsigned int size() const { return 0; }
+ template<class iT>
+ inline poly_line_arbitrary_hole_data& set(iT inputBegin, iT inputEnd) {
+ //assert this is not called
+ return *this;
+ }
+ template<class iT>
+ inline poly_line_arbitrary_hole_data& set_compact(iT inputBegin, iT inputEnd) {
+ //assert this is not called
+ return *this;
+ }
+ };
+
+ template <typename Unit>
+ class poly_line_arbitrary_polygon_data {
+ private:
+ typedef typename polygon_arbitrary_formation<Unit>::active_tail_arbitrary active_tail_arbitrary;
+ active_tail_arbitrary* p_;
+ public:
+ typedef point_data<Unit> Point;
+ typedef Point point_type;
+ typedef Unit coordinate_type;
+ typedef typename active_tail_arbitrary::iterator iterator_type;
+ typedef iterator_points_to_compact<iterator_type, Point> compact_iterator_type;
+ typedef typename coordinate_traits<Unit>::coordinate_distance area_type;
+
+ class iterator_holes_type {
+ private:
+ typedef poly_line_arbitrary_hole_data<Unit> holeType;
+ mutable holeType hole_;
+ typename active_tail_arbitrary::iteratorHoles itr_;
+
+ public:
+ typedef std::forward_iterator_tag iterator_category;
+ typedef holeType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const holeType* pointer; //immutable
+ typedef const holeType& reference; //immutable
+ inline iterator_holes_type() {}
+ inline iterator_holes_type(typename active_tail_arbitrary::iteratorHoles itr) : itr_(itr) {}
+ inline iterator_holes_type(const iterator_holes_type& that) : itr_(that.itr_) {}
+ inline iterator_holes_type& operator=(const iterator_holes_type& that) {
+ itr_ = that.itr_;
+ return *this;
+ }
+ inline bool operator==(const iterator_holes_type& that) { return itr_ == that.itr_; }
+ inline bool operator!=(const iterator_holes_type& that) { return itr_ != that.itr_; }
+ inline iterator_holes_type& operator++() {
+ ++itr_;
+ return *this;
+ }
+ inline const iterator_holes_type operator++(int) {
+ iterator_holes_type tmp = *this;
+ ++(*this);
+ return tmp;
+ }
+ inline reference operator*() {
+ hole_ = holeType(*itr_);
+ return hole_;
+ }
+ };
+
+ typedef poly_line_arbitrary_hole_data<Unit> hole_type;
+
+ inline poly_line_arbitrary_polygon_data() : p_(0) {}
+ inline poly_line_arbitrary_polygon_data(active_tail_arbitrary* p) : p_(p) {}
+ //use default copy and assign
+ inline iterator_type begin() const { return p_->getTail()->begin(); }
+ inline iterator_type end() const { return p_->getTail()->end(); }
+ inline compact_iterator_type begin_compact() const { return p_->getTail()->begin(); }
+ inline compact_iterator_type end_compact() const { return p_->getTail()->end(); }
+ inline iterator_holes_type begin_holes() const { return iterator_holes_type(p_->getHoles().begin()); }
+ inline iterator_holes_type end_holes() const { return iterator_holes_type(p_->getHoles().end()); }
+ inline active_tail_arbitrary* yield() { return p_; }
+ //stub out these four required functions that will not be used but are needed for the interface
+ inline unsigned int size_holes() const { return 0; }
+ inline unsigned int size() const { return 0; }
+ template<class iT>
+ inline poly_line_arbitrary_polygon_data& set(iT inputBegin, iT inputEnd) {
+ return *this;
+ }
+ template<class iT>
+ inline poly_line_arbitrary_polygon_data& set_compact(iT inputBegin, iT inputEnd) {
+ return *this;
+ }
+ template<class iT>
+ inline poly_line_arbitrary_polygon_data& set_holes(iT inputBegin, iT inputEnd) {
+ return *this;
+ }
+ };
+
+ template <typename T>
+ struct PolyLineArbitraryByConcept<T, polygon_with_holes_concept> { typedef poly_line_arbitrary_polygon_data<T> type; };
+ template <typename T>
+ struct PolyLineArbitraryByConcept<T, polygon_concept> { typedef poly_line_arbitrary_hole_data<T> type; };
+
+ template <typename T>
+ struct geometry_concept<poly_line_arbitrary_polygon_data<T> > { typedef polygon_45_with_holes_concept type; };
+ template <typename T>
+ struct geometry_concept<poly_line_arbitrary_hole_data<T> > { typedef polygon_45_concept type; };
+}
+
+#endif
Modified: sandbox/gtl/gtl/polygon_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,12 +8,15 @@
#ifndef GTL_POLYGON_DATA_HPP
#define GTL_POLYGON_DATA_HPP
namespace gtl {
-struct polygon_concept;
-template <typename T>
-class polygon_data : public polygon_45_data<T> {
-public:
- typedef polygon_concept geometry_type;
-};
+ struct polygon_concept;
+ template <typename T>
+ class polygon_data : public polygon_45_data<T> {
+ public:
+ typedef polygon_concept geometry_type;
+ };
+
+
+
}
#endif
Modified: sandbox/gtl/gtl/polygon_formation.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_formation.hpp (original)
+++ sandbox/gtl/gtl/polygon_formation.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -283,6 +283,10 @@
template<bool orientT, typename Unit>
class PolyLinePolygonData;
+ //forward declaration
+ template<bool orientT, typename Unit>
+ class PolyLinePolygonWithHolesData;
+
/**
* @brief ActiveTail represents an edge of an incomplete polygon.
*
@@ -392,7 +396,7 @@
}
return *this;
}
- inline iterator operator++(int) {
+ inline const iterator operator++(int) {
iterator tmp(*this);
++(*this);
return tmp;
@@ -526,8 +530,8 @@
* returns a handle to a hole if one is closed
*/
static ActiveTail* joinChains(ActiveTail* at1, ActiveTail* at2, bool solid, std::vector<Unit>& outBufferTmp);
- template <bool orientT>
- static ActiveTail* joinChains(ActiveTail* at1, ActiveTail* at2, bool solid, typename std::vector<PolyLinePolygonData<orientT, Unit> >& outBufferTmp);
+ template <typename PolygonT>
+ static ActiveTail* joinChains(ActiveTail* at1, ActiveTail* at2, bool solid, typename std::vector<PolygonT>& outBufferTmp);
/**
* @brief deallocate temp buffer
@@ -556,14 +560,11 @@
template <typename Unit>
void destroyActiveTail(ActiveTail<Unit>* aTail);
- struct polygon_90_concept;
-
template<bool orientT, typename Unit>
class PolyLineHoleData {
private:
ActiveTail<Unit>* p_;
public:
- typedef polygon_90_concept geometry_type;
typedef Unit coordinate_type;
typedef typename ActiveTail<Unit>::iterator compact_iterator_type;
typedef iterator_compact_to_points<compact_iterator_type, point_data<coordinate_type> > iterator_type;
@@ -575,6 +576,7 @@
inline iterator_type begin() const { return iterator_type(begin_compact(), end_compact()); }
inline iterator_type end() const { return iterator_type(end_compact(), end_compact()); }
inline unsigned int size() const { return 0; }
+ inline ActiveTail<Unit>* yield() { return p_; }
template<class iT>
inline PolyLineHoleData& set(iT inputBegin, iT inputEnd) {
return *this;
@@ -586,18 +588,16 @@
};
- struct polygon_90_with_holes_concept;
-
template<bool orientT, typename Unit>
- class PolyLinePolygonData {
+ class PolyLinePolygonWithHolesData {
private:
ActiveTail<Unit>* p_;
public:
- typedef polygon_90_with_holes_concept geometry_type;
typedef Unit coordinate_type;
typedef typename ActiveTail<Unit>::iterator compact_iterator_type;
typedef iterator_compact_to_points<compact_iterator_type, point_data<coordinate_type> > iterator_type;
typedef PolyLineHoleData<orientT, Unit> hole_type;
+ typedef typename coordinate_traits<Unit>::area_type area_type;
class iteratorHoles {
private:
typename ActiveTail<Unit>::iteratorHoles itr_;
@@ -609,7 +609,7 @@
++itr_;
return *this;
}
- inline iteratorHoles operator++(int) {
+ inline const iteratorHoles operator++(int) {
iteratorHoles tmp(*this);
++(*this);
return tmp;
@@ -624,8 +624,8 @@
};
typedef iteratorHoles iterator_holes_type;
- inline PolyLinePolygonData() : p_(0) {}
- inline PolyLinePolygonData(ActiveTail<Unit>* p) : p_(p) {}
+ inline PolyLinePolygonWithHolesData() : p_(0) {}
+ inline PolyLinePolygonWithHolesData(ActiveTail<Unit>* p) : p_(p) {}
//use default copy and assign
inline compact_iterator_type begin_compact() const { return p_->begin(false, (orientT ? VERTICAL : HORIZONTAL)); }
inline compact_iterator_type end_compact() const { return p_->end(); }
@@ -638,18 +638,18 @@
inline unsigned int size_holes() const { return 0; }
inline unsigned int size() const { return 0; }
template<class iT>
- inline PolyLinePolygonData& set(iT inputBegin, iT inputEnd) {
+ inline PolyLinePolygonWithHolesData& set(iT inputBegin, iT inputEnd) {
return *this;
}
template<class iT>
- inline PolyLinePolygonData& set_compact(iT inputBegin, iT inputEnd) {
+ inline PolyLinePolygonWithHolesData& set_compact(iT inputBegin, iT inputEnd) {
return *this;
}
/// initialize a polygon from x,y values, it is assumed that the first is an x
/// and that the input is a well behaved polygon
template<class iT>
- inline PolyLinePolygonData& set_holes(iT inputBegin, iT inputEnd) {
+ inline PolyLinePolygonWithHolesData& set_holes(iT inputBegin, iT inputEnd) {
return *this;
}
};
@@ -658,15 +658,32 @@
/**
* @brief ScanLine does all the work of stitching together polygons from incoming vertical edges
*/
+ struct ERROR {};
+ template <bool orientT, typename Unit, typename polygon_concept_type>
+ struct PolyLineType { };
+ template <bool orientT, typename Unit>
+ struct PolyLineType<orientT, Unit, polygon_90_with_holes_concept> { typedef PolyLinePolygonWithHolesData<orientT, Unit> type; };
+ template <bool orientT, typename Unit>
+ struct PolyLineType<orientT, Unit, polygon_45_with_holes_concept> { typedef PolyLinePolygonWithHolesData<orientT, Unit> type; };
+ template <bool orientT, typename Unit>
+ struct PolyLineType<orientT, Unit, polygon_with_holes_concept> { typedef PolyLinePolygonWithHolesData<orientT, Unit> type; };
template <bool orientT, typename Unit>
+ struct PolyLineType<orientT, Unit, polygon_90_concept> { typedef PolyLineHoleData<orientT, Unit> type; };
+ template <bool orientT, typename Unit>
+ struct PolyLineType<orientT, Unit, polygon_45_concept> { typedef PolyLineHoleData<orientT, Unit> type; };
+ template <bool orientT, typename Unit>
+ struct PolyLineType<orientT, Unit, polygon_concept> { typedef PolyLineHoleData<orientT, Unit> type; };
+
+ template <bool orientT, typename Unit, typename polygon_concept_type>
class ScanLineToPolygonItrs {
private:
/** @brief a map of horizontal edges of incomplete polygons by their y value coordinate */
std::map<Unit, ActiveTail<Unit>*> tailMap_;
- std::vector<PolyLinePolygonData<orientT, Unit> > outputPolygons_;
+ typedef typename PolyLineType<orientT, Unit, polygon_concept_type>::type PolyLinePolygonData;
+ std::vector<PolyLinePolygonData> outputPolygons_;
bool fractureHoles_;
public:
- typedef typename std::vector<PolyLinePolygonData<orientT, Unit> >::iterator iterator;
+ typedef typename std::vector<PolyLinePolygonData>::iterator iterator;
inline ScanLineToPolygonItrs() {}
/** @brief construct a scanline with the proper offsets, protocol and options */
inline ScanLineToPolygonItrs(bool fractureHoles) : fractureHoles_(fractureHoles) {}
@@ -685,46 +702,46 @@
/**
* @brief ScanLine does all the work of stitching together polygons from incoming vertical edges
*/
- template <typename Unit>
- class ScanLineToPolygons {
- private:
- ScanLineToPolygonItrs<true, Unit> scanline_;
- public:
- inline ScanLineToPolygons() : scanline_() {}
- /** @brief construct a scanline with the proper offsets, protocol and options */
- inline ScanLineToPolygons(bool fractureHoles) : scanline_(fractureHoles) {}
+// template <typename Unit, typename polygon_concept_type>
+// class ScanLineToPolygons {
+// private:
+// ScanLineToPolygonItrs<true, Unit> scanline_;
+// public:
+// inline ScanLineToPolygons() : scanline_() {}
+// /** @brief construct a scanline with the proper offsets, protocol and options */
+// inline ScanLineToPolygons(bool fractureHoles) : scanline_(fractureHoles) {}
- /** @brief process all vertical edges, left and right, at a unique x coordinate, edges must be sorted low to high */
- inline void processEdges(std::vector<Unit>& outBufferTmp, Unit currentX, std::vector<interval_data<Unit> >& leftEdges,
- std::vector<interval_data<Unit> >& rightEdges) {
- typename ScanLineToPolygonItrs<true, Unit>::iterator itr, endItr;
- scanline_.processEdges(itr, endItr, currentX, leftEdges, rightEdges);
- //copy data into outBufferTmp
- while(itr != endItr) {
- typename PolyLinePolygonData<true, Unit>::iterator pditr;
- outBufferTmp.push_back(0);
- unsigned int sizeIndex = outBufferTmp.size() - 1;
- int count = 0;
- for(pditr = (*itr).begin(); pditr != (*itr).end(); ++pditr) {
- outBufferTmp.push_back(*pditr);
- ++count;
- }
- outBufferTmp[sizeIndex] = count;
- typename PolyLinePolygonData<true, Unit>::iteratorHoles pdHoleItr;
- for(pdHoleItr = (*itr).beginHoles(); pdHoleItr != (*itr).endHoles(); ++pdHoleItr) {
- outBufferTmp.push_back(0);
- unsigned int sizeIndex2 = outBufferTmp.size() - 1;
- int count2 = 0;
- for(pditr = (*pdHoleItr).begin(); pditr != (*pdHoleItr).end(); ++pditr) {
- outBufferTmp.push_back(*pditr);
- ++count2;
- }
- outBufferTmp[sizeIndex2] = -count;
- }
- ++itr;
- }
- }
- };
+// /** @brief process all vertical edges, left and right, at a unique x coordinate, edges must be sorted low to high */
+// inline void processEdges(std::vector<Unit>& outBufferTmp, Unit currentX, std::vector<interval_data<Unit> >& leftEdges,
+// std::vector<interval_data<Unit> >& rightEdges) {
+// typename ScanLineToPolygonItrs<true, Unit>::iterator itr, endItr;
+// scanline_.processEdges(itr, endItr, currentX, leftEdges, rightEdges);
+// //copy data into outBufferTmp
+// while(itr != endItr) {
+// typename PolyLinePolygonData<true, Unit>::iterator pditr;
+// outBufferTmp.push_back(0);
+// unsigned int sizeIndex = outBufferTmp.size() - 1;
+// int count = 0;
+// for(pditr = (*itr).begin(); pditr != (*itr).end(); ++pditr) {
+// outBufferTmp.push_back(*pditr);
+// ++count;
+// }
+// outBufferTmp[sizeIndex] = count;
+// typename PolyLinePolygonData<true, Unit>::iteratorHoles pdHoleItr;
+// for(pdHoleItr = (*itr).beginHoles(); pdHoleItr != (*itr).endHoles(); ++pdHoleItr) {
+// outBufferTmp.push_back(0);
+// unsigned int sizeIndex2 = outBufferTmp.size() - 1;
+// int count2 = 0;
+// for(pditr = (*pdHoleItr).begin(); pditr != (*pdHoleItr).end(); ++pditr) {
+// outBufferTmp.push_back(*pditr);
+// ++count2;
+// }
+// outBufferTmp[sizeIndex2] = -count;
+// }
+// ++itr;
+// }
+// }
+// };
const int VERTICAL_HEAD = 1, HEAD_TO_TAIL = 2, TAIL_TO_TAIL = 4, SOLID_TO_RIGHT = 8;
@@ -1319,9 +1336,9 @@
//solid indicates if it was joined by a solit or a space
template <typename Unit>
- template <bool orientT>
+ template <typename PolygonT>
inline ActiveTail<Unit>* ActiveTail<Unit>::joinChains(ActiveTail<Unit>* at1, ActiveTail<Unit>* at2, bool solid,
- std::vector<PolyLinePolygonData<orientT, Unit> >& outBufferTmp) {
+ std::vector<PolygonT>& outBufferTmp) {
//checks to see if we closed a figure
if(at1->isOtherTail(*at2)){
//value of solid tells us if we closed solid or hole
@@ -1508,8 +1525,8 @@
// The currentTail vertical edge turns right and is added to the horizontal edges data.
// The horizontal edge from the left turns upward and becomes the currentTail vertical edge
//
- template <bool orientT, typename Unit>
- inline void ScanLineToPolygonItrs<orientT, Unit>::
+ template <bool orientT, typename Unit, typename polygon_concept_type>
+ inline void ScanLineToPolygonItrs<orientT, Unit, polygon_concept_type>::
processEdges(iterator& beginOutput, iterator& endOutput,
Unit currentX, std::vector<interval_data<Unit> >& leftEdges,
std::vector<interval_data<Unit> >& rightEdges) {
@@ -1520,7 +1537,6 @@
unsigned int rightIndex = 0;
bool bottomAlreadyProcessed = false;
ActiveTail<Unit>* currentTail = 0;
- bool holePassThrough = false;
const Unit UnitMax = std::numeric_limits<Unit>::max();
while(leftIndex < leftEdges.size() || rightIndex < rightEdges.size()) {
interval_data<Unit> edges[2] = {interval_data<Unit> (UnitMax, UnitMax), interval_data<Unit> (UnitMax, UnitMax)};
@@ -1538,7 +1554,7 @@
interval_data<Unit> & nextEdge = edges[!trailingEdge];
//process this edge
if(!bottomAlreadyProcessed) {
- //assert currentTail = 0 || holePassThrough == true
+ //assert currentTail = 0
//process the bottom end of this edge
typename std::map<Unit, ActiveTail<Unit>*>::iterator thisMapItr = findAtNext(tailMap_, nextMapItr, edge.get(LOW));
@@ -1547,10 +1563,8 @@
//it needs to turn upward and become the current tail
ActiveTail<Unit>* tail = thisMapItr->second;
if(currentTail) {
- //assert holePassThrough == true
//stitch currentTail into this tail
currentTail = tail->addHole(currentTail, fractureHoles_);
- holePassThrough = false;
if(!fractureHoles_)
currentTail->pushCoordinate(currentX);
} else {
@@ -1624,7 +1638,6 @@
//thisMapItr is pointing to a horizontal edge in the map at the top of this vertical edge
//we need to join them and potentially close a figure
//assert currentTail != 0
- //assert holePassThrough = false
ActiveTail<Unit>* tail = thisMapItr->second;
//pass the opositve of trailing edge to mean that they are joined because of solid to the right
currentTail = ActiveTail<Unit>::joinChains(currentTail, tail, !trailingEdge, outputPolygons_);
@@ -1674,8 +1687,8 @@
endOutput = outputPolygons_.end();
} //end function
- template<bool orientT, typename Unit>
- inline void ScanLineToPolygonItrs<orientT, Unit>::clearOutput_() {
+ template<bool orientT, typename Unit, typename polygon_concept_type>
+ inline void ScanLineToPolygonItrs<orientT, Unit, polygon_concept_type>::clearOutput_() {
for(unsigned int i = 0; i < outputPolygons_.size(); ++i) {
ActiveTail<Unit>* at1 = outputPolygons_[i].yield();
const std::list<ActiveTail<Unit>*>& holes = at1->getHoles();
@@ -1694,7 +1707,17 @@
outputPolygons_.clear();
}
-}; //polygon_formation namespace
+} //polygon_formation namespace
+
+ template <bool orientT, typename Unit>
+ struct geometry_concept<polygon_formation::PolyLinePolygonWithHolesData<orientT, Unit> > {
+ typedef polygon_90_with_holes_concept type;
+ };
+
+ template <bool orientT, typename Unit>
+ struct geometry_concept<polygon_formation::PolyLineHoleData<orientT, Unit> > {
+ typedef polygon_90_concept type;
+ };
//public API to access polygon formation algorithm
template <typename output_container, typename iterator_type, typename concept_type>
@@ -1704,8 +1727,9 @@
typedef typename iterator_type::value_type::first_type coordinate_type;
polygon_type poly;
unsigned int countPolygons = 0;
- polygon_formation::ScanLineToPolygonItrs<true, coordinate_type> scanlineToPolygonItrsV(fracture_holes);
- polygon_formation::ScanLineToPolygonItrs<false, coordinate_type> scanlineToPolygonItrsH(fracture_holes);
+ typedef typename geometry_concept<polygon_type>::type polygon_concept_type;
+ polygon_formation::ScanLineToPolygonItrs<true, coordinate_type, polygon_concept_type> scanlineToPolygonItrsV(fracture_holes);
+ polygon_formation::ScanLineToPolygonItrs<false, coordinate_type, polygon_concept_type> scanlineToPolygonItrsH(fracture_holes);
std::vector<interval_data<coordinate_type> > leftEdges;
std::vector<interval_data<coordinate_type> > rightEdges;
coordinate_type prevPos = std::numeric_limits<coordinate_type>::max();
@@ -1716,19 +1740,19 @@
coordinate_type pos = (*itr).first;
if(pos != prevPos) {
if(orient == VERTICAL) {
- typename polygon_formation::ScanLineToPolygonItrs<true, coordinate_type>::iterator itrPoly, itrPolyEnd;
+ typename polygon_formation::ScanLineToPolygonItrs<true, coordinate_type, polygon_concept_type>::iterator itrPoly, itrPolyEnd;
scanlineToPolygonItrsV.processEdges(itrPoly, itrPolyEnd, prevPos, leftEdges, rightEdges);
for( ; itrPoly != itrPolyEnd; ++ itrPoly) {
++countPolygons;
- concept_type::assign(poly, *itrPoly);
+ assign(poly, *itrPoly);
container.insert(container.end(), poly);
}
} else {
- typename polygon_formation::ScanLineToPolygonItrs<false, coordinate_type>::iterator itrPoly, itrPolyEnd;
+ typename polygon_formation::ScanLineToPolygonItrs<false, coordinate_type, polygon_concept_type>::iterator itrPoly, itrPolyEnd;
scanlineToPolygonItrsH.processEdges(itrPoly, itrPolyEnd, prevPos, leftEdges, rightEdges);
for( ; itrPoly != itrPolyEnd; ++ itrPoly) {
++countPolygons;
- concept_type::assign(poly, *itrPoly);
+ assign(poly, *itrPoly);
container.insert(container.end(), poly);
}
}
@@ -1744,13 +1768,13 @@
std::pair<interval_data<coordinate_type>, int> element(interval_data<coordinate_type>(prevY, y), count);
if(element.second == 1) {
if(leftEdges.size() && leftEdges.back().high() == element.first.low()) {
- interval_concept::encompass(leftEdges.back(), element.first, interval_concept());
+ encompass(leftEdges.back(), element.first);
} else {
leftEdges.push_back(element.first);
}
} else {
if(rightEdges.size() && rightEdges.back().high() == element.first.low()) {
- interval_concept::encompass(rightEdges.back(), element.first, interval_concept());
+ encompass(rightEdges.back(), element.first);
} else {
rightEdges.push_back(element.first);
}
@@ -1761,19 +1785,19 @@
count += (*itr).second.second;
}
if(orient == VERTICAL) {
- typename polygon_formation::ScanLineToPolygonItrs<true, coordinate_type>::iterator itrPoly, itrPolyEnd;
+ typename polygon_formation::ScanLineToPolygonItrs<true, coordinate_type, polygon_concept_type>::iterator itrPoly, itrPolyEnd;
scanlineToPolygonItrsV.processEdges(itrPoly, itrPolyEnd, prevPos, leftEdges, rightEdges);
for( ; itrPoly != itrPolyEnd; ++ itrPoly) {
++countPolygons;
- concept_type::assign(poly, *itrPoly);
+ assign(poly, *itrPoly);
container.insert(container.end(), poly);
}
} else {
- typename polygon_formation::ScanLineToPolygonItrs<false, coordinate_type>::iterator itrPoly, itrPolyEnd;
+ typename polygon_formation::ScanLineToPolygonItrs<false, coordinate_type, polygon_concept_type>::iterator itrPoly, itrPolyEnd;
scanlineToPolygonItrsH.processEdges(itrPoly, itrPolyEnd, prevPos, leftEdges, rightEdges);
for( ; itrPoly != itrPolyEnd; ++ itrPoly) {
++countPolygons;
- concept_type::assign(poly, *itrPoly);
+ assign(poly, *itrPoly);
container.insert(container.end(), poly);
}
}
Added: sandbox/gtl/gtl/polygon_set_concept.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_set_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,317 @@
+/*
+ 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 GTL_POLYGON_SET_CONCEPT_HPP
+#define GTL_POLYGON_SET_CONCEPT_HPP
+namespace gtl {
+
+ template <typename T, typename T2>
+ struct is_either_polygon_set_type {
+ typedef typename gtl_or<typename is_polygon_set_type<T>::type, typename is_polygon_set_type<T2>::type >::type type;
+ };
+
+ template <typename T>
+ struct is_any_polygon_set_type {
+ typedef typename gtl_or<typename is_polygon_45_or_90_set_type<T>::type, typename is_polygon_set_type<T>::type >::type type;
+ };
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_any_polygon_set_type<polygon_set_type>::type>::type,
+ typename polygon_set_traits<polygon_set_type>::iterator_type>::type
+ begin_polygon_set_data(const polygon_set_type& polygon_set) {
+ return polygon_set_traits<polygon_set_type>::begin(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_any_polygon_set_type<polygon_set_type>::type>::type,
+ typename polygon_set_traits<polygon_set_type>::iterator_type>::type
+ end_polygon_set_data(const polygon_set_type& polygon_set) {
+ return polygon_set_traits<polygon_set_type>::end(polygon_set);
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_polygon_set_type<polygon_set_type>::type>::type,
+ bool>::type
+ clean(const polygon_set_type& polygon_set) {
+ return polygon_set_traits<polygon_set_type>::clean(polygon_set);
+ }
+
+ //assign
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<polygon_set_type_2>::type>::type,
+ polygon_set_type_1>::type &
+ assign(polygon_set_type_1& lvalue, const polygon_set_type_2& rvalue) {
+ if(clean(rvalue))
+ polygon_set_mutable_traits<polygon_set_type_1>::set(lvalue, begin_polygon_set_data(rvalue), end_polygon_set_data(rvalue));
+ else {
+ polygon_set_data<typename polygon_set_traits<polygon_set_type_2>::coordinate_type> ps;
+ ps.insert(begin_polygon_set_data(rvalue), end_polygon_set_data(rvalue));
+ ps.clean();
+ polygon_set_mutable_traits<polygon_set_type_1>::set(lvalue, ps.begin(), ps.end());
+ }
+ return lvalue;
+ }
+
+// //get trapezoids
+// template <typename output_container_type, typename polygon_set_type>
+// typename requires_1< typename gtl_if<typename is_polygon_set_type<polygon_set_type>::type>::type,
+// void>::type
+// get_trapezoids(output_container_type& output, const polygon_set_type& polygon_set) {
+// //TODO
+// // clean(polygon_set);
+// // polygon_set_data<typename polygon_set_traits<polygon_set_type>::coordinate_type> ps;
+// // assign(ps, polygon_set);
+// // ps.get_trapezoids(output);
+// }
+
+ //equivalence
+ template <typename polygon_set_type_1, typename polygon_set_type_2>
+ typename requires_3< typename gtl_if<typename is_any_polygon_set_type<polygon_set_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<polygon_set_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_set_type<polygon_set_type_1, polygon_set_type_2>::type>::type,
+ bool>::type
+ equivalence(const polygon_set_type_1& lvalue,
+ const polygon_set_type_2& rvalue) {
+ polygon_set_data<typename polygon_set_traits<polygon_set_type_1>::coordinate_type> ps1;
+ assign(ps1, lvalue);
+ polygon_set_data<typename polygon_set_traits<polygon_set_type_2>::coordinate_type> ps2;
+ assign(ps2, rvalue);
+ return ps1 == ps2;
+ }
+
+ //clear
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ void>::type
+ clear(polygon_set_type& polygon_set) {
+ polygon_set_data<typename polygon_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(polygon_set, ps);
+ }
+
+ //empty
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ bool>::type
+ empty(const polygon_set_type& polygon_set) {
+ if(clean(polygon_set)) return begin_polygon_set_data(polygon_set) == end_polygon_set_data(polygon_set);
+ polygon_set_data<typename polygon_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(ps, polygon_set);
+ ps.clean();
+ return ps.empty();
+ }
+
+ //extents
+ template <typename polygon_set_type, typename rectangle_type>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ bool>::type
+ extents(rectangle_type& extents_rectangle,
+ const polygon_set_type& polygon_set) {
+ clean(polygon_set);
+ polygon_set_data<typename polygon_set_traits<polygon_set_type>::coordinate_type> ps;
+ assign(ps, polygon_set);
+ return ps.extents(extents_rectangle);
+ }
+
+ //area
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::area_type>::type
+ area(const polygon_set_type& polygon_set) {
+ typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef polygon_with_holes_data<Unit> p_type;
+ typedef typename coordinate_traits<Unit>::area_type area_type;
+ std::vector<p_type> polys;
+ assign(polys, polygon_set);
+ area_type retval = (area_type)0;
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ retval += area(polys[i]);
+ }
+ return retval;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale_up(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type factor) {
+ typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.scale_up(factor);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ scale_down(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type factor) {
+ typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.scale_down(factor);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ //transform
+ template <typename polygon_set_type, typename transformation_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ transform(polygon_set_type& polygon_set,
+ const transformation_type& transformation) {
+ typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+ clean(polygon_set);
+ polygon_set_data<Unit> ps;
+ assign(ps, polygon_set);
+ ps.transform(transformation);
+ assign(polygon_set, ps);
+ return polygon_set;
+ }
+
+ //keep
+ template <typename polygon_set_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_set_type<polygon_set_type>::type>::type,
+ polygon_set_type>::type &
+ keep(polygon_set_type& polygon_set,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::area_type min_area,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::area_type max_area,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_width,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_width,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type min_height,
+ typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type max_height) {
+ typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+ typedef typename coordinate_traits<Unit>::unsigned_area_type uat;
+ std::list<polygon_with_holes_data<Unit> > polys;
+ assign(polys, polygon_set);
+ typename std::list<polygon_with_holes_data<Unit> >::iterator itr_nxt;
+ for(typename std::list<polygon_with_holes_data<Unit> >::iterator itr = polys.begin(); itr != polys.end(); itr = itr_nxt){
+ itr_nxt = itr;
+ ++itr_nxt;
+ rectangle_data<Unit> bbox;
+ extents(bbox, *itr);
+ uat pwidth = delta(bbox, HORIZONTAL);
+ if(pwidth > min_width && pwidth <= max_width){
+ uat pheight = delta(bbox, VERTICAL);
+ if(pheight > min_height && pheight <= max_height){
+ typename coordinate_traits<Unit>::area_type parea = area(*itr);
+ if(parea <= max_area && parea >= min_area) {
+ continue;
+ }
+ }
+ }
+ polys.erase(itr);
+ }
+ assign(polygon_set, polys);
+ return polygon_set;
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_set_view<geometry_type_1, geometry_type_2, 0> >::type
+ operator|(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_set_view<geometry_type_1, geometry_type_2, 0>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_set_view<geometry_type_1, geometry_type_2, 0> >::type
+ operator+(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_set_view<geometry_type_1, geometry_type_2, 0>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_set_view<geometry_type_1, geometry_type_2, 1> >::type
+ operator*(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_set_view<geometry_type_1, geometry_type_2, 1>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_set_view<geometry_type_1, geometry_type_2, 2> >::type
+ operator^(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_set_view<geometry_type_1, geometry_type_2, 2>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_3< typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type,
+ polygon_set_view<geometry_type_1, geometry_type_2, 3> >::type
+ operator-(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return polygon_set_view<geometry_type_1, geometry_type_2, 3>
+ (lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator+=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, 0>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator|=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, 0>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator*=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, 1>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator&=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, 1>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator^=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, 2>(lvalue, rvalue);
+ }
+
+ template <typename geometry_type_1, typename geometry_type_2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_set_type<geometry_type_1>::type>::type,
+ typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type,
+ geometry_type_1>::type &
+ operator-=(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return self_assignment_boolean_op<geometry_type_1, geometry_type_2, 3>(lvalue, rvalue);
+ }
+
+}
+#endif
Modified: sandbox/gtl/gtl/polygon_set_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_set_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_set_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -9,46 +9,32 @@
#define GTL_POLYGON_SET_DATA_HPP
namespace gtl {
+ //foward declare view
+ template <typename ltype, typename rtype, int op_type> class polygon_set_view;
+
template <typename T>
class polygon_set_data {
public:
typedef T coordinate_type;
- typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
- typedef typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::const_iterator iterator_type;
+ typedef point_data<T> point_type;
+ typedef std::pair<point_type, point_type> edge_type;
+ typedef std::pair<edge_type, int> element_type;
+ typedef std::vector<element_type> value_type;
+ typedef typename value_type::const_iterator iterator_type;
typedef polygon_set_data operator_arg_type;
- typedef operator_provides_storage operator_storage_tag;
/// default constructor
- inline polygon_set_data() : orient_(HORIZONTAL), dirty_(false), unsorted_(false) {}
-
- /// constructor
- inline polygon_set_data(orientation_2d orient) : orient_(orient), dirty_(false), unsorted_(false) {}
+ inline polygon_set_data() : dirty_(false), unsorted_(false), is_45_(true) {}
- /// constructor from an iterator pair over vertex data
+ /// constructor from an iterator pair over edge data
template <typename iT>
- inline polygon_set_data(orientation_2d orient, iT input_begin, iT input_end) {
- dirty_ = true;
- unsorted_ = true;
+ inline polygon_set_data(iT input_begin, iT input_end) {
for( ; input_begin != input_end; ++input_begin) { insert(*input_begin); }
}
/// copy constructor
inline polygon_set_data(const polygon_set_data& that) :
- orient_(that.orient_), data_(that.data_), dirty_(that.dirty_), unsorted_(that.unsorted_) {}
-
- /// copy with orientation change constructor
- inline polygon_set_data(orientation_2d orient, const polygon_set_data& that) :
- orient_(orient), dirty_(false), unsorted_(false) {
- if(that.orient() == orient) { (*this) = that; }
- else if(!that.data_.empty()) {
- dirty_ = unsorted_ = true;
- iterator_vertex_orient_conversion<iterator_type> itr1(that.data_.begin()), iter2(that.data_.end());
- data_.resize(that.data_.size());
- for( ; itr1 != iter2; ++itr1) {
- data_.push_back(*itr1);
- }
- }
- }
+ data_(that.data_), dirty_(that.dirty_), unsorted_(that.unsorted_), is_45_(that.is_45_) {}
/// destructor
inline ~polygon_set_data() {}
@@ -56,17 +42,16 @@
/// assignement operator
inline polygon_set_data& operator=(const polygon_set_data& that) {
if(this == &that) return *this;
- orient_ = that.orient_;
data_ = that.data_;
dirty_ = that.dirty_;
unsorted_ = that.unsorted_;
+ is_45_ = that.is_45_;
return *this;
}
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- inline polygon_set_data& operator=(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& that) {
- orient_ = that.orient();
- data_ = that.value();
+ template <typename ltype, typename rtype, int op_type>
+ inline polygon_set_data& operator=(const polygon_set_view<ltype, rtype, op_type>& geometry) {
+ (*this) = geometry.value();
dirty_ = false;
unsorted_ = false;
return *this;
@@ -79,43 +64,111 @@
return *this;
}
- template <typename geometry_object>
- inline polygon_set_data& operator=(const polygon_set_const_wrapper<geometry_object>& geometry) {
- data_.clear();
- insert(geometry.begin(), geometry.end());
- return *this;
- }
-
/// insert iterator range
template <typename iT>
inline void insert(iT input_begin, iT input_end) {
- for( ; input_begin != input_end; ++input_begin) {
+ if(input_begin == input_end) return;
+ for(; input_begin != input_end; ++input_begin) {
insert(*input_begin);
}
}
template <typename geometry_type>
- inline void insert(const geometry_type& geometry_object) {
- iterator_geometry_to_set<typename geometry_concept<geometry_type>::type, geometry_type>
- begin_input(geometry_object, LOW, orient_), end_input(geometry_object, HIGH, orient_);
- insert(begin_input, end_input);
+ inline void insert(const geometry_type& geometry_object, bool is_hole = false) {
+ insert(geometry_object, is_hole, typename geometry_concept<geometry_type>::type());
}
- inline void insert(const std::pair<coordinate_type, std::pair<coordinate_type, int> >& vertex) {
- data_.push_back(vertex);
- dirty_ = true;
- unsorted_ = true;
+ template <typename polygon_type>
+ inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_concept tag) {
+ bool first_iteration = true;
+ point_type first_point;
+ point_type previous_point;
+ point_type current_point;
+ direction_1d winding_dir = winding(polygon_object);
+ int multiplier = winding_dir == COUNTERCLOCKWISE ? 1 : -1;
+ if(is_hole) multiplier *= -1;
+ for(typename polygon_traits<polygon_type>::iterator_type itr = begin_points(polygon_object);
+ itr != end_points(polygon_object); ++itr) {
+ assign(current_point, *itr);
+ if(first_iteration) {
+ first_iteration = false;
+ first_point = previous_point = current_point;
+ } else {
+ if(previous_point != current_point) {
+ element_type elem(edge_type(previous_point, current_point),
+ ( previous_point.get(HORIZONTAL) == current_point.get(HORIZONTAL) ? -1 : 1) * multiplier);
+ insert_clean(elem);
+ }
+ }
+ previous_point = current_point;
+ }
+ current_point = first_point;
+ if(!first_iteration) {
+ if(previous_point != current_point) {
+ element_type elem(edge_type(previous_point, current_point),
+ ( previous_point.get(HORIZONTAL) == current_point.get(HORIZONTAL) ? -1 : 1) * multiplier);
+ insert_clean(elem);
+ }
+ dirty_ = true;
+ unsorted_ = true;
+ }
+ }
+
+ template <typename coordinate_type_2>
+ inline void insert(const polygon_45_set_data<coordinate_type_2>& ps) {
+ std::vector<polygon_45_with_holes_data<coordinate_type_2> > polys;
+ assign(polys, ps);
+ insert(polys.begin(), polys.end());
+ }
+
+ template <typename polygon_type>
+ inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_45_concept tag) {
+ insert(polygon_object, is_hole, polygon_concept()); }
+
+ template <typename polygon_type>
+ inline void insert(const polygon_type& polygon_object, bool is_hole, polygon_90_concept tag) {
+ insert(polygon_object, is_hole, polygon_concept()); }
+
+ template <typename polygon_with_holes_type>
+ inline void insert(const polygon_with_holes_type& polygon_with_holes_object, bool is_hole, polygon_with_holes_concept tag) {
+ insert(polygon_with_holes_object, is_hole, polygon_concept());
+ for(typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type itr =
+ begin_holes(polygon_with_holes_object);
+ itr != end_holes(polygon_with_holes_object); ++itr) {
+ insert(*itr, !is_hole, polygon_concept());
+ }
+ }
+
+ template <typename polygon_with_holes_type>
+ inline void insert(const polygon_with_holes_type& polygon_with_holes_object, bool is_hole, polygon_45_with_holes_concept tag) {
+ insert(polygon_with_holes_object, is_hole, polygon_with_holes_concept()); }
+
+ template <typename polygon_with_holes_type>
+ inline void insert(const polygon_with_holes_type& polygon_with_holes_object, bool is_hole, polygon_90_with_holes_concept tag) {
+ insert(polygon_with_holes_object, is_hole, polygon_with_holes_concept()); }
+
+ template <typename rectangle_type>
+ inline void insert(const rectangle_type& rectangle_object, bool is_hole, rectangle_concept tag) {
+ polygon_90_data<coordinate_type> poly;
+ assign(poly, rectangle_object);
+ insert(poly, is_hole, polygon_concept());
+ }
+
+ inline void insert_clean(const element_type& edge) {
+ if( ! scanline_base<coordinate_type>::is_45_degree(edge.first) &&
+ ! scanline_base<coordinate_type>::is_horizontal(edge.first) &&
+ ! scanline_base<coordinate_type>::is_vertical(edge.first) ) is_45_ = false;
+ data_.push_back(edge);
+ if(data_.back().first.second < data_.back().first.first) {
+ std::swap(data_.back().first.second, data_.back().first.first);
+ data_.back().second *= -1;
+ }
}
- inline void insert(coordinate_type major_coordinate, const std::pair<interval_data<coordinate_type>, int>& edge) {
- std::pair<coordinate_type, std::pair<coordinate_type, int> > vertex;
- vertex.first = major_coordinate;
- vertex.second.first = edge.first.get(LOW);
- vertex.second.second = edge.second;
- insert(vertex);
- vertex.second.first = edge.first.get(HIGH);
- vertex.second.second *= -1;
- insert(vertex);
+ inline void insert(const element_type& edge) {
+ insert_clean(edge);
+ dirty_ = true;
+ unsorted_ = true;
}
template <typename output_container>
@@ -125,13 +178,9 @@
/// equivalence operator
inline bool operator==(const polygon_set_data& p) const {
- if(orient_ == p.orient()) {
- clean();
- p.clean();
- return data_ == p.data_;
- } else {
- return false;
- }
+ clean();
+ p.clean();
+ return data_ == p.data_;
}
/// inequivalence operator
@@ -165,120 +214,183 @@
/// find out if Polygon set is clean
inline bool dirty() const { return dirty_; }
- /// get the scanline orientation of the polygon set
- inline orientation_2d orient() const { return orient_; }
-
- void clean() const {
- if(unsorted_) sort();
- if(dirty_) {
- boolean_op::applyBooleanOr(data_);
- dirty_ = false;
- }
- }
+ void clean() const;
void sort() const{
- std::sort(data_.begin(), data_.end());
- unsorted_ = false;
+ if(unsorted_) {
+ std::sort(data_.begin(), data_.end());
+ unsorted_ = false;
+ }
}
template <typename input_iterator_type>
- void set(input_iterator_type input_begin, input_iterator_type input_end, orientation_2d orient) {
- data_.clear();
- data_.insert(data_.end(), input_begin, input_end);
- orient_ = orient;
+ void set(input_iterator_type input_begin, input_iterator_type input_end) {
+ clear();
+ insert(input_begin, input_end);
+ dirty_ = true;
+ unsorted_ = true;
}
- void set(const value_type& value, orientation_2d orient) {
+ void set(const value_type& value) {
data_ = value;
- orient_ = orient;
+ dirty_ = true;
+ unsorted_ = true;
+ }
+
+ template <typename rectangle_type>
+ bool extents(rectangle_type& rect) {
+ clean();
+ 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).first.first, (*itr).first.second);
+ if(first_iteration)
+ rect = edge_box;
+ else
+ encompass(rect, edge_box);
+ }
+ return true;
}
+
+ template <typename transform_type>
+ inline polygon_set_data&
+ transform(const transform_type& tr) {
+ for(typename value_type::iterator itr = data_.begin(); itr != data_.end(); ++itr) {
+ ::gtl::transform((*itr).first.first, tr);
+ ::gtl::transform((*itr).first.second, tr);
+ }
+ unsorted_ = true;
+ dirty_ = true;
+ return *this;
+ }
+
+ inline polygon_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) {
+ ::gtl::scale_up((*itr).first.first, factor);
+ ::gtl::scale_up((*itr).first.second, factor);
+ }
+ return *this;
+ }
+
+ inline polygon_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) {
+ ::gtl::scale_down((*itr).first.first, factor);
+ ::gtl::scale_down((*itr).first.second, factor);
+ }
+ unsorted_ = true;
+ dirty_ = true;
+ return *this;
+ }
+
+ template <typename scaling_type>
+ inline polygon_set_data& scale(polygon_set_data& polygon_set,
+ const scaling_type& scaling) {
+ for(typename value_type::iterator itr = begin(); itr != end(); ++itr) {
+ ::gtl::scale((*itr).first.first, scaling);
+ ::gtl::scale((*itr).first.second, scaling);
+ }
+ unsorted_ = true;
+ dirty_ = true;
+ return *this;
+ }
+
+ inline bool downcast(polygon_45_set_data<coordinate_type>& result) const {
+ if(!is_45_) return false;
+ for(iterator_type itr = begin(); itr != end(); ++itr) {
+ const element_type& elem = *itr;
+ int count = elem.second;
+ int rise = 1; //up sloping 45
+ if(scanline_base<coordinate_type>::is_horizontal(elem.first)) rise = 0;
+ else if(scanline_base<coordinate_type>::is_vertical(elem.first)) rise = 2;
+ else {
+ if(!scanline_base<coordinate_type>::is_45_degree(elem.first)) {
+ is_45_ = false;
+ return false; //consider throwing because is_45_ has be be wrong
+ }
+ if(elem.first.first.y() > elem.first.second.y()) rise = -1; //down sloping 45
+ }
+ typename polygon_45_set_data<coordinate_type>::Vertex45Compact vertex(elem.first.first, rise, count);
+ result.insert(vertex);
+ typename polygon_45_set_data<coordinate_type>::Vertex45Compact vertex2(elem.first.second, rise, -count);
+ result.insert(vertex2);
+ }
+ return true;
+ }
+
+ inline GEOMETRY_CONCEPT_ID concept_downcast() const {
+ typedef typename coordinate_traits<coordinate_type>::coordinate_difference delta_type;
+ bool is_45 = false;
+ for(iterator_type itr = begin(); itr != end(); ++itr) {
+ const element_type& elem = *itr;
+ delta_type h_delta = euclidean_distance(elem.first.first, elem.first.second, HORIZONTAL);
+ delta_type v_delta = euclidean_distance(elem.first.first, elem.first.second, VERTICAL);
+ if(h_delta != 0 || v_delta != 0) {
+ //neither delta is zero and the edge is not MANHATTAN
+ if(v_delta != h_delta && v_delta != -h_delta) return POLYGON_SET_CONCEPT;
+ else is_45 = true;
+ }
+ }
+ if(is_45) return POLYGON_45_SET_CONCEPT;
+ return POLYGON_90_SET_CONCEPT;
+ }
+
private:
- orientation_2d orient_;
mutable value_type data_;
mutable bool dirty_;
mutable bool unsorted_;
-
+ mutable bool is_45_;
+
private:
//functions
+
+ //TODO write trapezoidization function, object, concept and hook up
+ //template <typename output_container>
+ //void get_dispatch(output_container& output, rectangle_concept tag) {
+ // clean();
+ // get_rectangles(output, data_.begin(), data_.end(), orient_, tag);
+ //}
template <typename output_container>
- void get_dispatch(output_container& output, rectangle_concept tag) {
- clean();
- get_rectangles(output, data_.begin(), data_.end(), orient_, tag);
- }
- template <typename output_container>
- void get_dispatch(output_container& output, polygon_90_concept tag) {
+ void get_dispatch(output_container& output, polygon_concept tag) const {
get_fracture(output, true, tag);
}
template <typename output_container>
- void get_dispatch(output_container& output, polygon_90_with_holes_concept tag) {
+ void get_dispatch(output_container& output, polygon_with_holes_concept tag) const {
get_fracture(output, false, tag);
}
template <typename output_container, typename concept_type>
- void get_fracture(output_container& container, bool fracture_holes, concept_type tag) {
+ void get_fracture(output_container& container, bool fracture_holes, concept_type tag) const {
clean();
- get_polygons(container, data_.begin(), data_.end(), orient_, fracture_holes, tag);
+ polygon_arbitrary_formation<coordinate_type> pf(fracture_holes);
+ typedef typename polygon_arbitrary_formation<coordinate_type>::vertex_half_edge vertex_half_edge;
+ std::vector<vertex_half_edge> data;
+ for(iterator_type itr = data_.begin(); itr != data_.end(); ++itr){
+ data.push_back(vertex_half_edge((*itr).first.first, (*itr).first.second, (*itr).second));
+ data.push_back(vertex_half_edge((*itr).first.second, (*itr).first.first, -1 * (*itr).second));
+ }
+ std::sort(data.begin(), data.end());
+ pf.scan(container, data.begin(), data.end());
}
};
template <typename T>
- struct polygon_set_traits<polygon_set_data<T> > {
- typedef typename polygon_set_data<T>::coordinate_type coordinate_type;
- typedef typename polygon_set_data<T>::iterator_type iterator_type;
- typedef typename polygon_set_data<T>::operator_arg_type operator_arg_type;
- typedef typename polygon_set_data<T>::operator_storage_tag operator_storage_tag;
+ std::ostream& operator << (std::ostream& o, const polygon_set_data<T>& r)
+ {
+ o << "Polygon Set Data { ";
+ for(typename polygon_set_data<T>::iterator_type itr = r.begin(); itr != r.end(); ++itr) {
+ o << "<" << (*itr).first.first << ", " << (*itr).first.second << ">:" << (*itr).second << " ";
+ }
+ o << "} ";
+ return o;
+ }
- static inline iterator_type begin(const polygon_set_data<T>& polygon_set) {
- return polygon_set.begin();
- }
-
- static inline iterator_type end(const polygon_set_data<T>& polygon_set) {
- return polygon_set.end();
- }
-
- template <typename input_iterator_type>
- static inline void set(polygon_set_data<T>& polygon_set,
- input_iterator_type input_begin, input_iterator_type input_end,
- orientation_2d orient) {
- polygon_set.set(input_begin, input_end, orient);
- }
-
- static inline orientation_2d orient(const polygon_set_data<T>& polygon_set) { return polygon_set.orient(); }
-
- static inline bool dirty(const polygon_set_data<T>& polygon_set) { return polygon_set.dirty(); }
-
- static inline bool sorted(const polygon_set_data<T>& polygon_set) { return polygon_set.sorted(); }
-
- };
-
-
-
- template <typename coordinate_type, typename property_type>
- class property_merge {
- private:
- std::vector<std::pair<property_merge_point<coordinate_type>, std::pair<property_type, int> > > pmd_;
- public:
- inline property_merge() {}
- inline property_merge(const property_merge& that) : pmd_(that.pmd_) {}
- inline property_merge& operator=(const property_merge& that) { pmd_ = that.pmd_; }
- inline void insert(const polygon_set_data<coordinate_type>& ps, const property_type& property) {
- merge_scanline<coordinate_type, property_type, polygon_set_data<coordinate_type> >::
- populate_property_merge_data(pmd_, ps.begin(), ps.end(), property, ps.orient());
- }
- template <class GeoObjT>
- inline void insert(const GeoObjT& geoObj, const property_type& property) {
- polygon_set_data<coordinate_type> ps;
- ps.insert(geoObj);
- insert(ps, property);
- }
- //merge properties of input geometries and store the resulting geometries of regions
- //with unique sets of merged properties to polygons sets in a map keyed by sets of properties
- // T = std::map<std::set<property_type>, polygon_set_data<coordiante_type> > or
- // T = std::map<std::vector<property_type>, polygon_set_data<coordiante_type> >
- template <typename ResultType>
- inline void merge(ResultType& result) {
- merge_scanline<coordinate_type, property_type, polygon_set_data<coordinate_type>, typename ResultType::key_type> ms;
- ms.perform_merge(result, pmd_);
- }
+ struct polygon_set_concept;
+ template <typename T>
+ struct geometry_concept<polygon_set_data<T> > {
+ typedef polygon_set_concept type;
};
}
Modified: sandbox/gtl/gtl/polygon_set_traits.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_set_traits.hpp (original)
+++ sandbox/gtl/gtl/polygon_set_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -9,10 +9,114 @@
#define GTL_POLYGON_SET_TRAITS_HPP
namespace gtl {
-template <typename T>
-struct polygon_set_traits {};
+ struct polygon_set_concept {};
+ //default definition of polygon set traits works for any model of polygon , polygon with holes or any vector or list thereof
+ template <typename T>
+ struct polygon_set_traits {
+ typedef typename get_coordinate_type<T, typename geometry_concept<T>::type >::type coordinate_type;
+ typedef typename get_iterator_type<T>::type iterator_type;
+ typedef T operator_arg_type;
+ static inline iterator_type begin(const T& polygon_set) {
+ return get_iterator_type<T>::begin(polygon_set);
+ }
+
+ static inline iterator_type end(const T& polygon_set) {
+ return get_iterator_type<T>::end(polygon_set);
+ }
+
+ static inline bool clean(const T& polygon_set) { return false; }
+
+ static inline bool sorted(const T& polygon_set) { return false; }
+ };
+
+ template <typename T>
+ struct is_polygonal_concept { typedef gtl_no type; };
+ template <>
+ struct is_polygonal_concept<polygon_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_polygonal_concept<polygon_with_holes_concept> { typedef gtl_yes type; };
+ template <>
+ struct is_polygonal_concept<polygon_set_concept> { typedef gtl_yes type; };
+
+ template <typename T>
+ struct is_polygon_set_type {
+ typedef typename is_polygonal_concept<typename geometry_concept<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_polygon_set_type<std::list<T> > {
+ typedef typename is_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type type;
+ };
+ template <typename T>
+ struct is_polygon_set_type<std::vector<T> > {
+ typedef typename is_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_set_type {
+ typedef typename gtl_same_type<polygon_set_concept, typename geometry_concept<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_mutable_polygon_set_type<std::list<T> > {
+ typedef typename is_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type type;
+ };
+ template <typename T>
+ struct is_mutable_polygon_set_type<std::vector<T> > {
+ typedef typename is_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type type;
+ };
+
+ template <typename T>
+ struct polygon_set_mutable_traits {};
+ template <typename T>
+ struct polygon_set_mutable_traits<std::list<T> > {
+ template <typename input_iterator_type>
+ static inline void set(std::list<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end) {
+ polygon_set.clear();
+ polygon_set_data<typename polygon_set_traits<std::list<T> >::coordinate_type> ps;
+ ps.insert(input_begin, input_end);
+ ps.get(polygon_set);
+ }
+ };
+ template <typename T>
+ struct polygon_set_mutable_traits<std::vector<T> > {
+ template <typename input_iterator_type>
+ static inline void set(std::vector<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end) {
+ polygon_set.clear();
+ polygon_set_data<typename polygon_set_traits<std::list<T> >::coordinate_type> ps;
+ ps.insert(input_begin, input_end);
+ ps.get(polygon_set);
+ }
+ };
+
+ template <typename T>
+ struct polygon_set_mutable_traits<polygon_set_data<T> > {
+ template <typename input_iterator_type>
+ static inline void set(polygon_set_data<T>& polygon_set,
+ input_iterator_type input_begin, input_iterator_type input_end) {
+ polygon_set.set(input_begin, input_end);
+ }
+ };
+ template <typename T>
+ struct polygon_set_traits<polygon_set_data<T> > {
+ typedef typename polygon_set_data<T>::coordinate_type coordinate_type;
+ typedef typename polygon_set_data<T>::iterator_type iterator_type;
+ typedef typename polygon_set_data<T>::operator_arg_type operator_arg_type;
+
+ static inline iterator_type begin(const polygon_set_data<T>& polygon_set) {
+ return polygon_set.begin();
+ }
+
+ static inline iterator_type end(const polygon_set_data<T>& polygon_set) {
+ return polygon_set.end();
+ }
+
+ static inline bool clean(const polygon_set_data<T>& polygon_set) { polygon_set.clean(); return true; }
+
+ static inline bool sorted(const polygon_set_data<T>& polygon_set) { int untested = 0;polygon_set.sort(); return true; }
+
+ };
+
}
#endif
Modified: sandbox/gtl/gtl/polygon_set_view.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_set_view.hpp (original)
+++ sandbox/gtl/gtl/polygon_set_view.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,304 +8,152 @@
#ifndef GTL_POLYGON_SET_VIEW_HPP
#define GTL_POLYGON_SET_VIEW_HPP
namespace gtl {
- struct operator_provides_storage {};
- struct operator_requires_copy {};
+
+ template <typename coordinate_type>
+ void polygon_set_data<coordinate_type>::clean() const {
+ if(dirty_) {
+ polygon_45_set_data<coordinate_type> tmp;
+ if(downcast(tmp) ) {
+ tmp.clean();
+ data_.clear();
+ is_45_ = true;
+ polygon_set_data<coordinate_type> tmp2;
+ tmp2.insert(tmp);
+ data_.swap(tmp2.data_);
+ dirty_ = false;
+ sort();
+ } else {
+ sort();
+ arbitrary_boolean_op<coordinate_type> abo;
+ polygon_set_data<coordinate_type> tmp;
+ abo.execute(tmp, begin(), end(), end(), end(), 0);
+ data_.swap(tmp.data_);
+ is_45_ = tmp.is_45_;
+ dirty_ = false;
+ }
+ }
+ }
template <typename value_type, typename arg_type>
- inline void insert_into_view_arg(value_type& dest, const arg_type& arg, orientation_2d orient);
+ inline void insert_into_view_arg(value_type& dest, const arg_type& arg);
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
+ template <typename ltype, typename rtype, int op_type>
class polygon_set_view;
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- struct polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> > {
- typedef typename polygon_set_view<ltype, rtype, op_type, ltag, rtag>::coordinate_type coordinate_type;
- typedef typename polygon_set_view<ltype, rtype, op_type, ltag, rtag>::iterator_type iterator_type;
- typedef typename polygon_set_view<ltype, rtype, op_type, ltag, rtag>::operator_arg_type operator_arg_type;
- typedef typename polygon_set_view<ltype, rtype, op_type, ltag, rtag>::operator_storage_tag operator_storage_tag;
-
- static inline iterator_type begin(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set);
- static inline iterator_type end(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set);
-
- template <typename input_iterator_type>
- static inline void set(polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set,
- input_iterator_type input_begin, input_iterator_type input_end,
- orientation_2d orient);
+ template <typename ltype, typename rtype, int op_type>
+ struct polygon_set_traits<polygon_set_view<ltype, rtype, op_type> > {
+ typedef typename polygon_set_view<ltype, rtype, op_type>::coordinate_type coordinate_type;
+ typedef typename polygon_set_view<ltype, rtype, op_type>::iterator_type iterator_type;
+ typedef typename polygon_set_view<ltype, rtype, op_type>::operator_arg_type operator_arg_type;
- static inline orientation_2d orient(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set);
+ static inline iterator_type begin(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
+ static inline iterator_type end(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
- static inline bool dirty(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set);
+ static inline bool clean(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
- static inline bool sorted(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set);
+ static inline bool sort(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
};
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- class polygon_set_view {
- public:
+ template <typename value_type, typename geometry_type_1, typename geometry_type_2>
+ void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_, int op_type) {
+ typedef geometry_type_1 ltype;
+ typedef geometry_type_2 rtype;
typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
- typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
- typedef typename value_type::const_iterator iterator_type;
- typedef polygon_set_view operator_arg_type;
- typedef operator_provides_storage operator_storage_tag;
- private:
- const ltype& lvalue_;
- const rtype& rvalue_;
- op_type op_;
- orientation_2d orient_;
- mutable value_type output_;
- public:
- polygon_set_view(const ltype& lvalue,
- const rtype& rvalue,
- orientation_2d orient,
- op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
-
- /// get iterator to begin vertex data
- const value_type& value() const {
- if(output_.empty()) {
- value_type linput_;
- value_type rinput_;
- insert_into_view_arg(linput_, lvalue_, orient_);
- insert_into_view_arg(rinput_, rvalue_, orient_);
- boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>());
- }
- return output_;
- }
-
- iterator_type begin() const { return value().begin(); }
- iterator_type end() const { return value().begin(); }
-
- orientation_2d orient() const { return orient_; }
- bool dirty() const { return false; } //result of a boolean is clean
- bool sorted() const { return true; } //result of a boolean is sorted
-
- //insert is not inteded to be called because a view is read only
- void insert(const value_type& value,
- orientation_2d orient) const {
- //throw a helpful exception
+ value_type linput_;
+ value_type rinput_;
+ insert_into_view_arg(linput_, lvalue_);
+ insert_into_view_arg(rinput_, rvalue_);
+ polygon_45_set_data<coordinate_type> l45, r45, o45;
+ if(linput_.downcast(l45) && rinput_.downcast(r45)) {
+ l45.applyAdaptiveBoolean_(o45, op_type, r45);
+ output_.insert(o45);
+ } else {
+ arbitrary_boolean_op<coordinate_type> abo;
+ abo.execute(output_, linput_.begin(), linput_.end(),
+ rinput_.begin(), rinput_.end(), op_type);
}
- void sort() const {} //is always sorted
- };
+ }
- template <typename ltype, typename rtype, typename op_type>
- class polygon_set_view<ltype, rtype, op_type, operator_provides_storage, operator_provides_storage> {
+ template <typename ltype, typename rtype, int op_type>
+ class polygon_set_view {
public:
typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
- typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
- typedef typename value_type::const_iterator iterator_type;
+ typedef polygon_set_data<coordinate_type> value_type;
+ typedef typename value_type::iterator_type iterator_type;
typedef polygon_set_view operator_arg_type;
- typedef operator_provides_storage operator_storage_tag;
private:
const ltype& lvalue_;
const rtype& rvalue_;
- op_type op_;
- orientation_2d orient_;
mutable value_type output_;
+ mutable bool evaluated_;
public:
polygon_set_view(const ltype& lvalue,
- const rtype& rvalue,
- orientation_2d orient,
- op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), op_(op), orient_(orient) {}
+ const rtype& rvalue ) :
+ lvalue_(lvalue), rvalue_(rvalue), evaluated_(false) {}
/// get iterator to begin vertex data
- const value_type& value() const {
- if(output_.empty()) {
- value_type linput_;
- value_type rinput_;
- if(orient_ != lvalue_.orient()) {
- insert_into_view_arg(linput_, lvalue_, orient_);
- if(orient_ != rvalue_.orient()) {
- insert_into_view_arg(rinput_, rvalue_, orient_);
- boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>());
- } else {
- boolean_op::applyBooleanBinaryOp(output_, linput_, rvalue_.value(), boolean_op::BinaryCount<op_type>());
- }
- } else {
- if(!lvalue_.sorted()) lvalue_.sort();
- if(orient_ != rvalue_.orient()) {
- insert_into_view_arg(rinput_, rvalue_, orient_);
- boolean_op::applyBooleanBinaryOp(output_, lvalue_.value(), rinput_, boolean_op::BinaryCount<op_type>());
- } else {
- if(!rvalue_.sorted()) rvalue_.sort();
- boolean_op::applyBooleanBinaryOp(output_, lvalue_.value(), rvalue_.value(), boolean_op::BinaryCount<op_type>());
- }
- }
- }
- return output_;
- }
-
- iterator_type begin() const { return value().begin(); }
- iterator_type end() const { return value().begin(); }
- orientation_2d orient() const { return orient_; }
- bool dirty() const { return false; } //result of a boolean is clean
- bool sorted() const { return true; } //result of a boolean is sorted
-
- //insert is not inteded to be called because a view is read only
- void insert(const value_type& value,
- orientation_2d orient) const {
- //throw a helpful exception
- }
- void sort() const {} //is always sorted
- };
-
- template <typename ltype, typename rtype, typename op_type, typename rtag>
- class polygon_set_view<ltype, rtype, op_type, operator_provides_storage, rtag> {
- public:
- typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
- typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
- typedef typename value_type::const_iterator iterator_type;
- typedef polygon_set_view operator_arg_type;
- typedef operator_provides_storage operator_storage_tag;
- private:
- const ltype& lvalue_;
- const rtype& rvalue_;
- op_type op_;
- orientation_2d orient_;
- mutable value_type output_;
public:
- polygon_set_view(const ltype& lvalue,
- const rtype& rvalue,
- orientation_2d orient,
- op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), op_(op) , orient_(orient) {}
-
- /// get iterator to begin vertex data
const value_type& value() const {
- if(output_.empty()) {
- value_type linput_;
- value_type rinput_;
- insert_into_view_arg(rinput_, rvalue_, orient_);
- if(orient_ != lvalue_.orient()) {
- insert_into_view_arg(linput_, lvalue_, orient_);
- boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>());
- } else {
- if(!lvalue_.sorted()) lvalue_.sort();
- boolean_op::applyBooleanBinaryOp(output_, lvalue_.value(), rinput_, boolean_op::BinaryCount<op_type>());
- }
+ if(!evaluated_) {
+ evaluated_ = true;
+ execute_boolean_op(output_, lvalue_, rvalue_, op_type);
}
return output_;
}
-
- iterator_type begin() const { return value().begin(); }
- iterator_type end() const { return value().begin(); }
- orientation_2d orient() const { return orient_; }
- bool dirty() const { return false; } //result of a boolean is clean
- bool sorted() const { return true; } //result of a boolean is sorted
-
- //insert is not inteded to be called because a view is read only
- void insert(const value_type& value,
- orientation_2d orient) const {
- //throw a helpful exception
- }
- void sort() const {} //is always sorted
- };
-
- template <typename ltype, typename rtype, typename op_type, typename ltag>
- class polygon_set_view<ltype, rtype, op_type, ltag, operator_provides_storage> {
- public:
- typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
- typedef std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > > value_type;
- typedef typename value_type::const_iterator iterator_type;
- typedef polygon_set_view operator_arg_type;
- private:
- const ltype& lvalue_;
- const rtype& rvalue_;
- op_type op_;
- orientation_2d orient_;
- mutable value_type output_;
- mutable value_type linput_;
public:
- polygon_set_view(const ltype& lvalue,
- const rtype& rvalue,
- orientation_2d orient,
- op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), op_(op), orient_(orient) {}
-
- /// get iterator to begin vertex data
- const value_type& value() const {
- if(output_.empty()) {
- value_type linput_;
- value_type rinput_;
- insert_into_view_arg(linput_, lvalue_, orient_);
- if(orient_ != lvalue_.orient()) {
- insert_into_view_arg(rinput_, rvalue_, orient_);
- boolean_op::applyBooleanBinaryOp(output_, linput_, rinput_, boolean_op::BinaryCount<op_type>());
- } else {
- if(!rvalue_.sorted()) rvalue_.sort();
- boolean_op::applyBooleanBinaryOp(output_, linput_, rvalue_.value(), boolean_op::BinaryCount<op_type>());
- }
- }
- return output_;
- }
-
iterator_type begin() const { return value().begin(); }
- iterator_type end() const { return value().begin(); }
- orientation_2d orient() const { return orient_; }
+ iterator_type end() const { return value().end(); }
+
bool dirty() const { return false; } //result of a boolean is clean
bool sorted() const { return true; } //result of a boolean is sorted
- template <typename input_iterator_type>
- void set(input_iterator_type input_begin, input_iterator_type input_end,
- orientation_2d orient) const {
- //TODO
- }
void sort() const {} //is always sorted
};
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- typename polygon_set_view<ltype, rtype, op_type, ltag, rtag>::iterator_type
- polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> >::
- begin(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set) {
+ template <typename ltype, typename rtype, int op_type>
+ typename polygon_set_view<ltype, rtype, op_type>::iterator_type
+ polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+ begin(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
return polygon_set.begin();
}
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- typename polygon_set_view<ltype, rtype, op_type, ltag, rtag>::iterator_type
- polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> >::
- end(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set) {
+ template <typename ltype, typename rtype, int op_type>
+ typename polygon_set_view<ltype, rtype, op_type>::iterator_type
+ polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+ end(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
return polygon_set.end();
}
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- template <typename input_iterator_type>
- void polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> >::
- set(polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set,
- input_iterator_type input_begin, input_iterator_type input_end,
- orientation_2d orient) {
- polygon_set.set(input_begin, input_end, orient);
- }
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- orientation_2d polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> >::
- orient(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set) {
- return polygon_set.orient(); }
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> >::
- dirty(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set) {
- return polygon_set.dirty(); }
- template <typename ltype, typename rtype, typename op_type, typename ltag, typename rtag>
- bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type, ltag, rtag> >::
- sorted(const polygon_set_view<ltype, rtype, op_type, ltag, rtag>& polygon_set) {
- return polygon_set.sorted(); }
+ template <typename ltype, typename rtype, int op_type>
+ bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+ clean(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
+ return true; }
+ template <typename ltype, typename rtype, int op_type>
+ bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+ sort(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
+ return true; }
template <typename value_type, typename arg_type>
- inline void insert_into_view_arg(value_type& dest, const arg_type& arg, orientation_2d orient) {
+ inline void insert_into_view_arg(value_type& dest, const arg_type& arg) {
typedef typename polygon_set_traits<arg_type>::iterator_type literator;
literator itr1, itr2;
itr1 = polygon_set_traits<arg_type>::begin(arg);
itr2 = polygon_set_traits<arg_type>::end(arg);
- if(polygon_set_traits<arg_type>::orient(arg) == orient) {
- for( ; itr1 != itr2; ++itr1) {
- dest.push_back(*itr1);
- }
- if(!polygon_set_traits<arg_type>::sorted(arg)) std::sort(dest.begin(), dest.end());
- } else {
- iterator_vertex_orient_conversion<literator> citr2(itr2);
- for(iterator_vertex_orient_conversion<literator> citr1(itr1); citr1 != citr2; ++citr1) {
- dest.push_back(*citr1);
- }
- std::sort(dest.begin(), dest.end());
- }
+ dest.insert(itr1, itr2);
}
+ template <typename geometry_type_1, typename geometry_type_2, int op_type>
+ geometry_type_1& self_assignment_boolean_op(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
+ typedef geometry_type_1 ltype;
+ typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+ typedef polygon_set_data<coordinate_type> value_type;
+ value_type output_;
+ execute_boolean_op(output_, lvalue_, rvalue_, op_type);
+ polygon_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end());
+ return lvalue_;
+ }
+
+ template <typename ltype, typename rtype, int op_type>
+ struct geometry_concept<polygon_set_view<ltype, rtype, op_type> > { typedef polygon_set_concept type; };
+
}
#endif
Modified: sandbox/gtl/gtl/polygon_traits.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_traits.hpp (original)
+++ sandbox/gtl/gtl/polygon_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,57 +8,1079 @@
#ifndef GTL_POLYGON_TRAITS_HPP
#define GTL_POLYGON_TRAITS_HPP
namespace gtl {
-template <typename T>
-struct polygon_traits {
- typedef typename T::coordinate_type coordinate_type;
- typedef typename T::iterator_type iterator_type;
- typedef typename T::compact_iterator_type compact_iterator_type;
- /// Get the begin iterator
- static inline iterator_type begin(const T& t) {
- return t.begin();
- }
+ template <typename T, typename enable = void>
+ struct polygon_90_traits {
+ typedef typename T::coordinate_type coordinate_type;
+ typedef typename T::compact_iterator_type compact_iterator_type;
+
+ /// Get the begin iterator
+ static inline compact_iterator_type begin_compact(const T& t) {
+ return t.begin_compact();
+ }
- /// Get the end iterator
- static inline iterator_type end(const T& t) {
- return t.end();
- }
+ /// Get the end iterator
+ static inline compact_iterator_type end_compact(const T& t) {
+ return t.end_compact();
+ }
- /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
- template <typename iT>
- static inline T& set(T& t, iT input_begin, iT input_end) {
- t.set(input_begin, input_end);
+ /// Get the number of sides of the polygon
+ static inline unsigned int size(const T& t) {
+ return t.size();
+ }
+
+ /// Get the winding direction of the polygon
+ static inline winding_direction winding(const T& t) {
+ return unknown_winding;
+ }
+ };
+
+ template <typename T, typename enable = void>
+ struct polygon_traits {
+ typedef typename T::coordinate_type coordinate_type;
+ typedef typename T::iterator_type iterator_type;
+ typedef typename T::point_type point_type;
+
+ /// Get the begin iterator
+ static inline iterator_type begin_points(const T& t) {
+ return t.begin();
+ }
+
+ /// Get the end iterator
+ static inline iterator_type end_points(const T& t) {
+ return t.end();
+ }
+
+ /// Get the number of sides of the polygon
+ static inline unsigned int size(const T& t) {
+ return t.size();
+ }
+
+ /// Get the winding direction of the polygon
+ static inline winding_direction winding(const T& t) {
+ return unknown_winding;
+ }
+ };
+
+ template <typename T>
+ struct polygon_traits<T, typename is_same_type_SFINAE<polygon_90_concept, typename geometry_concept<T>::type>::type> {
+ typedef typename polygon_90_traits<T>::coordinate_type coordinate_type;
+ typedef iterator_compact_to_points<typename polygon_90_traits<T>::compact_iterator_type, point_data<coordinate_type> > iterator_type;
+
+ /// Get the begin iterator
+ static inline iterator_type begin_points(const T& t) {
+ return iterator_type(polygon_90_traits<T>::begin_compact(t),
+ polygon_90_traits<T>::end_compact(t));
+ }
+
+ /// Get the end iterator
+ static inline iterator_type end_points(const T& t) {
+ return iterator_type(polygon_90_traits<T>::end_compact(t),
+ polygon_90_traits<T>::end_compact(t));
+ }
+
+ /// Get the number of sides of the polygon
+ static inline unsigned int size(const T& t) {
+ return polygon_90_traits<T>::size(t);
+ }
+
+ /// Get the winding direction of the polygon
+ static inline winding_direction winding(const T& t) {
+ return polygon_90_traits<T>::winding(t);
+ }
+ };
+
+ template <typename T, typename enable = void>
+ struct polygon_with_holes_traits {
+ typedef typename T::iterator_holes_type iterator_holes_type;
+ typedef typename T::hole_type hole_type;
+
+ /// Get the begin iterator
+ static inline iterator_holes_type begin_holes(const T& t) {
+ return t.begin_holes();
+ }
+
+ /// Get the end iterator
+ static inline iterator_holes_type end_holes(const T& t) {
+ return t.end_holes();
+ }
+
+ /// Get the number of holes
+ static inline unsigned int size_holes(const T& t) {
+ return t.size_holes();
+ }
+ };
+
+ template <typename T, typename enable = void>
+ struct polygon_90_mutable_traits {
+
+ /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
+ template <typename iT>
+ static inline T& set_compact(T& t, iT input_begin, iT input_end) {
+ t.set_compact(input_begin, input_end);
+ return t;
+ }
+
+ };
+
+ template <typename T>
+ struct polygon_90_mutable_traits<T, typename is_same_type_SFINAE<polygon_concept, typename geometry_concept<T>::type>::type> {
+ /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
+ template <typename iT>
+ static inline T& set_compact(T& t, iT input_begin, iT input_end) {
+ typedef iterator_points_to_compact<iT, typename polygon_traits<T>::point_type> iTp;
+ t.set_points(iTp(polygon_traits<T>::begin_points(t)), iTp(polygon_traits<T>::end_points(t)));
+ return t;
+ }
+ };
+
+ template <typename T, typename enable = void>
+ struct polygon_mutable_traits {
+
+ /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
+ template <typename iT>
+ static inline T& set_points(T& t, iT input_begin, iT input_end) {
+ t.set(input_begin, input_end);
+ return t;
+ }
+
+ };
+
+ template <typename T, typename enable = void>
+ struct polygon_with_holes_mutable_traits {
+
+ /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
+ template <typename iT>
+ static inline T& set_holes(T& t, iT inputBegin, iT inputEnd) {
+ t.set_holes(inputBegin, inputEnd);
+ return t;
+ }
+
+ };
+}
+#include "isotropy.hpp"
+
+//point
+#include "point_data.hpp"
+#include "point_traits.hpp"
+#include "point_concept.hpp"
+
+//interval
+#include "interval_data.hpp"
+#include "interval_traits.hpp"
+#include "interval_concept.hpp"
+
+//rectangle
+#include "rectangle_data.hpp"
+#include "rectangle_traits.hpp"
+#include "rectangle_concept.hpp"
+
+//algorithms needed by polygon types
+#include "iterator_points_to_compact.hpp"
+#include "iterator_compact_to_points.hpp"
+
+namespace gtl {
+ struct polygon_concept {};
+ struct polygon_with_holes_concept {};
+ struct polygon_45_concept {};
+ struct polygon_45_with_holes_concept {};
+ struct polygon_90_concept {};
+ struct polygon_90_with_holes_concept {};
+
+
+ template <typename T>
+ struct is_polygon_90_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_90_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_polygon_45_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_or<typename is_polygon_90_type<T>::type,
+ typename gtl_same_type<polygon_45_concept, GC>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_polygon_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_or<typename is_polygon_45_type<T>::type,
+ typename gtl_same_type<polygon_concept, GC>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_polygon_90_with_holes_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_or<typename is_polygon_90_type<T>::type,
+ typename gtl_same_type<polygon_90_with_holes_concept, GC>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_polygon_45_with_holes_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_or_3<typename is_polygon_90_with_holes_type<T>::type,
+ typename is_polygon_45_type<T>::type,
+ typename gtl_same_type<polygon_45_with_holes_concept, GC>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_polygon_with_holes_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_or_3<typename is_polygon_45_with_holes_type<T>::type,
+ typename is_polygon_type<T>::type,
+ typename gtl_same_type<polygon_with_holes_concept, GC>::type>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_90_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_90_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_45_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_45_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_90_with_holes_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_90_with_holes_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_45_with_holes_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_45_with_holes_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_mutable_polygon_with_holes_type {
+ typedef typename geometry_concept<T>::type GC;
+ typedef typename gtl_same_type<polygon_with_holes_concept, GC>::type type;
+ };
+
+ template <typename T>
+ struct is_any_mutable_polygon_with_holes_type {
+ typedef typename gtl_or_3<typename is_mutable_polygon_90_with_holes_type<T>::type,
+ typename is_mutable_polygon_45_with_holes_type<T>::type,
+ typename is_mutable_polygon_with_holes_type<T>::type>::type type;
+ };
+ template <typename T>
+ struct is_any_mutable_polygon_without_holes_type {
+ typedef typename gtl_or_3<typename is_mutable_polygon_90_type<T>::type,
+ typename is_mutable_polygon_45_type<T>::type,
+ typename is_mutable_polygon_type<T>::type>::type type; };
+
+ template <typename T>
+ struct is_any_mutable_polygon_type {
+ typedef typename gtl_or<typename is_any_mutable_polygon_with_holes_type<T>::type,
+ typename is_any_mutable_polygon_without_holes_type<T>::type>::type type;
+ };
+
+ template <>
+ struct geometry_domain<polygon_45_concept> { typedef forty_five_domain type; };
+ template <>
+ struct geometry_domain<polygon_45_with_holes_concept> { typedef forty_five_domain type; };
+ template <>
+ struct geometry_domain<polygon_90_concept> { typedef manhattan_domain type; };
+ template <>
+ struct geometry_domain<polygon_90_with_holes_concept> { typedef manhattan_domain type; };
+
+ template <typename domain_type, typename coordinate_type>
+ struct distance_type_by_domain { typedef typename coordinate_traits<coordinate_type>::coordinate_distance type; };
+ template <typename coordinate_type>
+ struct distance_type_by_domain<manhattan_domain, coordinate_type> {
+ typedef typename coordinate_traits<coordinate_type>::coordinate_difference type; };
+
+ template <typename T, typename iT>
+ typename requires_1 <typename gtl_if<typename is_any_mutable_polygon_type<T>::type>::type, T>::type &
+ set_points(T& t, iT begin_points, iT end_points) {
+ polygon_mutable_traits<T>::set_points(t, begin_points, end_points);
return t;
}
+
+ template <typename T, typename iT>
+ typename requires_1 <typename gtl_if<typename gtl_or< typename is_mutable_polygon_90_type<T>::type,
+ typename is_mutable_polygon_90_with_holes_type<T>::type>::type>::type, T>::type &
+ set_compact(T& t, iT begin_compact_coordinates, iT end_compact_coordinates) {
+ polygon_90_mutable_traits<T>::set_compact(t, begin_compact_coordinates, end_compact_coordinates);
+ return t;
+ }
+
+ template <typename T, typename iT>
+ typename requires_2 <typename gtl_if<typename is_any_mutable_polygon_with_holes_type<T>::type>::type,
+ typename is_different_type_SFINAE<typename geometry_domain<typename geometry_concept<T>::type>::type, manhattan_domain>::type,
+ T>::type &
+ set_compact(T& t, iT begin_compact_coordinates, iT end_compact_coordinates) {
+ iterator_compact_to_points<iT, point_data<typename polygon_traits<T>::coordinate_type> >
+ itrb(begin_compact_coordinates, end_compact_coordinates),
+ itre(end_compact_coordinates, end_compact_coordinates);
+ return set_points(t, itrb, itre);
+ }
+
+ template <typename T, typename iT>
+ typename requires_1 <typename gtl_if<typename is_any_mutable_polygon_with_holes_type<T>::type>::type, T>::type &
+ set_holes(T& t, iT begin_holes, iT end_holes) {
+ polygon_with_holes_mutable_traits<T>::set_holes(t, begin_holes, end_holes);
+ return t;
+ }
+
+ template <typename T>
+ typename requires_2 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_domain<typename geometry_concept<T>::type>::type, manhattan_domain>::type,
+ typename polygon_90_traits<T>::compact_iterator_type>::type
+ begin_compact(const T& polygon) {
+ return polygon_90_traits<T>::begin_compact(polygon);
+ }
- /// Get the begin iterator
- static inline compact_iterator_type begin_compact(const T& t) {
- return t.begin_compact();
+ template <typename T>
+ typename requires_2 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_domain<typename geometry_concept<T>::type>::type, manhattan_domain>::type,
+ typename polygon_90_traits<T>::compact_iterator_type>::type
+ end_compact(const T& polygon) {
+ return polygon_90_traits<T>::end_compact(polygon);
}
- /// Get the end iterator
- static inline compact_iterator_type end_compact(const T& t) {
- return t.end_compact();
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename polygon_traits<T>::iterator_type>::type
+ begin_points(const T& polygon) {
+ return polygon_traits<T>::begin_points(polygon);
+ }
+
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename polygon_traits<T>::iterator_type>::type
+ end_points(const T& polygon) {
+ return polygon_traits<T>::end_points(polygon);
+ }
+
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ unsigned int>::type
+ size(const T& polygon) {
+ return polygon_traits<T>::size(polygon);
+ }
+
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename polygon_with_holes_traits<T>::iterator_holes_type>::type
+ begin_holes(const T& polygon) {
+ return polygon_with_holes_traits<T>::begin_holes(polygon);
+ }
+
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename polygon_with_holes_traits<T>::iterator_holes_type>::type
+ end_holes(const T& polygon) {
+ return polygon_with_holes_traits<T>::end_holes(polygon);
+ }
+
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ unsigned int>::type
+ size_holes(const T& polygon) {
+ return polygon_with_holes_traits<T>::size_holes(polygon);
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_type<T1>::type>::type,
+ typename gtl_if<typename is_polygon_type<T2>::type>::type, T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ polygon_mutable_traits<T1>::set_points(lvalue, polygon_traits<T2>::begin_points(rvalue),
+ polygon_traits<T2>::end_points(rvalue));
+ return lvalue;
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_with_holes_type<T1>::type>::type,
+ typename gtl_if<typename is_polygon_with_holes_type<T2>::type>::type, T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ polygon_mutable_traits<T1>::set_points(lvalue, polygon_traits<T2>::begin_points(rvalue),
+ polygon_traits<T2>::end_points(rvalue));
+ polygon_with_holes_mutable_traits<T1>::set_holes(lvalue, polygon_with_holes_traits<T2>::begin_holes(rvalue),
+ polygon_with_holes_traits<T2>::end_holes(rvalue));
+ return lvalue;
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_type<T1>::type>::type,
+ typename gtl_if<typename is_polygon_45_type<T2>::type>::type,
+ T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ polygon_mutable_traits<T1>::set_points(lvalue, polygon_traits<T2>::begin_points(rvalue),
+ polygon_traits<T2>::end_points(rvalue));
+ return lvalue;
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_45_with_holes_type<T1>::type>::type,
+ typename gtl_if<typename is_polygon_45_with_holes_type<T2>::type>::type, T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ polygon_mutable_traits<T1>::set_points(lvalue, polygon_traits<T2>::begin_points(rvalue),
+ polygon_traits<T2>::end_points(rvalue));
+ polygon_with_holes_mutable_traits<T1>::set_holes(lvalue, polygon_with_holes_traits<T2>::begin_holes(rvalue),
+ polygon_with_holes_traits<T2>::end_holes(rvalue));
+ return lvalue;
}
- /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
- template <typename iT>
- static inline T& set_compact(T& t, iT input_begin, iT input_end) {
- t.set_compact(input_begin, input_end);
- return t;
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_type<T1>::type>::type,
+ typename gtl_if<typename is_polygon_90_type<T2>::type>::type, T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ polygon_90_mutable_traits<T1>::set_compact(lvalue, polygon_90_traits<T2>::begin_compact(rvalue),
+ polygon_90_traits<T2>::end_compact(rvalue));
+ return lvalue;
}
- /// Get the number of sides of the polygon
- static inline unsigned int size(const T& t) {
- return t.size();
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_with_holes_type<T1>::type>::type,
+ typename gtl_if< typename is_polygon_90_with_holes_type<T2>::type>::type, T1>::type &
+ assign(T1& lvalue, const T2& rvalue) {
+ polygon_90_mutable_traits<T1>::set_compact(lvalue, polygon_90_traits<T2>::begin_compact(rvalue),
+ polygon_90_traits<T2>::end_compact(rvalue));
+ polygon_with_holes_mutable_traits<T1>::set_holes(lvalue, polygon_with_holes_traits<T2>::begin_holes(rvalue),
+ polygon_with_holes_traits<T2>::end_holes(rvalue));
+ return lvalue;
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename gtl_if<typename is_any_mutable_polygon_type<T1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<T2>::type>::type, T1>::type &
+ assign(T1& polygon, const T2& rect) {
+ typedef point_data<typename polygon_traits<T1>::coordinate_type> PT;
+ PT points[4] = {PT(xl(rect), yl(rect)), PT(xh(rect), yl(rect)), PT(xh(rect), yh(rect)), PT(xl(rect), yh(rect))};
+ set_points(polygon, points, points+4);
+ return polygon;
+ }
+
+ template <typename polygon_type, typename point_type>
+ typename requires_2< typename gtl_if<typename is_mutable_polygon_90_type<polygon_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ polygon_type>::type &
+ convolve(polygon_type& polygon, const point_type& point) {
+ std::vector<typename polygon_90_traits<polygon_type>::coordinate_type> coords;
+ coords.reserve(size(polygon));
+ bool pingpong = true;
+ for(typename polygon_90_traits<polygon_type>::compact_iterator_type iter = begin_compact(polygon);
+ iter != end_compact(polygon); ++iter) {
+ coords.push_back((*iter) + (pingpong ? x(point) : y(point)));
+ pingpong = !pingpong;
+ }
+ polygon_90_mutable_traits<polygon_type>::set_compact(polygon, coords.begin(), coords.end());
+ return polygon;
+ }
+ template <typename polygon_type, typename point_type>
+ typename requires_2< typename gtl_if<typename gtl_or<typename is_mutable_polygon_45_type<polygon_type>::type,
+ typename is_mutable_polygon_type<polygon_type>::type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ polygon_type>::type &
+ convolve(polygon_type& polygon, const point_type& point) {
+ std::vector<point_data<typename polygon_traits<polygon_type>::coordinate_type> > points;
+ points.reserve(size(polygon));
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin_points(polygon);
+ iter != end_points(polygon); ++iter) {
+ points.push_back(*iter);
+ convolve(points.back(), point);
+ }
+ polygon_mutable_traits<polygon_type>::set_points(polygon, points.begin(), points.end());
+ return polygon;
}
- /// Get the winding direction of the polygon
- static inline winding_direction winding(const T& t) {
- return unknown_winding;
+ template <typename polygon_type, typename point_type>
+ typename requires_2< typename gtl_if<typename is_any_mutable_polygon_with_holes_type<polygon_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ polygon_type>::type &
+ convolve(polygon_type& polygon, const point_type& point) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ hole_type h;
+ set_points(h, begin_points(polygon), end_points(polygon));
+ convolve(h, point);
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ for(typename polygon_with_holes_traits<polygon_type>::iterator_holes_type itr = begin_holes(polygon);
+ itr != end_holes(polygon); ++itr) {
+ holes.push_back(*itr);
+ convolve(holes.back(), point);
+ }
+ assign(polygon, h);
+ set_holes(polygon, holes.begin(), holes.end());
+ return polygon;
+ }
+
+ template <typename T>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_type<T>::type>::type, T>::type &
+ move(T& polygon, orientation_2d orient, typename polygon_traits<T>::coordinate_type displacement) {
+ typedef typename polygon_traits<T>::coordinate_type Unit;
+ if(orient == HORIZONTAL) return convolve(polygon, point_data<Unit>(displacement, Unit(0)));
+ return convolve(polygon, point_data<Unit>(Unit(0), displacement));
+ }
+
+ template <typename polygon_type, typename transform_type>
+ typename requires_1< typename gtl_if<typename is_mutable_polygon_90_type<polygon_type>::type>::type, polygon_type>::type &
+ transform(polygon_type& polygon, const transform_type& tr) {
+ std::vector<typename polygon_90_traits<polygon_type>::coordinate_type> coords;
+ coords.reserve(size(polygon));
+ bool pingpong = true;
+ for(typename polygon_90_traits<polygon_type>::compact_iterator_type iter = begin_compact(polygon);
+ iter != end_compact(polygon); ++iter) {
+ typename polygon_90_traits<polygon_type>::coordinate_type dummy(0);
+ coords.push_back(*iter);
+ if(pingpong)
+ tr.transform(coords.back(), dummy);
+ else
+ tr.transform(dummy, coords.back());
+ pingpong = !pingpong;
+ }
+ polygon_90_mutable_traits<polygon_type>::set_compact(polygon, coords.begin(), coords.end());
+ return polygon;
+ }
+ template <typename polygon_type, typename transform_type>
+ typename requires_1< typename gtl_if<typename gtl_or<typename is_mutable_polygon_45_type<polygon_type>::type,
+ typename is_mutable_polygon_type<polygon_type>::type>::type>::type, polygon_type>::type &
+ transform(polygon_type& polygon, const transform_type& tr) {
+ std::vector<point_data<typename polygon_traits<polygon_type>::coordinate_type> > points;
+ points.reserve(size(polygon));
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin_points(polygon);
+ iter != end_points(polygon); ++iter) {
+ points.push_back(*iter);
+ transform(points.back(), tr);
+ }
+ polygon_mutable_traits<polygon_type>::set_points(polygon, points.begin(), points.end());
+ return polygon;
+ }
+
+ template <typename T, typename transform_type>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_with_holes_type<T>::type>::type, T>::type &
+ transform(T& polygon, const transform_type& tr) {
+ typedef typename polygon_with_holes_traits<T>::hole_type hole_type;
+ hole_type h;
+ set_points(h, begin_points(polygon), end_points(polygon));
+ transform(h, tr);
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ for(typename polygon_with_holes_traits<T>::iterator_holes_type itr = begin_holes(polygon);
+ itr != end_holes(polygon); ++itr) {
+ holes.push_back(*itr);
+ transform(holes.back(), tr);
+ }
+ assign(polygon, h);
+ set_holes(polygon, holes.begin(), holes.end());
+ return polygon;
+ }
+
+ template <typename polygon_type>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_without_holes_type<polygon_type>::type>::type, polygon_type>::type &
+ scale_up(polygon_type& polygon, typename coordinate_traits<typename polygon_traits<polygon_type>::coordinate_type>::unsigned_area_type factor) {
+ std::vector<point_data<typename polygon_traits<polygon_type>::coordinate_type> > points;
+ points.reserve(size(polygon));
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin_points(polygon);
+ iter != end_points(polygon); ++iter) {
+ points.push_back(*iter);
+ scale_up(points.back(), factor);
+ }
+ polygon_mutable_traits<polygon_type>::set_points(polygon, points.begin(), points.end());
+ return polygon;
+ }
+
+ template <typename T>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_with_holes_type<T>::type>::type, T>::type &
+ scale_up(T& polygon, typename coordinate_traits<typename polygon_traits<T>::coordinate_type>::unsigned_area_type factor) {
+ typedef typename polygon_with_holes_traits<T>::hole_type hole_type;
+ hole_type h;
+ set_points(h, begin_points(polygon), end_points(polygon));
+ scale_up(h, factor);
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ for(typename polygon_with_holes_traits<T>::iterator_holes_type itr = begin_holes(polygon);
+ itr != end_holes(polygon); ++itr) {
+ holes.push_back(*itr);
+ scale_up(holes.back(), factor);
+ }
+ assign(polygon, h);
+ set_holes(polygon, holes.begin(), holes.end());
+ return polygon;
+ }
+
+ //scale non-45 down
+ template <typename polygon_type>
+ typename requires_2< typename gtl_if<typename is_any_mutable_polygon_without_holes_type<polygon_type>::type>::type,
+ typename gtl_if<typename gtl_not<typename gtl_same_type
+ < forty_five_domain,
+ typename geometry_domain<typename geometry_concept<polygon_type>::type>::type>::type>::type>::type,
+ polygon_type>::type &
+ scale_down(polygon_type& polygon, typename coordinate_traits<typename polygon_traits<polygon_type>::coordinate_type>::unsigned_area_type factor) {
+ std::vector<point_data<typename polygon_traits<polygon_type>::coordinate_type> > points;
+ points.reserve(size(polygon));
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin_points(polygon);
+ iter != end_points(polygon); ++iter) {
+ points.push_back(*iter);
+ scale_down(points.back(), factor);
+ }
+ polygon_mutable_traits<polygon_type>::set_points(polygon, points.begin(), points.end());
+ return polygon;
+ }
+
+ template <typename Unit>
+ Unit abs(Unit value) { return value < 0 ? -value : value; }
+
+ template <typename Unit>
+ 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;
+ std::unique(pts.begin(), pts.end());
+ if(pts.back() == pts[0]) pts.pop_back();
+ //iterate over point triplets
+ int numPts = pts.size();
+ bool wrap_around = false;
+ for(int i = 0; i < numPts; ++i) {
+ Point& pt1 = pts[i];
+ Point& pt2 = pts[(i + 1) % numPts];
+ Point& pt3 = pts[(i + 2) % numPts];
+ //check if non-45 edge
+ Unit deltax = x(pt2) - x(pt1);
+ Unit deltay = y(pt2) - y(pt1);
+ if(deltax && deltay &&
+ abs(deltax) != abs(deltay)) {
+ //adjust the middle point
+ Unit ndx = x(pt3) - x(pt2);
+ Unit ndy = y(pt3) - y(pt2);
+ if(ndx && ndy) {
+ Unit diff = abs(abs(deltax) - abs(deltay));
+ Unit halfdiff = diff/2;
+ if((deltax > 0 && deltay > 0) ||
+ (deltax < 0 && deltay < 0)) {
+ //previous edge is rising slope
+ if(abs(deltax + halfdiff + (diff % 2)) ==
+ abs(deltay - halfdiff)) {
+ x(pt2, x(pt2) + halfdiff + (diff % 2));
+ y(pt2, y(pt2) - halfdiff);
+ } else if(abs(deltax - halfdiff - (diff % 2)) ==
+ abs(deltay + halfdiff)) {
+ x(pt2, x(pt2) - halfdiff - (diff % 2));
+ y(pt2, y(pt2) + halfdiff);
+ } else{
+ std::cout << "fail1\n";
+ }
+ } else {
+ //previous edge is falling slope
+ if(abs(deltax + halfdiff + (diff % 2)) ==
+ abs(deltay + halfdiff)) {
+ x(pt2, x(pt2) + halfdiff + (diff % 2));
+ y(pt2, y(pt2) + halfdiff);
+ } else if(abs(deltax - halfdiff - (diff % 2)) ==
+ abs(deltay - halfdiff)) {
+ x(pt2, x(pt2) - halfdiff - (diff % 2));
+ y(pt2, y(pt2) - halfdiff);
+ } else {
+ std::cout << "fail2\n";
+ }
+ }
+ if(i == numPts - 1 && (diff % 2)) {
+ //we have a wrap around effect
+ if(!wrap_around) {
+ wrap_around = true;
+ i = -1;
+ }
+ }
+ } else if(ndx) {
+ //next edge is horizontal
+ //find the x value for pt1 that would make the abs(deltax) == abs(deltay)
+ Unit newDeltaX = abs(deltay);
+ if(deltax < 0) newDeltaX *= -1;
+ x(pt2, x(pt1) + newDeltaX);
+ } else { //ndy
+ //next edge is vertical
+ //find the y value for pt1 that would make the abs(deltax) == abs(deltay)
+ Unit newDeltaY = abs(deltax);
+ if(deltay < 0) newDeltaY *= -1;
+ y(pt2, y(pt1) + newDeltaY);
+ }
+ }
+ }
+ }
+
+ template <typename polygon_type>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_without_holes_type<polygon_type>::type>::type, polygon_type>::type &
+ snap_to_45(polygon_type& polygon) {
+ std::vector<point_data<typename polygon_traits<polygon_type>::coordinate_type> > points;
+ points.reserve(size(polygon));
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin_points(polygon);
+ iter != end_points(polygon); ++iter) {
+ points.push_back(*iter);
+ }
+ snap_point_vector_to_45(points);
+ polygon_mutable_traits<polygon_type>::set_points(polygon, points.begin(), points.end());
+ return polygon;
}
-};
+
+ template <typename polygon_type>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_with_holes_type<polygon_type>::type>::type, polygon_type>::type &
+ snap_to_45(polygon_type& polygon) {
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ hole_type h;
+ set_points(h, begin_points(polygon), end_points(polygon));
+ snap_to_45(h);
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ for(typename polygon_with_holes_traits<polygon_type>::iterator_holes_type itr = begin_holes(polygon);
+ itr != end_holes(polygon); ++itr) {
+ holes.push_back(*itr);
+ snap_to_45(holes.back());
+ }
+ assign(polygon, h);
+ set_holes(polygon, holes.begin(), holes.end());
+ return polygon;
+ }
+
+ //scale specifically 45 down
+ template <typename polygon_type>
+ typename requires_2< typename gtl_if<typename is_any_mutable_polygon_without_holes_type<polygon_type>::type>::type,
+ typename gtl_if<typename gtl_same_type
+ < forty_five_domain,
+ typename geometry_domain<typename geometry_concept<polygon_type>::type>::type>::type>::type,
+ polygon_type>::type &
+ scale_down(polygon_type& polygon, typename coordinate_traits<typename polygon_traits<polygon_type>::coordinate_type>::unsigned_area_type factor) {
+ std::vector<point_data<typename polygon_traits<polygon_type>::coordinate_type> > points;
+ points.reserve(size(polygon));
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin_points(polygon);
+ iter != end_points(polygon); ++iter) {
+ points.push_back(*iter);
+ scale_down(points.back(), factor);
+ }
+ snap_point_vector_to_45(points);
+ polygon_mutable_traits<polygon_type>::set_points(polygon, points.begin(), points.end());
+ return polygon;
+ }
+
+ template <typename T>
+ typename requires_1< typename gtl_if<typename is_any_mutable_polygon_with_holes_type<T>::type>::type, T>::type &
+ scale_down(T& polygon, typename coordinate_traits<typename polygon_traits<T>::coordinate_type>::unsigned_area_type factor) {
+ typedef typename polygon_with_holes_traits<T>::hole_type hole_type;
+ hole_type h;
+ set_points(h, begin_points(polygon), end_points(polygon));
+ scale_down(h, factor);
+ std::vector<hole_type> holes;
+ holes.reserve(size_holes(polygon));
+ for(typename polygon_with_holes_traits<T>::iterator_holes_type itr = begin_holes(polygon);
+ itr != end_holes(polygon); ++itr) {
+ holes.push_back(*itr);
+ scale_down(holes.back(), factor);
+ }
+ assign(polygon, h);
+ set_holes(polygon, holes.begin(), holes.end());
+ return polygon;
+ }
+
+ template <typename iterator_type, typename area_type>
+ static area_type
+ point_sequence_area(iterator_type begin_range, iterator_type end_range) {
+ typedef typename std::iterator_traits<iterator_type>::value_type point_type;
+ typedef typename point_traits<point_type>::coordinate_type Unit;
+ if(begin_range == end_range) return area_type(0);
+ point_type first = *begin_range;
+ point_type previous = first;
+ ++begin_range;
+ // Initialize trapezoid base line
+ area_type y_base = (area_type)y(first);
+ // Initialize area accumulator
+
+ area_type area(0);
+ while (begin_range != end_range) {
+ area_type x1 = (area_type)x(previous);
+ area_type x2 = (area_type)x(*begin_range);
+#ifdef __ICC
+#pragma warning (disable:1572)
+#endif
+ if(x1 != x2) {
+#ifdef __ICC
+#pragma warning (default:1572)
+#endif
+ // do trapezoid area accumulation
+ area += (x2 - x1) * (((area_type)y(*begin_range) - y_base) +
+ ((area_type)y(previous) - y_base)) / 2;
+ }
+ previous = *begin_range;
+ // go to next point
+ ++begin_range;
+ }
+ //wrap around to evaluate the edge between first and last if not closed
+ if(first != previous) {
+ area_type x1 = (area_type)x(previous);
+ area_type x2 = (area_type)x(first);
+ area += (x2 - x1) * (((area_type)y(first) - y_base) +
+ ((area_type)y(previous) - y_base)) / 2;
+ }
+ return area;
+ }
+
+ template <typename T>
+ typename requires_1< typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename area_type_by_domain< typename geometry_domain<typename geometry_concept<T>::type>::type,
+ typename polygon_traits<T>::coordinate_type>::type>::type
+ area(const T& polygon) {
+ typedef typename area_type_by_domain< typename geometry_domain<typename geometry_concept<T>::type>::type,
+ typename polygon_traits<T>::coordinate_type>::type area_type;
+ area_type retval = point_sequence_area<typename polygon_traits<T>::iterator_type, area_type>
+ (begin_points(polygon), end_points(polygon));
+ if(retval < 0) retval *= -1;
+ for(typename polygon_with_holes_traits<T>::iterator_holes_type itr =
+ polygon_with_holes_traits<T>::begin_holes(polygon);
+ itr != polygon_with_holes_traits<T>::end_holes(polygon); ++itr) {
+ area_type tmp_area = point_sequence_area
+ <typename polygon_traits<typename polygon_with_holes_traits<T>::hole_type>::iterator_type, area_type>
+ (begin_points(*itr), end_points(*itr));
+ if(tmp_area < 0) tmp_area *= -1;
+ retval -= tmp_area;
+ }
+ return retval;
+ }
+
+ template <typename iT>
+ bool point_sequence_is_45(iT itr, iT itr_end) {
+ typedef typename iT::value_type Point;
+ typedef typename point_traits<Point>::coordinate_type Unit;
+ if(itr == itr_end) return true;
+ Point firstPt = *itr;
+ Point prevPt = firstPt;
+ ++itr;
+ while(itr != itr_end) {
+ Point pt = *itr;
+ Unit deltax = x(pt) - x(prevPt);
+ Unit deltay = y(pt) - y(prevPt);
+ if(deltax && deltay &&
+ abs(deltax) != abs(deltay))
+ return false;
+ prevPt = pt;
+ ++itr;
+ }
+ Unit deltax = x(firstPt) - x(prevPt);
+ Unit deltay = y(firstPt) - y(prevPt);
+ if(deltax && deltay &&
+ abs(deltax) != abs(deltay))
+ return false;
+ return true;
+ }
+
+ template <typename polygon_type>
+ typename requires_1< typename gtl_if<typename is_polygon_with_holes_type<polygon_type>::type>::type, bool>::type
+ is_45(const polygon_type& polygon) {
+ typename polygon_traits<polygon_type>::iterator_type itr = begin_points(polygon), itr_end = end_points(polygon);
+ if(!point_sequence_is_45(itr, itr_end)) return false;
+ typename polygon_with_holes_traits<polygon_type>::iterator_holes_type itrh = begin_holes(polygon), itrh_end = end_holes(polygon);
+ typedef typename polygon_with_holes_traits<polygon_type>::hole_type hole_type;
+ for(; itrh != itrh_end; ++ itrh) {
+ typename polygon_traits<hole_type>::iterator_type itr1 = begin_points(polygon), itr1_end = end_points(polygon);
+ if(!point_sequence_is_45(itr1, itr1_end)) return false;
+ }
+ return true;
+ }
+
+ template <typename distance_type, typename iterator_type>
+ distance_type point_sequence_distance(iterator_type itr, iterator_type itr_end) {
+ typedef distance_type Unit;
+ typedef iterator_type iterator;
+ typedef typename std::iterator_traits<iterator>::value_type point_type;
+ Unit return_value = Unit(0);
+ point_type previous_point, first_point;
+ if(itr == itr_end) return return_value;
+ previous_point = first_point = *itr;
+ ++itr;
+ for( ; itr != itr_end; ++itr) {
+ point_type current_point = *itr;
+ return_value += (Unit)euclidean_distance(current_point, previous_point);
+ previous_point = current_point;
+ }
+ return_value += (Unit)euclidean_distance(previous_point, first_point);
+ return return_value;
+ }
+
+ template <typename T>
+ typename requires_1< typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename distance_type_by_domain<typename geometry_domain<typename geometry_concept<T>::type>::type,
+ typename polygon_traits<T>::coordinate_type>::type>::type
+ perimeter(const T& polygon) {
+ typedef typename distance_type_by_domain
+ <typename geometry_domain<typename geometry_concept<T>::type>::type, typename polygon_traits<T>::coordinate_type>::type Unit;
+ typedef typename polygon_traits<T>::iterator_type iterator;
+ iterator itr = begin_points(polygon);
+ iterator itr_end = end_points(polygon);
+ Unit return_value = point_sequence_distance<Unit, iterator>(itr, itr_end);
+ for(typename polygon_with_holes_traits<T>::iterator_holes_type itr_holes = begin_holes(polygon);
+ itr_holes != end_holes(polygon); ++itr_holes) {
+ typedef typename polygon_traits<typename polygon_with_holes_traits<T>::hole_type>::iterator_type hitertype;
+ return_value += point_sequence_distance<Unit, hitertype>(begin_points(*itr_holes), end_points(*itr_holes));
+ }
+ return return_value;
+ }
+
+ template <typename T>
+ typename requires_1 <typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ direction_1d>::type
+ winding(const T& polygon) {
+ winding_direction wd = polygon_traits<T>::winding(polygon);
+ if(wd != unknown_winding) {
+ return wd == clockwise_winding ? CLOCKWISE: COUNTERCLOCKWISE;
+ }
+ typedef typename area_type_by_domain< typename geometry_domain<typename geometry_concept<T>::type>::type,
+ typename polygon_traits<T>::coordinate_type>::type area_type;
+ return point_sequence_area<typename polygon_traits<T>::iterator_type, area_type>(begin_points(polygon), end_points(polygon)) < 0 ?
+ COUNTERCLOCKWISE : CLOCKWISE;
+ }
+
+ template <typename T, typename input_point_type>
+ typename requires_3< typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename is_same_type_SFINAE<typename geometry_domain<typename geometry_concept<T>::type>::type, manhattan_domain>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<input_point_type>::type, point_concept>::type,
+ bool>::type
+ contains(const T& polygon, const input_point_type& point, bool consider_touch = true) {
+ typedef T polygon_type;
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::iterator_type iterator;
+ typedef typename std::iterator_traits<iterator>::value_type point_type;
+ iterator iter, iter_end;
+ iter_end = end_points(polygon);
+ iter = begin_points(polygon);
+ point_type prev_pt = *iter;
+ unsigned int num = size(polygon);
+ unsigned int counts[2] = {0, 0};
+ for(unsigned int i = 0; i < num; ++i) {
+ if(i == num-1) iter = begin_points(polygon);
+ else ++iter;
+ point_type current_pt = *iter;
+ if(x(current_pt) ==
+ x(prev_pt)) {
+ unsigned int index = x(current_pt) >
+ x(point);
+ unsigned int increment = 0;
+ interval_data<coordinate_type> ivl(y(current_pt),
+ y(prev_pt));
+ if(contains(ivl, y(point), true)) {
+ if(x(current_pt) ==
+ x(point)) return consider_touch;
+ ++increment;
+ if(y(current_pt) !=
+ y(point) &&
+ y(prev_pt) !=
+ y(point)) {
+ ++increment;
+ }
+ counts[index] += increment;
+ }
+ }
+ prev_pt = current_pt;
+ }
+ //odd count implies boundary condition
+ if(counts[0] % 2 || counts[1] % 2) return consider_touch;
+ //an odd number of edges to the left implies interior pt
+ return counts[0] % 4;
+ }
+
+ template <typename T, typename input_point_type>
+ typename requires_3< typename gtl_if<typename is_polygon_with_holes_type<T>::type>::type,
+ typename is_different_type_SFINAE<typename geometry_domain<typename geometry_concept<T>::type>::type, manhattan_domain>::type,
+ typename is_same_type_SFINAE<typename geometry_concept<input_point_type>::type, point_concept>::type, bool>::type
+ contains(const T& polygon, const input_point_type& point, bool consider_touch = true) {
+ std::cout << "not implemented\n"; //awaiting arrival of general edge concept
+ return false;
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename is_mutable_point_concept<typename geometry_concept<T1>::type>::type,
+ typename gtl_if<typename is_polygon_with_holes_type<T2>::type>::type,
+ bool>::type
+ center(T1& center_point, const T2& polygon) {
+ typedef typename polygon_traits<T2>::coordinate_type coordinate_type;
+ rectangle_data<coordinate_type> bbox;
+ extents(bbox, polygon);
+ return center(center_point, bbox);
+ }
+
+ template <typename T1, typename T2>
+ typename requires_2< typename is_mutable_rectangle_concept<typename geometry_concept<T1>::type>::type,
+ typename gtl_if<typename is_polygon_with_holes_type<T2>::type>::type,
+ bool>::type
+ extents(T1& bounding_box, const T2& polygon) {
+ typedef typename polygon_traits<T2>::iterator_type iterator;
+ bool first_iteration = true;
+ iterator itr_end = end_points(polygon);
+ for(iterator itr = begin_points(polygon); itr != itr_end; ++itr) {
+ if(first_iteration) {
+ set_points(bounding_box, *itr, *itr);
+ first_iteration = false;
+ } else {
+ encompass(bounding_box, *itr);
+ }
+ }
+ if(first_iteration) return false;
+ return true;
+ }
+
+ template <class T>
+ template <class T2>
+ polygon_90_data<T>& polygon_90_data<T>::operator=(const T2& rvalue) {
+ assign(*this, rvalue);
+ return *this;
+ }
+
+ template <typename T>
+ struct geometry_concept<polygon_data<T> > {
+ typedef polygon_concept type;
+ };
+ template <typename T>
+ struct geometry_concept<polygon_45_data<T> > {
+ typedef polygon_45_concept type;
+ };
+ template <typename T>
+ struct geometry_concept<polygon_90_data<T> > {
+ typedef polygon_90_concept type;
+ };
+ template <typename T>
+ struct geometry_concept<polygon_with_holes_data<T> > {
+ typedef polygon_with_holes_concept type;
+ };
+ template <typename T>
+ struct geometry_concept<polygon_45_with_holes_data<T> > {
+ typedef polygon_45_with_holes_concept type;
+ };
+ template <typename T>
+ struct geometry_concept<polygon_90_with_holes_data<T> > {
+ typedef polygon_90_with_holes_concept type;
+ };
+
+ template <typename T> struct polygon_with_holes_traits<polygon_90_data<T> > {
+ typedef polygon_90_data<T> hole_type;
+ typedef const hole_type* iterator_holes_type;
+ static inline iterator_holes_type begin_holes(const hole_type& t) { return &t; }
+ static inline iterator_holes_type end_holes(const hole_type& t) { return &t; }
+ static inline unsigned int size_holes(const hole_type& t) { return 0; }
+ };
+ template <typename T> struct polygon_with_holes_traits<polygon_45_data<T> > {
+ typedef polygon_45_data<T> hole_type;
+ typedef const hole_type* iterator_holes_type;
+ static inline iterator_holes_type begin_holes(const hole_type& t) { return &t; }
+ static inline iterator_holes_type end_holes(const hole_type& t) { return &t; }
+ static inline unsigned int size_holes(const hole_type& t) { return 0; }
+ };
+ template <typename T> struct polygon_with_holes_traits<polygon_data<T> > {
+ typedef polygon_data<T> hole_type;
+ typedef const hole_type* iterator_holes_type;
+ static inline iterator_holes_type begin_holes(const hole_type& t) { return &t; }
+ static inline iterator_holes_type end_holes(const hole_type& t) { return &t; }
+ static inline unsigned int size_holes(const hole_type& t) { return 0; }
+ };
}
+
#endif
Modified: sandbox/gtl/gtl/polygon_with_holes_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_with_holes_concept.hpp (original)
+++ sandbox/gtl/gtl/polygon_with_holes_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -10,16 +10,160 @@
#define GTL_POLYGON_WITH_HOLES_CONCEPT_HPP
namespace gtl {
-struct polygon_with_holes_concept : virtual polygon_concept, polygon_45_with_holes_concept {
+struct polygon_with_holes_concept : public polygon_concept {
public:
- inline polygon_with_holes_concept() {}
- //inherits its behaviors
+ //inline polygon_with_holes_concept() {}
+
+ template <typename T>
+ struct coordinate_type {
+ typedef typename polygon_traits<T>::coordinate_type type;
+ };
+
+ template <typename T>
+ struct area_type {
+ typedef typename polygon_traits<T>::area_type type;
+ };
+
+ template <typename T>
+ struct coordinate_difference {
+ typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_difference type;
+ };
+
+ template <typename T>
+ struct coordinate_distance {
+ typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_distance type;
+ };
+
+ template <typename T>
+ struct point_type {
+ typedef typename polygon_traits<T>::iterator_type iterator;
+ typedef typename std::iterator_traits<iterator>::value_type type;
+ };
+
+ template<typename polygon_with_holes_type, typename hole_iterator_type>
+ static void set_holes(polygon_with_holes_type& polygon, hole_iterator_type holes_begin, hole_iterator_type holes_end) {
+ polygon_with_holes_traits<polygon_with_holes_type>::set_holes(polygon, holes_begin, holes_end);
+ }
+
+ template <typename polygon_with_holes_type>
+ static typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type
+ begin_holes(const polygon_with_holes_type& polygon) {
+ return polygon_with_holes_traits<polygon_with_holes_type>::begin_holes(polygon);
+ }
+
+ template <typename polygon_with_holes_type>
+ static typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type
+ end_holes(const polygon_with_holes_type& polygon) {
+ return polygon_with_holes_traits<polygon_with_holes_type>::end_holes(polygon);
+ }
+
+ template <typename polygon_with_holes_type_1, typename polygon_with_holes_type_2>
+ static polygon_with_holes_type_1 copy_construct(const polygon_with_holes_type_2& polygon) {
+ polygon_with_holes_type_1 retval;
+ set(retval, polygon_concept::begin(polygon), polygon_concept::end(polygon));
+ set_holes(retval, begin_holes(polygon), end_holes(polygon));
+ return retval;
+ }
+
+ template <typename polygon_with_holes_type>
+ static std::size_t size_holes(const polygon_with_holes_type& polygon) {
+ return polygon_with_holes_traits<polygon_with_holes_type>::size_holes(polygon);
+ }
//needed to disambiguate between multiple base class implementations of same function
template <typename polygon_with_holes_type_1, typename polygon_with_holes_type_2>
static polygon_with_holes_type_1& assign(polygon_with_holes_type_1& lvalue, const polygon_with_holes_type_2& rvalue) {
return polygon_45_with_holes_concept::assign(lvalue, rvalue);
}
+
+ //scaling down differs from the implementation in 45 polygons by not snapping the result to 45
+ template <typename polygon_type>
+ static polygon_type& scale_down(polygon_type& polygon,
+ typename coordinate_traits<typename coordinate_type<polygon_type>::type>::unsigned_area_type factor) {
+ polygon_90_with_holes_concept::scale_down(polygon, factor);
+ return polygon;
+ }
+
+ template <typename polygon_with_holes_type>
+ static typename area_type<polygon_with_holes_type>::type
+ area(const polygon_with_holes_type& polygon) {
+ return polygon_45_with_holes_concept::area(polygon);
+ }
+
+ /// check if point is inside polygon
+ template <typename polygon_with_holes_type, typename point_type>
+ static bool contains(const polygon_with_holes_type& polygon, const point_type& point,
+ bool consider_touch, point_concept pc) {
+ return polygon_45_with_holes_concept::contains(polygon, point, consider_touch, pc);
+ }
+
+ /// get the perimeter of the polygon
+ template <typename polygon_with_holes_type>
+ static typename coordinate_distance<polygon_with_holes_type>::type
+ perimeter(const polygon_with_holes_type& polygon) {
+ return polygon_45_with_holes_concept::perimeter(polygon);
+ }
+
+ template <typename polygon_with_holes_type, typename coordinate_type_1, typename coordinate_type_2>
+ static polygon_with_holes_type& move(polygon_with_holes_type& polygon,
+ coordinate_type_1 x_displacement, coordinate_type_2 y_displacement) {
+ return polygon_45_with_holes_concept::move(polygon, x_displacement, y_displacement);
+ }
+
+ /// move polygon by delta in orient
+ template <typename polygon_with_holes_type, typename coordinate_type_1>
+ static polygon_with_holes_type& move(polygon_with_holes_type& polygon,
+ orientation_2d orient, coordinate_type_1 displacement) {
+ return polygon_45_with_holes_concept::move(polygon, orient, displacement);
+ }
+
+ template <typename polygon_type>
+ static direction_1d winding(const polygon_type& polygon) {
+ return polygon_45_concept::winding(polygon);
+ }
+
+ template <typename point_type, typename polygon_type>
+ static bool
+ center(point_type& center_point, const polygon_type& polygon) {
+ return polygon_45_concept::center(center_point, polygon);
+ }
+
+ template <typename polygon_type, typename rectangle_type>
+ static bool
+ extents(rectangle_type& bounding_box, const polygon_type& polygon) {
+ return polygon_45_concept::extents(bounding_box, polygon);
+ }
+
+ template <typename polygon_type>
+ static polygon_type& scale_up(polygon_type& polygon,
+ typename coordinate_traits<typename coordinate_type<polygon_type>::type>::unsigned_area_type factor) {
+ return polygon_90_with_holes_concept::scale_up(polygon, factor);
+ }
+
+ template <typename polygon_type, typename scaling_type>
+ static polygon_type& scale(polygon_type& polygon,
+ const scaling_type& scaling) {
+ return polygon_90_with_holes_concept::scale(polygon, scaling);
+ }
+
+ template <typename polygon_type, typename transformation_type>
+ static polygon_type& transform(polygon_type& polygon,
+ const transformation_type& transformation) {
+ return polygon_90_with_holes_concept::transform(polygon, transformation);
+ }
+
+ template <typename polygon_type>
+ static polygon_type&
+ snap_to_45(polygon_type& polygon) {
+ return polygon_45_with_holes_concept::snap_to_45(polygon);
+ }
+
+ template <typename polygon_type>
+ static bool
+ is_45(const polygon_type& polygon) {
+ return polygon_45_with_holes_concept::is_45(polygon);
+ }
+
};
}
Modified: sandbox/gtl/gtl/polygon_with_holes_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_with_holes_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_with_holes_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -8,13 +8,44 @@
#ifndef GTL_POLYGON_WITH_HOLES_DATA_HPP
#define GTL_POLYGON_WITH_HOLES_DATA_HPP
namespace gtl {
-struct polygon_with_holes_concept;
-template <typename T>
-class polygon_with_holes_data : public polygon_45_with_holes_data<T> {
-public:
- typedef polygon_with_holes_concept geometry_type;
- //inherits everything
-};
+ struct polygon_with_holes_concept;
+ template <typename T>
+ class polygon_with_holes_data : public polygon_45_with_holes_data<T> {
+ public:
+ typedef polygon_with_holes_concept geometry_type;
+ //inherits everything
+ };
+
+ template <typename T>
+ std::ostream& operator<<(std::ostream& o, const polygon_90_with_holes_data<T>& poly) {
+ o << "Polygon With Holes { ";
+ for(typename polygon_90_with_holes_data<T>::iterator_type itr = poly.begin();
+ itr != poly.end(); ++itr) {
+ if(itr != poly.begin()) o << ", ";
+ o << (*itr).get(HORIZONTAL) << " " << (*itr).get(VERTICAL);
+ } o << " { ";
+ for(typename polygon_90_with_holes_data<T>::iterator_holes_type itr = poly.begin_holes();
+ itr != poly.end_holes(); ++itr) {
+ o << (*itr);
+ }
+ o << " } } ";
+ return o;
+ }
+ template <typename T>
+ std::ostream& operator<<(std::ostream& o, const polygon_45_with_holes_data<T>& poly) {
+ o << "Polygon With Holes { ";
+ for(typename polygon_45_with_holes_data<T>::iterator_type itr = poly.begin();
+ itr != poly.end(); ++itr) {
+ if(itr != poly.begin()) o << ", ";
+ o << (*itr).get(HORIZONTAL) << " " << (*itr).get(VERTICAL);
+ } o << " { ";
+ for(typename polygon_45_with_holes_data<T>::iterator_holes_type itr = poly.begin_holes();
+ itr != poly.end_holes(); ++itr) {
+ o << (*itr);
+ }
+ o << " } } ";
+ return o;
+ }
}
#endif
Modified: sandbox/gtl/gtl/rectangle_concept.hpp
==============================================================================
--- sandbox/gtl/gtl/rectangle_concept.hpp (original)
+++ sandbox/gtl/gtl/rectangle_concept.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -7,358 +7,408 @@
*/
#ifndef GTL_RECTANGLE_CONCEPT_HPP
#define GTL_RECTANGLE_CONCEPT_HPP
-namespace gtl {
-struct rectangle_concept {
- rectangle_concept() {}
+#include "isotropy.hpp"
- template <typename T>
- struct coordinate_type {
- typedef typename rectangle_traits<T>::coordinate_type type;
- };
-
- template <typename T>
- struct component_type {
- typedef typename rectangle_traits<T>::interval_type type;
- };
+//point
+#include "point_data.hpp"
+#include "point_traits.hpp"
+#include "point_concept.hpp"
+
+//interval
+#include "interval_data.hpp"
+#include "interval_traits.hpp"
+#include "interval_concept.hpp"
- template <typename T>
- struct center_type {
- //should we make point_type a trait?
- typedef point_data<typename coordinate_type<T>::type > type;
- };
-
- template <typename T>
- struct area_type {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::area_type type;
- };
+#include "rectangle_data.hpp"
+#include "rectangle_traits.hpp"
+namespace gtl {
+ struct rectangle_concept {};
+
template <typename T>
- struct coordinate_difference {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_difference type;
- };
+ struct is_rectangle_concept {};
+ template <>
+ struct is_rectangle_concept<rectangle_concept> { typedef void type; };
template <typename T>
- struct coordinate_distance {
- typedef typename coordinate_traits<typename coordinate_type<T>::type>::coordinate_distance type;
- };
+ struct is_mutable_rectangle_concept {};
+ template <>
+ struct is_mutable_rectangle_concept<rectangle_concept> { typedef void type; };
+
+ template <>
+ struct geometry_domain<rectangle_concept> { typedef manhattan_domain type; };
+
+ template <typename T, orientation_2d_enum orient>
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename rectangle_traits<T>::interval_type>::type
+ get(const T& rectangle) {
+ return rectangle_traits<T>::get(rectangle, orient);
+ }
template <typename T>
- static inline typename rectangle_traits<T>::interval_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename rectangle_traits<T>::interval_type>::type
get(const T& rectangle, orientation_2d orient) {
return rectangle_traits<T>::get(rectangle, orient);
}
template <typename T>
- static inline typename rectangle_traits<T>::interval_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename rectangle_traits<T>::interval_type>::type
horizontal(const T& rectangle) {
return rectangle_traits<T>::get(rectangle, HORIZONTAL);
}
template <typename T>
- static inline typename rectangle_traits<T>::interval_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename rectangle_traits<T>::interval_type>::type
vertical(const T& rectangle) {
return rectangle_traits<T>::get(rectangle, VERTICAL);
}
template <orientation_2d_enum orient, typename T, typename T2>
- static inline void set(T& rectangle, const T2& interval) {
- rectangle_traits<T>::set(rectangle, orient, interval);
+ typename requires_2<typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ void>::type
+ set(T& rectangle, const T2& interval) {
+ rectangle_mutable_traits<T>::set(rectangle, orient, interval);
}
template <typename T, typename T2>
- static inline void set(T& rectangle, orientation_2d orient, const T2& interval) {
- rectangle_traits<T>::set(rectangle, orient, interval);
+ typename requires_2<typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ void>::type
+ set(T& rectangle, orientation_2d orient, const T2& interval) {
+ rectangle_mutable_traits<T>::set(rectangle, orient, interval);
}
template <typename T, typename T2>
- static inline void horizontal(T& rectangle, const T2& interval) {
- rectangle_traits<T>::set(rectangle, HORIZONTAL, interval);
+ typename requires_2<typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ void>::type
+ horizontal(T& rectangle, const T2& interval) {
+ rectangle_mutable_traits<T>::set(rectangle, HORIZONTAL, interval);
}
template <typename T, typename T2>
- static inline void vertical(T& rectangle, const T2& interval) {
- rectangle_traits<T>::set(rectangle, VERTICAL, interval);
+ typename requires_2<typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename is_interval_concept<typename geometry_concept<T2>::type>::type,
+ void>::type
+ vertical(T& rectangle, const T2& interval) {
+ rectangle_mutable_traits<T>::set(rectangle, VERTICAL, interval);
}
template <typename T, typename T2, typename T3>
- static inline T construct(const T2& interval_horizontal,
- const T3& interval_vertical) {
- return rectangle_traits<T>::construct(interval_horizontal, interval_vertical); }
+ typename requires_1<
+ typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ T>::type
+ construct(const T2& interval_horizontal,
+ const T3& interval_vertical) {
+ return rectangle_mutable_traits<T>::construct(interval_horizontal, interval_vertical); }
template <typename T, typename coord_type>
- static inline T construct(coord_type xl, coord_type yl, coord_type xh, coord_type yh) {
- return rectangle_traits<T>::construct(interval_data<coord_type>(xl, xh),
+ typename requires_1<
+ typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ T>::type
+ construct(coord_type xl, coord_type yl, coord_type xh, coord_type yh) {
+ return rectangle_mutable_traits<T>::construct(interval_data<coord_type>(xl, xh),
interval_data<coord_type>(yl, yh));
}
template <typename T, typename T2>
- static T copy_construct(const T2& rectangle) {
- return construct<T>
- (get(rectangle, HORIZONTAL),
- get(rectangle, VERTICAL));
+ typename requires_2<
+ typename is_mutable_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<T2>::type>::type,
+ T>::type
+ copy_construct(const T2& rectangle) {
+ return construct<T> (get(rectangle, HORIZONTAL), get(rectangle, VERTICAL));
}
template <typename rectangle_type_1, typename rectangle_type_2>
- static rectangle_type_1& assign(rectangle_type_1& lvalue, const rectangle_type_2& rvalue) {
+ typename requires_2<
+ 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,
+ rectangle_type_1>::type &
+ assign(rectangle_type_1& lvalue, const rectangle_type_2& rvalue) {
set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
set(lvalue, VERTICAL, get(rvalue, VERTICAL));
return lvalue;
}
template <typename T, typename T2>
- static bool equivalence(const T& rect1, const T2& rect2) {
- return interval_concept::equivalence(get(rect1, HORIZONTAL),
- get(rect2, HORIZONTAL)) &&
- interval_concept::equivalence(get(rect1, VERTICAL),
- get(rect2, VERTICAL));
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<T>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<T2>::type>::type,
+ bool>::type
+ equivalence(const T& rect1, const T2& rect2) {
+ return equivalence(get(rect1, HORIZONTAL), get(rect2, HORIZONTAL)) &&
+ equivalence(get(rect1, VERTICAL), get(rect2, VERTICAL));
}
template <typename rectangle_type>
- static inline typename rectangle_traits<rectangle_type>::coordinate_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename rectangle_traits<rectangle_type>::coordinate_type>::type
get(const rectangle_type& rectangle, orientation_2d orient, direction_1d dir) {
- return interval_concept::get(rectangle_traits<rectangle_type>::get(rectangle, orient), dir);
+ return get(rectangle_traits<rectangle_type>::get(rectangle, orient), dir);
}
template <typename rectangle_type>
- static inline void set(rectangle_type& rectangle, orientation_2d orient, direction_1d dir,
- typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_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);
- interval_concept::set(ivl, dir, value);
+ set(ivl, dir, value);
set(rectangle, orient, ivl);
}
template <typename rectangle_type>
- static typename rectangle_traits<rectangle_type>::coordinate_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename rectangle_traits<rectangle_type>::coordinate_type>::type
xl(const rectangle_type& rectangle) {
return get(rectangle, HORIZONTAL, LOW);
}
template <typename rectangle_type>
- static void xl(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type, void>::type
+ xl(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
return set(rectangle, HORIZONTAL, LOW, value);
}
template <typename rectangle_type>
- static typename rectangle_traits<rectangle_type>::coordinate_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename rectangle_traits<rectangle_type>::coordinate_type>::type
xh(const rectangle_type& rectangle) {
return get(rectangle, HORIZONTAL, HIGH);
}
template <typename rectangle_type>
- static void xh(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type, void>::type
+ xh(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
return set(rectangle, HORIZONTAL, HIGH, value);
}
template <typename rectangle_type>
- static typename rectangle_traits<rectangle_type>::coordinate_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename rectangle_traits<rectangle_type>::coordinate_type>::type
yl(const rectangle_type& rectangle) {
return get(rectangle, VERTICAL, LOW);
}
template <typename rectangle_type>
- static void yl(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type, void>::type
+ yl(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
return set(rectangle, VERTICAL, LOW, value);
}
template <typename rectangle_type>
- static typename rectangle_traits<rectangle_type>::coordinate_type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename rectangle_traits<rectangle_type>::coordinate_type>::type
yh(const rectangle_type& rectangle) {
return get(rectangle, VERTICAL, HIGH);
}
template <typename rectangle_type>
- static void yh(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type, void>::type
+ yh(rectangle_type& rectangle, typename rectangle_traits<rectangle_type>::coordinate_type value) {
return set(rectangle, VERTICAL, HIGH, value);
}
- template <typename rectangle_type, typename rectangle_type2>
- static bool contains(const rectangle_type& rectangle, const rectangle_type2 rectangle_contained,
- bool consider_touch, rectangle_concept tag) {
- return interval_concept::contains(horizontal(rectangle), horizontal(rectangle_contained), consider_touch, interval_concept()) &&
- interval_concept::contains(vertical(rectangle), vertical(rectangle_contained), consider_touch, interval_concept());
+ template <typename rectangle_type>
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ ll(const rectangle_type& rectangle) {
+ return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xl(rectangle), yl(rectangle));
+ }
+
+ template <typename rectangle_type>
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ lr(const rectangle_type& rectangle) {
+ return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xh(rectangle), yl(rectangle));
+ }
+
+ template <typename rectangle_type>
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ ul(const rectangle_type& rectangle) {
+ return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xl(rectangle), yh(rectangle));
+ }
+
+ template <typename rectangle_type>
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ point_data<typename rectangle_traits<rectangle_type>::coordinate_type> >::type
+ ur(const rectangle_type& rectangle) {
+ return point_data<typename rectangle_traits<rectangle_type>::coordinate_type> (xh(rectangle), yh(rectangle));
+ }
+
+ template <typename rectangle_type, typename rectangle_type_2>
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ contains(const rectangle_type& rectangle, const rectangle_type_2 rectangle_contained,
+ bool consider_touch = true) {
+ return contains(horizontal(rectangle), horizontal(rectangle_contained), consider_touch) &&
+ contains(vertical(rectangle), vertical(rectangle_contained), consider_touch);
}
template <typename rectangle_type, typename point_type>
- static bool contains(const rectangle_type& rectangle, const point_type point_contained,
- bool consider_touch, point_concept tag) {
- return interval_concept::contains(horizontal(rectangle), point_concept::x(point_contained),
- consider_touch, coordinate_concept()) &&
- interval_concept::contains(vertical(rectangle), point_concept::y(point_contained),
- consider_touch, coordinate_concept());
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ bool>::type
+ contains(const rectangle_type& rectangle, const point_type point_contained,
+ bool consider_touch = true) {
+ return contains(horizontal(rectangle), x(point_contained), consider_touch) &&
+ contains(vertical(rectangle), y(point_contained), consider_touch);
}
/// set all four coordinates based upon two points
template <typename rectangle_type, typename point_type_1, typename point_type_2>
- static rectangle_type& set_points(rectangle_type& rectangle, const point_type_1& p1,
- const point_type_2& p2) {
+ typename requires_3< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type_2>::type>::type,
+ 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;
- Unit x1(point_concept::x(p1));
- Unit x2(point_concept::x(p2));
- Unit y1(point_concept::y(p1));
- Unit y2(point_concept::y(p2));
- horizontal(rectangle, interval_concept::construct<typename rectangle_traits<rectangle_type>::interval_type>(x1, x2));
- vertical(rectangle, interval_concept::construct<typename rectangle_traits<rectangle_type>::interval_type>(y1, y2));
+ 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));
return rectangle;
}
-
+
/// move rectangle by delta in orient
template <typename rectangle_type>
- static rectangle_type& move(rectangle_type& rectangle, orientation_2d orient,
- typename coordinate_difference<rectangle_type>::type delta) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_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 rectangle_traits<rectangle_type>::interval_type ivl = get(rectangle, orient);
- interval_concept::move(ivl, delta);
+ move(ivl, delta);
set(rectangle, orient, ivl);
return rectangle;
}
- //awaiting transform re-implementation
- // /// transform rectangle
- // RectangleImpl& transform(const AxisTransform& atr);
-
- // /// transform rectangle
- // RectangleImpl& transform(const Transform& tr);
-
/// convolve this with b
template <typename rectangle_type_1, typename rectangle_type_2>
- static rectangle_type_1& convolve(rectangle_type_1& rectangle,
- const rectangle_type_2& convolution_rectangle,
- rectangle_concept tag) {
+ typename requires_2< 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,
+ 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);
- horizontal(rectangle,
- interval_concept::convolve(ivl,
- horizontal(convolution_rectangle),
- interval_concept()));
+ horizontal(rectangle, convolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
- vertical(rectangle,
- interval_concept::convolve(ivl,
- vertical(convolution_rectangle),
- interval_concept()));
+ vertical(rectangle, convolve(ivl, vertical(convolution_rectangle)));
return rectangle;
}
/// deconvolve this with b
template <typename rectangle_type_1, typename rectangle_type_2>
- static rectangle_type_1& deconvolve(rectangle_type_1& rectangle,
- const rectangle_type_2& convolution_rectangle,
- rectangle_concept tag) {
+ typename requires_2< 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,
+ 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);
- horizontal(rectangle,
- interval_concept::deconvolve(ivl,
- horizontal(convolution_rectangle),
- interval_concept()));
+ horizontal(rectangle, deconvolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
- vertical(rectangle,
- interval_concept::deconvolve(ivl,
- vertical(convolution_rectangle),
- interval_concept()));
+ vertical(rectangle, deconvolve(ivl, vertical(convolution_rectangle)));
return rectangle;
}
-
+
/// reflectedConvolve this with b
template <typename rectangle_type_1, typename rectangle_type_2>
- static rectangle_type_1& reflected_convolve(rectangle_type_1& rectangle,
- const rectangle_type_2& convolution_rectangle,
- rectangle_concept tag) {
+ typename requires_2< 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,
+ 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);
- horizontal(rectangle,
- interval_concept::reflected_convolve(ivl,
- horizontal(convolution_rectangle),
- interval_concept()));
+ horizontal(rectangle, reflected_convolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
- vertical(rectangle,
- interval_concept::reflected_convolve(ivl,
- vertical(convolution_rectangle),
- interval_concept()));
+ vertical(rectangle, reflected_convolve(ivl, vertical(convolution_rectangle)));
return rectangle;
}
-
+
/// reflectedDeconvolve this with b
/// deconvolve this with b
template <typename rectangle_type_1, typename rectangle_type_2>
- static rectangle_type_1& reflected_deconvolve(rectangle_type_1& rectangle,
- const rectangle_type_2& convolution_rectangle,
- rectangle_concept tag) {
+ typename requires_2< 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,
+ 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);
- horizontal(rectangle,
- interval_concept::reflected_deconvolve(ivl,
- horizontal(convolution_rectangle),
- interval_concept()));
+ horizontal(rectangle, reflected_deconvolve(ivl, horizontal(convolution_rectangle)));
ivl = vertical(rectangle);
- vertical(rectangle,
- interval_concept::reflected_deconvolve(ivl,
- vertical(convolution_rectangle),
- interval_concept()));
+ vertical(rectangle, reflected_deconvolve(ivl, vertical(convolution_rectangle)));
return rectangle;
}
/// convolve with point
template <typename rectangle_type, typename point_type>
- static rectangle_type& convolve(rectangle_type& rectangle,
- const point_type& convolution_point,
- point_concept tag) {
+ typename requires_2< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_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);
- horizontal(rectangle,
- interval_concept::convolve(ivl,
- point_concept::x(convolution_point),
- coordinate_concept()));
+ horizontal(rectangle, convolve(ivl, x(convolution_point)));
ivl = vertical(rectangle);
- vertical(rectangle,
- interval_concept::convolve(ivl,
- point_concept::y(convolution_point),
- coordinate_concept()));
+ vertical(rectangle, convolve(ivl, y(convolution_point)));
return rectangle;
}
/// deconvolve with point
template <typename rectangle_type, typename point_type>
- static rectangle_type& deconvolve(rectangle_type& rectangle,
- const point_type& convolution_point,
- point_concept tag) {
+ typename requires_2< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_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);
- horizontal(rectangle,
- interval_concept::deconvolve(ivl,
- point_concept::x(convolution_point),
- coordinate_concept()));
+ horizontal(rectangle, deconvolve(ivl, x(convolution_point)));
ivl = vertical(rectangle);
- vertical(rectangle,
- interval_concept::deconvolve(ivl,
- point_concept::y(convolution_point),
- coordinate_concept()));
+ vertical(rectangle, deconvolve(ivl, y(convolution_point)));
return rectangle;
}
/// get the magnitude of the interval range depending on orient
template <typename rectangle_type>
- static typename rectangle_traits<rectangle_type>::coordinate_type
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference
delta(const rectangle_type& rectangle, orientation_2d orient) {
- return interval_concept::delta(get(rectangle, orient));
+ return delta(get(rectangle, orient));
}
/// get the area of the rectangle
template <typename rectangle_type>
- static typename area_type<rectangle_type>::type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::manhattan_area_type>::type
area(const rectangle_type& rectangle) {
- typedef typename area_type<rectangle_type>::type area_type;
+ typedef typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::manhattan_area_type area_type;
return (area_type)delta(rectangle, HORIZONTAL) * (area_type)delta(rectangle, VERTICAL);
}
/// returns the orientation of the longest side
template <typename rectangle_type>
- static orientation_2d guess_orientation(const rectangle_type& rectangle) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ orientation_2d>::type
+ guess_orientation(const rectangle_type& rectangle) {
return delta(rectangle, HORIZONTAL) >= delta(rectangle, VERTICAL) ?
HORIZONTAL : VERTICAL;
}
/// get the half perimeter of the rectangle
template <typename rectangle_type>
- static typename coordinate_difference<rectangle_type>::type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::type
half_perimeter(const rectangle_type& rectangle) {
return delta(rectangle, HORIZONTAL) + delta(rectangle, VERTICAL);
}
/// get the perimeter of the rectangle
template <typename rectangle_type>
- static typename coordinate_difference<rectangle_type>::type
+ typename requires_1< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::type
perimeter(const rectangle_type& rectangle) {
return 2 * half_perimeter(rectangle);
}
@@ -368,12 +418,13 @@
// [in] considerTouch If true, return true even if b touches the boundary
// [ret] . true if `t` intersects b
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool intersects(const rectangle_type_1& rectangle, const rectangle_type_2& b,
- bool consider_touch, rectangle_concept tag) {
- return interval_concept::intersects(horizontal(rectangle), horizontal(b), consider_touch,
- interval_concept()) &&
- interval_concept::intersects(vertical(rectangle), vertical(b), consider_touch,
- interval_concept());
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ intersects(const rectangle_type_1& rectangle, const rectangle_type_2& b, bool consider_touch = true) {
+ return intersects(horizontal(rectangle), horizontal(b), consider_touch) &&
+ intersects(vertical(rectangle), vertical(b), consider_touch);
}
/// Check if boundaries of Rectangle b and `this` Rectangle intersect
@@ -381,8 +432,12 @@
// [in] considerTouch If true, return true even if p is on the foundary
// [ret] . true if `t` contains p
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool boundaries_intersect(const rectangle_type_1& rectangle, const rectangle_type_2& b,
- bool consider_touch, rectangle_concept tag) {
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ boundaries_intersect(const rectangle_type_1& rectangle, const rectangle_type_2& b,
+ bool consider_touch = true) {
return (intersects(rectangle, b, consider_touch) &&
!(contains(rectangle, b, !consider_touch)) &&
!(contains(b, rectangle, !consider_touch)));
@@ -390,41 +445,53 @@
/// check if b is touching 'this' on the end specified by dir
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool abuts(const rectangle_type_1& rectangle, const rectangle_type_2& b,
- direction_2d dir, rectangle_concept tag) {
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ abuts(const rectangle_type_1& rectangle, const rectangle_type_2& b,
+ direction_2d dir) {
return
- interval_concept::abuts(get(rectangle, orientation_2d(dir)),
- get(b, orientation_2d(dir)),
- direction_1d(dir), interval_concept()) &&
- interval_concept::intersects(get(rectangle, orientation_2d(dir).get_perpendicular()),
- get(b, orientation_2d(dir).get_perpendicular()),
- true, interval_concept());
+ abuts(get(rectangle, orientation_2d(dir)),
+ get(b, orientation_2d(dir)),
+ direction_1d(dir)) &&
+ intersects(get(rectangle, orientation_2d(dir).get_perpendicular()),
+ get(b, orientation_2d(dir).get_perpendicular()), true);
}
/// check if they are touching in the given orientation
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool abuts(const rectangle_type_1& rectangle, const rectangle_type_2& b,
- orientation_2d orient, rectangle_concept tag) {
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ abuts(const rectangle_type_1& rectangle, const rectangle_type_2& b,
+ orientation_2d orient) {
return
- interval_concept::abuts(get(rectangle, orient), get(b, orient), interval_concept()) &&
- interval_concept::intersects(get(rectangle, orient.get_perpendicular()),
- get(b, orient.get_perpendicular()),
- true, interval_concept());
+ abuts(get(rectangle, orient), get(b, orient)) &&
+ intersects(get(rectangle, orient.get_perpendicular()),
+ get(b, orient.get_perpendicular()), true);
}
/// check if they are touching but not overlapping
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool abuts(const rectangle_type_1& rectangle, const rectangle_type_2& b,
- rectangle_concept tag) {
+ typename requires_2<
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ abuts(const rectangle_type_1& rectangle, const rectangle_type_2& b) {
return abuts(rectangle, b, HORIZONTAL) || abuts(rectangle, b, VERTICAL);
}
/// intersect rectangle with interval on orient
template <typename rectangle_type, typename interval_type>
- static bool intersect(const rectangle_type& rectangle, const interval_type& b,
- orientation_2d orient, bool consider_touch, interval_concept tag) {
+ typename requires_2< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+ 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);
- if(interval_concept::intersect(ivl, b, consider_touch, tag)) {
+ if(intersect(ivl, b, consider_touch)) {
set(rectangle, orient, ivl);
return true;
}
@@ -433,11 +500,13 @@
/// clip rectangle to b
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool intersect(const rectangle_type_1& rectangle, const rectangle_type_2& b,
- bool consider_touch, rectangle_concept tag) {
+ typename requires_2< 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,
+ bool>::type
+ intersect(rectangle_type_1& rectangle, const rectangle_type_2& b, bool consider_touch = true) {
if(intersects(rectangle, b)) {
- intersect(rectangle, horizontal(b), HORIZONTAL, consider_touch, interval_concept());
- intersect(rectangle, vertical(b), VERTICAL, consider_touch, interval_concept());
+ intersect(rectangle, horizontal(b), HORIZONTAL, consider_touch);
+ intersect(rectangle, vertical(b), VERTICAL, consider_touch);
return true;
}
return false;
@@ -445,72 +514,89 @@
/// Sets this to the generalized intersection of this and the given rectangle
template <typename rectangle_type_1, typename rectangle_type_2>
- static rectangle_type_1& generalized_intersect(rectangle_type_1& rectangle,
- const rectangle_type_2& b, rectangle_concept tag) {
+ typename requires_2< 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,
+ 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);
- interval_concept::generalized_intersect(ivl, horizontal(b), interval_concept());
+ generalized_intersect(ivl, horizontal(b));
horizontal(rectangle, ivl);
ivl = vertical(rectangle);
- interval_concept::generalized_intersect(ivl, vertical(b), interval_concept());
+ generalized_intersect(ivl, vertical(b));
vertical(rectangle, ivl);
return rectangle;
}
/// bloat the interval specified by orient by bloating
template <typename rectangle_type>
- static rectangle_type& bloat(rectangle_type& rectangle, orientation_2d orient,
- typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_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);
- interval_concept::bloat(ivl, bloating);
+ bloat(ivl, bloating);
set(rectangle, orient, ivl);
return rectangle;
}
/// bloat the Rectangle by bloating
template <typename rectangle_type>
- static rectangle_type& bloat(rectangle_type& rectangle,
- typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ rectangle_type>::type &
+ bloat(rectangle_type& rectangle,
+ typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
bloat(rectangle, HORIZONTAL, bloating);
return bloat(rectangle, VERTICAL, bloating);
}
/// bloat the interval cooresponding to orient by bloating in dir direction
template <typename rectangle_type>
- static rectangle_type& bloat(rectangle_type& rectangle, direction_2d dir,
- typename rectangle_traits<rectangle_type>::coordinate_type bloating) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_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));
- interval_concept::bloat(ivl, direction_1d(dir), bloating);
+ bloat(ivl, direction_1d(dir), bloating);
set(rectangle, orientation_2d(dir), ivl);
return rectangle;
}
/// shrink the interval specified by orient by bloating
template <typename rectangle_type>
- static rectangle_type& shrink(rectangle_type& rectangle, orientation_2d orient,
- typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ rectangle_type>::type &
+ shrink(rectangle_type& rectangle, orientation_2d orient,
+ typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
return bloat(rectangle, orient, -shrinking);
}
/// shrink the Rectangle by bloating
template <typename rectangle_type>
- static rectangle_type& shrink(rectangle_type& rectangle,
- typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ rectangle_type>::type &
+ shrink(rectangle_type& rectangle,
+ typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
return bloat(rectangle, -shrinking);
}
/// shrink the interval cooresponding to orient by bloating in dir direction
template <typename rectangle_type>
- static rectangle_type& shrink(rectangle_type& rectangle, direction_2d dir,
- typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
+ typename requires_1<typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ rectangle_type>::type &
+ shrink(rectangle_type& rectangle, direction_2d dir,
+ typename rectangle_traits<rectangle_type>::coordinate_type shrinking) {
return bloat(rectangle, dir, -shrinking);
}
/// encompass interval on orient
template <typename rectangle_type, typename interval_type>
- static bool encompass(const rectangle_type& rectangle, const interval_type& b,
- orientation_2d orient, interval_concept tag) {
+ typename requires_2< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_interval_concept<typename geometry_concept<interval_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);
- if(interval_concept::encompass(ivl, b, tag)) {
+ if(encompass(ivl, b)) {
set(rectangle, orient, ivl);
return true;
}
@@ -519,54 +605,81 @@
/// enlarge rectangle to encompass the Rectangle b
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool encompass(rectangle_type_1& rectangle, const rectangle_type_2& b,
- rectangle_concept tag) {
+ typename requires_2< 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,
+ 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, interval_concept()) |
- encompass(rectangle, vertical(b), VERTICAL, interval_concept());
+ return encompass(rectangle, horizontal(b), HORIZONTAL) |
+ encompass(rectangle, vertical(b), VERTICAL);
}
- //for consistency we should have encompass(rectangle, point) and encompass(interval, coordinate)
+ /// enlarge rectangle to encompass the point b
+ template <typename rectangle_type_1, typename point_type>
+ typename requires_2< typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ bool>::type
+ encompass(rectangle_type_1& rectangle, const point_type& b) {
+ typename rectangle_traits<rectangle_type_1>::interval_type hivl, vivl;
+ hivl = horizontal(rectangle);
+ vivl = vertical(rectangle);
+ //note that operator | is intentional because both should be called regardless
+ bool retval = encompass(hivl, x(b)) | encompass(vivl, y(b));
+ if(retval) {
+ horizontal(rectangle, hivl);
+ vertical(rectangle, vivl);
+ }
+ return retval;
+ }
/// returns the center of the rectangle
- template <typename rectangle_type>
- static inline typename center_type<rectangle_type>::type
- center(const rectangle_type& rectangle) {
- return typename center_type<rectangle_type>::type(interval_concept::center(horizontal(rectangle)),
- interval_concept::center(vertical(rectangle)));
+ template <typename point_type, typename rectangle_type>
+ typename requires_2< typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ bool>::type
+ center(point_type& center_point, const rectangle_type& rectangle) {
+ center_point = construct<point_type>(center(horizontal(rectangle)),
+ center(vertical(rectangle)));
+ return true;
}
- template <typename rectangle_type>
- static typename center_type<rectangle_type>::type
- get_corner(const rectangle_type& rectangle, direction_2d direction_facing, direction_1d direction_turning) {
+ template <typename point_type, typename rectangle_type>
+ typename requires_2< typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_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;
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);
- return point_concept::construct<typename center_type<rectangle_type>::type>(u1, u2);
+ corner_point = construct<point_type>(u1, u2);
+ return true;
}
template <typename rectangle_type>
- static rectangle_type get_half(const rectangle_type& rectangle, direction_2d dir) {
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type, rectangle_type>::type
+ get_half(const rectangle_type& rectangle, direction_2d dir) {
rectangle_type retval(rectangle);
- set(retval, orientation_2d(dir),
- interval_concept::get_half(get(rectangle, orientation_2d(dir)), direction_1d(dir)));
+ set(retval, orientation_2d(dir), get_half(get(rectangle, orientation_2d(dir)), direction_1d(dir)));
return retval;
}
template <typename rectangle_type_1, typename rectangle_type_2>
- static bool join_with(rectangle_type_1& rectangle, const rectangle_type_2& b) {
+ typename requires_2< 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,
+ 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;
Interval1 hi1 = get(rectangle, HORIZONTAL);
Interval1 vi1 = get(rectangle, VERTICAL);
Interval2 hi2 = get(b, HORIZONTAL), vi2 = get(b, VERTICAL);
Interval1 temp;
- if (interval_concept::equivalence(hi1, hi2) && interval_concept::join_with(vi1, vi2)) {
+ if (equivalence(hi1, hi2) && join_with(vi1, vi2)) {
vertical(rectangle, vi1);
return true;
}
- if (interval_concept::equivalence(vi1, vi2) && interval_concept::join_with(hi1, hi2)) {
+ if (equivalence(vi1, vi2) && join_with(hi1, hi2)) {
horizontal(rectangle, hi1);
return true;
}
@@ -574,65 +687,150 @@
}
template <typename rectangle_type, typename point_type>
- static typename coordinate_difference<rectangle_type>::type
- euclidean_distance(rectangle_type& lvalue, const point_type& rvalue,
- orientation_2d orient, point_concept tag) {
- return interval_concept::euclidean_distance(get(lvalue, orient), point_concept::get(rvalue, orient), coordinate_concept());
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::type
+ euclidean_distance(const rectangle_type& lvalue, const point_type& rvalue, orientation_2d orient) {
+ return euclidean_distance(get(lvalue, orient), get(rvalue, orient));
+ }
+
+ template <typename rectangle_type, typename rectangle_type_2>
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::type
+ euclidean_distance(const rectangle_type& lvalue, const rectangle_type_2& rvalue, orientation_2d orient) {
+ return euclidean_distance(get(lvalue, orient), get(rvalue, orient));
}
template <typename rectangle_type, typename point_type>
- static typename coordinate_difference<rectangle_type>::type
- euclidean_distance(rectangle_type& lvalue, const point_type& rvalue,
- orientation_2d orient, rectangle_concept tag) {
- return interval_concept::euclidean_distance(get(lvalue, orient), get(rvalue, orient), interval_concept());
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::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;
+ xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
+ ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
+ return (xdist * xdist) + (ydist * ydist);
}
- template <typename rectangle_type, typename point_type, typename tag_type>
- static typename coordinate_difference<rectangle_type>::type
- square_euclidian_distance(rectangle_type& lvalue, const point_type& rvalue, tag_type tag) {
- typename coordinate_difference<rectangle_type>::type xdist, ydist;
- xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL, tag);
- ydist = euclidean_distance(lvalue, rvalue, VERTICAL, tag);
+ template <typename rectangle_type, typename rectangle_type_2>
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::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;
+ xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
+ ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
return (xdist * xdist) + (ydist * ydist);
}
- template <typename rectangle_type, typename point_type, typename tag_type>
- static typename coordinate_distance<rectangle_type>::type
- euclidean_distance(rectangle_type& lvalue, const point_type& rvalue, tag_type tag) {
- return sqrt((typename coordinate_distance<rectangle_type>::type)(square_euclidian_distance(lvalue, rvalue, tag)));
+ template <typename rectangle_type, typename point_type>
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_distance>::type
+ euclidean_distance(rectangle_type& lvalue, const point_type& rvalue) {
+ return sqrt((typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_distance)
+ (square_euclidean_distance(lvalue, rvalue)));
}
- template <typename rectangle_type, typename point_type, typename tag_type>
- static typename coordinate_difference<rectangle_type>::type
- manhattan_distance(rectangle_type& lvalue, const point_type& rvalue,
- tag_type tag) {
- return euclidean_distance(lvalue, rvalue, HORIZONTAL, tag) + euclidean_distance(lvalue, rvalue, VERTICAL, tag);
+ template <typename rectangle_type, typename rectangle_type_2>
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_distance>::type
+ euclidean_distance(const rectangle_type& lvalue, const rectangle_type_2& rvalue) {
+ return sqrt((typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_distance)
+ (square_euclidean_distance(lvalue, rvalue)));
}
+ template <typename rectangle_type, typename point_type>
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_point_concept<typename geometry_concept<point_type>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::type
+ manhattan_distance(rectangle_type& lvalue, const point_type& rvalue) {
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference xdist, ydist;
+ xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
+ ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
+ return xdist + ydist;
+ }
+
+ template <typename rectangle_type, typename rectangle_type_2>
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ typename coordinate_traits<typename rectangle_traits<rectangle_type>::coordinate_type>::coordinate_difference>::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;
+ xdist = euclidean_distance(lvalue, rvalue, HORIZONTAL);
+ ydist = euclidean_distance(lvalue, rvalue, VERTICAL);
+ return xdist + ydist;
+ }
+
+ template <typename rectangle_type>
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_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) {
+ horizontal(rectangle, scale_up(horizontal(rectangle), factor));
+ vertical(rectangle, scale_up(vertical(rectangle), factor));
+ return rectangle;
+ }
+
+ template <typename rectangle_type>
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_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) {
+ horizontal(rectangle, scale_down(horizontal(rectangle), factor));
+ vertical(rectangle, scale_down(vertical(rectangle), factor));
+ return rectangle;
+ }
+
+ template <typename rectangle_type, typename scaling_type>
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_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));
+ scale(llp, scaling);
+ scale(urp, scaling);
+ set_points(rectangle, llp, urp);
+ return rectangle;
+ }
+
+ template <typename rectangle_type, typename transformation_type>
+ typename requires_1<typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_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(xl(rectangle), yl(rectangle));
+ transform(llp, transformation);
+ transform(urp, transformation);
+ set_points(rectangle, llp, urp);
+ return rectangle;
+ }
+
template <typename rectangle_type_1, typename rectangle_type_2>
- class less : public std::binary_function<const rectangle_type_1&, const rectangle_type_2&, bool> {
+ class less_rectangle_concept {
private:
orientation_2d orient_;
public:
- inline less(orientation_2d orient = VERTICAL) : orient_(orient) {}
- inline bool operator () (const rectangle_type_1& a,
- const rectangle_type_2& b) const {
+ inline less_rectangle_concept(orientation_2d orient = VERTICAL) : orient_(orient) {}
+ typename requires_2< typename is_rectangle_concept<typename geometry_concept<rectangle_type_1>::type>::type,
+ typename is_rectangle_concept<typename geometry_concept<rectangle_type_2>::type>::type,
+ bool>::type
+ operator () (const rectangle_type_1& a,
+ const rectangle_type_2& b) const {
typedef typename rectangle_traits<rectangle_type_1>::coordinate_type Unit;
- Unit vl1 = interval_concept::get(get(a, orient_), LOW);
- Unit vl2 = interval_concept::get(get(b, orient_), LOW);
+ Unit vl1 = get(get(a, orient_), LOW);
+ Unit vl2 = get(get(b, orient_), LOW);
if(vl1 > vl2) return false;
if(vl1 == vl2) {
orientation_2d perp = orient_.get_perpendicular();
- Unit hl1 = interval_concept::get(get(a, perp), LOW);
- Unit hl2 = interval_concept::get(get(b, perp), LOW);
+ Unit hl1 = get(get(a, perp), LOW);
+ Unit hl2 = get(get(b, perp), LOW);
if(hl1 > hl2) return false;
if(hl1 == hl2) {
- Unit vh1 = interval_concept::get(get(a, orient_), HIGH);
- Unit vh2 = interval_concept::get(get(b, orient_), HIGH);
+ Unit vh1 = get(get(a, orient_), HIGH);
+ Unit vh2 = get(get(b, orient_), HIGH);
if(vh1 > vh2) return false;
if(vh1 == vh2) {
- Unit hh1 = interval_concept::get(get(a, perp), HIGH);
- Unit hh2 = interval_concept::get(get(b, perp), HIGH);
+ Unit hh1 = get(get(a, perp), HIGH);
+ Unit hh2 = get(get(b, perp), HIGH);
return hh1 < hh2;
}
}
@@ -641,7 +839,30 @@
}
};
-};
+
+ template <typename T>
+ template <typename interval_type_1>
+ inline void rectangle_data<T>::set(orientation_2d orient, const interval_type_1& interval) {
+ assign(ranges_[orient.to_int()], interval);
+ }
+
+ template <class T>
+ template <class T2>
+ rectangle_data<T>& rectangle_data<T>::operator=(const T2& rvalue) {
+ assign(*this, rvalue);
+ return *this;
+ }
+
+ template <class T>
+ template <class T2>
+ bool rectangle_data<T>::operator==(const T2& rvalue) const {
+ return equivalence(*this, rvalue);
+ }
+
+ template <typename T>
+ struct geometry_concept<rectangle_data<T> > {
+ typedef rectangle_concept type;
+ };
}
#endif
Modified: sandbox/gtl/gtl/rectangle_data.hpp
==============================================================================
--- sandbox/gtl/gtl/rectangle_data.hpp (original)
+++ sandbox/gtl/gtl/rectangle_data.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -9,14 +9,23 @@
#define GTL_RECTANGLE_DATA_HPP
namespace gtl {
-struct rectangle_concept;
+#include "isotropy.hpp"
+//interval
+#include "interval_data.hpp"
template <typename T>
class rectangle_data {
public:
- typedef rectangle_concept geometry_type;
typedef T coordinate_type;
+ typedef interval_data<T> interval_type;
+
inline rectangle_data() {}
+ inline rectangle_data(T xl, T yl, T xh, T yh) {
+ if(xl > xh) std::swap(xl, xh);
+ if(yl > yh) std::swap(yl, yh);
+ ranges_[HORIZONTAL] = interval_data<T>(xl, xh);
+ ranges_[VERTICAL] = interval_data<T>(yl, yh);
+ }
template <typename interval_type_1, typename interval_type_2>
inline rectangle_data(const interval_type_1& hrange,
const interval_type_2& vrange) {
@@ -43,8 +52,8 @@
inline void set(direction_2d dir, coordinate_type value) {
return ranges_[orientation_2d(dir).to_int()].set(direction_1d(dir), value);
}
- template <typename interval_type>
- inline void set(orientation_2d orient, const interval_type& interval);
+ template <typename interval_type_1>
+ inline void set(orientation_2d orient, const interval_type_1& interval);
private:
interval_data<coordinate_type> ranges_[2];
};
Modified: sandbox/gtl/gtl/rectangle_formation.hpp
==============================================================================
--- sandbox/gtl/gtl/rectangle_formation.hpp (original)
+++ sandbox/gtl/gtl/rectangle_formation.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -18,7 +18,7 @@
typedef rectangle_data<coordinate_type> scan_rect_type;
private:
- typedef std::set<scan_rect_type, rectangle_concept::less<scan_rect_type, scan_rect_type> > ScanData;
+ typedef std::set<scan_rect_type, less_rectangle_concept<scan_rect_type, scan_rect_type> > ScanData;
ScanData scanData_;
bool haveCurrentRect_;
scan_rect_type currentRect_;
@@ -30,7 +30,7 @@
inline ScanLineToRects(orientation_2d orient, rectangle_type model) :
scanData_(orientation_2d(orient.to_int() ? VERTICAL : HORIZONTAL)),
haveCurrentRect_(false), orient_(orient) {
- rectangle_concept::assign(currentRect_, model);
+ assign(currentRect_, model);
currentCoordinate_ = std::numeric_limits<coordinate_type>::max();
}
@@ -72,7 +72,7 @@
const rectangle_type& rect = *dataIter;
//if the rectangle data intersects the edge at all
if(rect.get(orient).get(HIGH) >= edge.get(LOW)) {
- if(interval_concept::contains(rect.get(orient), edge, true, interval_concept())) {
+ if(contains(rect.get(orient), edge, true)) {
//this is a closing edge
//we need to write out the intersecting rectangle and
//insert between 0 and 2 rectangles into the scanData
@@ -85,7 +85,7 @@
tmpRect.set(orient.get_perpendicular().get_direction(HIGH),
currentCoordinate);
result_type result;
- rectangle_concept::assign(result, tmpRect);
+ assign(result, tmpRect);
rectangles.insert(rectangles.end(), result);
}
//erase the rectangle from the scan data
@@ -124,7 +124,7 @@
tmpRect.set(orient.get_perpendicular().get_direction(HIGH),
currentCoordinate);
result_type result;
- rectangle_concept::assign(result, tmpRect);
+ assign(result, tmpRect);
rectangles.insert(rectangles.end(), result);
}
//erase the rectangle from the scan data
@@ -173,7 +173,7 @@
edgeProcessed = true;
continue;
}
- edgeProcessed = true;
+ //edgeProcessed = true;
}
++dataIter;
} //end while edge intersects rectangle data
@@ -227,13 +227,13 @@
}
-}; //namespace rectangle_formation
+} //namespace rectangle_formation
template <typename output_container, typename iterator_type, typename rectangle_concept>
void get_rectangles(output_container& output, iterator_type begin, iterator_type end,
orientation_2d orient, rectangle_concept tag) {
typedef typename output_container::value_type rectangle_type;
- typedef typename rectangle_concept::template coordinate_type<rectangle_type>::type Unit;
+ typedef typename rectangle_traits<rectangle_type>::coordinate_type Unit;
rectangle_data<Unit> model;
Unit prevPos = std::numeric_limits<Unit>::max();
rectangle_formation::ScanLineToRects<rectangle_type> scanlineToRects(orient, model);
@@ -245,10 +245,11 @@
prevPos = pos;
}
Unit lowy = (*itr).second.first;
+ iterator_type tmp_itr = itr;
++itr;
Unit highy = (*itr).second.first;
scanlineToRects.processEdge(output, interval_data<Unit>(lowy, highy));
- if(abs((*itr).second.second) > 1) --itr; //next edge begins from this vertex
+ if(abs((*itr).second.second) > 1) itr = tmp_itr; //next edge begins from this vertex
}
}
}
Modified: sandbox/gtl/gtl/rectangle_traits.hpp
==============================================================================
--- sandbox/gtl/gtl/rectangle_traits.hpp (original)
+++ sandbox/gtl/gtl/rectangle_traits.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -9,23 +9,24 @@
#define GTL_RECTANGLE_TRAITS_HPP
namespace gtl {
-template <typename T>
-struct rectangle_traits {
- typedef typename T::coordinate_type coordinate_type;
- typedef interval_data<coordinate_type> interval_type;
-
- static inline interval_type get(const T& rectangle, orientation_2d orient) {
- return rectangle.get(orient); }
+ template <typename T>
+ struct rectangle_traits {
+ typedef typename T::coordinate_type coordinate_type;
+ typedef typename T::interval_type interval_type;
+ static inline interval_type get(const T& rectangle, orientation_2d orient) {
+ return rectangle.get(orient); }
+ };
- template <typename T2>
- static inline void set(T& rectangle, orientation_2d orient, const T2& interval) {
- rectangle.set(orient, interval); }
-
- template <typename T2, typename T3>
- static inline T construct(const T2& interval_horizontal,
- const T3& interval_vertical) {
- return T(interval_horizontal, interval_vertical); }
-};
+ template <typename T>
+ struct rectangle_mutable_traits {
+ template <typename T2>
+ static inline void set(T& rectangle, orientation_2d orient, const T2& interval) {
+ rectangle.set(orient, interval); }
+ template <typename T2, typename T3>
+ static inline T construct(const T2& interval_horizontal,
+ const T3& interval_vertical) {
+ return T(interval_horizontal, interval_vertical); }
+ };
}
#endif
Modified: sandbox/gtl/gtl/scan_arbitrary.hpp
==============================================================================
--- sandbox/gtl/gtl/scan_arbitrary.hpp (original)
+++ sandbox/gtl/gtl/scan_arbitrary.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -1,4 +1,3 @@
-
/*
Copyright 2008 Intel Corporation
@@ -8,111 +7,1458 @@
*/
#ifndef GTL_SCAN_ARBITRARY_HPP
#define GTL_SCAN_ARBITRARY_HPP
+
namespace gtl {
-
- template <typename user_coordinate, typename internal_coordinate, typename property_type>
- class scan_intersect {
- public: //change to private when done testing
- //definitions
- typedef point_data<user_coordinate> user_point;
- typedef point_data<internal_coordinate> internal_point;
- typedef std::pair<user_point, user_point> user_edge;
- typedef std::pair<internal_point, internal_point> internal_edge;
+ template <typename Unit>
+ class line_intersection : public scanline_base<Unit> {
+ private:
+ typedef typename scanline_base<Unit>::Point Point;
+
+ //the first point is the vertex and and second point establishes the slope of an edge eminating from the vertex
+ //typedef std::pair<Point, Point> half_edge;
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+
+ //scanline comparator functor
+ typedef typename scanline_base<Unit>::less_half_edge less_half_edge;
+ typedef typename scanline_base<Unit>::less_point less_point;
+
+ //when parallel half edges are encounterd the set of segments is expanded
+ //when a edge leaves the scanline it is removed from the set
+ //when the set is empty the element is removed from the map
+ typedef int segment_id;
+ typedef std::pair<half_edge, std::set<segment_id> > scanline_element;
+ typedef std::map<half_edge, std::set<segment_id>, less_half_edge> edge_scanline;
+ typedef typename edge_scanline::iterator iterator;
+
+ std::map<Unit, std::set<segment_id> > vertical_data_;
+ edge_scanline edge_scanline_;
+ Unit x_;
+ int just_before_;
+ segment_id segment_id_;
+ std::vector<std::pair<half_edge, int> > event_edges_;
+ std::set<Point> intersection_queue_;
+ public:
+ inline line_intersection() : x_(std::numeric_limits<Unit>::max()), just_before_(0), segment_id_(0) {
+ less_half_edge lessElm(&x_, &just_before_);
+ edge_scanline_ = edge_scanline(lessElm);
+ }
+ inline line_intersection(const line_intersection& that) { (*this) = that; }
+ inline line_intersection& operator=(const line_intersection& that) {
+ x_ = that.x_;
+ just_before_ = that.just_before_;
+ segment_id_ = that.segment_id_;
+
+ //I cannot simply copy that.edge_scanline_ to this edge_scanline_ becuase the functor store pointers to other members!
+ less_half_edge lessElm(&x_, &just_before_);
+ edge_scanline_ = edge_scanline(lessElm);
+
+ edge_scanline_.insert(that.edge_scanline_.begin(), that.edge_scanline_.end());
+ return *this;
+ }
+
+ static inline void between(Point pt, Point pt1, Point pt2) {
+ less_point lp;
+ if(lp(pt1, pt2))
+ return lp(pt, pt2) && lp(pt1, pt);
+ return lp(pt, pt1) && lp(pt2, pt);
+ }
+
+ //quadratic algorithm to do same work as optimal scan for cross checking
+ //assume sorted input
+ template <typename iT>
+ static inline void validate_scan(std::map<segment_id, std::set<Point> >& intersection_points,
+ iT begin, iT end) {
+ std::set<Point> pts;
+ std::vector<std::pair<half_edge, segment_id> > data(begin, end);
+ for(unsigned int i = 0; i < data.size(); ++i) {
+ if(data[i].first.second < data[i].first.first) {
+ std::swap(data[i].first.first, data[i].first.second);
+ }
+ }
+ std::sort(data.begin(), data.end());
+ //find all intersection points
+ for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
+ outer != data.end(); ++outer) {
+ const half_edge& he1 = (*outer).first;
+ //its own end points
+ pts.insert(he1.first);
+ pts.insert(he1.second);
+ for(typename std::vector<std::pair<half_edge, segment_id> >::iterator inner = outer;
+ inner != data.end(); ++inner) {
+ const half_edge& he2 = (*inner).first;
+ if(he1 == he2) continue;
+ if(std::min(he2. first.get(HORIZONTAL),
+ he2.second.get(HORIZONTAL)) >
+ std::max(he1.second.get(HORIZONTAL),
+ he1.first.get(HORIZONTAL)))
+ break;
+ Point intersection;
+ if(compute_intersection(intersection, he1, he2)) {
+ //their intersection point
+ pts.insert(intersection);
+ }
+ }
+ }
+ //find all segments that interact with intersection points
+ for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
+ outer != data.end(); ++outer) {
+ const half_edge& he1 = (*outer).first;
+ segment_id id1 = (*outer).second;
+ typedef rectangle_data<Unit> Rectangle;
+ Rectangle rect1;
+ set_points(rect1, he1.first, he1.second);
+ typename std::set<Point>::iterator itr = pts.lower_bound(std::min(he1.first, he1.second));
+ typename std::set<Point>::iterator itr2 = pts.upper_bound(std::max(he1.first, he1.second));
+ while(itr != pts.end() && itr != pts.begin() && (*itr).get(HORIZONTAL) >= std::min(he1.first.get(HORIZONTAL), he1.second.get(HORIZONTAL))) --itr;
+ while(itr2 != pts.end() && (*itr2).get(HORIZONTAL) <= std::max(he1.first.get(HORIZONTAL), he1.second.get(HORIZONTAL))) ++itr2;
+ //itr = pts.begin();
+ //itr2 = pts.end();
+ for( ; itr != itr2; ++itr) {
+ if(intersects_grid(*itr, he1))
+ intersection_points[id1].insert(*itr);
+ }
+ }
+ }
- class less_scanline_edge;
+ template <typename iT, typename property_type>
+ static inline void validate_scan(std::vector<std::pair<half_edge, std::pair<property_type, int> > >& output_segments,
+ iT begin, iT end) {
+ std::vector<std::pair<property_type, int> > input_properties;
+ std::vector<std::pair<half_edge, int> > input_segments, intermediate_segments;
+ int index = 0;
+ for( ; begin != end; ++begin) {
+ input_properties.push_back((*begin).second);
+ input_segments.push_back(std::make_pair((*begin).first, index++));
+ }
+ validate_scan(intermediate_segments, input_segments.begin(), input_segments.end());
+ for(unsigned int i = 0; i < intermediate_segments.size(); ++i) {
+ output_segments.push_back(std::make_pair(intermediate_segments[i].first,
+ input_properties[intermediate_segments[i].second]));
+ less_point lp;
+ if(lp(output_segments.back().first.first, output_segments.back().first.second) !=
+ lp(input_segments[intermediate_segments[i].second].first.first,
+ input_segments[intermediate_segments[i].second].first.second)) {
+ //edge changed orientation, invert count on edge
+ output_segments.back().second.second *= -1;
+ }
+ if(!is_vertical(input_segments[intermediate_segments[i].second].first) &&
+ is_vertical(output_segments.back().first)) {
+ output_segments.back().second.second *= -1;
+ }
+ if(lp(output_segments.back().first.second, output_segments.back().first.first)) {
+ std::swap(output_segments.back().first.first, output_segments.back().first.second);
+ }
+ }
+ }
- typedef std::map<property_type, int> property_count;
- typedef std::pair<internal_point, property_count> half_edge;
- typedef std::vector<half_edge> half_edge_vector;
- typedef std::pair<internal_point, half_edge_vector> vertex_data;
- typedef std::map<property_type, int> property_data;
- typedef std::pair<internal_edge, property_data> scanline_elment;
- typedef std::map<internal_edge, property_data, less_scanline_edge> scanline_data;
- typedef std::set<property_type> property_combination;
- typedef std::pair<property_combination, internal_edge> output_element;
- typedef std::set<internal_point> intersection_event_queue;
- typedef std::vector<vertex_data> vertex_vector;
-
- private:
- //data memebers
- internal_coordinate current_scanline_stop_;
- bool handling_intersections_;
- vertex_vector input_vertices_; //stores the input
- vertex_vector output_vertices_; //stores the output
- scanline_data scanline_;
- intersection_event_queue intersections_; //intersection points that need to be processed
- vertex_vector intersection_vertices_; //vertex events created by handling intersections
- property_count vertical_count_; //count coming in from below due to vertical edges
+ template <typename iT>
+ static inline void validate_scan(std::vector<std::pair<half_edge, int> >& output_segments,
+ iT begin, iT end) {
+ std::map<segment_id, std::set<Point> > intersection_points;
+ validate_scan(intersection_points, begin, end);
+ segment_intersections(output_segments, intersection_points, begin, end);
+ }
+
+ //quadratic algorithm to find intersections
+ template <typename iT, typename segment_id>
+ static inline bool verify_scan(std::pair<segment_id, segment_id>& offenders,
+ iT begin, iT end) {
+
+ std::vector<std::pair<half_edge, segment_id> > data(begin, end);
+ for(unsigned int i = 0; i < data.size(); ++i) {
+ if(data[i].first.second < data[i].first.first) {
+ std::swap(data[i].first.first, data[i].first.second);
+ }
+ }
+ std::sort(data.begin(), data.end());
+ for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
+ outer != data.end(); ++outer) {
+ const half_edge& he1 = (*outer).first;
+ segment_id id1 = (*outer).second;
+ for(typename std::vector<std::pair<half_edge, segment_id> >::iterator inner = outer;
+ inner != data.end(); ++inner) {
+ const half_edge& he2 = (*inner).first;
+ if(he1 == he2) continue;
+ if(std::min(he2. first.get(HORIZONTAL),
+ he2.second.get(HORIZONTAL)) >
+ std::max(he1.second.get(HORIZONTAL),
+ he1.first.get(HORIZONTAL)))
+ break;
+ segment_id id2 = (*inner).second;
+ if(scanline_base<Unit>::intersects(he1, he2)) {
+ offenders.first = id1;
+ offenders.second = id2;
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ class less_point_down_slope : public std::binary_function<Point, Point, bool> {
+ public:
+ inline less_point_down_slope() {}
+ inline bool operator () (const Point& pt1, const Point& pt2) const {
+ if(pt1.get(HORIZONTAL) < pt2.get(HORIZONTAL)) return true;
+ if(pt1.get(HORIZONTAL) == pt2.get(HORIZONTAL)) {
+ if(pt1.get(VERTICAL) > pt2.get(VERTICAL)) return true;
+ }
+ return false;
+ }
+ };
+
+ template <typename iT>
+ static inline void segment_edge(std::vector<std::pair<half_edge, int> >& output_segments,
+ const half_edge& he, segment_id id, iT begin, iT end) {
+ iT current = begin;
+ iT next = begin;
+ ++next;
+ while(next != end) {
+ output_segments.push_back(std::make_pair(half_edge(*current, *next), id));
+ current = next;
+ ++next;
+ }
+ }
+
+ template <typename iT>
+ static inline void segment_intersections(std::vector<std::pair<half_edge, int> >& output_segments,
+ std::map<segment_id, std::set<Point> >& intersection_points,
+ iT begin, iT end) {
+ for(iT iter = begin; iter != end; ++iter) {
+ //less_point lp;
+ const half_edge& he = (*iter).first;
+ //if(lp(he.first, he.second)) {
+ // //it is the begin event
+ segment_id id = (*iter).second;
+ const std::set<Point>& pts = intersection_points[id];
+ Point hpt(he.first.get(HORIZONTAL)+1, he.first.get(VERTICAL));
+ if(!is_vertical(he) && less_slope(he.first.get(HORIZONTAL), he.first.get(VERTICAL),
+ he.second, hpt)) {
+ //slope is below horizontal
+ std::vector<Point> tmpPts;
+ tmpPts.reserve(pts.size());
+ tmpPts.insert(tmpPts.end(), pts.begin(), pts.end());
+ less_point_down_slope lpds;
+ std::sort(tmpPts.begin(), tmpPts.end(), lpds);
+ segment_edge(output_segments, he, id, tmpPts.begin(), tmpPts.end());
+ } else {
+ segment_edge(output_segments, he, id, pts.begin(), pts.end());
+ }
+ //}
+ }
+ }
+
+ //iT iterator over unsorted pair<Point> representing line segments of input
+ //output_segments is populated with fully intersected output line segment half
+ //edges and the index of the input segment that they are assoicated with
+ //duplicate output half edges with different ids will be generated in the case
+ //that parallel input segments intersection
+ //outputs are in sorted order and include both begin and end events for
+ //each segment
+ template <typename iT>
+ inline void scan(std::vector<std::pair<half_edge, int> >& output_segments,
+ iT begin, iT end) {
+ std::map<segment_id, std::set<Point> > intersection_points;
+ scan(intersection_points, begin, end);
+ segment_intersections(output_segments, intersection_points, begin, end);
+ }
+
+ //iT iterator over sorted sequence of half edge, segment id pairs representing segment begin and end points
+ //intersection points provides a mapping from input segment id (vector index) to the set
+ //of intersection points assocated with that input segment
+ template <typename iT>
+ inline void scan(std::map<segment_id, std::set<Point> >& intersection_points,
+ iT begin, iT end) {
+ for(iT iter = begin; iter != end; ++iter) {
+ const std::pair<half_edge, int>& elem = *iter;
+ const half_edge& he = elem.first;
+ Unit current_x = he.first.get(HORIZONTAL);
+ if(current_x != x_) {
+ process_scan_event(intersection_points);
+ while(!intersection_queue_.empty() &&
+ (*(intersection_queue_.begin()).get(HORIZONTAL) < current_x)) {
+ x_ = *(intersection_queue_.begin()).get(HORIZONTAL);
+ process_intersections_at_scan_event(intersection_points);
+ }
+ x_ = current_x;
+ }
+ event_edges_.push_back(elem);
+ }
+ process_scan_event(intersection_points);
+ }
+
+ inline iterator lookup(const half_edge& he) {
+ return edge_scanline_.find(he);
+ }
+
+ inline void insert_into_scanline(const half_edge& he, int id) {
+ edge_scanline_[he].insert(id);
+ }
+
+ inline void lookup_and_remove(const half_edge& he, int id) {
+ iterator remove_iter = lookup(he);
+ if(remove_iter == edge_scanline_.end()) {
+ std::cout << "failed to find removal segment in scanline\n";
+ return;
+ }
+ std::set<segment_id>& ids = (*remove_iter).second;
+ std::set<segment_id>::iterator id_iter = ids.find(id);
+ if(id_iter == ids.end()) {
+ std::cout << "failed to find removal segment id in scanline set\n";
+ return;
+ }
+ ids.erase(id_iter);
+ if(ids.empty())
+ edge_scanline_.erase(remove_iter);
+ }
+
+ static inline void update_segments(std::map<segment_id, std::set<Point> >& intersection_points,
+ const std::set<segment_id>& segments, Point pt) {
+ for(std::set<segment_id>::const_iterator itr = segments.begin(); itr != segments.end(); ++itr) {
+ intersection_points[*itr].insert(pt);
+ }
+ }
+
+ inline void process_intersections_at_scan_event(std::map<segment_id, std::set<Point> >& intersection_points) {
+ //there may be additional intersection points at this x location that haven't been
+ //found yet if vertical or near vertical line segments intersect more than
+ //once before the next x location
+ just_before_ = true;
+ std::set<iterator> intersecting_elements;
+ std::set<Unit> intersection_locations;
+ typedef typename std::set<Point>::iterator intersection_iterator;
+ intersection_iterator iter;
+ //first find all secondary intersection locations and all scanline iterators
+ //that are intersecting
+ for(iter = intersection_queue_.begin();
+ iter != intersection_queue_.end() && (*iter).get(HORIZONTAL) == x_; ++iter) {
+ Point pt = *iter;
+ Unit y = pt.get(VERTICAL);
+ intersection_locations.insert(y);
+ //if x_ is max there can be only end events and no sloping edges
+ if(x_ != std::numeric_limits<Unit>::max()) {
+ //deal with edges that project to the right of scanline
+ //first find the edges in the scanline adjacent to primary intersectin points
+ //lookup segment in scanline at pt
+ iterator itr = edge_scanline_.lower_bound(half_edge(pt, Point(x_+1, y)));
+ //look above pt in scanline until reaching end or segment that doesn't intersect
+ //1x1 grid upper right of pt
+ //look below pt in scanline until reaching begin or segment that doesn't interset
+ //1x1 grid upper right of pt
+
+ //second find edges in scanline on the y interval of each edge found in the previous
+ //step for x_ to x_ + 1
+
+ //third find overlaps in the y intervals of all found edges to find all
+ //secondary intersection points
+
+ }
+ }
+ //erase the intersection points from the queue
+ intersection_queue_.erase(intersection_queue_.begin(), iter);
+ std::vector<scanline_element> insertion_edges;
+ insertion_edges.reserve(intersecting_elements.size());
+ std::vector<std::pair<Unit, iterator> > sloping_ends;
+ //do all the work of updating the output of all intersecting
+ for(typename std::set<iterator>::iterator inter_iter = intersecting_elements.begin();
+ inter_iter != intersecting_elements.end(); ++inter_iter) {
+ //if it is horizontal update it now and continue
+ if(is_horizontal((*inter_iter).first)) {
+ update_segments(intersection_points, (*inter_iter).second, Point(x_, (*inter_iter).first.get(VERTICAL)));
+ } else {
+ //if x_ is max there can be only end events and no sloping edges
+ if(x_ != std::numeric_limits<Unit>::max()) {
+ //insert its end points into the vector of sloping ends
+ const half_edge& he = (*inter_iter).first;
+ Unit y = evalAtXforY(x_, he.first, he.second);
+ Unit y2 = evalAtXforY(x_+1, he.first, he.second);
+ if(y2 >= y) y2 +=1; //we round up, in exact case we don't worry about overbite of one
+ else y += 1; //downward sloping round up
+ sloping_ends.push_back(std::make_pair(y, inter_iter));
+ sloping_ends.push_back(std::make_pair(y2, inter_iter));
+ }
+ }
+ }
+
+ //merge sloping element data
+ std::sort(sloping_ends.begin(), sloping_ends.end());
+ std::map<Unit, std::set<iterator> > sloping_elements;
+ std::set<iterator> merge_elements;
+ for(typename std::vector<std::pair<Unit, iterator> >::iterator slop_iter = sloping_ends.begin();
+ slop_iter = sloping_ends.end(); ++slop_iter) {
+ //merge into sloping elements
+ typename std::set<iterator>::iterator merge_iterator = merge_elements.find((*slop_iter).second);
+ if(merge_iterator = merge_elements.end()) {
+ merge_elements.insert((*slop_iter).second);
+ } else {
+ merge_elements.erase(merge_iterator);
+ }
+ sloping_elements[(*slop_iter).first] = merge_elements;
+ }
+
+ //scan intersection points
+ typename std::map<Unit, std::set<segment_id> >::iterator vertical_iter = vertical_data_.begin();
+ typename std::map<Unit, std::set<iterator> >::iterator sloping_iter = sloping_elements.begin();
+ for(typename std::set<Unit>::iterator position_iter = intersection_locations.begin();
+ position_iter = intersection_locations.end(); ++position_iter) {
+ //look for vertical segments that intersect this point and update them
+ Unit y = *position_iter;
+ Point pt(x_, y);
+ //handle vertical segments
+ if(vertical_iter != vertical_data_.end()) {
+ typename std::map<Unit, std::set<segment_id> >::iterator next_vertical = vertical_iter;
+ for(++next_vertical; next_vertical != vertical_data_.end() &&
+ (*next_vertical).first < y; ++next_vertical) {
+ vertical_iter = next_vertical;
+ }
+ if((*vertical_iter).first < y && !(*vertical_iter).second.empty()) {
+ update_segments(intersection_points, (*vertical_iter).second, pt);
+ ++vertical_iter;
+ if(vertical_iter != vertical_data_.end() && (*vertical_iter).first == y)
+ update_segments(intersection_points, (*vertical_iter).second, pt);
+ }
+ }
+ //handle sloping segments
+ if(sloping_iter != sloping_elements.end()) {
+ typename std::map<Unit, std::set<iterator> >::iterator next_sloping = sloping_iter;
+ for(++next_sloping; next_sloping != sloping_elements.end() &&
+ (*next_sloping).first < y; ++next_sloping) {
+ sloping_iter = next_sloping;
+ }
+ if((*sloping_iter).first < y && !(*sloping_iter).second.empty()) {
+ for(typename std::set<iterator>::iterator element_iter = (*sloping_iter).second.begin();
+ element_iter != (*sloping_iter).second.end(); ++element_iter) {
+ const half_edge& he = (*element_iter).first;
+ if(intersects_grid(pt, he)) {
+ update_segments(intersection_points, (*element_iter).second, pt);
+ }
+ }
+ ++sloping_iter;
+ if(sloping_iter != sloping_elements.end() && (*sloping_iter).first == y &&
+ !(*sloping_iter).second.empty()) {
+ for(typename std::set<iterator>::iterator element_iter = (*sloping_iter).second.begin();
+ element_iter != (*sloping_iter).second.end(); ++element_iter) {
+ const half_edge& he = (*element_iter).first;
+ if(intersects_grid(pt, he)) {
+ update_segments(intersection_points, (*element_iter).second, pt);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ //erase and reinsert edges into scanline with check for future intersection
+ }
+
+ inline void process_scan_event(std::map<segment_id, std::set<Point> >& intersection_points) {
+ just_before_ = true;
+
+ //process end events by removing those segments from the scanline
+ //and insert vertices of all events into intersection queue
+ Point prev_point(std::numeric_limits<Unit>::min(), std::numeric_limits<Unit>::min());
+ less_point lp;
+ std::set<segment_id> vertical_ids;
+ vertical_data_.clear();
+ for(unsigned int i = 0; i < event_edges_.size(); ++i) {
+ segment_id id = event_edges_[i].second;
+ const half_edge& he = event_edges_[i].first;
+ //vertical half edges are handled during intersection processing because
+ //they cannot be inserted into the scanline
+ if(!is_vertical(he)) {
+ if(lp(he.second, he.first)) {
+ //half edge is end event
+ lookup_and_remove(he, id);
+ } else {
+ //half edge is begin event
+ insert_into_scanline(he, id);
+ //note that they will be immediately removed and reinserted after
+ //handling their intersection (vertex)
+ //an optimization would allow them to be processed specially to avoid the redundant
+ //removal and reinsertion
+ }
+ } else {
+ //common case if you are lucky
+ //update the map of y to set of segment id
+ if(lp(he.second, he.first)) {
+ //half edge is end event
+ std::set<segment_id>::iterator itr = vertical_ids.find(id);
+ if(itr == vertical_ids.end()) {
+ std::cout << "Failed to find end event id in vertical ids\n";
+ } else {
+ vertical_ids.erase(itr);
+ vertical_data_[he.first.get(HORIZONTAL)] = vertical_ids;
+ }
+ } else {
+ //half edge is a begin event
+ vertical_ids.insert(id);
+ vertical_data_[he.first.get(HORIZONTAL)] = vertical_ids;
+ }
+ }
+ //prevent repeated insertion of same vertex into intersection queue
+ if(prev_point != he.first)
+ intersection_queue_.insert(he.first);
+ else
+ prev_point = he.first;
+ // process intersections at scan event
+ process_intersections_at_scan_event(intersection_points);
+ }
+ event_edges_.clear();
+ }
+
+ public:
+ static inline bool test_validate_scan() {
+ std::vector<std::pair<half_edge, segment_id> > input, edges;
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), 0));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 10)), 1));
+ std::pair<segment_id, segment_id> result;
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail1 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.push_back(std::make_pair(half_edge(Point(0, 5), Point(5, 5)), 2));
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.pop_back();
+ input.push_back(std::make_pair(half_edge(Point(1, 0), Point(11, 11)), 3));
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail3 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.push_back(std::make_pair(half_edge(Point(1, 0), Point(10, 11)), 4));
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail4 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.pop_back();
+ input.push_back(std::make_pair(half_edge(Point(1, 2), Point(11, 11)), 5));
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail5 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.push_back(std::make_pair(half_edge(Point(0, 5), Point(0, 11)), 6));
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail6 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.pop_back();
+ for(unsigned int i = 0; i < input.size(); ++i) {
+ std::swap(input[i].first.first, input[i].first.second);
+ }
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail5 2 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ for(unsigned int i = 0; i < input.size(); ++i) {
+ input[i].first.first = Point(input[i].first.first.get(HORIZONTAL) * -1,
+ input[i].first.first.get(VERTICAL) * -1);
+ input[i].first.second = Point(input[i].first.second.get(HORIZONTAL) * -1,
+ input[i].first.second.get(VERTICAL) * -1);
+ }
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ std::cout << edges.size() << std::endl;
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail5 3 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(5, 7), Point(7, 6)), 0));
+ input.push_back(std::make_pair(half_edge(Point(2, 4), Point(6, 7)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 1 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(3, 2), Point(1, 7)), 0));
+ input.push_back(std::make_pair(half_edge(Point(0, 6), Point(7, 4)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 2 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(6, 6), Point(1, 0)), 0));
+ input.push_back(std::make_pair(half_edge(Point(3, 6), Point(2, 3)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 3 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(7, 0)), 0));
+ input.push_back(std::make_pair(half_edge(Point(6, 0), Point(2, 0)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 4 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(-17333131 - -17208131, -10316869 - -10191869), Point(0, 0)), 0));
+ input.push_back(std::make_pair(half_edge(Point(-17291260 - -17208131, -10200000 - -10191869), Point(-17075000 - -17208131, -10200000 - -10191869)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 5 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(-17333131, -10316869), Point(-17208131, -10191869)), 0));
+ input.push_back(std::make_pair(half_edge(Point(-17291260, -10200000), Point(-17075000, -10200000)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 6 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(-9850009+9853379, -286971+290340), Point(-12777869+9853379, -3214831+290340)), 0));
+ input.push_back(std::make_pair(half_edge(Point(-5223510+9853379, -290340+290340), Point(-9858140+9853379, -290340+290340)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ print(edges);
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 7 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(-9850009, -286971), Point(-12777869, -3214831)), 0));
+ input.push_back(std::make_pair(half_edge(Point(-5223510, -290340), Point(-9858140, -290340)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 8 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ //3 3 2 2: 0; 4 2 0 6: 1; 0 3 6 3: 2; 4 1 5 5: 3;
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(3, 3), Point(2, 2)), 0));
+ input.push_back(std::make_pair(half_edge(Point(4, 2), Point(0, 6)), 1));
+ input.push_back(std::make_pair(half_edge(Point(0, 3), Point(6, 3)), 2));
+ input.push_back(std::make_pair(half_edge(Point(4, 1), Point(5, 5)), 3));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail4 1 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ //5 7 1 3: 0; 4 5 2 1: 1; 2 5 2 1: 2; 4 1 5 3: 3;
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(5, 7), Point(1, 3)), 0));
+ input.push_back(std::make_pair(half_edge(Point(4, 5), Point(2, 1)), 1));
+ input.push_back(std::make_pair(half_edge(Point(2, 5), Point(2, 1)), 2));
+ input.push_back(std::make_pair(half_edge(Point(4, 1), Point(5, 3)), 3));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail4 2 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ //1 0 -4 -1: 0; 0 0 2 -1: 1;
+ input.clear();
+ edges.clear();
+ input.push_back(std::make_pair(half_edge(Point(1, 0), Point(-4, -1)), 0));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(2, -1)), 1));
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail2 5 " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ Unit min_c =0;
+ Unit max_c =0;
+ for(unsigned int outer = 0; outer < 1000; ++outer) {
+ input.clear();
+ for(unsigned int i = 0; i < 4; ++i) {
+ Unit x1 = rand();
+ Unit x2 = rand();
+ Unit y1 = rand();
+ Unit y2 = rand();
+ int neg1 = rand() % 2;
+ if(neg1) x1 *= -1;
+ int neg2 = rand() % 2;
+ if(neg2) x2 *= -1;
+ int neg3 = rand() % 2;
+ if(neg3) y1 *= -1;
+ int neg4 = rand() % 2;
+ if(neg4) y2 *= -1;
+ if(x1 < min_c) min_c = x1;
+ if(x2 < min_c) min_c = x2;
+ if(y1 < min_c) min_c = y1;
+ if(y2 < min_c) min_c = y2;
+ if(x1 > max_c) max_c = x1;
+ if(x2 > max_c) max_c = x2;
+ if(y1 > max_c) max_c = y1;
+ if(y2 > max_c) max_c = y2;
+ Point pt1(x1, y1);
+ Point pt2(x2, y2);
+ if(pt1 != pt2)
+ input.push_back(std::make_pair(half_edge(pt1, pt2), i));
+ }
+ edges.clear();
+ validate_scan(edges, input.begin(), input.end());
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "s fail9 " << outer << ": " << result.first << " " << result.second << "\n";
+ print(input);
+ print(edges);
+ return false;
+ }
+ }
+ return true;
+ }
+
+ static void print(const std::pair<half_edge, segment_id>& segment) {
+ std::cout << segment.first.first << " " << segment.first.second << ": " << segment.second << "; ";
+ }
+ static void print(const std::vector<std::pair<half_edge, segment_id> >& vec) {
+ for(unsigned int i = 0; i < vec.size(); ++ i) {
+ print(vec[i]);
+ } std::cout << std::endl;
+ }
+
+ static inline bool test_verify_scan() {
+ std::vector<std::pair<half_edge, segment_id> > edges;
+ edges.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), 0));
+ edges.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 10)), 1));
+ std::pair<segment_id, segment_id> result;
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail1\n";
+ return false;
+ }
+ edges.push_back(std::make_pair(half_edge(Point(0, 5), Point(5, 5)), 2));
+ if(verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail2\n";
+ return false;
+ }
+ edges.pop_back();
+ edges.push_back(std::make_pair(half_edge(Point(1, 0), Point(11, 11)), 3));
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail3\n";
+ return false;
+ }
+ edges.push_back(std::make_pair(half_edge(Point(1, 0), Point(10, 11)), 4));
+ if(verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail4\n";
+ return false;
+ }
+ edges.pop_back();
+ edges.push_back(std::make_pair(half_edge(Point(1, 2), Point(11, 11)), 5));
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail5 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ edges.push_back(std::make_pair(half_edge(Point(0, 5), Point(0, 11)), 6));
+ if(verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail6 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ edges.pop_back();
+ for(unsigned int i = 0; i < edges.size(); ++i) {
+ std::swap(edges[i].first.first, edges[i].first.second);
+ }
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail5 2 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ for(unsigned int i = 0; i < edges.size(); ++i) {
+ edges[i].first.first = Point(edges[i].first.first.get(HORIZONTAL) * -1,
+ edges[i].first.first.get(VERTICAL) * -1);
+ edges[i].first.second = Point(edges[i].first.second.get(HORIZONTAL) * -1,
+ edges[i].first.second.get(VERTICAL) * -1);
+ }
+ if(!verify_scan(result, edges.begin(), edges.end())) {
+ std::cout << "fail5 3 " << result.first << " " << result.second << "\n";
+ return false;
+ }
+ return true;
+ }
+
+ };
+
+ //scanline consumes the "flattened" fully intersected line segments produced by
+ //a pass of line_intersection along with property and count information and performs a
+ //useful operation like booleans or property merge or connectivity extraction
+ template <typename Unit, typename property_type, typename keytype = std::set<property_type> >
+ class scanline : public scanline_base<Unit> {
+ public:
+ //definitions
+ typedef typename scanline_base<Unit>::Point Point;
+
+ //the first point is the vertex and and second point establishes the slope of an edge eminating from the vertex
+ //typedef std::pair<Point, Point> half_edge;
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+
+ //scanline comparator functor
+ typedef typename scanline_base<Unit>::less_half_edge less_half_edge;
+ typedef typename scanline_base<Unit>::less_point less_point;
+
+ typedef keytype property_set;
+ //this is the data type used internally to store the combination of property counts at a given location
+ typedef std::vector<std::pair<property_type, int> > property_map;
+ //this data structure assocates a property and count to a half edge
+ typedef std::pair<half_edge, std::pair<property_type, int> > vertex_property;
+ //this data type is used internally to store the combined property data for a given half edge
+ typedef std::pair<half_edge, property_map> vertex_data;
+ //this data type stores the combination of many half edges
+ typedef std::vector<vertex_property> property_merge_data;
+ //this data structure stores end points of edges in the scanline
+ typedef std::set<Point, less_point> end_point_queue;
+
+ //this is the output data type that is created by the scanline before it is post processed based on content of property sets
+ typedef std::pair<half_edge, std::pair<property_set, property_set> > half_edge_property;
+
+ //this is the scanline data structure
+ typedef std::map<half_edge, property_map, less_half_edge> scanline_type;
+ typedef std::pair<half_edge, property_map> scanline_element;
+ typedef typename scanline_type::iterator iterator;
+ typedef typename scanline_type::const_iterator const_iterator;
+
+ //data
+ scanline_type scan_data_;
+ std::vector<iterator> removal_set_; //edges to be removed at the current scanline stop
+ std::vector<scanline_element> insertion_set_; //edge to be inserted after current scanline stop
+ end_point_queue end_point_queue_;
+ Unit x_;
+ Unit y_;
+ int just_before_;
public:
- //interfaces
- scan_intersect() : scanline_(less_scanline_edge(¤t_scanline_stop_, &handling_intersections_)) {}
+ inline scanline() : x_(std::numeric_limits<Unit>::max()), y_(std::numeric_limits<Unit>::max()), just_before_(false) {
+ less_half_edge lessElm(&x_, &just_before_);
+ scan_data_ = scanline_type(lessElm);
+ }
+ inline scanline(const scanline& that) { (*this) = that; }
+ inline scanline& operator=(const scanline& that) {
+ x_ = that.x_;
+ y_ = that.y_;
+ just_before_ = that.just_before_;
+ end_point_queue_ = that.end_point_queue_;
+ //I cannot simply copy that.scanline_type to this scanline_type becuase the functor store pointers to other members!
+ less_half_edge lessElm(&x_, &just_before_);
+ scan_data_ = scanline_type(lessElm);
+
+ scan_data_.insert(that.scan_data_.begin(), that.scan_data_.end());
+ return *this;
+ }
+
+ template <typename result_type, typename result_functor>
+ void write_out(result_type& result, result_functor rf, const half_edge& he,
+ const property_map& pm_left, const property_map& pm_right) {
+ //std::cout << "write out ";
+ //std::cout << he.first << ", " << he.second << std::endl;
+ property_set ps_left, ps_right;
+ set_unique_property(ps_left, pm_left);
+ set_unique_property(ps_right, pm_right);
+ if(ps_left != ps_right) {
+ //std::cout << "!equivalent\n";
+ rf(result, he, ps_left, ps_right);
+ }
+ }
- template <typename geometry_type>
- void insert(const geometry_type& geometry_object, const property_type& property_value, bool is_hole = false) {
- insert(geometry_object, property_value, is_hole, typename geometry_concept<geometry_type>::type());
- }
-
- void scan() {
- sort_input();
- typename vertex_vector::iterator input_begin = input_vertices_.begin();
- typename vertex_vector::iterator input_end = input_vertices_.end();
- handling_intersections_ = false;
- while(input_begin != input_end) {
- internal_coordinate next_scanline_stop = point_concept::get((*input_begin).first, HORIZONTAL);
- if(next_scanline_stop != current_scanline_stop_) {
- //this call modifies current_scanline_stop to be the coordinate of the first intersection if any before the next input
- if(handle_intersections(next_scanline_stop)) {
- vertex_merge_iterator<typename vertex_vector::iterator, typename vertex_vector::const_iterator>
- merge_begin(input_begin, input_end, intersection_vertices_.begin(), intersection_vertices_.end());
- vertex_merge_iterator<typename vertex_vector::iterator, typename vertex_vector::const_iterator>
- merge_end(input_begin, input_end, intersection_vertices_.begin(), intersection_vertices_.end());
- while(merge_begin != merge_end && point_concept::get((*merge_begin).first, HORIZONTAL) == current_scanline_stop_) {
- scan_element(*merge_begin);
- ++merge_begin;
+ template <typename result_type, typename result_functor, typename iT>
+ iT handle_input_events(result_type& result, result_functor rf, iT begin, iT end) {
+ typedef typename high_precision_type<Unit>::type high_precision;
+ //for each event
+ property_map vertical_properties_above;
+ property_map vertical_properties_below;
+ half_edge vertical_edge_above;
+ half_edge vertical_edge_below;
+ std::vector<scanline_element> insertion_elements;
+ //current_iter should increase monotonically toward end as we process scanline stop
+ iterator current_iter = scan_data_.begin();
+ just_before_ = true;
+ high_precision y = (high_precision)(std::numeric_limits<Unit>::min());
+ bool first_iteration = true;
+ //we want to return from inside the loop when we hit end or new x
+ while(true) {
+ if(begin == end || (!first_iteration && (high_precision)(((*begin).first.first.get(VERTICAL)) != y ||
+ (*begin).first.first.get(HORIZONTAL) != x_))) {
+ //lookup iterator range in scanline for elements coming in from the left
+ //that end at this y
+ Point pt(x_, (Unit)y);
+ //grab the properties coming in from below
+ property_map properties_below;
+ if(current_iter != scan_data_.end()) {
+ //make sure we are looking at element in scanline just below y
+ if(evalAtXforY(x_, (*current_iter).first.first, (*current_iter).first.second) != y) {
+ Point e2(pt);
+ if(e2.get(VERTICAL) != std::numeric_limits<Unit>::max())
+ e2.set(VERTICAL, e2.get(VERTICAL) + 1);
+ else
+ e2.set(VERTICAL, e2.get(VERTICAL) - 1);
+ half_edge vhe(pt, e2);
+ current_iter = scan_data_.lower_bound(vhe);
+ }
+ if(current_iter != scan_data_.end()) {
+ //get the bottom iterator for elements at this point
+ while(evalAtXforY(x_, (*current_iter).first.first, (*current_iter).first.second) >= y &&
+ current_iter != scan_data_.begin()) {
+ --current_iter;
+ }
+ if(evalAtXforY(x_, (*current_iter).first.first, (*current_iter).first.second) >= y) {
+ properties_below.clear();
+ } else {
+ properties_below = (*current_iter).second;
+ //move back up to y or one past y
+ ++current_iter;
+ }
+ }
+ }
+ std::vector<iterator> edges_from_left;
+ while(current_iter != scan_data_.end() &&
+ evalAtXforY(x_, (*current_iter).first.first, (*current_iter).first.second) == y) {
+ //removal_set_.push_back(current_iter);
+ ++current_iter;
+ }
+ //merge vertical count with count from below
+ if(!vertical_properties_below.empty()) {
+ merge_property_maps(vertical_properties_below, properties_below);
+ //write out vertical edge
+ write_out(result, rf, vertical_edge_below, properties_below, vertical_properties_below);
+ } else {
+ merge_property_maps(vertical_properties_below, properties_below);
+ }
+ //iteratively add intertion element counts to count from below
+ //and write them to insertion set
+ for(unsigned int i = 0; i < insertion_elements.size(); ++i) {
+ if(i == 0) {
+ merge_property_maps(insertion_elements[i].second, vertical_properties_below);
+ write_out(result, rf, insertion_elements[i].first, insertion_elements[i].second, vertical_properties_below);
+ } else {
+ merge_property_maps(insertion_elements[i].second, insertion_elements[i-1].second);
+ write_out(result, rf, insertion_elements[i].first, insertion_elements[i].second, insertion_elements[i-1].second);
+ }
+ insertion_set_.push_back(insertion_elements[i]);
+ }
+ if((begin == end || (*begin).first.first.get(HORIZONTAL) != x_)) {
+ if(vertical_properties_above.empty()) {
+ return begin;
+ } else {
+ y = (high_precision)(vertical_edge_above.second.get(VERTICAL));
+ vertical_properties_below.clear();
+ vertical_properties_above.swap(vertical_properties_below);
+ vertical_edge_below = vertical_edge_above;
+ insertion_elements.clear();
+ continue;
}
+ }
+ vertical_properties_below.clear();
+ vertical_properties_above.swap(vertical_properties_below);
+ vertical_edge_below = vertical_edge_above;
+ insertion_elements.clear();
+ }
+ if(begin != end) {
+ const vertex_property& vp = *begin;
+ const half_edge& he = vp.first;
+ y = (high_precision)(he.first.get(VERTICAL));
+ first_iteration = false;
+ if(! vertical_properties_below.empty() &&
+ vertical_edge_below.second.get(VERTICAL) < y) {
+ y = (high_precision)(vertical_edge_below.second.get(VERTICAL));
+ continue;
+ }
+ if(is_vertical(he)) {
+ update_property_map(vertical_properties_above, vp.second);
+ vertical_edge_above = he;
} else {
- //no pending intersection events, so advance the scanline to the new stop
- current_scanline_stop_ = next_scanline_stop;
+ if(insertion_elements.empty() ||
+ insertion_elements.back().first != he) {
+ insertion_elements.push_back(scanline_element(he, property_map()));
+ }
+ update_property_map(insertion_elements.back().second, vp.second);
+ }
+ ++begin;
+ }
+ }
+ }
+
+ inline void erase_end_events(typename end_point_queue::iterator epqi) {
+ end_point_queue_.erase(end_point_queue_.begin(), epqi);
+ for(typename std::vector<iterator>::iterator retire_itr = removal_set_.begin();
+ retire_itr != removal_set_.end(); ++retire_itr) {
+ scan_data_.erase(*retire_itr);
+ }
+ removal_set_.clear();
+ }
+
+
+ inline void remove_retired_edges_from_scanline() {
+ just_before_ = true;
+ typename end_point_queue::iterator epqi = end_point_queue_.begin();
+ Unit current_x = x_;
+ Unit previous_x = x_;
+ while(epqi != end_point_queue_.end() &&
+ (*epqi).get(HORIZONTAL) <= current_x) {
+ x_ = (*epqi).get(HORIZONTAL);
+ if(x_ != previous_x) erase_end_events(epqi);
+ previous_x = x_;
+ //lookup elements
+ Point e2(*epqi);
+ if(e2.get(VERTICAL) != std::numeric_limits<Unit>::max())
+ e2.set(VERTICAL, e2.get(VERTICAL) + 1);
+ else
+ e2.set(VERTICAL, e2.get(VERTICAL) - 1);
+ half_edge vhe_e(*epqi, e2);
+ iterator current_iter = scan_data_.lower_bound(vhe_e);
+ while(current_iter != scan_data_.end() && (*current_iter).first.second == (*epqi)) {
+ //evalAtXforY(x_, (*current_iter).first.first, (*current_iter).first.second) == (*epqi).get(VERTICAL)) {
+ removal_set_.push_back(current_iter);
+ ++current_iter;
+ }
+ ++epqi;
+ }
+ x_ = current_x;
+ erase_end_events(epqi);
+ }
+
+ inline void insert_new_edges_into_scanline() {
+ just_before_ = false;
+ for(typename std::vector<scanline_element>::iterator insert_itr = insertion_set_.begin();
+ insert_itr != insertion_set_.end(); ++insert_itr) {
+ scan_data_.insert(*insert_itr);
+ end_point_queue_.insert((*insert_itr).first.second);
+ }
+ insertion_set_.clear();
+ }
+
+ //iterator over range of vertex property elements and call result functor
+ //passing edge to be output, the merged data on both sides and the result
+ template <typename result_type, typename result_functor, typename iT>
+ void scan(result_type& result, result_functor rf, iT begin, iT end) {
+ while(begin != end) {
+ x_ = (*begin).first.first.get(HORIZONTAL); //update scanline stop location
+ //print_scanline();
+ --x_;
+ remove_retired_edges_from_scanline();
+ ++x_;
+ begin = handle_input_events(result, rf, begin, end);
+ remove_retired_edges_from_scanline();
+ //print_scanline();
+ insert_new_edges_into_scanline();
+ }
+ //print_scanline();
+ x_ = std::numeric_limits<Unit>::max();
+ remove_retired_edges_from_scanline();
+ }
+
+ inline void print_scanline() {
+ std::cout << "scanline at " << x_ << ": ";
+ for(iterator itr = scan_data_.begin(); itr != scan_data_.end(); ++itr) {
+ const scanline_element& se = *itr;
+ const half_edge& he = se.first;
+ const property_map& mp = se.second;
+ std::cout << he.first << ", " << he.second << " ( ";
+ for(unsigned int i = 0; i < mp.size(); ++i) {
+ std::cout << mp[i].first << ":" << mp[i].second << " ";
+ } std::cout << ") ";
+ } std::cout << std::endl;
+ }
+
+ static inline void merge_property_maps(property_map& mp, const property_map& mp2, bool subtract = false) {
+ property_map newmp;
+ newmp.reserve(mp.size() + mp2.size());
+ unsigned int i = 0;
+ unsigned int j = 0;
+ while(i != mp.size() && j != mp2.size()) {
+ if(mp[i].first < mp2[j].first) {
+ newmp.push_back(mp[i]);
+ ++i;
+ } else if(mp[i].first > mp2[j].first) {
+ newmp.push_back(mp2[j]);
+ ++j;
+ } else {
+ int count = mp[i].second;
+ if(subtract) count -= mp2[j].second;
+ else count += mp2[j].second;
+ if(count) {
+ newmp.push_back(mp[i]);
+ newmp.back().second = count;
}
+ ++i;
+ ++j;
+ }
+ }
+ while(i != mp.size()) {
+ newmp.push_back(mp[i]);
+ ++i;
+ }
+ while(j != mp2.size()) {
+ newmp.push_back(mp2[j]);
+ ++j;
+ }
+ mp.swap(newmp);
+ }
+
+ static inline void update_property_map(property_map& mp, const std::pair<property_type, int>& prop_data) {
+ property_map newmp;
+ newmp.reserve(mp.size() +1);
+ bool consumed = false;
+ for(unsigned int i = 0; i < mp.size(); ++i) {
+ if(!consumed && prop_data.first == mp[i].first) {
+ consumed = true;
+ int count = prop_data.second + mp[i].second;
+ if(count)
+ newmp.push_back(std::make_pair(prop_data.first, count));
+ } else if(!consumed && prop_data.first < mp[i].first) {
+ consumed = true;
+ newmp.push_back(prop_data);
+ newmp.push_back(mp[i]);
} else {
- scan_element(*input_begin);
- ++input_begin;
+ newmp.push_back(mp[i]);
}
}
+ if(!consumed) newmp.push_back(prop_data);
+ mp.swap(newmp);
}
- //output is std::map<std::set<property_type>, back_intertable_container<geometry_type> >
- //geometry_type is either polygon_type or polygon_with_holes_type
- //back_insertable_container is any container that supports container.insert(container.end(), value_type)
- template <typename T>
- void getResult(T& output) {
- //TODO
+ static inline void set_unique_property(property_set& unqiue_property, const property_map& property) {
+ unqiue_property.clear();
+ for(typename property_map::const_iterator itr = property.begin(); itr != property.end(); ++itr) {
+ if((*itr).second > 0)
+ unqiue_property.insert(unqiue_property.end(), (*itr).first);
+ }
}
- public: //change to private when done testing
- //non-static member functions for internal use
+ static inline bool common_vertex(const half_edge& he1, const half_edge& he2) {
+ return he1.first == he2.first ||
+ he1.first == he2.second ||
+ he1.second == he2.first ||
+ he1.second == he2.second;
+ }
+
+ typedef typename scanline_base<Unit>::vertex_half_edge vertex_half_edge;
+ template <typename iT>
+ static inline void convert_segments_to_vertex_half_edges(std::vector<vertex_half_edge>& output, iT begin, iT end) {
+ for( ; begin != end; ++begin) {
+ const half_edge& he = (*begin).first;
+ int count = (*begin).second;
+ output.push_back(vertex_half_edge(he.first, he.second, count));
+ output.push_back(vertex_half_edge(he.second, he.first, -count));
+ }
+ std::sort(output.begin(), output.end());
+ }
+
+ class test_functor {
+ public:
+ inline test_functor() {}
+ inline void operator()(std::vector<std::pair<half_edge, std::pair<property_set, property_set> > >& result,
+ const half_edge& he, const property_set& ps_left, const property_set& ps_right) {
+ result.push_back(std::make_pair(he, std::make_pair(ps_left, ps_right)));
+ }
+ };
+ static inline bool test_scanline() {
+ std::vector<std::pair<half_edge, std::pair<property_set, property_set> > > result;
+ std::vector<std::pair<half_edge, std::pair<property_type, int> > > input;
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(10, 10)), std::make_pair(0, -1)));
+ scanline sl;
+ test_functor tf;
+ sl.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(-1, -1), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(-1, -1), Point(0, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(11, 11)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(11, 11)), std::make_pair(0, 1)));
+ scanline sl2;
+ sl2.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 1), Point(8, 2)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 1), Point(2, 8)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(2, 8), Point(9, 9)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(8, 2), Point(9, 9)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(10, 10)), std::make_pair(0, -1)));
+ scanline sl3;
+ sl3.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 1), Point(8, 2)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 1), Point(2, 8)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(2, 8), Point(9, 9)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(8, 2), Point(9, 9)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(10, 10)), std::make_pair(0, -1)));
+ scanline sl4;
+ sl4.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(9, 1)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(1, 9)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 9), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(9, 1), Point(10, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(10, 10)), std::make_pair(0, -1)));
+ scanline sl5;
+ sl5.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(9, 1)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(1, 9)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 9), Point(10, 10)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(9, 1), Point(10, 10)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(10, 10)), std::make_pair(0, -1)));
+ scanline sl6;
+ sl6.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(10, 0)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(9, 1)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(1, 9)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 0), Point(0, 10)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(10, 10)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 20), Point(10, 20)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 20), Point(9, 21)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 20), Point(1, 29)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 20), Point(0, 30)), std::make_pair(0, 1)));
+ input.push_back(std::make_pair(half_edge(Point(0, 30), Point(10, 30)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 9), Point(10, 10)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(1, 29), Point(10, 30)), std::make_pair(1, -1)));
+ input.push_back(std::make_pair(half_edge(Point(9, 1), Point(10, 10)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(9, 21), Point(10, 30)), std::make_pair(1, 1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 20), Point(10, 30)), std::make_pair(0, -1)));
+ input.push_back(std::make_pair(half_edge(Point(10, 20), Point(10, 30)), std::make_pair(0, -1)));
+ scanline sl7;
+ sl7.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ input.clear();
+ result.clear();
+ input.push_back(std::make_pair(half_edge(Point(-1, -1), Point(10, 0)), std::make_pair(0, 1))); //a
+ input.push_back(std::make_pair(half_edge(Point(-1, -1), Point(0, 10)), std::make_pair(0, -1))); //a
+ input.push_back(std::make_pair(half_edge(Point(0, 10), Point(11, 11)), std::make_pair(0, -1))); //a
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(20, 0)), std::make_pair(0, 1))); //b
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(11, 11)), std::make_pair(0, -1))); //b
+ input.push_back(std::make_pair(half_edge(Point(10, 0), Point(11, 11)), std::make_pair(0, 1))); //a
+ input.push_back(std::make_pair(half_edge(Point(11, 11), Point(20, 10)), std::make_pair(0, -1))); //b
+ input.push_back(std::make_pair(half_edge(Point(20, 0), Point(30, 0)), std::make_pair(0, 1))); //c
+ input.push_back(std::make_pair(half_edge(Point(20, 0), Point(20, 10)), std::make_pair(0, -1))); //b
+ input.push_back(std::make_pair(half_edge(Point(20, 0), Point(20, 10)), std::make_pair(0, 1))); //c
+ input.push_back(std::make_pair(half_edge(Point(20, 10), Point(30, 10)), std::make_pair(0, -1))); //c
+ input.push_back(std::make_pair(half_edge(Point(30, 0), Point(30, 10)), std::make_pair(0, -1))); //c
+ scanline sl8;
+ sl8.scan(result, tf, input.begin(), input.end());
+ std::cout << "scanned\n";
+ for(unsigned int i = 0; i < result.size(); ++i) {
+ std::cout << result[i].first.first << ", " << result[i].first.second << "; ";
+ } std::cout << std::endl;
+ return true;
+ }
+
+ };
+
+ template <typename Unit>
+ class merge_output_functor {
+ public:
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+ merge_output_functor() {}
+ template <typename result_type, typename key_type>
+ void operator()(result_type& result, const half_edge& edge, const key_type& left, const key_type& right) {
+ typename std::pair<half_edge, int> elem;
+ elem.first = edge;
+ elem.second = 1;
+ if(edge.second < edge.first) elem.second *= -1;
+ if(scanline_base<Unit>::is_vertical(edge)) elem.second *= -1;
+ if(!left.empty())
+ result[left].insert_clean(elem);
+ elem.second *= -1;
+ if(!right.empty())
+ result[right].insert_clean(elem);
+ }
+ };
+
+ template <typename Unit, typename property_type, typename key_type = std::set<property_type>,
+ typename output_functor_type = merge_output_functor<Unit> >
+ class property_merge : public scanline_base<Unit> {
+ private:
+ typedef typename scanline_base<Unit>::Point Point;
+
+ //the first point is the vertex and and second point establishes the slope of an edge eminating from the vertex
+ //typedef std::pair<Point, Point> half_edge;
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+
+ //scanline comparator functor
+ typedef typename scanline_base<Unit>::less_half_edge less_half_edge;
+ typedef typename scanline_base<Unit>::less_point less_point;
+
+ //this data structure assocates a property and count to a half edge
+ typedef std::pair<half_edge, std::pair<property_type, int> > vertex_property;
+ //this data type stores the combination of many half edges
+ typedef std::vector<vertex_property> property_merge_data;
+
+ //this is the data type used internally to store the combination of property counts at a given location
+ typedef std::vector<std::pair<property_type, int> > property_map;
+ //this data type is used internally to store the combined property data for a given half edge
+ typedef std::pair<half_edge, property_map> vertex_data;
+
+ property_merge_data pmd;
+
+ template<typename vertex_data_type>
+ class less_vertex_data {
+ public:
+ less_vertex_data() {}
+ bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) {
+ less_point lp;
+ if(lp(lvalue.first.first, rvalue.first.first)) return true;
+ if(lp(rvalue.first.first, lvalue.first.first)) return false;
+ Unit x = lvalue.first.first.get(HORIZONTAL);
+ int just_before_ = 0;
+ less_half_edge lhe(&x, &just_before_);
+ return lhe(lvalue.first, rvalue.first);
+ }
+ };
+
+ inline void sort_property_merge_data() {
+ less_vertex_data<vertex_property> lvd;
+ std::sort(pmd.begin(), pmd.end(), lvd);
+ }
+ public:
+ inline property_merge() {}
+ inline property_merge(const property_merge& pm) : pmd(pm.pmd) {}
+ inline property_merge& operator=(const property_merge& pm) { pmd = pm.pmd; return *this; }
- inline void sort_input() {
- less_vertex_data lessF;
- std::sort(input_vertices_.begin(), input_vertices_.end(), lessF);
+ template <typename polygon_type>
+ void insert(const polygon_type& polygon_object, const property_type& property_value, bool is_hole = false) {
+ insert(polygon_object, property_value, is_hole, typename geometry_concept<polygon_type>::type());
}
+ //result type should be std::map<std::set<property_type>, polygon_set_type>
+ //or std::map<std::vector<property_type>, polygon_set_type>
+ template <typename result_type>
+ void merge(result_type& result) {
+ //intersect data
+ property_merge_data tmp_pmd;
+ line_intersection<Unit>::validate_scan(tmp_pmd, pmd.begin(), pmd.end());
+ pmd.swap(tmp_pmd);
+ sort_property_merge_data();
+ scanline<Unit, property_type, key_type> sl;
+ output_functor_type mof;
+ sl.scan(result, mof, pmd.begin(), pmd.end());
+ }
+
+ inline bool verify() {
+ std::pair<int, int> offenders;
+ std::vector<std::pair<half_edge, int> > lines;
+ int count = 0;
+ for(unsigned int i = 0; i < pmd.size(); ++i) {
+ lines.push_back(std::make_pair(pmd[i].first, count++));
+ }
+ if(!line_intersection<Unit>::verify_scan(offenders, lines.begin(), lines.end())) {
+ std::cout << "Intersection failed!\n";
+ std::cout << offenders.first << " " << offenders.second << std::endl;
+ return false;
+ }
+ std::vector<Point> pts;
+ for(unsigned int i = 0; i < lines.size(); ++i) {
+ pts.push_back(lines[i].first.first);
+ pts.push_back(lines[i].first.second);
+ }
+ std::sort(pts.begin(), pts.end());
+ for(unsigned int i = 0; i < pts.size(); i+=2) {
+ if(pts[i] != pts[i+1]) {
+ std::cout << "Non-closed figures after line intersection!\n";
+ return false;
+ }
+ }
+ return true;
+ }
+
+ void clear() {*this = property_merge();}
+
+ private:
template <typename polygon_type>
void insert(const polygon_type& polygon_object, const property_type& property_value, bool is_hole,
polygon_concept tag) {
bool first_iteration = true;
bool second_iteration = true;
- internal_point first_point;
- internal_point second_point;
- internal_point previous_previous_point;
- internal_point previous_point;
- internal_point current_point;
- vertex_data current_vertex;
- direction_1d winding = polygon_concept::winding(polygon_object);
- for(typename polygon_traits<polygon_type>::iterator_type itr = polygon_concept::begin(polygon_object);
- itr != polygon_concept::end(polygon_object); ++itr) {
- point_concept::assign(current_point, *itr);
+ Point first_point;
+ Point second_point;
+ Point previous_previous_point;
+ Point previous_point;
+ Point current_point;
+ direction_1d winding_dir = winding(polygon_object);
+ for(typename polygon_traits<polygon_type>::iterator_type itr = begin_points(polygon_object);
+ itr != end_points(polygon_object); ++itr) {
+ assign(current_point, *itr);
if(first_iteration) {
first_iteration = false;
first_point = previous_point = current_point;
@@ -124,9 +1470,8 @@
}
} else {
if(previous_point != current_point) {
- create_vertex(current_vertex, previous_previous_point, previous_point, current_point, winding,
+ create_vertex(pmd, previous_previous_point, previous_point, current_point, winding_dir,
is_hole, property_value);
- input_vertices_.push_back(current_vertex);
previous_previous_point = previous_point;
previous_point = current_point;
}
@@ -135,16 +1480,14 @@
current_point = first_point;
if(!first_iteration && !second_iteration) {
if(previous_point != current_point) {
- create_vertex(current_vertex, previous_previous_point, previous_point, current_point, winding,
+ create_vertex(pmd, previous_previous_point, previous_point, current_point, winding_dir,
is_hole, property_value);
- input_vertices_.push_back(current_vertex);
previous_previous_point = previous_point;
previous_point = current_point;
}
current_point = second_point;
- create_vertex(current_vertex, previous_previous_point, previous_point, current_point, winding,
+ create_vertex(pmd, previous_previous_point, previous_point, current_point, winding_dir,
is_hole, property_value);
- input_vertices_.push_back(current_vertex);
previous_previous_point = previous_point;
previous_point = current_point;
}
@@ -155,8 +1498,8 @@
polygon_with_holes_concept tag) {
insert(polygon_with_holes_object, property_value, is_hole, polygon_concept());
for(typename polygon_with_holes_traits<polygon_with_holes_type>::iterator_holes_type itr =
- polygon_with_holes_concept::begin_holes(polygon_with_holes_object);
- itr != polygon_with_holes_concept::end_holes(polygon_with_holes_object); ++itr) {
+ begin_holes(polygon_with_holes_object);
+ itr != end_holes(polygon_with_holes_object); ++itr) {
insert(*itr, property_value, !is_hole, polygon_concept());
}
}
@@ -164,59 +1507,38 @@
template <typename rectangle_type>
void insert(const rectangle_type& rectangle_object, const property_type& property_value, bool is_hole,
rectangle_concept tag) {
- polygon_90_data<user_coordinate> poly;
- polygon_90_concept::set_rectangle(poly, rectangle_object);
+ polygon_90_data<Unit> poly;
+ assign(poly, rectangle_object);
insert(poly, property_value, is_hole, polygon_concept());
}
- void scan_element(const vertex_data& vertex) {
- for(typename half_edge_vector::const_iterator itr = vertex.second.begin(); itr != vertex.second.end(); ++itr) {
- //scan_half_edge(vertex.first, *itr);
- }
- }
-
- void handle_intersection(internal_coordinate intersection_intercept) {}
-
- bool handle_intersections(internal_coordinate next_scanline_stop) {
- if(intersections_.empty() || point_concept::get(*(intersections_.begin()), HORIZONTAL) > next_scanline_stop)
- return false;
- current_scanline_stop_ = point_concept::get(*(intersections_.begin()), HORIZONTAL);
- handling_intersections_ = true;
- do {
- handle_intersection(point_concept::get(*(intersections_.begin()), VERTICAL));
- intersections_.erase(intersections_.begin());
- } while(current_scanline_stop_ == point_concept::get(*(intersections_.begin()), HORIZONTAL));
- handling_intersections_ = false;
- return true;
- }
-
-
-
public: //change to private when done testing
- //static helper functions and member classes
- static inline void create_vertex(vertex_data& current_vertex,
- const internal_point& previous_point,
- const internal_point& current_point,
- const internal_point& next_point,
+ static inline void create_vertex(property_merge_data& pmd,
+ const Point& previous_point,
+ const Point& current_point,
+ const Point& next_point,
direction_1d winding,
bool is_hole, const property_type& property) {
- current_vertex.first = current_point;
- current_vertex.second.clear();
+ if(current_point == next_point) return;
+ vertex_property current_vertex;
+ current_vertex.first.first = current_point;
+ current_vertex.first.second = next_point;
+ current_vertex.second.first = property;
int multiplier = 1;
if(winding == CLOCKWISE)
multiplier = -1;
if(is_hole)
multiplier *= -1;
- half_edge he;
- he.first = next_point;
- he.second[property] = multiplier * (point_concept::euclidean_distance(next_point, current_point, HORIZONTAL) == 0 ? -1: 1);
- current_vertex.second.push_back(he);
- he.second.clear();
- he.first = previous_point;
- he.second[property] = -1 * multiplier * (point_concept::euclidean_distance(previous_point, current_point, HORIZONTAL) == 0 ? -1: 1);
- current_vertex.second.push_back(he);
- sort_vertex_half_edges(current_vertex);
+ if(current_point < next_point) {
+ multiplier *= -1;
+ std::swap(current_vertex.first.first, current_vertex.first.second);
+ }
+ current_vertex.second.second = multiplier * (euclidean_distance(next_point, current_point, HORIZONTAL) == 0 ? -1: 1);
+ pmd.push_back(current_vertex);
+ //current_vertex.first.second = previous_point;
+ //current_vertex.second.second *= -1;
+ //pmd.push_back(current_vertex);
}
static inline void sort_vertex_half_edges(vertex_data& vertex) {
@@ -224,248 +1546,66 @@
std::sort(vertex.second.begin(), vertex.second.end(), lessF);
}
- static inline internal_coordinate compute_intercept(const internal_coordinate& dy2,
- const internal_coordinate& dx1,
- const internal_coordinate& dx2) {
- //intercept = dy2 * dx1 / dx2
- typedef typename coordinate_traits<internal_coordinate>::area_type area_type;
- //try to protect against potential overflow by casting to area type for multiplication computation
- return (internal_coordinate)(((area_type)dy2 * (area_type)dx1) / (area_type)dx2);
- }
-
- static inline internal_coordinate compute_intercept(const internal_edge& edge, internal_coordinate& coordinate) {
- const internal_point* pts[2] = {edge.first, edge.second};
- if(*(pts[0]) > *(pts[1]))
- std::swap(pts[0], pts[1]);
- internal_coordinate dx = point_concept::euclidean_distance(*(pts[0]), *(pts[1]), HORIZONTAL);
- internal_coordinate dy = point_concept::euclidean_distance(*(pts[0]), *(pts[1]), VERTICAL);
- internal_coordinate dx_intercept = coordinate - point_concept::get(*(pts[0]), HORIZONTAL);
- return point_concept::get(*(pts[0]), VERTICAL) + compute_intercept(dy, dx_intercept, dx);
- }
-
- static inline bool less_slope(const internal_coordinate& x, const internal_coordinate& y,
- const internal_point& pt1, const internal_point& pt2) {
- const internal_point* pts[2] = {&pt1, &pt2};
- //compute y value on edge from pt_ to pts[1] at the x value of pts[0]
- internal_coordinate dy2 = pts[1]->get(VERTICAL) - y;
- internal_coordinate dy1 = pts[0]->get(VERTICAL) - y;
- internal_coordinate dx2 = pts[1]->get(HORIZONTAL) - x;
- internal_coordinate dx1 = pts[0]->get(HORIZONTAL) - x;
- if(dx1 < 0) {
- dy1 *= -1;
- dx1 *= -1;
- }
- if(dx2 < 0) {
- dy2 *= -1;
- dx2 *= -1;
- }
- if(dx1 < dx2)
- return (dy1 < compute_intercept(dy2, dx1, dx2));
- else
- return (dy2 > compute_intercept(dy1, dx2, dx1));
- }
-
- class less_vertex_data {
- public:
- less_vertex_data() {}
- bool operator()(const vertex_data& lvalue, const vertex_data& rvalue) {
- return lvalue.first < rvalue.first;
- }
- };
-
- class less_scanline_edge {
- private:
- internal_coordinate* scanline_stop;
- bool* processing_intersections;
- public:
- less_scanline_edge(internal_coordinate* stop, bool* flag) :
- scanline_stop(stop), processing_intersections(flag) {}
- bool operator()(const internal_edge& lvalue, const internal_edge& rvalue) {
- internal_coordinate ly1 = lvalue.first.get(VERTICAL);
- internal_coordinate ly2 = lvalue.second.get(VERTICAL);
- internal_coordinate ry1 = rvalue.first.get(VERTICAL);
- internal_coordinate ry2 = rvalue.second.get(VERTICAL);
- if(std::max(ly1, ly2) < std::min(ry1, ry2))
- return true;
- if(std::min(ly1, ly2) > std::max(ry1, ry2))
- return false;
- //the edges have overlapping range in y
- //it is assumed that the edges overlap the scanline stop
- //it is futher assumed that neither edge is vertical
- internal_coordinate ly = compute_intercept(lvalue, *scanline_stop);
- internal_coordinate ry = compute_intercept(lvalue, *scanline_stop);
- if(ly < ry) return true;
- if(ly > ry) return false;
- //the two edges have the same y value at the scanline stop
- return *processing_intersections ^
- less_slope(*scanline_stop, ly, lvalue.first, rvalue.first);
- }
- };
-
- static inline void merge_count(property_count& lvalue, const property_count& rvalue) {
- for(typename property_count::const_iterator itr = rvalue.begin(); itr != rvalue.end(); ++itr) {
- //double check that default initialization of element of map to int results in zero value
- lvalue[(*itr).first] += (*itr).second;
- }
- }
-
- //checks if two property counts that are adjacenet in the scanline are equivilent
- //for the purposes of determining if there should be an output generated along their boundary or not
- static inline bool equivalent(const property_count& lvalue, const property_count& rvalue) {
- typename property_count::const_iterator itr1 = lvalue.begin();
- typename property_count::const_iterator itr2 = rvalue.begin();
- while(itr1 != lvalue.end() || itr2 != rvalue.end()) {
- while(itr1 != lvalue.end() && (*itr1).second <= 0) ++itr1;
- while(itr2 != rvalue.end() && (*itr2).second <= 0) ++itr2;
- if(itr1 != lvalue.end()) {
- if(itr2 != rvalue.end() && *itr1.first != *itr2.first) return false;
- } else if(itr2 != rvalue.end())
- return false;
- }
- }
-
- static inline void set_unqiue_property(property_combination& unqiue_property, const property_count& property) {
- unqiue_property.clear();
- for(typename property_count::const_iterator itr = property.begin(); itr != property.end(); ++itr) {
- if(*itr.second > 0)
- unqiue_property.insert(unqiue_property.end(), *itr.first);
- }
- }
-
class less_half_edge_pair {
private:
- internal_point pt_;
+ Point pt_;
public:
- less_half_edge_pair(const internal_point& pt) : pt_(pt) {}
+ less_half_edge_pair(const Point& pt) : pt_(pt) {}
bool operator()(const half_edge& e1, const half_edge& e2) {
- const internal_point& pt1 = e1.first;
- const internal_point& pt2 = e2.first;
- if(point_concept::get(pt1, HORIZONTAL) ==
- point_concept::get(pt_, HORIZONTAL)) {
+ const Point& pt1 = e1.first;
+ const Point& pt2 = e2.first;
+ if(get(pt1, HORIZONTAL) ==
+ get(pt_, HORIZONTAL)) {
//vertical edge is always largest
return false;
}
- if(point_concept::get(pt2, HORIZONTAL) ==
- point_concept::get(pt_, HORIZONTAL)) {
+ if(get(pt2, HORIZONTAL) ==
+ get(pt_, HORIZONTAL)) {
//if half edge 1 is not vertical its slope is less than that of half edge 2
- return point_concept::get(pt1, HORIZONTAL) != point_concept::get(pt2, HORIZONTAL);
+ return get(pt1, HORIZONTAL) != get(pt2, HORIZONTAL);
}
- return less_slope(point_concept::get(pt_, HORIZONTAL),
- point_concept::get(pt_, VERTICAL), pt1, pt2);
+ return less_slope(get(pt_, HORIZONTAL),
+ get(pt_, VERTICAL), pt1, pt2);
}
};
- template <typename iterator1, typename iterator2>
- class vertex_merge_iterator {
- private:
- iterator1 begin1_, end1_;
- iterator2 begin2_, end2_;
- vertex_data merged_vertex_;
- unsigned int state_;
- public:
- typedef std::forward_iterator_tag iterator_category;
- typedef vertex_data value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type* pointer; //immutable
- typedef const value_type& reference; //immutable
- vertex_merge_iterator(iterator1 begin1, iterator1 end1, iterator2 begin2, iterator2 end2) :
- begin1_(begin1), end1_(end1), begin2_(begin2), end2_(end2) {
- set_state();
- if(state_ == 0)
- handle_equal();
- }
-
- bool operator==(const vertex_merge_iterator& that) {
- return begin1_ == that.begin1_ && begin2_ == that.begin2_;
- }
- bool operator!=(const vertex_merge_iterator& that) {
- return !((*this) == that);
- }
-
- reference operator*() {
- if(state_ == 1) return *begin1_;
- if(state_ == 2) return *begin2_;
- if(state_ == 3) return merged_vertex_;
- //assert this return statement should not be used
- return merged_vertex_;
- }
-
- inline vertex_merge_iterator& operator++() {
- if(state_ == 1) ++begin1_;
- if(state_ == 2) ++begin1_;
- set_state();
- if(state_ == 0)
- handle_equal();
- return *this;
- }
- inline vertex_merge_iterator operator++(int) {
- vertex_merge_iterator tmp(*this);
- ++(*this);
- return tmp;
- }
-
- void handle_equal() {
- half_edge_vector half_edges;
- merged_vertex_.first = (*begin1_).first;
- while(begin1_ != end1_ && (*begin1_).first == merged_vertex_.first) {
- half_edges.insert(half_edges.end(), (*begin1_).second.begin(), (*begin1_).second.end());
- ++begin1_;
- }
- while(begin2_ != end2_ && (*begin2_).first == merged_vertex_.first) {
- half_edges.insert(half_edges.end(), (*begin2_).second.begin(), (*begin2_).second.end());
- ++begin2_;
- }
- less_half_edge_pair lessF(merged_vertex_.first);
- std::sort(half_edges.begin(), half_edges.end(), lessF);
- merged_vertex_.second.push_back(half_edges.front());
- for(unsigned int i = 1; i < half_edges.size(); ++i) {
- if(!lessF(merged_vertex_.second.back(), half_edges[i])) {
- merge_count(merged_vertex_.second.back().second, half_edges[i].second);
- } else {
- merged_vertex_.second.push_back(half_edges[i]);
- }
- }
- state_ = 3;
- }
-
- void set_state() {
- if(begin1_ == end1_) {
- if(begin2_ == end2_) {
- state_ = 4;
- } else {
- state_ = 2;
- }
- } else if(begin2_ == end2_) {
- state_ = 1;
- } else {
- if((*begin1_).first == (*begin2_).first) {
- state_ = 0;
- } else if((*begin1_).first < (*begin2_).first) {
- state_ = 1;
- } else {
- state_ = 2;
- }
- }
- }
- };
-
public:
//test functions
- static std::ostream& print (std::ostream& o, const property_count& c)
+ static std::ostream& print (std::ostream& o, const property_map& c)
{
o << "count: {";
- for(typename property_count::const_iterator itr = c.begin(); itr != c.end(); ++itr) {
+ for(typename property_map::const_iterator itr = c.begin(); itr != c.end(); ++itr) {
o << ((*itr).first) << ":" << ((*itr).second) << " ";
}
return o << "} ";
}
+
static std::ostream& print (std::ostream& o, const half_edge& he)
{
- return print(o << "half edge: (" << (he.first) << ", ", (he.second)) << ") ";
+ o << "half edge: (";
+ o << (he.first);
+ return o << ", " << (he.second) << ") ";
+ }
+
+ static std::ostream& print (std::ostream& o, const vertex_property& c)
+ {
+ o << "vertex property: {";
+ print(o, c.first);
+ o << ", " << c.second.first << ":" << c.second.second << " ";
+ return o;
+ }
+
+ static std::ostream& print (std::ostream& o, const std::vector<vertex_property>& hev)
+ {
+ o << "vertex properties: {";
+ for(unsigned int i = 0; i < hev.size(); ++i) {
+ print(o, (hev[i])) << " ";
+ }
+ return o << "} ";
}
- static std::ostream& print (std::ostream& o, const half_edge_vector& hev)
+ static std::ostream& print (std::ostream& o, const std::vector<half_edge>& hev)
{
o << "half edges: {";
for(unsigned int i = 0; i < hev.size(); ++i) {
@@ -479,7 +1619,7 @@
return print(o << "vertex: <" << (v.first) << ", ", (v.second)) << "> ";
}
- static std::ostream& print (std::ostream& o, const vertex_vector& vv)
+ static std::ostream& print (std::ostream& o, const std::vector<vertex_data>& vv)
{
o << "vertices: {";
for(unsigned int i = 0; i < vv.size(); ++i) {
@@ -491,91 +1631,809 @@
static inline bool test_insertion() {
- scan_intersect si;
- rectangle_data<user_coordinate> rect;
- rectangle_concept::xl(rect, 0);
- rectangle_concept::yl(rect, 1);
- rectangle_concept::xh(rect, 10);
- rectangle_concept::yh(rect, 11);
+ property_merge si;
+ rectangle_data<Unit> rect;
+ xl(rect, 0);
+ yl(rect, 1);
+ xh(rect, 10);
+ yh(rect, 11);
si.insert(rect, 333);
- print(std::cout, si.input_vertices_) << std::endl;
+ print(std::cout, si.pmd) << std::endl;
- user_point pts[4] = {user_point(0, 0), user_point(10,-3), user_point(13, 8), user_point(0, 0) };
- polygon_data<user_coordinate> poly;
- scan_intersect si2;
+ Point pts[4] = {Point(0, 0), Point(10,-3), Point(13, 8), Point(0, 0) };
+ polygon_data<Unit> poly;
+ property_merge si2;
poly.set(pts, pts+3);
si2.insert(poly, 444);
- si2.sort_input();
- print(std::cout, si2.input_vertices_) << std::endl;
- scan_intersect si3;
+ si2.sort_property_merge_data();
+ print(std::cout, si2.pmd) << std::endl;
+ property_merge si3;
poly.set(pts, pts+4);
si3.insert(poly, 444);
- si3.sort_input();
- std::cout << (si2.input_vertices_ == si3.input_vertices_) << std::endl;
+ si3.sort_property_merge_data();
+ std::cout << (si2.pmd == si3.pmd) << std::endl;
std::reverse(pts, pts+4);
- scan_intersect si4;
+ property_merge si4;
poly.set(pts, pts+4);
si4.insert(poly, 444);
- si4.sort_input();
- std::cout << (si2.input_vertices_ == si4.input_vertices_) << std::endl;
+ si4.sort_property_merge_data();
+ print(std::cout, si4.pmd) << std::endl;
+ std::cout << (si2.pmd == si4.pmd) << std::endl;
std::reverse(pts, pts+3);
- scan_intersect si5;
+ property_merge si5;
poly.set(pts, pts+4);
si5.insert(poly, 444);
- si5.sort_input();
- std::cout << (si2.input_vertices_ == si5.input_vertices_) << std::endl;
+ si5.sort_property_merge_data();
+ std::cout << (si2.pmd == si5.pmd) << std::endl;
return true;
}
+ static inline bool test_merge() {
+ property_merge si;
+ rectangle_data<Unit> rect;
+ xl(rect, 0);
+ yl(rect, 1);
+ xh(rect, 10);
+ yh(rect, 11);
-
- static inline bool test_less_slope() {
- internal_coordinate x = 0;
- internal_coordinate y = 0;
- internal_point pt1(10, 10);
- internal_point pt2(10, 10);
- if(less_slope(x, y, pt1, pt2)) {
- std::cout << "fail1\n";
+ si.insert(rect, 333);
+ std::map<std::set<property_type>, polygon_set_data<Unit> > result;
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ polygon_set_data<Unit> psd = (*(result.begin())).second;
+ std::vector<polygon_data<Unit> > polys;
+ psd.get(polys);
+ if(polys.size() != 1) {
+ std::cout << "fail merge 1\n";
return false;
}
- if(less_slope(x, y, pt2, pt1)) {
- std::cout << "fail2\n";
+ std::cout << (polys[0]) << std::endl;
+ si.clear();
+ std::vector<Point> pts;
+ pts.push_back(Point(0, 0));
+ pts.push_back(Point(10, -10));
+ pts.push_back(Point(10, 10));
+ polygon_data<Unit> poly;
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(5, 0));
+ pts.push_back(Point(-5, -10));
+ pts.push_back(Point(-5, 10));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() != 1) {
+ std::cout << "fail merge 2\n";
return false;
}
- pt1.set(HORIZONTAL, 11);
- if(!less_slope(x, y, pt1, pt2)) {
- std::cout << "fail3\n";
+ //Polygon { -4 -1, 3 3, -2 3 }
+ //Polygon { 0 -4, -4 -2, -2 1 }
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(-4, -1));
+ pts.push_back(Point(3, 3));
+ pts.push_back(Point(-2, 3));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(0, -4));
+ pts.push_back(Point(-4, -2));
+ pts.push_back(Point(-2, 1));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() != 1) {
+ std::cout << "fail merge 3\n";
return false;
}
- if(less_slope(x, y, pt2, pt1)) {
- std::cout << "fail4\n";
+ std::cout << "Polygon { -2 2, -2 2, 1 4 } \n";
+ std::cout << "Polygon { 2 4, 2 -4, -3 1 } \n";
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(-2, 2));
+ pts.push_back(Point(-2, 2));
+ pts.push_back(Point(1, 4));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(2, 4));
+ pts.push_back(Point(2, -4));
+ pts.push_back(Point(-3, 1));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() != 1) {
+ std::cout << "fail merge 4\n";
return false;
}
- pt1 = internal_point(-10, -10);
- if(less_slope(x, y, pt1, pt2)) {
- std::cout << "fail5\n";
+ std::cout << (polys[0]) << std::endl;
+ std::cout << "Polygon { -4 0, -2 -3, 3 -4 } \n";
+ std::cout << "Polygon { -1 1, 1 -2, -4 -3 } \n";
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(-4, 0));
+ pts.push_back(Point(-2, -3));
+ pts.push_back(Point(3, -4));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(-1, 1));
+ pts.push_back(Point(1, -2));
+ pts.push_back(Point(-4, -3));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() != 1) {
+ std::cout << "fail merge 5\n";
return false;
}
- if(less_slope(x, y, pt2, pt1)) {
- std::cout << "fail6\n";
- return false;
+ std::cout << "Polygon { 2 2, -2 0, 0 1 } \n";
+ std::cout << "Polygon { 4 -2, 3 -1, 2 3 } \n";
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(2, 2));
+ pts.push_back(Point(-2, 0));
+ pts.push_back(Point(0, 1));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(4, -2));
+ pts.push_back(Point(3, -1));
+ pts.push_back(Point(2, 3));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ if(!result.empty()) {
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() != 1) {
+ std::cout << "fail merge 6\n";
+ return false;
+ }
+ std::cout << (polys[0]) << std::endl;
}
- pt1.set(HORIZONTAL, -11);
- if(!less_slope(x, y, pt1, pt2)) {
- std::cout << "fail7\n";
- return false;
+ std::cout << "Polygon { 0 2, 3 -1, 4 1 } \n";
+ std::cout << "Polygon { -4 3, 3 3, 4 2 } \n";
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(0, 2));
+ pts.push_back(Point(3, -1));
+ pts.push_back(Point(4, 1));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(-4, 3));
+ pts.push_back(Point(3, 3));
+ pts.push_back(Point(4, 2));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ if(!result.empty()) {
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() == 0) {
+ std::cout << "fail merge 7\n";
+ return false;
+ }
+ std::cout << (polys[0]) << std::endl;
+ }
+std::cout << "Polygon { 1 -2, -1 4, 3 -2 } \n";
+std::cout << "Polygon { 0 -3, 3 1, -3 -4 } \n";
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(1, -2));
+ pts.push_back(Point(-1, 4));
+ pts.push_back(Point(3, -2));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(0, -3));
+ pts.push_back(Point(3, 1));
+ pts.push_back(Point(-3, -4));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ if(!result.empty()) {
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() == 0) {
+ std::cout << "fail merge 8\n";
+ return false;
+ }
+ std::cout << (polys[0]) << std::endl;
+ }
+std::cout << "Polygon { 2 2, 3 0, -3 4 } \n";
+std::cout << "Polygon { -2 -2, 0 0, -1 -1 } \n";
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(2, 2));
+ pts.push_back(Point(3, 0));
+ pts.push_back(Point(-3, 4));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ pts.clear();
+ pts.push_back(Point(-2, -2));
+ pts.push_back(Point(0, 0));
+ pts.push_back(Point(-1, -1));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ if(!result.empty()) {
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() == 0) {
+ std::cout << "fail merge 9\n";
+ return false;
+ }
+ std::cout << (polys[0]) << std::endl;
+ }
+ si.clear();
+ pts.clear();
+ //5624841,17616200,75000,9125000
+ //pts.push_back(Point(5624841,75000));
+ //pts.push_back(Point(5624841,9125000));
+ //pts.push_back(Point(17616200,9125000));
+ //pts.push_back(Point(17616200,75000));
+pts.push_back(Point(12262940, 6652520 )); pts.push_back(Point(12125750, 6652520 )); pts.push_back(Point(12121272, 6652961 )); pts.push_back(Point(12112981, 6656396 )); pts.push_back(Point(12106636, 6662741 )); pts.push_back(Point(12103201, 6671032 )); pts.push_back(Point(12103201, 6680007 )); pts.push_back(Point(12106636, 6688298 )); pts.push_back(Point(12109500, 6691780 )); pts.push_back(Point(12748600, 7330890 )); pts.push_back(Point(15762600, 7330890 )); pts.push_back(Point(15904620, 7472900 )); pts.push_back(Point(15909200, 7473030 )); pts.push_back(Point(15935830, 7476006 )); pts.push_back(Point(15992796, 7499602 )); pts.push_back(Point(16036397, 7543203 )); pts.push_back(Point(16059993, 7600169 )); pts.push_back(Point(16059993, 7661830 )); pts.push_back(Point(16036397, 7718796 )); pts.push_back(Point(15992796, 7762397 )); pts.push_back(Point(15935830, 7785993 )); pts.push_back(Point(15874169, 7785993 )); pts.push_back(Point(15817203, 7762397 )); pts.push_back(Point(15773602, 7718796 )); pts.push_back(
Point(15750006, 7661830 )); pts.push_back(Point(15747030, 7635200 )); pts.push_back(Point(15746900, 7630620 )); pts.push_back(Point(15670220, 7553930 )); pts.push_back(Point(14872950, 7553930 )); pts.push_back(Point(14872950, 7626170 )); pts.push_back(Point(14869973, 7661280 )); pts.push_back(Point(14846377, 7718246 )); pts.push_back(Point(14802776, 7761847 )); pts.push_back(Point(14745810, 7785443 )); pts.push_back(Point(14684149, 7785443 )); pts.push_back(Point(14627183, 7761847 )); pts.push_back(Point(14583582, 7718246 )); pts.push_back(Point(14559986, 7661280 )); pts.push_back(Point(14557070, 7636660 )); pts.push_back(Point(14556670, 7625570 )); pts.push_back(Point(13703330, 7625570 )); pts.push_back(Point(13702930, 7636660 )); pts.push_back(Point(13699993, 7661830 )); pts.push_back(Point(13676397, 7718796 )); pts.push_back(Point(13632796, 7762397 )); pts.push_back(Point(13575830, 7785993 )); pts.push_back(Point(13514169, 7785993 )); pts.push_back(Point(13457203, 7762397 )); pts.push_back(Point(13436270,
7745670 )); pts.push_back(Point(13432940, 7742520 )); pts.push_back(Point(12963760, 7742520 )); pts.push_back(Point(12959272, 7742961 )); pts.push_back(Point(12950981, 7746396 )); pts.push_back(Point(12944636, 7752741 )); pts.push_back(Point(12941201, 7761032 )); pts.push_back(Point(12941201, 7770007 )); pts.push_back(Point(12944636, 7778298 )); pts.push_back(Point(12947490, 7781780 )); pts.push_back(Point(13425330, 8259620 )); pts.push_back(Point(15601330, 8259620 )); pts.push_back(Point(15904620, 8562900 )); pts.push_back(Point(15909200, 8563030 )); pts.push_back(Point(15935830, 8566006 )); pts.push_back(Point(15992796, 8589602 )); pts.push_back(Point(16036397, 8633203 )); pts.push_back(Point(16059993, 8690169 )); pts.push_back(Point(16059993, 8751830 )); pts.push_back(Point(16036397, 8808796 )); pts.push_back(Point(15992796, 8852397 )); pts.push_back(Point(15935830, 8875993 )); pts.push_back(Point(15874169, 8875993 )); pts.push_back(Point(15817203, 8852397 )); pts.push_back(Point(15773602, 8808796 )); pt
s.push_back(Point(15750006, 8751830 )); pts.push_back(Point(15747030, 8725200 )); pts.push_back(Point(15746900, 8720620 )); pts.push_back(Point(15508950, 8482660 )); pts.push_back(Point(14689890, 8482660 )); pts.push_back(Point(14685412, 8483101 )); pts.push_back(Point(14677121, 8486536 )); pts.push_back(Point(14670776, 8492881 )); pts.push_back(Point(14667341, 8501172 )); pts.push_back(Point(14667341, 8510147 )); pts.push_back(Point(14670776, 8518438 )); pts.push_back(Point(14673630, 8521920 )); pts.push_back(Point(14714620, 8562900 )); pts.push_back(Point(14719200, 8563030 )); pts.push_back(Point(14745830, 8566006 )); pts.push_back(Point(14802796, 8589602 )); pts.push_back(Point(14846397, 8633203 )); pts.push_back(Point(14869993, 8690169 )); pts.push_back(Point(14869993, 8751830 )); pts.push_back(Point(14846397, 8808796 )); pts.push_back(Point(14802796, 8852397 )); pts.push_back(Point(14745830, 8875993 )); pts.push_back(Point(14684169, 8875993 )); pts.push_back(Point(14627203, 8852397 )); pts.push_back(Poi
nt(14583602, 8808796 )); pts.push_back(Point(14560006, 8751830 )); pts.push_back(Point(14557030, 8725200 )); pts.push_back(Point(14556900, 8720620 )); pts.push_back(Point(14408270, 8571980 )); pts.push_back(Point(13696320, 8571980 )); pts.push_back(Point(13696320, 8675520 )); pts.push_back(Point(13699963, 8690161 )); pts.push_back(Point(13699963, 8751818 )); pts.push_back(Point(13676368, 8808781 )); pts.push_back(Point(13632771, 8852378 )); pts.push_back(Point(13575808, 8875973 )); pts.push_back(Point(13514151, 8875973 )); pts.push_back(Point(13457188, 8852378 )); pts.push_back(Point(13436270, 8835670 )); pts.push_back(Point(13432940, 8832520 )); pts.push_back(Point(13281760, 8832520 )); pts.push_back(Point(13277272, 8832961 )); pts.push_back(Point(13268981, 8836396 )); pts.push_back(Point(13262636, 8842741 )); pts.push_back(Point(13259201, 8851032 )); pts.push_back(Point(13259201, 8860007 )); pts.push_back(Point(13262636, 8868298 )); pts.push_back(Point(13265500, 8871780 )); pts.push_back(Point(13518710, 91
25000 )); pts.push_back(Point(16270720, 9125000 )); pts.push_back(Point(16270720, 8939590 )); pts.push_back(Point(17120780, 8939590 )); pts.push_back(Point(17120780, 9125000 )); pts.push_back(Point(17616200, 9125000 )); pts.push_back(Point(17616200, 75000 )); pts.push_back(Point(16024790, 75000 )); pts.push_back(Point(16021460, 80700 )); pts.push_back(Point(16016397, 88796 )); pts.push_back(Point(15972796, 132397 )); pts.push_back(Point(15915830, 155993 )); pts.push_back(Point(15908730, 157240 )); pts.push_back(Point(15905000, 157800 )); pts.push_back(Point(15516800, 546000 )); pts.push_back(Point(15905000, 934200 )); pts.push_back(Point(15908730, 934760 )); pts.push_back(Point(15915830, 936006 )); pts.push_back(Point(15972796, 959602 )); pts.push_back(Point(16016397, 1003203 )); pts.push_back(Point(16039993, 1060169 )); pts.push_back(Point(16039993, 1121830 )); pts.push_back(Point(16016397, 1178796 )); pts.push_back(Point(15972796, 1222397 )); pts.push_back(Point(15915830, 1245993 )); pts.p
ush_back(Point(15854169, 1245993 )); pts.push_back(Point(15797203, 1222397 )); pts.push_back(Point(15753602, 1178796 )); pts.push_back(Point(15730006, 1121830 )); pts.push_back(Point(15728760, 1114730 )); pts.push_back(Point(15728200, 1111000 )); pts.push_back(Point(15363500, 746300 )); pts.push_back(Point(14602620, 746300 )); pts.push_back(Point(14598142, 746741 )); pts.push_back(Point(14589851, 750176 )); pts.push_back(Point(14583506, 756521 )); pts.push_back(Point(14580071, 764812 )); pts.push_back(Point(14580071, 773787 )); pts.push_back(Point(14583506, 782078 )); pts.push_back(Point(14586360, 785560 )); pts.push_back(Point(14586370, 785560 )); pts.push_back(Point(14735000, 934200 )); pts.push_back(Point(14738730, 934760 )); pts.push_back(Point(14745830, 936006 )); pts.push_back(Point(14802796, 959602 )); pts.push_back(Point(14846397, 1003203 )); pts.push_back(Point(14869993, 1060169 )); pts.push_back(Point(14870450, 1062550 )); pts.push_back(Point(14872170, 1071980 )); pts.push_back(Point(
14972780, 1071980 )); pts.push_back(Point(15925000, 2024200 )); pts.push_back(Point(15928730, 2024760 )); pts.push_back(Point(15935830, 2026006 )); pts.push_back(Point(15992796, 2049602 )); pts.push_back(Point(16036397, 2093203 )); pts.push_back(Point(16059993, 2150169 )); pts.push_back(Point(16059993, 2211830 )); pts.push_back(Point(16036397, 2268796 )); pts.push_back(Point(15992796, 2312397 )); pts.push_back(Point(15935830, 2335993 )); pts.push_back(Point(15874169, 2335993 )); pts.push_back(Point(15817203, 2312397 )); pts.push_back(Point(15773602, 2268796 )); pts.push_back(Point(15750006, 2211830 )); pts.push_back(Point(15748760, 2204730 )); pts.push_back(Point(15748200, 2201000 )); pts.push_back(Point(14869220, 1322020 )); pts.push_back(Point(14088350, 1322020 )); pts.push_back(Point(14083862, 1322461 )); pts.push_back(Point(14075571, 1325896 )); pts.push_back(Point(14069226, 1332241 )); pts.push_back(Point(14065791, 1340532 )); pts.push_back(Point(14065791, 1349507 )); pts.push_back(Point(14069226, 13577
98 )); pts.push_back(Point(14072080, 1361280 )); pts.push_back(Point(14072090, 1361280 )); pts.push_back(Point(14735000, 2024200 )); pts.push_back(Point(14738730, 2024760 )); pts.push_back(Point(14745830, 2026006 )); pts.push_back(Point(14802796, 2049602 )); pts.push_back(Point(14846397, 2093203 )); pts.push_back(Point(14869993, 2150169 )); pts.push_back(Point(14869993, 2211830 )); pts.push_back(Point(14846397, 2268796 )); pts.push_back(Point(14802796, 2312397 )); pts.push_back(Point(14745830, 2335993 )); pts.push_back(Point(14684169, 2335993 )); pts.push_back(Point(14627203, 2312397 )); pts.push_back(Point(14583602, 2268796 )); pts.push_back(Point(14560006, 2211830 )); pts.push_back(Point(14558760, 2204730 )); pts.push_back(Point(14558200, 2201000 )); pts.push_back(Point(13752220, 1395020 )); pts.push_back(Point(12991340, 1395020 )); pts.push_back(Point(12986862, 1395461 )); pts.push_back(Point(12978571, 1398896 )); pts.push_back(Point(12972226, 1405241 )); pts.push_back(Point(12968791, 1413532 )); pts.push
_back(Point(12968791, 1422507 )); pts.push_back(Point(12972226, 1430798 )); pts.push_back(Point(12975080, 1434280 )); pts.push_back(Point(12975090, 1434280 )); pts.push_back(Point(13565000, 2024200 )); pts.push_back(Point(13568730, 2024760 )); pts.push_back(Point(13575830, 2026006 )); pts.push_back(Point(13632796, 2049602 )); pts.push_back(Point(13676397, 2093203 )); pts.push_back(Point(13699993, 2150169 )); pts.push_back(Point(13699993, 2211830 )); pts.push_back(Point(13676397, 2268796 )); pts.push_back(Point(13632796, 2312397 )); pts.push_back(Point(13575830, 2335993 )); pts.push_back(Point(13514169, 2335993 )); pts.push_back(Point(13457203, 2312397 )); pts.push_back(Point(13413602, 2268796 )); pts.push_back(Point(13390006, 2211830 )); pts.push_back(Point(13388760, 2204730 )); pts.push_back(Point(13388200, 2201000 )); pts.push_back(Point(12655220, 1468020 )); pts.push_back(Point(11894340, 1468020 )); pts.push_back(Point(11889862, 1468461 )); pts.push_back(Point(11881571, 1471896 )); pts.push_back(Point(118
75226, 1478241 )); pts.push_back(Point(11871791, 1486532 )); pts.push_back(Point(11871791, 1495507 )); pts.push_back(Point(11875226, 1503798 )); pts.push_back(Point(11878090, 1507280 )); pts.push_back(Point(12395000, 2024200 )); pts.push_back(Point(12398730, 2024760 )); pts.push_back(Point(12405830, 2026006 )); pts.push_back(Point(12462796, 2049602 )); pts.push_back(Point(12506397, 2093203 )); pts.push_back(Point(12529993, 2150169 )); pts.push_back(Point(12529993, 2211830 )); pts.push_back(Point(12506397, 2268796 )); pts.push_back(Point(12462796, 2312397 )); pts.push_back(Point(12405830, 2335993 )); pts.push_back(Point(12344169, 2335993 )); pts.push_back(Point(12287203, 2312397 )); pts.push_back(Point(12243602, 2268796 )); pts.push_back(Point(12220006, 2211830 )); pts.push_back(Point(12218760, 2204730 )); pts.push_back(Point(12218200, 2201000 )); pts.push_back(Point(11558220, 1541020 )); pts.push_back(Point(10797340, 1541020 )); pts.push_back(Point(10792862, 1541461 )); pts.push_back(Point(10784571, 1544896
)); pts.push_back(Point(10778226, 1551241 )); pts.push_back(Point(10774791, 1559532 )); pts.push_back(Point(10774791, 1568507 )); pts.push_back(Point(10778226, 1576798 )); pts.push_back(Point(10781080, 1580280 )); pts.push_back(Point(10781090, 1580280 )); pts.push_back(Point(11225000, 2024200 )); pts.push_back(Point(11228730, 2024760 )); pts.push_back(Point(11235830, 2026006 )); pts.push_back(Point(11292796, 2049602 )); pts.push_back(Point(11336397, 2093203 )); pts.push_back(Point(11359993, 2150169 )); pts.push_back(Point(11359993, 2211830 )); pts.push_back(Point(11336397, 2268796 )); pts.push_back(Point(11292796, 2312397 )); pts.push_back(Point(11235830, 2335993 )); pts.push_back(Point(11174169, 2335993 )); pts.push_back(Point(11117203, 2312397 )); pts.push_back(Point(11073602, 2268796 )); pts.push_back(Point(11050006, 2211830 )); pts.push_back(Point(11048760, 2204730 )); pts.push_back(Point(11048200, 2201000 )); pts.push_back(Point(10461220, 1614020 )); pts.push_back(Point( 5647400, 1614020 )); pts.push_ba
ck(Point( 5642912, 1614461 )); pts.push_back(Point( 5634621, 1617896 )); pts.push_back(Point( 5628276, 1624241 )); pts.push_back(Point( 5624841, 1632532 )); pts.push_back(Point( 5624841, 1641507 )); pts.push_back(Point( 5628276, 1649798 )); pts.push_back(Point( 5631130, 1653280 )); pts.push_back(Point( 5688490, 1710640 )); pts.push_back(Point( 9722350, 1710640 )); pts.push_back(Point(10034620, 2022900 )); pts.push_back(Point(10039200, 2023030 )); pts.push_back(Point(10065830, 2026006 )); pts.push_back(Point(10122796, 2049602 )); pts.push_back(Point(10166397, 2093203 )); pts.push_back(Point(10189993, 2150169 )); pts.push_back(Point(10189993, 2211830 )); pts.push_back(Point(10166397, 2268796 )); pts.push_back(Point(10158620, 2279450 )); pts.push_back(Point(10158620, 2404900 )); pts.push_back(Point(10548950, 2795240 )); pts.push_back(Point(15586950, 2795240 )); pts.push_back(Point(15904620, 3112900 )); pts.push_back(Point(15909200, 3113030 )); pts.push_back(Point(15935830, 3116006 )); pts.push_back(Point(159927
96, 3139602 )); pts.push_back(Point(16036397, 3183203 )); pts.push_back(Point(16059993, 3240169 )); pts.push_back(Point(16059993, 3301830 )); pts.push_back(Point(16036397, 3358796 )); pts.push_back(Point(15992796, 3402397 )); pts.push_back(Point(15935830, 3425993 )); pts.push_back(Point(15874169, 3425993 )); pts.push_back(Point(15817203, 3402397 )); pts.push_back(Point(15773602, 3358796 )); pts.push_back(Point(15750006, 3301830 )); pts.push_back(Point(15747030, 3275200 )); pts.push_back(Point(15746900, 3270620 )); pts.push_back(Point(15494570, 3018280 )); pts.push_back(Point(14675510, 3018280 )); pts.push_back(Point(14671032, 3018721 )); pts.push_back(Point(14662741, 3022156 )); pts.push_back(Point(14656396, 3028501 )); pts.push_back(Point(14652961, 3036792 )); pts.push_back(Point(14652961, 3045767 )); pts.push_back(Point(14656396, 3054058 )); pts.push_back(Point(14659260, 3057540 )); pts.push_back(Point(14714620, 3112900 )); pts.push_back(Point(14719200, 3113030 )); pts.push_back(Point(14745830, 3116006 ));
pts.push_back(Point(14802796, 3139602 )); pts.push_back(Point(14846397, 3183203 )); pts.push_back(Point(14869993, 3240169 )); pts.push_back(Point(14869993, 3301830 )); pts.push_back(Point(14846397, 3358796 )); pts.push_back(Point(14802796, 3402397 )); pts.push_back(Point(14745830, 3425993 )); pts.push_back(Point(14684169, 3425993 )); pts.push_back(Point(14627203, 3402397 )); pts.push_back(Point(14583602, 3358796 )); pts.push_back(Point(14560006, 3301830 )); pts.push_back(Point(14557030, 3275200 )); pts.push_back(Point(14556900, 3270620 )); pts.push_back(Point(14370700, 3084410 )); pts.push_back(Point(13702830, 3084410 )); pts.push_back(Point(13702830, 3263160 )); pts.push_back(Point(13700003, 3302210 )); pts.push_back(Point(13676407, 3359176 )); pts.push_back(Point(13632806, 3402777 )); pts.push_back(Point(13575840, 3426373 )); pts.push_back(Point(13514179, 3426373 )); pts.push_back(Point(13457213, 3402777 )); pts.push_back(Point(13413612, 3359176 )); pts.push_back(Point(13390016, 3302210 )); pts.push_back(
Point(13387030, 3275200 )); pts.push_back(Point(13386900, 3270620 )); pts.push_back(Point(13266840, 3150550 )); pts.push_back(Point(12532920, 3150550 )); pts.push_back(Point(12532920, 3264990 )); pts.push_back(Point(12529993, 3301820 )); pts.push_back(Point(12506397, 3358786 )); pts.push_back(Point(12462796, 3402387 )); pts.push_back(Point(12405830, 3425983 )); pts.push_back(Point(12344169, 3425983 )); pts.push_back(Point(12287203, 3402387 )); pts.push_back(Point(12243602, 3358786 )); pts.push_back(Point(12220006, 3301820 )); pts.push_back(Point(12217030, 3275200 )); pts.push_back(Point(12216900, 3270620 )); pts.push_back(Point(12157460, 3211170 )); pts.push_back(Point(11362030, 3211170 )); pts.push_back(Point(11360250, 3220520 )); pts.push_back(Point(11359993, 3221830 )); pts.push_back(Point(11336397, 3278796 )); pts.push_back(Point(11292796, 3322397 )); pts.push_back(Point(11235830, 3345993 )); pts.push_back(Point(11174169, 3345993 )); pts.push_back(Point(11117203, 3322397 )); pts.push_back(Point(11096270,
3305670 )); pts.push_back(Point(11092940, 3302520 )); pts.push_back(Point(10680760, 3302520 )); pts.push_back(Point(10676272, 3302961 )); pts.push_back(Point(10667981, 3306396 )); pts.push_back(Point(10661636, 3312741 )); pts.push_back(Point(10658201, 3321032 )); pts.push_back(Point(10658201, 3330007 )); pts.push_back(Point(10661636, 3338298 )); pts.push_back(Point(10664500, 3341780 )); pts.push_back(Point(11264260, 3941550 )); pts.push_back(Point(15643260, 3941550 )); pts.push_back(Point(15904620, 4202900 )); pts.push_back(Point(15909200, 4203030 )); pts.push_back(Point(15935830, 4206006 )); pts.push_back(Point(15992796, 4229602 )); pts.push_back(Point(16036397, 4273203 )); pts.push_back(Point(16059993, 4330169 )); pts.push_back(Point(16059993, 4391830 )); pts.push_back(Point(16036397, 4448796 )); pts.push_back(Point(15992796, 4492397 )); pts.push_back(Point(15935830, 4515993 )); pts.push_back(Point(15874169, 4515993 )); pts.push_back(Point(15817203, 4492397 )); pts.push_back(Point(15773602, 4448796 )); pt
s.push_back(Point(15750006, 4391830 )); pts.push_back(Point(15747030, 4365200 )); pts.push_back(Point(15746900, 4360620 )); pts.push_back(Point(15550880, 4164590 )); pts.push_back(Point(14825070, 4164590 )); pts.push_back(Point(14825070, 4247610 )); pts.push_back(Point(14846397, 4273213 )); pts.push_back(Point(14869993, 4330179 )); pts.push_back(Point(14869993, 4391840 )); pts.push_back(Point(14846397, 4448806 )); pts.push_back(Point(14802796, 4492407 )); pts.push_back(Point(14745830, 4516003 )); pts.push_back(Point(14684169, 4516003 )); pts.push_back(Point(14627203, 4492407 )); pts.push_back(Point(14583602, 4448806 )); pts.push_back(Point(14560006, 4391840 )); pts.push_back(Point(14557030, 4365200 )); pts.push_back(Point(14556900, 4360620 )); pts.push_back(Point(14432520, 4236230 )); pts.push_back(Point(13702830, 4236230 )); pts.push_back(Point(13702830, 4352930 )); pts.push_back(Point(13699993, 4391750 )); pts.push_back(Point(13676397, 4448716 )); pts.push_back(Point(13632796, 4492317 )); pts.push_back(Poi
nt(13575830, 4515913 )); pts.push_back(Point(13514169, 4515913 )); pts.push_back(Point(13457203, 4492317 )); pts.push_back(Point(13413602, 4448716 )); pts.push_back(Point(13390006, 4391750 )); pts.push_back(Point(13387030, 4365200 )); pts.push_back(Point(13386900, 4360620 )); pts.push_back(Point(13334170, 4307880 )); pts.push_back(Point(12532990, 4307880 )); pts.push_back(Point(12532990, 4357550 )); pts.push_back(Point(12529993, 4391760 )); pts.push_back(Point(12506397, 4448726 )); pts.push_back(Point(12462796, 4492327 )); pts.push_back(Point(12405830, 4515923 )); pts.push_back(Point(12344169, 4515923 )); pts.push_back(Point(12287203, 4492327 )); pts.push_back(Point(12243602, 4448726 )); pts.push_back(Point(12220006, 4391760 )); pts.push_back(Point(12217970, 4378710 )); pts.push_back(Point(12216810, 4368500 )); pts.push_back(Point(11363190, 4368500 )); pts.push_back(Point(11362030, 4378710 )); pts.push_back(Point(11359983, 4391828 )); pts.push_back(Point(11336388, 4448791 )); pts.push_back(Point(11292791, 44
92388 )); pts.push_back(Point(11235828, 4515983 )); pts.push_back(Point(11174171, 4515983 )); pts.push_back(Point(11117208, 4492388 )); pts.push_back(Point(11096270, 4475670 )); pts.push_back(Point(11092940, 4472520 )); pts.push_back(Point(11057750, 4472520 )); pts.push_back(Point(11053272, 4472961 )); pts.push_back(Point(11044981, 4476396 )); pts.push_back(Point(11038636, 4482741 )); pts.push_back(Point(11035201, 4491032 )); pts.push_back(Point(11035201, 4500007 )); pts.push_back(Point(11038636, 4508298 )); pts.push_back(Point(11041490, 4511780 )); pts.push_back(Point(11573490, 5043780 )); pts.push_back(Point(15655490, 5043780 )); pts.push_back(Point(15904620, 5292900 )); pts.push_back(Point(15909200, 5293030 )); pts.push_back(Point(15935830, 5296006 )); pts.push_back(Point(15992796, 5319602 )); pts.push_back(Point(16036397, 5363203 )); pts.push_back(Point(16059993, 5420169 )); pts.push_back(Point(16059993, 5481830 )); pts.push_back(Point(16036397, 5538796 )); pts.push_back(Point(15992796, 5582397 )); pts.p
ush_back(Point(15935830, 5605993 )); pts.push_back(Point(15874169, 5605993 )); pts.push_back(Point(15817203, 5582397 )); pts.push_back(Point(15773602, 5538796 )); pts.push_back(Point(15750006, 5481830 )); pts.push_back(Point(15747030, 5455200 )); pts.push_back(Point(15746900, 5450620 )); pts.push_back(Point(15563110, 5266820 )); pts.push_back(Point(14857380, 5266820 )); pts.push_back(Point(14857380, 5382430 )); pts.push_back(Point(14869993, 5420179 )); pts.push_back(Point(14869993, 5481840 )); pts.push_back(Point(14846397, 5538806 )); pts.push_back(Point(14802796, 5582407 )); pts.push_back(Point(14745830, 5606003 )); pts.push_back(Point(14684169, 5606003 )); pts.push_back(Point(14627203, 5582407 )); pts.push_back(Point(14583602, 5538806 )); pts.push_back(Point(14560006, 5481840 )); pts.push_back(Point(14557030, 5455200 )); pts.push_back(Point(14556900, 5450620 )); pts.push_back(Point(14444750, 5338460 )); pts.push_back(Point(13702890, 5338460 )); pts.push_back(Point(13702890, 5364400 )); pts.push_back(Point(
13699993, 5401800 )); pts.push_back(Point(13676397, 5458766 )); pts.push_back(Point(13632796, 5502367 )); pts.push_back(Point(13575830, 5525963 )); pts.push_back(Point(13514169, 5525963 )); pts.push_back(Point(13457203, 5502367 )); pts.push_back(Point(13413602, 5458766 )); pts.push_back(Point(13390006, 5401800 )); pts.push_back(Point(13389230, 5397620 )); pts.push_back(Point(13387590, 5388060 )); pts.push_back(Point(12532960, 5388060 )); pts.push_back(Point(12532960, 5446220 )); pts.push_back(Point(12529993, 5481820 )); pts.push_back(Point(12506397, 5538786 )); pts.push_back(Point(12462796, 5582387 )); pts.push_back(Point(12405830, 5605983 )); pts.push_back(Point(12344169, 5605983 )); pts.push_back(Point(12287203, 5582387 )); pts.push_back(Point(12266270, 5565670 )); pts.push_back(Point(12262940, 5562520 )); pts.push_back(Point(11737750, 5562520 )); pts.push_back(Point(11733272, 5562961 )); pts.push_back(Point(11724981, 5566396 )); pts.push_back(Point(11718636, 5572741 )); pts.push_back(Point(11715201, 55810
32 )); pts.push_back(Point(11715201, 5590007 )); pts.push_back(Point(11718636, 5598298 )); pts.push_back(Point(11721500, 5601780 )); pts.push_back(Point(12287760, 6168050 )); pts.push_back(Point(15689760, 6168050 )); pts.push_back(Point(15904620, 6382900 )); pts.push_back(Point(15909200, 6383030 )); pts.push_back(Point(15935830, 6386006 )); pts.push_back(Point(15992796, 6409602 )); pts.push_back(Point(16036397, 6453203 )); pts.push_back(Point(16059993, 6510169 )); pts.push_back(Point(16059993, 6571830 )); pts.push_back(Point(16036397, 6628796 )); pts.push_back(Point(15992796, 6672397 )); pts.push_back(Point(15935830, 6695993 )); pts.push_back(Point(15874169, 6695993 )); pts.push_back(Point(15817203, 6672397 )); pts.push_back(Point(15773602, 6628796 )); pts.push_back(Point(15750006, 6571830 )); pts.push_back(Point(15747030, 6545200 )); pts.push_back(Point(15746900, 6540620 )); pts.push_back(Point(15597380, 6391090 )); pts.push_back(Point(14858060, 6391090 )); pts.push_back(Point(14858060, 6473860 )); pts.push
_back(Point(14869993, 6510179 )); pts.push_back(Point(14869993, 6571840 )); pts.push_back(Point(14846397, 6628806 )); pts.push_back(Point(14802796, 6672407 )); pts.push_back(Point(14745830, 6696003 )); pts.push_back(Point(14684169, 6696003 )); pts.push_back(Point(14627203, 6672407 )); pts.push_back(Point(14583602, 6628806 )); pts.push_back(Point(14560006, 6571840 )); pts.push_back(Point(14557030, 6545200 )); pts.push_back(Point(14556900, 6540620 )); pts.push_back(Point(14479020, 6462730 )); pts.push_back(Point(13702990, 6462730 )); pts.push_back(Point(13702990, 6537170 )); pts.push_back(Point(13700003, 6571840 )); pts.push_back(Point(13676407, 6628806 )); pts.push_back(Point(13632806, 6672407 )); pts.push_back(Point(13575840, 6696003 )); pts.push_back(Point(13514179, 6696003 )); pts.push_back(Point(13457213, 6672407 )); pts.push_back(Point(13413612, 6628806 )); pts.push_back(Point(13390016, 6571840 )); pts.push_back(Point(13387040, 6545550 )); pts.push_back(Point(13386710, 6534380 )); pts.push_back(Point(125
33290, 6534380 )); pts.push_back(Point(12532960, 6545550 )); pts.push_back(Point(12529983, 6571828 )); pts.push_back(Point(12506388, 6628791 )); pts.push_back(Point(12462791, 6672388 )); pts.push_back(Point(12405828, 6695983 )); pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388 )); pts.push_back(Point(12266270, 6655670 ));
+ poly.set(pts.begin(), pts.end());
+ si.insert(poly, 444);
+ result.clear();
+ si.merge(result);
+ si.verify();
+ print(std::cout, si.pmd) << std::endl;
+ if(!result.empty()) {
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ std::vector<Point> outpts;
+ for(typename polygon_set_data<Unit>::iterator_type itr = psd.begin();
+ itr != psd.end(); ++itr) {
+ outpts.push_back((*itr).first.first);
+ outpts.push_back((*itr).first.second);
+ }
+ std::sort(outpts.begin(), outpts.end());
+ for(unsigned int i = 0; i < outpts.size(); i+=2) {
+ if(outpts[i] != outpts[i+1]) {
+ std::cout << "Polygon set not a closed figure\n";
+ std::cout << i << std::endl;
+ std::cout << outpts[i] << " " << outpts[i+1] << std::endl;
+ return 0;
+ }
+ }
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() == 0) {
+ std::cout << "fail merge 10\n";
+ return false;
+ }
+ std::cout << (polys[0]) << std::endl;
}
- if(less_slope(x, y, pt2, pt1)) {
- std::cout << "fail8\n";
+ for(unsigned int i = 0; i < 10; ++i) {
+ std::cout << "random case # " << i << std::endl;
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ polygon_data<Unit> poly1;
+ poly1.set(pts.begin(), pts.end());
+ std::cout << poly1 << std::endl;
+ si.insert(poly1, 444);
+ pts.clear();
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ polygon_data<Unit> poly2;
+ poly2.set(pts.begin(), pts.end());
+ std::cout << poly2 << std::endl;
+ si.insert(poly2, 444);
+ result.clear();
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ if(!result.empty()) {
+ psd = (*(result.begin())).second;
+ std::cout << psd << std::endl;
+ polys.clear();
+ psd.get(polys);
+ if(polys.size() == 0) {
+ si.clear();
+ si.insert(poly1, 333);
+ result.clear();
+ si.merge(result);
+ psd = (*(result.begin())).second;
+ std::vector<polygon_data<Unit> > polys1;
+ psd.get(polys1);
+ si.clear();
+ si.insert(poly2, 333);
+ result.clear();
+ si.merge(result);
+ psd = (*(result.begin())).second;
+ std::vector<polygon_data<Unit> > polys2;
+ psd.get(polys2);
+ if(!polys1.empty() || !polys2.empty()) {
+ std::cout << "fail random merge " << i << std::endl;
+ return false;
+ }
+ }
+ }
+ if(!polys.empty())
+ std::cout << polys.size() << ": " << (polys[0]) << std::endl;
+ }
+ return true;
+ }
+
+ static inline bool check_rectangle_trio(rectangle_data<Unit> rect1, rectangle_data<Unit> rect2, rectangle_data<Unit> rect3) {
+ property_merge si;
+ std::map<std::set<property_type>, polygon_set_data<Unit> > result;
+ std::vector<polygon_data<Unit> > polys;
+ property_merge_90<property_type, Unit> si90;
+ std::map<std::set<property_type>, polygon_90_set_data<Unit> > result90;
+ std::vector<polygon_data<Unit> > polys90;
+ si.insert(rect1, 111);
+ si90.insert(rect1, 111);
+ std::cout << rect1 << std::endl;
+ si.insert(rect2, 222);
+ si90.insert(rect2, 222);
+ std::cout << rect2 << std::endl;
+ si.insert(rect3, 333);
+ si90.insert(rect3, 333);
+ std::cout << rect3 << std::endl;
+ si.merge(result);
+ si90.merge(result90);
+ if(result.size() != result90.size()) {
+ std::cout << "merge failed with size mismatch\n";
+ return 0;
+ }
+ typename std::map<std::set<property_type>, polygon_90_set_data<Unit> >::iterator itr90 = result90.begin();
+ for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result.begin();
+ itr != result.end(); ++itr) {
+ for(typename std::set<property_type>::iterator set_itr = (*itr).first.begin();
+ set_itr != (*itr).first.end(); ++set_itr) {
+ std::cout << (*set_itr) << " ";
+ } std::cout << ") \n";
+ polygon_set_data<Unit> psd = (*itr).second;
+ polygon_90_set_data<Unit> psd90 = (*itr90).second;
+ polys.clear();
+ polys90.clear();
+ psd.get(polys);
+ psd90.get(polys90);
+ if(polys.size() != polys90.size()) {
+ std::cout << "merge failed with polygon count mismatch\n";
+ std::cout << psd << std::endl;
+ for(unsigned int j = 0; j < polys.size(); ++j) {
+ std::cout << polys[j] << std::endl;
+ }
+ std::cout << "reference\n";
+ for(unsigned int j = 0; j < polys90.size(); ++j) {
+ std::cout << polys90[j] << std::endl;
+ }
+ return 0;
+ }
+ bool failed = false;
+ for(unsigned int j = 0; j < polys.size(); ++j) {
+ std::cout << polys[j] << std::endl;
+ std::cout << polys90[j] << std::endl;
+#ifdef __ICC
+#pragma warning (disable:1572)
+#endif
+ if(area(polys[j]) != area(polys90[j])) {
+#ifdef __ICC
+#pragma warning (default:1572)
+#endif
+ std::cout << "merge failed with area mismatch\n";
+ failed = true;
+ }
+ }
+ if(failed) return 0;
+ ++itr90;
+ }
+ return true;
+ }
+
+ static inline bool test_manhattan_intersection() {
+ rectangle_data<Unit> rect1, rect2, rect3;
+ set_points(rect1, (Point(-1, 2)), (Point(1, 4)));
+ set_points(rect2, (Point(-1, 2)), (Point(2, 3)));
+ set_points(rect3, (Point(-3, 0)), (Point(4, 2)));
+ if(!check_rectangle_trio(rect1, rect2, rect3)) {
return false;
}
+ for(unsigned int i = 0; i < 100; ++i) {
+ property_merge si;
+ std::map<std::set<property_type>, polygon_set_data<Unit> > result;
+ std::vector<polygon_data<Unit> > polys;
+ property_merge_90<property_type, Unit> si90;
+ std::map<std::set<property_type>, polygon_90_set_data<Unit> > result90;
+ std::vector<polygon_data<Unit> > polys90;
+ std::cout << "random case # " << i << std::endl;
+ set_points(rect1, (Point(rand()%9-4, rand()%9-4)), (Point(rand()%9-4, rand()%9-4)));
+ set_points(rect2, (Point(rand()%9-4, rand()%9-4)), (Point(rand()%9-4, rand()%9-4)));
+ set_points(rect3, (Point(rand()%9-4, rand()%9-4)), (Point(rand()%9-4, rand()%9-4)));
+ if(!check_rectangle_trio(rect1, rect2, rect3)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ static inline bool test_intersection() {
+ property_merge si;
+ rectangle_data<Unit> rect;
+ xl(rect, 0);
+ yl(rect, 10);
+ xh(rect, 30);
+ yh(rect, 20);
+ si.insert(rect, 333);
+ xl(rect, 10);
+ yl(rect, 0);
+ xh(rect, 20);
+ yh(rect, 30);
+ si.insert(rect, 444);
+ xl(rect, 15);
+ yl(rect, 0);
+ xh(rect, 25);
+ yh(rect, 30);
+ si.insert(rect, 555);
+ std::map<std::set<property_type>, polygon_set_data<Unit> > result;
+ si.merge(result);
+ print(std::cout, si.pmd) << std::endl;
+ for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result.begin();
+ itr != result.end(); ++itr) {
+ std::cout << "( ";
+ for(typename std::set<property_type>::iterator set_itr = (*itr).first.begin();
+ set_itr != (*itr).first.end(); ++set_itr) {
+ std::cout << (*set_itr) << " ";
+ } std::cout << ") \n";
+ polygon_set_data<Unit> psd = (*itr).second;
+ std::cout << psd << std::endl;
+ std::vector<polygon_data<Unit> > polys;
+ psd.get(polys);
+ for(unsigned int i = 0; i < polys.size(); ++i) {
+ std::cout << polys[i] << std::endl;
+ }
+ }
+ std::vector<Point> pts;
+ std::vector<polygon_data<Unit> > polys;
+ for(unsigned int i = 0; i < 10; ++i) {
+ property_merge si2;
+ std::cout << "random case # " << i << std::endl;
+ si.clear();
+ pts.clear();
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ polygon_data<Unit> poly1;
+ poly1.set(pts.begin(), pts.end());
+ std::cout << poly1 << std::endl;
+ si.insert(poly1, 444);
+ si2.insert(poly1, 333);
+ pts.clear();
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ polygon_data<Unit> poly2;
+ poly2.set(pts.begin(), pts.end());
+ std::cout << poly2 << std::endl;
+ si.insert(poly2, 444);
+ si2.insert(poly2, 444);
+ pts.clear();
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ pts.push_back(Point(rand()%9-4, rand()%9-4));
+ polygon_data<Unit> poly3;
+ poly3.set(pts.begin(), pts.end());
+ std::cout << poly3 << std::endl;
+ si.insert(poly3, 444);
+ si2.insert(poly3, 555);
+ result.clear();
+ std::map<std::set<property_type>, polygon_set_data<Unit> > result2;
+ si.merge(result);
+ si2.merge(result2);
+ std::cout << "merged result\n";
+ for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result.begin();
+ itr != result.end(); ++itr) {
+ std::cout << "( ";
+ for(typename std::set<property_type>::iterator set_itr = (*itr).first.begin();
+ set_itr != (*itr).first.end(); ++set_itr) {
+ std::cout << (*set_itr) << " ";
+ } std::cout << ") \n";
+ polygon_set_data<Unit> psd = (*itr).second;
+ std::cout << psd << std::endl;
+ std::vector<polygon_data<Unit> > polys2;
+ psd.get(polys2);
+ for(unsigned int ii = 0; ii < polys2.size(); ++ii) {
+ std::cout << polys2[ii] << std::endl;
+ }
+ }
+ std::cout << "intersected pmd\n";
+ print(std::cout, si2.pmd) << std::endl;
+ std::cout << "intersected result\n";
+ for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result2.begin();
+ itr != result2.end(); ++itr) {
+ std::cout << "( ";
+ for(typename std::set<property_type>::iterator set_itr = (*itr).first.begin();
+ set_itr != (*itr).first.end(); ++set_itr) {
+ std::cout << (*set_itr) << " ";
+ } std::cout << ") \n";
+ polygon_set_data<Unit> psd = (*itr).second;
+ std::cout << psd << std::endl;
+ std::vector<polygon_data<Unit> > polys2;
+ psd.get(polys2);
+ for(unsigned int ii = 0; ii < polys2.size(); ++ii) {
+ std::cout << polys2[ii] << std::endl;
+ }
+ }
+ si.clear();
+ for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result2.begin();
+ itr != result2.end(); ++itr) {
+ polys.clear();
+ (*itr).second.get(polys);
+ for(unsigned int j = 0; j < polys.size(); ++j) {
+ si.insert(polys[j], 444);
+ }
+ }
+ result2.clear();
+ si.merge(result2);
+ std::cout << "remerged result\n";
+ for(typename std::map<std::set<property_type>, polygon_set_data<Unit> >::iterator itr = result2.begin();
+ itr != result2.end(); ++itr) {
+ std::cout << "( ";
+ for(typename std::set<property_type>::iterator set_itr = (*itr).first.begin();
+ set_itr != (*itr).first.end(); ++set_itr) {
+ std::cout << (*set_itr) << " ";
+ } std::cout << ") \n";
+ polygon_set_data<Unit> psd = (*itr).second;
+ std::cout << psd << std::endl;
+ std::vector<polygon_data<Unit> > polys2;
+ psd.get(polys2);
+ for(unsigned int ii = 0; ii < polys2.size(); ++ii) {
+ std::cout << polys2[ii] << std::endl;
+ }
+ }
+ std::vector<polygon_data<Unit> > polys2;
+ polys.clear();
+ (*(result.begin())).second.get(polys);
+ (*(result2.begin())).second.get(polys2);
+ if(!(polys == polys2)) {
+ std::cout << "failed intersection check # " << i << std::endl;
+ return false;
+ }
+ }
return true;
}
+ };
+
+ template <typename Unit>
+ class arbitrary_boolean_op : public scanline_base<Unit> {
+ private:
+
+ typedef int property_type;
+ typedef typename scanline_base<Unit>::Point Point;
+
+ //the first point is the vertex and and second point establishes the slope of an edge eminating from the vertex
+ //typedef std::pair<Point, Point> half_edge;
+ typedef typename scanline_base<Unit>::half_edge half_edge;
+
+ //scanline comparator functor
+ typedef typename scanline_base<Unit>::less_half_edge less_half_edge;
+ typedef typename scanline_base<Unit>::less_point less_point;
+
+ //this data structure assocates a property and count to a half edge
+ typedef std::pair<half_edge, std::pair<property_type, int> > vertex_property;
+ //this data type stores the combination of many half edges
+ typedef std::vector<vertex_property> property_merge_data;
+
+ //this is the data type used internally to store the combination of property counts at a given location
+ typedef std::vector<std::pair<property_type, int> > property_map;
+ //this data type is used internally to store the combined property data for a given half edge
+ typedef std::pair<half_edge, property_map> vertex_data;
+
+ property_merge_data pmd;
+
+ template<typename vertex_data_type>
+ class less_vertex_data {
+ public:
+ less_vertex_data() {}
+ bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) {
+ less_point lp;
+ if(lp(lvalue.first.first, rvalue.first.first)) return true;
+ if(lp(rvalue.first.first, lvalue.first.first)) return false;
+ Unit x = lvalue.first.first.get(HORIZONTAL);
+ int just_before_ = 0;
+ less_half_edge lhe(&x, &just_before_);
+ return lhe(lvalue.first, rvalue.first);
+ }
+ };
+
+ template <typename result_type, typename key_type, int op_type>
+ class boolean_output_functor {
+ public:
+ boolean_output_functor() {}
+ void operator()(result_type& result, const half_edge& edge, const key_type& left, const key_type& right) {
+ typename std::pair<half_edge, int> elem;
+ elem.first = edge;
+ elem.second = 1;
+ if(edge.second < edge.first) elem.second *= -1;
+ if(is_vertical(edge)) elem.second *= -1;
+ if(op_type == 0) { //OR
+ if(!left.empty() && right.empty()) {
+ result.insert_clean(elem);
+ } else if(!right.empty() && left.empty()) {
+ elem.second *= -1;
+ result.insert_clean(elem);
+ }
+ } else if(op_type == 1) { //AND
+ if(left.size() == 2 && right.size() != 2) {
+ result.insert_clean(elem);
+ } else if(right.size() == 2 && left.size() != 2) {
+ elem.second *= -1;
+ result.insert_clean(elem);
+ }
+ } else if(op_type == 2) { //XOR
+ if(left.size() == 1 && right.size() != 1) {
+ result.insert_clean(elem);
+ } else if(right.size() == 1 && left.size() != 1) {
+ elem.second *= -1;
+ result.insert_clean(elem);
+ }
+ } else { //SUBTRACT
+ if(left.size() == 1) {
+ if((*(left.begin())) == 0) {
+ result.insert_clean(elem);
+ }
+ }
+ if(right.size() == 1) {
+ if((*(right.begin())) == 0) {
+ elem.second *= -1;
+ result.insert_clean(elem);
+ }
+ }
+ }
+ }
+ };
+
+ inline void sort_property_merge_data() {
+ less_vertex_data<vertex_property> lvd;
+ std::sort(pmd.begin(), pmd.end(), lvd);
+ }
+ public:
+ inline arbitrary_boolean_op() {}
+ inline arbitrary_boolean_op(const arbitrary_boolean_op& pm) : pmd(pm.pmd) {}
+ inline arbitrary_boolean_op& operator=(const arbitrary_boolean_op& pm) { pmd = pm.pmd; return *this; }
+
+ enum BOOLEAN_OP_TYPE {
+ BOOLEAN_OR = 0,
+ BOOLEAN_AND = 1,
+ BOOLEAN_XOR = 2,
+ BOOLEAN_NOT = 3
+ };
+ template <typename result_type, typename iT1, typename iT2>
+ inline void execute(result_type& result, iT1 b1, iT1 e1, iT2 b2, iT2 e2, int op) {
+ //intersect data
+ insert(b1, e1, 0);
+ insert(b2, e2, 1);
+ property_merge_data tmp_pmd;
+ line_intersection<Unit>::validate_scan(tmp_pmd, pmd.begin(), pmd.end());
+ pmd.swap(tmp_pmd);
+ sort_property_merge_data();
+ scanline<Unit, property_type, std::vector<property_type> > sl;
+ if(op == BOOLEAN_OR) {
+ boolean_output_functor<result_type, std::vector<property_type>, 0> bof;
+ sl.scan(result, bof, pmd.begin(), pmd.end());
+ } else if(op == BOOLEAN_AND) {
+ boolean_output_functor<result_type, std::vector<property_type>, 1> bof;
+ sl.scan(result, bof, pmd.begin(), pmd.end());
+ } else if(op == BOOLEAN_XOR) {
+ boolean_output_functor<result_type, std::vector<property_type>, 2> bof;
+ sl.scan(result, bof, pmd.begin(), pmd.end());
+ } else if(op == BOOLEAN_NOT) {
+ boolean_output_functor<result_type, std::vector<property_type>, 3> bof;
+ sl.scan(result, bof, pmd.begin(), pmd.end());
+ }
+ }
+
+ inline void clear() {*this = arbitrary_boolean_op();}
+
+ private:
+ template <typename iT>
+ void insert(iT b, iT e, int id) {
+ for(;
+ b != e; ++b) {
+ pmd.push_back(vertex_property(half_edge((*b).first.first, (*b).first.second),
+ std::pair<property_type, int>(id, (*b).second)));
+ }
+ }
};
+ template <typename Unit>
+ bool test_arbitrary_boolean_op() {
+ polygon_set_data<Unit> psd;
+ rectangle_data<Unit> rect;
+ set_points(rect, point_data<Unit>(0, 0), point_data<Unit>(10, 10));
+ psd.insert(rect);
+ polygon_set_data<Unit> psd2;
+ set_points(rect, point_data<Unit>(5, 5), point_data<Unit>(15, 15));
+ psd2.insert(rect);
+ std::vector<polygon_data<Unit> > pv;
+ pv.clear();
+ arbitrary_boolean_op<Unit> abo;
+ polygon_set_data<Unit> psd3;
+ abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_OR);
+ psd3.get(pv);
+ for(unsigned int i = 0; i < pv.size(); ++i) {
+ std::cout << pv[i] << std::endl;
+ }
+ pv.clear();
+ abo.clear();
+ psd3.clear();
+ abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_AND);
+ psd3.get(pv);
+ for(unsigned int i = 0; i < pv.size(); ++i) {
+ std::cout << pv[i] << std::endl;
+ }
+ pv.clear();
+ abo.clear();
+ psd3.clear();
+ abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_XOR);
+ psd3.get(pv);
+ for(unsigned int i = 0; i < pv.size(); ++i) {
+ std::cout << pv[i] << std::endl;
+ }
+ pv.clear();
+ abo.clear();
+ psd3.clear();
+ abo.execute(psd3, psd.begin(), psd.end(), psd2.begin(), psd2.end(), arbitrary_boolean_op<Unit>::BOOLEAN_NOT);
+ psd3.get(pv);
+ for(unsigned int i = 0; i < pv.size(); ++i) {
+ std::cout << pv[i] << std::endl;
+ }
+ return true;
+ }
+
+
}
#endif
Added: sandbox/gtl/gtl/transform.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/transform.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,486 @@
+/*
+ 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 GTL_TRANSFORM_HPP
+#define GTL_TRANSFORM_HPP
+
+namespace gtl {
+/// Transformation of Coordinate Systems
+/// Enum meaning:
+/// Select which direction_3d to change the positive direction of each
+/// axis in the old coordinate system to map it to the new coordiante system.
+/// The first direction_3d listed for each enum is the direction to map the
+/// positive horizontal direction to.
+/// The second direction_3d listed for each enum is the direction to map the
+/// positive vertical direction to.
+/// The third direction_3d listed for each enum is the direction to map the
+/// positive proximal direction to.
+/// The zero position bit (LSB) indicates whether the horizontal axis flips
+/// when transformed.
+/// The 1st postion bit indicates whether the vertical axis flips when
+/// transformed.
+/// The 2nd position bit indicates whether the horizontal and vertical axis
+/// swap positions when transformed.
+/// Note that the first eight values are the complete set of 2D transforms.
+/// The 3rd position bit indicates whether the proximal axis flips when
+/// transformed.
+/// The 4th position bit indicates whether the proximal and horizontal axis are
+/// swapped when transformed. It changes the meaning of the 2nd position bit
+/// to mean that the horizontal and vertical axis are swapped in their new
+/// positions, naturally.
+/// The 5th position bit (MSB) indicates whether the proximal and vertical axis
+/// are swapped when transformed. It is mutually exclusive with the 4th postion
+/// bit, making the maximum legal value 48 (decimal). It similarly changes the
+/// meaning of the 2nd position bit to mean that the horizontal and vertical are
+/// swapped in their new positions.
+/// Enum Values:
+/// 000000 EAST NORTH UP
+/// 000001 WEST NORTH UP
+/// 000010 EAST SOUTH UP
+/// 000011 WEST SOUTH UP
+/// 000100 NORTH EAST UP
+/// 000101 SOUTH EAST UP
+/// 000110 NORTH WEST UP
+/// 000111 SOUTH WEST UP
+/// 001000 EAST NORTH DOWN
+/// 001001 WEST NORTH DOWN
+/// 001010 EAST SOUTH DOWN
+/// 001011 WEST SOUTH DOWN
+/// 001100 NORTH EAST DOWN
+/// 001101 SOUTH EAST DOWN
+/// 001110 NORTH WEST DOWN
+/// 001111 SOUTH WEST DOWN
+/// 010000 UP NORTH EAST
+/// 010001 DOWN NORTH EAST
+/// 010010 UP SOUTH EAST
+/// 010011 DOWN SOUTH EAST
+/// 010100 NORTH UP EAST
+/// 010101 SOUTH UP EAST
+/// 010110 NORTH DOWN EAST
+/// 010111 SOUTH DOWN EAST
+/// 011000 UP NORTH WEST
+/// 011001 DOWN NORTH WEST
+/// 011010 UP SOUTH WEST
+/// 011011 DOWN SOUTH WEST
+/// 011100 NORTH UP WEST
+/// 011101 SOUTH UP WEST
+/// 011110 NORTH DOWN WEST
+/// 011111 SOUTH DOWN WEST
+/// 100000 EAST UP NORTH
+/// 100001 WEST UP NORTH
+/// 100010 EAST DOWN NORTH
+/// 100011 WEST DOWN NORTH
+/// 100100 UP EAST NORTH
+/// 100101 DOWN EAST NORTH
+/// 100110 UP WEST NORTH
+/// 100111 DOWN WEST NORTH
+/// 101000 EAST UP SOUTH
+/// 101001 WEST UP SOUTH
+/// 101010 EAST DOWN SOUTH
+/// 101011 WEST DOWN SOUTH
+/// 101100 UP EAST SOUTH
+/// 101101 DOWN EAST SOUTH
+/// 101110 UP WEST SOUTH
+/// 101111 DOWN WEST SOUTH
+class axis_transformation {
+public:
+ /// Enum Names and values
+ /// NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
+ /// ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0,
+ /// WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X = 1,
+ /// ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y = 2,
+ /// WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3,
+ /// NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY = 4,
+ /// SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5,
+ /// NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6,
+ /// SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7,
+ /// END_2D_TRANSFORM = 7,
+ /// END = 8, EAST_NORTH_DOWN = 8,
+ /// WND = 9, WEST_NORTH_DOWN = 9,
+ /// ESD = 10, EAST_SOUTH_DOWN = 10,
+ /// WSD = 11, WEST_SOUTH_DOWN = 11,
+ /// NED = 12, NORTH_EAST_DOWN = 12,
+ /// SED = 13, SOUTH_EAST_DOWN = 13,
+ /// NWD = 14, NORTH_WEST_DOWN = 14,
+ /// SWD = 15, SOUTH_WEST_DOWN = 15,
+ /// UNE = 16, UP_NORTH_EAST = 16,
+ /// DNE = 17, DOWN_NORTH_EAST = 17,
+ /// USE = 18, UP_SOUTH_EAST = 18,
+ /// DSE = 19, DOWN_SOUTH_EAST = 19,
+ /// NUE = 20, NORTH_UP_EAST = 20,
+ /// SUE = 21, SOUTH_UP_EAST = 21,
+ /// NDE = 22, NORTH_DOWN_EAST = 22,
+ /// SDE = 23, SOUTH_DOWN_EAST = 23,
+ /// UNW = 24, UP_NORTH_WEST = 24,
+ /// DNW = 25, DOWN_NORTH_WEST = 25,
+ /// USW = 26, UP_SOUTH_WEST = 26,
+ /// DSW = 27, DOWN_SOUTH_WEST = 27,
+ /// NUW = 28, NORTH_UP_WEST = 28,
+ /// SUW = 29, SOUTH_UP_WEST = 29,
+ /// NDW = 30, NORTH_DOWN_WEST = 30,
+ /// SDW = 31, SOUTH_DOWN_WEST = 31,
+ /// EUN = 32, EAST_UP_NORTH = 32,
+ /// WUN = 33, WEST_UP_NORTH = 33,
+ /// EDN = 34, EAST_DOWN_NORTH = 34,
+ /// WDN = 35, WEST_DOWN_NORTH = 35,
+ /// UEN = 36, UP_EAST_NORTH = 36,
+ /// DEN = 37, DOWN_EAST_NORTH = 37,
+ /// UWN = 38, UP_WEST_NORTH = 38,
+ /// DWN = 39, DOWN_WEST_NORTH = 39,
+ /// EUS = 40, EAST_UP_SOUTH = 40,
+ /// WUS = 41, WEST_UP_SOUTH = 41,
+ /// EDS = 42, EAST_DOWN_SOUTH = 42,
+ /// WDS = 43, WEST_DOWN_SOUTH = 43,
+ /// UES = 44, UP_EAST_SOUTH = 44,
+ /// DES = 45, DOWN_EAST_SOUTH = 45,
+ /// UWS = 46, UP_WEST_SOUTH = 46,
+ /// DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47
+ enum ATR {
+ NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
+ ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0,
+ WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X = 1,
+ ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y = 2,
+ WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3, FLIP_XY = 3,
+ NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY = 4,
+ SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5, ROTATE_LEFT = 5,
+ NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6, ROTATE_RIGHT = 6,
+ SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7, FLIP_SWAP_XY = 7, END_2D_TRANSFORM = 7,
+ END = 8, EAST_NORTH_DOWN = 8, FLIP_Z = 8,
+ WND = 9, WEST_NORTH_DOWN = 9,
+ ESD = 10, EAST_SOUTH_DOWN = 10,
+ WSD = 11, WEST_SOUTH_DOWN = 11,
+ NED = 12, NORTH_EAST_DOWN = 12,
+ SED = 13, SOUTH_EAST_DOWN = 13,
+ NWD = 14, NORTH_WEST_DOWN = 14,
+ SWD = 15, SOUTH_WEST_DOWN = 15,
+ UNE = 16, UP_NORTH_EAST = 16,
+ DNE = 17, DOWN_NORTH_EAST = 17,
+ USE = 18, UP_SOUTH_EAST = 18,
+ DSE = 19, DOWN_SOUTH_EAST = 19,
+ NUE = 20, NORTH_UP_EAST = 20,
+ SUE = 21, SOUTH_UP_EAST = 21,
+ NDE = 22, NORTH_DOWN_EAST = 22,
+ SDE = 23, SOUTH_DOWN_EAST = 23,
+ UNW = 24, UP_NORTH_WEST = 24,
+ DNW = 25, DOWN_NORTH_WEST = 25,
+ USW = 26, UP_SOUTH_WEST = 26,
+ DSW = 27, DOWN_SOUTH_WEST = 27,
+ NUW = 28, NORTH_UP_WEST = 28,
+ SUW = 29, SOUTH_UP_WEST = 29,
+ NDW = 30, NORTH_DOWN_WEST = 30,
+ SDW = 31, SOUTH_DOWN_WEST = 31,
+ EUN = 32, EAST_UP_NORTH = 32,
+ WUN = 33, WEST_UP_NORTH = 33,
+ EDN = 34, EAST_DOWN_NORTH = 34,
+ WDN = 35, WEST_DOWN_NORTH = 35,
+ UEN = 36, UP_EAST_NORTH = 36,
+ DEN = 37, DOWN_EAST_NORTH = 37,
+ UWN = 38, UP_WEST_NORTH = 38,
+ DWN = 39, DOWN_WEST_NORTH = 39,
+ EUS = 40, EAST_UP_SOUTH = 40,
+ WUS = 41, WEST_UP_SOUTH = 41,
+ EDS = 42, EAST_DOWN_SOUTH = 42,
+ WDS = 43, WEST_DOWN_SOUTH = 43,
+ UES = 44, UP_EAST_SOUTH = 44,
+ DES = 45, DOWN_EAST_SOUTH = 45,
+ UWS = 46, UP_WEST_SOUTH = 46,
+ DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47
+ };
+
+ // Individual axis enum values indicate which axis an implicit individual
+ // axis will be mapped to.
+ // The value of the enum paired with an axis provides the information
+ // about what the axis will transform to.
+ // Three individual axis values, one for each axis, are equivalent to one
+ // ATR enum value, but easier to work with because they are independent.
+ // Converting to and from the individual axis values from the ATR value
+ // is a convenient way to implement tranformation related functionality.
+ // Enum meanings:
+ // PX: map to positive x axis
+ // NX: map to negative x axis
+ // PY: map to positive y axis
+ // NY: map to negative y axis
+ // PZ: map to positive z axis
+ // NZ: map to negative z axis
+ enum INDIVIDUAL_AXIS {
+ PX = 0,
+ NX = 1,
+ PY = 2,
+ NY = 3,
+ PZ = 4,
+ NZ = 5
+ };
+
+ inline axis_transformation() : atr_(NULL_TRANSFORM) {}
+ inline axis_transformation(ATR atr) : atr_(atr) {}
+ inline axis_transformation(const axis_transformation& atr) : atr_(atr.atr_) {}
+ explicit axis_transformation(const orientation_3d& orient);
+ explicit axis_transformation(const direction_3d& dir);
+ explicit axis_transformation(const orientation_2d& orient);
+ explicit axis_transformation(const direction_2d& dir);
+
+ /// assignment operator
+ axis_transformation& operator=(const axis_transformation& a);
+
+ /// assignment operator
+ axis_transformation& operator=(const ATR& atr);
+
+ /// equivalence operator
+ bool operator==(const axis_transformation& a) const;
+
+ /// inequivalence operator
+ bool operator!=(const axis_transformation& a) const;
+
+ /// ordering
+ bool operator<(const axis_transformation& a) const;
+
+ /// concatenation operator
+ axis_transformation operator+(const axis_transformation& a) const;
+
+ /// concatenate this with that
+ axis_transformation& operator+=(const axis_transformation& a);
+
+ /// populate_axis_array writes the three INDIVIDUAL_AXIS values that the
+ /// ATR enum value of 'this' represent into axis_array
+ void populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const;
+
+ /// it is recommended that the directions stored in an array
+ /// in the caller code for easier isotropic access by orientation value
+ inline void get_directions(direction_2d& horizontal_dir,
+ direction_2d& vertical_dir) const {
+ bool bit2 = atr_ & 4;
+ bool bit1 = atr_ & 2;
+ bool bit0 = atr_ & 1;
+ vertical_dir = direction_2d((direction_2d_enum)(((int)(!bit2) << 1) + !bit1));
+ horizontal_dir = direction_2d((direction_2d_enum)(((int)(bit2) << 1) + !bit0));
+ }
+
+ /// it is recommended that the directions stored in an array
+ /// in the caller code for easier isotropic access by orientation value
+ inline void get_directions(direction_3d& horizontal_dir,
+ direction_3d& vertical_dir,
+ direction_3d& proximal_dir) const {
+ bool bit5 = atr_ & 32;
+ bool bit4 = atr_ & 16;
+ bool bit3 = atr_ & 8;
+ bool bit2 = atr_ & 4;
+ bool bit1 = atr_ & 2;
+ bool bit0 = atr_ & 1;
+ proximal_dir = direction_3d((direction_2d_enum)((((int)(!bit4 & !bit5)) << 2) +
+ ((int)(bit5) << 1) +
+ !bit3));
+ vertical_dir = direction_3d((direction_2d_enum)((((int)((bit4 & bit2) | (bit5 & !bit2))) << 2)+
+ ((int)(!bit5 & !bit2) << 1) +
+ !bit1));
+ horizontal_dir = direction_3d((direction_2d_enum)((((int)((bit5 & bit2) |
+ (bit4 & !bit2))) << 2) +
+ ((int)(bit2 & !bit5) << 1) +
+ !bit0));
+ }
+
+ /// combine_axis_arrays concatenates this_array and that_array overwriting
+ /// the result into this_array
+ static void combine_axis_arrays (INDIVIDUAL_AXIS this_array[],
+ const INDIVIDUAL_AXIS that_array[]);
+
+ // write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
+ // to the ATR enum value and sets 'this' to that value
+ void write_back_axis_array(const INDIVIDUAL_AXIS this_array[]);
+
+ // behavior is deterministic but undefined in the case where illegal
+ // combinations of directions are passed in.
+ axis_transformation& set_directions(const direction_2d& horizontal_dir,
+ const direction_2d& vertical_dir);
+ // behavior is deterministic but undefined in the case where illegal
+ // combinations of directions are passed in.
+ axis_transformation& set_directions(const direction_3d& horizontal_dir,
+ const direction_3d& vertical_dir,
+ const direction_3d& proximal_dir);
+
+ /// transform the two coordinates by reference using the 2D portion of this
+ template <typename coordinate_type>
+ void transform(coordinate_type& x, coordinate_type& y) const;
+
+ /// transform the three coordinates by reference
+ template <typename coordinate_type>
+ void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;
+
+ /// invert the 2D portion of this
+ axis_transformation& invert_2d();
+
+ /// get the inverse of the 2D portion of this
+ axis_transformation inverse_2d() const;
+
+ /// invert this axis_transformation
+ axis_transformation& invert();
+
+ /// get the inverse axis_transformation of this
+ axis_transformation inverse() const;
+
+ friend std::ostream& operator<< (std::ostream& o, const axis_transformation& r);
+ friend std::istream& operator>> (std::istream& i, axis_transformation& r);
+
+private:
+ ATR atr_;
+};
+
+
+/// Scaling object to be used to store the scale factor for each axis
+
+/// For use by the transformation object, in that context the scale factor
+/// is the amount that each axis scales by when transformed.
+/// If the horizontal value of the Scale is 10 that means the horizontal
+/// axis of the input is multiplied by 10 when the transformation is applied.
+template <typename scale_factor_type>
+class anisotropic_scale_factor {
+public:
+ inline anisotropic_scale_factor() {
+ scale_[0] = 1;
+ scale_[1] = 1;
+ scale_[2] = 1;
+ }
+ inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale) {
+ scale_[0] = xscale;
+ scale_[1] = yscale;
+ scale_[2] = 1;
+ }
+ inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale, scale_factor_type zscale) {
+ scale_[0] = xscale;
+ scale_[1] = yscale;
+ scale_[2] = zscale;
+ }
+
+ /// get a component of the anisotropic_scale_factor by orientation
+ scale_factor_type get(orientation_3d orient) const;
+ scale_factor_type get(orientation_2d orient) const { return get(orientation_3d(orient)); }
+
+ /// set a component of the anisotropic_scale_factor by orientation
+ void set(orientation_3d orient, scale_factor_type value);
+ void set(orientation_2d orient, scale_factor_type value) { set(orientation_3d(orient), value); }
+
+ scale_factor_type x() const;
+ scale_factor_type y() const;
+ scale_factor_type z() const;
+ void x(scale_factor_type value);
+ void y(scale_factor_type value);
+ void z(scale_factor_type value);
+
+ /// concatination operator (convolve scale factors)
+ anisotropic_scale_factor operator+(const anisotropic_scale_factor& s) const;
+
+ /// concatinate this with that
+ const anisotropic_scale_factor& operator+=(const anisotropic_scale_factor& s);
+
+ /// transform this scale with an axis_transform
+ anisotropic_scale_factor& transform(axis_transformation atr);
+
+ /// scale the two coordinates
+ template <typename coordinate_type>
+ void scale(coordinate_type& x, coordinate_type& y) const;
+
+ /// scale the three coordinates
+ template <typename coordinate_type>
+ void scale(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;
+
+ /// invert this scale factor to give the reverse scale factor
+ anisotropic_scale_factor& invert();
+
+private:
+ scale_factor_type scale_[3];
+
+ //friend std::ostream& operator<< (std::ostream& o, const Scale& r);
+ //friend std::istream& operator>> (std::istream& i, Scale& r);
+};
+
+/// Transformation object, stores and provides services for transformations
+
+/// Transformation object stores an axistransformation, a scale factor and a translation.
+/// The tranlation is the position of the origin of the new system of coordinates in the old system.
+/// The scale scales the coordinates before they are transformed.
+template <typename coordinate_type>
+class transformation {
+public:
+ transformation();
+ transformation(axis_transformation atr);
+ template <typename point_type>
+ transformation(const point_type& p);
+ template <typename point_type>
+ transformation(axis_transformation atr, const point_type& p);
+ template <typename point_type>
+ transformation(axis_transformation atr, const point_type& referencePt, const point_type& destinationPt);
+ transformation(const transformation& tr);
+
+ /// equivalence operator
+ bool operator==(const transformation& tr) const;
+
+ /// inequivalence operator
+ bool operator!=(const transformation& tr) const;
+
+ /// ordering
+ bool operator<(const transformation& tr) const;
+
+ /// concatenation operator
+ transformation operator+(const transformation& tr) const;
+
+ /// concatenate this with that
+ const transformation& operator+=(const transformation& tr);
+
+ /// get the axis_transformation portion of this
+ inline axis_transformation get_axis_transformation() const {return atr_;}
+
+ /// set the axis_transformation portion of this
+ void set_axis_transformation(const axis_transformation& atr);
+
+ /// get the translation portion of this as a point3d
+ template <typename point_type>
+ void get_translation(point_type& translation) const;
+
+ /// set the translation portion of this with a point3d
+ template <typename point_type>
+ void set_translation(const point_type& p);
+
+ /// apply the 2D portion of this transformation to the two coordinates given
+ void transform(coordinate_type& x, coordinate_type& y) const;
+
+ /// apply this transformation to the three coordinates given
+ void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;
+
+ /// invert this transformation
+ transformation& invert();
+
+ /// get the inverse of this transformation
+ transformation inverse() const;
+
+ inline void get_directions(direction_2d& horizontal_dir,
+ direction_2d& vertical_dir) const {
+ return atr_.get_directions(horizontal_dir, vertical_dir); }
+
+ inline void get_directions(direction_3d& horizontal_dir,
+ direction_3d& vertical_dir,
+ direction_3d& proximal_dir) const {
+ return atr_.get_directions(horizontal_dir, vertical_dir, proximal_dir); }
+
+private:
+ axis_transformation atr_;
+ point_3d_data<coordinate_type> p_;
+
+ template <typename point_type>
+ void construct_dispatch(axis_transformation atr, point_type p, point_concept tag);
+ template <typename point_type>
+ void construct_dispatch(axis_transformation atr, point_type p, point_3d_concept tag);
+ template <typename point_type>
+ void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_concept tag);
+ template <typename point_type>
+ void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_3d_concept tag);
+
+ //friend std::ostream& operator<< (std::ostream& o, const transformation& tr);
+ //friend std::istream& operator>> (std::istream& i, transformation& tr);
+};
+
+}
+#endif
+
Added: sandbox/gtl/gtl/transform_detail.hpp
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/transform_detail.hpp 2009-01-08 12:02:09 EST (Thu, 08 Jan 2009)
@@ -0,0 +1,550 @@
+/*
+ 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 GTL_TRANSFORM_DETAIL_HPP
+#define GTL_TRANSFORM_DETAIL_HPP
+
+namespace gtl {
+// inline std::ostream& operator<< (std::ostream& o, const axis_transformation& r) {
+// o << r.atr_;
+// return o;
+// }
+
+// inline std::istream& operator>> (std::istream& i, axis_transformation& r) {
+// int tmp;
+// i >> tmp;
+// r = axis_transformation((axis_transformation::ATR)tmp);
+// return i;
+// }
+
+// template <typename scale_factor_type>
+// inline std::ostream& operator<< (std::ostream& o, const anisotropic_scale_factor<scale_factor_type>& sc) {
+// o << sc.scale_[0] << GTL_SEP << sc.scale_[1] << GTL_SEP << sc.scale_[2];
+// return o;
+// }
+
+// template <typename scale_factor_type>
+// inline std::istream& operator>> (std::istream& i, anisotropic_scale_factor<scale_factor_type>& sc) {
+// i >> sc.scale_[0] >> sc.scale_[1] >> sc.scale_[2];
+// return i;
+// }
+
+// template <typename coordinate_type>
+// inline std::ostream& operator<< (std::ostream& o, const transformation& tr) {
+// o << tr.atr_ << GTL_SEP << tr.p_;
+// return o;
+// }
+
+// template <typename coordinate_type>
+// inline std::istream& operator>> (std::istream& i, transformation& tr) {
+// i >> tr.atr_ >> tr.p_;
+// return i;
+// }
+
+
+inline axis_transformation::axis_transformation(const orientation_3d& orient) {
+ const ATR tmp[3] = {
+ UP_EAST_NORTH, //sort by x, then z, then y
+ EAST_UP_NORTH, //sort by y, then z, then x
+ EAST_NORTH_UP //sort by z, then y, then x
+ };
+ atr_ = tmp[orient.to_int()];
+}
+
+inline axis_transformation::axis_transformation(const orientation_2d& orient) {
+ const ATR tmp[3] = {
+ NORTH_EAST_UP, //sort by z, then x, then y
+ EAST_NORTH_UP //sort by z, then y, then x
+ };
+ atr_ = tmp[orient.to_int()];
+}
+
+inline axis_transformation::axis_transformation(const direction_3d& dir) {
+ const ATR tmp[6] = {
+ DOWN_EAST_NORTH, //sort by -x, then z, then y
+ UP_EAST_NORTH, //sort by x, then z, then y
+ EAST_DOWN_NORTH, //sort by -y, then z, then x
+ EAST_UP_NORTH, //sort by y, then z, then x
+ EAST_NORTH_DOWN, //sort by -z, then y, then x
+ EAST_NORTH_UP //sort by z, then y, then x
+ };
+ atr_ = tmp[dir.to_int()];
+}
+
+inline axis_transformation::axis_transformation(const direction_2d& dir) {
+ const ATR tmp[4] = {
+ SOUTH_EAST_UP, //sort by z, then x, then y
+ NORTH_EAST_UP, //sort by z, then x, then y
+ EAST_SOUTH_UP, //sort by z, then y, then x
+ EAST_NORTH_UP //sort by z, then y, then x
+ };
+ atr_ = tmp[dir.to_int()];
+}
+
+inline axis_transformation& axis_transformation::operator=(const axis_transformation& a) {
+ atr_ = a.atr_;
+ return *this;
+}
+
+inline axis_transformation& axis_transformation::operator=(const ATR& atr) {
+ atr_ = atr;
+ return *this;
+}
+
+inline bool axis_transformation::operator==(const axis_transformation& a) const {
+ return atr_ == a.atr_;
+}
+
+inline bool axis_transformation::operator!=(const axis_transformation& a) const {
+ return !(*this == a);
+}
+
+inline bool axis_transformation::operator<(const axis_transformation& a) const {
+ return atr_ < a.atr_;
+}
+
+inline axis_transformation& axis_transformation::operator+=(const axis_transformation& a){
+ bool abit5 = a.atr_ & 32;
+ bool abit4 = a.atr_ & 16;
+ bool abit3 = a.atr_ & 8;
+ bool abit2 = a.atr_ & 4;
+ bool abit1 = a.atr_ & 2;
+ bool abit0 = a.atr_ & 1;
+ bool bit5 = atr_ & 32;
+ bool bit4 = atr_ & 16;
+ bool bit3 = atr_ & 8;
+ bool bit2 = atr_ & 4;
+ bool bit1 = atr_ & 2;
+ bool bit0 = atr_ & 1;
+ int indexes[2][3] = {
+ {
+ ((int)((bit5 & bit2) | (bit4 & !bit2)) << 1) +
+ (int)(bit2 & !bit5),
+ ((int)((bit4 & bit2) | (bit5 & !bit2)) << 1) +
+ (int)(!bit5 & !bit2),
+ ((int)(!bit4 & !bit5) << 1) +
+ (int)(bit5)
+ },
+ {
+ ((int)((abit5 & abit2) | (abit4 & !abit2)) << 1) +
+ (int)(abit2 & !abit5),
+ ((int)((abit4 & abit2) | (abit5 & !abit2)) << 1) +
+ (int)(!abit5 & !abit2),
+ ((int)(!abit4 & !abit5) << 1) +
+ (int)(abit5)
+ }
+ };
+ int zero_bits[2][3] = {
+ {bit0, bit1, bit3},
+ {abit0, abit1, abit3}
+ };
+ int nbit3 = zero_bits[0][2] ^ zero_bits[1][indexes[0][2]];
+ int nbit1 = zero_bits[0][1] ^ zero_bits[1][indexes[0][1]];
+ int nbit0 = zero_bits[0][0] ^ zero_bits[1][indexes[0][0]];
+ indexes[0][0] = indexes[1][indexes[0][0]];
+ indexes[0][1] = indexes[1][indexes[0][1]];
+ indexes[0][2] = indexes[1][indexes[0][2]];
+ int nbit5 = (indexes[0][2] == 1);
+ int nbit4 = (indexes[0][2] == 0);
+ int nbit2 = (!(nbit5 | nbit4) & (bool)(indexes[0][0] & 1)) | //swap xy
+ (nbit5 & ((indexes[0][0] & 2) >> 1)) | //z->y x->z
+ (nbit4 & ((indexes[0][1] & 2) >> 1)); //z->x y->z
+ atr_ = (ATR)((nbit5 << 5) +
+ (nbit4 << 4) +
+ (nbit3 << 3) +
+ (nbit2 << 2) +
+ (nbit1 << 1) + nbit0);
+ return *this;
+}
+
+inline axis_transformation axis_transformation::operator+(const axis_transformation& a) const {
+ axis_transformation retval(*this);
+ return retval+=a;
+}
+
+// populate_axis_array writes the three INDIVIDUAL_AXIS values that the
+// ATR enum value of 'this' represent into axis_array
+inline void axis_transformation::populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const {
+ bool bit5 = atr_ & 32;
+ bool bit4 = atr_ & 16;
+ bool bit3 = atr_ & 8;
+ bool bit2 = atr_ & 4;
+ bool bit1 = atr_ & 2;
+ bool bit0 = atr_ & 1;
+ axis_array[2] =
+ (INDIVIDUAL_AXIS)((((int)(!bit4 & !bit5)) << 2) +
+ ((int)(bit5) << 1) +
+ bit3);
+ axis_array[1] =
+ (INDIVIDUAL_AXIS)((((int)((bit4 & bit2) | (bit5 & !bit2))) << 2)+
+ ((int)(!bit5 & !bit2) << 1) +
+ bit1);
+ axis_array[0] =
+ (INDIVIDUAL_AXIS)((((int)((bit5 & bit2) | (bit4 & !bit2))) << 2) +
+ ((int)(bit2 & !bit5) << 1) +
+ bit0);
+}
+
+// combine_axis_arrays concatenates this_array and that_array overwriting
+// the result into this_array
+inline void
+axis_transformation::combine_axis_arrays (INDIVIDUAL_AXIS this_array[],
+ const INDIVIDUAL_AXIS that_array[]){
+ int indexes[3] = {this_array[0] >> 1,
+ this_array[1] >> 1,
+ this_array[2] >> 1};
+ int zero_bits[2][3] = {
+ {this_array[0] & 1, this_array[1] & 1, this_array[2] & 1},
+ {that_array[0] & 1, that_array[1] & 1, that_array[2] & 1}
+ };
+ this_array[0] = that_array[indexes[0]];
+ this_array[0] = (INDIVIDUAL_AXIS)((int)this_array[0] & (int)((int)PZ+(int)PY));
+ this_array[0] = (INDIVIDUAL_AXIS)((int)this_array[0] |
+ ((int)zero_bits[0][0] ^
+ (int)zero_bits[1][indexes[0]]));
+ this_array[1] = that_array[indexes[1]];
+ this_array[1] = (INDIVIDUAL_AXIS)((int)this_array[1] & (int)((int)PZ+(int)PY));
+ this_array[1] = (INDIVIDUAL_AXIS)((int)this_array[1] |
+ ((int)zero_bits[0][1] ^
+ (int)zero_bits[1][indexes[1]]));
+ this_array[2] = that_array[indexes[2]];
+ this_array[2] = (INDIVIDUAL_AXIS)((int)this_array[2] & (int)((int)PZ+(int)PY));
+ this_array[2] = (INDIVIDUAL_AXIS)((int)this_array[2] |
+ ((int)zero_bits[0][2] ^
+ (int)zero_bits[1][indexes[2]]));
+}
+
+// write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
+// to the ATR enum value and sets 'this' to that value
+inline void axis_transformation::write_back_axis_array(const INDIVIDUAL_AXIS this_array[]) {
+ int bit5 = (bool)((int)this_array[2] & 2);
+ int bit4 = !((bool)((int)this_array[2] & 4) | (bool)((int)this_array[2] & 2));
+ int bit3 = (bool)((int)this_array[2] & 1);
+ //bit 2 is the tricky bit
+ int bit2 = (!(bit5 | bit4) & (bool)((int)this_array[0] & 2)) | //swap xy
+ (bit5 & (((int)this_array[0] & 4) >> 2)) | //z->y x->z
+ (bit4 & (((int)this_array[1] & 4) >> 2)); //z->x y->z
+ int bit1 = ((int)this_array[1] & 1);
+ int bit0 = ((int)this_array[0] & 1);
+ atr_ = ATR((bit5 << 5) +
+ (bit4 << 4) +
+ (bit3 << 3) +
+ (bit2 << 2) +
+ (bit1 << 1) + bit0);
+}
+
+// behavior is deterministic but undefined in the case where illegal
+// combinations of directions are passed in.
+inline axis_transformation&
+axis_transformation::set_directions(const direction_2d& horizontalDir,
+ const direction_2d& verticalDir){
+ int bit2 = bool(static_cast<orientation_2d>(horizontalDir).to_int());
+ int bit1 = !(verticalDir.to_int() & 1);
+ int bit0 = !(horizontalDir.to_int() & 1);
+ atr_ = ATR((bit2 << 2) + (bit1 << 1) + bit0);
+ return *this;
+}
+
+// behavior is deterministic but undefined in the case where illegal
+// combinations of directions are passed in.
+inline axis_transformation& axis_transformation::set_directions(const direction_3d& horizontalDir,
+ const direction_3d& verticalDir,
+ const direction_3d& proximalDir){
+ int this_array[3] = {horizontalDir.to_int(),
+ verticalDir.to_int(),
+ proximalDir.to_int()};
+ int bit5 = (bool)(this_array[2] & 2);
+ int bit4 = !((bool)(this_array[2] & 4) | (bool)(this_array[2] & 2));
+ int bit3 = !(bool)(this_array[2] & 1);
+ //bit 2 is the tricky bit
+ int bit2 = (!(bit5 | bit4) & (bool)(this_array[0] & 2)) | //swap xy
+ (bit5 & ((this_array[0] & 4) >> 2)) | //z->y x->z
+ (bit4 & ((this_array[1] & 4) >> 2)); //z->x y->z
+ int bit1 = !(this_array[1] & 1);
+ int bit0 = !(this_array[0] & 1);
+ atr_ = ATR((bit5 << 5) +
+ (bit4 << 4) +
+ (bit3 << 3) +
+ (bit2 << 2) +
+ (bit1 << 1) + bit0);
+ return *this;
+}
+
+template <typename coordinate_type_2>
+inline void axis_transformation::transform(coordinate_type_2& x, coordinate_type_2& y) const {
+ int bit2 = (bool)(atr_ & 4);
+ int bit1 = (bool)(atr_ & 2);
+ int bit0 = (bool)(atr_ & 1);
+ x *= -((bit0 << 1) - 1);
+ y *= -((bit1 << 1) - 1);
+ predicated_swap(bit2,x,y);
+}
+
+template <typename coordinate_type_2>
+inline void axis_transformation::transform(coordinate_type_2& x, coordinate_type_2& y, coordinate_type_2& z) const {
+ int bit5 = (bool)(atr_ & 32);
+ int bit4 = (bool)(atr_ & 16);
+ int bit3 = (bool)(atr_ & 8);
+ int bit2 = (bool)(atr_ & 4);
+ int bit1 = (bool)(atr_ & 2);
+ int bit0 = (bool)(atr_ & 1);
+ x *= -((bit0 << 1) - 1);
+ y *= -((bit1 << 1) - 1);
+ z *= -((bit3 << 1) - 1);
+ predicated_swap(bit2, x, y);
+ predicated_swap(bit5, y, z);
+ predicated_swap(bit4, x, z);
+}
+
+inline axis_transformation& axis_transformation::invert_2d() {
+ int bit2 = (bool)(atr_ & 4);
+ int bit1 = (bool)(atr_ & 2);
+ int bit0 = (bool)(atr_ & 1);
+ //swap bit 0 and bit 1 if bit2 is 1
+ predicated_swap(bit2, bit0, bit1);
+ bit1 = bit1 << 1;
+ atr_ = (ATR)(atr_ & (32+16+8+4)); //mask away bit0 and bit1
+ atr_ = (ATR)(atr_ | bit0 | bit1);
+ return *this;
+}
+
+inline axis_transformation axis_transformation::inverse_2d() const {
+ axis_transformation retval(*this);
+ return retval.invert_2d();
+}
+
+inline axis_transformation& axis_transformation::invert() {
+ int bit5 = (bool)(atr_ & 32);
+ int bit4 = (bool)(atr_ & 16);
+ int bit3 = (bool)(atr_ & 8);
+ int bit2 = (bool)(atr_ & 4);
+ int bit1 = (bool)(atr_ & 2);
+ int bit0 = (bool)(atr_ & 1);
+ predicated_swap(bit2, bit4, bit5);
+ predicated_swap(bit4, bit0, bit3);
+ predicated_swap(bit5, bit1, bit3);
+ predicated_swap(bit2, bit0, bit1);
+ atr_ = (ATR)((bit5 << 5) +
+ (bit4 << 4) +
+ (bit3 << 3) +
+ (bit2 << 2) +
+ (bit1 << 1) + bit0);
+ return *this;
+}
+
+inline axis_transformation axis_transformation::inverse() const {
+ axis_transformation retval(*this);
+ return retval.invert();
+}
+
+template <typename scale_factor_type>
+inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::get(orientation_3d orient) const {
+ return scale_[orient.to_int()];
+}
+
+template <typename scale_factor_type>
+inline void anisotropic_scale_factor<scale_factor_type>::set(orientation_3d orient, scale_factor_type value) {
+ scale_[orient.to_int()] = value;
+}
+
+template <typename scale_factor_type>
+inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::x() const { return scale_[HORIZONTAL]; }
+template <typename scale_factor_type>
+inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::y() const { return scale_[VERTICAL]; }
+template <typename scale_factor_type>
+inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::z() const { return scale_[PROXIMAL]; }
+template <typename scale_factor_type>
+inline void anisotropic_scale_factor<scale_factor_type>::x(scale_factor_type value) { scale_[HORIZONTAL] = value; }
+template <typename scale_factor_type>
+inline void anisotropic_scale_factor<scale_factor_type>::y(scale_factor_type value) { scale_[VERTICAL] = value; }
+template <typename scale_factor_type>
+inline void anisotropic_scale_factor<scale_factor_type>::z(scale_factor_type value) { scale_[PROXIMAL] = value; }
+
+//concatenation operator (convolve scale factors)
+template <typename scale_factor_type>
+inline anisotropic_scale_factor<scale_factor_type> anisotropic_scale_factor<scale_factor_type>::operator+(const anisotropic_scale_factor<scale_factor_type>& s) const {
+ anisotropic_scale_factor<scale_factor_type> retval(*this);
+ return retval+=s;
+}
+
+//concatenate this with that
+template <typename scale_factor_type>
+inline const anisotropic_scale_factor<scale_factor_type>& anisotropic_scale_factor<scale_factor_type>::operator+=(const anisotropic_scale_factor<scale_factor_type>& s){
+ scale_[0] *= s.scale_[0];
+ scale_[1] *= s.scale_[1];
+ scale_[2] *= s.scale_[2];
+ return *this;
+}
+
+//transform
+template <typename scale_factor_type>
+inline anisotropic_scale_factor<scale_factor_type>& anisotropic_scale_factor<scale_factor_type>::transform(axis_transformation atr){
+ direction_3d dirs[3];
+ atr.get_directions(dirs[0],dirs[1],dirs[2]);
+ scale_factor_type tmp[3] = {scale_[0], scale_[1], scale_[2]};
+ for(int i = 0; i < 3; ++i){
+ scale_[orientation_3d(dirs[i]).to_int()] = tmp[i];
+ }
+ return *this;
+}
+
+template <typename scale_factor_type>
+template <typename coordinate_type_2>
+inline void anisotropic_scale_factor<scale_factor_type>::scale(coordinate_type_2& x, coordinate_type_2& y) const {
+ x = scaling_policy<coordinate_type_2>::round((scale_factor_type)x * get(HORIZONTAL));
+ y = scaling_policy<coordinate_type_2>::round((scale_factor_type)y * get(HORIZONTAL));
+}
+
+template <typename scale_factor_type>
+template <typename coordinate_type_2>
+inline void anisotropic_scale_factor<scale_factor_type>::scale(coordinate_type_2& x, coordinate_type_2& y, coordinate_type_2& z) const {
+ scale(x, y);
+ z = scaling_policy<coordinate_type_2>::round((scale_factor_type)z * get(HORIZONTAL));
+}
+
+template <typename scale_factor_type>
+inline anisotropic_scale_factor<scale_factor_type>& anisotropic_scale_factor<scale_factor_type>::invert() {
+ x(1/x());
+ y(1/y());
+ z(1/z());
+ return *this;
+}
+
+
+template <typename coordinate_type>
+inline transformation<coordinate_type>::transformation() : p_(0, 0, 0) {;}
+
+template <typename coordinate_type>
+inline transformation<coordinate_type>::transformation(axis_transformation atr) : atr_(atr), p_(0, 0, 0){;}
+
+template <typename coordinate_type>
+template <typename point_type>
+inline transformation<coordinate_type>::transformation(const point_type& p) {
+ set_translation(p);
+}
+
+template <typename coordinate_type>
+template <typename point_type>
+inline transformation<coordinate_type>::transformation(axis_transformation atr, const point_type& p) :
+ atr_(atr) {
+ set_translation(p);
+}
+
+template <typename coordinate_type>
+template <typename point_type>
+inline transformation<coordinate_type>::transformation(axis_transformation atr, const point_type& referencePt, const point_type& destinationPt) {
+ transformation<coordinate_type> tmp(referencePt);
+ transformation<coordinate_type> rotRef(atr);
+ transformation<coordinate_type> tmpInverse = tmp.inverse();
+ point_type decon(referencePt);
+ deconvolve(decon, destinationPt);
+ transformation<coordinate_type> displacement(decon);
+ tmp += rotRef;
+ tmp += tmpInverse;
+ tmp += displacement;
+ (*this) = tmp;
+}
+
+template <typename coordinate_type>
+inline transformation<coordinate_type>::transformation(const transformation<coordinate_type>& tr) :
+ atr_(tr.atr_), p_(tr.p_) {;}
+
+template <typename coordinate_type>
+inline bool transformation<coordinate_type>::operator==(const transformation<coordinate_type>& tr) const {
+ return atr_ == tr.atr_ && p_ == tr.p_;
+}
+
+template <typename coordinate_type>
+inline bool transformation<coordinate_type>::operator!=(const transformation<coordinate_type>& tr) const {
+ return !(*this == tr);
+}
+
+template <typename coordinate_type>
+inline bool transformation<coordinate_type>::operator<(const transformation<coordinate_type>& tr) const {
+ return atr_ < tr.atr_ || atr_ == tr.atr_ && p_ < tr.p_;
+}
+
+template <typename coordinate_type>
+inline transformation<coordinate_type> transformation<coordinate_type>::operator+(const transformation<coordinate_type>& tr) const {
+ transformation<coordinate_type> retval(*this);
+ return retval+=tr;
+}
+
+template <typename coordinate_type>
+inline const transformation<coordinate_type>& transformation<coordinate_type>::operator+=(const transformation<coordinate_type>& tr){
+ //apply the inverse transformation of this to the translation point of that
+ //and convolve it with this translation point
+ coordinate_type x, y, z;
+ transformation<coordinate_type> inv = inverse();
+ inv.transform(x, y, z);
+ p_.set(HORIZONTAL, p_.get(HORIZONTAL) + x);
+ p_.set(VERTICAL, p_.get(VERTICAL) + y);
+ p_.set(PROXIMAL, p_.get(PROXIMAL) + z);
+ //concatenate axis transforms
+ atr_ += tr.atr_;
+ return *this;
+}
+
+template <typename coordinate_type>
+inline void transformation<coordinate_type>::set_axis_transformation(const axis_transformation& atr) {
+ atr_ = atr;
+}
+
+template <typename coordinate_type>
+template <typename point_type>
+inline void transformation<coordinate_type>::get_translation(point_type& p) const {
+ assign(p, p_);
+}
+
+template <typename coordinate_type>
+template <typename point_type>
+inline void transformation<coordinate_type>::set_translation(const point_type& p) {
+ assign(p_, p);
+}
+
+template <typename coordinate_type>
+inline void transformation<coordinate_type>::transform(coordinate_type& x, coordinate_type& y) const {
+ //subtract each component of new origin point
+ y -= p_.get(VERTICAL);
+ x -= p_.get(HORIZONTAL);
+ atr_.transform(x, y);
+}
+
+template <typename coordinate_type>
+inline void transformation<coordinate_type>::transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const {
+ //subtract each component of new origin point
+ z -= p_.get(PROXIMAL);
+ y -= p_.get(VERTICAL);
+ x -= p_.get(HORIZONTAL);
+ atr_.transform(x,y,z);
+}
+
+/// sets the axis_transform portion to its inverse
+/// transforms the tranlastion portion by that inverse axis_transform
+/// multiplies the translation portion by -1 to reverse it
+template <typename coordinate_type>
+inline transformation<coordinate_type>& transformation<coordinate_type>::invert() {
+ coordinate_type x = p_.get(HORIZONTAL), y = p_.get(VERTICAL), z = p_.get(PROXIMAL);
+ atr_.transform(x, y, z);
+ x *= -1;
+ y *= -1;
+ z *= -1;
+ p_ = point_3d_data<coordinate_type>(x, y, z);
+ atr_.invert();
+ return *this;
+}
+
+template <typename coordinate_type>
+inline transformation<coordinate_type> transformation<coordinate_type>::inverse() const {
+ transformation<coordinate_type> retval(*this);
+ return retval.invert();
+}
+
+}
+#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