Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r52703 - in sandbox/gtl: . gtl
From: lucanus.j.simonson_at_[hidden]
Date: 2009-05-01 12:51:15


Author: ljsimons
Date: 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
New Revision: 52703
URL: http://svn.boost.org/trac/boost/changeset/52703

Log:
removing mistakenly added files
Removed:
   sandbox/gtl/boolean_op.hpp
   sandbox/gtl/boolean_op_45.hpp
   sandbox/gtl/gtl.hpp
   sandbox/gtl/interval_concept.hpp
   sandbox/gtl/interval_data.hpp
   sandbox/gtl/interval_traits.hpp
   sandbox/gtl/isotropy.hpp
   sandbox/gtl/iterator_compact_to_points.hpp
   sandbox/gtl/iterator_geometry_to_set.hpp
   sandbox/gtl/iterator_points_to_compact.hpp
   sandbox/gtl/max_cover.hpp
   sandbox/gtl/point_3d_concept.hpp
   sandbox/gtl/point_3d_data.hpp
   sandbox/gtl/point_3d_traits.hpp
   sandbox/gtl/point_concept.hpp
   sandbox/gtl/point_data.hpp
   sandbox/gtl/point_traits.hpp
   sandbox/gtl/polygon_45_data.hpp
   sandbox/gtl/polygon_45_formation.hpp
   sandbox/gtl/polygon_45_set_concept.hpp
   sandbox/gtl/polygon_45_set_data.hpp
   sandbox/gtl/polygon_45_set_traits.hpp
   sandbox/gtl/polygon_45_set_view.hpp
   sandbox/gtl/polygon_45_touch.hpp
   sandbox/gtl/polygon_45_with_holes_data.hpp
   sandbox/gtl/polygon_90_data.hpp
   sandbox/gtl/polygon_90_set_concept.hpp
   sandbox/gtl/polygon_90_set_data.hpp
   sandbox/gtl/polygon_90_set_traits.hpp
   sandbox/gtl/polygon_90_set_view.hpp
   sandbox/gtl/polygon_90_touch.hpp
   sandbox/gtl/polygon_90_with_holes_data.hpp
   sandbox/gtl/polygon_arbitrary_formation.hpp
   sandbox/gtl/polygon_data.hpp
   sandbox/gtl/polygon_formation.hpp
   sandbox/gtl/polygon_set_concept.hpp
   sandbox/gtl/polygon_set_data.hpp
   sandbox/gtl/polygon_set_traits.hpp
   sandbox/gtl/polygon_set_view.hpp
   sandbox/gtl/polygon_traits.hpp
   sandbox/gtl/polygon_with_holes_data.hpp
   sandbox/gtl/property_merge.hpp
   sandbox/gtl/rectangle_concept.hpp
   sandbox/gtl/rectangle_data.hpp
   sandbox/gtl/rectangle_formation.hpp
   sandbox/gtl/rectangle_traits.hpp
   sandbox/gtl/scan_arbitrary.hpp
   sandbox/gtl/transform.hpp
   sandbox/gtl/transform_detail.hpp
Text files modified:
   sandbox/gtl/gtl/boolean_op.hpp | 18
   sandbox/gtl/gtl/boolean_op_45.hpp | 33
   sandbox/gtl/gtl/interval_data.hpp | 6
   sandbox/gtl/gtl/isotropy.hpp | 469 +++++++++---------
   sandbox/gtl/gtl/iterator_compact_to_points.hpp | 4
   sandbox/gtl/gtl/iterator_geometry_to_set.hpp | 24
   sandbox/gtl/gtl/iterator_points_to_compact.hpp | 7
   sandbox/gtl/gtl/max_cover.hpp | 113 ++++
   sandbox/gtl/gtl/point_3d_data.hpp | 8
   sandbox/gtl/gtl/point_data.hpp | 6
   sandbox/gtl/gtl/polygon_45_data.hpp | 2
   sandbox/gtl/gtl/polygon_45_formation.hpp | 44
   sandbox/gtl/gtl/polygon_45_set_data.hpp | 63 +-
   sandbox/gtl/gtl/polygon_45_set_view.hpp | 2
   sandbox/gtl/gtl/polygon_45_touch.hpp | 4
   sandbox/gtl/gtl/polygon_45_with_holes_data.hpp | 6
   sandbox/gtl/gtl/polygon_90_data.hpp | 2
   sandbox/gtl/gtl/polygon_90_set_data.hpp | 43 +
   sandbox/gtl/gtl/polygon_90_touch.hpp | 12
   sandbox/gtl/gtl/polygon_90_with_holes_data.hpp | 2
   sandbox/gtl/gtl/polygon_arbitrary_formation.hpp | 37
   sandbox/gtl/gtl/polygon_formation.hpp | 16
   sandbox/gtl/gtl/polygon_set_data.hpp | 25
   sandbox/gtl/gtl/polygon_set_view.hpp | 2
   sandbox/gtl/gtl/property_merge.hpp | 6
   sandbox/gtl/gtl/rectangle_data.hpp | 10
   sandbox/gtl/gtl/rectangle_formation.hpp | 4
   sandbox/gtl/gtl/scan_arbitrary.hpp | 26
   sandbox/gtl/gtl/transform.hpp | 7
   sandbox/gtl/gtl/transform_detail.hpp | 975 ++++++++++++++++++++-------------------
   30 files changed, 1074 insertions(+), 902 deletions(-)

Deleted: sandbox/gtl/boolean_op.hpp
==============================================================================
--- sandbox/gtl/boolean_op.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,556 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_BOOLEAN_OP_HPP
-#define GTL_BOOLEAN_OP_HPP
-namespace gtl {
-namespace boolean_op {
-
- //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
- //to multi-layer scans, properties and other advanced scanline operations above
- //and beyond simple booleans.
- //T must cast to int
- template <class T, typename Unit>
- class BooleanOp {
- public:
- typedef std::map<Unit, T> ScanData;
- typedef std::pair<Unit, T> ElementType;
- protected:
- ScanData scanData_;
- typename ScanData::iterator nextItr_;
- T nullT_;
- public:
- inline BooleanOp () : scanData_(), nextItr_(), nullT_() { nextItr_ = scanData_.end(); nullT_ = 0; }
- inline BooleanOp (T nullT) : scanData_(), nextItr_(), nullT_(nullT) { nextItr_ = scanData_.end(); }
- inline BooleanOp (const BooleanOp& that) : scanData_(that.scanData_), nextItr_(),
- nullT_(that.nullT_) { nextItr_ = scanData_.begin(); }
- inline BooleanOp& operator=(const BooleanOp& that);
-
- //moves scanline forward
- inline void advanceScan() { nextItr_ = scanData_.begin(); }
-
- //proceses the given interval and T data
- //appends output edges to cT
- template <class cT>
- inline void processInterval(cT& outputContainer, interval_data<Unit> ivl, T deltaCount);
-
- 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, T count){
- return nextItr_ = scanData_.insert(nextItr_, ElementType(pos, count));
- }
- template <class cT>
- inline void evaluateInterval_(cT& outputContainer, interval_data<Unit> ivl, T beforeCount, T afterCount);
- };
-
- class BinaryAnd {
- public:
- inline BinaryAnd() {}
- inline bool operator()(int a, int b) { return (a > 0) & (b > 0); }
- };
- class BinaryOr {
- public:
- inline BinaryOr() {}
- inline bool operator()(int a, int b) { return (a > 0) | (b > 0); }
- };
- class BinaryNot {
- public:
- inline BinaryNot() {}
- inline bool operator()(int a, int b) { return (a > 0) & !(b > 0); }
- };
- class BinaryXor {
- public:
- inline BinaryXor() {}
- inline bool operator()(int a, int b) { return (a > 0) ^ (b > 0); }
- };
-
- //BinaryCount is an array of two deltaCounts coming from two different layers
- //of scan event data. It is the merged count of the two suitable for consumption
- //as the template argument of the BooleanOp algorithm because BinaryCount casts to int.
- //T is a binary functor object that evaluates the array of counts and returns a logical
- //result of some operation on those values.
- //BinaryCount supports many of the operators that work with int, particularly the
- //binary operators, but cannot support less than or increment.
- template <class T>
- class BinaryCount {
- public:
- inline BinaryCount() : counts_() { counts_[0] = counts_[1] = 0; }
- // constructs from two integers
- inline BinaryCount(int countL, int countR) : counts_() { counts_[0] = countL, counts_[1] = countR; }
- inline BinaryCount& operator=(int count) { counts_[0] = count, counts_[1] = count; }
- inline BinaryCount& operator=(const BinaryCount& that);
- inline BinaryCount(const BinaryCount& that) : counts_() { *this = that; }
- inline bool operator==(const BinaryCount& that) const;
- inline bool operator!=(const BinaryCount& that) const { return !((*this) == that);}
- inline BinaryCount& operator+=(const BinaryCount& that);
- inline BinaryCount& operator-=(const BinaryCount& that);
- inline BinaryCount operator+(const BinaryCount& that) const;
- inline BinaryCount operator-(const BinaryCount& that) const;
- inline BinaryCount operator-() const;
- inline int& operator[](bool index) { return counts_[index]; }
-
- //cast to int operator evaluates data using T binary functor
- inline operator int() const { return T()(counts_[0], counts_[1]); }
- private:
- int counts_[2];
- };
-
- class UnaryCount {
- public:
- inline UnaryCount() : count_(0) {}
- // constructs from two integers
- inline explicit UnaryCount(int count) : count_(count) {}
- inline UnaryCount& operator=(int count) { count_ = count; return *this; }
- inline UnaryCount& operator=(const UnaryCount& that) { count_ = that.count_; return *this; }
- inline UnaryCount(const UnaryCount& that) : count_(that.count_) {}
- inline bool operator==(const UnaryCount& that) const { return count_ == that.count_; }
- inline bool operator!=(const UnaryCount& that) const { return !((*this) == that);}
- inline UnaryCount& operator+=(const UnaryCount& that) { count_ += that.count_; return *this; }
- inline UnaryCount& operator-=(const UnaryCount& that) { count_ -= that.count_; return *this; }
- inline UnaryCount operator+(const UnaryCount& that) const { UnaryCount tmp(*this); tmp += that; return tmp; }
- inline UnaryCount operator-(const UnaryCount& that) const { UnaryCount tmp(*this); tmp -= that; return tmp; }
- inline UnaryCount operator-() const { UnaryCount tmp; return tmp - *this; }
-
- //cast to int operator evaluates data using T binary functor
- inline operator int() const { return count_ % 2; }
- private:
- int count_;
- };
-
- template <class T, typename Unit>
- inline BooleanOp<T, Unit>& BooleanOp<T, Unit>::operator=(const BooleanOp& that) {
- scanData_ = that.scanData_;
- nextItr_ = scanData_.begin();
- nullT_ = that.nullT_;
- return *this;
- }
-
- //appends output edges to cT
- template <class T, typename Unit>
- template <class cT>
- inline void BooleanOp<T, Unit>::processInterval(cT& outputContainer, interval_data<Unit> ivl, T deltaCount) {
- typename ScanData::iterator lowItr = lookup_(ivl.low());
- typename ScanData::iterator highItr = lookup_(ivl.high());
- //add interval to scan data if it is past the end
- if(lowItr == scanData_.end()) {
- lowItr = insert_(ivl.low(), deltaCount);
- highItr = insert_(ivl.high(), nullT_);
- evaluateInterval_(outputContainer, ivl, nullT_, deltaCount);
- return;
- }
- //ensure that highItr points to the end of the ivl
- if(highItr == scanData_.end() || (*highItr).first > ivl.high()) {
- T value = nullT_;
- if(highItr != scanData_.begin()) {
- --highItr;
- value = highItr->second;
- }
- nextItr_ = highItr;
- highItr = insert_(ivl.high(), value);
- }
- //split the low interval if needed
- if(lowItr->first > ivl.low()) {
- if(lowItr != scanData_.begin()) {
- --lowItr;
- nextItr_ = lowItr;
- lowItr = insert_(ivl.low(), lowItr->second);
- } else {
- nextItr_ = lowItr;
- lowItr = insert_(ivl.low(), nullT_);
- }
- }
- //process scan data intersecting interval
- for(typename ScanData::iterator itr = lowItr; itr != highItr; ){
- T beforeCount = itr->second;
- T afterCount = itr->second += deltaCount;
- Unit low = itr->first;
- ++itr;
- Unit high = itr->first;
- evaluateInterval_(outputContainer, interval_data<Unit>(low, high), beforeCount, afterCount);
- }
- //merge the bottom interval with the one below if they have the same count
- if(lowItr != scanData_.begin()){
- typename ScanData::iterator belowLowItr = lowItr;
- --belowLowItr;
- if(belowLowItr->second == lowItr->second) {
- scanData_.erase(lowItr);
- }
- }
- //merge the top interval with the one above if they have the same count
- if(highItr != scanData_.begin()) {
- typename ScanData::iterator beforeHighItr = highItr;
- --beforeHighItr;
- if(beforeHighItr->second == highItr->second) {
- scanData_.erase(highItr);
- highItr = beforeHighItr;
- ++highItr;
- }
- }
- nextItr_ = highItr;
- }
-
- template <class T, typename Unit>
- template <class cT>
- inline void BooleanOp<T, Unit>::evaluateInterval_(cT& outputContainer, interval_data<Unit> ivl,
- T beforeCount, T afterCount) {
- bool before = (int)beforeCount > 0;
- bool after = (int)afterCount > 0;
- int value = (!before & after) - (before & !after);
- if(value) {
- outputContainer.insert(outputContainer.end(), std::pair<interval_data<Unit>, int>(ivl, value));
- }
- }
-
- template <class T>
- inline BinaryCount<T>& BinaryCount<T>::operator=(const BinaryCount<T>& that) {
- counts_[0] = that.counts_[0];
- counts_[1] = that.counts_[1];
- return *this;
- }
- template <class T>
- inline bool BinaryCount<T>::operator==(const BinaryCount<T>& that) const {
- return counts_[0] == that.counts_[0] &&
- counts_[1] == that.counts_[1];
- }
- template <class T>
- inline BinaryCount<T>& BinaryCount<T>::operator+=(const BinaryCount<T>& that) {
- counts_[0] += that.counts_[0];
- counts_[1] += that.counts_[1];
- return *this;
- }
- template <class T>
- inline BinaryCount<T>& BinaryCount<T>::operator-=(const BinaryCount<T>& that) {
- counts_[0] += that.counts_[0];
- counts_[1] += that.counts_[1];
- return *this;
- }
- template <class T>
- inline BinaryCount<T> BinaryCount<T>::operator+(const BinaryCount<T>& that) const {
- BinaryCount retVal(*this);
- retVal += that;
- return retVal;
- }
- template <class T>
- inline BinaryCount<T> BinaryCount<T>::operator-(const BinaryCount<T>& that) const {
- BinaryCount retVal(*this);
- retVal -= that;
- return retVal;
- }
- template <class T>
- inline BinaryCount<T> BinaryCount<T>::operator-() const {
- return BinaryCount<T>() - *this;
- }
-
- //self contained unit test for BooleanOr algorithm
- template <typename Unit>
- inline bool testBooleanOr() {
- BooleanOp<int, Unit> booleanOr;
- //test one rectangle
- std::vector<std::pair<interval_data<Unit>, int> > container;
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), -1);
- if(container.size() != 2) {
- std::cout << "Test one rectangle, wrong output size\n";
- return false;
- }
- if(container[0] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 10), 1)) {
- std::cout << "Test one rectangle, first output wrong: Interval(" <<
- container[0].first << "), " << container[0].second << std::endl;
- }
- if(container[1] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 10), -1)) {
- std::cout << "Test one rectangle, second output wrong: Interval(" <<
- container[1].first << "), " << container[1].second << std::endl;
- }
-
- //test two rectangles
- container.clear();
- booleanOr = BooleanOp<int, Unit>();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(5, 15), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), -1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(5, 15), -1);
- if(container.size() != 4) {
- std::cout << "Test two rectangles, wrong output size\n";
- for(unsigned int i = 0; i < container.size(); ++i){
- std::cout << container[i].first << "), " << container[i].second << std::endl;
- }
- return false;
- }
- if(container[0] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 10), 1)) {
- std::cout << "Test two rectangles, first output wrong: Interval(" <<
- container[0].first << "), " << container[0].second << std::endl;
- }
- if(container[1] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(10, 15), 1)) {
- std::cout << "Test two rectangles, second output wrong: Interval(" <<
- container[1].first << "), " << container[1].second << std::endl;
- }
- if(container[2] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 5), -1)) {
- std::cout << "Test two rectangles, third output wrong: Interval(" <<
- container[2].first << "), " << container[2].second << std::endl;
- }
- if(container[3] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(5, 15), -1)) {
- std::cout << "Test two rectangles, fourth output wrong: Interval(" <<
- container[3].first << "), " << container[3].second << std::endl;
- }
-
- //test two rectangles
- container.clear();
- booleanOr = BooleanOp<int, Unit>();
- booleanOr.processInterval(container, interval_data<Unit>(5, 15), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(5, 15), -1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), -1);
- if(container.size() != 4) {
- std::cout << "Test other two rectangles, wrong output size\n";
- for(unsigned int i = 0; i < container.size(); ++i){
- std::cout << container[i].first << "), " << container[i].second << std::endl;
- }
- return false;
- }
- if(container[0] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(5, 15), 1)) {
- std::cout << "Test other two rectangles, first output wrong: Interval(" <<
- container[0].first << "), " << container[0].second << std::endl;
- }
- if(container[1] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 5), 1)) {
- std::cout << "Test other two rectangles, second output wrong: Interval(" <<
- container[1].first << "), " << container[1].second << std::endl;
- }
- if(container[2] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(10, 15), -1)) {
- std::cout << "Test other two rectangles, third output wrong: Interval(" <<
- container[2].first << "), " << container[2].second << std::endl;
- }
- if(container[3] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 10), -1)) {
- std::cout << "Test other two rectangles, fourth output wrong: Interval(" <<
- container[3].first << "), " << container[3].second << std::endl;
- }
-
- //test two nonoverlapping rectangles
- container.clear();
- booleanOr = BooleanOp<int, Unit>();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(15, 25), 1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(0, 10), -1);
- booleanOr.advanceScan();
- booleanOr.processInterval(container, interval_data<Unit>(15, 25), -1);
- if(container.size() != 4) {
- std::cout << "Test two nonoverlapping rectangles, wrong output size\n";
- return false;
- }
- if(container[0] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 10), 1)) {
- std::cout << "Test two nonoverlapping rectangles, first output wrong: Interval(" <<
- container[0].first << "), " << container[0].second << std::endl;
- }
- if(container[1] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(15, 25), 1)) {
- std::cout << "Test two nonoverlapping rectangles, second output wrong: Interval(" <<
- container[1].first << "), " << container[1].second << std::endl;
- }
- if(container[2] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(0, 10), -1)) {
- std::cout << "Test two nonoverlapping rectangles, third output wrong: Interval(" <<
- container[2].first << "), " << container[2].second << std::endl;
- }
- if(container[3] != std::pair<interval_data<Unit>, int>(interval_data<Unit>(15, 25), -1)) {
- std::cout << "Test two nonoverlapping rectangles, fourth output wrong: Interval(" <<
- container[3].first << "), " << container[3].second << std::endl;
- }
- return true;
- }
-
- 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,
- 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();
- std::vector<std::pair<interval_data<Unit>, int> > container;
- //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();
- Unit prevCoord = UnitMax;
- Unit prevPosition = UnitMax;
- T count(defaultCount);
- //define the starting point
- if(itr1 != itr1_end) {
- prevCoord = (*itr1).first;
- prevPosition = (*itr1).second.first;
- count[0] += (*itr1).second.second;
- }
- if(itr2 != itr2_end) {
- if((*itr2).first < prevCoord ||
- ((*itr2).first == prevCoord && (*itr2).second.first < prevPosition)) {
- prevCoord = (*itr2).first;
- prevPosition = (*itr2).second.first;
- count = defaultCount;
- count[1] += (*itr2).second.second;
- ++itr2;
- } else if((*itr2).first == prevCoord && (*itr2).second.first == prevPosition) {
- count[1] += (*itr2).second.second;
- ++itr2;
- if(itr1 != itr1_end) ++itr1;
- } else {
- if(itr1 != itr1_end) ++itr1;
- }
- } else {
- if(itr1 != itr1_end) ++itr1;
- }
-
- while(itr1 != itr1_end || itr2 != itr2_end) {
- Unit curCoord = UnitMax;
- Unit curPosition = UnitMax;
- T curCount(defaultCount);
- if(itr1 != itr1_end) {
- curCoord = (*itr1).first;
- curPosition = (*itr1).second.first;
- curCount[0] += (*itr1).second.second;
- }
- if(itr2 != itr2_end) {
- if((*itr2).first < curCoord ||
- ((*itr2).first == curCoord && (*itr2).second.first < curPosition)) {
- curCoord = (*itr2).first;
- curPosition = (*itr2).second.first;
- curCount = defaultCount;
- curCount[1] += (*itr2).second.second;
- ++itr2;
- } else if((*itr2).first == curCoord && (*itr2).second.first == curPosition) {
- curCount[1] += (*itr2).second.second;
- ++itr2;
- if(itr1 != itr1_end) ++itr1;
- } else {
- if(itr1 != itr1_end) ++itr1;
- }
- } else {
- ++itr1;
- }
-
- if(prevCoord != curCoord) {
- boolean.advanceScan();
- prevCoord = curCoord;
- prevPosition = curPosition;
- count = curCount;
- continue;
- }
- if(curPosition != prevPosition && count != defaultCount) {
- interval_data<Unit> ivl(prevPosition, curPosition);
- container.clear();
- boolean.processInterval(container, ivl, count);
- for(unsigned int i = 0; i < container.size(); ++i) {
- std::pair<interval_data<Unit>, int>& element = container[i];
- if(!output.empty() && output.back().first == prevCoord &&
- output.back().second.first == element.first.low() &&
- output.back().second.second == element.second * -1) {
- output.pop_back();
- } else {
- output.push_back(std::pair<Unit, std::pair<Unit, int> >(prevCoord, std::pair<Unit, int>(element.first.low(),
- element.second)));
- }
- output.push_back(std::pair<Unit, std::pair<Unit, int> >(prevCoord, std::pair<Unit, int>(element.first.high(),
- element.second * -1)));
- }
- }
- prevPosition = curPosition;
- count += curCount;
- }
- }
-
- template <class T, typename Unit>
- inline void applyBooleanBinaryOp(std::vector<std::pair<Unit, std::pair<Unit, int> > >& inputOutput,
- const std::vector<std::pair<Unit, std::pair<Unit, int> > >& input2,
- T defaultCount) {
- std::vector<std::pair<Unit, std::pair<Unit, int> > > output;
- applyBooleanBinaryOp(output, inputOutput, input2, defaultCount);
- if(output.size() < inputOutput.size() / 2) {
- inputOutput = std::vector<std::pair<Unit, std::pair<Unit, int> > >();
- } else {
- inputOutput.clear();
- }
- inputOutput.insert(inputOutput.end(), output.begin(), output.end());
- }
-
- template <typename Unit>
- inline void applyUnaryXOr(std::vector<std::pair<Unit, std::pair<Unit, int> > >& input) {
- BooleanOp<UnaryCount, Unit> booleanXOr;
-
- }
-
- template <typename count_type = int>
- struct default_arg_workaround {
- template <typename Unit>
- static inline void applyBooleanOr(std::vector<std::pair<Unit, std::pair<Unit, int> > >& input) {
- BooleanOp<count_type, Unit> booleanOr;
- std::vector<std::pair<interval_data<Unit>, int> > container;
- std::vector<std::pair<Unit, std::pair<Unit, int> > > output;
- output.reserve(input.size());
- //consider eliminating dependecy on limits with bool flag for initial state
- Unit UnitMax = std::numeric_limits<Unit>::max();
- Unit prevPos = UnitMax;
- Unit prevY = UnitMax;
- int count = 0;
- for(typename std::vector<std::pair<Unit, std::pair<Unit, int> > >::iterator itr = input.begin();
- itr != input.end(); ++itr) {
- Unit pos = (*itr).first;
- Unit y = (*itr).second.first;
- if(pos != prevPos) {
- booleanOr.advanceScan();
- prevPos = pos;
- prevY = y;
- count = (*itr).second.second;
- continue;
- }
- if(y != prevY && count != 0) {
- interval_data<Unit> ivl(prevY, y);
- container.clear();
- booleanOr.processInterval(container, ivl, count_type(count));
- for(unsigned int i = 0; i < container.size(); ++i) {
- std::pair<interval_data<Unit>, int>& element = container[i];
- if(!output.empty() && output.back().first == prevPos &&
- output.back().second.first == element.first.low() &&
- output.back().second.second == element.second * -1) {
- output.pop_back();
- } else {
- output.push_back(std::pair<Unit, std::pair<Unit, int> >(prevPos, std::pair<Unit, int>(element.first.low(),
- element.second)));
- }
- output.push_back(std::pair<Unit, std::pair<Unit, int> >(prevPos, std::pair<Unit, int>(element.first.high(),
- element.second * -1)));
- }
- }
- prevY = y;
- count += (*itr).second.second;
- }
- if(output.size() < input.size() / 2) {
- input = std::vector<std::pair<Unit, std::pair<Unit, int> > >();
- } else {
- input.clear();
- }
- input.insert(input.end(), output.begin(), output.end());
- }
- };
-
-}
-
-}
-#endif

Deleted: sandbox/gtl/boolean_op_45.hpp
==============================================================================
--- sandbox/gtl/boolean_op_45.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,1357 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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() { counts[0] = counts[1] = 0; }
- //inline Count2(int count) { counts[0] = counts[1] = count; }
- inline Count2(int count1, int count2) : counts() { counts[0] = count1; counts[1] = count2; }
- inline Count2(const Count2& count) : counts() { 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];
- };
-
- class Count1 {
- public:
- inline Count1() : count_(0) { }
- inline Count1(int count) : count_(count) { }
- inline Count1(const Count1& count) : count_(count.count_) { }
- inline bool operator==(const Count1& count) const { return count_ == count.count_; }
- inline bool operator!=(const Count1& count) const { return !((*this) == count); }
- inline Count1& operator=(int count) { count_ = count; return *this; }
- inline Count1& operator=(const Count1& count) { count_ = count.count_; return *this; }
- inline Count1& operator+=(const Count1& count){
- count_ += count.count_;
- return *this;
- }
- inline Count1& operator-=(const Count1& count){
- count_ -= count.count_;
- return *this;
- }
- inline Count1 operator+(const Count1& count) const {
- return Count1(*this)+=count;
- }
- inline Count1 operator-(const Count1& count) const {
- return Count1(*this)-=count;
- }
- inline Count1 invert() const {
- return Count1(-count_);
- }
- int count_;
- };
-
- // inline std::ostream& operator<< (std::ostream& o, const Count2& c) {
- // o << c[0] << " " << c[1];
- // return o;
- // }
-
- template <typename CountType>
- class Scan45ElementT {
- public:
- Unit x;
- Unit y;
- int rise; //-1, 0, +1
- mutable CountType count;
- inline Scan45ElementT(){}
- inline Scan45ElementT(Unit xIn, Unit yIn, int riseIn, CountType countIn = CountType()) :
- x(xIn), y(yIn), rise(riseIn), count(countIn) {}
- inline Scan45ElementT(const Scan45ElementT& that) :
- x(that.x), y(that.y), rise(that.rise), count(that.count) {}
- inline Scan45ElementT& operator=(const Scan45ElementT& 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 Scan45ElementT& 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;
- }
- };
-
- typedef Scan45ElementT<Count2> Scan45Element;
-
- // 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;
- }
- };
-
- template <typename CountType>
- class lessScan45Element {
- private:
- Unit *x_; //x value at which to apply comparison
- int *justBefore_;
- public:
- inline lessScan45Element() : x_(0), justBefore_(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 Scan45ElementT<CountType>& elm1,
- const Scan45ElementT<CountType>& 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;
- }
- };
-
- template <typename CountType>
- class Scan45CountT {
- public:
- inline Scan45CountT() : counts() {} //counts[0] = counts[1] = counts[2] = counts[3] = 0; }
- inline Scan45CountT(CountType count) : counts() { counts[0] = counts[1] = counts[2] = counts[3] = count; }
- inline Scan45CountT(const CountType& count1, const CountType& count2, const CountType& count3,
- const CountType& count4) : counts() {
- counts[0] = count1;
- counts[1] = count2;
- counts[2] = count3;
- counts[3] = count4;
- }
- inline Scan45CountT(const Scan45CountT& count) : counts() {
- (*this) = count;
- }
- inline bool operator==(const Scan45CountT& count) const {
- for(unsigned int i = 0; i < 4; ++i) {
- if(counts[i] != count.counts[i]) return false;
- }
- return true;
- }
- inline bool operator!=(const Scan45CountT& count) const { return !((*this) == count); }
- inline Scan45CountT& operator=(CountType count) {
- counts[0] = counts[1] = counts[2] = counts[3] = count; return *this; }
- inline Scan45CountT& operator=(const Scan45CountT& count) {
- for(unsigned int i = 0; i < 4; ++i) {
- counts[i] = count.counts[i];
- }
- return *this;
- }
- inline CountType& operator[](int index) { return counts[index]; }
- inline CountType operator[](int index) const {return counts[index]; }
- inline Scan45CountT& operator+=(const Scan45CountT& count){
- for(unsigned int i = 0; i < 4; ++i) {
- counts[i] += count.counts[i];
- }
- return *this;
- }
- inline Scan45CountT& operator-=(const Scan45CountT& count){
- for(unsigned int i = 0; i < 4; ++i) {
- counts[i] -= count.counts[i];
- }
- return *this;
- }
- inline Scan45CountT operator+(const Scan45CountT& count) const {
- return Scan45CountT(*this)+=count;
- }
- inline Scan45CountT operator-(const Scan45CountT& count) const {
- return Scan45CountT(*this)-=count;
- }
- inline Scan45CountT invert() const {
- return Scan45CountT(CountType())-=(*this);
- }
- inline Scan45CountT& operator+=(const Scan45ElementT<CountType>& element){
- counts[element.rise+1] += element.count; return *this;
- }
- private:
- CountType counts[4];
- };
-
- typedef Scan45CountT<Count2> Scan45Count;
-
- // inline std::ostream& operator<< (std::ostream& o, const Scan45Count& c) {
- // o << c[0] << ", " << c[1] << ", ";
- // o << c[2] << ", " << c[3];
- // return o;
- // }
-
-
- // inline std::ostream& operator<< (std::ostream& o, const Scan45Vertex& c) {
- // o << c.first << ": " << c.second;
- // return o;
- // }
-
-
- //vetex45 is sortable
- template <typename ct>
- class Vertex45T {
- public:
- Point pt;
- int rise; // 1, 0 or -1
- ct count; //dxdydTheta
- inline Vertex45T() {}
- inline Vertex45T(const Point& point, int riseIn, ct countIn) : pt(point), rise(riseIn), count(countIn) {}
- inline Vertex45T(const Vertex45T& vertex) : pt(vertex.pt), rise(vertex.rise), count(vertex.count) {}
- inline Vertex45T& operator=(const Vertex45T& vertex){
- pt = vertex.pt; rise = vertex.rise; count = vertex.count; return *this; }
- inline Vertex45T(const std::pair<Point, Point>& vertex) {}
- inline Vertex45T& operator=(const std::pair<Point, Point>& vertex){ return *this; }
- inline bool operator==(const Vertex45T& vertex) const {
- return pt == vertex.pt && rise == vertex.rise && count == vertex.count; }
- inline bool operator!=(const Vertex45T& 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 Vertex45T& 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 Vertex45T& vertex) const { return vertex < (*this); }
- inline bool operator<=(const Vertex45T& vertex) const { return !((*this) > vertex); }
- inline bool operator>=(const Vertex45T& vertex) const { return !((*this) < vertex); }
- inline Unit evalAtX(Unit xIn) const { return pt.y() + rise * (xIn - pt.x()); }
- };
-
- typedef Vertex45T<int> Vertex45;
-
- // 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 {
- private:
- Unit *x_; //x value at which to apply comparison
- int *justBefore_;
- public:
- inline lessVertex45() : x_(0), justBefore_() {}
-
- 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; }
-
- template <typename ct>
- inline bool operator () (const Vertex45T<ct>& elm1, const Vertex45T<ct>& 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);
- }
-
- template <int op, typename CountType>
- static int applyLogic(CountType count1, CountType count2){
- bool l1 = applyLogic<op>(count1);
- bool l2 = applyLogic<op>(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
- }
- template <int op>
- static bool applyLogic(Count2 count) {
- if(op == 0) { //apply or
- return count[0] > 0 || count[1] > 0;
- } else if(op == 1) { //apply and
- return count[0] > 0 && count[1] > 0;
- } else if(op == 2) { //apply not
- return count[0] > 0 && !(count[1] > 0);
- } else if(op == 3) { //apply xor
- return (count[0] > 0) ^ (count[1] > 0);
- } else
- return false;
- }
-
- template <int op>
- struct boolean_op_45_output_functor {
- template <typename cT>
- void operator()(cT& output, const Count2& count1, const Count2& count2,
- const Point& pt, int rise, direction_1d end) {
- int edgeType = applyLogic<op>(count1, count2);
- if(edgeType) {
- int multiplier = end == LOW ? -1 : 1;
- //std::cout << "cross logic: " << edgeType << std::endl;
- output.insert(output.end(), Vertex45(pt, rise, edgeType * multiplier));
- //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << std::endl;
- }
- }
- };
-
- template <int op>
- static bool applyLogic(Count1 count) {
- if(op == 0) { //apply or
- return count.count_ > 0;
- } else if(op == 1) { //apply and
- return count.count_ > 1;
- } else if(op == 3) { //apply xor
- return count.count_ % 2;
- } else
- return false;
- }
-
- template <int op>
- struct unary_op_45_output_functor {
- template <typename cT>
- void operator()(cT& output, const Count1& count1, const Count1& count2,
- const Point& pt, int rise, direction_1d end) {
- int edgeType = applyLogic<op>(count1, count2);
- if(edgeType) {
- int multiplier = end == LOW ? -1 : 1;
- //std::cout << "cross logic: " << edgeType << std::endl;
- output.insert(output.end(), Vertex45(pt, rise, edgeType * multiplier));
- //std::cout << "write out: " << crossPoint << " " << Point(eraseItrs[i]->x, eraseItrs[i]->y) << std::endl;
- }
- }
- };
-
- class lessScan45Vertex {
- public:
- inline lessScan45Vertex() {} //default constructor is only constructor
- template <typename Scan45Vertex>
- 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());
- }
- };
- template <typename S45V>
- static inline void sortScan45Vector(S45V& vec) {
- std::sort(vec.begin(), vec.end(), lessScan45Vertex());
- }
-
- template <typename CountType, typename output_functor>
- class Scan45 {
- public:
- typedef Scan45CountT<CountType> Scan45Count;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
-
- //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());
- }
- };
-
- typedef std::vector<Scan45Vertex> Scan45Vector;
-
- //definitions
- typedef std::set<Scan45ElementT<CountType>, lessScan45Element<CountType> > 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_;
- Unit x_;
- int justBefore_;
- public:
- inline Scan45() : scanData_(), crossQueue_(), crossVector_(),
- x_(std::numeric_limits<Unit>::min()), justBefore_(false) {
- lessScan45Element<CountType> lessElm(&x_, &justBefore_);
- scanData_ = std::set<Scan45ElementT<CountType>, lessScan45Element<CountType> >(lessElm);
- }
- inline Scan45(const Scan45& that) : scanData_(), crossQueue_(), crossVector_(),
- x_(std::numeric_limits<Unit>::min()), justBefore_(false) {
- (*this) = that; }
- inline Scan45& operator=(const Scan45& that) {
- x_ = that.x_;
- justBefore_ = that.justBefore_;
- crossQueue_ = that.crossQueue_;
- crossVector_ = that.crossVector_;
- lessScan45Element<CountType> lessElm(&x_, &justBefore_);
- scanData_ = std::set<Scan45ElementT<CountType>, lessScan45Element<CountType> >(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 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 end events then cross events
- //process end events
- if(!crossQueue_.empty() &&
- (*crossQueue_.begin()).x() < nextX) {
- //std::cout << "4\n";
- nextX = std::min(nextX, (*crossQueue_.begin()).x());
- }
- //std::cout << "6\n";
- justBefore_ = true;
- x_ = nextX;
- advance_(output);
- justBefore_ = false;
- 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;
- }
- CountType countBelow;
- 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";
- findCross_(eraseItrs[0]);
- continue;
- }
- //before we erase the elements we need to decide if they should be written out
- CountType currentCount = countBelow;
- for(unsigned int i = 0; i < numEdges; ++i) {
- output_functor f;
- f(output, currentCount, eraseItrs[i]->count, crossPoint, eraseItrs[i]->rise, LOW);
- 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;
- for(unsigned int i = 0; i < eraseVec.size(); ++i) {
- if(eraseVec[i] != scanData_.begin()) {
- iterator searchItr = eraseVec[i];
- --searchItr;
- if(searchVec.empty() ||
- searchVec.back() != searchItr)
- searchVec.push_back(searchItr);
- }
- scanData_.erase(eraseVec[i]);
- }
- for(unsigned int i = 0; i < searchVec.size(); ++i) {
- findCross_(searchVec[i]);
- }
- }
-
- template <class iT>
- inline iT mergeCross_(iT inputBegin, iT inputEnd) {
- Scan45Vector vec;
- 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";
- CountType verticalCount = CountType();
- Point prevPoint;
- iterator prevIter = scanData_.end();
- while(inputBegin != inputEnd &&
- (*inputBegin).first.x() == x_) {
- //std::cout << (*inputBegin) << std::endl;
- //std::cout << "loop\n";
- Scan45Vertex vertex = *inputBegin;
- //std::cout << vertex.first << std::endl;
- //if vertical count propigating up fake a null event at the next element
- if(verticalCount != CountType() && (prevIter != scanData_.end() &&
- prevIter->evalAtX(x_) < vertex.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;
- }
- }
- //std::cout << vertex.second << std::endl;
- //integrate vertex
- CountType 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
- CountType 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 != CountType()) {
- output_functor f;
- f(output, countBelow - verticalCount, countBelow, prevPoint, 2, HIGH);
- f(output, countBelow - verticalCount, countBelow, vertex.first, 2, LOW);
- }
- 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) {
- output_functor f;
- f(output, currentCount, lowIter->count, vertex.first, lowIter->rise, LOW);
- }
- currentCount = lowIter->count;
- iterator nextIter = lowIter;
- ++nextIter;
- //std::cout << "erase\n";
- scanData_.erase(lowIter);
- if(nextIter != scanData_.end())
- findCross_(nextIter);
- lowIter = nextIter;
- }
- 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(),
- Scan45ElementT<CountType>(vertex.first.x(),
- vertex.first.y(),
- i - 1, vertex.second[i]));
- findCross_(insertIter);
- output_functor f;
- f(output, countBelow, vertex.second[i], vertex.first, i - 1, HIGH);
- }
- 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 void 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);
- } 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);
- }
- }
-
- inline void 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) {
- 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) {
- scheduleCross1_(iteratorAbove, iter);
- } else if(iteratorAbove->rise == 0) {
- scheduleCross0_(iteratorAbove, iter);
- }
- }
- }
- //std::cout << std::endl;
- }
-
- inline iterator lookUp_(Unit y){
- //if just before then we need to look from 1 not -1
- return scanData_.lower_bound(Scan45ElementT<CountType>(x_, y, -1+2*justBefore_));
- }
- };
-
- template <typename CountType>
- static inline void print45Data(const std::set<Scan45ElementT<CountType>,
- lessScan45Element<CountType> >& data) {
- typename std::set<Scan45ElementT<CountType>, lessScan45Element<CountType> >::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<Count2> lessElm(&x, &justBefore);
- std::set<Scan45ElementT<Count2>, lessScan45Element<Count2> > testData(lessElm);
- //Unit size = testData.size();
- typedef std::set<Scan45ElementT<Count2>, lessScan45Element<Count2> > 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<1> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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<Count2, boolean_op_45_output_functor<0> > scan45;
- std::vector<Vertex45 > result;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- 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

Deleted: sandbox/gtl/gtl.hpp
==============================================================================
--- sandbox/gtl/gtl.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,298 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_GTL_HPP
-#define GTL_GTL_HPP
-
-//external
-#include <math.h>
-#include <vector>
-#include <deque>
-#include <map>
-#include <set>
-#include <list>
-#include <iostream>
-#include <algorithm>
-#include <limits>
-#include <iterator>
-
-#ifdef __ICC
-#pragma warning (disable:1125)
-#endif
-
-#ifdef WIN32
-#pragma warning( disable: 4996 )
-#pragma warning( disable: 4800 )
-#ifdef max
-#undef max
-#endif
-#ifdef min
-#undef min
-#endif
-#endif
-
-#include "isotropy.hpp"
-
-//point
-#include "point_data.hpp"
-#include "point_traits.hpp"
-#include "point_concept.hpp"
-
-//point 3d
-#include "point_3d_data.hpp"
-#include "point_3d_traits.hpp"
-#include "point_3d_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"
-
-//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_with_holes_data.hpp"
-#include "polygon_with_holes_data.hpp"
-#include "polygon_traits.hpp"
-
-//manhattan boolean algorithms
-#include "boolean_op.hpp"
-#include "polygon_formation.hpp"
-#include "rectangle_formation.hpp"
-#include "max_cover.hpp"
-#include "property_merge.hpp"
-#include "polygon_90_touch.hpp"
-#include "iterator_geometry_to_set.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_90_set_traits.hpp"
-//polygon set concepts
-#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_touch.hpp"
-#include "polygon_45_set_concept.hpp"
-#include "polygon_45_set_view.hpp"
-
-//arbitrary polygon algorithms
-#include "polygon_arbitrary_formation.hpp"
-#include "polygon_set_data.hpp"
-
-//general scanline
-#include "scan_arbitrary.hpp"
-#include "polygon_set_traits.hpp"
-#include "polygon_set_view.hpp"
-
-#include "polygon_set_concept.hpp"
-
-/// \mainpage gtl -- Geometry Template Library
-/// The geometry template library is a Concepts based typesystem that implements that API and algorithms for a large number of planar (2D) geometry operations. The primary algorithms provided by gtl are polygon set operations, so-called Booleans, such as polygon intersection and union. There are three classes of Booleans and associated types, which are axis-parallel (Manhattan), 45-degree restricted and arbitrary angle polygon operations. This is done because it is significantly more efficient to process geometry data when assumptions about whether it is axis-parallel or restricted to 45-degree can be made.
-
-/// \file "gtl.hpp"
-/// \brief Includes all gtl header files in the correct order to use all gtl features. Include gtl.hpp to treat gtl like a package.
-
-/// \file "isotropy.hpp"
-/// \brief Defines abstract ideas such as orientation and direction as data types that are used extensively to aid geometric programming.
-
-//point
-/// \file "point_data.hpp"
-/// \brief Defines a data structure that models point_concept by satisfying the default point_traits.
-/// \file "point_traits.hpp"
-/// \brief Defines the point_traits that must be satisfied for an object to model point_concept.
-/// \file "point_concept.hpp"
-/// \brief Defines behaviors specific to objects that model point_concept.
-
-//point 3d
-/// \file "point_3d_data.hpp"
-/// \brief Defines a data structure that models point_3d_concept by satisfying the default point_3d_traits.
-/// \file "point_3d_traits.hpp"
-/// \brief Defines the point_3d_traits that must be satisfied for an object to model point_3d_concept.
-/// \file "point_3d_concept.hpp"
-/// \brief Defines behaviors specific to objects that model point_3d_concept.
-
-/// \file "transform.hpp"
-/// \brief Defines transformations of cartesian coordinate systems through several types
-/// \file "transform_detail.hpp"
-/// \brief Details of transforms implementation
-
-//interval
-/// \file "interval_data.hpp"
-/// \brief Defines a data structure that models interval_concept by satisfying the default interval_traits.
-/// \file "interval_traits.hpp"
-/// \brief Defines the interval_traits that must be satisfied for an object to model interval_concept.
-/// \file "interval_concept.hpp"
-/// \brief Defines behaviors specific to objects that model interval_concept.
-
-//rectangle
-/// \file "rectangle_data.hpp"
-/// \brief Defines a data structure that models rectangle_concept by satisfying the default rectangle_traits.
-/// \file "rectangle_traits.hpp"
-/// \brief Defines the rectangle_traits that must be satisfied for an object to model rectangle_concept.
-/// \file "rectangle_concept.hpp"
-/// \brief Defines behaviors specific to objects that model rectangle_concept.
-
-//algorithms needed by polygon types
-/// \file "iterator_points_to_compact.hpp"
-/// \brief Details of an iterator filter that converts a sequence of points of a manhattan polygon to non-redundant coordinate values.
-/// \file "iterator_compact_to_points.hpp"
-/// \brief Details of an iterator filter that converts a sequence of non-redundant coordinate values to the points of a manhattan polygon.
-
-//polygons
-/// \file "polygon_45_data.hpp"
-/// \brief Defines a data structure that models polygon_45_concept by satisfying the default rectangle_traits.
-/// \file "polygon_data.hpp"
-/// \brief Defines a data structure that models polygon_concept by satisfying the default rectangle_traits.
-/// \file "polygon_90_data.hpp"
-/// \brief Defines a data structure that models polygon_90_concept by satisfying the default rectangle_traits.
-/// \file "polygon_90_with_holes_data.hpp"
-/// \brief Defines a data structure that models polygon_90_with_holes_concept by satisfying the default rectangle_traits.
-/// \file "polygon_45_with_holes_data.hpp"
-/// \brief Defines a data structure that models polygon_45_with_holes_concept by satisfying the default rectangle_traits.
-/// \file "polygon_with_holes_data.hpp"
-/// \brief Defines a data structure that models polygon_with_holes_concept by satisfying the default rectangle_traits.
-/// \file "polygon_traits.hpp"
-/// \brief Defines the traits that must be satisfied for an object to model any of the polygonal concepts as well as behaviors of those concepts.
-
-//manhattan boolean algorithms
-/// \file "boolean_op.hpp"
-/// \brief Details of the generic framework for scanline algorithm on manhattan polygonal data.
-/// \file "polygon_formation.hpp"
-/// \brief Details of the scanline algorithm for forming polygons from manhattan polygonal data and associating holes to outer shells.
-/// \file "rectangle_formation.hpp"
-/// \brief Details of the scanline algorithm for forming rectangles from manhattan polygonal data.
-/// \file "max_cover.hpp"
-/// \brief Details of the visibility algorithm for computing largest enclosed rectangles contained within manhattan polygonal data.
-/// \file "property_merge.hpp"
-/// \brief Details of the scanline algorithm for merging properties from many manhattan polygonal data inputs.
-/// \file "polygon_90_touch.hpp"
-//
-/// \file "iterator_geometry_to_set.hpp"
-//
-
-//45 boolean op algorithms
-/// \file "boolean_op_45.hpp"
-//
-/// \file "polygon_45_formation.hpp"
-
-//polygon set data types
-/// \file "polygon_90_set_data.hpp"
-//polygon set trait types
-/// \file "polygon_90_set_traits.hpp"
-//polygon set concepts
-/// \file "polygon_90_set_concept.hpp"
-//boolean operator syntax
-/// \file "polygon_90_set_view.hpp"
-//
-
-//45 boolean op algorithms
-/// \file "boolean_op_45.hpp"
-//
-/// \file "polygon_45_formation.hpp"
-//
-/// \file "polygon_45_set_data.hpp"
-//
-/// \file "polygon_45_set_traits.hpp"
-//
-/// \file "polygon_45_touch.hpp"
-//
-/// \file "polygon_45_set_concept.hpp"
-//
-/// \file "polygon_45_set_view.hpp"
-//
-
-//arbitrary polygon algorithms
-/// \file "polygon_arbitrary_formation.hpp"
-//
-/// \file "polygon_set_data.hpp"
-//
-
-//general scanline
-/// \file "scan_arbitrary.hpp"
-//
-/// \file "polygon_set_traits.hpp"
-//
-/// \file "polygon_set_view.hpp"
-//
-
-/// \file "polygon_set_concept.hpp"
-//
-
-
-/// \defgroup d_concepts Concepts
-/// \brief These are the geometry concepts provided by gtl.
-/// \details A geometry concept is the idea of a geometry, a given data structure may model a certain geometry concept if it is able to provide a complete concept traits definition for that concept.
-/// @{
-/// \struct coordinate_concept
-/// \brief coordinate_concept is a numeric
-/// \details Behaviors specific to coordinate_concept are defined in \ref isotropy.hpp
-/// defgroup d_polygon_concept_functions Polygon Concept Functions
-
-/// \struct interval_concept
-/// \brief interval_concept is one dimensional interval
-/// \details Behaviors specific to interval_concept are defined in \ref interval_concept.hpp
-/// \par An interval is inclusive of all the values one the number line between its low and high coordinate values.
-
-/// \struct point_concept
-/// \brief point_concept is two dimensional point
-//
-/// \struct point_3d_concept
-/// \brief point_3d_concept is two dimensional point
-//
-/// \struct rectangle_concept
-/// \brief rectangle_concept is two dimensional axis-parallel (Manhattan) rectangle often used as a bounding box
-//
-/// \struct polygon_concept
-/// \brief polygon_concept is a two dimensional polygon
-//
-/// \struct polygon_with_holes_concept
-/// \brief polygon_with_holes_concept is a refinement of polygon_concept and extends it with holes that are themselves two dimensional polygons
-//
-/// \struct polygon_45_concept
-/// \brief polygon_45_concept is a refinement of polygon_concept and extends it with the restriction that angles formed at corners are multiples of 45 degrees
-//
-/// \struct polygon_45_with_holes_concept
-/// \brief polygon_45_with_holes_concept is a refinement of polygon_45_concept and polygon_with_holes_concept and extends them with the restriction that holes are of conceptual type polygon_45_concept
-//
-/// \struct polygon_90_concept
-/// \brief polygon_90_concept is a refinement of polygon_45_concept and extends it with the restriction that angles formed at corners are right angles and edges are axis-parallel (Manhattan)
-//
-/// \struct polygon_90_with_holes_concept
-/// \brief polygon_90_with_holes_concept is a refinement of polygon_90_concept and polygon_45_with_holes_concept and extends them with the restriction that holes are of conceptual type polygon_90_concept
-//
-/// @}
-//
-
-#if __ICC
-#pragma warning (default:1125)
-#endif
-#endif

Modified: sandbox/gtl/gtl/boolean_op.hpp
==============================================================================
--- sandbox/gtl/gtl/boolean_op.hpp (original)
+++ sandbox/gtl/gtl/boolean_op.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -26,9 +26,9 @@
     typename ScanData::iterator nextItr_;
     T nullT_;
   public:
- inline BooleanOp () { nextItr_ = scanData_.end(); nullT_ = 0; }
- inline BooleanOp (T nullT) : nullT_(nullT) { nextItr_ = scanData_.end(); }
- inline BooleanOp (const BooleanOp& that) : scanData_(that.scanData_),
+ inline BooleanOp () : scanData_(), nextItr_(), nullT_() { nextItr_ = scanData_.end(); nullT_ = 0; }
+ inline BooleanOp (T nullT) : scanData_(), nextItr_(), nullT_(nullT) { nextItr_ = scanData_.end(); }
+ inline BooleanOp (const BooleanOp& that) : scanData_(that.scanData_), nextItr_(),
                                                nullT_(that.nullT_) { nextItr_ = scanData_.begin(); }
     inline BooleanOp& operator=(const BooleanOp& that);
    
@@ -85,12 +85,12 @@
   template <class T>
   class BinaryCount {
   public:
- inline BinaryCount() { counts_[0] = counts_[1] = 0; }
+ inline BinaryCount() : counts_() { counts_[0] = counts_[1] = 0; }
     // constructs from two integers
- inline BinaryCount(int countL, int countR) { counts_[0] = countL, counts_[1] = countR; }
+ inline BinaryCount(int countL, int countR) : counts_() { counts_[0] = countL, counts_[1] = countR; }
     inline BinaryCount& operator=(int count) { counts_[0] = count, counts_[1] = count; }
     inline BinaryCount& operator=(const BinaryCount& that);
- inline BinaryCount(const BinaryCount& that) { *this = that; }
+ inline BinaryCount(const BinaryCount& that) : counts_() { *this = that; }
     inline bool operator==(const BinaryCount& that) const;
     inline bool operator!=(const BinaryCount& that) const { return !((*this) == that);}
     inline BinaryCount& operator+=(const BinaryCount& that);
@@ -108,12 +108,12 @@
 
   class UnaryCount {
   public:
- inline UnaryCount() { count_ = 0; }
+ inline UnaryCount() : count_(0) {}
     // constructs from two integers
- inline explicit UnaryCount(int count) { count_ = count; }
+ inline explicit UnaryCount(int count) : count_(count) {}
     inline UnaryCount& operator=(int count) { count_ = count; return *this; }
     inline UnaryCount& operator=(const UnaryCount& that) { count_ = that.count_; return *this; }
- inline UnaryCount(const UnaryCount& that) { *this = that; }
+ inline UnaryCount(const UnaryCount& that) : count_(that.count_) {}
     inline bool operator==(const UnaryCount& that) const { return count_ == that.count_; }
     inline bool operator!=(const UnaryCount& that) const { return !((*this) == that);}
     inline UnaryCount& operator+=(const UnaryCount& that) { count_ += that.count_; return *this; }

Modified: sandbox/gtl/gtl/boolean_op_45.hpp
==============================================================================
--- sandbox/gtl/gtl/boolean_op_45.hpp (original)
+++ sandbox/gtl/gtl/boolean_op_45.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -16,10 +16,10 @@
 
     class Count2 {
     public:
- inline Count2() { counts[0] = counts[1] = 0; }
+ inline Count2() : counts() { 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 Count2(int count1, int count2) : counts() { counts[0] = count1; counts[1] = count2; }
+ inline Count2(const Count2& count) : counts() { 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; }
@@ -51,9 +51,9 @@
 
     class Count1 {
     public:
- inline Count1() { count_ = 0; }
- inline Count1(int count) { count_ = count; }
- inline Count1(const Count1& count) { count_ = count.count_; }
+ inline Count1() : count_(0) { }
+ inline Count1(int count) : count_(count) { }
+ inline Count1(const Count1& count) : count_(count.count_) { }
       inline bool operator==(const Count1& count) const { return count_ == count.count_; }
       inline bool operator!=(const Count1& count) const { return !((*this) == count); }
       inline Count1& operator=(int count) { count_ = count; return *this; }
@@ -152,7 +152,7 @@
       Unit *x_; //x value at which to apply comparison
       int *justBefore_;
     public:
- inline lessScan45Element() : x_(0) {}
+ inline lessScan45Element() : x_(0), justBefore_(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; }
@@ -176,16 +176,16 @@
     template <typename CountType>
     class Scan45CountT {
     public:
- inline Scan45CountT() {} //counts[0] = counts[1] = counts[2] = counts[3] = 0; }
- inline Scan45CountT(CountType count) { counts[0] = counts[1] = counts[2] = counts[3] = count; }
+ inline Scan45CountT() : counts() {} //counts[0] = counts[1] = counts[2] = counts[3] = 0; }
+ inline Scan45CountT(CountType count) : counts() { counts[0] = counts[1] = counts[2] = counts[3] = count; }
       inline Scan45CountT(const CountType& count1, const CountType& count2, const CountType& count3,
- const CountType& count4) {
+ const CountType& count4) : counts() {
         counts[0] = count1;
         counts[1] = count2;
         counts[2] = count3;
         counts[3] = count4;
       }
- inline Scan45CountT(const Scan45CountT& count) {
+ inline Scan45CountT(const Scan45CountT& count) : counts() {
         (*this) = count;
       }
       inline bool operator==(const Scan45CountT& count) const {
@@ -294,7 +294,7 @@
       Unit *x_; //x value at which to apply comparison
       int *justBefore_;
     public:
- inline lessVertex45() : x_(0) {}
+ inline lessVertex45() : x_(0), justBefore_() {}
       
       inline lessVertex45(Unit *x, int *justBefore) : x_(x), justBefore_(justBefore) {}
       
@@ -458,11 +458,14 @@
       Unit x_;
       int justBefore_;
     public:
- inline Scan45() : x_(std::numeric_limits<Unit>::min()), justBefore_(false) {
+ inline Scan45() : scanData_(), crossQueue_(), crossVector_(),
+ x_(std::numeric_limits<Unit>::min()), justBefore_(false) {
         lessScan45Element<CountType> lessElm(&x_, &justBefore_);
         scanData_ = std::set<Scan45ElementT<CountType>, lessScan45Element<CountType> >(lessElm);
       }
- inline Scan45(const Scan45& that) { (*this) = that; }
+ inline Scan45(const Scan45& that) : scanData_(), crossQueue_(), crossVector_(),
+ x_(std::numeric_limits<Unit>::min()), justBefore_(false) {
+ (*this) = that; }
       inline Scan45& operator=(const Scan45& that) {
         x_ = that.x_;
         justBefore_ = that.justBefore_;
@@ -723,6 +726,8 @@
             ++nextIter;
             //std::cout << "erase\n";
             scanData_.erase(lowIter);
+ if(nextIter != scanData_.end())
+ findCross_(nextIter);
             lowIter = nextIter;
           }
           verticalCount += vertex.second[3];

Modified: sandbox/gtl/gtl/interval_data.hpp
==============================================================================
--- sandbox/gtl/gtl/interval_data.hpp (original)
+++ sandbox/gtl/gtl/interval_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -13,11 +13,11 @@
   class interval_data {
   public:
     typedef T coordinate_type;
- inline interval_data(){}
- inline interval_data(coordinate_type low, coordinate_type high) {
+ inline interval_data():coords_(){}
+ inline interval_data(coordinate_type low, coordinate_type high):coords_() {
       coords_[LOW] = low; coords_[HIGH] = high;
     }
- inline interval_data(const interval_data& that) {
+ inline interval_data(const interval_data& that):coords_() {
       (*this) = that;
     }
     inline interval_data& operator=(const interval_data& that) {

Modified: sandbox/gtl/gtl/isotropy.hpp
==============================================================================
--- sandbox/gtl/gtl/isotropy.hpp (original)
+++ sandbox/gtl/gtl/isotropy.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -113,7 +113,7 @@
 
   struct gtl_no { static const bool value = false; };
   struct gtl_yes { typedef gtl_yes type;
- static const bool value = true; };
+ static const bool value = true; };
 
   template <typename T, typename T2>
   struct gtl_and { typedef gtl_no type; };
@@ -130,7 +130,7 @@
                        T, typename gtl_and<T2, T3>::type>::type type; };
   template <typename T, typename T2, typename T3>
   struct gtl_or_3 { typedef typename gtl_or<
- T, typename gtl_or<T2, T3>::type>::type type; };
+ T, typename gtl_or<T2, T3>::type>::type type; };
 
   template <typename T, typename T2, typename T3, typename T4>
   struct gtl_or_4 { typedef typename gtl_or<
@@ -171,55 +171,55 @@
   struct is_different_type_SFINAE<T, T> {};
 
   namespace boost_copy {
- template <bool B, class T = void>
- struct enable_if_c {
- typedef T type;
- };
+ template <bool B, class T = void>
+ struct enable_if_c {
+ typedef T type;
+ };
 
- template <class T>
- struct enable_if_c<false, T> {};
+ template <class T>
+ struct enable_if_c<false, T> {};
 
- template <class Cond, class T = void>
- struct enable_if : public enable_if_c<Cond::value, T> {};
+ template <class Cond, class T = void>
+ struct enable_if : public enable_if_c<Cond::value, T> {};
 
- template <bool B, class T>
- struct lazy_enable_if_c {
- typedef typename T::type type;
- };
+ template <bool B, class T>
+ struct lazy_enable_if_c {
+ typedef typename T::type type;
+ };
 
- template <class T>
- struct lazy_enable_if_c<false, T> {};
+ template <class T>
+ struct lazy_enable_if_c<false, T> {};
 
- template <class Cond, class T>
- struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+ template <class Cond, class T>
+ struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
 
 
- template <bool B, class T = void>
- struct disable_if_c {
- typedef T type;
- };
+ template <bool B, class T = void>
+ struct disable_if_c {
+ typedef T type;
+ };
 
- template <class T>
- struct disable_if_c<true, T> {};
+ template <class T>
+ struct disable_if_c<true, T> {};
 
- template <class Cond, class T = void>
- struct disable_if : public disable_if_c<Cond::value, T> {};
+ template <class Cond, class T = void>
+ struct disable_if : public disable_if_c<Cond::value, T> {};
 
- template <bool B, class T>
- struct lazy_disable_if_c {
- typedef typename T::type type;
- };
+ template <bool B, class T>
+ struct lazy_disable_if_c {
+ typedef typename T::type type;
+ };
 
- template <class T>
- struct lazy_disable_if_c<true, T> {};
+ template <class T>
+ struct lazy_disable_if_c<true, T> {};
 
- template <class Cond, class T>
- struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
-}
-// template <typename T1, typename T2>
-// struct requires_1 {};
-// template <typename T2>
-// struct requires_1<gtl_yes, T2> { typedef T2 type; };
+ template <class Cond, class T>
+ struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+ }
+ // template <typename T1, typename T2>
+ // struct requires_1 {};
+ // template <typename T2>
+ // struct requires_1<gtl_yes, T2> { typedef T2 type; };
 #define requires_1 boost_copy::enable_if
 
   struct manhattan_domain {};
@@ -247,231 +247,222 @@
 
 
 
-// predicated_swap swaps a and b if pred is true
+ // 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,
- CLOCKWISE = 0, COUNTERCLOCKWISE = 1,
- REVERSE = 0, FORWARD = 1,
- NEGATIVE = 0, POSITIVE = 1 };
-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,
- unknown_winding = 2
-};
-
-class direction_2d;
-class direction_3d;
-class orientation_2d;
-
-class direction_1d {
-private:
- unsigned int val_;
- explicit direction_1d(int d);
-public:
- 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; }
- 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;
-
-class orientation_2d {
-private:
- unsigned int val_;
- explicit inline orientation_2d(int o);
-public:
- 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; }
- 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;
+ // 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;
   }
- inline direction_2d get_direction(direction_1d dir) const;
-};
 
-class direction_2d {
-private:
- int val_;
+ enum direction_1d_enum { LOW = 0, HIGH = 1,
+ LEFT = 0, RIGHT = 1,
+ CLOCKWISE = 0, COUNTERCLOCKWISE = 1,
+ REVERSE = 0, FORWARD = 1,
+ NEGATIVE = 0, POSITIVE = 1 };
+ 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,
+ unknown_winding = 2
+ };
 
-public:
+ class direction_2d;
+ class direction_3d;
+ class orientation_2d;
+
+ class direction_1d {
+ private:
+ unsigned int val_;
+ explicit direction_1d(int d);
+ public:
+ 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; }
+ 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; }
+ };
 
- inline direction_2d() { val_ = WEST; }
+ class direction_2d;
 
- inline direction_2d(const direction_2d& that) : val_(that.val_) {}
-
- inline direction_2d(const direction_2d_enum val) : val_(val) {}
+ class orientation_2d {
+ private:
+ unsigned int val_;
+ explicit inline orientation_2d(int o);
+ public:
+ 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; }
+ 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;
+ }
+ inline direction_2d get_direction(direction_1d dir) const;
+ };
 
- inline direction_2d& operator=(const direction_2d& d) {
- val_ = d.val_;
- return * this;
- }
+ class direction_2d {
+ private:
+ int val_;
 
- inline ~direction_2d() { }
+ public:
 
- 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
- inline unsigned int to_int(void) const { return val_; }
-
- inline direction_2d backward() const {
- // flip the LSB, toggles 0 - 1 and 2 - 3
- return direction_2d(direction_2d_enum(val_ ^ 1));
- }
+ inline direction_2d() : val_(WEST) {}
 
- // Returns a direction 90 degree left (LOW) or right(HIGH) to this one
- inline direction_2d turn(direction_1d t) const {
- return direction_2d(direction_2d_enum(val_ ^ 3 ^ (val_ >> 1) ^ t.to_int()));
- }
+ inline direction_2d(const direction_2d& that) : val_(that.val_) {}
+
+ inline direction_2d(const direction_2d_enum val) : val_(val) {}
 
- // Returns a direction 90 degree left to this one
- inline direction_2d left() const {return turn(HIGH);}
+ inline direction_2d& operator=(const direction_2d& d) {
+ val_ = d.val_;
+ return * this;
+ }
+
+ inline ~direction_2d() { }
+
+ 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
+ inline unsigned int to_int(void) const { return val_; }
+
+ 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
+ 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
+ inline direction_2d left() const {return turn(HIGH);}
+
+ // Returns a direction 90 degree right to this one
+ inline direction_2d right() const {return turn(LOW);}
+
+ // 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;}
 
- // Returns a direction 90 degree right to this one
- inline direction_2d right() const {return turn(LOW);}
+ };
 
- // 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_2d& that) : val_(that.to_int() & 1) {}
 
-};
+ orientation_2d::orientation_2d(const direction_2d& that) : val_(that.to_int() >> 1) {}
 
-direction_1d::direction_1d(const direction_2d& that) {
- val_ = that.to_int() & 1;
-}
-orientation_2d::orientation_2d(const direction_2d& that) {
- val_ = that.to_int() >> 1;
-}
+ direction_2d orientation_2d::get_direction(direction_1d dir) const {
+ return direction_2d(direction_2d_enum((val_ << 1) + dir.to_int()));
+ }
 
-direction_2d orientation_2d::get_direction(direction_1d dir) const {
- return direction_2d(direction_2d_enum((val_ << 1) + dir.to_int()));
-}
+ class orientation_3d {
+ private:
+ unsigned int val_;
+ explicit inline orientation_3d(int o);
+ public:
+ 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; }
+ 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 orientation_3d {
-private:
- unsigned int val_;
- explicit inline orientation_3d(int o);
-public:
- 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; }
- 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_;
+ class direction_3d {
+ private:
+ int val_;
 
-public:
+ public:
 
- inline direction_3d() { val_ = WEST; }
+ 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(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(const direction_2d_enum val) : val_(val) {}
+ inline direction_3d(const direction_3d_enum val) : val_(val) {}
 
- inline ~direction_3d() { }
+ 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;}
 
- 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_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()));
-}
+ direction_3d orientation_3d::get_direction(direction_1d dir) const {
+ return direction_3d(direction_3d_enum((val_ << 1) + dir.to_int()));
+ }
 
 
 }

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-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -23,9 +23,9 @@
   typedef const point_type* pointer; //immutable
   typedef const point_type& reference; //immutable
 
- inline iterator_compact_to_points() {}
+ inline iterator_compact_to_points() : iter_(), iter_end_(), pt_(), firstX_(), orient_() {}
   inline iterator_compact_to_points(iterator_type iter, iterator_type iter_end) :
- iter_(iter), iter_end_(iter_end), orient_(HORIZONTAL) {
+ iter_(iter), iter_end_(iter_end), pt_(), firstX_(), orient_(HORIZONTAL) {
     if(iter_ != iter_end_) {
       firstX_ = *iter_;
       x(pt_, firstX_);

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-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -27,9 +27,10 @@
   orientation_2d orient_;
   bool is_hole_;
 public:
- iterator_geometry_to_set() : corner_(4) {}
+ iterator_geometry_to_set() : rectangle_(), vertex_(), corner_(4), orient_(), is_hole_() {}
   iterator_geometry_to_set(const rectangle_type& rectangle, direction_1d dir,
- orientation_2d orient = HORIZONTAL, bool is_hole = false) : corner_(0), orient_(orient), is_hole_(is_hole) {
+ orientation_2d orient = HORIZONTAL, bool is_hole = false) :
+ rectangle_(), vertex_(), corner_(0), orient_(orient), is_hole_(is_hole) {
     assign(rectangle_, rectangle);
     if(dir == HIGH) corner_ = 4;
   }
@@ -91,9 +92,11 @@
   orientation_2d orient_;
   int polygon_index;
 public:
- iterator_geometry_to_set() : polygon_index(-1) {}
+ iterator_geometry_to_set() : vertex_(), itrb(), itre(), last_vertex_(), is_hole_(), multiplier_(), first_pt(), second_pt(), pts(), use_wrap(), orient_(), 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) {
+ vertex_(), itrb(), itre(), last_vertex_(),
+ is_hole_(is_hole), multiplier_(), first_pt(), second_pt(), pts(), use_wrap(),
+ orient_(orient), polygon_index(0) {
     itrb = begin_points(polygon);
     itre = end_points(polygon);
     use_wrap = false;
@@ -160,10 +163,16 @@
   inline void evaluate_() {
     vertex_.first = pts[1].get(orient_.get_perpendicular());
     vertex_.second.first =pts[1].get(orient_);
+ if(pts[1] == pts[2]) {
+ vertex_.second.second = 0;
+ return;
+ }
     if(pts[0].get(HORIZONTAL) != pts[1].get(HORIZONTAL)) {
       vertex_.second.second = -1;
- } else {
+ } else if(pts[0].get(VERTICAL) != pts[1].get(VERTICAL)) {
       vertex_.second.second = 1;
+ } else {
+ vertex_.second.second = 0;
     }
     vertex_.second.second *= multiplier_;
   }
@@ -186,9 +195,10 @@
   bool is_hole_;
   bool started_holes;
 public:
- iterator_geometry_to_set() {}
+ iterator_geometry_to_set() : itrb(), itre(), itrhib(), itrhie(), itrhb(), itrhe(), orient_(), is_hole_(), started_holes() {}
   iterator_geometry_to_set(const polygon_with_holes_type& polygon, direction_1d dir,
- orientation_2d orient = HORIZONTAL, bool is_hole = false) : orient_(orient), is_hole_(is_hole) {
+ orientation_2d orient = HORIZONTAL, bool is_hole = false) :
+ itrb(), itre(), itrhib(), itrhie(), itrhb(), itrhe(), orient_(orient), is_hole_(is_hole), started_holes() {
     itre = iterator_geometry_to_set<polygon_90_concept, polygon_with_holes_type>(polygon, HIGH, orient, is_hole_);
     itrhe = end_holes(polygon);
     if(dir == HIGH) {

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-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -22,10 +22,11 @@
   typedef const coordinate_type* pointer; //immutable
   typedef const coordinate_type& reference; //immutable
 
- inline iterator_points_to_compact() {}
- explicit inline iterator_points_to_compact(iT iter, iT iterEnd) : iter_(iter), iterEnd_(iterEnd), orient_(HORIZONTAL) {}
+ inline iterator_points_to_compact() : iter_(), iterEnd_(), orient_(), coord_() {}
+ explicit inline iterator_points_to_compact(iT iter, iT iterEnd) :
+ iter_(iter), iterEnd_(iterEnd), orient_(HORIZONTAL), coord_() {}
   inline iterator_points_to_compact(const iterator_points_to_compact& that) :
- iter_(that.iter_), orient_(that.orient_) {}
+ iter_(that.iter_), iterEnd_(that.iterEnd_), orient_(that.orient_), coord_(that.coord_) {}
   //use bitwise copy and assign provided by the compiler
   inline iterator_points_to_compact& operator++() {
     //iT tmp = iter_;

Modified: sandbox/gtl/gtl/max_cover.hpp
==============================================================================
--- sandbox/gtl/gtl/max_cover.hpp (original)
+++ sandbox/gtl/gtl/max_cover.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -20,8 +20,8 @@
       std::set<Interval> tracedPaths_;
     public:
       Rectangle rect;
- Node() {}
- Node(const Rectangle rectIn) : rect(rectIn) {}
+ Node() : children_(), tracedPaths_(), rect() {}
+ Node(const Rectangle rectIn) : children_(), tracedPaths_(), rect(rectIn) {}
       typedef typename std::vector<Node*>::iterator iterator;
       inline iterator begin() { return children_.begin(); }
       inline iterator end() { return children_.end(); }
@@ -54,6 +54,7 @@
       }
       node->addPath(rectIvl);
       if(node->begin() == node->end()) {
+ //std::cout << "WRITE OUT 3: " << node->rect << std::endl;
         outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(node->rect));
         return;
       }
@@ -64,10 +65,110 @@
         if(contains(nodeIvl, rectIvl, true)) writeOut = false;
       }
       if(writeOut) {
+ //std::cout << "WRITE OUT 2: " << node->rect << std::endl;
         outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(node->rect));
       }
     }
 
+ struct stack_element {
+ inline stack_element() :
+ node(), rect(), itr() {}
+ inline stack_element(Node* n,
+ const Rectangle& r,
+ typename Node::iterator i) :
+ node(n), rect(r), itr(i) {}
+ Node* node;
+ Rectangle rect;
+ typename Node::iterator itr;
+ };
+
+ template <class cT>
+ static inline void getMaxCover(cT& outputContainer, Node* node, orientation_2d orient,
+ Rectangle rect) {
+ //std::cout << "New Root\n";
+ std::vector<stack_element> stack;
+ typename Node::iterator itr = node->begin();
+ do {
+ //std::cout << "LOOP\n";
+ //std::cout << node->rect << std::endl;
+ Interval rectIvl = rect.get(orient);
+ Interval nodeIvl = node->rect.get(orient);
+ bool iresult = intersect(rectIvl, nodeIvl, false);
+ bool tresult = !node->tracedPath(rectIvl);
+ //std::cout << (itr != node->end()) << " " << iresult << " " << tresult << std::endl;
+ Rectangle nextRect = Rectangle(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));
+ if(iresult && tresult) {
+ node->addPath(rectIvl);
+ bool writeOut = true;
+ //check further visibility beyond this node
+ for(typename Node::iterator itr2 = node->begin(); itr2 != node->end(); ++itr2) {
+ Interval nodeIvl3 = (*itr2)->rect.get(orient);
+ //if a child of this node can contain the interval then we can extend through
+ if(contains(nodeIvl3, rectIvl, true)) writeOut = false;
+ //std::cout << "child " << (*itr2)->rect << std::endl;
+ }
+ Rectangle nextRect = Rectangle(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));
+ if(writeOut) {
+ //std::cout << "write out " << nextRect << std::endl;
+ outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
+ } else {
+ //std::cout << "supress " << nextRect << std::endl;
+ }
+ }
+ if(itr != node->end() && iresult && tresult) {
+ //std::cout << "recurse into child\n";
+ stack.push_back(stack_element(node, rect, itr));
+ rect = nextRect;
+ node = *itr;
+ itr = node->begin();
+ } else {
+ if(!stack.empty()) {
+ //std::cout << "recurse out of child\n";
+ node = stack.back().node;
+ rect = stack.back().rect;
+ itr = stack.back().itr;
+ stack.pop_back();
+ } else {
+ //std::cout << "empty stack\n";
+ //if there were no children of the root node
+// Rectangle nextRect = Rectangle(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));
+// outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
+ }
+ //std::cout << "increment " << (itr != node->end()) << std::endl;
+ if(itr != node->end()) {
+ ++itr;
+ if(itr != node->end()) {
+ //std::cout << "recurse into next child.\n";
+ stack.push_back(stack_element(node, rect, itr));
+ Interval rectIvl2 = rect.get(orient);
+ Interval nodeIvl2 = node->rect.get(orient);
+ bool iresult = intersect(rectIvl2, nodeIvl2, false);
+ Rectangle nextRect2 = Rectangle(rectIvl2, rectIvl2);
+ Unit low2 = rect.get(orient.get_perpendicular()).low();
+ Unit high2 = node->rect.get(orient.get_perpendicular()).high();
+ nextRect2.set(orient.get_perpendicular(), Interval(low2, high2));
+ rect = nextRect2;
+ //std::cout << "rect for next child" << rect << std::endl;
+ node = *itr;
+ itr = node->begin();
+ }
+ }
+ }
+ } while(!stack.empty() || itr != node->end());
+ }
+
+ /* Function recursive version of getMaxCover
+ Because the code is so much simpler than the loop algorithm I retain it for clarity
+
     template <class cT>
     static inline void getMaxCover(cT& outputContainer, Node* node, orientation_2d orient,
                                    const Rectangle& rect) {
@@ -89,15 +190,16 @@
       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));
       }
+ for(typename Node::iterator itr = node->begin(); itr != node->end(); ++itr) {
+ getMaxCover(outputContainer, *itr, orient, 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>
@@ -169,7 +271,6 @@
       }
     }
 
-
   };
 
 }

Modified: sandbox/gtl/gtl/point_3d_data.hpp
==============================================================================
--- sandbox/gtl/gtl/point_3d_data.hpp (original)
+++ sandbox/gtl/gtl/point_3d_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -12,12 +12,12 @@
   class point_3d_data {
   public:
     typedef T coordinate_type;
- inline point_3d_data(){}
- inline point_3d_data(coordinate_type x, coordinate_type y) {
+ inline point_3d_data():coords_(){}
+ inline point_3d_data(coordinate_type x, coordinate_type y):coords_() {
       coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = 0; }
- inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z) {
+ inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z):coords_() {
       coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = z; }
- inline point_3d_data(const point_3d_data& that) { (*this) = that; }
+ inline point_3d_data(const point_3d_data& that):coords_() { (*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; }

Modified: sandbox/gtl/gtl/point_data.hpp
==============================================================================
--- sandbox/gtl/gtl/point_data.hpp (original)
+++ sandbox/gtl/gtl/point_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -16,11 +16,11 @@
   class point_data {
   public:
     typedef T coordinate_type;
- inline point_data(){}
- inline point_data(coordinate_type x, coordinate_type y) {
+ inline point_data():coords_(){}
+ inline point_data(coordinate_type x, coordinate_type y):coords_() {
       coords_[HORIZONTAL] = x; coords_[VERTICAL] = y;
     }
- inline point_data(const point_data& that) { (*this) = that; }
+ inline point_data(const point_data& that):coords_() { (*this) = that; }
     inline point_data& operator=(const point_data& that) {
       coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
     }

Modified: sandbox/gtl/gtl/polygon_45_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -18,7 +18,7 @@
   typedef typename coordinate_traits<T>::coordinate_distance area_type;
   typedef point_data<T> point_type;
 
- inline polygon_45_data(){;} //do nothing default constructor
+ inline polygon_45_data() : coords_() {} //do nothing default constructor
 
   template<class iT>
   inline polygon_45_data(iT input_begin, iT input_end) : coords_(input_begin, input_end) {}

Modified: sandbox/gtl/gtl/polygon_45_formation.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_formation.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -36,7 +36,7 @@
       typedef typename std::list<Point>::const_iterator iterator;
 
       // default constructor of point does not initialize x and y
- inline PolyLine45(){;} //do nothing default constructor
+ inline PolyLine45() : points() {} //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
@@ -91,10 +91,11 @@
       typedef typename std::list<ActiveTail45*>::const_iterator iteratorHoles;
    
       //default constructor
- inline ActiveTail45() : tailp_(0), otherTailp_(0), head_(0) {}
+ inline ActiveTail45() : tailp_(0), otherTailp_(0), holesList_(), head_(0) {}
    
       //constructor
- inline ActiveTail45(const Vertex45& vertex, ActiveTail45* otherTailp = 0) {
+ inline ActiveTail45(const Vertex45& vertex, ActiveTail45* otherTailp = 0) :
+ tailp_(0), otherTailp_(0), holesList_(), head_(0) {
         tailp_ = new PolyLine45;
         tailp_->points.push_back(vertex.pt);
         bool headArray[4] = {false, true, true, true};
@@ -103,20 +104,23 @@
         otherTailp_ = otherTailp;
       }
 
- inline ActiveTail45(Point point, ActiveTail45* otherTailp, bool head = true) {
+ inline ActiveTail45(Point point, ActiveTail45* otherTailp, bool head = true) :
+ tailp_(0), otherTailp_(0), holesList_(), head_(0) {
         tailp_ = new PolyLine45;
         tailp_->points.push_back(point);
         head_ = head;
         otherTailp_ = otherTailp;
       
       }
- inline ActiveTail45(ActiveTail45* otherTailp) {
+ inline ActiveTail45(ActiveTail45* otherTailp) :
+ tailp_(0), otherTailp_(0), holesList_(), head_(0) {
         tailp_ = otherTailp->tailp_;
         otherTailp_ = otherTailp;
       }
 
       //copy constructor
- inline ActiveTail45(const ActiveTail45& that) { (*this) = that; }
+ inline ActiveTail45(const ActiveTail45& that) :
+ tailp_(0), otherTailp_(0), holesList_(), head_(0) { (*this) = that; }
 
       //destructor
       inline ~ActiveTail45() {
@@ -390,20 +394,20 @@
     class Vertex45CountT {
     public:
       typedef ct count_type;
- inline Vertex45CountT() { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
+ inline Vertex45CountT() : counts() { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
       //inline Vertex45CountT(ct count) { counts[0] = counts[1] = counts[2] = counts[3] = count; }
       inline Vertex45CountT(const ct& count1, const ct& count2, const ct& count3,
- const ct& count4) {
+ const ct& count4) : counts() {
         counts[0] = count1;
         counts[1] = count2;
         counts[2] = count3;
         counts[3] = count4;
       }
- inline Vertex45CountT(const Vertex45& vertex) {
+ inline Vertex45CountT(const Vertex45& vertex) : counts() {
         counts[0] = counts[1] = counts[2] = counts[3] = 0;
         (*this) += vertex;
       }
- inline Vertex45CountT(const Vertex45CountT& count) {
+ inline Vertex45CountT(const Vertex45CountT& count) : counts() {
         (*this) = count;
       }
       inline bool operator==(const Vertex45CountT& count) const {
@@ -468,18 +472,16 @@
       Point pt;
       ct count;
       typedef typename boolean_op_45<Unit>::template Vertex45T<typename ct::count_type> Vertex45T;
- inline Vertex45CompactT() {}
- inline Vertex45CompactT(const Point& point, int riseIn, int countIn) : pt(point) {
+ inline Vertex45CompactT() : pt(), count() {}
+ inline Vertex45CompactT(const Point& point, int riseIn, int countIn) : pt(point), count() {
         count[riseIn+1] = countIn;
       }
- inline Vertex45CompactT(const Vertex45T& vertex) : pt(vertex.pt) {
+ inline Vertex45CompactT(const Vertex45T& vertex) : pt(vertex.pt), count() {
         count[vertex.rise+1] = vertex.count;
       }
       inline Vertex45CompactT(const Vertex45CompactT& vertex) : pt(vertex.pt), count(vertex.count) {}
       inline Vertex45CompactT& operator=(const Vertex45CompactT& vertex){
         pt = vertex.pt; count = vertex.count; return *this; }
- inline Vertex45CompactT(const std::pair<Point, Point>& vertex) {}
- inline Vertex45CompactT& operator=(const std::pair<Point, Point>& vertex){ return *this; }
       inline bool operator==(const Vertex45CompactT& vertex) const {
         return pt == vertex.pt && count == vertex.count; }
       inline bool operator!=(const Vertex45CompactT& vertex) const { return !((*this) == vertex); }
@@ -520,15 +522,16 @@
       int justBefore_;
       int fractureHoles_;
     public:
- inline Polygon45Formation() : x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(0) {
+ inline Polygon45Formation() : scanData_(), 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) {
+ inline Polygon45Formation(bool fractureHoles) : scanData_(), 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(const Polygon45Formation& that) :
+ scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(0) { (*this) = that; }
       inline Polygon45Formation& operator=(const Polygon45Formation& that) {
         x_ = that.x_;
         justBefore_ = that.justBefore_;
@@ -1230,11 +1233,12 @@
       Unit x_;
       int justBefore_;
     public:
- inline Polygon45Tiling() : x_((std::numeric_limits<Unit>::min())), justBefore_(false) {
+ inline Polygon45Tiling() : scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false) {
         lessVertex45 lessElm(&x_, &justBefore_);
         scanData_ = Polygon45FormationData(lessElm);
       }
- inline Polygon45Tiling(const Polygon45Tiling& that) { (*this) = that; }
+ inline Polygon45Tiling(const Polygon45Tiling& that) :
+ scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false) { (*this) = that; }
       inline Polygon45Tiling& operator=(const Polygon45Tiling& that) {
         x_ = that.x_;
         justBefore_ = that.justBefore_;

Modified: sandbox/gtl/gtl/polygon_45_set_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_set_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_set_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -29,20 +29,22 @@
     typedef polygon_45_set_data operator_arg_type;
 
     // default constructor
- inline polygon_45_set_data() : dirty_(false), unsorted_(false), is_manhattan_(true) {}
+ inline polygon_45_set_data() : error_data_(), 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) {
+ inline polygon_45_set_data(const geometry_type& that) : error_data_(), data_(), 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_) {}
+ error_data_(that.error_data_), data_(that.data_), dirty_(that.dirty_),
+ unsorted_(that.unsorted_), is_manhattan_(that.is_manhattan_) {}
 
     template <typename ltype, typename rtype, int op_type>
- inline polygon_45_set_data(const polygon_45_set_view<ltype, rtype, op_type>& that) {
+ inline polygon_45_set_data(const polygon_45_set_view<ltype, rtype, op_type>& that) :
+ error_data_(), data_(), dirty_(false), unsorted_(false), is_manhattan_(true) {
       (*this) = that.value();
     }
 
@@ -74,6 +76,17 @@
     }
 
     // insert iterator range
+ inline void insert(iterator_type input_begin, iterator_type input_end, bool is_hole = false) {
+ if(input_begin == input_end || input_begin == data_.begin()) return;
+ dirty_ = true;
+ unsorted_ = true;
+ while(input_begin != input_end) {
+ insert(*input_begin, is_hole);
+ ++input_begin;
+ }
+ }
+
+ // 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;
@@ -526,17 +539,15 @@
   // 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;
- }
+ unsigned int count = data_.size();
     data_.insert(data_.end(), polygon_set.data_.begin(), polygon_set.data_.end());
     error_data_.insert(error_data_.end(), polygon_set.error_data_.begin(),
                        polygon_set.error_data_.end());
+ if(is_hole) {
+ for(unsigned int i = count; i < data_.size(); ++i) {
+ data_[i].count = data_[i].count.invert();
+ }
+ }
     dirty_ = true;
     unsorted_ = true;
     if(polygon_set.is_manhattan_ == false) is_manhattan_ = false;
@@ -568,6 +579,7 @@
   template <typename Unit>
   template <typename rectangle_type>
   inline bool polygon_45_set_data<Unit>::extents(rectangle_type& rect) const{
+ clean();
     if(empty()) {
       return false;
     }
@@ -1026,11 +1038,7 @@
                                                          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;
- //}
+ if(hole) resizing *= -1;
     typedef typename polygon_45_data<Unit>::iterator_type piterator;
     piterator first, second, third, end, real_end;
     real_end = end_points(poly);
@@ -1065,21 +1073,12 @@
     //sizingSet.snap();
     polygon_45_set_data<Unit> tmp;
     //insert original shape
- tmp.insert_dispatch(poly, hole, polygon_45_concept());
- if(hole) {
- Unit UnitMax = std::numeric_limits<Unit>::max();
- Unit UnitMin = std::numeric_limits<Unit>::min();
- tmp.insert(rectangle_data<Unit>(UnitMin, UnitMin, UnitMax, UnitMax));
- if(resizing < 0) tmp -= sizingSet;
- else tmp += sizingSet;
- tmp.clean();
- tmp.insert(rectangle_data<Unit>(UnitMin, UnitMin, UnitMax, UnitMax), true); //insert as hole to cancel out
- } else {
- if(resizing < 0) tmp -= sizingSet;
- else tmp += sizingSet;
- tmp.clean();
- }
- return (*this) += tmp;
+ tmp.insert_dispatch(poly, false, polygon_45_concept());
+ if(resizing < 0) tmp -= sizingSet;
+ else tmp += sizingSet;
+ tmp.clean();
+ insert(tmp, hole);
+ return (*this);
   }
 
   // accumulate the bloated polygon with holes

Modified: sandbox/gtl/gtl/polygon_45_set_view.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_set_view.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_set_view.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -81,7 +81,7 @@
   public:
     polygon_45_set_view(const ltype& lvalue,
                         const rtype& rvalue ) :
- lvalue_(lvalue), rvalue_(rvalue), evaluated_(false) {}
+ lvalue_(lvalue), rvalue_(rvalue), output_(), evaluated_(false) {}
 
     // get iterator to begin vertex data
   public:

Modified: sandbox/gtl/gtl/polygon_45_touch.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_45_touch.hpp (original)
+++ sandbox/gtl/gtl/polygon_45_touch.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -55,7 +55,7 @@
 
     class CountTouch {
     public:
- inline CountTouch() {}
+ inline CountTouch() : counts() {}
       //inline CountTouch(int count) { counts[0] = counts[1] = count; }
       //inline CountTouch(int count1, int count2) { counts[0] = count1; counts[1] = count2; }
       inline CountTouch(const CountTouch& count) : counts(count.counts) {}
@@ -240,7 +240,7 @@
     tsd tsd_;
     unsigned int nodeCount_;
   public:
- inline connectivity_extraction_45() : nodeCount_(0) {}
+ inline connectivity_extraction_45() : tsd_(), nodeCount_(0) {}
     inline connectivity_extraction_45(const connectivity_extraction_45& that) : tsd_(that.tsd_),
                                                                           nodeCount_(that.nodeCount_) {}
     inline connectivity_extraction_45& operator=(const connectivity_extraction_45& that) {

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-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -21,15 +21,15 @@
   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
+ inline polygon_45_with_holes_data() : self_(), holes_() {} //do nothing default constructor
 
   template<class iT>
- inline polygon_45_with_holes_data(iT input_begin, iT input_end) {
+ inline polygon_45_with_holes_data(iT input_begin, iT input_end) : self_(), holes_() {
     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) {
+ inline polygon_45_with_holes_data(iT input_begin, iT input_end, hiT holes_begin, hiT holes_end) : self_(), holes_() {
     set(input_begin, input_end);
     set_holes(holes_begin, holes_end);
   }

Modified: sandbox/gtl/gtl/polygon_90_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_90_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_90_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -18,7 +18,7 @@
   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
+ inline polygon_90_data() : coords_() {} //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

Modified: sandbox/gtl/gtl/polygon_90_set_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_90_set_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_90_set_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -20,14 +20,15 @@
     typedef polygon_90_set_data operator_arg_type;
 
     // default constructor
- inline polygon_90_set_data() : orient_(HORIZONTAL), dirty_(false), unsorted_(false) {}
+ inline polygon_90_set_data() : orient_(HORIZONTAL), data_(), dirty_(false), unsorted_(false) {}
 
     // constructor
- inline polygon_90_set_data(orientation_2d orient) : orient_(orient), dirty_(false), unsorted_(false) {}
+ inline polygon_90_set_data(orientation_2d orient) : orient_(orient), data_(), 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) {
+ inline polygon_90_set_data(orientation_2d orient, iT input_begin, iT input_end) :
+ orient_(HORIZONTAL), data_(), dirty_(false), unsorted_(false) {
       dirty_ = true;
       unsorted_ = true;
       for( ; input_begin != input_end; ++input_begin) { insert(*input_begin); }
@@ -42,7 +43,7 @@
 
     // 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) {
+ data_(), orient_(orient), dirty_(false), unsorted_(false) {
       insert(that, false, that.orient_);
     }
 
@@ -77,6 +78,20 @@
 // }
 
     // insert iterator range
+ inline void insert(iterator_type input_begin, iterator_type input_end, orientation_2d orient = HORIZONTAL) {
+ if(input_begin == input_end || input_begin == data_.begin()) return;
+ dirty_ = true;
+ unsorted_ = true;
+ if(orient == orient_)
+ data_.insert(data_.end(), input_begin, input_end);
+ else {
+ for( ; input_begin != input_end; ++input_begin) {
+ insert(*input_begin, false, orient);
+ }
+ }
+ }
+
+ // insert iterator range
     template <typename iT>
     inline void insert(iT input_begin, iT input_end, orientation_2d orient = HORIZONTAL) {
       if(input_begin == input_end) return;
@@ -501,15 +516,21 @@
     if((e_total < 0) ^ (n_total < 0)) {
       //different signs
       if(e_total < 0) {
- shrink(0, e_total, 0, 0);
- return bloat(0, 0, 0, n_total);
+ shrink(0, -e_total, 0, 0);
+ if(n_total != 0)
+ return bloat(0, 0, 0, n_total);
+ else
+ return (*this);
       } else {
- shrink(0, 0, 0, n_total); //shrink first
- return bloat(0, e_total, 0, 0);
+ shrink(0, 0, 0, -n_total); //shrink first
+ if(e_total != 0)
+ return bloat(0, e_total, 0, 0);
+ else
+ return (*this);
       }
     } else {
       if(e_total < 0) {
- return shrink(0, e_total, 0, n_total);
+ return shrink(0, -e_total, 0, -n_total);
       }
       return bloat(0, e_total, 0, n_total);
     }
@@ -520,7 +541,7 @@
   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() : pmd_() {}
     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) {
@@ -553,7 +574,7 @@
     tsd tsd_;
     unsigned int nodeCount_;
   public:
- inline connectivity_extraction_90() : nodeCount_(0) {}
+ inline connectivity_extraction_90() : tsd_(), nodeCount_(0) {}
     inline connectivity_extraction_90(const connectivity_extraction_90& that) : tsd_(that.tsd_),
                                                                           nodeCount_(that.nodeCount_) {}
     inline connectivity_extraction_90& operator=(const connectivity_extraction_90& that) {

Modified: sandbox/gtl/gtl/polygon_90_touch.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_90_touch.hpp (original)
+++ sandbox/gtl/gtl/polygon_90_touch.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -28,13 +28,13 @@
         typename EventData::const_iterator itr_;
         std::pair<Interval, std::set<int> > ivlIds_;
       public:
- inline iterator() {}
+ inline iterator() : itr_(), ivlIds_() {}
         inline iterator(typename EventData::const_iterator itr,
- Unit prevPos, const std::set<int>& ivlIds) : itr_(itr) {
+ Unit prevPos, const std::set<int>& ivlIds) : itr_(itr), ivlIds_() {
           ivlIds_.second = ivlIds;
           ivlIds_.first = Interval(prevPos, itr->first);
         }
- inline iterator(const iterator& that) { (*this) = that; }
+ inline iterator(const iterator& that) : itr_(), ivlIds_() { (*this) = that; }
         inline iterator& operator=(const iterator& that) {
           itr_ = that.itr_;
           ivlIds_.first = that.ivlIds_.first;
@@ -77,7 +77,7 @@
         inline std::pair<Interval, std::set<int> >& operator*() { if(ivlIds_.second.empty())(++(*this)); return ivlIds_; }
       };
 
- inline TouchScanEvent() {}
+ inline TouchScanEvent() : eventData_() {}
       template<class iT>
       inline TouchScanEvent(iT begin, iT end) {
         for( ; begin != end; ++begin){
@@ -155,8 +155,8 @@
       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 () : scanData_(), nextItr_() { nextItr_ = scanData_.end(); }
+ inline TouchOp (const TouchOp& that) : scanData_(that.scanData_), nextItr_() { nextItr_ = scanData_.begin(); }
       inline TouchOp& operator=(const TouchOp& that);
    
       //moves scanline forward

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-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -22,7 +22,7 @@
   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
+ inline polygon_90_with_holes_data() : self_(), holes_() {} //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

Modified: sandbox/gtl/gtl/polygon_arbitrary_formation.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_arbitrary_formation.hpp (original)
+++ sandbox/gtl/gtl/polygon_arbitrary_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -203,7 +203,7 @@
       Unit *x_; //x value at which to apply comparison
       int *justBefore_;
     public:
- inline less_half_edge() : x_(0) {}
+ inline less_half_edge() : x_(0), justBefore_(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; }
@@ -518,7 +518,7 @@
       Unit *x_; //x value at which to apply comparison
       int *justBefore_;
     public:
- inline less_vertex_half_edge() : x_(0) {}
+ inline less_vertex_half_edge() : x_(0), justBefore_(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; }
@@ -554,7 +554,7 @@
       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
+ inline poly_line_arbitrary() : points() {} //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
@@ -621,20 +621,23 @@
         otherTailp_ = otherTailp;
       }
 
- inline active_tail_arbitrary(Point point, active_tail_arbitrary* otherTailp, bool head = true) {
+ inline active_tail_arbitrary(Point point, active_tail_arbitrary* otherTailp, bool head = true) :
+ tailp_(), otherTailp_(), holesList_(), head_() {
         tailp_ = new poly_line_arbitrary;
         tailp_->points.push_back(point);
         head_ = head;
         otherTailp_ = otherTailp;
       
       }
- inline active_tail_arbitrary(active_tail_arbitrary* otherTailp) {
+ inline active_tail_arbitrary(active_tail_arbitrary* otherTailp) :
+ tailp_(), otherTailp_(), holesList_(), head_() {
         tailp_ = otherTailp->tailp_;
         otherTailp_ = otherTailp;
       }
 
       //copy constructor
- inline active_tail_arbitrary(const active_tail_arbitrary& that) { (*this) = that; }
+ inline active_tail_arbitrary(const active_tail_arbitrary& that) :
+ tailp_(), otherTailp_(), holesList_(), head_() { (*this) = that; }
 
       //destructor
       inline ~active_tail_arbitrary() {
@@ -1021,16 +1024,18 @@
     int justBefore_;
     int fractureHoles_;
   public:
- inline polygon_arbitrary_formation() : x_(std::numeric_limits<Unit>::min()), justBefore_(false), fractureHoles_(0) {
+ inline polygon_arbitrary_formation() :
+ scanData_(), 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) {
+ inline polygon_arbitrary_formation(bool fractureHoles = false) :
+ scanData_(), 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(const polygon_arbitrary_formation& that) :
+ scanData_(), x_(std::numeric_limits<Unit>::min()), justBefore_(false), fractureHoles_(0) { (*this) = that; }
     inline polygon_arbitrary_formation& operator=(const polygon_arbitrary_formation& that) {
       x_ = that.x_;
       justBefore_ = that.justBefore_;
@@ -1261,6 +1266,7 @@
                 //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);
+ if(returnValue) returnCount.first = point;
                 //std::cout << returnValue << std::endl;
                 tails[i] = 0;
                 tails[j] = 0;
@@ -1284,8 +1290,11 @@
                 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)
+ if(have_vertical_tail_from_below) {
                   holep = tails[c_size_less_1];
+ tails[c_size_less_1] = 0;
+ have_vertical_tail_from_below = false;
+ }
                 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)) {
@@ -1861,9 +1870,9 @@
       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() : hole_(), itr_() {}
+ inline iterator_holes_type(typename active_tail_arbitrary::iteratorHoles itr) : hole_(), itr_(itr) {}
+ inline iterator_holes_type(const iterator_holes_type& that) : hole_(that.hole_), itr_(that.itr_) {}
       inline iterator_holes_type& operator=(const iterator_holes_type& that) {
         itr_ = that.itr_;
         return *this;

Modified: sandbox/gtl/gtl/polygon_formation.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_formation.hpp (original)
+++ sandbox/gtl/gtl/polygon_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -330,8 +330,9 @@
       unsigned int indexEnd_;
       End startEnd_;
     public:
- inline iterator() : pLine_(0), index_(0) {}
- inline iterator(const ActiveTail* at, bool isHole, orientation_2d orient) {
+ inline iterator() : pLine_(), pLineEnd_(), index_(), indexEnd_(), startEnd_() {}
+ inline iterator(const ActiveTail* at, bool isHole, orientation_2d orient) :
+ pLine_(), pLineEnd_(), index_(), indexEnd_(), startEnd_() {
         //if it is a hole and orientation is vertical or it is not a hole and orientation is horizontal
         //we want to use this active tail, otherwise we want to use the other active tail
         startEnd_ = TAIL;
@@ -679,9 +680,9 @@
     bool fractureHoles_;
   public:
     typedef typename std::vector<PolyLinePolygonData>::iterator iterator;
- inline ScanLineToPolygonItrs() {}
+ inline ScanLineToPolygonItrs() : tailMap_(), outputPolygons_(), fractureHoles_(false) {}
     /* construct a scanline with the proper offsets, protocol and options */
- inline ScanLineToPolygonItrs(bool fractureHoles) : fractureHoles_(fractureHoles) {}
+ inline ScanLineToPolygonItrs(bool fractureHoles) : tailMap_(), outputPolygons_(), fractureHoles_(fractureHoles) {}
    
     ~ScanLineToPolygonItrs() { clearOutput_(); }
    
@@ -1006,17 +1007,18 @@
   }
 
   template <typename Unit>
- inline ActiveTail<Unit>::ActiveTail() : tailp_(0), otherTailp_(0) {}
+ inline ActiveTail<Unit>::ActiveTail() : tailp_(0), otherTailp_(0), holesList_() {}
 
   template <typename Unit>
- inline ActiveTail<Unit>::ActiveTail(orientation_2d orient, Unit coord, Side solidToRight, ActiveTail* otherTailp) {
+ inline ActiveTail<Unit>::ActiveTail(orientation_2d orient, Unit coord, Side solidToRight, ActiveTail* otherTailp) :
+ tailp_(0), otherTailp_(0), holesList_() {
     tailp_ = createPolyLine(orient, coord, solidToRight);
     otherTailp_ = otherTailp;
   }
 
   template <typename Unit>
   inline ActiveTail<Unit>::ActiveTail(PolyLine<Unit>* active, ActiveTail<Unit>* otherTailp) :
- tailp_(active), otherTailp_(otherTailp) {}
+ tailp_(active), otherTailp_(otherTailp), holesList_() {}
 
   //copy constructor
   template <typename Unit>

Modified: sandbox/gtl/gtl/polygon_set_data.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_set_data.hpp (original)
+++ sandbox/gtl/gtl/polygon_set_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -24,11 +24,11 @@
     typedef polygon_set_data operator_arg_type;
 
     // default constructor
- inline polygon_set_data() : dirty_(false), unsorted_(false), is_45_(true) {}
+ inline polygon_set_data() : data_(), dirty_(false), unsorted_(false), is_45_(true) {}
 
     // constructor from an iterator pair over edge data
     template <typename iT>
- inline polygon_set_data(iT input_begin, iT input_end) {
+ inline polygon_set_data(iT input_begin, iT input_end) : data_(), dirty_(false), unsorted_(false), is_45_(true) {
       for( ; input_begin != input_end; ++input_begin) { insert(*input_begin); }
     }
 
@@ -68,6 +68,18 @@
       return *this;
     }
 
+
+ // insert iterator range
+ inline void insert(iterator_type input_begin, iterator_type input_end) {
+ if(input_begin == input_end || input_begin == data_.begin()) return;
+ dirty_ = true;
+ unsorted_ = true;
+ while(input_begin != input_end) {
+ insert(*input_begin);
+ ++input_begin;
+ }
+ }
+
     // insert iterator range
     template <typename iT>
     inline void insert(iT input_begin, iT input_end) {
@@ -134,7 +146,8 @@
       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) {
+ 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);
@@ -144,11 +157,13 @@
     }
 
     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) {
+ 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) {
+ 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>

Modified: sandbox/gtl/gtl/polygon_set_view.hpp
==============================================================================
--- sandbox/gtl/gtl/polygon_set_view.hpp (original)
+++ sandbox/gtl/gtl/polygon_set_view.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -119,7 +119,7 @@
   public:
     polygon_set_view(const ltype& lvalue,
                      const rtype& rvalue ) :
- lvalue_(lvalue), rvalue_(rvalue), evaluated_(false) {}
+ lvalue_(lvalue), rvalue_(rvalue), output_(), evaluated_(false) {}
 
     // get iterator to begin vertex data
   public:

Modified: sandbox/gtl/gtl/property_merge.hpp
==============================================================================
--- sandbox/gtl/gtl/property_merge.hpp (original)
+++ sandbox/gtl/gtl/property_merge.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -14,7 +14,7 @@
 private:
   coordinate_type x_, y_;
 public:
- inline property_merge_point() {}
+ inline property_merge_point() : x_(), y_() {}
   inline property_merge_point(coordinate_type x, coordinate_type y) : x_(x), y_(y) {}
   //use builtin assign and copy
   inline bool operator==(const property_merge_point& that) const { return x_ == that.x_ && y_ == that.y_; }
@@ -35,7 +35,7 @@
 private:
   coordinate_type low_, high_;
 public:
- inline property_merge_interval() {}
+ inline property_merge_interval() : low_(), high_() {}
   inline property_merge_interval(coordinate_type low, coordinate_type high) : low_(low), high_(high) {}
   //use builtin assign and copy
   inline bool operator==(const property_merge_interval& that) const { return low_ == that.low_ && high_ == that.high_; }
@@ -87,7 +87,7 @@
 
   //public member functions
 
- merge_scanline() {}
+ merge_scanline() : output(), scanline(), currentVertex(), tmpVector(), previousY(), countFromBelow(), scanlinePosition() {}
   merge_scanline(const merge_scanline& that) :
     output(that.output),
     scanline(that.scanline),

Modified: sandbox/gtl/gtl/rectangle_data.hpp
==============================================================================
--- sandbox/gtl/gtl/rectangle_data.hpp (original)
+++ sandbox/gtl/gtl/rectangle_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -19,9 +19,8 @@
 public:
   typedef T coordinate_type;
   typedef interval_data<T> interval_type;
-
- inline rectangle_data() {}
- inline rectangle_data(T xl, T yl, T xh, T yh) {
+ inline rectangle_data():ranges_() {}
+ inline rectangle_data(T xl, T yl, T xh, T yh):ranges_() {
     if(xl > xh) std::swap(xl, xh);
     if(yl > yh) std::swap(yl, yh);
     ranges_[HORIZONTAL] = interval_data<T>(xl, xh);
@@ -29,11 +28,10 @@
   }
   template <typename interval_type_1, typename interval_type_2>
   inline rectangle_data(const interval_type_1& hrange,
- const interval_type_2& vrange) {
+ const interval_type_2& vrange):ranges_() {
     set(HORIZONTAL, hrange); set(VERTICAL, vrange); }
 
- inline rectangle_data(const rectangle_data& that) { (*this) = that; }
-
+ inline rectangle_data(const rectangle_data& that):ranges_() { (*this) = that; }
   inline rectangle_data& operator=(const rectangle_data& that) {
     ranges_[0] = that.ranges_[0]; ranges_[1] = that.ranges_[1]; return *this;
   }

Modified: sandbox/gtl/gtl/rectangle_formation.hpp
==============================================================================
--- sandbox/gtl/gtl/rectangle_formation.hpp (original)
+++ sandbox/gtl/gtl/rectangle_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -25,11 +25,11 @@
     orientation_2d orient_;
     typename rectangle_traits<T>::coordinate_type currentCoordinate_;
   public:
- inline ScanLineToRects() {}
+ inline ScanLineToRects() : scanData_(), haveCurrentRect_(), currentRect_(), orient_(), currentCoordinate_() {}
     
     inline ScanLineToRects(orientation_2d orient, rectangle_type model) :
       scanData_(orientation_2d(orient.to_int() ? VERTICAL : HORIZONTAL)),
- haveCurrentRect_(false), orient_(orient) {
+ haveCurrentRect_(false), currentRect_(), orient_(orient), currentCoordinate_() {
       assign(currentRect_, model);
       currentCoordinate_ = std::numeric_limits<coordinate_type>::max();
     }

Modified: sandbox/gtl/gtl/scan_arbitrary.hpp
==============================================================================
--- sandbox/gtl/gtl/scan_arbitrary.hpp (original)
+++ sandbox/gtl/gtl/scan_arbitrary.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -7,7 +7,7 @@
 */
 #ifndef GTL_SCAN_ARBITRARY_HPP
 #define GTL_SCAN_ARBITRARY_HPP
-
+#include <fstream>
 namespace gtl {
 
   template <typename Unit>
@@ -864,11 +864,14 @@
     Unit y_;
     int just_before_;
   public:
- inline scanline() : x_(std::numeric_limits<Unit>::max()), y_(std::numeric_limits<Unit>::max()), just_before_(false) {
+ inline scanline() : scan_data_(), removal_set_(), insertion_set_(), end_point_queue_(),
+ 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(const scanline& that) : scan_data_(), removal_set_(), insertion_set_(), end_point_queue_(),
+ x_(std::numeric_limits<Unit>::max()), y_(std::numeric_limits<Unit>::max()), just_before_(false) {
+ (*this) = that; }
     inline scanline& operator=(const scanline& that) {
       x_ = that.x_;
       y_ = that.y_;
@@ -1348,7 +1351,7 @@
   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:
+ protected:
     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
@@ -1386,12 +1389,14 @@
       }
     };
 
+
     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_data& get_property_merge_data() { return pmd; }
+ inline property_merge() : pmd() {}
     inline property_merge(const property_merge& pm) : pmd(pm.pmd) {}
     inline property_merge& operator=(const property_merge& pm) { pmd = pm.pmd; return *this; }
 
@@ -1443,7 +1448,7 @@
 
     void clear() {*this = property_merge();}
 
- private:
+ protected:
     template <typename polygon_type>
     void insert(const polygon_type& polygon_object, const property_type& property_value, bool is_hole,
                 polygon_concept tag) {
@@ -2421,7 +2426,7 @@
       std::sort(pmd.begin(), pmd.end(), lvd);
     }
   public:
- inline arbitrary_boolean_op() {}
+ inline arbitrary_boolean_op() : pmd() {}
     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; }
 
@@ -2437,6 +2442,13 @@
       insert(b1, e1, 0);
       insert(b2, e2, 1);
       property_merge_data tmp_pmd;
+ //#define GTL_DEBUG_FILE
+#ifdef GTL_DEBUG_FILE
+ std::fstream debug_file;
+ debug_file.open("gtl_debug.txt", std::ios::out);
+ property_merge<Unit, property_type, std::vector<property_type> >::print(debug_file, pmd);
+ debug_file.close();
+#endif
       line_intersection<Unit>::validate_scan(tmp_pmd, pmd.begin(), pmd.end());
       pmd.swap(tmp_pmd);
       sort_property_merge_data();

Modified: sandbox/gtl/gtl/transform.hpp
==============================================================================
--- sandbox/gtl/gtl/transform.hpp (original)
+++ sandbox/gtl/gtl/transform.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -338,17 +338,17 @@
 template <typename scale_factor_type>
 class anisotropic_scale_factor {
 public:
- inline anisotropic_scale_factor() {
+ inline anisotropic_scale_factor() : scale_() {
     scale_[0] = 1;
     scale_[1] = 1;
     scale_[2] = 1;
   }
- inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale) {
+ inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale) : scale_() {
     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) {
+ inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale, scale_factor_type zscale) : scale_() {
     scale_[0] = xscale;
     scale_[1] = yscale;
     scale_[2] = zscale;
@@ -406,6 +406,7 @@
 public:
   transformation();
   transformation(axis_transformation atr);
+ transformation(axis_transformation::ATR atr);
   template <typename point_type>
   transformation(const point_type& p);
   template <typename point_type>

Modified: sandbox/gtl/gtl/transform_detail.hpp
==============================================================================
--- sandbox/gtl/gtl/transform_detail.hpp (original)
+++ sandbox/gtl/gtl/transform_detail.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
@@ -9,540 +9,543 @@
 #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 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) : atr_(NULL_TRANSFORM) {
+ 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 orientation_2d& orient) : atr_(NULL_TRANSFORM) {
+ 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_3d& dir) : atr_(NULL_TRANSFORM) {
+ 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(const direction_2d& dir) : atr_(NULL_TRANSFORM) {
+ 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 axis_transformation& a) {
+ atr_ = a.atr_;
+ return *this;
+ }
 
-inline axis_transformation& axis_transformation::operator=(const ATR& atr) {
- atr_ = 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 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 !(*this == a);
+ }
 
-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 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){
+ 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;
-}
+ 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);
-}
+ // 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]]));
-}
+ // 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);
-}
+ // 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_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;
-}
+ // 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) 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);
-}
+ 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::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::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::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();
-}
+ 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 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 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;
-}
+ 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;
-}
+ //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];
+ //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;
   }
- 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) 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>
+ 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 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() : atr_(), 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>
+ 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>
+ inline transformation<coordinate_type>::transformation(axis_transformation::ATR atr) : atr_(atr), p_(0, 0, 0){;}
 
-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(const point_type& p) : atr_(), p_(0, 0, 0) {
+ 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>
+ template <typename point_type>
+ inline transformation<coordinate_type>::transformation(axis_transformation atr, const point_type& p) :
+ atr_(atr), p_(0, 0, 0) {
+ set_translation(p);
+ }
 
-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>
+ template <typename point_type>
+ inline transformation<coordinate_type>::transformation(axis_transformation atr, const point_type& referencePt, const point_type& destinationPt) : atr_(), p_(0, 0, 0) {
+ 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 !(*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 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 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 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>
+ 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>::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>
+ 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) 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);
-}
+ 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;
-}
+ // 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();
-}
+ template <typename coordinate_type>
+ inline transformation<coordinate_type> transformation<coordinate_type>::inverse() const {
+ transformation<coordinate_type> retval(*this);
+ return retval.invert();
+ }
 
 }
 #endif

Deleted: sandbox/gtl/interval_concept.hpp
==============================================================================
--- sandbox/gtl/interval_concept.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,499 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_INTERVAL_CONCEPT_HPP
-#define GTL_INTERVAL_CONCEPT_HPP
-#include "isotropy.hpp"
-#include "interval_data.hpp"
-#include "interval_traits.hpp"
-
-namespace gtl {
- struct interval_concept {};
-
- template <typename T>
- struct is_interval_concept { typedef gtl_no type; };
- template <>
- struct is_interval_concept<interval_concept> { typedef gtl_yes type; };
-
- template <typename T>
- struct is_mutable_interval_concept { typedef gtl_no type; };
- template <>
- struct is_mutable_interval_concept<interval_concept> { typedef gtl_yes type; };
-
- template <typename T>
- typename requires_1<typename gtl_if<typename is_interval_concept<typename geometry_concept<T>::type>::type>::type,
- typename interval_traits<T>::coordinate_type>::type
- get(const T& interval, direction_1d dir) {
- return interval_traits<T>::get(interval, dir);
- }
-
- template <typename T, typename coordinate_type>
- 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 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_mutable_traits<T>::construct(low_value, high_value);
- }
-
- template <typename T, typename T2>
- typename requires_1< typename gtl_and<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type,
- typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type,
- T>::type
- copy_construct(const T2& interval) {
- return construct<T>
- (get(interval, LOW ),
- get(interval, HIGH));
- }
-
- template <typename T1, typename T2>
- typename requires_1< typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<T1>::type>::type,
- typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type,
- T1>::type &
- assign(T1& lvalue, const T2& rvalue) {
- lvalue = copy_construct<T1>(rvalue);
- return lvalue;
- }
-
- template <typename T, typename T2>
- typename requires_1< typename gtl_and< typename is_interval_concept<typename geometry_concept<T>::type>::type,
- typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type,
- bool>::type
- equivalence(const T& interval1, const T2& interval2) {
- return get(interval1, LOW) ==
- get(interval2, LOW) &&
- get(interval1, HIGH) ==
- get(interval2, HIGH);
- }
-
- template <typename interval_type>
- 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 <= high(interval) && value >= low(interval);
- } else {
- return value < high(interval) && value > low(interval);
- }
- }
-
- template <typename interval_type, typename interval_type_2>
- typename requires_1< typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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
- template <typename interval_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>
- 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>
- 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>
- 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>
- 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>
- 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
- delta(const interval_type& interval) {
- 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>
- 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);
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // scale interval by factor
- template <typename interval_type>
- 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 = 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>
- 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);
- return interval;
- }
-
- // convolve this with b
- template <typename interval_type>
- 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;
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // deconvolve this with b
- template <typename interval_type>
- 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;
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // convolve this with b
- template <typename interval_type, typename interval_type_2>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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);
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // deconvolve this with b
- template <typename interval_type, typename interval_type_2>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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);
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // reflected convolve this with b
- template <typename interval_type, typename interval_type_2>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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);
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // reflected deconvolve this with b
- template <typename interval_type, typename interval_type_2>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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);
- low(interval, newLow);
- high(interval, newHigh);
- return interval;
- }
-
- // distance from a coordinate to an interval
- template <typename interval_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) {
- 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>
- typename requires_1<
- typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference>::type
- euclidean_distance(const interval_type& interval,
- const interval_type_2& b) {
- typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
- 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>
- typename requires_1<
- typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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));
- }
-
- // check if Interval b partially overlaps `this` Interval
- template <typename interval_type, typename interval_type_2>
- typename requires_1<
- typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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>
- typename requires_1< typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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>
- typename requires_1<
- typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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>
- typename requires_1< typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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));
- bool valid = consider_touch ?
- lowVal <= highVal :
- lowVal < highVal;
- if(valid) {
- low(interval, lowVal);
- high(interval, highVal);
- }
- return valid;
- }
-
- // set 'this' interval to the generalized intersection of 'this' and b
- template <typename interval_type, typename interval_type_2>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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
- std::sort(coords, coords+4);
- low(interval, coords[1]);
- high(interval, coords[2]);
- return interval;
- }
-
- // bloat the Interval
- template <typename interval_type>
- 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;
- }
-
- // bloat the specified side of `this` Interval
- template <typename interval_type>
- 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;
- }
-
-
- // shrink the Interval
- template <typename interval_type>
- 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>
- 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>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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>
- 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,
- (d1d == LOW) ? c : get(interval, HIGH));
- }
-
- // 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>
- typename requires_1<
- typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
- typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type,
- 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

Deleted: sandbox/gtl/interval_data.hpp
==============================================================================
--- sandbox/gtl/interval_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,61 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_INTERVAL_DATA_HPP
-#define GTL_INTERVAL_DATA_HPP
-#include "isotropy.hpp"
-namespace gtl {
- template <typename T>
- class interval_data {
- public:
- typedef T coordinate_type;
- inline interval_data():coords_(){}
- inline interval_data(coordinate_type low, coordinate_type high):coords_() {
- coords_[LOW] = low; coords_[HIGH] = high;
- }
- inline interval_data(const interval_data& that):coords_() {
- (*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;
- }
-private:
- coordinate_type coords_[2];
-};
-
-
-template <class T>
-std::ostream& operator << (std::ostream& o, const interval_data<T>& i)
-{
- return o << i.get(LOW) << ' ' << i.get(HIGH);
-}
-
-}
-#endif

Deleted: sandbox/gtl/interval_traits.hpp
==============================================================================
--- sandbox/gtl/interval_traits.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,33 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_INTERVAL_TRAITS_HPP
-#define GTL_INTERVAL_TRAITS_HPP
-namespace gtl {
- 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);
- }
- };
-
- 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
-

Deleted: sandbox/gtl/isotropy.hpp
==============================================================================
--- sandbox/gtl/isotropy.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,470 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-
-#ifndef GTL_ISOTROPY_HPP
-#define GTL_ISOTROPY_HPP
-namespace gtl {
-
- 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
- };
-
- struct undefined_concept {};
-
- template <typename T>
- struct geometry_concept { typedef undefined_concept type; };
-
- template <typename T>
- struct coordinate_traits {};
-
- template <typename T>
- struct high_precision_type {
- typedef long double 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 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 { static const bool value = false; };
- struct gtl_yes { typedef gtl_yes type;
- static const bool value = true; };
-
- 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 typename gtl_and<
- T, typename gtl_and<T2, T3>::type>::type type; };
- template <typename T, typename T2, typename T3>
- struct gtl_or_3 { typedef typename gtl_or<
- T, typename gtl_or<T2, T3>::type>::type type; };
-
- template <typename T, typename T2, typename T3, typename T4>
- struct gtl_or_4 { typedef typename gtl_or<
- T, typename gtl_or_3<T2, T3, T4>::type>::type 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 {
-#ifdef WIN32
- typedef gtl_no type;
-#endif
- };
- template <>
- struct gtl_if<gtl_yes> { typedef gtl_yes type; };
-
- 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 T, typename T2>
- struct gtl_different_type { typedef typename gtl_not<typename gtl_same_type<T, T2>::type>::type 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> {};
-
- namespace boost_copy {
- template <bool B, class T = void>
- struct enable_if_c {
- typedef T type;
- };
-
- template <class T>
- struct enable_if_c<false, T> {};
-
- template <class Cond, class T = void>
- struct enable_if : public enable_if_c<Cond::value, T> {};
-
- template <bool B, class T>
- struct lazy_enable_if_c {
- typedef typename T::type type;
- };
-
- template <class T>
- struct lazy_enable_if_c<false, T> {};
-
- template <class Cond, class T>
- struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
-
-
- template <bool B, class T = void>
- struct disable_if_c {
- typedef T type;
- };
-
- template <class T>
- struct disable_if_c<true, T> {};
-
- template <class Cond, class T = void>
- struct disable_if : public disable_if_c<Cond::value, T> {};
-
- template <bool B, class T>
- struct lazy_disable_if_c {
- typedef typename T::type type;
- };
-
- template <class T>
- struct lazy_disable_if_c<true, T> {};
-
- template <class Cond, class T>
- struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
- }
- // template <typename T1, typename T2>
- // struct requires_1 {};
- // template <typename T2>
- // struct requires_1<gtl_yes, T2> { typedef T2 type; };
-#define requires_1 boost_copy::enable_if
-
- 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>
- typename requires_1<
- typename gtl_and<typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>::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_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,
- CLOCKWISE = 0, COUNTERCLOCKWISE = 1,
- REVERSE = 0, FORWARD = 1,
- NEGATIVE = 0, POSITIVE = 1 };
- 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,
- unknown_winding = 2
- };
-
- class direction_2d;
- class direction_3d;
- class orientation_2d;
-
- class direction_1d {
- private:
- unsigned int val_;
- explicit direction_1d(int d);
- public:
- 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; }
- 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;
-
- class orientation_2d {
- private:
- unsigned int val_;
- explicit inline orientation_2d(int o);
- public:
- 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; }
- 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;
- }
- inline direction_2d get_direction(direction_1d dir) const;
- };
-
- class direction_2d {
- private:
- int val_;
-
- public:
-
- inline direction_2d() : val_(WEST) {}
-
- inline direction_2d(const direction_2d& that) : val_(that.val_) {}
-
- inline direction_2d(const direction_2d_enum val) : val_(val) {}
-
- inline direction_2d& operator=(const direction_2d& d) {
- val_ = d.val_;
- return * this;
- }
-
- inline ~direction_2d() { }
-
- 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
- inline unsigned int to_int(void) const { return val_; }
-
- 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
- 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
- inline direction_2d left() const {return turn(HIGH);}
-
- // Returns a direction 90 degree right to this one
- inline direction_2d right() const {return turn(LOW);}
-
- // 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_2d& that) : val_(that.to_int() & 1) {}
-
- orientation_2d::orientation_2d(const direction_2d& that) : val_(that.to_int() >> 1) {}
-
- direction_2d orientation_2d::get_direction(direction_1d dir) const {
- return direction_2d(direction_2d_enum((val_ << 1) + dir.to_int()));
- }
-
- class orientation_3d {
- private:
- unsigned int val_;
- explicit inline orientation_3d(int o);
- public:
- 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; }
- 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
-

Deleted: sandbox/gtl/iterator_compact_to_points.hpp
==============================================================================
--- sandbox/gtl/iterator_compact_to_points.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,69 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_ITERATOR_COMPACT_TO_POINTS_HPP
-#define GTL_ITERATOR_COMPACT_TO_POINTS_HPP
-namespace gtl {
-template <typename iterator_type, typename point_type>
-class iterator_compact_to_points {
-private:
- iterator_type iter_;
- iterator_type iter_end_;
- point_type pt_;
- typename point_traits<point_type>::coordinate_type firstX_;
- orientation_2d orient_;
-public:
- typedef std::forward_iterator_tag iterator_category;
- typedef point_type value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const point_type* pointer; //immutable
- typedef const point_type& reference; //immutable
-
- inline iterator_compact_to_points() : iter_(), iter_end_(), pt_(), firstX_(), orient_() {}
- inline iterator_compact_to_points(iterator_type iter, iterator_type iter_end) :
- iter_(iter), iter_end_(iter_end), pt_(), firstX_(), orient_(HORIZONTAL) {
- if(iter_ != iter_end_) {
- firstX_ = *iter_;
- x(pt_, firstX_);
- ++iter_;
- if(iter_ != iter_end_) {
- y(pt_, *iter_);
- }
- }
- }
- //use bitwise copy and assign provided by the compiler
- inline iterator_compact_to_points& operator++() {
- iterator_type prev_iter = iter_;
- ++iter_;
- if(iter_ == iter_end_) {
- if(x(pt_) != firstX_) {
- iter_ = prev_iter;
- x(pt_, firstX_);
- }
- } else {
- set(pt_, orient_, *iter_);
- orient_.turn_90();
- }
- return *this;
- }
- inline const iterator_compact_to_points operator++(int) {
- iterator_compact_to_points tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator_compact_to_points& that) const {
- return (iter_ == that.iter_);
- }
- inline bool operator!=(const iterator_compact_to_points& that) const {
- return (iter_ != that.iter_);
- }
- inline reference operator*() const { return pt_; }
-};
-
-}
-#endif
-

Deleted: sandbox/gtl/iterator_geometry_to_set.hpp
==============================================================================
--- sandbox/gtl/iterator_geometry_to_set.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,278 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_ITERATOR_GEOMETRY_TO_SET_HPP
-#define GTL_ITERATOR_GEOMETRY_TO_SET_HPP
-namespace gtl {
-template <typename concept_type, typename geometry_type>
-class iterator_geometry_to_set {};
-
-template <typename rectangle_type>
-class iterator_geometry_to_set<rectangle_concept, rectangle_type> {
-public:
- typedef typename rectangle_traits<rectangle_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;
- typedef const value_type* pointer; //immutable
- typedef const value_type& reference; //immutable
-private:
- rectangle_data<coordinate_type> rectangle_;
- mutable value_type vertex_;
- unsigned int corner_;
- orientation_2d orient_;
- bool is_hole_;
-public:
- iterator_geometry_to_set() : rectangle_(), vertex_(), corner_(4), orient_(), is_hole_() {}
- iterator_geometry_to_set(const rectangle_type& rectangle, direction_1d dir,
- orientation_2d orient = HORIZONTAL, bool is_hole = false) :
- rectangle_(), vertex_(), 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 const iterator_geometry_to_set operator++(int) {
- iterator_geometry_to_set tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator_geometry_to_set& that) const {
- return corner_ == that.corner_;
- }
- inline bool operator!=(const iterator_geometry_to_set& that) const {
- return !(*this == that);
- }
- inline reference operator*() const {
- if(corner_ == 0) {
- 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 = get(get(rectangle_, orient_), HIGH);
- vertex_.second.second = -1;
- if(is_hole_) vertex_.second.second *= -1;
- } else if(corner_ == 2) {
- vertex_.first = get(get(rectangle_, orient_.get_perpendicular()), HIGH);
- vertex_.second.first = get(get(rectangle_, orient_), LOW);
- } else {
- vertex_.second.first = get(get(rectangle_, orient_), HIGH);
- vertex_.second.second = 1;
- if(is_hole_) vertex_.second.second *= -1;
- }
- return vertex_;
- }
-};
-
-template <typename polygon_type>
-class iterator_geometry_to_set<polygon_90_concept, polygon_type> {
-public:
- typedef typename polygon_traits<polygon_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;
- typedef const value_type* pointer; //immutable
- typedef const value_type& reference; //immutable
- typedef typename polygon_traits<polygon_type>::iterator_type coord_iterator_type;
-private:
- value_type vertex_;
- typename polygon_traits<polygon_type>::iterator_type itrb, itre;
- bool last_vertex_;
- bool is_hole_;
- int multiplier_;
- point_data<coordinate_type> first_pt, second_pt, pts[3];
- bool use_wrap;
- orientation_2d orient_;
- int polygon_index;
-public:
- iterator_geometry_to_set() : vertex_(), itrb(), itre(), last_vertex_(), is_hole_(), multiplier_(), first_pt(), second_pt(), pts(), use_wrap(), orient_(), polygon_index(-1) {}
- iterator_geometry_to_set(const polygon_type& polygon, direction_1d dir, orientation_2d orient = HORIZONTAL, bool is_hole = false) :
- vertex_(), itrb(), itre(), last_vertex_(),
- is_hole_(is_hole), multiplier_(), first_pt(), second_pt(), pts(), use_wrap(),
- orient_(orient), polygon_index(0) {
- itrb = begin_points(polygon);
- itre = end_points(polygon);
- use_wrap = false;
- if(itrb == itre || dir == HIGH || size(polygon) < 4) {
- polygon_index = -1;
- } else {
- direction_1d wdir = winding(polygon);
- multiplier_ = wdir == LOW ? -1 : 1;
- if(is_hole_) multiplier_ *= -1;
- first_pt = pts[0] = *itrb;
- ++itrb;
- second_pt = pts[1] = *itrb;
- ++itrb;
- pts[2] = *itrb;
- evaluate_();
- }
- }
-
- inline iterator_geometry_to_set& operator++() {
- ++polygon_index;
- if(itrb == itre) {
- if(first_pt == pts[1]) polygon_index = -1;
- else {
- pts[0] = pts[1];
- pts[1] = pts[2];
- if(first_pt == pts[2]) {
- pts[2] = second_pt;
- } else {
- pts[2] = first_pt;
- }
- }
- } else {
- ++itrb;
- pts[0] = pts[1];
- pts[1] = pts[2];
- if(itrb == itre) {
- if(first_pt == pts[2]) {
- pts[2] = second_pt;
- } else {
- pts[2] = first_pt;
- }
- } else {
- pts[2] = *itrb;
- }
- }
- evaluate_();
- return *this;
- }
- inline const iterator_geometry_to_set operator++(int) {
- iterator_geometry_to_set tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator_geometry_to_set& that) const {
- return polygon_index == that.polygon_index;
- }
- inline bool operator!=(const iterator_geometry_to_set& that) const {
- return !(*this == that);
- }
- inline reference operator*() const {
- return vertex_;
- }
-
- inline void evaluate_() {
- vertex_.first = pts[1].get(orient_.get_perpendicular());
- vertex_.second.first =pts[1].get(orient_);
- if(pts[1] == pts[2]) {
- vertex_.second.second = 0;
- return;
- }
- if(pts[0].get(HORIZONTAL) != pts[1].get(HORIZONTAL)) {
- vertex_.second.second = -1;
- } else if(pts[0].get(VERTICAL) != pts[1].get(VERTICAL)) {
- vertex_.second.second = 1;
- } else {
- vertex_.second.second = 0;
- }
- vertex_.second.second *= multiplier_;
- }
-};
-
-template <typename polygon_with_holes_type>
-class iterator_geometry_to_set<polygon_90_with_holes_concept, polygon_with_holes_type> {
-public:
- 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;
- typedef const value_type* pointer; //immutable
- typedef const value_type& reference; //immutable
-private:
- iterator_geometry_to_set<polygon_90_concept, polygon_with_holes_type> itrb, itre;
- 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() : itrb(), itre(), itrhib(), itrhie(), itrhb(), itrhe(), orient_(), is_hole_(), started_holes() {}
- iterator_geometry_to_set(const polygon_with_holes_type& polygon, direction_1d dir,
- orientation_2d orient = HORIZONTAL, bool is_hole = false) :
- itrb(), itre(), itrhib(), itrhie(), itrhb(), itrhe(), orient_(orient), is_hole_(is_hole), started_holes() {
- 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, is_hole_);
- itrhb = begin_holes(polygon);
- started_holes = false;
- }
- }
- inline iterator_geometry_to_set& operator++() {
- //this code can be folded with flow control factoring
- if(itrb == itre) {
- 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_, !is_hole_);
- itrhie = iterator_geometry_to_set<polygon_90_concept,
- 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,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>();
- }
- } else {
- ++itrhib;
- 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_, !is_hole_);
- itrhie = iterator_geometry_to_set<polygon_90_concept,
- 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,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>();
- }
- }
- }
- } else {
- ++itrb;
- 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_, !is_hole_);
- itrhie = iterator_geometry_to_set<polygon_90_concept,
- typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, !is_hole_);
- ++itrhb;
- }
- }
- }
- return *this;
- }
- inline const iterator_geometry_to_set operator++(int) {
- iterator_geometry_to_set tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator_geometry_to_set& that) const {
- return itrb == that.itrb && itrhb == that.itrhb && itrhib == that.itrhib;
- }
- inline bool operator!=(const iterator_geometry_to_set& that) const {
- return !(*this == that);
- }
- inline reference operator*() const {
- if(itrb != itre) return *itrb;
- return *itrhib;
- }
-};
-
-
-
-}
-#endif
-

Deleted: sandbox/gtl/iterator_points_to_compact.hpp
==============================================================================
--- sandbox/gtl/iterator_points_to_compact.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,60 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_ITERATOR_POINTS_TO_COMPACT_HPP
-#define GTL_ITERATOR_POINTS_TO_COMPACT_HPP
-namespace gtl {
-template <typename iT, typename point_type>
-class iterator_points_to_compact {
-private:
- iT iter_, iterEnd_;
- orientation_2d orient_;
- mutable typename point_traits<point_type>::coordinate_type coord_;
-public:
- typedef typename point_traits<point_type>::coordinate_type coordinate_type;
- typedef std::forward_iterator_tag iterator_category;
- typedef coordinate_type value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const coordinate_type* pointer; //immutable
- typedef const coordinate_type& reference; //immutable
-
- inline iterator_points_to_compact() : iter_(), iterEnd_(), orient_(), coord_() {}
- explicit inline iterator_points_to_compact(iT iter, iT iterEnd) :
- iter_(iter), iterEnd_(iterEnd), orient_(HORIZONTAL), coord_() {}
- inline iterator_points_to_compact(const iterator_points_to_compact& that) :
- iter_(that.iter_), iterEnd_(that.iterEnd_), orient_(that.orient_), coord_(that.coord_) {}
- //use bitwise copy and assign provided by the compiler
- inline iterator_points_to_compact& operator++() {
- //iT tmp = iter_;
- ++iter_;
- //iT tmp2 = iter_;
- orient_.turn_90();
- //while(tmp2 != iterEnd_ && get(*tmp2, orient_) == get(*tmp, orient_)) {
- // iter_ = tmp2;
- // ++tmp2;
- //}
- return *this;
- }
- inline const iterator_points_to_compact operator++(int) {
- iT tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator_points_to_compact& that) const {
- return (iter_ == that.iter_);
- }
- inline bool operator!=(const iterator_points_to_compact& that) const {
- return (iter_ != that.iter_);
- }
- inline reference operator*() const { coord_ = get(*iter_, orient_);
- return coord_;
- }
-};
-
-}
-#endif
-

Deleted: sandbox/gtl/max_cover.hpp
==============================================================================
--- sandbox/gtl/max_cover.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,278 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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() : children_(), tracedPaths_(), rect() {}
- Node(const Rectangle rectIn) : children_(), tracedPaths_(), 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()) {
- //std::cout << "WRITE OUT 3: " << node->rect << std::endl;
- 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) {
- //std::cout << "WRITE OUT 2: " << node->rect << std::endl;
- outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(node->rect));
- }
- }
-
- struct stack_element {
- inline stack_element() :
- node(), rect(), itr() {}
- inline stack_element(Node* n,
- const Rectangle& r,
- typename Node::iterator i) :
- node(n), rect(r), itr(i) {}
- Node* node;
- Rectangle rect;
- typename Node::iterator itr;
- };
-
- template <class cT>
- static inline void getMaxCover(cT& outputContainer, Node* node, orientation_2d orient,
- Rectangle rect) {
- //std::cout << "New Root\n";
- std::vector<stack_element> stack;
- typename Node::iterator itr = node->begin();
- do {
- //std::cout << "LOOP\n";
- //std::cout << node->rect << std::endl;
- Interval rectIvl = rect.get(orient);
- Interval nodeIvl = node->rect.get(orient);
- bool iresult = intersect(rectIvl, nodeIvl, false);
- bool tresult = !node->tracedPath(rectIvl);
- //std::cout << (itr != node->end()) << " " << iresult << " " << tresult << std::endl;
- Rectangle nextRect = Rectangle(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));
- if(iresult && tresult) {
- node->addPath(rectIvl);
- bool writeOut = true;
- //check further visibility beyond this node
- for(typename Node::iterator itr2 = node->begin(); itr2 != node->end(); ++itr2) {
- Interval nodeIvl3 = (*itr2)->rect.get(orient);
- //if a child of this node can contain the interval then we can extend through
- if(contains(nodeIvl3, rectIvl, true)) writeOut = false;
- //std::cout << "child " << (*itr2)->rect << std::endl;
- }
- Rectangle nextRect = Rectangle(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));
- if(writeOut) {
- //std::cout << "write out " << nextRect << std::endl;
- outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
- } else {
- //std::cout << "supress " << nextRect << std::endl;
- }
- }
- if(itr != node->end() && iresult && tresult) {
- //std::cout << "recurse into child\n";
- stack.push_back(stack_element(node, rect, itr));
- rect = nextRect;
- node = *itr;
- itr = node->begin();
- } else {
- if(!stack.empty()) {
- //std::cout << "recurse out of child\n";
- node = stack.back().node;
- rect = stack.back().rect;
- itr = stack.back().itr;
- stack.pop_back();
- } else {
- //std::cout << "empty stack\n";
- //if there were no children of the root node
-// Rectangle nextRect = Rectangle(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));
-// outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
- }
- //std::cout << "increment " << (itr != node->end()) << std::endl;
- if(itr != node->end()) {
- ++itr;
- if(itr != node->end()) {
- //std::cout << "recurse into next child.\n";
- stack.push_back(stack_element(node, rect, itr));
- Interval rectIvl2 = rect.get(orient);
- Interval nodeIvl2 = node->rect.get(orient);
- bool iresult = intersect(rectIvl2, nodeIvl2, false);
- Rectangle nextRect2 = Rectangle(rectIvl2, rectIvl2);
- Unit low2 = rect.get(orient.get_perpendicular()).low();
- Unit high2 = node->rect.get(orient.get_perpendicular()).high();
- nextRect2.set(orient.get_perpendicular(), Interval(low2, high2));
- rect = nextRect2;
- //std::cout << "rect for next child" << rect << std::endl;
- node = *itr;
- itr = node->begin();
- }
- }
- }
- } while(!stack.empty() || itr != node->end());
- }
-
- /* Function recursive version of getMaxCover
- Because the code is so much simpler than the loop algorithm I retain it for clarity
-
- 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;
- }
- if(writeOut) {
- outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect));
- }
- for(typename Node::iterator itr = node->begin(); itr != node->end(); ++itr) {
- getMaxCover(outputContainer, *itr, orient, nextRect);
- }
- }
- */
-
- //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

Deleted: sandbox/gtl/point_3d_concept.hpp
==============================================================================
--- sandbox/gtl/point_3d_concept.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,192 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GLT_POINT_3D_CONCEPT_HPP
-#define GLT_POINT_3D_CONCEPT_HPP
-namespace gtl {
- struct point_3d_concept {};
-
- template <typename T>
- struct is_point_3d_concept { typedef gtl_no type; };
- template <>
- struct is_point_3d_concept<point_3d_concept> { typedef gtl_yes type; };
- //template <>
- //struct is_point_concept<point_3d_concept> { typedef void type; };
-
- template <typename T>
- struct is_mutable_point_3d_concept { typedef gtl_no type; };
- template <>
- struct is_mutable_point_3d_concept<point_3d_concept> { typedef gtl_yes type; };
-
- template <typename T>
- typename requires_1< typename gtl_if<typename is_point_3d_concept<typename geometry_concept<T>::type>::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 <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_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>
- 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>
- typename requires_1<
- typename gtl_and< 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>::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_1<
- typename gtl_and< typename gtl_same_type<point_3d_concept, typename geometry_concept<T>::type>::type,
- typename gtl_same_type<point_3d_concept, typename geometry_concept<T2>::type>::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_1< typename gtl_and< typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_1>::type>::type,
- typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_2>::type>::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_1< typename gtl_and< 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>::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_1< typename gtl_and<
- typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_1>::type>::type,
- typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_2>::type>::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_1< typename gtl_and<
- typename is_mutable_point_3d_concept<typename geometry_concept<point_type_1>::type>::type,
- typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_2>::type>::type>::type,
- point_type_1>::type &
- convolve(point_type_1& lvalue, const point_type_2& rvalue) {
- x(lvalue, x(lvalue) + x(rvalue));
- y(lvalue, y(lvalue) + y(rvalue));
- z(lvalue, z(lvalue) + z(rvalue));
- return lvalue;
- }
-
- template <typename point_type_1, typename point_type_2>
- typename requires_1<
- typename gtl_and< typename is_mutable_point_3d_concept<typename geometry_concept<point_type_1>::type>::type,
- typename gtl_same_type<point_3d_concept, typename geometry_concept<point_type_2>::type>::type>::type,
- point_type_1>::type &
- deconvolve(point_type_1& lvalue, const point_type_2& rvalue) {
- x(lvalue, x(lvalue) - x(rvalue));
- y(lvalue, y(lvalue) - y(rvalue));
- 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
-

Deleted: sandbox/gtl/point_3d_data.hpp
==============================================================================
--- sandbox/gtl/point_3d_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,41 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POINT_3D_DATA_HPP
-#define GTL_POINT_3D_DATA_HPP
-namespace gtl {
- template <typename T>
- class point_3d_data {
- public:
- typedef T coordinate_type;
- inline point_3d_data():coords_(){}
- inline point_3d_data(coordinate_type x, coordinate_type y):coords_() {
- coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = 0; }
- inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z):coords_() {
- coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = z; }
- inline point_3d_data(const point_3d_data& that):coords_() { (*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
-
-

Deleted: sandbox/gtl/point_3d_traits.hpp
==============================================================================
--- sandbox/gtl/point_3d_traits.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,32 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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;
-
- static inline coordinate_type get(const T& point, orientation_3d orient) {
- return point.get(orient); }
- };
-
- 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(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
-

Deleted: sandbox/gtl/point_concept.hpp
==============================================================================
--- sandbox/gtl/point_concept.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,230 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POINT_CONCEPT_HPP
-#define GTL_POINT_CONCEPT_HPP
-#include "isotropy.hpp"
-#include "point_data.hpp"
-#include "point_traits.hpp"
-
-namespace gtl {
- struct point_concept {};
-
- template <typename T>
- struct is_point_concept { typedef gtl_no type; };
- template <>
- struct is_point_concept<point_concept> { typedef gtl_yes type; };
-
- struct point_3d_concept;
- template <>
- struct is_point_concept<point_3d_concept> { typedef gtl_yes type; };
-
- template <typename T>
- struct is_mutable_point_concept { typedef gtl_no type; };
- template <>
- struct is_mutable_point_concept<point_concept> { typedef gtl_yes type; };
-
-
- template <typename T>
- typename requires_1< typename gtl_if<typename is_point_concept<typename geometry_concept<T>::type>::type>::type,
- typename point_traits<T>::coordinate_type >::type
- get(const T& point, orientation_2d orient) {
- return point_traits<T>::get(point, orient);
- }
-
- template <typename T, typename coordinate_type>
- 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 <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 T1, typename T2>
- typename requires_1< typename gtl_and< typename is_mutable_point_concept<typename geometry_concept<T1>::type>::type,
- typename is_point_concept<typename geometry_concept<T2>::type>::type>::type,
- 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>
- 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 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>
- 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, 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>
- typename requires_1< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<T>::type>::type,
- typename is_point_concept<typename geometry_concept<T2>::type>::type>::type,
- 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 = y(point2);
- return x1 == x2 && y1 == y2;
- }
-
- template <typename point_type_1, typename point_type_2>
- typename requires_1< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
- 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>
- typename requires_1< typename gtl_and<typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
- 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 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>
- typename requires_1< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
- typename gtl_same_type<point_concept, typename geometry_concept<point_type_2>::type>::type>::type,
- typename 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) {
- 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>
- typename requires_1< typename gtl_and<typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
- 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) {
- 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_1< typename gtl_and<typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type, 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_1< typename gtl_and<typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type,
- typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type, 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
-

Deleted: sandbox/gtl/point_data.hpp
==============================================================================
--- sandbox/gtl/point_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,71 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTLPOINT_DATA_HPP
-#define GTLPOINT_DATA_HPP
-
-#include "isotropy.hpp"
-
-namespace gtl {
-
- template <typename T>
- class point_data {
- public:
- typedef T coordinate_type;
- inline point_data():coords_(){}
- inline point_data(coordinate_type x, coordinate_type y):coords_() {
- coords_[HORIZONTAL] = x; coords_[VERTICAL] = y;
- }
- inline point_data(const point_data& that):coords_() { (*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 <class T>
- std::ostream& operator << (std::ostream& o, const point_data<T>& r)
- {
- return o << r.get(HORIZONTAL) << ' ' << r.get(VERTICAL);
- }
-
-}
-#endif
-

Deleted: sandbox/gtl/point_traits.hpp
==============================================================================
--- sandbox/gtl/point_traits.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,33 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POINT_TRAITS_HPP
-#define GTL_POINT_TRAITS_HPP
-
-namespace gtl {
- 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);
- }
- };
-
- 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
-

Deleted: sandbox/gtl/polygon_45_data.hpp
==============================================================================
--- sandbox/gtl/polygon_45_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,81 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_45_DATA_HPP
-#define GTL_POLYGON_45_DATA_HPP
-namespace gtl {
-struct polygon_45_concept;
-template <typename T>
-class polygon_45_data {
-public:
- typedef polygon_45_concept geometry_type;
- typedef T coordinate_type;
- typedef typename std::vector<point_data<coordinate_type> >::const_iterator iterator_type;
- typedef typename coordinate_traits<T>::coordinate_distance area_type;
- typedef point_data<T> point_type;
-
- inline polygon_45_data() : coords_() {} //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;
- }
-
- // copy constructor (since we have dynamic memory)
- inline polygon_45_data(const polygon_45_data& that) : coords_(that.coords_) {}
-
- // assignment operator (since we have dynamic memory do a deep copy)
- inline polygon_45_data& operator=(const polygon_45_data& that) {
- coords_ = that.coords_;
- return *this;
- }
-
- template <typename T2>
- inline polygon_45_data& operator=(const T2& rvalue);
-
- 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;
- }
-
- inline bool operator!=(const polygon_45_data& that) const { return !((*this) == that); }
-
- // get begin iterator, returns a pointer to a const Unit
- inline iterator_type begin() const { return coords_.begin(); }
-
- // get end iterator, returns a pointer to a const Unit
- inline iterator_type end() const { return coords_.end(); }
-
- inline std::size_t size() const { return coords_.size(); }
-
-private:
- 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
-

Deleted: sandbox/gtl/polygon_45_formation.hpp
==============================================================================
--- sandbox/gtl/polygon_45_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,2212 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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<Unit> Point;
- typedef polygon_45_data<Unit> Polygon45;
- typedef polygon_45_with_holes_data<Unit> Polygon45WithHoles;
- typedef typename boolean_op_45<Unit>::Vertex45 Vertex45;
- typedef typename boolean_op_45<Unit>::lessVertex45 lessVertex45;
- typedef typename boolean_op_45<Unit>::Count2 Count2;
- typedef typename boolean_op_45<Unit>::Scan45Count Scan45Count;
- typedef std::pair<Point, Scan45Count> Scan45Vertex;
- typedef typename boolean_op_45<Unit>::template
- Scan45<Count2, typename boolean_op_45<Unit>::template boolean_op_45_output_functor<0> > Scan45;
-
- class PolyLine45 {
- public:
- typedef typename std::list<Point>::const_iterator iterator;
-
- // default constructor of point does not initialize x and y
- inline PolyLine45() : points() {} //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), holesList_(), head_(0) {}
-
- //constructor
- inline ActiveTail45(const Vertex45& vertex, ActiveTail45* otherTailp = 0) :
- tailp_(0), otherTailp_(0), holesList_(), head_(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_(0), otherTailp_(0), holesList_(), head_(0) {
- tailp_ = new PolyLine45;
- tailp_->points.push_back(point);
- head_ = head;
- otherTailp_ = otherTailp;
-
- }
- inline ActiveTail45(ActiveTail45* otherTailp) :
- tailp_(0), otherTailp_(0), holesList_(), head_(0) {
- tailp_ = otherTailp->tailp_;
- otherTailp_ = otherTailp;
- }
-
- //copy constructor
- inline ActiveTail45(const ActiveTail45& that) :
- tailp_(0), otherTailp_(0), holesList_(), head_(0) { (*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 = 0;
- ActiveTail45* 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 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);
- }
-
- };
-
- template <typename ct>
- class Vertex45CountT {
- public:
- typedef ct count_type;
- inline Vertex45CountT() : counts() { counts[0] = counts[1] = counts[2] = counts[3] = 0; }
- //inline Vertex45CountT(ct count) { counts[0] = counts[1] = counts[2] = counts[3] = count; }
- inline Vertex45CountT(const ct& count1, const ct& count2, const ct& count3,
- const ct& count4) : counts() {
- counts[0] = count1;
- counts[1] = count2;
- counts[2] = count3;
- counts[3] = count4;
- }
- inline Vertex45CountT(const Vertex45& vertex) : counts() {
- counts[0] = counts[1] = counts[2] = counts[3] = 0;
- (*this) += vertex;
- }
- inline Vertex45CountT(const Vertex45CountT& count) : counts() {
- (*this) = count;
- }
- inline bool operator==(const Vertex45CountT& count) const {
- for(unsigned int i = 0; i < 4; ++i) {
- if(counts[i] != count.counts[i]) return false;
- }
- return true;
- }
- inline bool operator!=(const Vertex45CountT& count) const { return !((*this) == count); }
- inline Vertex45CountT& operator=(ct count) {
- counts[0] = counts[1] = counts[2] = counts[3] = count; return *this; }
- inline Vertex45CountT& operator=(const Vertex45CountT& count) {
- for(unsigned int i = 0; i < 4; ++i) {
- counts[i] = count.counts[i];
- }
- return *this;
- }
- inline ct& operator[](int index) { return counts[index]; }
- inline ct operator[](int index) const {return counts[index]; }
- inline Vertex45CountT& operator+=(const Vertex45CountT& count){
- for(unsigned int i = 0; i < 4; ++i) {
- counts[i] += count.counts[i];
- }
- return *this;
- }
- inline Vertex45CountT& operator-=(const Vertex45CountT& count){
- for(unsigned int i = 0; i < 4; ++i) {
- counts[i] -= count.counts[i];
- }
- return *this;
- }
- inline Vertex45CountT operator+(const Vertex45CountT& count) const {
- return Vertex45CountT(*this)+=count;
- }
- inline Vertex45CountT operator-(const Vertex45CountT& count) const {
- return Vertex45CountT(*this)-=count;
- }
- inline Vertex45CountT invert() const {
- return Vertex45CountT()-=(*this);
- }
- inline Vertex45CountT& 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:
- ct counts[4];
- };
-
- typedef Vertex45CountT<int> Vertex45Count;
-
-// inline std::ostream& operator<< (std::ostream& o, const Vertex45Count& c) {
-// o << c[0] << ", " << c[1] << ", ";
-// o << c[2] << ", " << c[3];
-// return o;
-// }
-
- template <typename ct>
- class Vertex45CompactT {
- public:
- Point pt;
- ct count;
- typedef typename boolean_op_45<Unit>::template Vertex45T<typename ct::count_type> Vertex45T;
- inline Vertex45CompactT() : pt(), count() {}
- inline Vertex45CompactT(const Point& point, int riseIn, int countIn) : pt(point), count() {
- count[riseIn+1] = countIn;
- }
- inline Vertex45CompactT(const Vertex45T& vertex) : pt(vertex.pt), count() {
- count[vertex.rise+1] = vertex.count;
- }
- inline Vertex45CompactT(const Vertex45CompactT& vertex) : pt(vertex.pt), count(vertex.count) {}
- inline Vertex45CompactT& operator=(const Vertex45CompactT& vertex){
- pt = vertex.pt; count = vertex.count; return *this; }
- inline bool operator==(const Vertex45CompactT& vertex) const {
- return pt == vertex.pt && count == vertex.count; }
- inline bool operator!=(const Vertex45CompactT& 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 Vertex45CompactT& 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 Vertex45CompactT& vertex) const { return vertex < (*this); }
- inline bool operator<=(const Vertex45CompactT& vertex) const { return !((*this) > vertex); }
- inline bool operator>=(const Vertex45CompactT& vertex) const { return !((*this) < vertex); }
- inline bool haveVertex45(int index) const { return count[index]; }
- inline Vertex45T operator[](int index) const {
- return Vertex45T(pt, index-1, count[index]); }
- };
-
- typedef Vertex45CompactT<Vertex45Count> Vertex45Compact;
-
-// 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() : scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(0) {
- lessVertex45 lessElm(&x_, &justBefore_);
- scanData_ = Polygon45FormationData(lessElm);
- }
- inline Polygon45Formation(bool fractureHoles) : scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(fractureHoles) {
- lessVertex45 lessElm(&x_, &justBefore_);
- scanData_ = Polygon45FormationData(lessElm);
- }
- inline Polygon45Formation(const Polygon45Formation& that) :
- scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false), fractureHoles_(0) { (*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;
- 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() : scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false) {
- lessVertex45 lessElm(&x_, &justBefore_);
- scanData_ = Polygon45FormationData(lessElm);
- }
- inline Polygon45Tiling(const Polygon45Tiling& that) :
- scanData_(), x_((std::numeric_limits<Unit>::min())), justBefore_(false) { (*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;
- 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

Deleted: sandbox/gtl/polygon_45_set_concept.hpp
==============================================================================
--- sandbox/gtl/polygon_45_set_concept.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,350 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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_1< typename gtl_and< 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>::type,
- polygon_set_type_1>::type &
- assign(polygon_set_type_1& lvalue, const polygon_set_type_2& rvalue) {
- polygon_45_set_mutable_traits<polygon_set_type_1>::set(lvalue, begin_45_set_data(rvalue), end_45_set_data(rvalue));
- 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);
- }
-
- //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, orientation_2d slicing_orientation) {
- 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, slicing_orientation);
- }
-
- //equivalence
- template <typename polygon_set_type_1, typename polygon_set_type_2>
- typename requires_1< typename gtl_and_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>::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_1<
- typename gtl_and< 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>::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 is_mutable_polygon_45_set_type<polygon_set_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;
- }
-
- //interact
- template <typename polygon_set_type_1, typename polygon_set_type_2>
- typename requires_1 <
- typename gtl_and< 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 >::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_45_set_traits<polygon_set_type_1>::coordinate_type Unit;
- std::vector<polygon_45_data<Unit> > polys;
- assign(polys, polygon_set_1);
- std::vector<std::set<int> > graph(polys.size()+1, std::set<int>());
- connectivity_extraction_45<Unit> ce;
- ce.insert(polygon_set_2);
- for(unsigned int i = 0; i < polys.size(); ++i){
- ce.insert(polys[i]);
- }
- ce.extract(graph);
- clear(polygon_set_1);
- polygon_45_set_data<Unit> ps;
- 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 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 is_mutable_polygon_45_set_type<polygon_set_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 is_mutable_polygon_45_set_type<polygon_set_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 is_mutable_polygon_45_set_type<polygon_set_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 is_mutable_polygon_45_set_type<polygon_set_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);
- }
- ps.self_intersect();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_45_set_type<polygon_set_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 is_mutable_polygon_45_set_type<polygon_set_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;
- }
-
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_45_set_type<polygon_set_type>::type,
- polygon_set_type>::type &
- scale(polygon_set_type& polygon_set, double 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(factor);
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- //self_intersect
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_45_set_type<polygon_set_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;
- polygon_45_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.self_intersect();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- //self_xor
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_45_set_type<polygon_set_type>::type,
- polygon_set_type>::type &
- self_xor(polygon_set_type& polygon_set) {
- typedef typename polygon_45_set_traits<polygon_set_type>::coordinate_type Unit;
- polygon_45_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.self_xor();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- //transform
- template <typename polygon_set_type, typename transformation_type>
- typename requires_1< typename is_mutable_polygon_45_set_type<polygon_set_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 is_mutable_polygon_45_set_type<polygon_set_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

Deleted: sandbox/gtl/polygon_45_set_data.hpp
==============================================================================
--- sandbox/gtl/polygon_45_set_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,1728 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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, SQRT1OVER2 = 4 };
- enum CornerOption { INTERSECTION = 0, ORTHOGONAL = 1, UNFILLED = 2 };
-
- template <typename ltype, typename rtype, int op_type>
- struct 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() : error_data_(), 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) : error_data_(), data_(), dirty_(false), unsorted_(false), is_manhattan_(true) {
- insert(that);
- }
-
- // copy constructor
- inline polygon_45_set_data(const polygon_45_set_data& that) :
- error_data_(that.error_data_), data_(that.data_), dirty_(that.dirty_),
- unsorted_(that.unsorted_), is_manhattan_(that.is_manhattan_) {}
-
- template <typename ltype, typename rtype, int op_type>
- inline polygon_45_set_data(const polygon_45_set_view<ltype, rtype, op_type>& that) :
- error_data_(), data_(), dirty_(false), unsorted_(false), is_manhattan_(true) {
- (*this) = that.value();
- }
-
- // 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;
- error_data_ = that.error_data_;
- 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) {
- (*this) = that.value();
- 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
- inline void insert(iterator_type input_begin, iterator_type input_end, bool is_hole = false) {
- if(input_begin == input_end || input_begin == data_.begin()) return;
- dirty_ = true;
- unsorted_ = true;
- while(input_begin != input_end) {
- insert(*input_begin, is_hole);
- ++input_begin;
- }
- }
-
- // 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());
- }
-
- inline void has_error_data() const { return !error_data_.empty(); }
- inline unsigned int error_count() const { return error_data_.size() / 4; }
- inline void get_error_data(polygon_45_set_data& p) const {
- p.data_.insert(p.data_.end(), error_data_.begin(), error_data_.end());
- }
-
- // 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(); error_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
- // slicing orientation is vertical
- template <class cT>
- void 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";
- }
-
- // append to the container cT with polygons of three or four verticies
- template <class cT>
- void get_trapezoids(cT& container, orientation_2d slicing_orientation) const {
- if(slicing_orientation == VERTICAL) {
- get_trapezoids(container);
- } else {
- polygon_45_set_data<Unit> ps(*this);
- ps.transform(axis_transformation(axis_transformation::SWAP_XY));
- cT result;
- ps.get_trapezoids(result);
- for(typename cT::iterator itr = result.begin(); itr != result.end(); ++itr) {
- ::gtl::transform(*itr, axis_transformation(axis_transformation::SWAP_XY));
- }
- container.insert(container.end(), result.begin(), result.end());
- }
- }
-
- // 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);
- polygon_45_set_data& scale(double scaling);
-
- // self_intersect
- polygon_45_set_data& self_intersect() {
- sort();
- applyAdaptiveUnary_<1>(); //1 = AND
- dirty_ = false;
- return *this;
- }
-
- // self_xor
- polygon_45_set_data& self_xor() {
- sort();
- applyAdaptiveUnary_<3>(); //3 = XOR
- dirty_ = false;
- return *this;
- }
-
- // 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 error_data_;
- 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);
- 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:
- template <int op>
- void applyAdaptiveBoolean_(const polygon_45_set_data& rvalue) const;
- template <int op>
- void applyAdaptiveBoolean_(polygon_45_set_data& result, const polygon_45_set_data& rvalue) const;
- template <int op>
- void applyAdaptiveUnary_() const;
- };
-
- template <typename T>
- struct geometry_concept<polygon_45_set_data<T> > {
- typedef polygon_45_set_concept type;
- };
-
- template <typename iT>
- void scale_up_vertex_45_compact_range(iT beginr, iT endr, unsigned int factor) {
- for( ; beginr != endr; ++beginr) {
- scale_up((*beginr).pt, factor);
- }
- }
- template <typename iT>
- void scale_down_vertex_45_compact_range_blindly(iT beginr, iT endr, unsigned int factor) {
- for( ; beginr != endr; ++beginr) {
- scale_down((*beginr).pt, factor);
- }
- }
-
- 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 cT, typename pT>
- bool insert_vertex_half_edge_45_pair_into_vector(cT& output,
- const pT& pt1, pT& pt2,
- const pT& pt3,
- direction_1d wdir) {
- int multiplier = wdir == LOW ? -1 : 1;
- typename cT::value_type 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;
- output.push_back(vertex);
- return vertex.count.is_45();
- }
-
- 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) {
- if(insert_vertex_half_edge_45_pair_into_vector(data_, pt1, pt2, pt3, wdir)) 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) {
- unsigned int count = data_.size();
- data_.insert(data_.end(), polygon_set.data_.begin(), polygon_set.data_.end());
- error_data_.insert(error_data_.end(), polygon_set.error_data_.begin(),
- polygon_set.error_data_.end());
- if(is_hole) {
- for(unsigned int i = count; i < data_.size(); ++i) {
- data_[i].count = data_[i].count.invert();
- }
- }
- dirty_ = true;
- unsorted_ = true;
- if(polygon_set.is_manhattan_ == false) is_manhattan_ = false;
- return;
- }
-
- template <typename cT, typename rT>
- void insert_rectangle_into_vector_45(cT& output, const rT& rect, bool is_hole) {
- point_data<typename rectangle_traits<rT>::coordinate_type>
- llpt = ll(rect), lrpt = lr(rect), ulpt = ul(rect), urpt = ur(rect);
- direction_1d dir = COUNTERCLOCKWISE;
- if(is_hole) dir = CLOCKWISE;
- insert_vertex_half_edge_45_pair_into_vector(output, llpt, lrpt, urpt, dir);
- insert_vertex_half_edge_45_pair_into_vector(output, lrpt, urpt, ulpt, dir);
- insert_vertex_half_edge_45_pair_into_vector(output, urpt, ulpt, llpt, dir);
- insert_vertex_half_edge_45_pair_into_vector(output, ulpt, llpt, lrpt, dir);
- }
-
- template <typename Unit>
- template <typename geometry_type>
- inline void polygon_45_set_data<Unit>::insert_dispatch(const geometry_type& geometry_object,
- bool is_hole, rectangle_concept tag) {
- dirty_ = true;
- unsorted_ = true;
- insert_rectangle_into_vector_45(data_, geometry_object, is_hole);
- }
-
- // get the external boundary rectangle
- template <typename Unit>
- template <typename rectangle_type>
- inline bool polygon_45_set_data<Unit>::extents(rectangle_type& rect) const{
- clean();
- 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_SQRT1OVER2(polygon_45_set_data<Unit>& sizingSet, point_data<Unit> first,
- point_data<Unit> second, Unit resizing, CornerOption corner) {
- if(first.x() == second.x()) {
- sizingSet.insert(rectangle_data<int>(first.x() - resizing, first.y(), first.x() + resizing, second.y()));
- return;
- }
- if(first.y() == second.y()) {
- sizingSet.insert(rectangle_data<int>(first.x(), first.y() - resizing, second.x(), first.y() + resizing));
- return;
- }
- std::vector<point_data<Unit> > pts;
- Unit bloating = resizing < 0 ? -resizing : resizing;
- if(corner == UNFILLED) {
- //we have to round up
- bloating = bloating / 2 + bloating % 2 ; //round up
- if(second.x() < first.x()) std::swap(first, second);
- if(first.y() < second.y()) { //upward sloping
- pts.push_back(point_data<Unit>(first.x() + bloating, first.y() - bloating));
- pts.push_back(point_data<Unit>(first.x() - bloating, first.y() + bloating));
- pts.push_back(point_data<Unit>(second.x() - bloating, second.y() + bloating));
- pts.push_back(point_data<Unit>(second.x() + bloating, second.y() - bloating));
- sizingSet.insert_vertex_sequence(pts.begin(), pts.end(), CLOCKWISE, false);
- } else { //downward sloping
- pts.push_back(point_data<Unit>(first.x() + bloating, first.y() + bloating));
- pts.push_back(point_data<Unit>(first.x() - bloating, first.y() - bloating));
- pts.push_back(point_data<Unit>(second.x() - bloating, second.y() - bloating));
- pts.push_back(point_data<Unit>(second.x() + bloating, second.y() + bloating));
- sizingSet.insert_vertex_sequence(pts.begin(), pts.end(), COUNTERCLOCKWISE, false);
- }
- return;
- }
- if(second.x() < first.x()) std::swap(first, second);
- if(first.y() < second.y()) { //upward sloping
- pts.push_back(point_data<Unit>(first.x(), first.y() - bloating));
- pts.push_back(point_data<Unit>(first.x() - bloating, first.y()));
- pts.push_back(point_data<Unit>(second.x(), second.y() + bloating));
- pts.push_back(point_data<Unit>(second.x() + bloating, second.y()));
- sizingSet.insert_vertex_sequence(pts.begin(), pts.end(), CLOCKWISE, false);
- } else { //downward sloping
- pts.push_back(point_data<Unit>(first.x() - bloating, first.y()));
- pts.push_back(point_data<Unit>(first.x(), first.y() + bloating));
- pts.push_back(point_data<Unit>(second.x() + bloating, second.y()));
- pts.push_back(point_data<Unit>(second.x(), second.y() - bloating));
- sizingSet.insert_vertex_sequence(pts.begin(), pts.end(), CLOCKWISE, false);
- }
- }
-
-
- 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.insert(rectangle_data<int>(first.x() - resizing, first.y(), first.x() + resizing, second.y()));
- return;
- }
- if(first.y() == second.y()) {
- sizingSet.insert(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 point_data<Unit> bloatVertexInDirWithSQRT1OVER2(int edge1, int normal1, const point_data<Unit>& second, Unit bloating,
- bool first) {
- orientation_2d orient = first ? HORIZONTAL : VERTICAL;
- orientation_2d orientp = orient.get_perpendicular();
- int multiplier = first ? 1 : -1;
- point_data<Unit> pt1(second);
- if(edge1 == 1) {
- if(normal1 == 3) {
- move(pt1, orient, -multiplier * bloating);
- } else {
- move(pt1, orientp, -multiplier * bloating);
- }
- } else if(edge1 == 3) {
- if(normal1 == 1) {
- move(pt1, orient, multiplier * bloating);
- } else {
- move(pt1, orientp, -multiplier * bloating);
- }
- } else if(edge1 == 5) {
- if(normal1 == 3) {
- move(pt1, orientp, multiplier * bloating);
- } else {
- move(pt1, orient, multiplier * bloating);
- }
- } else {
- if(normal1 == 5) {
- move(pt1, orient, -multiplier * bloating);
- } else {
- move(pt1, orientp, multiplier * bloating);
- }
- }
- return pt1;
- }
-
- 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
- }
- Unit bloating = abs(resizing);
- if(rounding == SQRT1OVER2) {
- if(edge1 % 2 && edge2 % 2) return;
- if(corner == ORTHOGONAL && edge1 % 2 == 0 && edge2 % 2 == 0) {
- rectangle_data<Unit> insertion_rect;
- set_points(insertion_rect, second, second);
- bloat(insertion_rect, bloating);
- sizingSet.insert(insertion_rect);
- } else if(corner != ORTHOGONAL) {
- point_data<Unit> pt1(0, 0);
- point_data<Unit> pt2(0, 0);
- unsigned int normal1 = getEdge45NormalDirection(edge1, multiplier);
- unsigned int normal2 = getEdge45NormalDirection(edge2, multiplier);
- if(edge1 % 2) {
- pt1 = bloatVertexInDirWithSQRT1OVER2(edge1, normal1, second, bloating, true);
- } else {
- pt1 = bloatVertexInDirWithOptions(second, normal1, bloating, UNDERSIZE);
- }
- if(edge2 % 2) {
- pt2 = bloatVertexInDirWithSQRT1OVER2(edge2, normal2, second, bloating, false);
- } else {
- pt2 = bloatVertexInDirWithOptions(second, normal2, bloating, UNDERSIZE);
- }
- std::vector<point_data<Unit> > pts;
- pts.push_back(pt1);
- pts.push_back(second);
- pts.push_back(pt2);
- pts.push_back(getIntersectionPoint(pt1, edge1, pt2, edge2));
- polygon_45_data<Unit> poly(pts.begin(), pts.end());
- sizingSet.insert(poly);
- } else {
- //ORTHOGONAL of a 45 degree corner
- int normal = 0;
- if(edge1 % 2) {
- normal = getEdge45NormalDirection(edge2, multiplier);
- } else {
- normal = getEdge45NormalDirection(edge1, multiplier);
- }
- rectangle_data<Unit> insertion_rect;
- point_data<Unit> edgePoint = bloatVertexInDirWithOptions(second, normal, bloating, UNDERSIZE);
- set_points(insertion_rect, second, edgePoint);
- if(normal == 0 || normal == 4)
- bloat(insertion_rect, VERTICAL, bloating);
- else
- bloat(insertion_rect, HORIZONTAL, bloating);
- sizingSet.insert(insertion_rect);
- }
- return;
- }
- unsigned int normal1 = getEdge45NormalDirection(edge1, multiplier);
- unsigned int normal2 = getEdge45NormalDirection(edge2, multiplier);
- 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 == ORTHOGONAL) {
- rectangle_data<Unit> 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.insert(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) 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 {
- if(rounding != SQRT1OVER2) {
- handleResizingEdge45(sizingSet, *first, *second, resizing, rounding);
- } else {
- handleResizingEdge45_SQRT1OVER2(sizingSet, *first, *second, resizing, corner);
- }
- if(corner != UNFILLED)
- 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_dispatch(poly, false, polygon_45_concept());
- if(resizing < 0) tmp -= sizingSet;
- else tmp += sizingSet;
- tmp.clean();
- insert(tmp, hole);
- return (*this);
- }
-
- // 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) {
- scale_up_vertex_45_compact_range(data_.begin(), data_.end(), factor);
- 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 polygon_45_set_data<Unit>& polygon_45_set_data<Unit>::scale(double 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(*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_) {
- applyAdaptiveUnary_<0>();
- dirty_ = false;
- }
- return true;
- }
-
- template <typename Unit>
- template <int op>
- inline void polygon_45_set_data<Unit>::applyAdaptiveBoolean_(const polygon_45_set_data<Unit>& rvalue) const {
- polygon_45_set_data<Unit> tmp;
- applyAdaptiveBoolean_<op>(tmp, rvalue);
- data_.swap(tmp.data_); //swapping vectors should be constant time operation
- error_data_.swap(tmp.error_data_);
- is_manhattan_ = tmp.is_manhattan_;
- unsorted_ = false;
- dirty_ = false;
- }
-
- template <typename Unit2, int op>
- bool applyBoolean45OpOnVectors(std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact>& result_data,
- std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact>& lvalue_data,
- std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact>& rvalue_data
- ) {
- bool result_is_manhattan_ = true;
- typename boolean_op_45<Unit2>::template Scan45<typename boolean_op_45<Unit2>::Count2,
- typename boolean_op_45<Unit2>::template boolean_op_45_output_functor<op> > scan45;
- std::vector<typename boolean_op_45<Unit2>::Vertex45> eventOut;
- typedef std::pair<typename boolean_op_45<Unit2>::Point,
- typename boolean_op_45<Unit2>::template Scan45CountT<typename boolean_op_45<Unit2>::Count2> > Scan45Vertex;
- std::vector<Scan45Vertex> eventIn;
- typedef std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact> value_type;
- typename value_type::const_iterator iter1 = lvalue_data.begin();
- typename value_type::const_iterator iter2 = rvalue_data.begin();
- typename value_type::const_iterator end1 = lvalue_data.end();
- typename value_type::const_iterator end2 = rvalue_data.end();
- const Unit2 UnitMax = std::numeric_limits<Unit2>::max();
- Unit2 x = UnitMax;
- while(iter1 != end1 || iter2 != end2) {
- Unit2 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());
- unsigned int ptCount = 0;
- 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];
- ++ptCount;
- } else {
- if(!result_data.empty()) {
- if(result_data.back().count.is_45()) {
- result_is_manhattan_ = false;
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- }
- result_data.push_back(eventOut[i]);
- ptCount = 1;
- }
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::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(Scan45Vertex
- (iter2->pt,
- typename polygon_45_formation<Unit2>::
- Scan45Count(typename polygon_45_formation<Unit2>::Count2(0, iter2->count[0]),
- typename polygon_45_formation<Unit2>::Count2(0, iter2->count[1]),
- typename polygon_45_formation<Unit2>::Count2(0, iter2->count[2]),
- typename polygon_45_formation<Unit2>::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(Scan45Vertex
- (iter1->pt,
- typename polygon_45_formation<Unit2>::
- Scan45Count(
- typename polygon_45_formation<Unit2>::Count2(iter1->count[0], 0),
- typename polygon_45_formation<Unit2>::Count2(iter1->count[1], 0),
- typename polygon_45_formation<Unit2>::Count2(iter1->count[2], 0),
- typename polygon_45_formation<Unit2>::Count2(iter1->count[3], 0))));
- ++iter1;
- } else {
- //std::cout << "case3 next\n";
- eventIn.push_back(Scan45Vertex
- (iter2->pt,
- typename polygon_45_formation<Unit2>::
- Scan45Count(typename polygon_45_formation<Unit2>::Count2(iter1->count[0],
- iter2->count[0]),
- typename polygon_45_formation<Unit2>::Count2(iter1->count[1],
- iter2->count[1]),
- typename polygon_45_formation<Unit2>::Count2(iter1->count[2],
- iter2->count[2]),
- typename polygon_45_formation<Unit2>::Count2(iter1->count[3],
- iter2->count[3]))));
- ++iter1;
- ++iter2;
- }
- }
- scan45.scan(eventOut, eventIn.begin(), eventIn.end());
- std::sort(eventOut.begin(), eventOut.end());
-
- unsigned int ptCount = 0;
- 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];
- ++ptCount;
- } else {
- if(!result_data.empty()) {
- if(result_data.back().count.is_45()) {
- result_is_manhattan_ = false;
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- }
- result_data.push_back(eventOut[i]);
- ptCount = 1;
- }
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- if(!result_data.empty() &&
- result_data.back().count.is_45()) {
- result_is_manhattan_ = false;
- }
- return result_is_manhattan_;
- }
-
- template <typename Unit2, int op>
- bool applyUnary45OpOnVectors(std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact>& result_data,
- std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact>& lvalue_data ) {
- bool result_is_manhattan_ = true;
- typename boolean_op_45<Unit2>::template Scan45<typename boolean_op_45<Unit2>::Count1,
- typename boolean_op_45<Unit2>::template unary_op_45_output_functor<op> > scan45;
- std::vector<typename boolean_op_45<Unit2>::Vertex45> eventOut;
- typedef typename boolean_op_45<Unit2>::template Scan45CountT<typename boolean_op_45<Unit2>::Count1> Scan45Count;
- typedef std::pair<typename boolean_op_45<Unit2>::Point, Scan45Count> Scan45Vertex;
- std::vector<Scan45Vertex> eventIn;
- typedef std::vector<typename polygon_45_formation<Unit2>::Vertex45Compact> value_type;
- typename value_type::const_iterator iter1 = lvalue_data.begin();
- typename value_type::const_iterator end1 = lvalue_data.end();
- const Unit2 UnitMax = std::numeric_limits<Unit2>::max();
- Unit2 x = UnitMax;
- while(iter1 != end1) {
- Unit2 currentX = iter1->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());
- unsigned int ptCount = 0;
- 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];
- ++ptCount;
- } else {
- if(!result_data.empty()) {
- if(result_data.back().count.is_45()) {
- result_is_manhattan_ = false;
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- }
- result_data.push_back(eventOut[i]);
- ptCount = 1;
- }
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- eventOut.clear();
- eventIn.clear();
- x = currentX;
- }
- //std::cout << "get next\n";
- eventIn.push_back(Scan45Vertex
- (iter1->pt,
- Scan45Count( typename boolean_op_45<Unit2>::Count1(iter1->count[0]),
- typename boolean_op_45<Unit2>::Count1(iter1->count[1]),
- typename boolean_op_45<Unit2>::Count1(iter1->count[2]),
- typename boolean_op_45<Unit2>::Count1(iter1->count[3]))));
- ++iter1;
- }
- scan45.scan(eventOut, eventIn.begin(), eventIn.end());
- std::sort(eventOut.begin(), eventOut.end());
-
- unsigned int ptCount = 0;
- 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];
- ++ptCount;
- } else {
- if(!result_data.empty()) {
- if(result_data.back().count.is_45()) {
- result_is_manhattan_ = false;
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- }
- result_data.push_back(eventOut[i]);
- ptCount = 1;
- }
- }
- if(ptCount == 2 && result_data.back().count == (typename polygon_45_formation<Unit2>::Vertex45Count(0, 0, 0, 0))) {
- result_data.pop_back();
- }
- if(!result_data.empty() &&
- result_data.back().count.is_45()) {
- result_is_manhattan_ = false;
- }
- return result_is_manhattan_;
- }
-
- template <typename cT, typename iT>
- void get_error_rects_shell(cT& posE, cT& negE, iT beginr, iT endr) {
- typedef typename iT::value_type Point;
- Point pt1, pt2, pt3;
- bool i1 = true;
- bool i2 = true;
- bool not_done = beginr != endr;
- bool next_to_last = false;
- bool last = false;
- Point first, second;
- while(not_done) {
- if(last) {
- last = false;
- not_done = false;
- pt3 = second;
- } else if(next_to_last) {
- next_to_last = false;
- last = true;
- pt3 = first;
- } else if(i1) {
- const Point& pt = *beginr;
- first = pt1 = pt;
- i1 = false;
- i2 = true;
- ++beginr;
- if(beginr == endr) return; //too few points
- continue;
- } else if (i2) {
- const Point& pt = *beginr;
- second = pt2 = pt;
- i2 = false;
- ++beginr;
- if(beginr == endr) return; //too few points
- continue;
- } else {
- const Point& pt = *beginr;
- pt3 = pt;
- ++beginr;
- if(beginr == endr) {
- next_to_last = true;
- //skip last point equal to first
- continue;
- }
- }
- if(abs(x(pt2)) % 2) { //y % 2 should also be odd
- //is corner concave or convex?
- Point pts[] = {pt1, pt2, pt3};
- double ar = point_sequence_area<Point*, double>(pts, pts+3);
- direction_1d dir = ar < 0 ? COUNTERCLOCKWISE : CLOCKWISE;
- //std::cout << pt1 << " " << pt2 << " " << pt3 << " " << ar << std::endl;
- if(dir == CLOCKWISE) {
- posE.push_back(rectangle_data<typename Point::coordinate_type>
- (x(pt2) - 1, y(pt2) - 1, x(pt2) + 1, y(pt2) + 1));
-
- } else {
- negE.push_back(rectangle_data<typename Point::coordinate_type>
- (x(pt2) - 1, y(pt2) - 1, x(pt2) + 1, y(pt2) + 1));
- }
- }
- pt1 = pt2;
- pt2 = pt3;
- }
- }
-
- template <typename cT, typename pT>
- void get_error_rects(cT& posE, cT& negE, const pT& p) {
- get_error_rects_shell(posE, negE, p.begin(), p.end());
- for(typename pT::iterator_holes_type iHb = p.begin_holes();
- iHb != p.end_holes(); ++iHb) {
- get_error_rects_shell(posE, negE, iHb->begin(), iHb->end());
- }
- }
-
- template <typename Unit>
- template <int op>
- inline void polygon_45_set_data<Unit>::applyAdaptiveBoolean_(polygon_45_set_data<Unit>& result,
- const polygon_45_set_data<Unit>& rvalue) const {
- result.clear();
- result.error_data_ = error_data_;
- result.error_data_.insert(result.error_data_.end(), rvalue.error_data_.begin(),
- rvalue.error_data_.end());
- 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.data_.clear();
- result.insert(output);
- result.is_manhattan_ = true;
- result.dirty_ = false;
- result.unsorted_ = false;
- } else {
- sort();
- rvalue.sort();
- try {
- result.is_manhattan_ = applyBoolean45OpOnVectors<Unit, op>(result.data_, data_, rvalue.data_);
- } catch (std::string str) {
- std::string msg = "GTL 45 Boolean error, precision insufficient to represent edge intersection coordinate value.";
- if(str == msg) {
- result.clear();
- typedef typename coordinate_traits<Unit>::manhattan_area_type Unit2;
- typedef typename polygon_45_formation<Unit2>::Vertex45Compact Vertex45Compact2;
- typedef std::vector<Vertex45Compact2> Data2;
- Data2 rvalue_data, lvalue_data, result_data;
- rvalue_data.reserve(rvalue.data_.size());
- lvalue_data.reserve(data_.size());
- for(unsigned int i = 0 ; i < data_.size(); ++i) {
- const Vertex45Compact& vi = data_[i];
- Vertex45Compact2 ci;
- ci.pt = point_data<Unit2>(x(vi.pt), y(vi.pt));
- ci.count = typename polygon_45_formation<Unit2>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- lvalue_data.push_back(ci);
- }
- for(unsigned int i = 0 ; i < rvalue.data_.size(); ++i) {
- const Vertex45Compact& vi = rvalue.data_[i];
- Vertex45Compact2 ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
- ci.count = typename polygon_45_formation<Unit2>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- rvalue_data.push_back(ci);
- }
- scale_up_vertex_45_compact_range(lvalue_data.begin(), lvalue_data.end(), 2);
- scale_up_vertex_45_compact_range(rvalue_data.begin(), rvalue_data.end(), 2);
- bool result_is_manhattan = applyBoolean45OpOnVectors<Unit2, op>(result_data,
- lvalue_data,
- rvalue_data );
- if(!result_is_manhattan) {
- typename polygon_45_formation<Unit2>::Polygon45Formation pf(false);
- //std::cout << "FORMING POLYGONS\n";
- std::vector<polygon_45_with_holes_data<Unit2> > container;
- pf.scan(container, result_data.begin(), result_data.end());
- Data2 error_data_out;
- std::vector<rectangle_data<Unit2> > pos_error_rects;
- std::vector<rectangle_data<Unit2> > neg_error_rects;
- for(unsigned int i = 0; i < container.size(); ++i) {
- get_error_rects(pos_error_rects, neg_error_rects, container[i]);
- }
- for(unsigned int i = 0; i < pos_error_rects.size(); ++i) {
- insert_rectangle_into_vector_45(result_data, pos_error_rects[i], false);
- insert_rectangle_into_vector_45(error_data_out, pos_error_rects[i], false);
- }
- for(unsigned int i = 0; i < neg_error_rects.size(); ++i) {
- insert_rectangle_into_vector_45(result_data, neg_error_rects[i], true);
- insert_rectangle_into_vector_45(error_data_out, neg_error_rects[i], false);
- }
- scale_down_vertex_45_compact_range_blindly(error_data_out.begin(), error_data_out.end(), 2);
- for(unsigned int i = 0 ; i < error_data_out.size(); ++i) {
- const Vertex45Compact2& vi = error_data_out[i];
- Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
- ci.count = typename polygon_45_formation<Unit>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- result.error_data_.push_back(ci);
- }
- Data2 new_result_data;
- std::sort(result_data.begin(), result_data.end());
- applyUnary45OpOnVectors<Unit2, 0>(new_result_data, result_data); //OR operation
- result_data.swap(new_result_data);
- }
- scale_down_vertex_45_compact_range_blindly(result_data.begin(), result_data.end(), 2);
- //result.data_.reserve(result_data.size());
- for(unsigned int i = 0 ; i < result_data.size(); ++i) {
- const Vertex45Compact2& vi = result_data[i];
- Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
- ci.count = typename polygon_45_formation<Unit>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- result.data_.push_back(ci);
- }
- result.is_manhattan_ = result_is_manhattan;
- result.dirty_ = false;
- result.unsorted_ = false;
- } else { throw str; }
- }
- //std::cout << "DONE SCANNING\n";
- }
- }
-
- template <typename Unit>
- template <int op>
- inline void polygon_45_set_data<Unit>::applyAdaptiveUnary_() const {
- polygon_45_set_data<Unit> result;
- result.error_data_ = error_data_;
- if(is_manhattan()) {
- //convert each into polygon_90_set data and call boolean operations
- polygon_90_set_data<Unit> l90sd(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);
- }
- l90sd.sort();
- if(op == 0) {
- l90sd.clean();
- } else if (op == 1) {
- l90sd.self_intersect();
- } else if (op == 3) {
- l90sd.self_xor();
- }
- result.data_.clear();
- result.insert(l90sd);
- result.is_manhattan_ = true;
- result.dirty_ = false;
- result.unsorted_ = false;
- } else {
- sort();
- try {
- result.is_manhattan_ = applyUnary45OpOnVectors<Unit, op>(result.data_, data_);
- } catch (std::string str) {
- std::string msg = "GTL 45 Boolean error, precision insufficient to represent edge intersection coordinate value.";
- if(str == msg) {
- result.clear();
- typedef typename coordinate_traits<Unit>::manhattan_area_type Unit2;
- typedef typename polygon_45_formation<Unit2>::Vertex45Compact Vertex45Compact2;
- typedef std::vector<Vertex45Compact2> Data2;
- Data2 lvalue_data, result_data;
- lvalue_data.reserve(data_.size());
- for(unsigned int i = 0 ; i < data_.size(); ++i) {
- const Vertex45Compact& vi = data_[i];
- Vertex45Compact2 ci;
- ci.pt = point_data<Unit2>(x(vi.pt), y(vi.pt));
- ci.count = typename polygon_45_formation<Unit2>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- lvalue_data.push_back(ci);
- }
- scale_up_vertex_45_compact_range(lvalue_data.begin(), lvalue_data.end(), 2);
- bool result_is_manhattan = applyUnary45OpOnVectors<Unit2, op>(result_data,
- lvalue_data );
- if(!result_is_manhattan) {
- typename polygon_45_formation<Unit2>::Polygon45Formation pf(false);
- //std::cout << "FORMING POLYGONS\n";
- std::vector<polygon_45_with_holes_data<Unit2> > container;
- pf.scan(container, result_data.begin(), result_data.end());
- Data2 error_data_out;
- std::vector<rectangle_data<Unit2> > pos_error_rects;
- std::vector<rectangle_data<Unit2> > neg_error_rects;
- for(unsigned int i = 0; i < container.size(); ++i) {
- get_error_rects(pos_error_rects, neg_error_rects, container[i]);
- }
- for(unsigned int i = 0; i < pos_error_rects.size(); ++i) {
- insert_rectangle_into_vector_45(result_data, pos_error_rects[i], false);
- insert_rectangle_into_vector_45(error_data_out, pos_error_rects[i], false);
- }
- for(unsigned int i = 0; i < neg_error_rects.size(); ++i) {
- insert_rectangle_into_vector_45(result_data, neg_error_rects[i], true);
- insert_rectangle_into_vector_45(error_data_out, neg_error_rects[i], false);
- }
- scale_down_vertex_45_compact_range_blindly(error_data_out.begin(), error_data_out.end(), 2);
- for(unsigned int i = 0 ; i < error_data_out.size(); ++i) {
- const Vertex45Compact2& vi = error_data_out[i];
- Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
- ci.count = typename polygon_45_formation<Unit>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- result.error_data_.push_back(ci);
- }
- Data2 new_result_data;
- std::sort(result_data.begin(), result_data.end());
- applyUnary45OpOnVectors<Unit2, 0>(new_result_data, result_data); //OR operation
- result_data.swap(new_result_data);
- }
- scale_down_vertex_45_compact_range_blindly(result_data.begin(), result_data.end(), 2);
- //result.data_.reserve(result_data.size());
- for(unsigned int i = 0 ; i < result_data.size(); ++i) {
- const Vertex45Compact2& vi = result_data[i];
- Vertex45Compact ci;
- ci.pt = (point_data<Unit2>(x(vi.pt), y(vi.pt)));
- ci.count = typename polygon_45_formation<Unit>::Vertex45Count
- ( vi.count[0], vi.count[1], vi.count[2], vi.count[3]);
- result.data_.push_back(ci);
- }
- result.is_manhattan_ = result_is_manhattan;
- result.dirty_ = false;
- result.unsorted_ = false;
- } else { throw str; }
- }
- //std::cout << "DONE SCANNING\n";
- }
- data_.swap(result.data_);
- error_data_.swap(result.error_data_);
- dirty_ = result.dirty_;
- unsorted_ = result.unsorted_;
- is_manhattan_ = result.is_manhattan_;
- }
-
- 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
-

Deleted: sandbox/gtl/polygon_45_set_traits.hpp
==============================================================================
--- sandbox/gtl/polygon_45_set_traits.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,136 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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
-

Deleted: sandbox/gtl/polygon_45_set_view.hpp
==============================================================================
--- sandbox/gtl/polygon_45_set_view.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,341 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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 value_type, typename ltype, typename rtype, int op_type>
- struct compute_45_set_value {
- static
- void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_) {
- output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
- polygon_45_set_traits<ltype>::end(lvalue_));
- value_type rinput_;
- 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_;
- }
- };
-
- template <typename value_type, typename ltype, typename rcoord, int op_type>
- struct compute_45_set_value<value_type, ltype, polygon_45_set_data<rcoord>, op_type> {
- static
- void value(value_type& output_, const ltype& lvalue_, const polygon_45_set_data<rcoord>& rvalue_) {
- output_.set(polygon_45_set_traits<ltype>::begin(lvalue_),
- polygon_45_set_traits<ltype>::end(lvalue_));
- if(op_type == 0)
- output_ |= rvalue_;
- else if(op_type == 1)
- output_ &= rvalue_;
- else if(op_type == 2)
- output_ ^= rvalue_;
- else
- output_ -= rvalue_;
- }
- };
-
- 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), output_(), evaluated_(false) {}
-
- // get iterator to begin vertex data
- public:
- const value_type& value() const {
- if(!evaluated_) {
- evaluated_ = true;
- compute_45_set_value<value_type, ltype, rtype, op_type>::value(output_, lvalue_, rvalue_);
- }
- 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_1< typename gtl_and_3<
- typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
- typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
- 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_1< typename gtl_and_3< typename is_polygon_45_or_90_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_polygon_45_or_90_set_type<geometry_type_2>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>
-#ifdef __ICC
- ::type
-#endif
- ::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_1< typename gtl_and_3< typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
- typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
- 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_1< typename gtl_and_3< typename is_polygon_45_or_90_set_type<geometry_type_1>::type,
- typename is_polygon_45_or_90_set_type<geometry_type_2>::type,
- 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_1< typename gtl_and_3< typename is_polygon_45_or_90_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_polygon_45_or_90_set_type<geometry_type_2>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>
-#ifdef __ICC
- ::type
-#endif
- ::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_1< typename gtl_and< typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and<
- typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- 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_1<
- typename gtl_and< typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_45_set_type<geometry_type_1>::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
- coordinate_concept>::type>::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_1< typename gtl_and< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
- coordinate_concept>::type>::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_1< typename gtl_and< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
- coordinate_concept>::type>
-#ifdef __ICC
- ::type
-#endif
- ::type, geometry_type_1>::type
- operator+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
- geometry_type_1 retval(lvalue);
- retval += rvalue;
- return retval;
- }
-
- template <typename geometry_type_1, typename coordinate_type_1>
- typename requires_1< typename gtl_and< typename gtl_if<typename is_mutable_polygon_45_set_type<geometry_type_1>::type>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type,
- coordinate_concept>::type>
-#ifdef __ICC
- ::type
-#endif
- ::type, geometry_type_1>::type
- operator-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
- geometry_type_1 retval(lvalue);
- retval -= rvalue;
- return retval;
- }
-}
-#endif
-

Deleted: sandbox/gtl/polygon_45_touch.hpp
==============================================================================
--- sandbox/gtl/polygon_45_touch.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,275 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_45_TOUCH_HPP
-#define GTL_POLYGON_45_TOUCH_HPP
-namespace gtl {
-
- template <typename Unit>
- struct polygon_45_touch {
-
- typedef point_data<Unit> Point;
- typedef typename coordinate_traits<Unit>::manhattan_area_type LongUnit;
-
- template <typename property_map>
- 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]);
- if(subtract) newmp.back().second *= -1;
- ++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]);
- if(subtract) newmp.back().second *= -1;
- ++j;
- }
- mp.swap(newmp);
- }
-
- class CountTouch {
- public:
- inline CountTouch() : counts() {}
- //inline CountTouch(int count) { counts[0] = counts[1] = count; }
- //inline CountTouch(int count1, int count2) { counts[0] = count1; counts[1] = count2; }
- inline CountTouch(const CountTouch& count) : counts(count.counts) {}
- inline bool operator==(const CountTouch& count) const { return counts == count.counts; }
- inline bool operator!=(const CountTouch& count) const { return !((*this) == count); }
- //inline CountTouch& operator=(int count) { counts[0] = counts[1] = count; return *this; }
- inline CountTouch& operator=(const CountTouch& count) { counts = count.counts; return *this; }
- inline int& operator[](int index) {
- std::vector<std::pair<int, int> >::iterator itr = lower_bound(counts.begin(), counts.end(), std::make_pair(index, int(0)));
- if(itr != counts.end() && itr->first == index) {
- return itr->second;
- }
- itr = counts.insert(itr, std::make_pair(index, int(0)));
- return itr->second;
- }
-// inline int operator[](int index) const {
-// std::vector<std::pair<int, int> >::const_iterator itr = counts.begin();
-// for( ; itr != counts.end() && itr->first <= index; ++itr) {
-// if(itr->first == index) {
-// return itr->second;
-// }
-// }
-// return 0;
-// }
- inline CountTouch& operator+=(const CountTouch& count){
- merge_property_maps(counts, count.counts, false);
- return *this;
- }
- inline CountTouch& operator-=(const CountTouch& count){
- merge_property_maps(counts, count.counts, true);
- return *this;
- }
- inline CountTouch operator+(const CountTouch& count) const {
- return CountTouch(*this)+=count;
- }
- inline CountTouch operator-(const CountTouch& count) const {
- return CountTouch(*this)-=count;
- }
- inline CountTouch invert() const {
- CountTouch retval;
- retval -= *this;
- return retval;
- }
- std::vector<std::pair<int, int> > counts;
- };
-
- typedef std::pair<std::pair<Unit, std::map<Unit, std::set<int> > >, std::map<int, std::set<int> > > map_graph_o;
- typedef std::pair<std::pair<Unit, std::map<Unit, std::set<int> > >, std::vector<std::set<int> > > vector_graph_o;
-
- template <typename cT>
- static void process_previous_x(cT& output) {
- std::map<Unit, std::set<int> >& y_prop_map = output.first.second;
- for(typename std::map<Unit, std::set<int> >::iterator itr = y_prop_map.begin();
- itr != y_prop_map.end(); ++itr) {
- for(std::set<int>::iterator inner_itr = itr->second.begin();
- inner_itr != itr->second.end(); ++inner_itr) {
- std::set<int>& output_edges = (*(output.second))[*inner_itr];
- std::set<int>::iterator inner_inner_itr = inner_itr;
- ++inner_inner_itr;
- for( ; inner_inner_itr != itr->second.end(); ++inner_inner_itr) {
- output_edges.insert(output_edges.end(), *inner_inner_itr);
- std::set<int>& output_edges_2 = (*(output.second))[*inner_inner_itr];
- output_edges_2.insert(output_edges_2.end(), *inner_itr);
- }
- }
- }
- y_prop_map.clear();
- }
-
- struct touch_45_output_functor {
- template <typename cT>
- void operator()(cT& output, const CountTouch& count1, const CountTouch& count2,
- const Point& pt, int rise, direction_1d end) {
- Unit& x = output.first.first;
- std::map<Unit, std::set<int> >& y_prop_map = output.first.second;
- if(pt.x() != x) process_previous_x(output);
- x = pt.x();
- std::set<int>& output_set = y_prop_map[pt.y()];
- for(std::vector<std::pair<int, int> >::const_iterator itr1 = count1.counts.begin();
- itr1 != count1.counts.end(); ++itr1) {
- if(itr1->second > 0) {
- output_set.insert(output_set.end(), itr1->first);
- }
- }
- for(std::vector<std::pair<int, int> >::const_iterator itr2 = count2.counts.begin();
- itr2 != count2.counts.end(); ++itr2) {
- if(itr2->second > 0) {
- output_set.insert(output_set.end(), itr2->first);
- }
- }
- }
- };
- typedef typename std::pair<Point,
- typename boolean_op_45<Unit>::template Scan45CountT<CountTouch> > Vertex45Compact;
- typedef std::vector<Vertex45Compact> TouchSetData;
-
- struct lessVertex45Compact {
- bool operator()(const Vertex45Compact& l, const Vertex45Compact& r) {
- return l.first < r.first;
- }
- };
-
- template <typename TSD>
- static void print_tsd(TSD& tsd) {
- for(unsigned int i = 0; i < tsd.size(); ++i) {
- std::cout << tsd[i].first << ": ";
- for(unsigned int r = 0; r < 4; ++r) {
- std::cout << r << " { ";
- for(std::vector<std::pair<int, int> >::iterator itr = tsd[i].second[r].counts.begin();
- itr != tsd[i].second[r].counts.end(); ++itr) {
- std::cout << itr->first << "," << itr->second << " ";
- } std::cout << "} ";
- }
- } std::cout << std::endl;
- }
-
- template <typename T>
- static void print_scanline(T& t) {
- for(typename T::iterator itr = t.begin(); itr != t.end(); ++itr) {
- std::cout << itr->x << "," << itr->y << " " << itr->rise << " ";
- for(std::vector<std::pair<int, int> >::iterator itr2 = itr->count.counts.begin();
- itr2 != itr->count.counts.end(); ++itr2) {
- std::cout << itr2->first << ":" << itr2->second << " ";
- } std::cout << std::endl;
- }
- }
-
- template <typename graph_type>
- static void performTouch(graph_type& graph, TouchSetData& tsd) {
-
- std::sort(tsd.begin(), tsd.end(), lessVertex45Compact());
- typedef std::vector<std::pair<Point, typename boolean_op_45<Unit>::template Scan45CountT<CountTouch> > > TSD;
- TSD tsd_;
- tsd_.reserve(tsd.size());
- for(typename TouchSetData::iterator itr = tsd.begin(); itr != tsd.end(); ) {
- typename TouchSetData::iterator itr2 = itr;
- ++itr2;
- for(; itr2 != tsd.end() && itr2->first == itr->first; ++itr2) {
- (itr->second) += (itr2->second); //accumulate
- }
- tsd_.push_back(std::make_pair(itr->first, itr->second));
- itr = itr2;
- }
- std::pair<std::pair<Unit, std::map<Unit, std::set<int> > >, graph_type*> output
- (std::make_pair(std::make_pair(std::numeric_limits<Unit>::max(), std::map<Unit, std::set<int> >()), &graph));
- typename boolean_op_45<Unit>::template Scan45<CountTouch, touch_45_output_functor> scanline;
- for(typename TSD::iterator itr = tsd_.begin(); itr != tsd_.end(); ) {
- typename TSD::iterator itr2 = itr;
- ++itr2;
- while(itr2 != tsd_.end() && itr2->first.x() == itr->first.x()) {
- ++itr2;
- }
- scanline.scan(output, itr, itr2);
- itr = itr2;
- }
- process_previous_x(output);
- }
-
- template <typename iT>
- static void populateTouchSetData(TouchSetData& tsd, iT begin, iT end, int nodeCount) {
- for( ; begin != end; ++begin) {
- Vertex45Compact vertex;
- vertex.first = typename Vertex45Compact::first_type(begin->pt.x() * 2, begin->pt.y() * 2);
- tsd.push_back(vertex);
- for(unsigned int i = 0; i < 4; ++i) {
- if(begin->count[i]) {
- tsd.back().second[i][nodeCount] += begin->count[i];
- }
- }
- }
- }
-
- };
-
- //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_45 {
- private:
- typedef typename coordinate_traits<coordinate_type>::manhattan_area_type big_coord;
- typedef typename polygon_45_touch<big_coord>::TouchSetData tsd;
- tsd tsd_;
- unsigned int nodeCount_;
- public:
- inline connectivity_extraction_45() : tsd_(), nodeCount_(0) {}
- inline connectivity_extraction_45(const connectivity_extraction_45& that) : tsd_(that.tsd_),
- nodeCount_(that.nodeCount_) {}
- inline connectivity_extraction_45& operator=(const connectivity_extraction_45& 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_45_set_data<coordinate_type>& ps) {
- ps.clean();
- polygon_45_touch<big_coord>::populateTouchSetData(tsd_, ps.begin(), ps.end(), nodeCount_);
- return nodeCount_++;
- }
- template <class GeoObjT>
- inline unsigned int insert(const GeoObjT& geoObj) {
- polygon_45_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) {
- polygon_45_touch<big_coord>::performTouch(graph, tsd_);
- }
- };
-
-}
-#endif

Deleted: sandbox/gtl/polygon_45_with_holes_data.hpp
==============================================================================
--- sandbox/gtl/polygon_45_with_holes_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,101 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_45_WITH_HOLES_DATA_HPP
-#define GTL_POLYGON_45_WITH_HOLES_DATA_HPP
-namespace gtl {
-struct polygon_45_with_holes_concept;
-template <typename T>
-class polygon_45_with_holes_data {
-public:
- typedef polygon_45_with_holes_concept geometry_type;
- typedef T coordinate_type;
- typedef typename polygon_45_data<T>::iterator_type 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() : self_(), holes_() {} //do nothing default constructor
-
- template<class iT>
- inline polygon_45_with_holes_data(iT input_begin, iT input_end) : self_(), holes_() {
- 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) : self_(), holes_() {
- set(input_begin, input_end);
- set_holes(holes_begin, holes_end);
- }
-
- template<class iT>
- inline polygon_45_with_holes_data& set(iT input_begin, iT input_end) {
- self_.set(input_begin, input_end);
- 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 polygon_45_with_holes_data& set_holes(iT input_begin, iT input_end) {
- holes_.clear(); //just in case there was some old data there
- for( ; input_begin != input_end; ++ input_begin) {
- holes_.push_back(hole_type());
- holes_.back().set((*input_begin).begin(), (*input_begin).end());
- }
- return *this;
- }
-
- // copy constructor (since we have dynamic memory)
- inline polygon_45_with_holes_data(const polygon_45_with_holes_data& that) : self_(that.self_),
- holes_(that.holes_) {}
-
- // assignment operator (since we have dynamic memory do a deep copy)
- inline polygon_45_with_holes_data& operator=(const polygon_45_with_holes_data& that) {
- self_ = that.self_;
- holes_ = that.holes_;
- return *this;
- }
-
- // get begin iterator, returns a pointer to a const coordinate_type
- inline const iterator_type begin() const {
- return self_.begin();
- }
-
- // get end iterator, returns a pointer to a const coordinate_type
- inline const iterator_type end() const {
- return self_.end();
- }
-
- inline unsigned int size() const {
- return self_.size();
- }
-
- // get begin iterator, returns a pointer to a const polygon
- inline const iterator_holes_type begin_holes() const {
- return holes_.begin();
- }
-
- // get end iterator, returns a pointer to a const polygon
- inline const iterator_holes_type end_holes() const {
- return holes_.end();
- }
-
- inline unsigned int size_holes() const {
- return holes_.size();
- }
-
-private:
- polygon_45_data<coordinate_type> self_;
- std::list<hole_type> holes_;
-};
-
-}
-#endif
-

Deleted: sandbox/gtl/polygon_90_data.hpp
==============================================================================
--- sandbox/gtl/polygon_90_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,132 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_90_DATA_HPP
-#define GTL_POLYGON_90_DATA_HPP
-namespace gtl {
-struct polygon_90_concept;
-template <typename T>
-class polygon_90_data {
-public:
- typedef polygon_90_concept geometry_type;
- 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() : coords_() {} //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 polygon_90_data& set(iT begin_point, iT end_point) {
- return set_compact(iterator_points_to_compact<iT, typename std::iterator_traits<iT>::value_type>(begin_point, end_point),
- iterator_points_to_compact<iT, typename std::iterator_traits<iT>::value_type>(end_point, end_point));
- }
-
- template<class iT>
- inline polygon_90_data& set_compact(iT input_begin, iT input_end) {
- coords_.clear(); //just in case there was some old data there
- while(input_begin != input_end) {
- coords_.insert(coords_.end(), *input_begin);
- ++input_begin;
- }
- return *this;
- }
-
- // copy constructor (since we have dynamic memory)
- inline polygon_90_data(const polygon_90_data& that) : coords_(that.coords_) {}
-
- // assignment operator (since we have dynamic memory do a deep copy)
- inline polygon_90_data& operator=(const polygon_90_data& that) {
- coords_ = that.coords_;
- return *this;
- }
-
- 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()); }
-
- // get end iterator, returns a pointer to a const Unit
- inline iterator_type end() const { return iterator_type(coords_.end(), coords_.end()); }
-
- // get begin iterator, returns a pointer to a const Unit
- inline compact_iterator_type begin_compact() const { return coords_.begin(); }
-
- // get end iterator, returns a pointer to a const Unit
- 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;
-}
-
-}
-
-#endif
-

Deleted: sandbox/gtl/polygon_90_set_concept.hpp
==============================================================================
--- sandbox/gtl/polygon_90_set_concept.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,541 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_90_SET_CONCEPT_HPP
-#define GTL_POLYGON_90_SET_CONCEPT_HPP
-namespace gtl {
-
- template <typename polygon_set_type>
- typename requires_1< typename is_polygon_90_set_type<polygon_set_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 is_polygon_90_set_type<polygon_set_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 is_polygon_90_set_type<polygon_set_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 is_polygon_90_set_type<polygon_set_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_1 <
- typename gtl_and<
- typename is_mutable_polygon_90_set_type<polygon_set_type_1>::type,
- 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 gtl_yes type; };
- template <>
- struct are_not_both_rectangle_concept<rectangle_concept, rectangle_concept> { typedef gtl_no type; };
-
- //equivalence
- template <typename polygon_set_type_1, typename polygon_set_type_2>
- typename requires_1< typename gtl_and_3<
- typename is_polygon_90_set_type<polygon_set_type_1>::type,
- typename is_polygon_90_set_type<polygon_set_type_2>::type,
- typename are_not_both_rectangle_concept<typename geometry_concept<polygon_set_type_1>::type,
- typename geometry_concept<polygon_set_type_2>::type>::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 rectangle tiles (slicing orientation is vertical)
- template <typename output_container_type, typename polygon_set_type>
- typename requires_1< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
- void>::type
- get_rectangles(output_container_type& output, const polygon_set_type& polygon_set) {
- clean(polygon_set);
- polygon_90_set_data<typename polygon_90_set_traits<polygon_set_type>::coordinate_type> ps(VERTICAL);
- assign(ps, polygon_set);
- ps.get_rectangles(output);
- }
-
- //get rectangle tiles
- template <typename output_container_type, typename polygon_set_type>
- typename requires_1< typename gtl_if<typename is_polygon_90_set_type<polygon_set_type>::type>::type,
- void>::type
- get_rectangles(output_container_type& output, const polygon_set_type& polygon_set, orientation_2d slicing_orientation) {
- clean(polygon_set);
- polygon_90_set_data<typename polygon_90_set_traits<polygon_set_type>::coordinate_type> ps;
- assign(ps, polygon_set);
- ps.get_rectangles(output, slicing_orientation);
- }
-
- //get: min_rectangles max_rectangles
- template <typename output_container_type, typename polygon_set_type>
- typename requires_1 <typename gtl_and<
- typename is_polygon_90_set_type<polygon_set_type>::type,
- typename gtl_same_type<rectangle_concept,
- typename geometry_concept
- <typename std::iterator_traits
- <typename output_container_type::iterator>::value_type>::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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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_1 <typename gtl_and< typename is_mutable_polygon_90_set_type<polygon_set_type>::type,
- typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::type>::type>::type,
- bool>::type
- extents(rectangle_type& extents_rectangle,
- const 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);
- return ps.extents(extents_rectangle);
- }
-
- //area
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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_1 <typename gtl_and< typename is_mutable_polygon_90_set_type<polygon_set_type_1>::type,
- 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;
- polygon_90_set_data<Unit> ps(scanline_orientation(polygon_set_2));
- polygon_90_set_data<Unit> ps2(ps);
- ps.insert(polygon_set_1);
- ps2.insert(polygon_set_2);
- ps.interact(ps2);
- assign(polygon_set_1, ps);
- return polygon_set_1;
- }
-
- //self_intersect
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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);
- ps.self_intersect();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- //self_xor
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_type>::type,
- polygon_set_type>::type &
- self_xor(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);
- ps.self_xor();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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;
- polygon_90_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.bloat(west_bloating, east_bloating, south_bloating, north_bloating);
- ps.clean();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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.shrink(west_shrinking, east_shrinking, south_shrinking, north_shrinking);
- ps.clean();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- template <typename polygon_set_type, typename coord_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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;
- }
-
- //positive or negative values allow for any and all directions of sizing
- template <typename polygon_set_type, typename coord_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_type>::type,
- polygon_set_type>::type &
- resize(polygon_set_type& polygon_set, coord_type west, coord_type east, coord_type south, coord_type north) {
- typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
- polygon_90_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.resize(west, east, south, north);
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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 is_mutable_polygon_90_set_type<polygon_set_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;
- polygon_90_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 is_mutable_polygon_90_set_type<polygon_set_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;
- polygon_90_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.scale_down(factor);
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- template <typename polygon_set_type, typename scaling_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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;
- polygon_90_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.scale(scaling);
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- //move
- template <typename polygon_set_type, typename coord_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_type>::type,
- polygon_set_type>::type &
- move(polygon_set_type& polygon_set,
- orientation_2d orient, coord_type displacement) {
- if(orient == HORIZONTAL)
- return move(polygon_set, displacement, 0);
- else
- return move(polygon_set, 0, displacement);
- }
-
- template <typename polygon_set_type, typename coord_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_type>::type,
- polygon_set_type>::type &
- move(polygon_set_type& polygon_set, coord_type x_displacement, coord_type y_displacement) {
- typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
- polygon_90_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.move(x_displacement, y_displacement);
- ps.clean();
- assign(polygon_set, ps);
- return polygon_set;
- }
-
- //transform
- template <typename polygon_set_type, typename transformation_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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;
- polygon_90_set_data<Unit> ps;
- assign(ps, polygon_set);
- ps.transform(transformation);
- ps.clean();
- assign(polygon_set, ps);
- return polygon_set;
- typedef typename polygon_90_set_traits<polygon_set_type>::coordinate_type Unit;
- }
-
- //keep
- template <typename polygon_set_type>
- typename requires_1< typename is_mutable_polygon_90_set_type<polygon_set_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

Deleted: sandbox/gtl/polygon_90_set_data.hpp
==============================================================================
--- sandbox/gtl/polygon_90_set_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,610 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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), data_(), dirty_(false), unsorted_(false) {}
-
- // constructor
- inline polygon_90_set_data(orientation_2d orient) : orient_(orient), data_(), 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) :
- orient_(HORIZONTAL), data_(), dirty_(false), unsorted_(false) {
- 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_) {}
-
- template <typename ltype, typename rtype, typename op_type>
- inline polygon_90_set_data(const polygon_90_set_view<ltype, rtype, op_type>& that);
-
- // copy with orientation change constructor
- inline polygon_90_set_data(orientation_2d orient, const polygon_90_set_data& that) :
- data_(), 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
- inline void insert(iterator_type input_begin, iterator_type input_end, orientation_2d orient = HORIZONTAL) {
- if(input_begin == input_end || input_begin == data_.begin()) return;
- dirty_ = true;
- unsorted_ = true;
- if(orient == orient_)
- data_.insert(data_.end(), input_begin, input_end);
- else {
- for( ; input_begin != input_end; ++input_begin) {
- insert(*input_begin, false, orient);
- }
- }
- }
-
- // insert iterator range
- template <typename iT>
- inline void insert(iT input_begin, iT input_end, orientation_2d orient = HORIZONTAL) {
- 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());
- }
-
- inline void insert(const std::pair<std::pair<point_data<coordinate_type>, point_data<coordinate_type> >, int>& edge, bool is_hole = false,
- orientation_2d orient = HORIZONTAL) {
- std::pair<coordinate_type, std::pair<coordinate_type, int> > vertex;
- vertex.first = edge.first.first.x();
- vertex.second.first = edge.first.first.y();
- vertex.second.second = edge.second * (is_hole ? -1 : 1);
- insert(vertex, false, VERTICAL);
- vertex.first = edge.first.second.x();
- vertex.second.first = edge.first.second.y();
- vertex.second.second *= -1;
- insert(vertex, false, VERTICAL);
- }
-
- 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());
- }
-
- template <typename output_container>
- inline void get_polygons(output_container& output) const {
- get_dispatch(output, polygon_90_concept());
- }
-
- template <typename output_container>
- inline void get_rectangles(output_container& output) const {
- clean();
- form_rectangles(output, data_.begin(), data_.end(), orient_, rectangle_concept());
- }
-
- template <typename output_container>
- inline void get_rectangles(output_container& output, orientation_2d slicing_orientation) const {
- if(slicing_orientation == orient_) {
- get_rectangles(output);
- } else {
- polygon_90_set_data<coordinate_type> ps(*this);
- ps.transform(axis_transformation(axis_transformation::SWAP_XY));
- output_container result;
- ps.get_rectangles(result);
- for(typename output_container::iterator itr = result.begin(); itr != result.end(); ++itr) {
- ::gtl::transform(*itr, axis_transformation(axis_transformation::SWAP_XY));
- }
- output.insert(output.end(), result.begin(), result.end());
- }
- }
-
- // 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::default_arg_workaround<int>::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;
- }
-
- //extents
- template <typename rectangle_type>
- bool
- extents(rectangle_type& extents_rectangle) const {
- clean();
- if(data_.empty()) return false;
- if(orient_ == HORIZONTAL)
- set_points(extents_rectangle, point_data<coordinate_type>(data_[0].second.first, data_[0].first),
- point_data<coordinate_type>(data_[data_.size() - 1].second.first, data_[data_.size() - 1].first));
- else
- set_points(extents_rectangle, point_data<coordinate_type>(data_[0].first, data_[0].second.first),
- point_data<coordinate_type>(data_[data_.size() - 1].first, data_[data_.size() - 1].second.first));
- for(unsigned int i = 1; i < data_.size() - 1; ++i) {
- if(orient_ == HORIZONTAL)
- encompass(extents_rectangle, point_data<coordinate_type>(data_[i].second.first, data_[i].first));
- else
- encompass(extents_rectangle, point_data<coordinate_type>(data_[i].first, data_[i].second.first));
- }
- return true;
- }
-
- polygon_90_set_data&
- bloat(typename coordinate_traits<coordinate_type>::unsigned_area_type west_bloating,
- typename coordinate_traits<coordinate_type>::unsigned_area_type east_bloating,
- typename coordinate_traits<coordinate_type>::unsigned_area_type south_bloating,
- typename coordinate_traits<coordinate_type>::unsigned_area_type north_bloating) {
- std::vector<rectangle_data<coordinate_type> > rects;
- get(rects);
- rectangle_data<coordinate_type> convolutionRectangle(interval_data<coordinate_type>(-((coordinate_type)west_bloating),
- (coordinate_type)east_bloating),
- interval_data<coordinate_type>(-((coordinate_type)south_bloating),
- (coordinate_type)north_bloating));
- for(typename std::vector<rectangle_data<coordinate_type> >::iterator itr = rects.begin();
- itr != rects.end(); ++itr) {
- convolve(*itr, convolutionRectangle);
- }
- clear();
- insert(rects.begin(), rects.end());
- return *this;
- }
-
- polygon_90_set_data&
- shrink(typename coordinate_traits<coordinate_type>::unsigned_area_type west_shrinking,
- typename coordinate_traits<coordinate_type>::unsigned_area_type east_shrinking,
- typename coordinate_traits<coordinate_type>::unsigned_area_type south_shrinking,
- typename coordinate_traits<coordinate_type>::unsigned_area_type north_shrinking) {
- rectangle_data<coordinate_type> externalBoundary;
- if(!extents(externalBoundary)) return *this;
- ::gtl::bloat(externalBoundary, 10); //bloat by diferential ammount
- //insert a hole that encompasses the data
- insert(externalBoundary, true); //note that the set is in a dirty state now
- sort(); //does not apply implicit OR operation
- std::vector<rectangle_data<coordinate_type> > rects;
- //begin does not apply implicit or operation, this is a dirty range
- form_rectangles(rects, data_.begin(), data_.end(), orient_, rectangle_concept());
- clear();
- rectangle_data<coordinate_type> convolutionRectangle(interval_data<coordinate_type>(-((coordinate_type)east_shrinking),
- (coordinate_type)west_shrinking),
- interval_data<coordinate_type>(-((coordinate_type)north_shrinking),
- (coordinate_type)south_shrinking));
- for(typename std::vector<rectangle_data<coordinate_type> >::iterator itr = rects.begin();
- itr != rects.end(); ++itr) {
- rectangle_data<coordinate_type>& rect = *itr;
- convolve(rect, convolutionRectangle);
- //insert rectangle as a hole
- insert(rect, true);
- }
- convolve(externalBoundary, convolutionRectangle);
- //insert duplicate of external boundary as solid to cancel out the external hole boundaries
- insert(externalBoundary);
- clean(); //we have negative values in the set, so we need to apply an OR operation to make it valid input to a boolean
- return *this;
- }
-
- polygon_90_set_data&
- resize(coordinate_type west, coordinate_type east, coordinate_type south, coordinate_type north);
-
- polygon_90_set_data& move(coordinate_type x_delta, coordinate_type y_delta) {
- for(typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::iterator
- itr = data_.begin(); itr != data_.end(); ++itr) {
- if(orient_ == orientation_2d(VERTICAL)) {
- (*itr).first += x_delta;
- (*itr).second.first += y_delta;
- } else {
- (*itr).second.first += x_delta;
- (*itr).first += y_delta;
- }
- }
- return *this;
- }
-
- // transform set
- template <typename transformation_type>
- polygon_90_set_data& transform(const transformation_type& transformation) {
- direction_2d dir1, dir2;
- transformation.get_directions(dir1, dir2);
- int sign = dir1.get_sign() * dir2.get_sign();
- for(typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::iterator
- itr = data_.begin(); itr != data_.end(); ++itr) {
- if(orient_ == orientation_2d(VERTICAL)) {
- transformation.transform((*itr).first, (*itr).second.first);
- } else {
- transformation.transform((*itr).second.first, (*itr).first);
- }
- (*itr).second.second *= sign;
- }
- if(dir1 != EAST || dir2 != NORTH)
- unsorted_ = true; //some mirroring or rotation must have happened
- return *this;
- }
-
- // scale set
- polygon_90_set_data& scale_up(typename coordinate_traits<coordinate_type>::unsigned_area_type factor) {
- for(typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::iterator
- itr = data_.begin(); itr != data_.end(); ++itr) {
- (*itr).first *= (coordinate_type)factor;
- (*itr).second.first *= (coordinate_type)factor;
- }
- return *this;
- }
- polygon_90_set_data& scale_down(typename coordinate_traits<coordinate_type>::unsigned_area_type factor) {
- typedef typename coordinate_traits<coordinate_type>::coordinate_distance dt;
- for(typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::iterator
- itr = data_.begin(); itr != data_.end(); ++itr) {
- (*itr).first = scaling_policy<coordinate_type>::round((dt)((*itr).first) / (dt)factor);
- (*itr).second.first = scaling_policy<coordinate_type>::round((dt)((*itr).second.first) / (dt)factor);
- }
- unsorted_ = true; //scaling down can make coordinates equal that were not previously equal
- return *this;
- }
- template <typename scaling_type>
- polygon_90_set_data& scale(const anisotropic_scale_factor<scaling_type>& scaling) {
- for(typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::iterator
- itr = data_.begin(); itr != data_.end(); ++itr) {
- if(orient_ == orientation_2d(VERTICAL)) {
- scaling.scale((*itr).first, (*itr).second.first);
- } else {
- scaling.scale((*itr).second.first, (*itr).first);
- }
- }
- unsorted_ = true;
- return *this;
- }
- polygon_90_set_data& scale(double factor) {
- typedef typename coordinate_traits<coordinate_type>::coordinate_distance dt;
- for(typename std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >::iterator
- itr = data_.begin(); itr != data_.end(); ++itr) {
- (*itr).first = scaling_policy<coordinate_type>::round((dt)((*itr).first) * (dt)factor);
- (*itr).second.first = scaling_policy<coordinate_type>::round((dt)((*itr).second.first) * (dt)factor);
- }
- unsorted_ = true; //scaling make coordinates equal that were not previously equal
- return *this;
- }
-
- polygon_90_set_data& self_xor() {
- sort();
- if(dirty_) { //if it is clean it is a no-op
- boolean_op::default_arg_workaround<boolean_op::UnaryCount>::applyBooleanOr(data_);
- dirty_ = false;
- }
- return *this;
- }
-
- polygon_90_set_data& self_intersect() {
- sort();
- if(dirty_) { //if it is clean it is a no-op
- interval_data<coordinate_type> ivl(std::numeric_limits<coordinate_type>::min(), std::numeric_limits<coordinate_type>::max());
- rectangle_data<coordinate_type> rect(ivl, ivl);
- insert(rect, true);
- clean();
- }
- return *this;
- }
-
- inline polygon_90_set_data& interact(const polygon_90_set_data& that) {
- typedef coordinate_type Unit;
- if(that.dirty_) that.clean();
- typename touch_90_operation<Unit>::TouchSetData tsd;
- touch_90_operation<Unit>::populateTouchSetData(tsd, that.data_, 0);
- std::vector<polygon_90_data<Unit> > polys;
- get(polys);
- 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(that.orient_);
- psTmp.insert(polys[i]);
- psTmp.clean();
- touch_90_operation<Unit>::populateTouchSetData(tsd, psTmp.data_, i+1);
- }
- touch_90_operation<Unit>::performTouch(graph, tsd);
- clear();
- for(std::set<int>::iterator itr = graph[0].begin(); itr != graph[0].end(); ++itr){
- insert(polys[(*itr)-1]);
- }
- dirty_ = false;
- return *this;
- }
-
-
- 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();
- form_rectangles(output, data_.begin(), data_.end(), orient_, rectangle_concept());
- }
- 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();
- ::gtl::get_polygons(container, data_.begin(), data_.end(), orient_, fracture_holes, tag);
- }
- };
-
- template <typename coordinate_type>
- polygon_90_set_data<coordinate_type>&
- polygon_90_set_data<coordinate_type>::resize(coordinate_type west,
- coordinate_type east,
- coordinate_type south,
- coordinate_type north) {
- move(-west, -south);
- coordinate_type e_total = west + east;
- coordinate_type n_total = south + north;
- if((e_total < 0) ^ (n_total < 0)) {
- //different signs
- if(e_total < 0) {
- shrink(0, -e_total, 0, 0);
- if(n_total != 0)
- return bloat(0, 0, 0, n_total);
- else
- return (*this);
- } else {
- shrink(0, 0, 0, -n_total); //shrink first
- if(e_total != 0)
- return bloat(0, e_total, 0, 0);
- else
- return (*this);
- }
- } else {
- if(e_total < 0) {
- return shrink(0, -e_total, 0, -n_total);
- }
- return bloat(0, e_total, 0, n_total);
- }
- }
-
- 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() : pmd_() {}
- 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_90 {
- private:
- typedef typename touch_90_operation<coordinate_type>::TouchSetData tsd;
- tsd tsd_;
- unsigned int nodeCount_;
- public:
- inline connectivity_extraction_90() : tsd_(), nodeCount_(0) {}
- inline connectivity_extraction_90(const connectivity_extraction_90& that) : tsd_(that.tsd_),
- nodeCount_(that.nodeCount_) {}
- inline connectivity_extraction_90& operator=(const connectivity_extraction_90& 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
-

Deleted: sandbox/gtl/polygon_90_set_traits.hpp
==============================================================================
--- sandbox/gtl/polygon_90_set_traits.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,353 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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) {
- form_rectangles(output, ps.begin(), ps.end(), orient, rectangle_concept());
- }
-
- 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 gtl_yes type; };
- template <>
- struct is_polygon_90_set_concept<rectangle_concept> { typedef gtl_yes type; };
- template <>
- struct is_polygon_90_set_concept<polygon_90_concept> { typedef gtl_yes type; };
- template <>
- struct is_polygon_90_set_concept<polygon_90_with_holes_concept> { typedef gtl_yes type; };
-
- template <typename T>
- struct is_mutable_polygon_90_set_concept { typedef gtl_no type; };
- template <>
- struct is_mutable_polygon_90_set_concept<polygon_90_set_concept> { typedef gtl_yes 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
-

Deleted: sandbox/gtl/polygon_90_set_view.hpp
==============================================================================
--- sandbox/gtl/polygon_90_set_view.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,438 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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 value_type, typename ltype, typename rtype, typename op_type>
- struct compute_90_set_value {
- static
- void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_, orientation_2d orient_) {
- 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>());
- }
- };
-
- template <typename value_type, typename lcoord, typename rcoord, typename op_type>
- struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, polygon_90_set_data<rcoord>, op_type> {
- static
- void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
- const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
- lvalue_.sort();
- rvalue_.sort();
- output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
- rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
- }
- };
-
- template <typename value_type, typename lcoord, typename rtype, typename op_type>
- struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, rtype, op_type> {
- static
- void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
- const rtype& rvalue_, orientation_2d orient_) {
- value_type rinput_(orient_);
- lvalue_.sort();
- insert_into_view_arg(rinput_, rvalue_, orient_);
- output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
- rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
- }
- };
-
- template <typename value_type, typename ltype, typename rcoord, typename op_type>
- struct compute_90_set_value<value_type, ltype, polygon_90_set_data<rcoord>, op_type> {
- static
- void value(value_type& output_, const ltype& lvalue_,
- const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
- value_type linput_(orient_);
- insert_into_view_arg(linput_, lvalue_, orient_);
- rvalue_.sort();
- output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
- rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
- }
- };
-
- 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;
- compute_90_set_value<value_type, ltype, rtype, op_type>::value(output_, lvalue_, rvalue_, orient_);
- }
- 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 T>
- template <typename ltype, typename rtype, typename op_type>
- inline polygon_90_set_data<T>::polygon_90_set_data(const polygon_90_set_view<ltype, rtype, op_type>& that) :
- orient_(that.orient()), data_(that.begin(), that.end()), dirty_(false), unsorted_(false) {}
-
- 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_1< typename gtl_and<
- typename is_polygon_90_set_type<geometry_type_1>::type,
- 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_1<
- typename gtl_and<
- typename is_polygon_90_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
- ::type,
- typename is_polygon_90_set_type<geometry_type_2>::type>
-#ifdef __ICC
- ::type
-#endif
- ::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_1< typename gtl_and<
- typename is_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_if<typename gtl_and<
- typename is_polygon_90_set_type<geometry_type_1>::type,
- typename is_polygon_90_set_type<geometry_type_2>::type>::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_1< typename gtl_and<
- typename is_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and<
- typename is_polygon_90_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
-::type,
- typename is_polygon_90_set_type<geometry_type_2>::type>
-#ifdef __ICC
- ::type
-#endif
-::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 is_polygon_90_set_type<geometry_type_2>::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 is_polygon_90_set_type<geometry_type_2>::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_1< typename gtl_and< typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and<
- typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>::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_1< typename gtl_and<
- typename is_mutable_polygon_90_set_type<geometry_type_1>::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>::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_1< typename gtl_and<
- typename is_mutable_polygon_90_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
-::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>
-#ifdef __ICC
- ::type
-#endif
- ::type,
- geometry_type_1>::type
- operator+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
- geometry_type_1 retval(lvalue);
- retval += rvalue;
- return retval;
- }
-
- template <typename geometry_type_1, typename coordinate_type_1>
- typename requires_1< typename gtl_and<
- typename is_mutable_polygon_90_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
-::type,
- typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>
-#ifdef __ICC
- ::type
-#endif
- ::type,
- geometry_type_1>::type
- operator-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
- geometry_type_1 retval(lvalue);
- retval -= rvalue;
- return retval;
- }
-
-}
-#endif
-

Deleted: sandbox/gtl/polygon_90_touch.hpp
==============================================================================
--- sandbox/gtl/polygon_90_touch.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,401 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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() : itr_(), ivlIds_() {}
- inline iterator(typename EventData::const_iterator itr,
- Unit prevPos, const std::set<int>& ivlIds) : itr_(itr), ivlIds_() {
- ivlIds_.second = ivlIds;
- ivlIds_.first = Interval(prevPos, itr->first);
- }
- inline iterator(const iterator& that) : itr_(), ivlIds_() { (*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() : eventData_() {}
- 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 () : scanData_(), nextItr_() { nextItr_ = scanData_.end(); }
- inline TouchOp (const TouchOp& that) : scanData_(that.scanData_), nextItr_() { 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

Deleted: sandbox/gtl/polygon_90_with_holes_data.hpp
==============================================================================
--- sandbox/gtl/polygon_90_with_holes_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,111 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_90_WITH_HOLES_DATA_HPP
-#define GTL_POLYGON_90_WITH_HOLES_DATA_HPP
-namespace gtl {
-struct polygon_90_with_holes_concept;
-template <typename T>
-class polygon_90_with_holes_data {
-public:
- typedef polygon_90_with_holes_concept geometry_type;
- typedef T coordinate_type;
- typedef typename polygon_90_data<T>::iterator_type iterator_type;
- 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() : self_(), holes_() {} //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 polygon_90_with_holes_data& set(iT input_begin, iT input_end) {
- self_.set(input_begin, input_end);
- 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 polygon_90_with_holes_data& set_compact(iT input_begin, iT input_end) {
- self_.set_compact(input_begin, input_end);
- 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 polygon_90_with_holes_data& set_holes(iT input_begin, iT input_end) {
- holes_.clear(); //just in case there was some old data there
- for( ; input_begin != input_end; ++ input_begin) {
- holes_.push_back(hole_type());
- holes_.back().set_compact((*input_begin).begin_compact(), (*input_begin).end_compact());
- }
- return *this;
- }
-
- // copy constructor (since we have dynamic memory)
- inline polygon_90_with_holes_data(const polygon_90_with_holes_data& that) : self_(that.self_),
- holes_(that.holes_) {}
-
- // assignment operator (since we have dynamic memory do a deep copy)
- inline polygon_90_with_holes_data& operator=(const polygon_90_with_holes_data& that) {
- self_ = that.self_;
- holes_ = that.holes_;
- return *this;
- }
-
- // get begin iterator, returns a pointer to a const coordinate_type
- inline const iterator_type begin() const {
- return self_.begin();
- }
-
- // get end iterator, returns a pointer to a const coordinate_type
- inline const iterator_type end() const {
- 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();
- }
-
- // get begin iterator, returns a pointer to a const polygon
- inline const iterator_holes_type begin_holes() const {
- return holes_.begin();
- }
-
- // get end iterator, returns a pointer to a const polygon
- inline const iterator_holes_type end_holes() const {
- return holes_.end();
- }
-
- inline unsigned int size_holes() const {
- return holes_.size();
- }
-
-private:
- polygon_90_data<coordinate_type> self_;
- std::list<hole_type> holes_;
-};
-
-}
-#endif
-

Deleted: sandbox/gtl/polygon_arbitrary_formation.hpp
==============================================================================
--- sandbox/gtl/polygon_arbitrary_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,1937 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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), justBefore_(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), justBefore_(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() : points() {} //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_(), otherTailp_(), holesList_(), head_() {
- tailp_ = new poly_line_arbitrary;
- tailp_->points.push_back(point);
- head_ = head;
- otherTailp_ = otherTailp;
-
- }
- inline active_tail_arbitrary(active_tail_arbitrary* otherTailp) :
- tailp_(), otherTailp_(), holesList_(), head_() {
- tailp_ = otherTailp->tailp_;
- otherTailp_ = otherTailp;
- }
-
- //copy constructor
- inline active_tail_arbitrary(const active_tail_arbitrary& that) :
- tailp_(), otherTailp_(), holesList_(), head_() { (*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() :
- scanData_(), 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) :
- scanData_(), 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) :
- scanData_(), x_(std::numeric_limits<Unit>::min()), justBefore_(false), fractureHoles_(0) { (*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);
- if(returnValue) returnCount.first = point;
- //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];
- tails[c_size_less_1] = 0;
- have_vertical_tail_from_below = false;
- }
- 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() : hole_(), itr_() {}
- inline iterator_holes_type(typename active_tail_arbitrary::iteratorHoles itr) : hole_(), itr_(itr) {}
- inline iterator_holes_type(const iterator_holes_type& that) : hole_(that.hole_), 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

Deleted: sandbox/gtl/polygon_data.hpp
==============================================================================
--- sandbox/gtl/polygon_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,22 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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;
- };
-
-
-
-}
-#endif
-

Deleted: sandbox/gtl/polygon_formation.hpp
==============================================================================
--- sandbox/gtl/polygon_formation.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,1807 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_FORMATION_HPP
-#define GTL_POLYGON_FORMATION_HPP
-namespace gtl {
-
-namespace polygon_formation {
-
- /*
- * End has two states, HEAD and TAIL as is represented by a bool
- */
- typedef bool End;
-
- /*
- * HEAD End is represented as false because it is the lesser state
- */
- const End HEAD = false;
-
- /*
- * TAIL End is represented by true because TAIL comes after head and 1 after 0
- */
- const End TAIL = true;
-
- /*
- * 2D turning direction, left and right sides (is a boolean value since it has two states.)
- */
- typedef bool Side;
-
- /*
- * LEFT Side is 0 because we inuitively think left to right; left < right
- */
- const Side LEFT = false;
-
- /*
- * RIGHT Side is 1 so that right > left
- */
- const Side RIGHT = true;
-
- /*
- * The PolyLine class is data storage and services for building and representing partial polygons.
- * As the polyline is added to it extends its storage to accomodate the data.
- * PolyLines can be joined head-to-head/head-to-tail when it is determined that two polylines are
- * part of the same polygon.
- * PolyLines keep state information about what orientation their incomplete head and tail geometry have,
- * which side of the polyline is solid and whether the polyline is joined head-to-head and tail-to-head.
- * PolyLines have nothing whatsoever to do with holes.
- * It may be valuable to collect a histogram of PolyLine lengths used by an algorithm on its typical data
- * sets and tune the allocation of the initial vector of coordinate data to be greater than or equal to
- * the mean, median, mode, or mean plus some number of standard deviation, or just generally large enough
- * to prevent too much unnecesary reallocations, but not too big that it wastes a lot of memory and degrades cache
- * performance.
- */
- template <typename Unit>
- class PolyLine {
- private:
- //data
-
- /*
- * ptdata_ a vector of coordiantes
- * if VERTICAL_HEAD, first coordiante is an X
- * else first coordinate is a Y
- */
- std::vector<Unit> ptdata_;
-
- /*
- * head and tail points to other polylines before and after this in a chain
- */
- PolyLine* headp_;
- PolyLine* tailp_;
-
- /*
- * state bitmask
- * bit zero is orientation, 0 H, 1 V
- * bit 1 is head connectivity, 0 for head, 1 for tail
- * bit 2 is tail connectivity, 0 for head, 1 for tail
- * bit 3 is solid to left of PolyLine when 1, right when 0
- */
- int state_;
-
- public:
- /*
- * default constructor (for preallocation)
- */
- PolyLine();
-
- /*
- * constructor that takes the orientation, coordiante and side to which there is solid
- */
- PolyLine(orientation_2d orient, Unit coord, Side side);
-
- //copy constructor
- PolyLine(const PolyLine& pline);
-
- //destructor
- ~PolyLine();
-
- //assignment operator
- PolyLine& operator=(const PolyLine& that);
-
- //equivalence operator
- bool operator==(const PolyLine& b) const;
-
- /*
- * valid PolyLine (only default constructed polylines are invalid.)
- */
- bool isValid() const;
-
- /*
- * Orientation of Head
- */
- orientation_2d headOrient() const;
-
- /*
- * returns true if first coordinate is an X value (first segment is vertical)
- */
- bool verticalHead() const;
-
- /*
- * returns the orientation_2d fo the tail
- */
- orientation_2d tailOrient() const;
-
- /*
- * returns true if last coordinate is an X value (last segment is vertical)
- */
- bool verticalTail() const;
-
- /*
- * retrun true if PolyLine has odd number of coordiantes
- */
- bool oddLength() const;
-
- /*
- * retrun the End of the other polyline that the specified end of this polyline is connected to
- */
- End endConnectivity(End end) const;
-
- /*
- * retrun true if the head of this polyline is connect to the tail of a polyline
- */
- bool headToTail() const;
- /*
- * retrun true if the head of this polyline is connect to the head of a polyline
- */
- bool headToHead() const;
-
- /*
- * retrun true if the tail of this polyline is connect to the tail of a polyline
- */
- bool tailToTail() const;
- /*
- * retrun true if the tail of this polyline is connect to the head of a polyline
- */
- bool tailToHead() const;
-
- /*
- * retrun the side on which there is solid for this polyline
- */
- Side solidSide() const;
-
- /*
- * retrun true if there is solid to the right of this polyline
- */
- bool solidToRight() const;
-
- /*
- * returns true if the polyline tail is not connected
- */
- bool active() const;
-
- /*
- * adds a coordinate value to the end of the polyline changing the tail orientation
- */
- PolyLine& pushCoordinate(Unit coord);
-
- /*
- * removes a coordinate value at the end of the polyline changing the tail orientation
- */
- PolyLine& popCoordinate();
-
- /*
- * extends the tail of the polyline to include the point, changing orientation if needed
- */
- PolyLine& pushPoint(const point_data<Unit>& point);
-
- /*
- * changes the last coordinate of the tail of the polyline by the amount of the delta
- */
- PolyLine& extendTail(Unit delta);
-
- /*
- * join thisEnd of this polyline to that polyline's end
- */
- PolyLine& joinTo(End thisEnd, PolyLine& that, End end);
-
- /*
- * join an end of this polyline to the tail of that polyline
- */
- PolyLine& joinToTail(PolyLine& that, End end);
-
- /*
- * join an end of this polyline to the head of that polyline
- */
- PolyLine& joinToHead(PolyLine& that, End end);
-
- /*
- * join the head of this polyline to the head of that polyline
- */
- //join this to that in the given way
- PolyLine& joinHeadToHead(PolyLine& that);
-
- /*
- * join the head of this polyline to the tail of that polyline
- */
- PolyLine& joinHeadToTail(PolyLine& that);
-
- /*
- * join the tail of this polyline to the head of that polyline
- */
- PolyLine& joinTailToHead(PolyLine& that);
-
- /*
- * join the tail of this polyline to the tail of that polyline
- */
- PolyLine& joinTailToTail(PolyLine& that);
-
- /*
- * dissconnect the tail at the end of the polygon
- */
- PolyLine& disconnectTails();
-
- /*
- * get the coordinate at one end of this polyline, by default the tail end
- */
- Unit getEndCoord(End end = TAIL) const;
-
- /*
- * get the point on the polyline at the given index (polylines have the same number of coordinates as points
- */
- point_data<Unit> getPoint(unsigned int index) const;
-
- /*
- * get the point on one end of the polyline, by default the tail
- */
- point_data<Unit> getEndPoint(End end = TAIL) const;
-
- /*
- * get the orientation of a segment by index
- */
- orientation_2d segmentOrient(unsigned int index = 0) const;
-
- /*
- * get a coordinate by index using the square bracket operator
- */
- Unit operator[] (unsigned int index) const;
-
- /*
- * get the number of segments/points/coordinates in the polyline
- */
- unsigned int numSegments() const;
-
- /*
- * get the pointer to the next polyline at one end of this
- */
- PolyLine* next(End end) const;
-
- /*
- * write out coordinates of this and all attached polylines to a single vector
- */
- PolyLine* writeOut(std::vector<Unit>& outVec, End startEnd = TAIL) const;
-
- private:
- //methods
- PolyLine& joinTo_(End thisEnd, PolyLine& that, End end);
- };
-
- //forward declaration
- template<bool orientT, typename Unit>
- class PolyLinePolygonData;
-
- //forward declaration
- template<bool orientT, typename Unit>
- class PolyLinePolygonWithHolesData;
-
- /*
- * ActiveTail represents an edge of an incomplete polygon.
- *
- * An ActiveTail object is the active tail end of a polyline object, which may (should) be the attached to
- * a chain of polyline objects through a pointer. The ActiveTail class provides an abstraction between
- * and algorithm that builds polygons and the PolyLine data representation of incomplete polygons that are
- * being built. It does this by providing an iterface to access the information about the last edge at the
- * tail of the PolyLine it is associated with. To a polygon constructing algorithm, an ActiveTail is a floating
- * edge of an incomplete polygon and has an orientation and coordinate value, as well as knowing which side of
- * that edge is supposed to be solid or space. Any incomplete polygon will have two active tails. Active tails
- * may be joined together to merge two incomplete polygons into a larger incomplete polygon. If two active tails
- * that are to be merged are the oppositve ends of the same incomplete polygon that indicates that the polygon
- * has been closed and is complete. The active tail keeps a pointer to the other active tail of its incomplete
- * polygon so that it is easy to check this condition. These pointers are updated when active tails are joined.
- * The active tail also keeps a list of pointers to active tail objects that serve as handles to closed holes. In
- * this way a hole can be associated to another incomplete polygon, which will eventually be its enclosing shell,
- * or reassociate the hole to another incomplete polygon in the case that it become a hole itself. Alternately,
- * the active tail may add a filiment to stitch a hole into a shell and "fracture" the hole out of the interior
- * of a polygon. The active tail maintains a static output buffer to temporarily write polygon data to when
- * it outputs a figure so that outputting a polygon does not require the allocation of a temporary buffer. This
- * static buffer should be destroyed whenever the program determines that it won't need it anymore and would prefer to
- * release the memory it has allocated back to the system.
- */
- template <typename Unit>
- class ActiveTail {
- private:
- //data
- PolyLine<Unit>* tailp_;
- ActiveTail *otherTailp_;
- std::list<ActiveTail*> holesList_;
- public:
-
- /*
- * iterator over coordinates of the figure
- */
- class iterator {
- private:
- const PolyLine<Unit>* pLine_;
- const PolyLine<Unit>* pLineEnd_;
- unsigned int index_;
- unsigned int indexEnd_;
- End startEnd_;
- public:
- inline iterator() : pLine_(), pLineEnd_(), index_(), indexEnd_(), startEnd_() {}
- inline iterator(const ActiveTail* at, bool isHole, orientation_2d orient) :
- pLine_(), pLineEnd_(), index_(), indexEnd_(), startEnd_() {
- //if it is a hole and orientation is vertical or it is not a hole and orientation is horizontal
- //we want to use this active tail, otherwise we want to use the other active tail
- startEnd_ = TAIL;
- if(!isHole ^ (orient == HORIZONTAL)) {
- //switch winding direction
- at = at->getOtherActiveTail();
- }
- //now we have the right winding direction
- //if it is horizontal we need to skip the first element
- pLine_ = at->getTail();
- index_ = at->getTail()->numSegments() - 1;
- if((at->getOrient() == HORIZONTAL) ^ (orient == HORIZONTAL)) {
- pLineEnd_ = at->getTail();
- indexEnd_ = pLineEnd_->numSegments() - 1;
- if(index_ == 0) {
- pLine_ = at->getTail()->next(HEAD);
- if(at->getTail()->endConnectivity(HEAD) == TAIL) {
- index_ = pLine_->numSegments() -1;
- } else {
- startEnd_ = HEAD;
- index_ = 0;
- }
- } else { --index_; }
- } else {
- pLineEnd_ = at->getOtherActiveTail()->getTail();
- indexEnd_ = pLineEnd_->numSegments() - 1;
- }
- at->getTail()->joinTailToTail(*(at->getOtherActiveTail()->getTail()));
- }
- //use bitwise copy and assign provided by the compiler
- inline iterator& operator++() {
- if(pLine_ == pLineEnd_ && index_ == indexEnd_) {
- pLine_ = 0;
- index_ = 0;
- return *this;
- }
- if(startEnd_ == HEAD) {
- ++index_;
- if(index_ == pLine_->numSegments()) {
- End end = pLine_->endConnectivity(TAIL);
- pLine_ = pLine_->next(TAIL);
- if(end == TAIL) {
- startEnd_ = TAIL;
- index_ = pLine_->numSegments() -1;
- } else {
- index_ = 0;
- }
- }
- } else {
- if(index_ == 0) {
- End end = pLine_->endConnectivity(HEAD);
- pLine_ = pLine_->next(HEAD);
- if(end == TAIL) {
- index_ = pLine_->numSegments() -1;
- } else {
- startEnd_ = HEAD;
- index_ = 0;
- }
- } else {
- --index_;
- }
- }
- return *this;
- }
- inline const iterator operator++(int) {
- iterator tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iterator& that) const {
- return pLine_ == that.pLine_ && index_ == that.index_;
- }
- inline bool operator!=(const iterator& that) const {
- return pLine_ != that.pLine_ || index_ != that.index_;
- }
- inline Unit operator*() { return (*pLine_)[index_]; }
- };
-
- /*
- * iterator over holes contained within the figure
- */
- typedef typename std::list<ActiveTail*>::const_iterator iteratorHoles;
-
- //default constructor
- ActiveTail();
-
- //constructor
- ActiveTail(orientation_2d orient, Unit coord, Side solidToRight, ActiveTail* otherTailp);
-
- //constructor
- ActiveTail(PolyLine<Unit>* active, ActiveTail* otherTailp);
-
- //copy constructor
- ActiveTail(const ActiveTail& that);
-
- //destructor
- ~ActiveTail();
-
- //assignment operator
- ActiveTail& operator=(const ActiveTail& that);
-
- //equivalence operator
- bool operator==(const ActiveTail& b) const;
-
- /*
- * comparison operators, ActiveTail objects are sortable by geometry
- */
- bool operator<(const ActiveTail& b) const;
- bool operator<=(const ActiveTail& b) const;
- bool operator>(const ActiveTail& b) const;
- bool operator>=(const ActiveTail& b) const;
-
- /*
- * get the pointer to the polyline that this is an active tail of
- */
- PolyLine<Unit>* getTail() const;
-
- /*
- * get the pointer to the polyline at the other end of the chain
- */
- PolyLine<Unit>* getOtherTail() const;
-
- /*
- * get the pointer to the activetail at the other end of the chain
- */
- ActiveTail* getOtherActiveTail() const;
-
- /*
- * test if another active tail is the other end of the chain
- */
- bool isOtherTail(const ActiveTail& b);
-
- /*
- * update this end of chain pointer to new polyline
- */
- ActiveTail& updateTail(PolyLine<Unit>* newTail);
-
- /*
- * associate a hole to this active tail by the specified policy
- */
- ActiveTail* addHole(ActiveTail* hole, bool fractureHoles);
-
- /*
- * get the list of holes
- */
- const std::list<ActiveTail*>& getHoles() const;
-
- /*
- * copy holes from that to this
- */
- void copyHoles(ActiveTail& that);
-
- /*
- * find out if solid to right
- */
- bool solidToRight() const;
-
- /*
- * get coordinate (getCoord and getCoordinate are aliases for eachother)
- */
- Unit getCoord() const;
- Unit getCoordinate() const;
-
- /*
- * get the tail orientation
- */
- orientation_2d getOrient() const;
-
- /*
- * add a coordinate to the polygon at this active tail end, properly handle degenerate edges by removing redundant coordinate
- */
- void pushCoordinate(Unit coord);
-
- /*
- * write the figure that this active tail points to out to the temp buffer
- */
- void writeOutFigure(std::vector<Unit>& outVec, bool isHole = false) const;
-
- /*
- * write the figure that this active tail points to out through iterators
- */
- void writeOutFigureItrs(iterator& beginOut, iterator& endOut, bool isHole = false, orientation_2d orient = VERTICAL) const;
- iterator begin(bool isHole, orientation_2d orient) const;
- iterator end() const;
-
- /*
- * write the holes that this active tail points to out through iterators
- */
- void writeOutFigureHoleItrs(iteratorHoles& beginOut, iteratorHoles& endOut) const;
- iteratorHoles beginHoles() const;
- iteratorHoles endHoles() const;
-
- /*
- * 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
- */
- static ActiveTail* joinChains(ActiveTail* at1, ActiveTail* at2, bool solid, std::vector<Unit>& outBufferTmp);
- template <typename PolygonT>
- static ActiveTail* joinChains(ActiveTail* at1, ActiveTail* at2, bool solid, typename std::vector<PolygonT>& outBufferTmp);
-
- /*
- * deallocate temp buffer
- */
- static void destroyOutBuffer();
-
- /*
- * deallocate all polygon data this active tail points to (deep delete, call only from one of a pair of active tails)
- */
- void destroyContents();
- };
-
- /* allocate a polyline object */
- template <typename Unit>
- PolyLine<Unit>* createPolyLine(orientation_2d orient, Unit coord, Side side);
-
- /* deallocate a polyline object */
- template <typename Unit>
- void destroyPolyLine(PolyLine<Unit>* pLine);
-
- /* allocate an activetail object */
- template <typename Unit>
- ActiveTail<Unit>* createActiveTail();
-
- /* deallocate an activetail object */
- template <typename Unit>
- void destroyActiveTail(ActiveTail<Unit>* aTail);
-
- template<bool orientT, typename Unit>
- class PolyLineHoleData {
- private:
- ActiveTail<Unit>* p_;
- public:
- 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;
- inline PolyLineHoleData() : p_(0) {}
- inline PolyLineHoleData(ActiveTail<Unit>* p) : p_(p) {}
- //use default copy and assign
- inline compact_iterator_type begin_compact() const { return p_->begin(true, (orientT ? VERTICAL : HORIZONTAL)); }
- inline compact_iterator_type end_compact() const { return p_->end(); }
- 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;
- }
- template<class iT>
- inline PolyLineHoleData& set_compact(iT inputBegin, iT inputEnd) {
- return *this;
- }
-
- };
-
- template<bool orientT, typename Unit>
- class PolyLinePolygonWithHolesData {
- private:
- ActiveTail<Unit>* p_;
- public:
- 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_;
- public:
- inline iteratorHoles() {}
- inline iteratorHoles(typename ActiveTail<Unit>::iteratorHoles itr) : itr_(itr) {}
- //use bitwise copy and assign provided by the compiler
- inline iteratorHoles& operator++() {
- ++itr_;
- return *this;
- }
- inline const iteratorHoles operator++(int) {
- iteratorHoles tmp(*this);
- ++(*this);
- return tmp;
- }
- inline bool operator==(const iteratorHoles& that) const {
- return itr_ == that.itr_;
- }
- inline bool operator!=(const iteratorHoles& that) const {
- return itr_ != that.itr_;
- }
- inline PolyLineHoleData<orientT, Unit> operator*() { return PolyLineHoleData<orientT, Unit>(*itr_);}
- };
- typedef iteratorHoles iterator_holes_type;
-
- 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(); }
- 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 iteratorHoles begin_holes() const { return iteratorHoles(p_->beginHoles()); }
- inline iteratorHoles end_holes() const { return iteratorHoles(p_->endHoles()); }
- inline ActiveTail<Unit>* 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 PolyLinePolygonWithHolesData& set(iT inputBegin, iT inputEnd) {
- return *this;
- }
- template<class iT>
- 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 PolyLinePolygonWithHolesData& set_holes(iT inputBegin, iT inputEnd) {
- return *this;
- }
- };
-
-
- 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:
- std::map<Unit, ActiveTail<Unit>*> tailMap_;
- typedef typename PolyLineType<orientT, Unit, polygon_concept_type>::type PolyLinePolygonData;
- std::vector<PolyLinePolygonData> outputPolygons_;
- bool fractureHoles_;
- public:
- typedef typename std::vector<PolyLinePolygonData>::iterator iterator;
- inline ScanLineToPolygonItrs() : tailMap_(), outputPolygons_(), fractureHoles_(false) {}
- /* construct a scanline with the proper offsets, protocol and options */
- inline ScanLineToPolygonItrs(bool fractureHoles) : tailMap_(), outputPolygons_(), fractureHoles_(fractureHoles) {}
-
- ~ScanLineToPolygonItrs() { clearOutput_(); }
-
- /* process all vertical edges, left and right, at a unique x coordinate, edges must be sorted low to high */
- void processEdges(iterator& beginOutput, iterator& endOutput,
- Unit currentX, std::vector<interval_data<Unit> >& leftEdges,
- std::vector<interval_data<Unit> >& rightEdges);
-
- private:
- void clearOutput_();
- };
-
- /*
- * ScanLine does all the work of stitching together polygons from incoming vertical edges
- */
-// template <typename Unit, typename polygon_concept_type>
-// class ScanLineToPolygons {
-// private:
-// ScanLineToPolygonItrs<true, Unit> scanline_;
-// public:
-// inline ScanLineToPolygons() : scanline_() {}
-// /* construct a scanline with the proper offsets, protocol and options */
-// inline ScanLineToPolygons(bool fractureHoles) : scanline_(fractureHoles) {}
-
-// /* 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;
-
- //EVERY FUNCTION in this DEF file should be explicitly defined as inline
-
- //microsoft compiler improperly warns whenever you cast an integer to bool
- //call this function on an integer to convert it to bool without a warning
- template <class T>
- inline bool to_bool(const T& val) { return val != 0; }
-
- //default constructor (for preallocation)
- template <typename Unit>
- inline PolyLine<Unit>::PolyLine() : headp_(0), tailp_(0), state_(-1) {}
-
- //constructor
- template <typename Unit>
- inline PolyLine<Unit>::PolyLine(orientation_2d orient, Unit coord, Side side) :
- ptdata_(1, coord),
- headp_(0),
- tailp_(0),
- state_(orient.to_int() +
- (side << 3)) {}
-
- //copy constructor
- template <typename Unit>
- inline PolyLine<Unit>::PolyLine(const PolyLine<Unit>& pline) : ptdata_(pline.ptdata_),
- headp_(pline.headp_),
- tailp_(pline.tailp_),
- state_(pline.state_) {}
-
- //destructor
- template <typename Unit>
- inline PolyLine<Unit>::~PolyLine() {
- //clear out data just in case it is read later
- headp_ = tailp_ = 0;
- state_ = 0;
- }
-
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::operator=(const PolyLine<Unit>& that) {
- if(!(this == &that)) {
- headp_ = that.headp_;
- tailp_ = that.tailp_;
- ptdata_ = that.ptdata_;
- state_ = that.state_;
- }
- return *this;
- }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::operator==(const PolyLine<Unit>& b) const {
- return this == &b || (state_ == b.state_ &&
- headp_ == b.headp_ &&
- tailp_ == b.tailp_);
- }
-
- //valid PolyLine
- template <typename Unit>
- inline bool PolyLine<Unit>::isValid() const {
- return state_ > -1; }
-
- //first coordinate is an X value
- //first segment is vertical
- template <typename Unit>
- inline bool PolyLine<Unit>::verticalHead() const {
- return state_ & VERTICAL_HEAD;
- }
-
- //retrun true is PolyLine has odd number of coordiantes
- template <typename Unit>
- inline bool PolyLine<Unit>::oddLength() const {
- return to_bool((ptdata_.size()-1) % 2);
- }
-
- //last coordiante is an X value
- //last segment is vertical
- template <typename Unit>
- inline bool PolyLine<Unit>::verticalTail() const {
- return to_bool(verticalHead() ^ oddLength());
- }
-
- template <typename Unit>
- inline orientation_2d PolyLine<Unit>::tailOrient() const {
- return (verticalTail() ? VERTICAL : HORIZONTAL);
- }
-
- template <typename Unit>
- inline orientation_2d PolyLine<Unit>::headOrient() const {
- return (verticalHead() ? VERTICAL : HORIZONTAL);
- }
-
- template <typename Unit>
- inline End PolyLine<Unit>::endConnectivity(End end) const {
- //Tail should be defined as true
- if(end) { return tailToTail(); }
- return headToTail();
- }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::headToTail() const {
- return to_bool(state_ & HEAD_TO_TAIL);
- }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::headToHead() const {
- return to_bool(!headToTail());
- }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::tailToHead() const {
- return to_bool(!tailToTail());
- }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::tailToTail() const {
- return to_bool(state_ & TAIL_TO_TAIL);
- }
-
- template <typename Unit>
- inline Side PolyLine<Unit>::solidSide() const {
- return solidToRight(); }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::solidToRight() const {
- return to_bool(state_ & SOLID_TO_RIGHT) != 0;
- }
-
- template <typename Unit>
- inline bool PolyLine<Unit>::active() const {
- return !to_bool(tailp_);
- }
-
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::pushCoordinate(Unit coord) {
- ptdata_.push_back(coord);
- return *this;
- }
-
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::popCoordinate() {
- ptdata_.pop_back();
- return *this;
- }
-
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::pushPoint(const point_data<Unit>& point) {
- point_data<Unit> endPt = getEndPoint();
- //vertical is true, horizontal is false
- if((tailOrient().to_int() ? point.get(VERTICAL) == endPt.get(VERTICAL) : point.get(HORIZONTAL) == endPt.get(HORIZONTAL))) {
- //we were pushing a colinear segment
- return popCoordinate();
- }
- return pushCoordinate(tailOrient().to_int() ? point.get(VERTICAL) : point.get(HORIZONTAL));
- }
-
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::extendTail(Unit delta) {
- ptdata_.back() += delta;
- return *this;
- }
-
- //private member function that creates a link from this PolyLine to that
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinTo_(End thisEnd, PolyLine<Unit>& that, End end) {
- if(thisEnd){
- tailp_ = &that;
- state_ &= ~TAIL_TO_TAIL; //clear any previous state_ of bit (for safety)
- state_ |= (end << 2); //place bit into mask
- } else {
- headp_ = &that;
- state_ &= ~HEAD_TO_TAIL; //clear any previous state_ of bit (for safety)
- state_ |= (end << 1); //place bit into mask
- }
- return *this;
- }
-
- //join two PolyLines (both ways of the association)
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinTo(End thisEnd, PolyLine<Unit>& that, End end) {
- joinTo_(thisEnd, that, end);
- that.joinTo_(end, *this, thisEnd);
- return *this;
- }
-
- //convenience functions for joining PolyLines
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinToTail(PolyLine<Unit>& that, End end) {
- return joinTo(TAIL, that, end);
- }
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinToHead(PolyLine<Unit>& that, End end) {
- return joinTo(HEAD, that, end);
- }
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinHeadToHead(PolyLine<Unit>& that) {
- return joinToHead(that, HEAD);
- }
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinHeadToTail(PolyLine<Unit>& that) {
- return joinToHead(that, TAIL);
- }
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinTailToHead(PolyLine<Unit>& that) {
- return joinToTail(that, HEAD);
- }
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::joinTailToTail(PolyLine<Unit>& that) {
- return joinToTail(that, TAIL);
- }
-
- template <typename Unit>
- inline PolyLine<Unit>& PolyLine<Unit>::disconnectTails() {
- next(TAIL)->state_ &= !TAIL_TO_TAIL;
- next(TAIL)->tailp_ = 0;
- state_ &= !TAIL_TO_TAIL;
- tailp_ = 0;
- return *this;
- }
-
- template <typename Unit>
- inline Unit PolyLine<Unit>::getEndCoord(End end) const {
- if(end)
- return ptdata_.back();
- return ptdata_.front();
- }
-
- template <typename Unit>
- inline orientation_2d PolyLine<Unit>::segmentOrient(unsigned int index) const {
- return (to_bool((unsigned int)verticalHead() ^ (index % 2)) ? VERTICAL : HORIZONTAL);
- }
-
- template <typename Unit>
- inline point_data<Unit> PolyLine<Unit>::getPoint(unsigned int index) const {
- //assert(isValid() && headp_->isValid()) ("PolyLine: headp_ must be valid");
- point_data<Unit> pt;
- pt.set(HORIZONTAL, ptdata_[index]);
- pt.set(VERTICAL, ptdata_[index]);
- Unit prevCoord;
- if(index == 0) {
- prevCoord = headp_->getEndCoord(headToTail());
- } else {
- prevCoord = ptdata_[index-1];
- }
- pt.set(segmentOrient(index), prevCoord);
- return pt;
- }
-
- template <typename Unit>
- inline point_data<Unit> PolyLine<Unit>::getEndPoint(End end) const {
- return getPoint((end ? numSegments() - 1 : (unsigned int)0));
- }
-
- template <typename Unit>
- inline Unit PolyLine<Unit>::operator[] (unsigned int index) const {
- //assert(ptdata_.size() > index) ("PolyLine: out of bounds index");
- return ptdata_[index];
- }
-
- template <typename Unit>
- inline unsigned int PolyLine<Unit>::numSegments() const {
- return ptdata_.size();
- }
-
- template <typename Unit>
- inline PolyLine<Unit>* PolyLine<Unit>::next(End end) const {
- return (end ? tailp_ : headp_);
- }
-
- template <typename Unit>
- inline ActiveTail<Unit>::ActiveTail() : tailp_(0), otherTailp_(0), holesList_() {}
-
- template <typename Unit>
- inline ActiveTail<Unit>::ActiveTail(orientation_2d orient, Unit coord, Side solidToRight, ActiveTail* otherTailp) :
- tailp_(0), otherTailp_(0), holesList_() {
- tailp_ = createPolyLine(orient, coord, solidToRight);
- otherTailp_ = otherTailp;
- }
-
- template <typename Unit>
- inline ActiveTail<Unit>::ActiveTail(PolyLine<Unit>* active, ActiveTail<Unit>* otherTailp) :
- tailp_(active), otherTailp_(otherTailp), holesList_() {}
-
- //copy constructor
- template <typename Unit>
- inline ActiveTail<Unit>::ActiveTail(const ActiveTail<Unit>& that) : tailp_(that.tailp_), otherTailp_(that.otherTailp_) {}
-
- //destructor
- template <typename Unit>
- inline ActiveTail<Unit>::~ActiveTail() {
- //clear them in case the memory is read later
- tailp_ = 0; otherTailp_ = 0;
- }
-
- template <typename Unit>
- inline ActiveTail<Unit>& ActiveTail<Unit>::operator=(const ActiveTail<Unit>& that) {
- //self assignment is safe in this case
- tailp_ = that.tailp_;
- otherTailp_ = that.otherTailp_;
- return *this;
- }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::operator==(const ActiveTail<Unit>& b) const {
- return tailp_ == b.tailp_ && otherTailp_ == b.otherTailp_;
- }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::operator<(const ActiveTail<Unit>& b) const {
- return tailp_->getEndPoint().get(VERTICAL) < b.tailp_->getEndPoint().get(VERTICAL);
- }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::operator<=(const ActiveTail<Unit>& b) const {
- return !(*this > b); }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::operator>(const ActiveTail<Unit>& b) const {
- return b < (*this); }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::operator>=(const ActiveTail<Unit>& b) const {
- return !(*this < b); }
-
- template <typename Unit>
- inline PolyLine<Unit>* ActiveTail<Unit>::getTail() const {
- return tailp_; }
-
- template <typename Unit>
- inline PolyLine<Unit>* ActiveTail<Unit>::getOtherTail() const {
- return otherTailp_->tailp_; }
-
- template <typename Unit>
- inline ActiveTail<Unit>* ActiveTail<Unit>::getOtherActiveTail() const {
- return otherTailp_; }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::isOtherTail(const ActiveTail<Unit>& b) {
- // assert( (tailp_ == b.getOtherTail() && getOtherTail() == b.tailp_) ||
- // (tailp_ != b.getOtherTail() && getOtherTail() != b.tailp_))
- // ("ActiveTail: Active tails out of sync");
- return otherTailp_ == &b;
- }
-
- template <typename Unit>
- inline ActiveTail<Unit>& ActiveTail<Unit>::updateTail(PolyLine<Unit>* newTail) {
- tailp_ = newTail;
- return *this;
- }
-
- template <typename Unit>
- inline ActiveTail<Unit>* ActiveTail<Unit>::addHole(ActiveTail<Unit>* hole, bool fractureHoles) {
- if(!fractureHoles){
- holesList_.push_back(hole);
- copyHoles(*hole);
- copyHoles(*(hole->getOtherActiveTail()));
- return this;
- }
- ActiveTail<Unit>* h, *v;
- ActiveTail<Unit>* other = hole->getOtherActiveTail();
- if(other->getOrient() == VERTICAL) {
- //assert that hole.getOrient() == HORIZONTAL
- //this case should never happen
- h = hole;
- v = other;
- } else {
- //assert that hole.getOrient() == VERTICAL
- h = other;
- v = hole;
- }
- h->pushCoordinate(v->getCoordinate());
- //assert that h->getOrient() == VERTICAL
- //v->pushCoordinate(getCoordinate());
- //assert that v->getOrient() == VERTICAL
- //I can't close a figure by adding a hole, so pass zero for xMin and yMin
- std::vector<Unit> tmpVec;
- ActiveTail<Unit>::joinChains(this, h, false, tmpVec);
- return v;
- }
-
- template <typename Unit>
- inline const std::list<ActiveTail<Unit>*>& ActiveTail<Unit>::getHoles() const {
- return holesList_;
- }
-
- template <typename Unit>
- inline void ActiveTail<Unit>::copyHoles(ActiveTail<Unit>& that) {
- holesList_.splice(holesList_.end(), that.holesList_); //splice the two lists together
- }
-
- template <typename Unit>
- inline bool ActiveTail<Unit>::solidToRight() const {
- return getTail()->solidToRight(); }
-
- template <typename Unit>
- inline Unit ActiveTail<Unit>::getCoord() const {
- return getTail()->getEndCoord(); }
-
- template <typename Unit>
- inline Unit ActiveTail<Unit>::getCoordinate() const {
- return getCoord(); }
-
- template <typename Unit>
- inline orientation_2d ActiveTail<Unit>::getOrient() const {
- return getTail()->tailOrient(); }
-
- template <typename Unit>
- inline void ActiveTail<Unit>::pushCoordinate(Unit coord) {
- //appropriately handle any co-linear polyline segments by calling push point internally
- point_data<Unit> p;
- p.set(HORIZONTAL, coord);
- p.set(VERTICAL, coord);
- //if we are vertical assign the last coordinate (an X) to p.x, else to p.y
- p.set(getOrient().get_perpendicular(), getCoordinate());
- tailp_->pushPoint(p);
- }
-
-
- //global utility functions
- template <typename Unit>
- inline PolyLine<Unit>* createPolyLine(orientation_2d orient, Unit coord, Side side) {
- return new PolyLine<Unit>(orient, coord, side);
- }
-
- template <typename Unit>
- inline void destroyPolyLine(PolyLine<Unit>* pLine) {
- delete pLine;
- }
-
- template <typename Unit>
- inline ActiveTail<Unit>* createActiveTail() {
- //consider replacing system allocator with ActiveTail memory pool
- return new ActiveTail<Unit>();
- }
-
- template <typename Unit>
- inline void destroyActiveTail(ActiveTail<Unit>* aTail) {
- delete aTail;
- }
-
-
- //no recursion, to prevent max recursion depth errors
- template <typename Unit>
- inline void ActiveTail<Unit>::destroyContents() {
- tailp_->disconnectTails();
- PolyLine<Unit>* nextPolyLinep = tailp_->next(HEAD);
- End end = tailp_->endConnectivity(HEAD);
- destroyPolyLine(tailp_);
- while(nextPolyLinep) {
- End nextEnd = nextPolyLinep->endConnectivity(!end); //get the direction of next polyLine
- PolyLine<Unit>* nextNextPolyLinep = nextPolyLinep->next(!end); //get the next polyline
- destroyPolyLine(nextPolyLinep); //destroy the current polyline
- end = nextEnd;
- nextPolyLinep = nextNextPolyLinep;
- }
- }
-
- template <typename Unit>
- inline typename ActiveTail<Unit>::iterator ActiveTail<Unit>::begin(bool isHole, orientation_2d orient) const {
- return iterator(this, isHole, orient);
- }
-
- template <typename Unit>
- inline typename ActiveTail<Unit>::iterator ActiveTail<Unit>::end() const {
- return iterator();
- }
-
- template <typename Unit>
- inline typename ActiveTail<Unit>::iteratorHoles ActiveTail<Unit>::beginHoles() const {
- return holesList_.begin();
- }
-
- template <typename Unit>
- inline typename ActiveTail<Unit>::iteratorHoles ActiveTail<Unit>::endHoles() const {
- return holesList_.end();
- }
-
- template <typename Unit>
- inline void ActiveTail<Unit>::writeOutFigureItrs(iterator& beginOut, iterator& endOut, bool isHole, orientation_2d orient) const {
- beginOut = begin(isHole, orient);
- endOut = end();
- }
-
- template <typename Unit>
- inline void ActiveTail<Unit>::writeOutFigureHoleItrs(iteratorHoles& beginOut, iteratorHoles& endOut) const {
- beginOut = beginHoles();
- endOut = endHoles();
- }
-
- template <typename Unit>
- inline void ActiveTail<Unit>::writeOutFigure(std::vector<Unit>& outVec, bool isHole) const {
- //we start writing out the polyLine that this active tail points to at its tail
- unsigned int size = outVec.size();
- outVec.push_back(0); //place holder for size
- PolyLine<Unit>* nextPolyLinep = 0;
- if(!isHole){
- nextPolyLinep = otherTailp_->tailp_->writeOut(outVec);
- } else {
- nextPolyLinep = tailp_->writeOut(outVec);
- }
- Unit firsty = outVec[size + 1];
- if((getOrient() == HORIZONTAL) ^ !isHole) {
- //our first coordinate is a y value, so we need to rotate it to the end
- typename std::vector<Unit>::iterator tmpItr = outVec.begin();
- tmpItr += size;
- outVec.erase(++tmpItr); //erase the 2nd element
- }
- End startEnd = tailp_->endConnectivity(HEAD);
- if(isHole) startEnd = otherTailp_->tailp_->endConnectivity(HEAD);
- while(nextPolyLinep) {
- bool nextStartEnd = nextPolyLinep->endConnectivity(!startEnd);
- nextPolyLinep = nextPolyLinep->writeOut(outVec, startEnd);
- startEnd = nextStartEnd;
- }
- if((getOrient() == HORIZONTAL) ^ !isHole) {
- //we want to push the y value onto the end since we ought to have ended with an x
- outVec.push_back(firsty); //should never be executed because we want first value to be an x
- }
- //the vector contains the coordinates of the linked list of PolyLines in the correct order
- //first element is supposed to be the size
- outVec[size] = outVec.size() - 1 - size; //number of coordinates in vector
- //assert outVec[size] % 2 == 0 //it should be even
- //make the size negative for holes
- outVec[size] *= (isHole ? -1 : 1);
- }
-
- //no recursion to prevent max recursion depth errors
- template <typename Unit>
- inline PolyLine<Unit>* PolyLine<Unit>::writeOut(std::vector<Unit>& outVec, End startEnd) const {
- if(startEnd == HEAD){
- //forward order
- outVec.insert(outVec.end(), ptdata_.begin(), ptdata_.end());
- return tailp_;
- }else{
- //reverse order
- //do not reserve because we expect outVec to be large enough already
- for(int i = ptdata_.size() - 1; i >= 0; --i){
- outVec.push_back(ptdata_[i]);
- }
- //NT didn't know about this version of the API....
- //outVec.insert(outVec.end(), ptdata_.rbegin(), ptdata_.rend());
- return headp_;
- }
- }
-
- //solid indicates if it was joined by a solit or a space
- template <typename Unit>
- inline ActiveTail<Unit>* ActiveTail<Unit>::joinChains(ActiveTail<Unit>* at1, ActiveTail<Unit>* at2, bool solid, std::vector<Unit>& outBufferTmp)
- {
- //checks to see if we closed a figure
- if(at1->isOtherTail(*at2)){
- //value of solid tells us if we closed solid or hole
- //and output the solid or handle the hole appropriately
- //if the hole needs to fracture across horizontal partition boundary we need to notify
- //the calling context to do so
- if(solid) {
- //the chains are being joined because there is solid to the right
- //this means that if the figure is closed at this point it must be a hole
- //because otherwise it would have to have another vertex to the right of this one
- //and would not be closed at this point
- return at1;
- } else {
- //assert pG != 0
- //the figure that was closed is a shell
- at1->writeOutFigure(outBufferTmp);
- //process holes of the polygon
- at1->copyHoles(*at2); //there should not be holes on at2, but if there are, copy them over
- const std::list<ActiveTail<Unit>*>& holes = at1->getHoles();
- for(typename std::list<ActiveTail<Unit>*>::const_iterator litr = holes.begin(); litr != holes.end(); ++litr) {
- (*litr)->writeOutFigure(outBufferTmp, true);
- //delete the hole
- (*litr)->destroyContents();
- destroyActiveTail((*litr)->getOtherActiveTail());
- destroyActiveTail((*litr));
- }
- //delete the polygon
- at1->destroyContents();
- //at2 contents are the same as at1, so it should not destroy them
- destroyActiveTail(at1);
- destroyActiveTail(at2);
- }
- return 0;
- }
- //join the two partial polygons into one large partial polygon
- at1->getTail()->joinTailToTail(*(at2->getTail()));
- *(at1->getOtherActiveTail()) = ActiveTail(at1->getOtherTail(), at2->getOtherActiveTail());
- *(at2->getOtherActiveTail()) = ActiveTail(at2->getOtherTail(), at1->getOtherActiveTail());
- at1->getOtherActiveTail()->copyHoles(*at1);
- at1->getOtherActiveTail()->copyHoles(*at2);
- destroyActiveTail(at1);
- destroyActiveTail(at2);
- return 0;
- }
-
- //solid indicates if it was joined by a solit or a space
- template <typename Unit>
- template <typename PolygonT>
- inline ActiveTail<Unit>* ActiveTail<Unit>::joinChains(ActiveTail<Unit>* at1, ActiveTail<Unit>* at2, bool solid,
- 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
- //and output the solid or handle the hole appropriately
- //if the hole needs to fracture across horizontal partition boundary we need to notify
- //the calling context to do so
- if(solid) {
- //the chains are being joined because there is solid to the right
- //this means that if the figure is closed at this point it must be a hole
- //because otherwise it would have to have another vertex to the right of this one
- //and would not be closed at this point
- return at1;
- } else {
- //assert pG != 0
- //the figure that was closed is a shell
- outBufferTmp.push_back(at1);
- at1->copyHoles(*at2); //there should not be holes on at2, but if there are, copy them over
- }
- return 0;
- }
- //join the two partial polygons into one large partial polygon
- at1->getTail()->joinTailToTail(*(at2->getTail()));
- *(at1->getOtherActiveTail()) = ActiveTail<Unit>(at1->getOtherTail(), at2->getOtherActiveTail());
- *(at2->getOtherActiveTail()) = ActiveTail<Unit>(at2->getOtherTail(), at1->getOtherActiveTail());
- at1->getOtherActiveTail()->copyHoles(*at1);
- at1->getOtherActiveTail()->copyHoles(*at2);
- destroyActiveTail(at1);
- destroyActiveTail(at2);
- return 0;
- }
-
- template <class TKey, class T> inline typename std::map<TKey, T>::iterator findAtNext(std::map<TKey, T>& theMap,
- typename std::map<TKey, T>::iterator pos, const TKey& key)
- {
- if(pos == theMap.end()) return theMap.find(key);
- //if they match the mapItr is pointing to the correct position
- if(pos->first < key) {
- return theMap.find(key);
- }
- if(pos->first > key) {
- return theMap.end();
- }
- //else they are equal and no need to do anything to the iterator
- return pos;
- }
-
- // createActiveTailsAsPair is called in these two end cases of geometry
- // 1. lower left concave corner
- // ###|
- // ###|
- // ###|###
- // ###|###
- // 2. lower left convex corner
- // |###
- // |###
- // |
- // |
- // In case 1 there may be a hole propigated up from the bottom. If the fracture option is enabled
- // the two active tails that form the filament fracture line edges can become the new active tail pair
- // by pushing x and y onto them. Otherwise the hole simply needs to be associated to one of the new active tails
- // with add hole
- template <typename Unit>
- inline std::pair<ActiveTail<Unit>*, ActiveTail<Unit>*> createActiveTailsAsPair(Unit x, Unit y, bool solid, ActiveTail<Unit>* phole, bool fractureHoles) {
- ActiveTail<Unit>* at1 = 0;
- ActiveTail<Unit>* at2 = 0;
- if(!phole || !fractureHoles){
- at1 = createActiveTail<Unit>();
- at2 = createActiveTail<Unit>();
- (*at1) = ActiveTail<Unit>(VERTICAL, x, solid, at2);
- (*at2) = ActiveTail<Unit>(HORIZONTAL, y, !solid, at1);
- //provide a function through activeTail class to provide this
- at1->getTail()->joinHeadToHead(*(at2->getTail()));
- if(phole)
- at1->addHole(phole, fractureHoles); //assert fractureHoles == false
- return std::pair<ActiveTail<Unit>*, ActiveTail<Unit>*>(at1, at2);
- }
- //assert phole is not null
- //assert fractureHoles is true
- if(phole->getOrient() == VERTICAL) {
- at2 = phole;
- } else {
- at2 = phole->getOtherActiveTail(); //should never be executed since orientation is expected to be vertical
- }
- //assert solid == false, we should be creating a corner with solid below and to the left if there was a hole
- at1 = at2->getOtherActiveTail();
- //assert at1 is horizontal
- at1->pushCoordinate(x);
- //assert at2 is vertical
- at2->pushCoordinate(y);
- return std::pair<ActiveTail<Unit>*, ActiveTail<Unit>*>(at1, at2);
- }
-
- //Process edges connects vertical input edges (right or left edges of figures) to horizontal edges stored as member
- //data of the scanline object. It also creates now horizontal edges as needed to construct figures from edge data.
- //
- //There are only 12 geometric end cases where the scanline intersects a horizontal edge and even fewer unique
- //actions to take:
- // 1. Solid on both sides of the vertical partition after the current position and space on both sides before
- // ###|###
- // ###|###
- // |
- // |
- // This case does not need to be handled because there is no vertical edge at the current x coordinate.
- //
- // 2. Solid on both sides of the vertical partition before the current position and space on both sides after
- // |
- // |
- // ###|###
- // ###|###
- // This case does not need to be handled because there is no vertical edge at the current x coordinate.
- //
- // 3. Solid on the left of the vertical partition after the current position and space elsewhere
- // ###|
- // ###|
- // |
- // |
- // The horizontal edge from the left is found and turns upward because of the vertical right edge to become
- // the currently active vertical edge.
- //
- // 4. Solid on the left of the vertical partion before the current position and space elsewhere
- // |
- // |
- // ###|
- // ###|
- // The horizontal edge from the left is found and joined to the currently active vertical edge.
- //
- // 5. Solid to the right above and below and solid to the left above current position.
- // ###|###
- // ###|###
- // |###
- // |###
- // The horizontal edge from the left is found and joined to the currently active vertical edge,
- // potentially closing a hole.
- //
- // 6. Solid on the left of the vertical partion before the current position and solid to the right above and below
- // |###
- // |###
- // ###|###
- // ###|###
- // The horizontal edge from the left is found and turns upward because of the vertical right edge to become
- // the currently active vertical edge.
- //
- // 7. Solid on the right of the vertical partition after the current position and space elsewhere
- // |###
- // |###
- // |
- // |
- // Create two new ActiveTails, one is added to the horizontal edges and the other becomes the vertical currentTail
- //
- // 8. Solid on the right of the vertical partion before the current position and space elsewhere
- // |
- // |
- // |###
- // |###
- // The currentTail vertical edge turns right and is added to the horizontal edges data
- //
- // 9. Solid to the right above and solid to the left above and below current position.
- // ###|###
- // ###|###
- // ###|
- // ###|
- // The currentTail vertical edge turns right and is added to the horizontal edges data
- //
- // 10. Solid on the left of the vertical partion above and below the current position and solid to the right below
- // ###|
- // ###|
- // ###|###
- // ###|###
- // Create two new ActiveTails, one is added to the horizontal edges data and the other becomes the vertical currentTail
- //
- // 11. Solid to the right above and solid to the left below current position.
- // |###
- // |###
- // ###|
- // ###|
- // The currentTail vertical edge joins the horizontal edge from the left (may close a polygon)
- // Create two new ActiveTails, one is added to the horizontal edges data and the other becomes the vertical currentTail
- //
- // 12. Solid on the left of the vertical partion above the current position and solid to the right below
- // ###|
- // ###|
- // |###
- // |###
- // 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, 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) {
- clearOutput_();
- typename std::map<Unit, ActiveTail<Unit>*>::iterator nextMapItr = tailMap_.begin();
- //foreach edge
- unsigned int leftIndex = 0;
- unsigned int rightIndex = 0;
- bool bottomAlreadyProcessed = false;
- ActiveTail<Unit>* currentTail = 0;
- 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)};
- bool haveNextEdge = true;
- if(leftIndex < leftEdges.size())
- edges[0] = leftEdges[leftIndex];
- else
- haveNextEdge = false;
- if(rightIndex < rightEdges.size())
- edges[1] = rightEdges[rightIndex];
- else
- haveNextEdge = false;
- bool trailingEdge = edges[1].get(LOW) < edges[0].get(LOW);
- interval_data<Unit> & edge = edges[trailingEdge];
- interval_data<Unit> & nextEdge = edges[!trailingEdge];
- //process this edge
- if(!bottomAlreadyProcessed) {
- //assert currentTail = 0
-
- //process the bottom end of this edge
- typename std::map<Unit, ActiveTail<Unit>*>::iterator thisMapItr = findAtNext(tailMap_, nextMapItr, edge.get(LOW));
- if(thisMapItr != tailMap_.end()) {
- //there is an edge in the map at the low end of this edge
- //it needs to turn upward and become the current tail
- ActiveTail<Unit>* tail = thisMapItr->second;
- if(currentTail) {
- //stitch currentTail into this tail
- currentTail = tail->addHole(currentTail, fractureHoles_);
- if(!fractureHoles_)
- currentTail->pushCoordinate(currentX);
- } else {
- currentTail = tail;
- currentTail->pushCoordinate(currentX);
- }
- //assert currentTail->getOrient() == VERTICAL
- nextMapItr = thisMapItr; //set nextMapItr to the next position after this one
- ++nextMapItr;
- //remove thisMapItr from the map
- tailMap_.erase(thisMapItr);
- } else {
- //there is no edge in the map at the low end of this edge
- //we need to create one and another one to be the current vertical tail
- //if this is a trailing edge then there is space to the right of the vertical edge
- //so pass the inverse of trailingEdge to indicate solid to the right
- std::pair<ActiveTail<Unit>*, ActiveTail<Unit>*> tailPair =
- createActiveTailsAsPair(currentX, edge.get(LOW), !trailingEdge, currentTail, fractureHoles_);
- currentTail = tailPair.first;
- tailMap_.insert(nextMapItr, std::pair<Unit, ActiveTail<Unit>*>(edge.get(LOW), tailPair.second));
- // leave nextMapItr unchanged
- }
-
- }
- if(haveNextEdge && edge.get(HIGH) == nextEdge.get(LOW)) {
- //the top of this edge is equal to the bottom of the next edge, process them both
- bottomAlreadyProcessed = true;
- typename std::map<Unit, ActiveTail<Unit>*>::iterator thisMapItr = findAtNext(tailMap_, nextMapItr, edge.get(HIGH));
- if(thisMapItr == tailMap_.end()) //assert this should never happen
- return;
- if(trailingEdge) {
- //geometry at this position
- // |##
- // |##
- // -----
- // ##|
- // ##|
- //current tail should join thisMapItr tail
- ActiveTail<Unit>* tail = thisMapItr->second;
- //pass false because they are being joined because space is to the right and it will close a solid figure
- ActiveTail<Unit>::joinChains(currentTail, tail, false, outputPolygons_);
- //two new tails are created, the vertical becomes current tail, the horizontal becomes thisMapItr tail
- //pass true becuase they are created at the lower left corner of some solid
- //pass null because there is no hole pointer possible
- std::pair<ActiveTail<Unit>*, ActiveTail<Unit>*> tailPair =
- createActiveTailsAsPair<Unit>(currentX, edge.get(HIGH), true, 0, fractureHoles_);
- currentTail = tailPair.first;
- thisMapItr->second = tailPair.second;
- } else {
- //geometry at this position
- // ##|
- // ##|
- // -----
- // |##
- // |##
- //current tail should turn right
- currentTail->pushCoordinate(edge.get(HIGH));
- //thisMapItr tail should turn up
- thisMapItr->second->pushCoordinate(currentX);
- //thisMapItr tail becomes current tail and current tail becomes thisMapItr tail
- std::swap(currentTail, thisMapItr->second);
- }
- nextMapItr = thisMapItr; //set nextMapItr to the next position after this one
- ++nextMapItr;
- } else {
- //there is a gap between the top of this edge and the bottom of the next, process the top of this edge
- bottomAlreadyProcessed = false;
- //process the top of this edge
- typename std::map<Unit, ActiveTail<Unit>*>::iterator thisMapItr = findAtNext(tailMap_, nextMapItr, edge.get(HIGH));
- if(thisMapItr != tailMap_.end()) {
- //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
- 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_);
- nextMapItr = thisMapItr; //set nextMapItr to the next position after this one
- ++nextMapItr;
- if(currentTail) {
- Unit nextItrY = UnitMax;
- if(nextMapItr != tailMap_.end()) {
- nextItrY = nextMapItr->first;
- }
- //for it to be a hole this must have been a left edge
- Unit leftY = UnitMax;
- if(leftIndex + 1 < leftEdges.size())
- leftY = leftEdges[leftIndex+1].get(LOW);
- Unit rightY = nextEdge.get(LOW);
- if(!haveNextEdge || (nextItrY < leftY && nextItrY < rightY)) {
- //we need to add it to the next edge above it in the map
- tail = nextMapItr->second;
- tail = tail->addHole(currentTail, fractureHoles_);
- if(fractureHoles_) {
- //some small additional work stitching in the filament
- tail->pushCoordinate(nextItrY);
- nextMapItr->second = tail;
- }
- //set current tail to null
- currentTail = 0;
- }
- }
- //delete thisMapItr from the map
- tailMap_.erase(thisMapItr);
- } else {
- //currentTail must turn right and be added into the map
- currentTail->pushCoordinate(edge.get(HIGH));
- //assert currentTail->getOrient() == HORIZONTAL
- tailMap_.insert(nextMapItr, std::pair<Unit, ActiveTail<Unit>*>(edge.get(HIGH), currentTail));
- //set currentTail to null
- currentTail = 0;
- //leave nextMapItr unchanged, it is still next
- }
- }
-
- //increment index
- leftIndex += !trailingEdge;
- rightIndex += trailingEdge;
- } //end while
- beginOutput = outputPolygons_.begin();
- endOutput = outputPolygons_.end();
- } //end function
-
- 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();
- for(typename std::list<ActiveTail<Unit>*>::const_iterator litr = holes.begin(); litr != holes.end(); ++litr) {
- //delete the hole
- (*litr)->destroyContents();
- destroyActiveTail((*litr)->getOtherActiveTail());
- destroyActiveTail((*litr));
- }
- //delete the polygon
- at1->destroyContents();
- //at2 contents are the same as at1, so it should not destroy them
- destroyActiveTail((at1)->getOtherActiveTail());
- destroyActiveTail(at1);
- }
- outputPolygons_.clear();
- }
-
-} //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>
- unsigned int get_polygons(output_container& container, iterator_type begin, iterator_type end,
- orientation_2d orient, bool fracture_holes, concept_type tag) {
- typedef typename output_container::value_type polygon_type;
- typedef typename iterator_type::value_type::first_type coordinate_type;
- polygon_type poly;
- unsigned int countPolygons = 0;
- 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();
- coordinate_type prevY = std::numeric_limits<coordinate_type>::max();
- int count = 0;
- for(iterator_type itr = begin;
- itr != end; ++ itr) {
- coordinate_type pos = (*itr).first;
- if(pos != prevPos) {
- if(orient == VERTICAL) {
- 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;
- assign(poly, *itrPoly);
- container.insert(container.end(), poly);
- }
- } else {
- 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;
- assign(poly, *itrPoly);
- container.insert(container.end(), poly);
- }
- }
- leftEdges.clear();
- rightEdges.clear();
- prevPos = pos;
- prevY = (*itr).second.first;
- count = (*itr).second.second;
- continue;
- }
- coordinate_type y = (*itr).second.first;
- if(count != 0 && y != prevY) {
- 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()) {
- encompass(leftEdges.back(), element.first);
- } else {
- leftEdges.push_back(element.first);
- }
- } else {
- if(rightEdges.size() && rightEdges.back().high() == element.first.low()) {
- encompass(rightEdges.back(), element.first);
- } else {
- rightEdges.push_back(element.first);
- }
- }
-
- }
- prevY = y;
- count += (*itr).second.second;
- }
- if(orient == VERTICAL) {
- 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;
- assign(poly, *itrPoly);
- container.insert(container.end(), poly);
- }
- } else {
- 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;
- assign(poly, *itrPoly);
- container.insert(container.end(), poly);
- }
- }
- return countPolygons;
- }
-
-
-}
-#endif
-

Deleted: sandbox/gtl/polygon_set_concept.hpp
==============================================================================
--- sandbox/gtl/polygon_set_concept.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,342 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef 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 is_any_polygon_set_type<polygon_set_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 is_any_polygon_set_type<polygon_set_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 is_polygon_set_type<polygon_set_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_1< typename gtl_and<
- typename is_mutable_polygon_set_type<polygon_set_type_1>::type,
- 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_1< typename gtl_and_3 <
- typename is_any_polygon_set_type<polygon_set_type_1>::type,
- typename is_any_polygon_set_type<polygon_set_type_2>::type,
- 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 is_mutable_polygon_set_type<polygon_set_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 is_mutable_polygon_set_type<polygon_set_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_1< typename gtl_and<
- typename is_mutable_polygon_set_type<polygon_set_type>::type,
- typename is_mutable_rectangle_concept<typename geometry_concept<rectangle_type>::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 is_mutable_polygon_set_type<polygon_set_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 is_mutable_polygon_set_type<polygon_set_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 is_mutable_polygon_set_type<polygon_set_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 is_mutable_polygon_set_type<polygon_set_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 is_mutable_polygon_set_type<polygon_set_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_1< typename gtl_and_3 < typename is_any_polygon_set_type<geometry_type_1>::type,
- typename is_any_polygon_set_type<geometry_type_2>::type,
- 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_1< typename gtl_and_3 < typename is_any_polygon_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_any_polygon_set_type<geometry_type_2>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>
-#ifdef __ICC
- ::type
-#endif
- ::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_1< typename gtl_and_3 <
- typename is_any_polygon_set_type<geometry_type_1>::type,
- typename is_any_polygon_set_type<geometry_type_2>::type,
- 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_1< typename gtl_and_3 <
- typename is_any_polygon_set_type<geometry_type_1>::type,
- typename is_any_polygon_set_type<geometry_type_2>::type,
- 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_1< typename gtl_and_3 < typename is_any_polygon_set_type<geometry_type_1>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_any_polygon_set_type<geometry_type_2>
-#ifdef __ICC
- ::type
-#endif
- ::type, typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>
-#ifdef __ICC
- ::type
-#endif
- ::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_1< typename gtl_and< typename is_mutable_polygon_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_set_type<geometry_type_1>::type,
- 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_1<
- typename gtl_and< typename is_mutable_polygon_set_type<geometry_type_1>::type,
- 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_1< typename gtl_and< typename is_mutable_polygon_set_type<geometry_type_1>::type,
- 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_1<
- typename gtl_and< typename is_mutable_polygon_set_type<geometry_type_1>::type,
- 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

Deleted: sandbox/gtl/polygon_set_data.hpp
==============================================================================
--- sandbox/gtl/polygon_set_data.hpp 2009-05-01 12:50:58 EDT (Fri, 01 May 2009)
+++ (empty file)
@@ -1,417 +0,0 @@
-/*
- Copyright 2008 Intel Corporation
-
- Use, modification and distribution are subject to the Boost Software License,
- Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt).
-*/
-#ifndef GTL_POLYGON_SET_DATA_HPP
-#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 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;
-
- // default constructor
- inline polygon_set_data() : data_(), dirty_(false), unsorted_(false), is_45_(true) {}
-
- // constructor from an iterator pair over edge data
- template <typename iT>
- inline polygon_set_data(iT input_begin, iT input_end) : data_(), dirty_(false), unsorted_(false), is_45_(true) {
- for( ; input_begin != input_end; ++input_begin) { insert(*input_begin); }
- }
-
- // copy constructor
- inline polygon_set_data(const polygon_set_data& that) :
- data_(that.data_), dirty_(that.dirty_), unsorted_(that.unsorted_), is_45_(that.is_45_) {}
-
- // copy constructor
- template <typename ltype, typename rtype, int op_type>
- inline polygon_set_data(const polygon_set_view<ltype, rtype, op_type>& that);
-
- // destructor
- inline ~polygon_set_data() {}
-
- // assignement operator
- inline polygon_set_data& operator=(const polygon_set_data& that) {
- if(this == &that) return *this;
- data_ = that.data_;
- dirty_ = that.dirty_;
- unsorted_ = that.unsorted_;
- is_45_ = that.is_45_;
- return *this;
- }
-
- 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;
- }
-
- template <typename geometry_object>
- inline polygon_set_data& operator=(const geometry_object& geometry) {
- data_.clear();
- insert(geometry);
- return *this;
- }
-
-
- // insert iterator range
- inline void insert(iterator_type input_begin, iterator_type input_end) {
- if(input_begin == input_end || input_begin == data_.begin()) return;
- dirty_ = true;
- unsorted_ = true;
- while(input_begin != input_end) {
- insert(*input_begin);
- ++input_begin;
- }
- }
-
- // insert iterator range
- template <typename iT>
- inline void insert(iT input_begin, iT input_end) {
- 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, bool is_hole = false) {
- insert(geometry_object, is_hole, typename geometry_concept<geometry_type>::type());
- }
-
- 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(const element_type& edge) {
- insert_clean(edge);
- dirty_ = true;
- unsorted_ = true;
- }
-
- template <typename output_container>
- inline void get(output_container& output) {
- get_dispatch(output, typename geometry_concept<typename output_container::value_type>::type());
- }
-
- // equivalence operator
- inline bool operator==(const polygon_set_data& p) const {
- clean();
- p.clean();
- return data_ == p.data_;
- }
-
- // inequivalence operator
- inline bool operator!=(const polygon_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_set_data
- inline void clear() { data_.clear(); dirty_ = unsorted_ = false; }
-
- // 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_; }
-
- void 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) {
- clear();
- insert(input_begin, input_end);
- dirty_ = true;
- unsorted_ = true;
- }
-
- void set(const value_type& value) {
- data_ = value;
- dirty_ = true;
- unsorted_ = true;
- }
-
- template <typename rectangle_type>
- bool extents(rectangle_type& rect) {
- 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;
- d