Added boost header

test/external/boost/polygon/detail/boolean_op.hpp

@@ -0,0 +1,448 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_BOOLEAN_OP_HPP
+#define BOOST_POLYGON_BOOLEAN_OP_HPP
+namespace boost { namespace polygon{
+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() 
+#ifndef BOOST_POLYGON_MSVC  
+      : counts_() 
+#endif
+    { counts_[0] = counts_[1] = 0; }
+    // constructs from two integers
+    inline BinaryCount(int countL, int countR) 
+#ifndef BOOST_POLYGON_MSVC  
+      : counts_() 
+#endif
+    { counts_[0] = countL, counts_[1] = countR; }
+    inline BinaryCount& operator=(int count) { counts_[0] = count, counts_[1] = count; return *this; }
+    inline BinaryCount& operator=(const BinaryCount& that); 
+    inline BinaryCount(const BinaryCount& that)
+#ifndef BOOST_POLYGON_MSVC
+      : counts_() 
+#endif
+    { *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;
+  }
+
+
+  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(std::size_t 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(std::size_t 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

test/external/boost/polygon/detail/iterator_compact_to_points.hpp

@@ -0,0 +1,69 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_ITERATOR_COMPACT_TO_POINTS_HPP
+#define BOOST_POLYGON_ITERATOR_COMPACT_TO_POINTS_HPP
+namespace boost { namespace polygon{
+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
+

test/external/boost/polygon/detail/iterator_geometry_to_set.hpp

@@ -0,0 +1,315 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_ITERATOR_GEOMETRY_TO_SET_HPP
+#define BOOST_POLYGON_ITERATOR_GEOMETRY_TO_SET_HPP
+namespace boost { namespace polygon{
+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, bool = false, direction_1d = CLOCKWISE) : 
+    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, bool winding_override = false, direction_1d w = CLOCKWISE) : 
+    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 = w;
+      if(!winding_override)
+        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_();
+    }
+  }
+  iterator_geometry_to_set(const iterator_geometry_to_set& that) : 
+    vertex_(), itrb(), itre(), last_vertex_(), is_hole_(), multiplier_(), first_pt(),
+    second_pt(), pts(), use_wrap(), orient_(), polygon_index(-1) {
+    vertex_ = that.vertex_;
+    itrb = that.itrb;
+    itre = that.itre;
+    last_vertex_ = that.last_vertex_;
+    is_hole_ = that.is_hole_;
+    multiplier_ = that.multiplier_;
+    first_pt = that.first_pt;
+    second_pt = that.second_pt;
+    pts[0] = that.pts[0];
+    pts[1] = that.pts[1];
+    pts[2] = that.pts[2];
+    use_wrap = that.use_wrap;
+    orient_ = that.orient_;
+    polygon_index = that.polygon_index;
+  }
+  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;
+    } else 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, bool = false, direction_1d = CLOCKWISE) : 
+    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;
+    }
+  }
+  iterator_geometry_to_set(const iterator_geometry_to_set& that) : 
+    itrb(), itre(), itrhib(), itrhie(), itrhb(), itrhe(), orient_(), is_hole_(), started_holes() {
+    itrb = that.itrb;
+    itre = that.itre;
+    if(that.itrhib != that.itrhie) {
+      itrhib = that.itrhib;
+      itrhie = that.itrhie;
+    }
+    itrhb = that.itrhb;
+    itrhe = that.itrhe;
+    orient_ = that.orient_;
+    is_hole_ = that.is_hole_;
+    started_holes = that.started_holes;
+  }
+  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 {
+          //in this case we have no holes so we just need the iterhib == itrhie, which
+          //is always true if they were default initialized in the initial case or
+          //both point to end of the previous hole processed
+          //no need to explicitly reset them, and it causes an stl debug assertion to use
+          //the default constructed iterator this way
+          //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 {
+            //this is the same case as above
+            //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
+

test/external/boost/polygon/detail/iterator_points_to_compact.hpp

@@ -0,0 +1,60 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_ITERATOR_POINTS_TO_COMPACT_HPP
+#define BOOST_POLYGON_ITERATOR_POINTS_TO_COMPACT_HPP
+namespace boost { namespace polygon{
+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_() {}
+  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
+

test/external/boost/polygon/detail/max_cover.hpp

@@ -0,0 +1,278 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_MAX_COVER_HPP
+#define BOOST_POLYGON_MAX_COVER_HPP
+namespace boost { namespace polygon{
+
+  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 nextRect1 = Rectangle(rectIvl, rectIvl);
+        Unit low = rect.get(orient.get_perpendicular()).low();
+        Unit high = node->rect.get(orient.get_perpendicular()).high();
+        nextRect1.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 nextRect2 = Rectangle(rectIvl, rectIvl);
+          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));
+          if(writeOut) {
+            //std::cout << "write out " << nextRect << std::endl;
+            outputContainer.push_back(copy_construct<typename cT::value_type, Rectangle>(nextRect2));
+          } 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 = nextRect1;
+          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,
+                                  std::size_t 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));
+      }
+      gtlsort(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(std::size_t i = 0; i < rects.size(); ++i) { nodes.push_back(Node(rects[i])); }
+      }
+      computeDag(nodes.begin(), nodes.end(), orient, nodes.size());
+      for(std::size_t i = 0; i < nodes.size(); ++i) {
+        getMaxCover(outputContainer, &(nodes[i]), orient);
+      }
+    }
+
+  };
+}
+}
+
+#endif

test/external/boost/polygon/detail/minkowski.hpp

@@ -0,0 +1,125 @@
+
+namespace boost { namespace polygon { namespace detail {
+
+template <typename coordinate_type>
+struct minkowski_offset {
+  typedef point_data<coordinate_type> point;
+  typedef polygon_set_data<coordinate_type> polygon_set;
+  typedef polygon_with_holes_data<coordinate_type> polygon;
+  typedef std::pair<point, point> edge;
+
+  static void convolve_two_segments(std::vector<point>& figure, const edge& a, const edge& b) {
+    figure.clear();
+    figure.push_back(point(a.first));
+    figure.push_back(point(a.first));
+    figure.push_back(point(a.second));
+    figure.push_back(point(a.second));
+    convolve(figure[0], b.second);
+    convolve(figure[1], b.first);
+    convolve(figure[2], b.first);
+    convolve(figure[3], b.second);
+  }
+
+  template <typename itrT1, typename itrT2>
+  static void convolve_two_point_sequences(polygon_set& result, itrT1 ab, itrT1 ae, itrT2 bb, itrT2 be) {
+    if(ab == ae || bb == be)
+      return;
+    point first_a = *ab;
+    point prev_a = *ab;
+    std::vector<point> vec;
+    polygon poly;
+    ++ab;
+    for( ; ab != ae; ++ab) {
+      point first_b = *bb;
+      point prev_b = *bb;
+      itrT2 tmpb = bb;
+      ++tmpb;
+      for( ; tmpb != be; ++tmpb) {
+        convolve_two_segments(vec, std::make_pair(prev_b, *tmpb), std::make_pair(prev_a, *ab));
+        set_points(poly, vec.begin(), vec.end());
+        result.insert(poly);
+        prev_b = *tmpb;
+      }
+      prev_a = *ab;
+    }
+  }
+
+  template <typename itrT>
+  static void convolve_point_sequence_with_polygons(polygon_set& result, itrT b, itrT e, const std::vector<polygon>& polygons) {
+    for(std::size_t i = 0; i < polygons.size(); ++i) {
+      convolve_two_point_sequences(result, b, e, begin_points(polygons[i]), end_points(polygons[i]));
+      for(typename polygon_with_holes_traits<polygon>::iterator_holes_type itrh = begin_holes(polygons[i]);
+          itrh != end_holes(polygons[i]); ++itrh) {
+        convolve_two_point_sequences(result, b, e, begin_points(*itrh), end_points(*itrh));
+      }
+    }
+  }
+
+  static void convolve_two_polygon_sets(polygon_set& result, const polygon_set& a, const polygon_set& b) {
+    result.clear();
+    std::vector<polygon> a_polygons;
+    std::vector<polygon> b_polygons;
+    a.get(a_polygons);
+    b.get(b_polygons);
+    for(std::size_t ai = 0; ai < a_polygons.size(); ++ai) {
+      convolve_point_sequence_with_polygons(result, begin_points(a_polygons[ai]), 
+                                            end_points(a_polygons[ai]), b_polygons);
+      for(typename polygon_with_holes_traits<polygon>::iterator_holes_type itrh = begin_holes(a_polygons[ai]);
+          itrh != end_holes(a_polygons[ai]); ++itrh) {
+        convolve_point_sequence_with_polygons(result, begin_points(*itrh), 
+                                              end_points(*itrh), b_polygons);
+      }
+      for(std::size_t bi = 0; bi < b_polygons.size(); ++bi) {
+        polygon tmp_poly = a_polygons[ai];
+        result.insert(convolve(tmp_poly, *(begin_points(b_polygons[bi]))));
+        tmp_poly = b_polygons[bi];
+        result.insert(convolve(tmp_poly, *(begin_points(a_polygons[ai]))));
+      }
+    }
+  }
+};
+
+}
+  template<typename T>
+  inline polygon_set_data<T>&
+  polygon_set_data<T>::resize(coordinate_type resizing, bool corner_fill_arc, unsigned int num_circle_segments) {
+    using namespace ::boost::polygon::operators;
+    if(!corner_fill_arc) {
+      if(resizing < 0)
+        return shrink(-resizing);
+      if(resizing > 0)
+        return bloat(resizing);
+      return *this;
+    }
+    if(resizing == 0) return *this;
+    if(empty()) return *this;
+    if(num_circle_segments < 3) num_circle_segments = 4;
+    rectangle_data<coordinate_type> rect;
+    extents(rect);
+    if(resizing < 0) {
+      ::boost::polygon::bloat(rect, 10);
+      (*this) = rect - (*this); //invert
+    }
+    //make_arc(std::vector<point_data< T> >& return_points,  
+    //point_data< double> start, point_data< double>  end,
+    //point_data< double> center,  double r, unsigned int num_circle_segments)      
+    std::vector<point_data<coordinate_type> > circle;
+    point_data<double> center(0.0, 0.0), start(0.0, (double)resizing);
+    make_arc(circle, start, start, center, std::abs((double)resizing),
+             num_circle_segments);
+    polygon_data<coordinate_type> poly;
+    set_points(poly, circle.begin(), circle.end());
+    polygon_set_data<coordinate_type> offset_set;
+    offset_set += poly;
+    polygon_set_data<coordinate_type> result;
+    detail::minkowski_offset<coordinate_type>::convolve_two_polygon_sets
+      (result, *this, offset_set);
+    if(resizing < 0) {
+      result = result & rect;//eliminate overhang
+      result = result ^ rect;//invert
+    }
+    *this = result;
+    return *this;
+  }
+
+}}

test/external/boost/polygon/detail/polygon_45_set_view.hpp

@@ -0,0 +1,378 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_45_SET_VIEW_HPP
+#define BOOST_POLYGON_POLYGON_45_SET_VIEW_HPP
+namespace boost { namespace polygon{
+
+  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_));
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
+      if(op_type == 0)
+        output_ |= rinput_;
+      else if(op_type == 1)
+        output_ &= rinput_;
+      else if(op_type == 2)
+        output_ ^= rinput_;
+      else
+        output_ -= rinput_;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
+    }
+  };
+
+  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_));
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
+      if(op_type == 0)
+        output_ |= rvalue_;
+      else if(op_type == 1)
+        output_ &= rvalue_;
+      else if(op_type == 2)
+        output_ ^= rvalue_;
+      else
+        output_ -= rvalue_;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
+    }
+  };
+
+  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_;
+
+    polygon_45_set_view& operator=(const polygon_45_set_view&);
+  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);
+    //       gtlsort(output_.begin(), output_.end());
+    //     }
+  };
+
+  template <typename ltype, typename rtype, int op_type>
+  typename polygon_45_set_traits<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_traits<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_));
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
+    if(op_type == 0)
+      output_ |= rinput_;
+    else if(op_type == 1)
+      output_ &= rinput_;
+    else if(op_type == 2)
+      output_ ^= rinput_;
+    else
+      output_ -= rinput_;
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
+    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; };
+
+  namespace operators {
+  struct y_ps45_b : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< y_ps45_b,
+    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);
+  }
+  
+  struct y_ps45_p : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< y_ps45_p,
+    typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type, 
+    typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type, 
+    typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type>::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);
+  }
+  
+  struct y_ps45_s : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< y_ps45_s, 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);
+  }
+
+  struct y_ps45_a : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< y_ps45_a, 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);
+  }
+
+  struct y_ps45_x : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< y_ps45_x, 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);
+  }
+  
+  struct y_ps45_m : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< y_ps45_m,
+    typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_1>::type>::type, 
+    typename gtl_if<typename is_polygon_45_or_90_set_type<geometry_type_2>::type>::type, 
+    typename gtl_if<typename is_either_polygon_45_set_type<geometry_type_1, geometry_type_2>::type>::type>::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);
+  }
+  
+  struct y_ps45_pe : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4<y_ps45_pe, typename is_mutable_polygon_45_set_type<geometry_type_1>::type, gtl_yes,
+                                         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);
+  }
+
+  struct y_ps45_be : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps45_be, 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);
+  }
+
+  struct y_ps45_se : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps45_se,
+    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);
+  }
+
+  struct y_ps45_ae : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps45_ae, 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);
+  }
+
+  struct y_ps45_xe : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_ps45_xe, 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);
+  }
+
+  struct y_ps45_me : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps45_me, 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);
+  }
+
+  struct y_ps45_rpe : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3< y_ps45_rpe, 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);
+  }
+
+  struct y_ps45_rme : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps45_rme, 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);
+  }
+
+  struct y_ps45_rp : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps45_rp, 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+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+    geometry_type_1 retval(lvalue);
+    retval += rvalue;
+    return retval;
+  }
+
+  struct y_ps45_rm : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps45_rm, 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-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+    geometry_type_1 retval(lvalue);
+    retval -= rvalue;
+    return retval;
+  }
+  }
+}
+}
+#endif
+

test/external/boost/polygon/detail/polygon_45_touch.hpp

@@ -0,0 +1,236 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_45_TOUCH_HPP
+#define BOOST_POLYGON_POLYGON_45_TOUCH_HPP
+namespace boost { namespace polygon{
+
+  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());
+      std::size_t i = 0;
+      std::size_t 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 , direction_1d ) {
+        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(std::size_t 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) {
+      
+      gtlsort(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];
+          }
+        }
+      }
+    }
+    
+  };
+
+
+}
+}
+#endif 

test/external/boost/polygon/detail/polygon_90_set_view.hpp

@@ -0,0 +1,491 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_SET_VIEW_HPP
+#define BOOST_POLYGON_POLYGON_90_SET_VIEW_HPP
+namespace boost { namespace polygon{
+  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_);
+        orientation_2d orient_l = polygon_90_set_traits<ltype>::orient(lvalue_);
+        orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
+        //std::cout << "compute_90_set_value-0 orientations (left, right, out):\t" << orient_l.to_int()
+        //        << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
+        insert_into_view_arg(linput_, lvalue_, orient_l);
+        insert_into_view_arg(rinput_, rvalue_, orient_r);
+        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_) {
+        orientation_2d orient_l = lvalue_.orient();
+        orientation_2d orient_r = rvalue_.orient();
+        value_type linput_(orient_);
+        value_type rinput_(orient_);
+        //std::cout << "compute_90_set_value-1 orientations (left, right, out):\t" << orient_l.to_int()
+        //          << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
+        if((orient_ == orient_l) && (orient_== orient_r)){ // assume that most of the time this condition is met
+          lvalue_.sort();
+          rvalue_.sort();
+          output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
+                                       rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>()); 
+        }else if((orient_ != orient_l) && (orient_!= orient_r)){ // both the orientations are not equal to input
+          // easier way is to ignore the input orientation and use the input data's orientation, but not done so
+          insert_into_view_arg(linput_, lvalue_, orient_l);
+          insert_into_view_arg(rinput_, rvalue_, orient_r);
+          output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
+                                       rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>()); 
+        }else if(orient_ != orient_l){ // left hand side orientation is different
+          insert_into_view_arg(linput_, lvalue_, orient_l);
+          rvalue_.sort();
+          output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
+                                       rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>()); 
+        } else if(orient_ != orient_r){ // right hand side orientation is different
+          insert_into_view_arg(rinput_, rvalue_, orient_r);
+          lvalue_.sort();
+          output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
+                                       rinput_.begin(), rinput_.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();
+         orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
+         //std::cout << "compute_90_set_value-2 orientations (right, out):\t" << orient_r.to_int()
+         //          << "," << orient_.to_int() << std::endl;
+         insert_into_view_arg(rinput_, rvalue_, orient_r);
+         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_);
+        orientation_2d orient_l = polygon_90_set_traits<ltype>::orient(lvalue_);
+        insert_into_view_arg(linput_, lvalue_, orient_l);
+        rvalue_.sort();
+        //std::cout << "compute_90_set_value-3 orientations (left, out):\t" << orient_l.to_int()
+        //          << "," << orient_.to_int() << std::endl;
+
+        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_;
+    polygon_90_set_view& operator=(const polygon_90_set_view&);
+  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);
+//       gtlsort(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_traits<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_traits<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_);
+      //BM: rvalue_ data set may have its own orientation for scanline
+      orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
+      //std::cout << "self-assignment boolean-op (left, right, out):\t" << orient_.to_int()
+      //          << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
+      value_type linput_(orient_);
+      // BM: the rinput_ set's (that stores the rvalue_ dataset  polygons) scanline orientation is *forced*
+      // to be same as linput
+      value_type rinput_(orient_);
+      //BM: The output dataset's scanline orient is set as equal to first input dataset's (lvalue_) orientation
+      value_type output_(orient_); 
+      insert_into_view_arg(linput_, lvalue_, orient_);
+      // BM: The last argument orient_r is the user initialized scanline orientation for rvalue_ data set.
+      // But since rinput (see above) is initialized to scanline orientation consistent with the lvalue_
+      // data set, this insertion operation will change the incoming rvalue_ dataset's scanline orientation
+      insert_into_view_arg(rinput_, rvalue_, orient_r);
+      // BM: boolean operation and output uses lvalue_ dataset's scanline orientation.
+      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_;
+    }
+  
+  namespace operators {
+  struct y_ps90_b : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_b,
+    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());
+  }
+  
+  struct y_ps90_p : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< 
+    typename gtl_and_3< y_ps90_p,
+      typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+      typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type>::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());
+  }
+  
+  struct y_ps90_s : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_s,
+    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());
+  }
+  
+  struct y_ps90_a : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_a,
+    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());
+  }
+
+  struct y_ps90_x : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_x,
+    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());
+  }
+  
+  struct y_ps90_m : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_m,
+    typename gtl_if<typename is_polygon_90_set_type<geometry_type_1>::type>::type,
+    typename gtl_if<typename is_polygon_90_set_type<geometry_type_2>::type>::type>::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());
+  }
+  
+  struct y_ps90_pe : gtl_yes {};
+
+  template <typename coordinate_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and< y_ps90_pe, typename is_polygon_90_set_type<geometry_type_2>::type>::type,
+                       polygon_90_set_data<coordinate_type_1> >::type &
+  operator+=(polygon_90_set_data<coordinate_type_1>& lvalue, const geometry_type_2& rvalue) {
+    lvalue.insert(polygon_90_set_traits<geometry_type_2>::begin(rvalue), polygon_90_set_traits<geometry_type_2>::end(rvalue),
+                  polygon_90_set_traits<geometry_type_2>::orient(rvalue));
+    return lvalue;
+  }
+  
+  struct y_ps90_be : gtl_yes {};
+  //
+  template <typename coordinate_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and< y_ps90_be, typename is_polygon_90_set_type<geometry_type_2>::type>::type, 
+                       polygon_90_set_data<coordinate_type_1> >::type &
+  operator|=(polygon_90_set_data<coordinate_type_1>& lvalue, const geometry_type_2& rvalue) {
+    return lvalue += rvalue;
+  }
+
+  struct y_ps90_pe2 : gtl_yes {};
+
+  //normal self assignment boolean operations
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_pe2, 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);
+  }
+
+  struct y_ps90_be2 : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps90_be2, 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);
+  }
+
+  struct y_ps90_se : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps90_se, 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);
+  }
+ 
+  struct y_ps90_ae : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps90_ae, 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);
+  }
+
+  struct y_ps90_xe : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3<y_ps90_xe, 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);
+  }
+
+  struct y_ps90_me : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< y_ps90_me, 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);
+  }
+
+  struct y_ps90_rpe : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps90_rpe,
+    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);
+  }
+
+  struct y_ps90_rme : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps90_rme,
+    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);
+  }
+
+  struct y_ps90_rp : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps90_rp,
+    typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type, 
+    typename gtl_if<typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>::type>::type,
+  geometry_type_1>::type
+  operator+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+    geometry_type_1 retval(lvalue);
+    retval += rvalue;
+    return retval;
+  }
+
+  struct y_ps90_rm : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps90_rm,
+    typename gtl_if<typename is_mutable_polygon_90_set_type<geometry_type_1>::type>::type, 
+    typename gtl_if<typename gtl_same_type<typename geometry_concept<coordinate_type_1>::type, coordinate_concept>::type>::type>::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
+

test/external/boost/polygon/detail/polygon_90_touch.hpp

@@ -0,0 +1,418 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_TOUCH_HPP
+#define BOOST_POLYGON_POLYGON_90_TOUCH_HPP
+namespace boost { namespace polygon{
+
+  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_;
+        bool incremented_;
+      public:
+        inline iterator() : itr_(), ivlIds_(), incremented_(false) {}
+        inline iterator(typename EventData::const_iterator itr, 
+                        Unit prevPos, Unit curPos, const std::set<int>& ivlIds) : itr_(itr), ivlIds_(), incremented_(false) {
+          ivlIds_.second = ivlIds;
+          ivlIds_.first = Interval(prevPos, curPos);
+        }
+        inline iterator(const iterator& that) : itr_(), ivlIds_(), incremented_(false) { (*this) = that; }
+        inline iterator& operator=(const iterator& that) {
+          itr_ = that.itr_;
+          ivlIds_.first = that.ivlIds_.first;
+          ivlIds_.second = that.ivlIds_.second;
+          incremented_ = that.incremented_;
+          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);
+          incremented_ = true;
+          return *this;
+        }
+        inline const iterator operator++(int){
+          iterator tmpItr(*this);
+          ++(*this);
+          return tmpItr;
+        }
+        inline std::pair<Interval, std::set<int> >& operator*() { 
+          if(incremented_) ivlIds_.first = Interval(ivlIds_.first.get(HIGH), itr_->first);
+          incremented_ = false;
+          if(ivlIds_.second.empty())(++(*this));
+          if(incremented_) ivlIds_.first = Interval(ivlIds_.first.get(HIGH), itr_->first);
+          incremented_ = false;
+          return ivlIds_; }
+      };
+
+      inline TouchScanEvent() : eventData_() {}
+      template<class iT>
+      inline TouchScanEvent(iT begin, iT end) : eventData_() {
+        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, itr->first, idr);
+      }
+   
+      //Get the end iterator over event data
+      inline iterator end() const { return iterator(eventData_.end(), 0, 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
+      template <typename graphT>
+      inline void processInterval(graphT& 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));
+      }
+
+      template <typename graphT>
+      inline void evaluateInterval_(graphT& 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);
+        }
+      }
+      template <typename graphT>
+      inline void evaluateBorder_(graphT& 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);
+        }
+      }
+      template <typename graphT>
+      inline void evaluateBorderId_(graphT& 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);
+          }
+        }
+      }
+      template <typename graphT>
+      inline void evaluateId_(graphT& 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);
+          }
+        }
+      }
+    };
+
+    template <typename graphT>
+    static inline void processEvent(graphT& 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);
+      }
+    }
+
+    template <typename graphT>
+    static inline void performTouch(graphT& 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

test/external/boost/polygon/detail/polygon_set_view.hpp

@@ -0,0 +1,213 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_SET_VIEW_HPP
+#define BOOST_POLYGON_POLYGON_SET_VIEW_HPP
+namespace boost { namespace polygon{
+  
+  
+  template <typename coordinate_type>
+  inline void polygon_set_data<coordinate_type>::clean() const {
+    if(dirty_) {
+      polygon_45_set_data<coordinate_type> tmp;
+      //very important:
+      //the 45 degree algorithm does not satisfy
+      //the precondition of arbitrary polygon formation
+      //that vertices be "linearly consistent"
+      //therefore it doesn't work to fall back on 45-degree
+      //booleans for arbitrary angle polygons
+      if(0) { //downcast(tmp) ) {
+        tmp.clean();
+        data_.clear();
+        is_45_ = true;
+        polygon_set_data<coordinate_type> tmp2;
+        tmp2.insert(tmp);
+        data_.swap(tmp2.data_);
+        dirty_ = false;
+        sort();
+      } else {
+        sort();
+        arbitrary_boolean_op<coordinate_type> abo;
+        polygon_set_data<coordinate_type> tmp2;
+        abo.execute(tmp2, begin(), end(), end(), end(), 0);
+        data_.swap(tmp2.data_);
+        is_45_ = tmp2.is_45_;
+        dirty_ = false;
+      }
+    }
+  }
+
+  template <>
+  inline void polygon_set_data<double>::clean() const {
+    if(dirty_) {
+      sort();
+      arbitrary_boolean_op<double> abo;
+      polygon_set_data<double> tmp2;
+      abo.execute(tmp2, begin(), end(), end(), end(), 0);
+      data_.swap(tmp2.data_);
+      is_45_ = tmp2.is_45_;
+      dirty_ = false;
+    }
+  }
+
+  template <typename value_type, typename arg_type>
+  inline void insert_into_view_arg(value_type& dest, const arg_type& arg);
+
+  template <typename ltype, typename rtype, int op_type>
+  class polygon_set_view;
+
+  template <typename ltype, typename rtype, int op_type>
+  struct polygon_set_traits<polygon_set_view<ltype, rtype, op_type> > {
+    typedef typename polygon_set_view<ltype, rtype, op_type>::coordinate_type coordinate_type;
+    typedef typename polygon_set_view<ltype, rtype, op_type>::iterator_type iterator_type;
+    typedef typename polygon_set_view<ltype, rtype, op_type>::operator_arg_type operator_arg_type;
+
+    static inline iterator_type begin(const polygon_set_view<ltype, rtype, op_type>& polygon_set); 
+    static inline iterator_type end(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
+
+    static inline bool clean(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
+
+    static inline bool sort(const polygon_set_view<ltype, rtype, op_type>& polygon_set);
+  };
+
+  //template <typename value_type, typename geometry_type_1, typename geometry_type_2, int op_type>
+  //void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_,
+  //                        double coord) {
+  //  typedef geometry_type_1 ltype;
+  //  typedef geometry_type_2 rtype;
+  //  typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+  //  value_type linput_;
+  //  value_type rinput_;
+  //  insert_into_view_arg(linput_, lvalue_);
+  //  insert_into_view_arg(rinput_, rvalue_);
+  //  arbitrary_boolean_op<coordinate_type> abo;
+  //  abo.execute(output_, linput_.begin(), linput_.end(),
+  //              rinput_.begin(), rinput_.end(), op_type);
+  //}
+
+  template <typename value_type, typename geometry_type_1, typename geometry_type_2, int op_type>
+  void execute_boolean_op(value_type& output_, const geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
+    typedef geometry_type_1 ltype;
+    typedef geometry_type_2 rtype;
+    typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+    value_type linput_;
+    value_type rinput_;
+    insert_into_view_arg(linput_, lvalue_);
+    insert_into_view_arg(rinput_, rvalue_);
+    polygon_45_set_data<coordinate_type> l45, r45, o45;
+    if(linput_.downcast(l45) && rinput_.downcast(r45)) {
+      //the op codes are screwed up between 45 and arbitrary
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (disable: 4127)
+#endif
+      if(op_type < 2)
+        l45.template applyAdaptiveBoolean_<op_type>(o45, r45);
+      else if(op_type == 2)
+        l45.template applyAdaptiveBoolean_<3>(o45, r45);
+      else
+        l45.template applyAdaptiveBoolean_<2>(o45, r45);
+#ifdef BOOST_POLYGON_MSVC
+#pragma warning (default: 4127)
+#endif
+      output_.insert(o45);
+    } else {
+      arbitrary_boolean_op<coordinate_type> abo;
+      abo.execute(output_, linput_.begin(), linput_.end(),
+                  rinput_.begin(), rinput_.end(), op_type);
+    }
+  }
+
+  template <typename ltype, typename rtype, int op_type>
+  class polygon_set_view {
+  public:
+    typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+    typedef polygon_set_data<coordinate_type> value_type;
+    typedef typename value_type::iterator_type iterator_type;
+    typedef polygon_set_view operator_arg_type;
+  private:
+    const ltype& lvalue_;
+    const rtype& rvalue_;
+    mutable value_type output_;
+    mutable bool evaluated_;
+    polygon_set_view& operator=(const polygon_set_view&);
+  public:
+    polygon_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;
+        execute_boolean_op<value_type, ltype, rtype, op_type>(output_, lvalue_, rvalue_);
+      }
+      return output_;
+    }
+  public:
+    iterator_type begin() const { return value().begin(); }
+    iterator_type end() const { return value().end(); }
+
+    bool dirty() const { return false; } //result of a boolean is clean
+    bool sorted() const { return true; } //result of a boolean is sorted
+
+    void sort() const {} //is always sorted
+  };
+
+  template <typename ltype, typename rtype, int op_type>
+  typename polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::iterator_type
+  polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+  begin(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
+    return polygon_set.begin();
+  }
+  template <typename ltype, typename rtype, int op_type>
+  typename polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::iterator_type
+  polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+  end(const polygon_set_view<ltype, rtype, op_type>& polygon_set) {
+    return polygon_set.end();
+  }
+  template <typename ltype, typename rtype, int op_type>
+  bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+  clean(const polygon_set_view<ltype, rtype, op_type>& ) { 
+    return true; }
+  template <typename ltype, typename rtype, int op_type>
+  bool polygon_set_traits<polygon_set_view<ltype, rtype, op_type> >::
+  sort(const polygon_set_view<ltype, rtype, op_type>& ) { 
+    return true; }
+
+  template <typename value_type, typename arg_type>
+  inline void insert_into_view_arg(value_type& dest, const arg_type& arg) {
+    typedef typename polygon_set_traits<arg_type>::iterator_type literator;
+    literator itr1, itr2;
+    itr1 = polygon_set_traits<arg_type>::begin(arg);
+    itr2 = polygon_set_traits<arg_type>::end(arg);
+    dest.insert(itr1, itr2);
+  }
+  
+  template <typename geometry_type_1, typename geometry_type_2, int op_type>
+  geometry_type_1& self_assignment_boolean_op(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
+    typedef geometry_type_1 ltype;
+    typedef typename polygon_set_traits<ltype>::coordinate_type coordinate_type;
+    typedef polygon_set_data<coordinate_type> value_type;
+    value_type output_;
+    execute_boolean_op<value_type, geometry_type_1, geometry_type_2, op_type>(output_, lvalue_, rvalue_);
+    polygon_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end());
+    return lvalue_;
+  }
+
+  // copy constructor
+  template <typename coordinate_type>
+  template <typename ltype, typename rtype, int op_type> 
+  polygon_set_data<coordinate_type>::polygon_set_data(const polygon_set_view<ltype, rtype, op_type>& that) :
+    data_(that.value().data_), dirty_(that.value().dirty_), unsorted_(that.value().unsorted_), is_45_(that.value().is_45_) {}
+
+  template <typename ltype, typename rtype, int op_type>
+  struct geometry_concept<polygon_set_view<ltype, rtype, op_type> > { typedef polygon_set_concept type; };
+}
+}
+#endif
+

test/external/boost/polygon/detail/polygon_simplify.hpp

@@ -0,0 +1,116 @@
+// Copyright 2011, Andrew Ross
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+#ifndef BOOST_POLYGON_DETAIL_SIMPLIFY_HPP
+#define BOOST_POLYGON_DETAIL_SIMPLIFY_HPP
+#include <vector>
+
+namespace boost { namespace polygon { namespace detail { namespace simplify_detail {
+  
+  // Does a simplification/optimization pass on the polygon.  If a given
+  // vertex lies within "len" of the line segment joining its neighbor
+  // vertices, it is removed.
+  template <typename T> //T is a model of point concept
+  std::size_t simplify(std::vector<T>& dst, const std::vector<T>& src, 
+                       typename coordinate_traits<
+                       typename point_traits<T>::coordinate_type
+                       >::coordinate_distance len)
+  {
+    using namespace boost::polygon;
+    typedef typename point_traits<T>::coordinate_type coordinate_type;
+    typedef typename coordinate_traits<coordinate_type>::area_type ftype; 
+    typedef typename std::vector<T>::const_iterator iter;
+
+    std::vector<T> out;
+    out.reserve(src.size());
+    dst = src;
+    std::size_t final_result = 0;
+    std::size_t orig_size = src.size();
+
+    //I can't use == if T doesn't provide it, so use generic point concept compare
+    bool closed = equivalence(src.front(), src.back());
+
+    //we need to keep smoothing until we don't find points to remove
+    //because removing points in the first iteration through the 
+    //polygon may leave it in a state where more removal is possible
+    bool not_done = true;
+    while(not_done) {
+      if(dst.size() < 3) {
+        dst.clear();
+        return orig_size;
+      }
+      
+      // Start with the second, test for the last point
+      // explicitly, and exit after looping back around to the first.
+      ftype len2 = ftype(len) * ftype(len);
+      for(iter prev=dst.begin(), i=prev+1, next; /**/; i = next) {
+        next = i+1;
+        if(next == dst.end())
+          next = dst.begin();
+        
+        // points A, B, C
+        ftype ax = x(*prev), ay = y(*prev);
+        ftype bx = x(*i), by = y(*i);
+        ftype cx = x(*next), cy = y(*next);
+        
+        // vectors AB, BC and AC:
+        ftype abx = bx-ax, aby = by-ay;
+        ftype bcx = cx-bx, bcy = cy-by;
+        ftype acx = cx-ax, acy = cy-ay;
+        
+        // dot products
+        ftype ab_ab = abx*abx + aby*aby;
+        ftype bc_bc = bcx*bcx + bcy*bcy;
+        ftype ac_ac = acx*acx + acy*acy;
+        ftype ab_ac = abx*acx + aby*acy;
+        
+        // projection of AB along AC
+        ftype projf = ab_ac / ac_ac;
+        ftype projx = acx * projf, projy = acy * projf;
+        
+        // perpendicular vector from the line AC to point B (i.e. AB - proj)
+        ftype perpx = abx - projx, perpy = aby - projy;
+        
+        // Squared fractional distance of projection. FIXME: can
+        // remove this division, the decisions below can be made with
+        // just the sign of the quotient and a check to see if
+        // abs(numerator) is greater than abs(divisor).
+        ftype f2 = (projx*acx + projy*acx) / ac_ac;
+        
+        // Square of the relevant distance from point B:
+        ftype dist2;
+        if     (f2 < 0) dist2 = ab_ab;
+        else if(f2 > 1) dist2 = bc_bc;
+        else            dist2 = perpx*perpx + perpy*perpy;
+        
+        if(dist2 > len2) {
+          prev = i; // bump prev, we didn't remove the segment
+          out.push_back(*i);
+        }
+        
+        if(i == dst.begin())
+          break;
+      }
+      std::size_t result = dst.size() - out.size();
+      if(result == 0) {
+        not_done = false;
+      } else {
+        final_result += result;
+        dst = out;
+        out.clear();
+      }
+    } //end of while loop
+    if(closed) {
+      //if the input was closed we want the output to be closed
+      --final_result;
+      dst.push_back(dst.front());
+    }
+    return final_result;
+  }
+
+
+}}}}
+
+#endif

test/external/boost/polygon/detail/polygon_sort_adaptor.hpp

@@ -0,0 +1,67 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_SORT_ADAPTOR_HPP
+#define BOOST_POLYGON_SORT_ADAPTOR_HPP
+#ifdef __ICC
+#pragma warning(disable:2022)
+#pragma warning(disable:2023)
+#endif
+
+#include <algorithm>
+
+//! @brief gtlsort_adaptor default implementation that calls std::sort
+namespace boost {
+  namespace polygon {
+
+    template<typename iterator_type>
+    struct dummy_to_delay_instantiation{
+      typedef int unit_type; // default GTL unit 
+    };
+
+    //! @brief gtlsort_adaptor default implementation that calls std::sort
+    template<typename T>
+    struct gtlsort_adaptor {
+      //! @brief wrapper that mimics std::sort() function and takes
+      // the same arguments
+      template<typename RandomAccessIterator_Type>
+      static void sort(RandomAccessIterator_Type _First, 
+                       RandomAccessIterator_Type _Last)
+      {
+         std::sort(_First, _Last);
+      }
+      //! @brief wrapper that mimics std::sort() function overload and takes
+      // the same arguments
+      template<typename RandomAccessIterator_Type, typename Pred_Type>
+      static void sort(RandomAccessIterator_Type _First, 
+                       RandomAccessIterator_Type _Last, 
+                       const Pred_Type& _Comp)
+      {
+         std::sort(_First, _Last, _Comp);
+      }
+    };
+
+    //! @brief user level wrapper for sorting quantities 
+    template <typename iter_type>
+    void gtlsort(iter_type _b_, iter_type _e_) 
+    {
+      gtlsort_adaptor<typename dummy_to_delay_instantiation<iter_type>::unit_type>::sort(_b_, _e_);
+    }
+
+    //! @brief user level wrapper for sorting quantities that takes predicate
+    // as additional argument
+    template <typename iter_type, typename pred_type>
+    void gtlsort(iter_type _b_, iter_type _e_, const pred_type& _pred_) 
+    {
+      gtlsort_adaptor<typename dummy_to_delay_instantiation<iter_type>::unit_type>::sort(_b_, _e_, _pred_);
+    }
+
+
+    
+  } // namespace polygon
+}   // namespace boost 
+#endif

test/external/boost/polygon/detail/property_merge.hpp

@@ -0,0 +1,588 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_PROPERTY_MERGE_HPP
+#define BOOST_POLYGON_PROPERTY_MERGE_HPP
+namespace boost { namespace polygon{
+
+template <typename coordinate_type>
+class property_merge_point {
+private:
+  coordinate_type x_, y_;
+public:
+  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_; }
+  inline bool operator!=(const property_merge_point& that) const { return !((*this) == that); }
+  inline bool operator<(const property_merge_point& that) const {
+    if(x_ < that.x_) return true;
+    if(x_ > that.x_) return false;
+    return y_ < that.y_;
+  }
+  inline coordinate_type x() const { return x_; }
+  inline coordinate_type y() const { return y_; }
+  inline void x(coordinate_type value) { x_ = value; }
+  inline void y(coordinate_type value) { y_ = value; }
+};
+
+template <typename coordinate_type>
+class property_merge_interval {
+private:
+  coordinate_type low_, high_;
+public:
+  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_; }
+  inline bool operator!=(const property_merge_interval& that) const { return !((*this) == that); }
+  inline bool operator<(const property_merge_interval& that) const {
+    if(low_ < that.low_) return true;
+    if(low_ > that.low_) return false;
+    return high_ < that.high_;
+  }
+  inline coordinate_type low() const { return low_; }
+  inline coordinate_type high() const { return high_; }
+  inline void low(coordinate_type value) { low_ = value; }
+  inline void high(coordinate_type value) { high_ = value; }
+};
+
+template <typename coordinate_type, typename property_type, typename polygon_set_type, typename keytype = std::set<property_type> >
+class merge_scanline {
+public:
+  //definitions
+
+  typedef keytype property_set;
+  typedef std::vector<std::pair<property_type, int> > property_map;
+  typedef std::pair<property_merge_point<coordinate_type>, std::pair<property_type, int> > vertex_property;
+  typedef std::pair<property_merge_point<coordinate_type>, property_map> vertex_data;
+  typedef std::vector<vertex_property> property_merge_data;
+  //typedef std::map<property_set, polygon_set_type> Result;
+  typedef std::map<coordinate_type, property_map> scanline_type;
+  typedef typename scanline_type::iterator scanline_iterator;
+  typedef std::pair<property_merge_interval<coordinate_type>, std::pair<property_set, property_set> > edge_property;
+  typedef std::vector<edge_property> edge_property_vector;
+
+  //static public member functions
+
+  template <typename iT, typename orientation_2d_type>
+  static inline void 
+  populate_property_merge_data(property_merge_data& pmd, iT input_begin, iT input_end, 
+                               const property_type& property, orientation_2d_type orient) {
+    for( ; input_begin != input_end; ++input_begin) {
+      std::pair<property_merge_point<coordinate_type>, std::pair<property_type, int> > element;
+      if(orient == HORIZONTAL)
+        element.first = property_merge_point<coordinate_type>((*input_begin).second.first, (*input_begin).first);
+      else
+        element.first = property_merge_point<coordinate_type>((*input_begin).first, (*input_begin).second.first);
+      element.second.first = property;
+      element.second.second = (*input_begin).second.second;
+      pmd.push_back(element);
+    }
+  }
+
+  //public member functions
+
+  merge_scanline() : output(), scanline(), currentVertex(), tmpVector(), previousY(), countFromBelow(), scanlinePosition() {}
+  merge_scanline(const merge_scanline& that) :
+    output(that.output),
+    scanline(that.scanline),
+    currentVertex(that.currentVertex),
+    tmpVector(that.tmpVector),
+    previousY(that.previousY),
+    countFromBelow(that.countFromBelow),
+    scanlinePosition(that.scanlinePosition)
+  {}
+  merge_scanline& operator=(const merge_scanline& that) {
+    output = that.output;
+    scanline = that.scanline;
+    currentVertex = that.currentVertex;
+    tmpVector = that.tmpVector;
+    previousY = that.previousY;
+    countFromBelow = that.countFromBelow;
+    scanlinePosition = that.scanlinePosition;
+    return *this;
+  }
+
+  template <typename result_type>
+  inline void perform_merge(result_type& result, property_merge_data& data) {
+    if(data.empty()) return;
+    //sort
+    gtlsort(data.begin(), data.end(), less_vertex_data<vertex_property>());
+    //scanline
+    bool firstIteration = true;
+    scanlinePosition = scanline.end();
+    for(std::size_t i = 0; i < data.size(); ++i) {
+      if(firstIteration) {
+        mergeProperty(currentVertex.second, data[i].second);
+        currentVertex.first = data[i].first;
+        firstIteration = false;
+      } else {
+        if(data[i].first != currentVertex.first) {
+          if(data[i].first.x() != currentVertex.first.x()) {
+            processVertex(output);
+            //std::cout << scanline.size() << " ";
+            countFromBelow.clear(); //should already be clear
+            writeOutput(currentVertex.first.x(), result, output);
+            currentVertex.second.clear();
+            mergeProperty(currentVertex.second, data[i].second);
+            currentVertex.first = data[i].first;
+            //std::cout << assertRedundant(scanline) << "/" << scanline.size() << " ";
+          } else {
+            processVertex(output);
+            currentVertex.second.clear();
+            mergeProperty(currentVertex.second, data[i].second);
+            currentVertex.first = data[i].first;
+          }
+        } else {
+          mergeProperty(currentVertex.second, data[i].second);
+        }
+      }
+    }
+    processVertex(output);
+    writeOutput(currentVertex.first.x(), result, output);
+    //std::cout << assertRedundant(scanline) << "/" << scanline.size() << "\n";
+    //std::cout << scanline.size() << "\n";
+  }
+
+private:
+  //private supporting types
+
+  template <class T>
+  class less_vertex_data {
+  public:
+    less_vertex_data() {}
+    bool operator()(const T& lvalue, const T& rvalue) const {
+      if(lvalue.first.x() < rvalue.first.x()) return true;
+      if(lvalue.first.x() > rvalue.first.x()) return false;
+      if(lvalue.first.y() < rvalue.first.y()) return true;
+      return false;
+    }
+  };
+
+  template <typename T>
+  struct lessPropertyCount {
+    lessPropertyCount() {}
+    bool operator()(const T& a, const T& b) {
+      return a.first < b.first;
+    }
+  };
+
+  //private static member functions
+
+  static inline void mergeProperty(property_map& lvalue, std::pair<property_type, int>& rvalue) {
+    typename property_map::iterator itr = std::lower_bound(lvalue.begin(), lvalue.end(), rvalue, 
+                                                          lessPropertyCount<std::pair<property_type, int> >());
+    if(itr == lvalue.end() ||
+       (*itr).first != rvalue.first) {
+      lvalue.insert(itr, rvalue);
+    } else {
+      (*itr).second += rvalue.second;
+      if((*itr).second == 0)
+        lvalue.erase(itr);
+    }
+//     if(assertSorted(lvalue)) {
+//       std::cout << "in mergeProperty\n";
+//       exit(0);
+//     }
+  }
+
+//   static inline bool assertSorted(property_map& pset) {
+//     bool result = false;
+//     for(std::size_t i = 1; i < pset.size(); ++i) {
+//       if(pset[i] < pset[i-1]) {
+//         std::cout << "Out of Order Error ";
+//         result = true;
+//       }
+//       if(pset[i].first == pset[i-1].first) {
+//         std::cout << "Duplicate Property Error ";
+//         result = true;
+//       }
+//       if(pset[0].second == 0 || pset[1].second == 0) {
+//         std::cout << "Empty Property Error ";
+//         result = true;
+//       }
+//     }
+//     return result;
+//   }
+
+  static inline void setProperty(property_set& pset, property_map& pmap) {
+    for(typename property_map::iterator itr = pmap.begin(); itr != pmap.end(); ++itr) {
+      if((*itr).second > 0) {
+        pset.insert(pset.end(), (*itr).first);
+      }
+    }
+  }
+
+  //private data members
+
+  edge_property_vector output;
+  scanline_type scanline;
+  vertex_data currentVertex;
+  property_map tmpVector;
+  coordinate_type previousY;
+  property_map countFromBelow;
+  scanline_iterator scanlinePosition;
+
+  //private member functions
+
+  inline void mergeCount(property_map& lvalue, property_map& rvalue) {
+    typename property_map::iterator litr = lvalue.begin();
+    typename property_map::iterator ritr = rvalue.begin();
+    tmpVector.clear();
+    while(litr != lvalue.end() && ritr != rvalue.end()) {
+      if((*litr).first <= (*ritr).first) {
+        if(!tmpVector.empty() &&
+           (*litr).first == tmpVector.back().first) {
+          tmpVector.back().second += (*litr).second;
+        } else {
+          tmpVector.push_back(*litr);
+        }
+        ++litr;
+      } else if((*ritr).first <= (*litr).first) {
+        if(!tmpVector.empty() &&
+           (*ritr).first == tmpVector.back().first) {
+          tmpVector.back().second += (*ritr).second;
+        } else {
+          tmpVector.push_back(*ritr);
+        }
+        ++ritr;
+      }
+    }
+    while(litr != lvalue.end()) {
+      if(!tmpVector.empty() &&
+         (*litr).first == tmpVector.back().first) {
+        tmpVector.back().second += (*litr).second;
+      } else {
+        tmpVector.push_back(*litr);
+      }
+      ++litr;
+    }
+    while(ritr != rvalue.end()) {
+      if(!tmpVector.empty() &&
+         (*ritr).first == tmpVector.back().first) {
+        tmpVector.back().second += (*ritr).second;
+      } else {
+        tmpVector.push_back(*ritr);
+      }
+      ++ritr;
+    }
+    lvalue.clear();
+    for(std::size_t i = 0; i < tmpVector.size(); ++i) {
+      if(tmpVector[i].second != 0) {
+        lvalue.push_back(tmpVector[i]);
+      }
+    }
+//     if(assertSorted(lvalue)) {
+//       std::cout << "in mergeCount\n";
+//       exit(0);
+//     }
+  }
+
+  inline void processVertex(edge_property_vector& output) {
+    if(!countFromBelow.empty()) {
+      //we are processing an interval of change in scanline state between
+      //previous vertex position and current vertex position where 
+      //count from below represents the change on the interval
+      //foreach scanline element from previous to current we
+      //write the interval on the scanline that is changing
+      //the old value and the new value to output
+      property_merge_interval<coordinate_type> currentInterval(previousY, currentVertex.first.y());
+      coordinate_type currentY = currentInterval.low();
+      if(scanlinePosition == scanline.end() ||
+         (*scanlinePosition).first != previousY) {
+        scanlinePosition = scanline.lower_bound(previousY);
+      }
+      scanline_iterator previousScanlinePosition = scanlinePosition;
+      ++scanlinePosition;
+      while(scanlinePosition != scanline.end()) {
+        coordinate_type elementY = (*scanlinePosition).first;
+        if(elementY <= currentInterval.high()) {
+          property_map& countOnLeft = (*previousScanlinePosition).second;
+          edge_property element;
+          output.push_back(element);
+          output.back().first = property_merge_interval<coordinate_type>((*previousScanlinePosition).first, elementY);
+          setProperty(output.back().second.first, countOnLeft);
+          mergeCount(countOnLeft, countFromBelow);
+          setProperty(output.back().second.second, countOnLeft);
+          if(output.back().second.first == output.back().second.second) {
+            output.pop_back(); //it was an internal vertical edge, not to be output
+          }
+          else if(output.size() > 1) {
+            edge_property& secondToLast = output[output.size()-2];
+            if(secondToLast.first.high() == output.back().first.low() &&
+               secondToLast.second.first == output.back().second.first &&
+               secondToLast.second.second == output.back().second.second) {
+              //merge output onto previous output because properties are
+              //identical on both sides implying an internal horizontal edge
+              secondToLast.first.high(output.back().first.high());
+              output.pop_back();
+            }
+          }
+          if(previousScanlinePosition == scanline.begin()) {
+            if(countOnLeft.empty()) {
+              scanline.erase(previousScanlinePosition);
+            }
+          } else {
+            scanline_iterator tmpitr = previousScanlinePosition;
+            --tmpitr;
+            if((*tmpitr).second == (*previousScanlinePosition).second)
+              scanline.erase(previousScanlinePosition);
+          }
+             
+        } else if(currentY < currentInterval.high()){
+          //elementY > currentInterval.high()
+          //split the interval between previous and current scanline elements
+          std::pair<coordinate_type, property_map> elementScan;
+          elementScan.first = currentInterval.high();
+          elementScan.second = (*previousScanlinePosition).second;
+          scanlinePosition = scanline.insert(scanlinePosition, elementScan);
+          continue;
+        } else {
+          break;
+        }
+        previousScanlinePosition = scanlinePosition;
+        currentY = previousY = elementY;
+        ++scanlinePosition;
+        if(scanlinePosition == scanline.end() &&
+           currentY < currentInterval.high()) {
+          //insert a new element for top of range
+          std::pair<coordinate_type, property_map> elementScan;
+          elementScan.first = currentInterval.high();
+          scanlinePosition = scanline.insert(scanline.end(), elementScan);
+        } 
+      }
+      if(scanlinePosition == scanline.end() &&
+         currentY < currentInterval.high()) {
+        //handle case where we iterated to end of the scanline
+        //we need to insert an element into the scanline at currentY
+        //with property value coming from below
+        //and another one at currentInterval.high() with empty property value
+        mergeCount(scanline[currentY], countFromBelow);
+        std::pair<coordinate_type, property_map> elementScan;
+        elementScan.first = currentInterval.high();
+        scanline.insert(scanline.end(), elementScan);
+
+        edge_property element;
+        output.push_back(element);
+        output.back().first = property_merge_interval<coordinate_type>(currentY, currentInterval.high());
+        setProperty(output.back().second.second, countFromBelow);
+        mergeCount(countFromBelow, currentVertex.second);
+      } else {
+        mergeCount(countFromBelow, currentVertex.second);
+        if(countFromBelow.empty()) {
+          if(previousScanlinePosition == scanline.begin()) {
+            if((*previousScanlinePosition).second.empty()) {
+              scanline.erase(previousScanlinePosition);
+              //previousScanlinePosition = scanline.end();
+              //std::cout << "ERASE_A ";
+            }
+          } else {
+            scanline_iterator tmpitr = previousScanlinePosition;
+            --tmpitr;
+            if((*tmpitr).second == (*previousScanlinePosition).second) {
+              scanline.erase(previousScanlinePosition);
+              //previousScanlinePosition = scanline.end();
+              //std::cout << "ERASE_B ";
+            }
+          }
+        }
+      }
+    } else {
+      //count from below is empty, we are starting a new interval of change
+      countFromBelow = currentVertex.second;
+      scanlinePosition = scanline.lower_bound(currentVertex.first.y());
+      if(scanlinePosition != scanline.end()) {
+        if((*scanlinePosition).first != currentVertex.first.y()) {
+          if(scanlinePosition != scanline.begin()) {
+            //decrement to get the lower position of the first interval this vertex intersects
+            --scanlinePosition;
+            //insert a new element into the scanline for the incoming vertex
+            property_map& countOnLeft = (*scanlinePosition).second;
+            std::pair<coordinate_type, property_map> element(currentVertex.first.y(), countOnLeft);
+            scanlinePosition = scanline.insert(scanlinePosition, element);
+          } else {
+            property_map countOnLeft;
+            std::pair<coordinate_type, property_map> element(currentVertex.first.y(), countOnLeft);
+            scanlinePosition = scanline.insert(scanlinePosition, element);
+          }
+        }
+      } else {
+        property_map countOnLeft;
+        std::pair<coordinate_type, property_map> element(currentVertex.first.y(), countOnLeft);
+        scanlinePosition = scanline.insert(scanlinePosition, element);
+      }
+    }
+    previousY = currentVertex.first.y();
+  }
+
+  template <typename T>
+  inline int assertRedundant(T& t) {
+    if(t.empty()) return 0;
+    int count = 0; 
+    typename T::iterator itr = t.begin();
+    if((*itr).second.empty())
+      ++count;
+    typename T::iterator itr2 = itr;
+    ++itr2;
+    while(itr2 != t.end()) {
+      if((*itr).second == (*itr2).second)
+        ++count;
+      itr = itr2;
+      ++itr2;
+    }
+    return count;
+  }
+
+  template <typename T>
+  inline void performExtract(T& result, property_merge_data& data) {
+    if(data.empty()) return;
+    //sort
+    gtlsort(data.begin(), data.end(), less_vertex_data<vertex_property>());
+    
+    //scanline
+    bool firstIteration = true;
+    scanlinePosition = scanline.end();
+    for(std::size_t i = 0; i < data.size(); ++i) {
+      if(firstIteration) {
+        mergeProperty(currentVertex.second, data[i].second);
+        currentVertex.first = data[i].first;
+        firstIteration = false;
+      } else {
+        if(data[i].first != currentVertex.first) {
+          if(data[i].first.x() != currentVertex.first.x()) {
+            processVertex(output);
+            //std::cout << scanline.size() << " ";
+            countFromBelow.clear(); //should already be clear
+            writeGraph(currentVertex.first.x(), result, output, scanline);
+            currentVertex.second.clear();
+            mergeProperty(currentVertex.second, data[i].second);
+            currentVertex.first = data[i].first;
+          } else {
+            processVertex(output);
+            currentVertex.second.clear();
+            mergeProperty(currentVertex.second, data[i].second);
+            currentVertex.first = data[i].first;
+          }
+        } else {
+          mergeProperty(currentVertex.second, data[i].second);
+        }
+      }
+    }
+    processVertex(output);
+    writeGraph(currentVertex.first.x(), result, output, scanline);
+    //std::cout << scanline.size() << "\n";
+  }
+
+  template <typename T>
+  inline void insertEdges(T& graph, property_set& p1, property_set& p2) {
+    for(typename property_set::iterator itr = p1.begin(); itr != p1.end(); ++itr) {
+      for(typename property_set::iterator itr2 = p2.begin(); itr2 != p2.end(); ++itr2) {
+        if(*itr != *itr2) {
+          graph[*itr].insert(*itr2);
+          graph[*itr2].insert(*itr);
+        }
+      }
+    }
+  }
+
+  template <typename T>
+  inline void propertySetAbove(coordinate_type y, property_set& ps, T& scanline) {
+    ps.clear();
+    typename T::iterator itr = scanline.find(y);
+    if(itr != scanline.end())
+      setProperty(ps, (*itr).second);
+  }
+
+  template <typename T>
+  inline void propertySetBelow(coordinate_type y, property_set& ps, T& scanline) {
+    ps.clear();
+    typename T::iterator itr = scanline.find(y);
+    if(itr != scanline.begin()) {
+      --itr;
+      setProperty(ps, (*itr).second);
+    }
+  }
+
+  template <typename T, typename T2>
+  inline void writeGraph(coordinate_type x, T& graph, edge_property_vector& output, T2& scanline) {
+    if(output.empty()) return;
+    edge_property* previousEdgeP = &(output[0]);
+    bool firstIteration = true;
+    property_set ps;
+    for(std::size_t i = 0; i < output.size(); ++i) {
+      edge_property& previousEdge = *previousEdgeP;
+      edge_property& edge = output[i];
+      if(previousEdge.first.high() == edge.first.low()) {
+        //horizontal edge
+        insertEdges(graph, edge.second.first, previousEdge.second.first);
+        //corner 1
+        insertEdges(graph, edge.second.first, previousEdge.second.second);
+        //other horizontal edge
+        insertEdges(graph, edge.second.second, previousEdge.second.second);
+        //corner 2
+        insertEdges(graph, edge.second.second, previousEdge.second.first);
+      } else {
+        if(!firstIteration){
+          //look up regions above previous edge 
+          propertySetAbove(previousEdge.first.high(), ps, scanline);
+          insertEdges(graph, ps, previousEdge.second.first);
+          insertEdges(graph, ps, previousEdge.second.second);
+        }
+        //look up regions below current edge in the scanline
+        propertySetBelow(edge.first.high(), ps, scanline);
+        insertEdges(graph, ps, edge.second.first);
+        insertEdges(graph, ps, edge.second.second);
+      }
+      firstIteration = false;
+      //vertical edge
+      insertEdges(graph, edge.second.second, edge.second.first);
+      //shared region to left
+      insertEdges(graph, edge.second.second, edge.second.second);
+      //shared region to right
+      insertEdges(graph, edge.second.first, edge.second.first);
+      previousEdgeP = &(output[i]);
+    }
+    edge_property& previousEdge = *previousEdgeP;
+    propertySetAbove(previousEdge.first.high(), ps, scanline);
+    insertEdges(graph, ps, previousEdge.second.first);
+    insertEdges(graph, ps, previousEdge.second.second);
+    output.clear();
+  }
+
+  template <typename Result>
+  inline void writeOutput(coordinate_type x, Result& result, edge_property_vector& output) {
+    for(std::size_t i = 0; i < output.size(); ++i) {
+      edge_property& edge = output[i];
+      //edge.second.first is the property set on the left of the edge
+      if(!edge.second.first.empty()) {
+        typename Result::iterator itr = result.find(edge.second.first);
+        if(itr == result.end()) {
+          std::pair<property_set, polygon_set_type> element(edge.second.first, polygon_set_type(VERTICAL));
+          itr = result.insert(result.end(), element);
+        }
+        std::pair<interval_data<coordinate_type>, int> element2(interval_data<coordinate_type>(edge.first.low(), edge.first.high()), -1); //right edge of figure
+        (*itr).second.insert(x, element2);
+      }
+      if(!edge.second.second.empty()) {
+        //edge.second.second is the property set on the right of the edge
+        typename Result::iterator itr = result.find(edge.second.second);
+        if(itr == result.end()) {
+          std::pair<property_set, polygon_set_type> element(edge.second.second, polygon_set_type(VERTICAL));
+          itr = result.insert(result.end(), element);
+        }
+        std::pair<interval_data<coordinate_type>, int> element3(interval_data<coordinate_type>(edge.first.low(), edge.first.high()), 1); //left edge of figure
+        (*itr).second.insert(x, element3);
+      }
+    }
+    output.clear();
+  }
+};
+
+}
+}
+#endif

test/external/boost/polygon/detail/property_merge_45.hpp

@@ -0,0 +1,160 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_PROPERTY_MERGE_45_HPP
+#define BOOST_POLYGON_PROPERTY_MERGE_45_HPP
+namespace boost { namespace polygon{
+
+  template <typename Unit, typename property_type>
+  struct polygon_45_property_merge {
+
+    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) {
+      polygon_45_touch<Unit>::merge_property_maps(mp, mp2, subtract);
+    }
+
+    class CountMerge {
+    public:
+      inline CountMerge() : counts() {}
+      //inline CountMerge(int count) { counts[0] = counts[1] = count; }
+      //inline CountMerge(int count1, int count2) { counts[0] = count1; counts[1] = count2; }
+      inline CountMerge(const CountMerge& count) : counts(count.counts) {}
+      inline bool operator==(const CountMerge& count) const { return counts == count.counts; }
+      inline bool operator!=(const CountMerge& count) const { return !((*this) == count); }
+      //inline CountMerge& operator=(int count) { counts[0] = counts[1] = count; return *this; }
+      inline CountMerge& operator=(const CountMerge& count) { counts = count.counts; return *this; }
+      inline int& operator[](property_type 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 CountMerge& operator+=(const CountMerge& count){
+        merge_property_maps(counts, count.counts, false);
+        return *this;
+      }
+      inline CountMerge& operator-=(const CountMerge& count){
+        merge_property_maps(counts, count.counts, true);
+        return *this;
+      }
+      inline CountMerge operator+(const CountMerge& count) const {
+        return CountMerge(*this)+=count;
+      }
+      inline CountMerge operator-(const CountMerge& count) const {
+        return CountMerge(*this)-=count;
+      }
+      inline CountMerge invert() const {
+        CountMerge retval;
+        retval -= *this;
+        return retval;
+      }
+      std::vector<std::pair<property_type, int> > counts;
+    };
+
+    //output is a std::map<std::set<property_type>, polygon_45_set_data<Unit> >
+    struct merge_45_output_functor {
+      template <typename cT>
+      void operator()(cT& output, const CountMerge& count1, const CountMerge& count2, 
+                      const Point& pt, int rise, direction_1d end) {
+        typedef typename cT::key_type keytype;
+        keytype left;
+        keytype right;
+        int edgeType = end == LOW ? -1 : 1;
+        for(typename std::vector<std::pair<property_type, int> >::const_iterator itr = count1.counts.begin();
+            itr != count1.counts.end(); ++itr) {
+          left.insert(left.end(), (*itr).first);
+        }
+        for(typename std::vector<std::pair<property_type, int> >::const_iterator itr = count2.counts.begin();
+            itr != count2.counts.end(); ++itr) {
+          right.insert(right.end(), (*itr).first);
+        }
+        if(left == right) return;
+        if(!left.empty()) {
+          //std::cout << pt.x() << " " << pt.y() << " " << rise << " " << edgeType << std::endl;
+          output[left].insert_clean(typename boolean_op_45<Unit>::Vertex45(pt, rise, -edgeType));
+        }
+        if(!right.empty()) {
+          //std::cout << pt.x() << " " << pt.y() << " " << rise << " " << -edgeType << std::endl;
+          output[right].insert_clean(typename boolean_op_45<Unit>::Vertex45(pt, rise, edgeType));
+        }
+      }
+    };
+
+    typedef typename std::pair<Point, 
+                               typename boolean_op_45<Unit>::template Scan45CountT<CountMerge> > Vertex45Compact;
+    typedef std::vector<Vertex45Compact> MergeSetData;
+    
+    struct lessVertex45Compact {
+      bool operator()(const Vertex45Compact& l, const Vertex45Compact& r) {
+        return l.first < r.first;
+      }
+    };
+    
+    template <typename output_type>
+    static void performMerge(output_type& result, MergeSetData& tsd) {
+      
+      gtlsort(tsd.begin(), tsd.end(), lessVertex45Compact());
+      typedef std::vector<std::pair<Point, typename boolean_op_45<Unit>::template Scan45CountT<CountMerge> > > TSD;
+      TSD tsd_;
+      tsd_.reserve(tsd.size());
+      for(typename MergeSetData::iterator itr = tsd.begin(); itr != tsd.end(); ) {
+        typename MergeSetData::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;
+      }
+      typename boolean_op_45<Unit>::template Scan45<CountMerge, merge_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(result, itr, itr2);
+        itr = itr2;
+      }
+    }
+
+    template <typename iT>
+    static void populateMergeSetData(MergeSetData& tsd, iT begin, iT end, property_type property) {
+      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][property] += begin->count[i];
+          }
+        }
+      }
+    }
+    
+  };
+
+
+
+}
+}
+
+#endif

test/external/boost/polygon/detail/rectangle_formation.hpp

@@ -0,0 +1,267 @@
+/*
+    Copyright 2008 Intel Corporation
+ 
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_RECTANGLE_FORMATION_HPP
+#define BOOST_POLYGON_RECTANGLE_FORMATION_HPP
+namespace boost { namespace polygon{
+
+namespace rectangle_formation {
+  template <class T> 
+  class ScanLineToRects {
+  public:
+    typedef T rectangle_type;
+    typedef typename rectangle_traits<T>::coordinate_type coordinate_type;
+    typedef rectangle_data<coordinate_type> scan_rect_type;
+  private:
+    
+    typedef std::set<scan_rect_type, less_rectangle_concept<scan_rect_type, scan_rect_type> > ScanData;
+    ScanData scanData_;
+    bool haveCurrentRect_;
+    scan_rect_type currentRect_;
+    orientation_2d orient_;
+    typename rectangle_traits<T>::coordinate_type currentCoordinate_;
+  public:
+    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), currentRect_(), orient_(orient), currentCoordinate_() {
+      assign(currentRect_, model);
+      currentCoordinate_ = (std::numeric_limits<coordinate_type>::max)();
+    }
+    
+    template <typename CT>
+    inline ScanLineToRects& processEdge(CT& rectangles, const interval_data<coordinate_type>& edge);
+    
+    inline ScanLineToRects& nextMajorCoordinate(coordinate_type currentCoordinate) {
+      if(haveCurrentRect_) {
+        scanData_.insert(scanData_.end(), currentRect_);
+        haveCurrentRect_ = false;
+      }
+      currentCoordinate_ = currentCoordinate;
+      return *this;
+    }
+    
+  };
+
+  template <class CT, class ST, class rectangle_type, typename interval_type, typename coordinate_type> inline CT& 
+  processEdge_(CT& rectangles, ST& scanData, const interval_type& edge, 
+               bool& haveCurrentRect, rectangle_type& currentRect, coordinate_type currentCoordinate, orientation_2d orient) 
+  {
+    typedef typename CT::value_type result_type;
+    bool edgeProcessed = false;
+    if(!scanData.empty()) {
+
+      //process all rectangles in the scanData that touch the edge
+      typename ST::iterator dataIter = scanData.lower_bound(rectangle_type(edge, edge));
+      //decrement beginIter until its low is less than edge's low
+      while((dataIter == scanData.end() || (*dataIter).get(orient).get(LOW) > edge.get(LOW)) && 
+            dataIter != scanData.begin())
+        {
+          --dataIter;
+        }
+      //process each rectangle until the low end of the rectangle 
+      //is greater than the high end of the edge
+      while(dataIter != scanData.end() &&
+            (*dataIter).get(orient).get(LOW) <= edge.get(HIGH)) 
+        {
+          const rectangle_type& rect = *dataIter;
+          //if the rectangle data intersects the edge at all
+          if(rect.get(orient).get(HIGH) >= edge.get(LOW)) {
+            if(contains(rect.get(orient), edge, true)) {
+              //this is a closing edge
+              //we need to write out the intersecting rectangle and
+              //insert between 0 and 2 rectangles into the scanData
+              //write out rectangle
+              rectangle_type tmpRect = rect;
+
+              if(rect.get(orient.get_perpendicular()).get(LOW) < currentCoordinate) {
+                //set the high coordinate perpedicular to slicing orientation
+                //to the current coordinate of the scan event
+                tmpRect.set(orient.get_perpendicular().get_direction(HIGH),
+                            currentCoordinate);
+                result_type result;
+                assign(result, tmpRect);
+                rectangles.insert(rectangles.end(), result);
+              }
+              //erase the rectangle from the scan data
+              typename ST::iterator nextIter = dataIter;
+              ++nextIter;
+              scanData.erase(dataIter);
+              if(tmpRect.get(orient).get(LOW) < edge.get(LOW)) {
+                //insert a rectangle for the overhang of the bottom
+                //of the rectangle back into scan data
+                rectangle_type lowRect(tmpRect);
+                lowRect.set(orient.get_perpendicular(), interval_data<coordinate_type>(currentCoordinate,
+                                                                currentCoordinate));
+                lowRect.set(orient.get_direction(HIGH), edge.get(LOW));
+                scanData.insert(nextIter, lowRect);
+              }
+              if(tmpRect.get(orient).get(HIGH) > edge.get(HIGH)) {
+                //insert a rectangle for the overhang of the top
+                //of the rectangle back into scan data
+                rectangle_type highRect(tmpRect);
+                highRect.set(orient.get_perpendicular(), interval_data<coordinate_type>(currentCoordinate,
+                                                                 currentCoordinate));
+                highRect.set(orient.get_direction(LOW), edge.get(HIGH));
+                scanData.insert(nextIter, highRect);
+              }
+              //we are done with this edge
+              edgeProcessed = true;                 
+              break;
+            } else {
+              //it must be an opening edge
+              //assert that rect does not overlap the edge but only touches
+              //write out rectangle
+              rectangle_type tmpRect = rect;
+              //set the high coordinate perpedicular to slicing orientation
+              //to the current coordinate of the scan event
+              if(tmpRect.get(orient.get_perpendicular().get_direction(LOW)) < currentCoordinate) {
+                tmpRect.set(orient.get_perpendicular().get_direction(HIGH),
+                            currentCoordinate);
+                result_type result;
+                assign(result, tmpRect);
+                rectangles.insert(rectangles.end(), result);
+              }
+              //erase the rectangle from the scan data
+              typename ST::iterator nextIter = dataIter;
+              ++nextIter;
+              scanData.erase(dataIter);
+              dataIter = nextIter;
+              if(haveCurrentRect) {
+                if(currentRect.get(orient).get(HIGH) >= edge.get(LOW)){
+                  if(!edgeProcessed && currentRect.get(orient.get_direction(HIGH)) > edge.get(LOW)){
+                    rectangle_type tmpRect2(currentRect);
+                    tmpRect2.set(orient.get_direction(HIGH), edge.get(LOW));
+                    scanData.insert(nextIter, tmpRect2);
+                    if(currentRect.get(orient.get_direction(HIGH)) > edge.get(HIGH)) {
+                      currentRect.set(orient, interval_data<coordinate_type>(edge.get(HIGH), currentRect.get(orient.get_direction(HIGH))));
+                    } else {
+                      haveCurrentRect = false;
+                    }
+                  } else {
+                    //extend the top of current rect
+                    currentRect.set(orient.get_direction(HIGH), 
+                                    (std::max)(edge.get(HIGH), 
+                                               tmpRect.get(orient.get_direction(HIGH))));
+                  }
+                } else {
+                  //insert current rect into the scanData
+                  scanData.insert(nextIter, currentRect);
+                  //create a new current rect
+                  currentRect.set(orient.get_perpendicular(), interval_data<coordinate_type>(currentCoordinate,
+                                                                      currentCoordinate));
+                  currentRect.set(orient, interval_data<coordinate_type>((std::min)(tmpRect.get(orient).get(LOW), 
+                                                       edge.get(LOW)),
+                                                                         (std::max)(tmpRect.get(orient).get(HIGH),
+                                                       edge.get(HIGH))));
+                }
+              } else {
+                haveCurrentRect = true;
+                currentRect.set(orient.get_perpendicular(), interval_data<coordinate_type>(currentCoordinate,
+                                                                    currentCoordinate));
+                currentRect.set(orient, interval_data<coordinate_type>((std::min)(tmpRect.get(orient).get(LOW), 
+                                                     edge.get(LOW)),
+                                                                       (std::max)(tmpRect.get(orient).get(HIGH),
+                                                     edge.get(HIGH))));
+              }
+              //skip to nextIter position
+              edgeProcessed = true;
+              continue;
+            }
+            //edgeProcessed = true;
+          }
+          ++dataIter;
+        } //end while edge intersects rectangle data 
+
+    }
+    if(!edgeProcessed) {
+      if(haveCurrentRect) {
+        if(currentRect.get(orient.get_perpendicular().get_direction(HIGH)) 
+           == currentCoordinate &&
+           currentRect.get(orient.get_direction(HIGH)) >= edge.get(LOW)) 
+          {
+            if(currentRect.get(orient.get_direction(HIGH)) > edge.get(LOW)){
+              rectangle_type tmpRect(currentRect);
+              tmpRect.set(orient.get_direction(HIGH), edge.get(LOW));
+              scanData.insert(scanData.end(), tmpRect);
+              if(currentRect.get(orient.get_direction(HIGH)) > edge.get(HIGH)) {
+                currentRect.set(orient, 
+                                interval_data<coordinate_type>(edge.get(HIGH), 
+                                         currentRect.get(orient.get_direction(HIGH))));
+                return rectangles;
+              } else {
+                haveCurrentRect = false;
+                return rectangles;
+              }
+            }
+            //extend current rect
+            currentRect.set(orient.get_direction(HIGH), edge.get(HIGH));
+            return rectangles;
+          }
+        scanData.insert(scanData.end(), currentRect);
+        haveCurrentRect = false;
+      } 
+      rectangle_type tmpRect(currentRect);
+      tmpRect.set(orient.get_perpendicular(), interval_data<coordinate_type>(currentCoordinate,
+                                                      currentCoordinate));
+      tmpRect.set(orient, edge);
+      scanData.insert(tmpRect);
+      return rectangles;
+    }
+    return rectangles;
+  
+  }
+
+  template <class T> 
+  template <class CT> 
+  inline 
+  ScanLineToRects<T>& ScanLineToRects<T>::processEdge(CT& rectangles, const interval_data<coordinate_type>& edge) 
+  {
+    processEdge_(rectangles, scanData_, edge, haveCurrentRect_, currentRect_, currentCoordinate_, orient_);
+    return *this;
+  }
+
+
+} //namespace rectangle_formation
+
+  template <typename T, typename T2>
+  struct get_coordinate_type_for_rectangles {
+    typedef typename polygon_traits<T>::coordinate_type type;
+  };
+  template <typename T>
+  struct get_coordinate_type_for_rectangles<T, rectangle_concept> {
+    typedef typename rectangle_traits<T>::coordinate_type type;
+  };
+
+  template <typename output_container, typename iterator_type, typename rectangle_concept>
+  void form_rectangles(output_container& output, iterator_type begin, iterator_type end,
+                       orientation_2d orient, rectangle_concept ) {
+    typedef typename output_container::value_type rectangle_type;
+    typedef typename get_coordinate_type_for_rectangles<rectangle_type, typename geometry_concept<rectangle_type>::type>::type Unit;
+    rectangle_data<Unit> model;
+    Unit prevPos = (std::numeric_limits<Unit>::max)();
+    rectangle_formation::ScanLineToRects<rectangle_data<Unit> > scanlineToRects(orient, model);
+    for(iterator_type itr = begin;
+        itr != end; ++ itr) {
+      Unit pos = (*itr).first;
+      if(pos != prevPos) {
+        scanlineToRects.nextMajorCoordinate(pos);
+        prevPos = pos;
+      }
+      Unit lowy = (*itr).second.first;
+      iterator_type tmp_itr = itr;
+      ++itr;
+      Unit highy = (*itr).second.first;
+      scanlineToRects.processEdge(output, interval_data<Unit>(lowy, highy));
+      if(abs((*itr).second.second) > 1) itr = tmp_itr; //next edge begins from this vertex
+    }
+  }
+}
+}
+#endif
+

test/external/boost/polygon/detail/transform_detail.hpp

@@ -0,0 +1,553 @@
+/*
+    Copyright 2008 Intel Corporation
+ 
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_TRANSFORM_DETAIL_HPP
+#define BOOST_POLYGON_TRANSFORM_DETAIL_HPP
+
+namespace boost { namespace polygon{
+  // 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] << BOOST_POLYGON_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_ << BOOST_POLYGON_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) : 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) : 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) : 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 ATR& atr) {
+    atr_ = atr;
+    return *this;
+  }
+
+  inline bool axis_transformation::operator==(const axis_transformation& a) const {
+    return atr_ == a.atr_;
+  }
+
+  inline bool axis_transformation::operator!=(const axis_transformation& a) const {
+    return !(*this == a);
+  }
+
+  inline bool axis_transformation::operator<(const axis_transformation& a) const {
+    return atr_ < a.atr_;
+  }
+
+  inline axis_transformation& axis_transformation::operator+=(const axis_transformation& a){
+    bool abit5 = (a.atr_ & 32) != 0;
+    bool abit4 = (a.atr_ & 16) != 0;
+    bool abit3 = (a.atr_ & 8) != 0;
+    bool abit2 = (a.atr_ & 4) != 0;
+    bool abit1 = (a.atr_ & 2) != 0;
+    bool abit0 = (a.atr_ & 1) != 0;      
+    bool bit5 = (atr_ & 32) != 0;
+    bool bit4 = (atr_ & 16) != 0;
+    bool bit3 = (atr_ & 8) != 0;
+    bool bit2 = (atr_ & 4) != 0;
+    bool bit1 = (atr_ & 2) != 0;
+    bool bit0 = (atr_ & 1) != 0;      
+    int indexes[2][3] = {
+      {
+        ((int)((bit5 & bit2) | (bit4 & !bit2)) << 1) +
+        (int)(bit2 & !bit5),
+        ((int)((bit4 & bit2) | (bit5 & !bit2)) << 1) +
+        (int)(!bit5 & !bit2),
+        ((int)(!bit4 & !bit5) << 1) +
+        (int)(bit5) 
+      },
+      {
+        ((int)((abit5 & abit2) | (abit4 & !abit2)) << 1) +
+        (int)(abit2 & !abit5),
+        ((int)((abit4 & abit2) | (abit5 & !abit2)) << 1) +
+        (int)(!abit5 & !abit2),
+        ((int)(!abit4 & !abit5) << 1) +
+        (int)(abit5) 
+      }
+    };
+    int zero_bits[2][3] = {
+      {bit0, bit1, bit3},
+      {abit0, abit1, abit3}
+    };
+    int nbit3 = zero_bits[0][2] ^ zero_bits[1][indexes[0][2]];
+    int nbit1 = zero_bits[0][1] ^ zero_bits[1][indexes[0][1]];
+    int nbit0 = zero_bits[0][0] ^ zero_bits[1][indexes[0][0]];
+    indexes[0][0] = indexes[1][indexes[0][0]];
+    indexes[0][1] = indexes[1][indexes[0][1]];
+    indexes[0][2] = indexes[1][indexes[0][2]];
+    int nbit5 = (indexes[0][2] == 1);
+    int nbit4 = (indexes[0][2] == 0);
+    int nbit2 = (!(nbit5 | nbit4) & (bool)(indexes[0][0] & 1)) | //swap xy
+      (nbit5 & ((indexes[0][0] & 2) >> 1)) | //z->y x->z
+      (nbit4 & ((indexes[0][1] & 2) >> 1));  //z->x y->z
+    atr_ = (ATR)((nbit5 << 5) + 
+                 (nbit4 << 4) + 
+                 (nbit3 << 3) + 
+                 (nbit2 << 2) + 
+                 (nbit1 << 1) + nbit0);
+    return *this;
+  }
+  
+  inline axis_transformation axis_transformation::operator+(const axis_transformation& a) const {
+    axis_transformation retval(*this);
+    return retval+=a;
+  }
+  
+  // populate_axis_array writes the three INDIVIDUAL_AXIS values that the
+  // ATR enum value of 'this' represent into axis_array
+  inline void axis_transformation::populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const {
+    bool bit5 = (atr_ & 32) != 0;
+    bool bit4 = (atr_ & 16) != 0;
+    bool bit3 = (atr_ & 8) != 0;
+    bool bit2 = (atr_ & 4) != 0;
+    bool bit1 = (atr_ & 2) != 0;
+    bool bit0 = (atr_ & 1) != 0;      
+    axis_array[2] = 
+      (INDIVIDUAL_AXIS)((((int)(!bit4 & !bit5)) << 2) +
+                        ((int)(bit5) << 1) + 
+                        bit3);
+    axis_array[1] = 
+      (INDIVIDUAL_AXIS)((((int)((bit4 & bit2) | (bit5 & !bit2))) << 2)+
+                        ((int)(!bit5 & !bit2) << 1) + 
+                        bit1);
+    axis_array[0] = 
+      (INDIVIDUAL_AXIS)((((int)((bit5 & bit2) | (bit4 & !bit2))) << 2) +
+                        ((int)(bit2 & !bit5) << 1) + 
+                        bit0);
+  }
+  
+  // combine_axis_arrays concatenates this_array and that_array overwriting
+  // the result into this_array
+  inline void 
+  axis_transformation::combine_axis_arrays (INDIVIDUAL_AXIS this_array[],
+                                            const INDIVIDUAL_AXIS that_array[]){
+    int indexes[3] = {this_array[0] >> 1,
+                      this_array[1] >> 1,
+                      this_array[2] >> 1};
+    int zero_bits[2][3] = {
+      {this_array[0] & 1, this_array[1] & 1, this_array[2] & 1},
+      {that_array[0] & 1, that_array[1] & 1, that_array[2] & 1}
+    };
+    this_array[0] = that_array[indexes[0]];
+    this_array[0] = (INDIVIDUAL_AXIS)((int)this_array[0] & (int)((int)PZ+(int)PY));
+    this_array[0] = (INDIVIDUAL_AXIS)((int)this_array[0] | 
+                                      ((int)zero_bits[0][0] ^ 
+                                       (int)zero_bits[1][indexes[0]]));
+    this_array[1] = that_array[indexes[1]];
+    this_array[1] = (INDIVIDUAL_AXIS)((int)this_array[1] & (int)((int)PZ+(int)PY));
+    this_array[1] = (INDIVIDUAL_AXIS)((int)this_array[1] | 
+                                      ((int)zero_bits[0][1] ^ 
+                                       (int)zero_bits[1][indexes[1]]));
+    this_array[2] = that_array[indexes[2]];
+    this_array[2] = (INDIVIDUAL_AXIS)((int)this_array[2] & (int)((int)PZ+(int)PY));
+    this_array[2] = (INDIVIDUAL_AXIS)((int)this_array[2] | 
+                                      ((int)zero_bits[0][2] ^ 
+                                       (int)zero_bits[1][indexes[2]]));
+  }
+  
+  // write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
+  // to the ATR enum value and sets 'this' to that value
+  inline void axis_transformation::write_back_axis_array(const INDIVIDUAL_AXIS this_array[]) {
+    int bit5 = ((int)this_array[2] & 2) != 0;
+    int bit4 = !((((int)this_array[2] & 4) != 0) | (((int)this_array[2] & 2) != 0));
+    int bit3 = ((int)this_array[2] & 1) != 0;
+    //bit 2 is the tricky bit
+    int bit2 = ((!(bit5 | bit4)) & (((int)this_array[0] & 2) != 0)) | //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 = (static_cast<orientation_2d>(horizontalDir).to_int()) != 0;
+    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 = (this_array[2] & 2) != 0;
+    int bit4 = !(((this_array[2] & 4) != 0) | ((this_array[2] & 2) != 0));
+    int bit3 = !((this_array[2] & 1) != 0);
+    //bit 2 is the tricky bit
+    int bit2 = (!(bit5 | bit4) & ((this_array[0] & 2) != 0 )) | //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 = (atr_ & 4) != 0;
+    int bit1 = (atr_ & 2) != 0;
+    int bit0 = (atr_ & 1) != 0;
+    x *= -((bit0 << 1) - 1);
+    y *= -((bit1 << 1) - 1);    
+    predicated_swap(bit2 != 0,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 = (atr_ & 32) != 0;
+    int bit4 = (atr_ & 16) != 0;
+    int bit3 = (atr_ & 8) != 0;
+    int bit2 = (atr_ & 4) != 0;
+    int bit1 = (atr_ & 2) != 0;
+    int bit0 = (atr_ & 1) != 0;
+    x *= -((bit0 << 1) - 1);
+    y *= -((bit1 << 1) - 1);    
+    z *= -((bit3 << 1) - 1);
+    predicated_swap(bit2 != 0, x, y);
+    predicated_swap(bit5 != 0, y, z);
+    predicated_swap(bit4 != 0, x, z);
+  }
+  
+  inline axis_transformation& axis_transformation::invert_2d() {
+    int bit2 = ((atr_ & 4) != 0);
+    int bit1 = ((atr_ & 2) != 0);
+    int bit0 = ((atr_ & 1) != 0);
+    //swap bit 0 and bit 1 if bit2 is 1
+    predicated_swap(bit2 != 0, bit0, bit1);
+    bit1 = bit1 << 1;
+    atr_ = (ATR)(atr_ & (32+16+8+4)); //mask away bit0 and bit1
+    atr_ = (ATR)(atr_ | bit0 | bit1);
+    return *this;
+  }
+  
+  inline axis_transformation axis_transformation::inverse_2d() const {
+    axis_transformation retval(*this);
+    return retval.invert_2d();
+  }
+  
+  inline axis_transformation& axis_transformation::invert() {
+    int bit5 = ((atr_ & 32) != 0);
+    int bit4 = ((atr_ & 16) != 0);    
+    int bit3 = ((atr_ & 8) != 0);
+    int bit2 = ((atr_ & 4) != 0);
+    int bit1 = ((atr_ & 2) != 0);
+    int bit0 = ((atr_ & 1) != 0);
+    predicated_swap(bit2 != 0, bit4, bit5);
+    predicated_swap(bit4 != 0, bit0, bit3);
+    predicated_swap(bit5 != 0, bit1, bit3);
+    predicated_swap(bit2 != 0, bit0, bit1);
+    atr_ = (ATR)((bit5 << 5) + 
+                 (bit4 << 4) + 
+                 (bit3 << 3) + 
+                 (bit2 << 2) + 
+                 (bit1 << 1) + bit0);
+    return *this;
+  }
+  
+  inline axis_transformation axis_transformation::inverse() const {
+    axis_transformation retval(*this);
+    return retval.invert();
+  }
+  
+  template <typename scale_factor_type>
+  inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::get(orientation_3d orient) const {
+    return scale_[orient.to_int()];
+  }
+  
+  template <typename scale_factor_type>
+  inline void anisotropic_scale_factor<scale_factor_type>::set(orientation_3d orient, scale_factor_type value) {
+    scale_[orient.to_int()] = value;
+  }
+
+  template <typename scale_factor_type>
+  inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::x() const { return scale_[HORIZONTAL]; }
+  template <typename scale_factor_type>
+  inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::y() const { return scale_[VERTICAL]; }
+  template <typename scale_factor_type>
+  inline scale_factor_type anisotropic_scale_factor<scale_factor_type>::z() const { return scale_[PROXIMAL]; }
+  template <typename scale_factor_type>
+  inline void anisotropic_scale_factor<scale_factor_type>::x(scale_factor_type value) { scale_[HORIZONTAL] = value; }
+  template <typename scale_factor_type>
+  inline void anisotropic_scale_factor<scale_factor_type>::y(scale_factor_type value) { scale_[VERTICAL] = value; }
+  template <typename scale_factor_type>
+  inline void anisotropic_scale_factor<scale_factor_type>::z(scale_factor_type value) { scale_[PROXIMAL] = value; }
+  
+  //concatenation operator (convolve scale factors)
+  template <typename scale_factor_type>
+  inline anisotropic_scale_factor<scale_factor_type> anisotropic_scale_factor<scale_factor_type>::operator+(const anisotropic_scale_factor<scale_factor_type>& s) const {
+    anisotropic_scale_factor<scale_factor_type> retval(*this);
+    return retval+=s;
+  }
+  
+  //concatenate this with that
+  template <typename scale_factor_type>
+  inline const anisotropic_scale_factor<scale_factor_type>& anisotropic_scale_factor<scale_factor_type>::operator+=(const anisotropic_scale_factor<scale_factor_type>& s){
+    scale_[0] *= s.scale_[0];
+    scale_[1] *= s.scale_[1];
+    scale_[2] *= s.scale_[2];
+    return *this;
+  }
+  
+  //transform
+  template <typename scale_factor_type>
+  inline anisotropic_scale_factor<scale_factor_type>& anisotropic_scale_factor<scale_factor_type>::transform(axis_transformation atr){
+    direction_3d dirs[3];
+    atr.get_directions(dirs[0],dirs[1],dirs[2]);
+    scale_factor_type tmp[3] = {scale_[0], scale_[1], scale_[2]};
+    for(int i = 0; i < 3; ++i){
+      scale_[orientation_3d(dirs[i]).to_int()] = tmp[i];
+    }
+    return *this;
+  }
+
+  template <typename scale_factor_type>
+  template <typename coordinate_type_2>
+  inline void anisotropic_scale_factor<scale_factor_type>::scale(coordinate_type_2& x, coordinate_type_2& y) const {
+    x = scaling_policy<coordinate_type_2>::round((scale_factor_type)x * get(HORIZONTAL));
+    y = scaling_policy<coordinate_type_2>::round((scale_factor_type)y * get(HORIZONTAL));
+  }
+
+  template <typename scale_factor_type>
+  template <typename coordinate_type_2>
+  inline void anisotropic_scale_factor<scale_factor_type>::scale(coordinate_type_2& x, coordinate_type_2& y, coordinate_type_2& z) const {
+    scale(x, y);
+    z = scaling_policy<coordinate_type_2>::round((scale_factor_type)z * get(HORIZONTAL));
+  }
+
+  template <typename scale_factor_type>
+  inline anisotropic_scale_factor<scale_factor_type>& anisotropic_scale_factor<scale_factor_type>::invert() {
+    x(1/x());
+    y(1/y());
+    z(1/z());
+    return *this;
+  }
+
+
+  template <typename coordinate_type>
+  inline transformation<coordinate_type>::transformation() : 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_(atr), p_(0, 0, 0){;}
+
+  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& p) :
+    atr_(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) : 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 atr_ < tr.atr_ || atr_ == tr.atr_ && p_ < tr.p_;
+  }
+  
+  template <typename coordinate_type>
+  inline transformation<coordinate_type> transformation<coordinate_type>::operator+(const transformation<coordinate_type>& tr) const {
+    transformation<coordinate_type> retval(*this);
+    return retval+=tr;
+  }
+  
+  template <typename coordinate_type>
+  inline const transformation<coordinate_type>& transformation<coordinate_type>::operator+=(const transformation<coordinate_type>& tr){
+    //apply the inverse transformation of this to the translation point of that
+    //and convolve it with this translation point
+    coordinate_type x, y, z;
+    transformation<coordinate_type> inv = inverse();
+    inv.transform(x, y, z);
+    p_.set(HORIZONTAL, p_.get(HORIZONTAL) + x);
+    p_.set(VERTICAL, p_.get(VERTICAL) + y);
+    p_.set(PROXIMAL, p_.get(PROXIMAL) + z);
+    //concatenate axis transforms
+    atr_ += tr.atr_;
+    return *this;
+  }
+  
+  template <typename coordinate_type>
+  inline void transformation<coordinate_type>::set_axis_transformation(const axis_transformation& atr) {
+    atr_ = atr;
+  }
+  
+  template <typename coordinate_type>
+  template <typename point_type>
+  inline void transformation<coordinate_type>::get_translation(point_type& p) const {
+    assign(p, p_);
+  }
+  
+  template <typename coordinate_type>
+  template <typename point_type>
+  inline void transformation<coordinate_type>::set_translation(const point_type& p) {
+    assign(p_, p);
+  }
+  
+  template <typename coordinate_type>
+  inline void transformation<coordinate_type>::transform(coordinate_type& x, coordinate_type& y) const {
+    //subtract each component of new origin point
+    y -= p_.get(VERTICAL);
+    x -= p_.get(HORIZONTAL);
+    atr_.transform(x, y);
+  }
+
+  template <typename coordinate_type>
+  inline void transformation<coordinate_type>::transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const {
+    //subtract each component of new origin point
+    z -= p_.get(PROXIMAL);
+    y -= p_.get(VERTICAL);
+    x -= p_.get(HORIZONTAL);
+    atr_.transform(x,y,z);
+  }
+  
+  // sets the axis_transform portion to its inverse
+  // transforms the tranlastion portion by that inverse axis_transform
+  // multiplies the translation portion by -1 to reverse it
+  template <typename coordinate_type>
+  inline transformation<coordinate_type>& transformation<coordinate_type>::invert() {
+    coordinate_type x = p_.get(HORIZONTAL), y = p_.get(VERTICAL), z = p_.get(PROXIMAL);
+    atr_.transform(x, y, z);
+    x *= -1;
+    y *= -1;
+    z *= -1;
+    p_ = point_3d_data<coordinate_type>(x, y, z);
+    atr_.invert();
+    return *this;
+  }
+  
+  template <typename coordinate_type>
+  inline transformation<coordinate_type> transformation<coordinate_type>::inverse() const {
+    transformation<coordinate_type> retval(*this);
+    return retval.invert();
+  }
+}
+}
+#endif
+
+

test/external/boost/polygon/gmp_override.hpp

@@ -0,0 +1,129 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_GMP_OVERRIDE_HPP
+#define BOOST_POLYGON_GMP_OVERRIDE_HPP
+#include <gmpxx.h>
+namespace boost { namespace polygon {
+
+  class gmp_int {
+  private:
+    inline gmp_int(const mpq_class& input) : v_(input) {}
+  public:
+    inline gmp_int() {}
+    explicit inline gmp_int(long input) : v_(input) {}
+    inline gmp_int(const gmp_int& input) : v_(input.v_) {}
+    inline gmp_int& operator=(const gmp_int& that) {
+      v_ = that.v_;
+      return (*this);
+    }
+    inline gmp_int& operator=(long that) {
+      v_ = that;
+      return (*this);
+    }
+    inline operator int() const { 
+      std::cout << "cast\n";
+      mpz_class num = v_.get_num();
+      mpz_class den = v_.get_den();
+      num /= den;
+      return num.get_si(); 
+    }
+    inline double get_d() const { 
+      return v_.get_d();
+    }
+    inline int get_num() const {
+      return v_.get_num().get_si();
+    }
+    inline int get_den() const {
+      return v_.get_den().get_si();
+    }
+    inline bool operator==(const gmp_int& that) const {
+      return v_ == that.v_;
+    }
+    inline bool operator!=(const gmp_int& that) const {
+      return v_ != that.v_;
+    }
+    inline bool operator<(const gmp_int& that) const {
+      bool retval = v_ < that.v_;
+      return retval;
+    }
+    inline bool operator<=(const gmp_int& that) const {
+      return v_ <= that.v_;
+    }
+    inline bool operator>(const gmp_int& that) const {
+      return v_ > that.v_;
+    }
+    inline bool operator>=(const gmp_int& that) const {
+      return v_ >= that.v_;
+    }
+    inline gmp_int operator+(const gmp_int& b) {
+      return gmp_int((*this).v_ + b.v_);
+    }
+    inline gmp_int operator-(const gmp_int& b) {
+      return gmp_int((*this).v_ - b.v_);
+    }
+    inline gmp_int operator*(const gmp_int& b) {
+      return gmp_int((*this).v_ * b.v_);
+    }
+    inline gmp_int operator/(const gmp_int& b) {
+      return gmp_int((*this).v_ / b.v_);
+    }
+    inline gmp_int& operator+=(const gmp_int& b) {
+      (*this).v_ += b.v_;
+      return (*this);
+    }
+    inline gmp_int& operator-=(const gmp_int& b) {
+      (*this).v_ -= b.v_;
+      return (*this);
+    }
+    inline gmp_int& operator*=(const gmp_int& b) {
+      (*this).v_ *= b.v_;
+      return (*this);
+    }
+    inline gmp_int& operator/=(const gmp_int& b) {
+      (*this).v_ /= b.v_;
+      return (*this);
+    }
+    inline gmp_int& operator++() {
+      ++v_;
+      return (*this);
+    }
+    inline gmp_int& operator--() {
+      --v_;
+      return (*this);
+    }
+    inline gmp_int operator++(int) {
+      gmp_int retval(*this);
+      ++(*this);
+      return retval;
+    }
+    inline gmp_int operator--(int) {
+      gmp_int retval(*this);
+      --(*this);
+      return retval;
+    }
+  private:
+    mpq_class v_;
+  };
+  
+  template <>
+  struct high_precision_type<int> {
+    typedef mpq_class type;
+  };
+
+  template <>
+  int convert_high_precision_type<int>(const mpq_class& v) {
+    mpz_class num = v.get_num();
+    mpz_class den = v.get_den();
+    num /= den;
+    return num.get_si(); 
+  };
+
+}
+}
+//==
+#endif

test/external/boost/polygon/gtl.hpp

@@ -0,0 +1,27 @@
+/*
+  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
+
+#ifdef __ICC
+#pragma warning (disable:1125)
+#endif
+
+#ifdef WIN32
+#pragma warning( disable: 4996 )
+#pragma warning( disable: 4800 )
+#endif
+
+#define BOOST_POLYGON_NO_DEPS
+#include "polygon.hpp"
+namespace gtl = boost::polygon;
+using namespace boost::polygon::operators;
+#if __ICC
+#pragma warning (default:1125)
+#endif
+#endif

test/external/boost/polygon/interval_concept.hpp

@@ -0,0 +1,592 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_INTERVAL_CONCEPT_HPP
+#define BOOST_POLYGON_INTERVAL_CONCEPT_HPP
+#include "isotropy.hpp"
+#include "interval_data.hpp"
+#include "interval_traits.hpp"
+
+namespace boost { namespace polygon{
+  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 CT>
+  struct interval_coordinate_type_by_concept { typedef void type; };
+  template <typename T>
+  struct interval_coordinate_type_by_concept<T, gtl_yes> { typedef typename interval_traits<T>::coordinate_type type; };
+
+  template <typename T>
+  struct interval_coordinate_type {
+      typedef typename interval_coordinate_type_by_concept<
+            T, typename is_interval_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  template <typename T, typename CT>
+  struct interval_difference_type_by_concept { typedef void type; };
+  template <typename T>
+  struct interval_difference_type_by_concept<T, gtl_yes> { 
+    typedef typename coordinate_traits<typename interval_traits<T>::coordinate_type>::coordinate_difference type; };
+
+  template <typename T>
+  struct interval_difference_type {
+      typedef typename interval_difference_type_by_concept<
+            T, typename is_interval_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+
+  template <typename T>
+  typename interval_coordinate_type<T>::type
+  get(const T& interval, direction_1d dir,
+  typename enable_if<typename gtl_if<typename is_interval_concept<typename geometry_concept<T>::type>::type>::type>::type * = 0
+  ) {
+    return interval_traits<T>::get(interval, dir); 
+  }
+
+  template <typename T, typename coordinate_type>
+  void 
+  set(T& interval, direction_1d dir, coordinate_type value,
+  typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type>::type * = 0
+  ) {
+    //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 T2, typename T3>
+  T
+  construct(T2 low_value, T3 high_value,
+            typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type>::type * = 0
+  ) {
+    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>
+  T
+  copy_construct(const T2& interval,
+  typename enable_if< typename gtl_and<typename is_mutable_interval_concept<typename geometry_concept<T>::type>::type,
+  typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
+  ) {
+    return construct<T>
+      (get(interval, LOW ),
+       get(interval, HIGH));
+  }
+
+  template <typename T1, typename T2>
+  T1 &
+  assign(T1& lvalue, const T2& rvalue,
+  typename enable_if< typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<T1>::type>::type,
+  typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0) {
+    lvalue = copy_construct<T1>(rvalue);
+    return lvalue;
+  }
+
+  template <typename T, typename T2>
+  bool 
+  equivalence(const T& interval1, const T2& interval2,
+  typename enable_if< typename gtl_and< typename is_interval_concept<typename geometry_concept<T>::type>::type,
+  typename is_interval_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
+  ) {
+    return get(interval1, LOW) ==
+      get(interval2, LOW) &&
+      get(interval1, HIGH) ==
+      get(interval2, HIGH); 
+  }
+  
+  struct y_i_contains : gtl_yes {};
+
+  template <typename interval_type>
+  typename enable_if< typename gtl_and< y_i_contains, typename is_interval_concept<typename geometry_concept<interval_type>::type>::type >::type, bool>::type 
+  contains(const interval_type& interval,
+           typename interval_traits<interval_type>::coordinate_type value, 
+           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>
+  bool 
+  contains(const interval_type& interval,
+           const interval_type_2& value, bool consider_touch = true,
+           typename enable_if< typename gtl_and< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type,
+           typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type>::type * = 0
+           ) {
+    return contains(interval, get(value, LOW), consider_touch) &&
+      contains(interval, get(value, HIGH), consider_touch);
+  }
+  
+  // get the low coordinate
+  template <typename interval_type>
+  typename interval_traits<interval_type>::coordinate_type 
+  low(const interval_type& interval,
+  typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
+  ) { return get(interval, LOW); }
+
+  // get the high coordinate
+  template <typename interval_type>
+  typename interval_traits<interval_type>::coordinate_type 
+  high(const interval_type& interval,
+  typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
+  ) { return get(interval, HIGH); }
+
+  // get the center coordinate
+  template <typename interval_type>
+  typename interval_traits<interval_type>::coordinate_type
+  center(const interval_type& interval,
+  typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
+  ) { return (high(interval) + low(interval))/2; }
+
+
+  struct y_i_low : gtl_yes {};
+
+  // set the low coordinate to v
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_low, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, void>::type 
+  low(interval_type& interval,
+      typename interval_traits<interval_type>::coordinate_type v) { set(interval, LOW, v); }
+  
+  struct y_i_high : gtl_yes {};
+
+  // set the high coordinate to v
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_high, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, void>::type 
+  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 interval_difference_type<interval_type>::type 
+  delta(const interval_type& interval,
+  typename enable_if< typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
+  ) { 
+    typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference diffT;
+    return (diffT)high(interval) - (diffT)low(interval); }
+
+  struct y_i_flip : gtl_yes {};
+
+  // flip this about coordinate
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_flip, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
+  flip(interval_type& interval,
+       typename interval_traits<interval_type>::coordinate_type axis = 0) {
+    typename interval_traits<interval_type>::coordinate_type newLow, newHigh;
+    newLow  = 2 * axis - high(interval);
+    newHigh = 2 * axis - low(interval);
+    low(interval, newLow);
+    high(interval, newHigh);
+    return interval;
+  }
+
+  struct y_i_scale_up : gtl_yes {};
+
+  // scale interval by factor
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_scale_up, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
+  scale_up(interval_type& interval, 
+           typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::unsigned_area_type factor) {
+    typedef typename interval_traits<interval_type>::coordinate_type Unit;
+    Unit newHigh = high(interval) * (Unit)factor;
+    low(interval, low(interval) * (Unit)factor);
+    high(interval, (newHigh));
+    return interval;
+  }
+
+  struct y_i_scale_down : gtl_yes {};
+
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_scale_down, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
+  scale_down(interval_type& interval, 
+             typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::unsigned_area_type factor) {
+    typedef typename interval_traits<interval_type>::coordinate_type Unit;
+    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;
+  }
+
+  struct y_i_scale : gtl_yes {};
+
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_scale, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
+  scale(interval_type& interval, double factor) {
+    typedef typename interval_traits<interval_type>::coordinate_type Unit;
+    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>
+  interval_type&
+  move(interval_type& interval,
+       typename interval_difference_type<interval_type>::type displacement,
+       typename enable_if<typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type * = 0
+       ) {
+    typedef typename interval_traits<interval_type>::coordinate_type ctype;
+    typedef typename coordinate_traits<ctype>::coordinate_difference Unit;
+    Unit len = delta(interval);
+    low(interval, static_cast<ctype>(static_cast<Unit>(low(interval)) + displacement));
+    high(interval, static_cast<ctype>(static_cast<Unit>(low(interval)) + len));
+    return interval;
+  }
+  
+  struct y_i_convolve : gtl_yes {};
+
+  // convolve this with b
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_convolve, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
+  convolve(interval_type& interval,
+           typename interval_traits<interval_type>::coordinate_type b) {
+    typedef typename interval_traits<interval_type>::coordinate_type Unit;
+    Unit newLow  = low(interval) + b;
+    Unit newHigh = high(interval) + b;
+    low(interval, newLow);
+    high(interval, newHigh);
+    return interval;
+  }
+
+  struct y_i_deconvolve : gtl_yes {};
+
+  // deconvolve this with b
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_deconvolve, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type &
+  deconvolve(interval_type& interval,
+             typename interval_traits<interval_type>::coordinate_type b) {
+    typedef typename interval_traits<interval_type>::coordinate_type Unit;
+    Unit newLow  = low(interval)  - b;
+    Unit newHigh = high(interval) - b;
+    low(interval, newLow);
+    high(interval, newHigh);
+    return interval;
+  }
+
+  struct y_i_convolve2 : gtl_yes {};
+
+  // convolve this with b
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_convolve2,
+                       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;
+  }
+  
+  struct y_i_deconvolve2 : gtl_yes {};
+
+  // deconvolve this with b
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3< y_i_deconvolve2,
+                        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;
+  }
+  
+  struct y_i_reconvolve : gtl_yes {};
+
+  // reflected convolve this with b
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_reconvolve,
+                       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;
+  }
+  
+  struct y_i_redeconvolve : gtl_yes {};
+
+  // reflected deconvolve this with b
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3< y_i_redeconvolve,
+                        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;
+  }
+  
+  struct y_i_e_dist1 : gtl_yes {};
+
+  // distance from a coordinate to an interval
+  template <typename interval_type>
+  typename enable_if< typename gtl_and<y_i_e_dist1, typename is_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+                       typename interval_difference_type<interval_type>::type>::type
+  euclidean_distance(const interval_type& interval,
+                     typename interval_traits<interval_type>::coordinate_type position) {
+    typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
+    Unit dist[3] = {0, (Unit)low(interval) - (Unit)position, (Unit)position - (Unit)high(interval)};
+    return dist[ (dist[1] > 0) + ((dist[2] > 0) << 1) ];
+  }
+
+  struct y_i_e_dist2 : gtl_yes {};
+  
+  // distance between two intervals
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_e_dist2, 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 interval_difference_type<interval_type>::type>::type
+  euclidean_distance(const interval_type& interval,
+                     const interval_type_2& b) {
+    typedef typename coordinate_traits<typename interval_traits<interval_type>::coordinate_type>::coordinate_difference Unit;
+    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) ];
+  }
+  
+  struct y_i_e_intersects : gtl_yes {};
+
+  // check if Interval b intersects `this` Interval
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_e_intersects, 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));
+  }
+
+  struct y_i_e_bintersect : gtl_yes {};
+
+  // check if Interval b partially overlaps `this` Interval
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_e_bintersect, 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));
+  }
+
+  struct y_i_abuts1 : gtl_yes {};
+
+  // check if they are end to end
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< typename gtl_and_3<y_i_abuts1, 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);
+  }
+
+  struct y_i_abuts2 : gtl_yes {};
+
+  // check if they are end to end
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_abuts2, 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);
+  } 
+
+  struct y_i_intersect : gtl_yes {};
+
+  // set 'this' interval to the intersection of 'this' and b
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< typename gtl_and_3<y_i_intersect, 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;
+  }
+
+  struct y_i_g_intersect : gtl_yes {};
+
+  // set 'this' interval to the generalized intersection of 'this' and b
+  template <typename interval_type, typename interval_type_2>
+  typename enable_if< 
+    typename gtl_and_3<y_i_g_intersect, 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
+    gtlsort(coords, coords+4);
+    low(interval, coords[1]);
+    high(interval, coords[2]);
+    return interval;
+  }
+
+  struct y_i_bloat : gtl_yes {};
+
+  // bloat the Interval
+  template <typename interval_type>
+  typename enable_if< typename gtl_and<y_i_bloat, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+                       interval_type>::type &
+  bloat(interval_type& interval, typename interval_traits<interval_type>::coordinate_type bloating) {
+    low(interval, low(interval)-bloating);
+    high(interval, high(interval)+bloating);
+    return interval;
+  }
+  
+  struct y_i_bloat2 : gtl_yes {};
+
+  // bloat the specified side of `this` Interval
+  template <typename interval_type>
+  typename enable_if< typename gtl_and<y_i_bloat2, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+                       interval_type>::type &
+  bloat(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type bloating) {
+    set(interval, dir, get(interval, dir) + dir.get_sign() * bloating);
+    return interval;
+  }
+
+  struct y_i_shrink : gtl_yes {};
+
+  // shrink the Interval
+  template <typename interval_type>
+  typename enable_if< typename gtl_and<y_i_shrink, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+                       interval_type>::type &
+  shrink(interval_type& interval, typename interval_traits<interval_type>::coordinate_type shrinking) {
+    return bloat(interval, -shrinking);
+  }
+
+  struct y_i_shrink2 : gtl_yes {};
+
+  // shrink the specified side of `this` Interval
+  template <typename interval_type>
+  typename enable_if< typename gtl_and<y_i_shrink2, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+                       interval_type>::type &
+  shrink(interval_type& interval, direction_1d dir, typename interval_traits<interval_type>::coordinate_type shrinking) {
+    return bloat(interval, dir, -shrinking);
+  }
+
+  // Enlarge `this` Interval to encompass the specified Interval
+  template <typename interval_type, typename interval_type_2>
+  bool
+  encompass(interval_type& interval, const interval_type_2& b,
+  typename enable_if<
+    typename gtl_and< typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type,
+            typename is_interval_concept<typename geometry_concept<interval_type_2>::type>::type>::type>::type * = 0
+  ) {
+    bool retval = !contains(interval, b, true);
+    low(interval, (std::min)(low(interval), low(b)));
+    high(interval, (std::max)(high(interval), high(b)));
+    return retval;
+  }    
+
+  struct y_i_encompass : gtl_yes {};
+
+  // Enlarge `this` Interval to encompass the specified Interval
+  template <typename interval_type>
+  typename enable_if< typename gtl_and<y_i_encompass, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type,
+                       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;
+  }    
+
+  struct y_i_get_half : gtl_yes {};
+
+  // gets the half of the interval as an interval
+  template <typename interval_type>
+  typename enable_if<typename gtl_and<y_i_get_half, typename is_mutable_interval_concept<typename geometry_concept<interval_type>::type>::type>::type, interval_type>::type 
+  get_half(const interval_type& interval, direction_1d d1d) {
+    typedef typename interval_traits<interval_type>::coordinate_type Unit;
+    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));
+  }
+
+  struct y_i_join_with : gtl_yes {};
+
+  // 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 enable_if< 
+    typename gtl_and_3<y_i_join_with, 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

test/external/boost/polygon/interval_data.hpp

@@ -0,0 +1,67 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_INTERVAL_DATA_HPP
+#define BOOST_POLYGON_INTERVAL_DATA_HPP
+#include "isotropy.hpp"
+namespace boost { namespace polygon{
+  template <typename T>
+  class interval_data {
+  public:
+    typedef T coordinate_type;
+    inline interval_data()
+#ifndef BOOST_POLYGON_MSVC 
+      :coords_() 
+#endif 
+    {} 
+    inline interval_data(coordinate_type low, coordinate_type high)
+#ifndef BOOST_POLYGON_MSVC 
+      :coords_() 
+#endif 
+    {
+      coords_[LOW] = low; coords_[HIGH] = high; 
+    }
+    inline interval_data(const interval_data& that)
+#ifndef BOOST_POLYGON_MSVC 
+      :coords_() 
+#endif 
+    {
+      (*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]; 
+};
+
+}
+}
+#endif

test/external/boost/polygon/interval_traits.hpp

@@ -0,0 +1,33 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_INTERVAL_TRAITS_HPP
+#define BOOST_POLYGON_INTERVAL_TRAITS_HPP
+namespace boost { namespace polygon{
+  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
+

test/external/boost/polygon/isotropy.hpp

@@ -0,0 +1,554 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+
+#ifndef BOOST_POLYGON_ISOTROPY_HPP
+#define BOOST_POLYGON_ISOTROPY_HPP
+
+//external
+#include <cmath>
+#include <cstddef>
+#include <cstdlib>
+#include <vector>
+#include <deque>
+#include <map>
+#include <set>
+#include <list>
+//#include <iostream>
+#include <algorithm>
+#include <limits>
+#include <iterator>
+#include <string>
+
+#ifndef BOOST_POLYGON_NO_DEPS
+
+#include <boost/config.hpp> 
+#ifdef BOOST_MSVC
+#define BOOST_POLYGON_MSVC
+#endif
+#ifdef BOOST_INTEL
+#define BOOST_POLYGON_ICC
+#endif
+#ifdef BOOST_HAS_LONG_LONG
+#define BOOST_POLYGON_USE_LONG_LONG
+typedef boost::long_long_type polygon_long_long_type;
+typedef boost::ulong_long_type polygon_ulong_long_type;
+//typedef long long polygon_long_long_type;
+//typedef unsigned long long polygon_ulong_long_type;
+#endif
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/protect.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#else
+
+#ifdef _WIN32
+#define BOOST_POLYGON_MSVC
+#endif
+#ifdef __ICC
+#define BOOST_POLYGON_ICC
+#endif
+#define BOOST_POLYGON_USE_LONG_LONG
+typedef long long polygon_long_long_type;
+typedef unsigned long long polygon_ulong_long_type;
+
+  namespace boost { 
+    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> {};
+  }
+
+#endif
+
+namespace boost { namespace polygon{
+
+  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 GCT, typename T>
+  struct view_of {};
+
+  template <typename T1, typename T2>
+  view_of<T1, T2> view_as(const T2& obj) { return view_of<T1, T2>(obj); }  
+
+  template <typename T>
+  struct coordinate_traits {};
+
+  template <typename T>
+  struct high_precision_type {
+    typedef long double type;
+  };
+
+  template <typename T>
+  T convert_high_precision_type(const typename high_precision_type<T>::type& v) {
+    return T(v);
+  }
+
+  template <>
+  struct coordinate_traits<int> {
+    typedef int coordinate_type;
+    typedef long double area_type;
+#ifdef BOOST_POLYGON_USE_LONG_LONG
+    typedef polygon_long_long_type manhattan_area_type;
+    typedef polygon_ulong_long_type unsigned_area_type;
+    typedef polygon_long_long_type coordinate_difference;
+#else
+    typedef long manhattan_area_type;
+    typedef unsigned long unsigned_area_type;
+    typedef long coordinate_difference;
+#endif
+    typedef long double coordinate_distance;
+  };
+
+#ifdef BOOST_POLYGON_USE_LONG_LONG
+  template <>
+  struct coordinate_traits<polygon_long_long_type> {
+    typedef polygon_long_long_type coordinate_type;
+    typedef long double area_type;
+    typedef polygon_long_long_type manhattan_area_type;
+    typedef polygon_ulong_long_type unsigned_area_type;
+    typedef polygon_long_long_type coordinate_difference;
+    typedef long double coordinate_distance;
+  };
+#endif
+
+  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 <>
+  struct coordinate_traits<long double> {
+    typedef long double coordinate_type;
+    typedef long double area_type;
+    typedef long double manhattan_area_type;
+    typedef long double unsigned_area_type;
+    typedef long double coordinate_difference;
+    typedef long double coordinate_distance;
+  };
+
+  template <typename T>
+  struct scaling_policy {
+    template <typename T2>
+    static inline T round(T2 t2) {
+      return (T)std::floor(t2+0.5);
+    }
+
+    static inline T round(T t2) {
+      return t2;
+    }
+  };
+
+  struct coordinate_concept {};
+
+  template <>
+  struct geometry_concept<int> { typedef coordinate_concept type; };
+#ifdef BOOST_POLYGON_USE_LONG_LONG
+  template <>
+  struct geometry_concept<polygon_long_long_type> { typedef coordinate_concept type; };
+#endif
+  template <>
+  struct geometry_concept<float> { typedef coordinate_concept type; };
+  template <>
+  struct geometry_concept<double> { typedef coordinate_concept type; };
+  template <>
+  struct geometry_concept<long double> { typedef coordinate_concept type; };
+
+#ifndef BOOST_POLYGON_NO_DEPS
+  struct gtl_no : mpl::bool_<false> {};
+  struct gtl_yes : mpl::bool_<true> {};
+  template <typename T, typename T2>
+  struct gtl_and : mpl::and_<T, T2> {};
+  template <typename T, typename T2, typename T3>
+  struct gtl_and_3 : mpl::and_<T, T2, T3> {};
+  template <typename T, typename T2, typename T3, typename T4>
+  struct gtl_and_4 : mpl::and_<T, T2, T3, T4> {};
+//  template <typename T, typename T2>
+//  struct gtl_or : mpl::or_<T, T2> {};
+//  template <typename T, typename T2, typename T3>
+//  struct gtl_or_3 : mpl::or_<T, T2, T3> {};
+//  template <typename T, typename T2, typename T3, typename T4>
+//  struct gtl_or_4 : mpl::or_<T, T2, T3, T4> {};
+#else
+  struct gtl_no { static const bool value = false; };
+  struct gtl_yes { typedef gtl_yes type;
+    static const bool value = true; };
+
+  template <bool T, bool T2>
+  struct gtl_and_c { typedef gtl_no type; };
+  template <>
+  struct gtl_and_c<true, true> { typedef gtl_yes type; };
+
+  template <typename T, typename T2>
+  struct gtl_and : gtl_and_c<T::value, T2::value> {};
+  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, typename T4>
+  struct gtl_and_4 { typedef typename gtl_and_3<
+                       T, T2, typename gtl_and<T3, T4>::type>::type type; };
+#endif
+  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_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 BOOST_POLYGON_MSVC
+    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; };
+
+  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; };
+
+  struct y_c_edist : gtl_yes {};
+
+  template <typename coordinate_type_1, typename coordinate_type_2>
+    typename enable_if< 
+    typename gtl_and_3<y_c_edist, 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 guarenteed 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, U are positive, S, W, D 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
+

test/external/boost/polygon/point_3d_concept.hpp

@@ -0,0 +1,270 @@
+/*
+  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
+#include "point_concept.hpp"
+#include "point_3d_data.hpp"
+#include "point_3d_traits.hpp"
+namespace boost { namespace polygon{
+  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 CT>
+  struct point_3d_coordinate_type_by_concept { typedef void type; };
+  template <typename T>
+  struct point_3d_coordinate_type_by_concept<T, gtl_yes> { typedef typename point_3d_traits<T>::coordinate_type type; };
+
+  template <typename T>
+  struct point_3d_coordinate_type {
+      typedef typename point_3d_coordinate_type_by_concept<T, typename is_point_3d_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  template <typename T, typename CT>
+  struct point_3d_difference_type_by_concept { typedef void type; };
+  template <typename T>
+  struct point_3d_difference_type_by_concept<T, gtl_yes> { 
+    typedef typename coordinate_traits<typename point_3d_traits<T>::coordinate_type>::coordinate_difference type; };
+
+  template <typename T>
+  struct point_3d_difference_type {
+      typedef typename point_3d_difference_type_by_concept<
+            T, typename is_point_3d_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  template <typename T, typename CT>
+  struct point_3d_distance_type_by_concept { typedef void type; };
+  template <typename T>
+  struct point_3d_distance_type_by_concept<T, gtl_yes> { 
+    typedef typename coordinate_traits<typename point_3d_traits<T>::coordinate_type>::coordinate_distance type; };
+
+  template <typename T>
+  struct point_3d_distance_type {
+    typedef typename point_3d_distance_type_by_concept<
+      T, typename is_point_3d_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  struct y_p3d_get : gtl_yes {};
+
+  template <typename T>
+  typename enable_if< typename gtl_and<y_p3d_get, typename gtl_if<typename is_point_3d_concept<typename geometry_concept<T>::type>::type>::type>::type, 
+                       typename point_3d_coordinate_type<T>::type >::type 
+  get(const T& point, orientation_3d orient) { return point_3d_traits<T>::get(point, orient); }
+  
+  struct y_p3d_set : gtl_yes {};
+
+  template <typename T, typename coordinate_type>
+  typename enable_if< typename gtl_and<y_p3d_set, typename is_mutable_point_3d_concept<typename geometry_concept<T>::type>::type>::type, void>::type
+  set(T& point, orientation_3d orient, coordinate_type value) { point_3d_mutable_traits<T>::set(point, orient, value); }
+
+  struct y_p3d_set2 : gtl_yes {};
+
+  template <typename T, typename coordinate_type>
+  typename enable_if< typename gtl_and<y_p3d_set2, typename is_mutable_point_3d_concept<typename geometry_concept<T>::type>::type>::type, void>::type
+  set(T& point, orientation_2d orient, coordinate_type value) { point_3d_mutable_traits<T>::set(point, orient, value); }
+
+  struct y_p3d_construct : gtl_yes {};
+
+  template <typename T, typename coordinate_type1, typename coordinate_type2, typename coordinate_type3>
+  typename enable_if< typename gtl_and<y_p3d_construct, typename is_mutable_point_3d_concept<typename geometry_concept<T>::type>::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); }
+
+  struct y_p3d_assign : gtl_yes {};
+ 
+  template <typename point_3d_type_1, typename point_3d_type_2>
+  typename enable_if<
+    typename gtl_and_3<y_p3d_assign, 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;
+  }
+
+  struct y_p3d_z : gtl_yes {};
+
+  template <typename point_type>
+  typename enable_if< typename gtl_and<y_p3d_z, typename is_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, 
+                       typename point_3d_traits<point_type>::coordinate_type >::type 
+  z(const point_type& point) { return get(point, PROXIMAL); }
+
+  struct y_p3d_x : gtl_yes {};
+
+  template <typename point_type, typename coordinate_type>
+  typename enable_if< typename gtl_and<y_p3d_x, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, void>::type
+  x(point_type& point, coordinate_type value) { set(point, HORIZONTAL, value); }
+
+  struct y_p3d_y : gtl_yes {};
+
+  template <typename point_type, typename coordinate_type>
+  typename enable_if< typename gtl_and<y_p3d_y, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, void>::type
+  y(point_type& point, coordinate_type value) { set(point, VERTICAL, value); }
+
+  struct y_p3d_z2 : gtl_yes {};
+
+  template <typename point_type, typename coordinate_type>
+  typename enable_if< typename gtl_and<y_p3d_z2, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, void>::type
+  z(point_type& point, coordinate_type value) { set(point, PROXIMAL, value); }
+
+  struct y_p3d_equiv : gtl_yes {};
+
+  template <typename T, typename T2>
+  typename enable_if<
+    typename gtl_and_3<y_p3d_equiv, 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);
+  }
+
+  struct y_p3d_dist : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if< typename gtl_and_3<y_p3d_dist, 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 point_3d_difference_type<point_type_1>::type>::type
+  euclidean_distance(const point_type_1& point1, const point_type_2& point2, orientation_3d orient) {
+    typedef typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_difference return_type;
+    return_type return_value =
+      (return_type)get(point1, orient) - (return_type)get(point2, orient);
+    return return_value < 0 ? -return_value : return_value;
+  }
+
+  struct y_p3d_man_dist : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if< typename gtl_and_3<y_p3d_man_dist,  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 point_3d_difference_type<point_type_1>::type>::type
+  manhattan_distance(const point_type_1& point1, const point_type_2& point2) {
+    return euclidean_distance(point1, point2, HORIZONTAL) + euclidean_distance(point1, point2, VERTICAL) 
+      + euclidean_distance(point1, point2, PROXIMAL);
+  }
+
+  struct y_p3d_dist2 : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if< typename gtl_and_3< y_p3d_dist2, 
+    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 point_3d_distance_type<point_type_1>::type>::type
+  euclidean_distance(const point_type_1& point1, const point_type_2& point2) {
+    typedef typename coordinate_traits<typename point_3d_traits<point_type_1>::coordinate_type>::coordinate_distance return_value;
+    return_value pdist = (return_value)euclidean_distance(point1, point2, PROXIMAL);
+    pdist *= pdist;
+    return sqrt((double)(distance_squared(point1, point2) + pdist));
+  }
+  
+  struct y_p3d_convolve : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if< typename gtl_and_3<  y_p3d_convolve,
+    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;
+  }
+ 
+  struct y_p3d_deconvolve : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if<
+    typename gtl_and_3<y_p3d_deconvolve,  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;
+  }
+
+  struct y_p3d_scale_up : gtl_yes {};
+
+  template <typename point_type>
+  typename enable_if< typename gtl_and<y_p3d_scale_up, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, 
+                       point_type>::type &
+  scale_up(point_type& point, 
+           typename coordinate_traits<typename point_3d_traits<point_type>::coordinate_type>::unsigned_area_type factor) {
+    x(point, x(point) * (typename point_3d_traits<point_type>::coordinate_type)factor);
+    y(point, y(point) * (typename point_3d_traits<point_type>::coordinate_type)factor);
+    z(point, z(point) * (typename point_3d_traits<point_type>::coordinate_type)factor);
+    return point;
+  }
+
+  struct y_p3d_scale_down : gtl_yes {};
+
+  template <typename point_type>
+  typename enable_if< typename gtl_and<y_p3d_scale_down, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, 
+                       point_type>::type &
+  scale_down(point_type& point, 
+             typename coordinate_traits<typename point_3d_traits<point_type>::coordinate_type>::unsigned_area_type factor) {
+    typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+    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;
+  }
+
+  struct y_p3d_scale : gtl_yes {};
+
+  template <typename point_type, typename scaling_type>
+  typename enable_if< typename gtl_and<y_p3d_scale, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::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;
+  }
+
+  struct y_p3d_transform : gtl_yes {};
+
+  template <typename point_type, typename transformation_type>
+  typename enable_if< typename gtl_and<y_p3d_transform, typename is_mutable_point_3d_concept<typename geometry_concept<point_type>::type>::type>::type, 
+                       point_type>::type &
+  transform(point_type& point, const transformation_type& transformation) {
+    typedef typename point_3d_traits<point_type>::coordinate_type Unit;
+    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
+

test/external/boost/polygon/point_3d_data.hpp

@@ -0,0 +1,51 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POINT_3D_DATA_HPP
+#define BOOST_POLYGON_POINT_3D_DATA_HPP
+namespace boost { namespace polygon{
+  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)
+#ifndef BOOST_POLYGON_MSVC
+      :coords_()
+#endif
+    {
+      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 bool operator==(const point_3d_data& that) const {
+      return coords_[0] == that.coords_[0] && coords_[1] == that.coords_[1] && coords_[2] == that.coords_[2];
+    }
+    inline bool operator!=(const point_3d_data& that) const {
+      return !((*this) == that);
+    }
+    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
+
+

test/external/boost/polygon/point_3d_traits.hpp

@@ -0,0 +1,35 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POINT_3D_TRAITS_HPP
+#define BOOST_POLYGON_POINT_3D_TRAITS_HPP
+
+#include "isotropy.hpp"
+
+namespace boost { namespace polygon{
+  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
+

test/external/boost/polygon/point_concept.hpp

@@ -0,0 +1,298 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POINT_CONCEPT_HPP
+#define BOOST_POLYGON_POINT_CONCEPT_HPP
+#include "isotropy.hpp"
+#include "point_data.hpp"
+#include "point_traits.hpp"
+
+namespace boost { namespace polygon{
+  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 CT>
+  struct point_coordinate_type_by_concept { typedef void type; };
+  template <typename T>
+  struct point_coordinate_type_by_concept<T, gtl_yes> { typedef typename point_traits<T>::coordinate_type type; };
+
+  template <typename T>
+  struct point_coordinate_type {
+      typedef typename point_coordinate_type_by_concept<T, typename is_point_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  template <typename T, typename CT>
+  struct point_difference_type_by_concept { typedef void type; };
+  template <typename T>
+  struct point_difference_type_by_concept<T, gtl_yes> { 
+    typedef typename coordinate_traits<typename point_traits<T>::coordinate_type>::coordinate_difference type; };
+
+  template <typename T>
+  struct point_difference_type {
+      typedef typename point_difference_type_by_concept<
+            T, typename is_point_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  template <typename T, typename CT>
+  struct point_distance_type_by_concept { typedef void type; };
+  template <typename T>
+  struct point_distance_type_by_concept<T, gtl_yes> { 
+    typedef typename coordinate_traits<typename point_traits<T>::coordinate_type>::coordinate_distance type; };
+
+  template <typename T>
+  struct point_distance_type {
+      typedef typename point_distance_type_by_concept<
+            T, typename is_point_concept<typename geometry_concept<T>::type>::type>::type type;
+  };
+
+  template <typename T>
+  typename point_coordinate_type<T>::type 
+  get(const T& point, orientation_2d orient,
+  typename enable_if< typename gtl_if<typename is_point_concept<typename geometry_concept<T>::type>::type>::type>::type * = 0
+  ) {
+    return point_traits<T>::get(point, orient);
+  }
+  
+  template <typename T, typename coordinate_type>
+  void 
+  set(T& point, orientation_2d orient, coordinate_type value,
+  typename enable_if<typename is_mutable_point_concept<typename geometry_concept<T>::type>::type>::type * = 0
+  ) {
+    point_mutable_traits<T>::set(point, orient, value);
+  }
+  
+  template <typename T, typename coordinate_type1, typename coordinate_type2>
+  T
+  construct(coordinate_type1 x_value, coordinate_type2 y_value,
+  typename enable_if<typename is_mutable_point_concept<typename geometry_concept<T>::type>::type>::type * = 0
+  ) {
+    return point_mutable_traits<T>::construct(x_value, y_value); 
+  }
+
+  template <typename T1, typename T2>
+  T1&
+  assign(T1& lvalue, const T2& rvalue,
+  typename enable_if< typename gtl_and< typename is_mutable_point_concept<typename geometry_concept<T1>::type>::type,
+                                         typename is_point_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
+  ) {
+    set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
+    set(lvalue, VERTICAL, get(rvalue, VERTICAL));
+    return lvalue;
+  }
+
+  struct y_p_x : gtl_yes {};
+
+  template <typename point_type>
+  typename enable_if< typename gtl_and<y_p_x, typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type, 
+                       typename point_traits<point_type>::coordinate_type >::type 
+  x(const point_type& point) {
+    return get(point, HORIZONTAL);
+  }
+
+  struct y_p_y : gtl_yes {};
+
+  template <typename point_type>
+  typename enable_if< typename gtl_and<y_p_y, typename is_point_concept<typename geometry_concept<point_type>::type>::type>::type, 
+                       typename point_traits<point_type>::coordinate_type >::type 
+  y(const point_type& point) {
+    return get(point, VERTICAL);
+  }
+
+  struct y_p_sx : gtl_yes {};
+
+  template <typename point_type, typename coordinate_type>
+  typename enable_if<typename gtl_and<y_p_sx, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+                      void>::type 
+  x(point_type& point, coordinate_type value) {
+    set(point, HORIZONTAL, value);
+  }
+
+  struct y_p_sy : gtl_yes {};
+
+  template <typename point_type, typename coordinate_type>
+  typename enable_if<typename gtl_and<y_p_sy, typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type,
+                      void>::type 
+  y(point_type& point, coordinate_type value) {
+    set(point, VERTICAL, value);
+  }
+
+  template <typename T, typename T2>
+  bool
+  equivalence(const T& point1, const T2& point2,
+    typename enable_if< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<T>::type>::type,
+              typename is_point_concept<typename geometry_concept<T2>::type>::type>::type>::type * = 0
+  ) {
+    typename point_traits<T>::coordinate_type x1 = x(point1);
+    typename point_traits<T2>::coordinate_type x2 = get(point2, HORIZONTAL);
+    typename point_traits<T>::coordinate_type y1 = get(point1, VERTICAL);
+    typename point_traits<T2>::coordinate_type y2 = y(point2);
+    return x1 == x2 && y1 == y2;
+  }
+
+  template <typename point_type_1, typename point_type_2>
+  typename point_difference_type<point_type_1>::type
+  manhattan_distance(const point_type_1& point1, const point_type_2& point2,
+  typename enable_if< typename gtl_and<typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type, 
+  typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0) {
+    return euclidean_distance(point1, point2, HORIZONTAL) + euclidean_distance(point1, point2, VERTICAL);
+  }
+  
+  struct y_i_ed1 : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if< typename gtl_and_3<y_i_ed1, typename is_point_concept<typename geometry_concept<point_type_1>::type>::type, 
+  typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type,
+  typename point_difference_type<point_type_1>::type>::type
+  euclidean_distance(const point_type_1& point1, const point_type_2& point2, orientation_2d orient) {
+    typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference return_value =
+      get(point1, orient) - get(point2, orient);
+    return return_value < 0 ? (typename coordinate_traits<typename point_traits<point_type_1>::coordinate_type>::coordinate_difference)-return_value : return_value;
+  }
+  
+  struct y_i_ed2 : gtl_yes {};
+
+  template <typename point_type_1, typename point_type_2>
+  typename enable_if< typename gtl_and_3<y_i_ed2, typename gtl_same_type<point_concept, typename geometry_concept<point_type_1>::type>::type,
+  typename gtl_same_type<point_concept, typename geometry_concept<point_type_2>::type>::type>::type,
+  typename point_distance_type<point_type_1>::type>::type
+  euclidean_distance(const point_type_1& point1, const point_type_2& point2) {
+    typedef typename point_traits<point_type_1>::coordinate_type Unit;
+    return sqrt((double)(distance_squared(point1, point2)));
+  }
+  
+  template <typename point_type_1, typename point_type_2>
+  typename point_difference_type<point_type_1>::type
+  distance_squared(const point_type_1& point1, const point_type_2& point2,
+    typename enable_if< typename gtl_and<typename is_point_concept<typename geometry_concept<point_type_1>::type>::type,
+                   typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0
+  ) {
+    typedef typename point_traits<point_type_1>::coordinate_type Unit;
+    typename 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>
+  point_type_1 &
+  convolve(point_type_1& lvalue, const point_type_2& rvalue,
+  typename enable_if< typename gtl_and<typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type, 
+  typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0
+  ) {
+    x(lvalue, x(lvalue) + x(rvalue));
+    y(lvalue, y(lvalue) + y(rvalue));
+    return lvalue;
+  }
+  
+  template <typename point_type_1, typename point_type_2>
+  point_type_1 &
+  deconvolve(point_type_1& lvalue, const point_type_2& rvalue,
+  typename enable_if< typename gtl_and<typename is_mutable_point_concept<typename geometry_concept<point_type_1>::type>::type, 
+  typename is_point_concept<typename geometry_concept<point_type_2>::type>::type>::type>::type * = 0
+  ) {
+    x(lvalue, x(lvalue) - x(rvalue));
+    y(lvalue, y(lvalue) - y(rvalue));
+    return lvalue;
+  }
+  
+  template <typename point_type, typename coord_type>
+  point_type &
+  scale_up(point_type& point, coord_type factor,
+  typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
+  ) {
+    typedef typename point_traits<point_type>::coordinate_type Unit;
+    x(point, x(point) * (Unit)factor);
+    y(point, y(point) * (Unit)factor);
+    return point;
+  }
+
+  template <typename point_type, typename coord_type>
+  point_type &
+  scale_down(point_type& point, coord_type factor,
+  typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
+  ) {
+    typedef typename point_traits<point_type>::coordinate_type Unit;
+    typedef typename coordinate_traits<Unit>::coordinate_distance dt;
+    x(point, scaling_policy<Unit>::round((dt)((dt)(x(point)) / (dt)factor))); 
+    y(point, scaling_policy<Unit>::round((dt)((dt)(y(point)) / (dt)factor))); 
+    return point;
+  }
+
+  template <typename point_type, typename scaling_type>
+  point_type &
+  scale(point_type& point, 
+        const scaling_type& scaling,
+        typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
+        ) {
+    typedef typename point_traits<point_type>::coordinate_type Unit;
+    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>
+  point_type &
+  transform(point_type& point, const transformation_type& transformation,
+  typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
+  ) {
+    typedef typename point_traits<point_type>::coordinate_type Unit;
+    Unit x_(x(point)), y_(y(point));
+    transformation.transform(x_, y_);
+    x(point, x_);
+    y(point, y_);
+    return point;
+  }
+
+  struct y_pt_move : gtl_yes {};
+
+  template <typename point_type>
+  typename enable_if< 
+    typename gtl_and< y_pt_move, 
+                      typename is_mutable_point_concept<
+      typename geometry_concept<point_type>::type>::type>::type, 
+    point_type>::type &
+  move(point_type& point, orientation_2d orient,
+       typename point_traits<point_type>::coordinate_type displacement,
+       typename enable_if<typename is_mutable_point_concept<typename geometry_concept<point_type>::type>::type>::type * = 0
+       ) {
+    typedef typename point_traits<point_type>::coordinate_type Unit;
+    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
+

test/external/boost/polygon/point_data.hpp

@@ -0,0 +1,105 @@
+/*
+  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 boost { namespace polygon{
+
+  template <typename T>
+  class point_data {
+  public:
+    typedef T coordinate_type;
+    inline point_data()
+#ifndef BOOST_POLYGON_MSVC
+      :coords_()  
+#endif
+    {} 
+    inline point_data(coordinate_type x, coordinate_type y)
+#ifndef BOOST_POLYGON_MSVC
+      :coords_()  
+#endif
+    {
+      coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; 
+    }
+    inline point_data(const point_data& that)
+#ifndef BOOST_POLYGON_MSVC
+      :coords_() 
+#endif
+    { (*this) = that; }
+    template <typename other>
+    point_data(const other& that)
+#ifndef BOOST_POLYGON_MSVC
+      :coords_()  
+#endif
+    { (*this) = that; }
+    inline point_data& operator=(const point_data& that) {
+      coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this; 
+    }
+    template<typename T1, typename T2>
+    inline point_data(const T1& x, const T2& y)
+#ifndef BOOST_POLYGON_MSVC
+      :coords_()  
+#endif
+    {
+      coords_[HORIZONTAL] = (coordinate_type)x;
+      coords_[VERTICAL] = (coordinate_type)y;
+    }
+    template <typename T2>
+    inline point_data(const point_data<T2>& rvalue)
+#ifndef BOOST_POLYGON_MSVC
+      :coords_()  
+#endif
+    {
+      coords_[HORIZONTAL] = (coordinate_type)(rvalue.x());
+      coords_[VERTICAL] = (coordinate_type)(rvalue.y());
+    }
+    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 bool operator<=(const point_data& that) const { return !(that < *this); }
+    inline bool operator>(const point_data& that) const { return that < *this; }
+    inline bool operator>=(const point_data& that) const { return !((*this) < that); }
+    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]; 
+  };
+
+}
+}
+#endif
+

test/external/boost/polygon/point_traits.hpp

@@ -0,0 +1,35 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POINT_TRAITS_HPP
+#define BOOST_POLYGON_POINT_TRAITS_HPP
+
+#include "isotropy.hpp"
+
+namespace boost { namespace polygon{
+  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
+

test/external/boost/polygon/polygon.hpp

@@ -0,0 +1,91 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_HPP
+#define BOOST_POLYGON_POLYGON_HPP
+#define BOOST_POLYGON_VERSION 014401
+
+#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 "detail/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 "detail/iterator_points_to_compact.hpp"
+#include "detail/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 "detail/boolean_op.hpp"
+#include "detail/polygon_formation.hpp"
+#include "detail/rectangle_formation.hpp"
+#include "detail/max_cover.hpp"
+#include "detail/property_merge.hpp"
+#include "detail/polygon_90_touch.hpp"
+#include "detail/iterator_geometry_to_set.hpp"
+
+//45 boolean op algorithms
+#include "detail/boolean_op_45.hpp"
+#include "detail/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 "detail/polygon_90_set_view.hpp"
+
+//45 boolean op algorithms
+#include "detail/polygon_45_touch.hpp"
+#include "detail/property_merge_45.hpp"
+#include "polygon_45_set_data.hpp"
+#include "polygon_45_set_traits.hpp"
+#include "polygon_45_set_concept.hpp"
+#include "detail/polygon_45_set_view.hpp"
+
+//arbitrary polygon algorithms
+#include "detail/polygon_arbitrary_formation.hpp"
+#include "polygon_set_data.hpp"
+
+//general scanline
+#include "detail/scan_arbitrary.hpp"
+#include "polygon_set_traits.hpp"
+#include "detail/polygon_set_view.hpp"
+
+#include "polygon_set_concept.hpp"
+
+#endif

test/external/boost/polygon/polygon_45_data.hpp

@@ -0,0 +1,73 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_45_DATA_HPP
+#define BOOST_POLYGON_POLYGON_45_DATA_HPP
+#include "isotropy.hpp"
+namespace boost { namespace polygon{
+struct polygon_45_concept;
+template <typename T> class polygon_data;
+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(std::size_t 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(); }
+
+public:
+  std::vector<point_data<coordinate_type> > coords_; 
+};
+
+
+}
+}
+#endif
+

test/external/boost/polygon/polygon_45_set_concept.hpp

@@ -0,0 +1,441 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_45_SET_CONCEPT_HPP
+#define BOOST_POLYGON_POLYGON_45_SET_CONCEPT_HPP
+#include "polygon_45_set_data.hpp"
+#include "polygon_45_set_traits.hpp"
+#include "detail/polygon_45_touch.hpp"
+namespace boost { namespace polygon{
+
+  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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if<
+    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 enable_if< 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(std::size_t 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 enable_if <
+    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(std::size_t 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 enable_if< 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 enable_if< 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 enable_if< 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, static_cast<typename polygon_45_set_traits<polygon_set_type>::coordinate_type>(bloating));
+  }
+
+  template <typename polygon_set_type>
+  typename enable_if< 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 enable_if< 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(std::size_t 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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;
+  }
+
+  template <typename T>
+  struct view_of<polygon_90_set_concept, T> {
+    typedef typename get_coordinate_type<T, typename geometry_concept<T>::type >::type coordinate_type;
+    T* tp;
+    std::vector<polygon_90_with_holes_data<coordinate_type> > polys;
+    view_of(T& obj) : tp(&obj), polys() {
+      std::vector<polygon_with_holes_data<coordinate_type> > gpolys;
+      assign(gpolys, obj);
+      for(typename std::vector<polygon_with_holes_data<coordinate_type> >::iterator itr = gpolys.begin();
+          itr != gpolys.end(); ++itr) {
+        polys.push_back(polygon_90_with_holes_data<coordinate_type>());
+        assign(polys.back(), view_as<polygon_90_with_holes_concept>(*itr));
+      }
+    }
+    view_of(const T& obj) : tp(), polys() {
+      std::vector<polygon_with_holes_data<coordinate_type> > gpolys;
+      assign(gpolys, obj);
+      for(typename std::vector<polygon_with_holes_data<coordinate_type> >::iterator itr = gpolys.begin();
+          itr != gpolys.end(); ++itr) {
+        polys.push_back(polygon_90_with_holes_data<coordinate_type>());
+        assign(polys.back(), view_as<polygon_90_with_holes_concept>(*itr));
+      }
+    }
+
+    typedef typename std::vector<polygon_90_with_holes_data<coordinate_type> >::const_iterator iterator_type;
+    typedef view_of operator_arg_type;
+
+    inline iterator_type begin() const {
+      return polys.begin();
+    }
+
+    inline iterator_type end() const {
+      return polys.end();
+    }
+
+    inline orientation_2d orient() const { return HORIZONTAL; }
+
+    inline bool clean() const { return false; }
+
+    inline bool sorted() const { return false; }
+
+    inline T& get() { return *tp; }
+
+  };
+
+  template <typename T>
+  struct polygon_90_set_traits<view_of<polygon_90_set_concept, T> > {
+    typedef typename view_of<polygon_90_set_concept, T>::coordinate_type coordinate_type;
+    typedef typename view_of<polygon_90_set_concept, T>::iterator_type iterator_type;
+    typedef view_of<polygon_90_set_concept, T> operator_arg_type;
+
+    static inline iterator_type begin(const view_of<polygon_90_set_concept, T>& polygon_set) {
+      return polygon_set.begin();
+    }
+
+    static inline iterator_type end(const view_of<polygon_90_set_concept, T>& polygon_set) {
+      return polygon_set.end();
+    }
+
+    static inline orientation_2d orient(const view_of<polygon_90_set_concept, T>& polygon_set) { 
+      return polygon_set.orient(); }
+
+    static inline bool clean(const view_of<polygon_90_set_concept, T>& polygon_set) { 
+      return polygon_set.clean(); }
+
+    static inline bool sorted(const view_of<polygon_90_set_concept, T>& polygon_set) { 
+      return polygon_set.sorted(); }
+
+  };
+
+  template <typename T>
+  struct geometry_concept<view_of<polygon_90_set_concept, T> > {
+    typedef polygon_90_set_concept type;
+  };
+
+  template <typename T>
+  struct get_coordinate_type<view_of<polygon_90_set_concept, T>, polygon_90_set_concept> {
+    typedef typename view_of<polygon_90_set_concept, T>::coordinate_type type;
+  };
+  template <typename T>
+  struct get_iterator_type_2<view_of<polygon_90_set_concept, T>, polygon_90_set_concept> {
+    typedef typename view_of<polygon_90_set_concept, T>::iterator_type type;
+    static type begin(const view_of<polygon_90_set_concept, T>& t) { return t.begin(); }
+    static type end(const view_of<polygon_90_set_concept, T>& t) { return t.end(); }
+  };
+
+}
+}
+#include "detail/polygon_45_set_view.hpp"
+#endif

test/external/boost/polygon/polygon_45_set_traits.hpp

@@ -0,0 +1,146 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_45_SET_TRAITS_HPP
+#define BOOST_POLYGON_POLYGON_45_SET_TRAITS_HPP
+namespace boost { namespace polygon{
+
+  //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& ) { return false; }
+
+    static inline bool sorted(const T& ) { 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 gtl_or<
+      typename is_45_polygonal_concept<typename geometry_concept<std::list<T> >::type>::type,
+      typename is_45_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type>::type type;
+  };
+  template <typename T>
+  struct is_polygon_45_set_type<std::vector<T> > { 
+    typedef typename gtl_or<
+      typename is_45_polygonal_concept<typename geometry_concept<std::vector<T> >::type>::type,
+      typename is_45_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::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 gtl_or<
+      typename gtl_same_type<polygon_45_set_concept, typename geometry_concept<std::list<T> >::type>::type,
+      typename is_45_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type>::type type;
+  };
+  template <typename T>
+  struct is_mutable_polygon_45_set_type<std::vector<T> > { 
+    typedef typename gtl_or<
+      typename gtl_same_type<polygon_45_set_concept, typename geometry_concept<std::vector<T> >::type>::type,
+      typename is_45_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::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();
+      ps.clean();
+      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();
+      ps.clean();
+      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) { polygon_set.sort(); return true; }
+
+  };
+}  
+}
+#endif
+

test/external/boost/polygon/polygon_45_with_holes_data.hpp

@@ -0,0 +1,108 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_45_WITH_HOLES_DATA_HPP
+#define BOOST_POLYGON_POLYGON_45_WITH_HOLES_DATA_HPP
+#include "isotropy.hpp"
+#include "polygon_45_data.hpp"
+namespace boost { namespace polygon{
+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;
+  }
+
+  template <typename T2>
+  inline polygon_45_with_holes_data& operator=(const T2& rvalue);
+
+  // 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 std::size_t 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 std::size_t size_holes() const {
+    return holes_.size();
+  }
+
+public:
+  polygon_45_data<coordinate_type> self_;
+  std::list<hole_type> holes_; 
+};
+
+
+}
+}
+#endif
+

test/external/boost/polygon/polygon_90_data.hpp

@@ -0,0 +1,80 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_DATA_HPP
+#define BOOST_POLYGON_POLYGON_90_DATA_HPP
+namespace boost { namespace polygon{
+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(); }
+  
+private:
+  std::vector<coordinate_type> coords_; 
+};
+
+
+}
+}
+#endif
+

test/external/boost/polygon/polygon_90_set_concept.hpp

@@ -0,0 +1,548 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_SET_CONCEPT_HPP
+#define BOOST_POLYGON_POLYGON_90_SET_CONCEPT_HPP
+#include "polygon_90_set_data.hpp"
+#include "polygon_90_set_traits.hpp"
+namespace boost { namespace polygon{
+
+  template <typename polygon_set_type>
+  typename enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if <
+    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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if <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 enable_if< 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 enable_if< 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 enable_if <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 enable_if< 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(std::size_t 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 enable_if <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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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(std::size_t 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 enable_if< 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 enable_if< 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 enable_if< 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>
+  polygon_set_type&
+  move(polygon_set_type& polygon_set,
+  orientation_2d orient, typename polygon_90_set_traits<polygon_set_type>::coordinate_type displacement,
+       typename enable_if< typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type * = 0) {
+    if(orient == HORIZONTAL)
+      return move(polygon_set, displacement, 0);
+    else 
+      return move(polygon_set, 0, displacement);
+  }
+
+  template <typename polygon_set_type>
+  polygon_set_type&
+  move(polygon_set_type& polygon_set, typename polygon_90_set_traits<polygon_set_type>::coordinate_type x_displacement, 
+  typename polygon_90_set_traits<polygon_set_type>::coordinate_type y_displacement,
+  typename enable_if< typename is_mutable_polygon_90_set_type<polygon_set_type>::type>::type * = 0
+  ) {
+    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 enable_if< 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 enable_if< 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;
+  }
+
+
+}
+}
+#include "detail/polygon_90_set_view.hpp"
+#endif

test/external/boost/polygon/polygon_90_set_data.hpp

@@ -0,0 +1,957 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_SET_DATA_HPP
+#define BOOST_POLYGON_POLYGON_90_SET_DATA_HPP
+#include "isotropy.hpp"
+#include "point_concept.hpp"
+#include "point_3d_concept.hpp"
+#include "transform.hpp"
+#include "interval_concept.hpp"
+#include "rectangle_concept.hpp"
+#include "detail/iterator_points_to_compact.hpp"
+#include "detail/iterator_compact_to_points.hpp"
+#include "polygon_traits.hpp"
+
+//manhattan boolean algorithms
+#include "detail/boolean_op.hpp"
+#include "detail/polygon_formation.hpp"
+#include "detail/rectangle_formation.hpp"
+#include "detail/max_cover.hpp"
+#include "detail/property_merge.hpp"
+#include "detail/polygon_90_touch.hpp"
+#include "detail/iterator_geometry_to_set.hpp"
+
+namespace boost { namespace polygon{
+  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) : 
+      orient_(orient), data_(), 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;
+    }
+
+    // insert iterator range
+    inline void insert(iterator_type input_begin, iterator_type input_end, orientation_2d orient = HORIZONTAL) {
+      if(input_begin == input_end || (!data_.empty() && &(*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 = 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, false, orient_);
+      vertex.second.first = edge.first.get(HIGH);
+      vertex.second.second *= -1;
+      insert(vertex, false, orient_);
+    }
+
+    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) {
+          ::boost::polygon::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(); }
+
+    // get the Polygon set size in vertices
+    inline std::size_t size() const { clean(); return data_.size(); }
+
+    // get the current Polygon set capacity in vertices
+    inline std::size_t capacity() const { return data_.capacity(); }
+
+    // reserve size of polygon set in vertices
+    inline void reserve(std::size_t size) { return data_.reserve(size); }
+
+    // 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_; }
+
+    // Start BM
+    // The problem: If we have two polygon sets with two different scanline orientations:
+    // I tried changing the orientation of one to coincide with other (If not, resulting boolean operation
+    // produces spurious results).
+    // First I tried copying polygon data from one of the sets into another set with corrected orientation
+    // using one of the copy constructor that takes in orientation (see somewhere above in this file) --> copy constructor throws error
+    // Then I tried another approach:(see below). This approach also fails to produce the desired results when test case is run.
+    // Here is the part that beats me: If I comment out the whole section, I can do all the operations (^=, -=, &= )these commented out
+    // operations perform. So then why do we need them?. Hence, I commented out this whole section.
+    // End BM
+    // polygon_90_set_data<coordinate_type>& operator-=(const polygon_90_set_data& that) {
+    //   sort();
+    //   that.sort();
+    //   value_type data;
+    //   std::swap(data, data_);
+    //   applyBooleanBinaryOp(data.begin(), data.end(),
+    //                        that.begin(), that.end(), boolean_op::BinaryCount<boolean_op::BinaryNot>()); 
+    //   return *this;
+    // }
+    // polygon_90_set_data<coordinate_type>& operator^=(const polygon_90_set_data& that) {
+    //   sort();
+    //   that.sort();
+    //   value_type data;
+    //   std::swap(data, data_);
+    //   applyBooleanBinaryOp(data.begin(), data.end(),
+    //                        that.begin(), that.end(),  boolean_op::BinaryCount<boolean_op::BinaryXor>()); 
+    //   return *this;
+    // }
+    // polygon_90_set_data<coordinate_type>& operator&=(const polygon_90_set_data& that) {
+    //   sort();
+    //   that.sort();
+    //   value_type data;
+    //   std::swap(data, data_);
+    //   applyBooleanBinaryOp(data.begin(), data.end(),
+    //                        that.begin(), that.end(), boolean_op::BinaryCount<boolean_op::BinaryAnd>()); 
+    //   return *this;
+    // }
+    // polygon_90_set_data<coordinate_type>& operator|=(const polygon_90_set_data& that) {
+    //   insert(that);
+    //   return *this;
+    // }
+
+    void clean() const {
+      sort();
+      if(dirty_) {
+        boolean_op::default_arg_workaround<int>::applyBooleanOr(data_);
+        dirty_ = false;
+      }
+    }
+
+    void sort() const{
+      if(unsorted_) {
+        gtlsort(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(std::size_t 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&
+    bloat2(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;
+      clean();
+      rects.reserve(data_.size() / 2); 
+      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;
+    }
+
+    static void modify_pt(point_data<coordinate_type>& pt, const point_data<coordinate_type>&  prev_pt,
+                          const point_data<coordinate_type>&  current_pt,  const point_data<coordinate_type>&  next_pt,
+                          coordinate_type west_bloating,
+                          coordinate_type east_bloating,
+                          coordinate_type south_bloating,
+                          coordinate_type north_bloating) {
+      bool pxl = prev_pt.x() < current_pt.x();
+      bool pyl = prev_pt.y() < current_pt.y();
+      bool nxl = next_pt.x() < current_pt.x();
+      bool nyl = next_pt.y() < current_pt.y();
+      bool pxg = prev_pt.x() > current_pt.x();
+      bool pyg = prev_pt.y() > current_pt.y();
+      bool nxg = next_pt.x() > current_pt.x();
+      bool nyg = next_pt.y() > current_pt.y();
+      //two of the four if statements will execute
+      if(pxl)
+        pt.y(current_pt.y() - south_bloating);
+      if(pxg)
+        pt.y(current_pt.y() + north_bloating);
+      if(nxl)
+        pt.y(current_pt.y() + north_bloating);
+      if(nxg)
+        pt.y(current_pt.y() - south_bloating);
+      if(pyl)
+        pt.x(current_pt.x() + east_bloating);
+      if(pyg)
+        pt.x(current_pt.x() - west_bloating);
+      if(nyl)
+        pt.x(current_pt.x() - west_bloating);
+      if(nyg)
+        pt.x(current_pt.x() + east_bloating);
+    }
+    static void resize_poly_up(std::vector<point_data<coordinate_type> >& poly, 
+                               coordinate_type west_bloating,
+                               coordinate_type east_bloating,
+                               coordinate_type south_bloating,
+                               coordinate_type north_bloating) {
+      point_data<coordinate_type> first_pt = poly[0];
+      point_data<coordinate_type> second_pt = poly[1];
+      point_data<coordinate_type> prev_pt = poly[0];
+      point_data<coordinate_type> current_pt = poly[1];
+      for(std::size_t i = 2; i < poly.size(); ++i) {
+        point_data<coordinate_type> next_pt = poly[i];
+        modify_pt(poly[i-1], prev_pt, current_pt, next_pt, west_bloating, east_bloating, south_bloating, north_bloating);
+        prev_pt = current_pt;
+        current_pt = next_pt;
+      }
+      point_data<coordinate_type> next_pt = first_pt;
+      modify_pt(poly.back(), prev_pt, current_pt, next_pt, west_bloating, east_bloating, south_bloating, north_bloating);
+      prev_pt = current_pt;
+      current_pt = next_pt;
+      next_pt = second_pt;
+      modify_pt(poly[0], prev_pt, current_pt, next_pt, west_bloating, east_bloating, south_bloating, north_bloating);
+      remove_colinear_pts(poly);
+    }
+    static bool resize_poly_down(std::vector<point_data<coordinate_type> >& poly, 
+                                 coordinate_type west_shrinking,
+                                 coordinate_type east_shrinking,
+                                 coordinate_type south_shrinking,
+                                 coordinate_type north_shrinking) {
+      rectangle_data<coordinate_type> extents_rectangle;
+      set_points(extents_rectangle, poly[0], poly[0]);
+      point_data<coordinate_type> first_pt = poly[0];
+      point_data<coordinate_type> second_pt = poly[1];
+      point_data<coordinate_type> prev_pt = poly[0];
+      point_data<coordinate_type> current_pt = poly[1];
+      encompass(extents_rectangle, current_pt);
+      for(int i = 2; i < poly.size(); ++i) {
+        point_data<coordinate_type> next_pt = poly[i];
+        encompass(extents_rectangle, next_pt);
+        modify_pt(poly[i-1], prev_pt, current_pt, next_pt, west_shrinking, east_shrinking, south_shrinking, north_shrinking);
+        prev_pt = current_pt;
+        current_pt = next_pt;
+      }
+      if(delta(extents_rectangle, HORIZONTAL) < std::abs(west_shrinking + east_shrinking))
+        return false;
+      if(delta(extents_rectangle, VERTICAL) < std::abs(north_shrinking + south_shrinking))
+        return false;
+      point_data<coordinate_type> next_pt = first_pt;
+      modify_pt(poly.back(), prev_pt, current_pt, next_pt, west_shrinking, east_shrinking, south_shrinking, north_shrinking);
+      prev_pt = current_pt;
+      current_pt = next_pt;
+      next_pt = second_pt;
+      modify_pt(poly[0], prev_pt, current_pt, next_pt, west_shrinking, east_shrinking, south_shrinking, north_shrinking);
+      return remove_colinear_pts(poly);
+    }
+
+    static bool remove_colinear_pts(std::vector<point_data<coordinate_type> >& poly) {
+      bool found_colinear = true;
+      while(found_colinear && poly.size() >= 4) {
+        found_colinear = false;
+        typename std::vector<point_data<coordinate_type> >::iterator itr = poly.begin(); 
+        itr += poly.size() - 1; //get last element position
+        typename std::vector<point_data<coordinate_type> >::iterator itr2 = poly.begin();
+        typename std::vector<point_data<coordinate_type> >::iterator itr3 = itr2;
+        ++itr3;
+        std::size_t count = 0;
+        for( ; itr3 < poly.end(); ++itr3) {
+          if(((*itr).x() == (*itr2).x() && (*itr).x() == (*itr3).x()) ||
+             ((*itr).y() == (*itr2).y() && (*itr).y() == (*itr3).y()) ) {
+            ++count;
+            found_colinear = true;
+          } else {
+            itr = itr2;
+            ++itr2;
+          }
+          *itr2 = *itr3;
+        }
+        itr3 = poly.begin();
+        if(((*itr).x() == (*itr2).x() && (*itr).x() == (*itr3).x()) ||
+           ((*itr).y() == (*itr2).y() && (*itr).y() == (*itr3).y()) ) {
+          ++count;
+          found_colinear = true;
+        }
+        poly.erase(poly.end() - count, poly.end());
+      }
+      return poly.size() >= 4;
+    }    
+
+    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::list<polygon_45_with_holes_data<coordinate_type> > polys;
+      get(polys);
+      clear();
+      for(typename std::list<polygon_45_with_holes_data<coordinate_type> >::iterator itr = polys.begin();
+          itr != polys.end(); ++itr) {
+        //polygon_90_set_data<coordinate_type> psref;
+        //psref.insert(view_as<polygon_90_concept>((*itr).self_));
+        //rectangle_data<coordinate_type> prerect;
+        //psref.extents(prerect);
+        resize_poly_up((*itr).self_.coords_, west_bloating, east_bloating, south_bloating, north_bloating);
+        iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+          begin_input(view_as<polygon_90_concept>((*itr).self_), LOW, orient_, false, true, COUNTERCLOCKWISE), 
+          end_input(view_as<polygon_90_concept>((*itr).self_), HIGH, orient_, false, true, COUNTERCLOCKWISE);
+        insert(begin_input, end_input, orient_);
+        //polygon_90_set_data<coordinate_type> pstest;
+        //pstest.insert(view_as<polygon_90_concept>((*itr).self_));
+        //psref.bloat2(west_bloating, east_bloating, south_bloating, north_bloating);
+        //if(!equivalence(psref, pstest)) {
+        // std::cout << "test failed\n";
+        //}
+        for(typename std::list<polygon_45_data<coordinate_type> >::iterator itrh = (*itr).holes_.begin();
+            itrh != (*itr).holes_.end(); ++itrh) {
+          //rectangle_data<coordinate_type> rect;
+          //psref.extents(rect);
+          //polygon_90_set_data<coordinate_type> psrefhole;
+          //psrefhole.insert(prerect);
+          //psrefhole.insert(view_as<polygon_90_concept>(*itrh), true);
+          //polygon_45_data<coordinate_type> testpoly(*itrh);
+          if(resize_poly_down((*itrh).coords_, west_bloating, east_bloating, south_bloating, north_bloating)) {
+            iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+              begin_input2(view_as<polygon_90_concept>(*itrh), LOW, orient_, true, true), 
+              end_input2(view_as<polygon_90_concept>(*itrh), HIGH, orient_, true, true);
+            insert(begin_input2, end_input2, orient_);
+            //polygon_90_set_data<coordinate_type> pstesthole;
+            //pstesthole.insert(rect);
+            //iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+            // begin_input2(view_as<polygon_90_concept>(*itrh), LOW, orient_, true, true); 
+            //pstesthole.insert(begin_input2, end_input, orient_);
+            //psrefhole.bloat2(west_bloating, east_bloating, south_bloating, north_bloating);
+            //if(!equivalence(psrefhole, pstesthole)) {
+            // std::cout << (winding(testpoly) == CLOCKWISE) << std::endl;
+            // std::cout << (winding(*itrh) == CLOCKWISE) << std::endl;
+            // polygon_90_set_data<coordinate_type> c(psrefhole);
+            // c.clean();
+            // polygon_90_set_data<coordinate_type> a(pstesthole);
+            // polygon_90_set_data<coordinate_type> b(pstesthole);
+            // a.sort();
+            // b.clean();
+            // std::cout << "test hole failed\n";
+            // //std::cout << testpoly << std::endl;
+            //}
+          }
+        }
+      }
+      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) {
+      std::list<polygon_45_with_holes_data<coordinate_type> > polys;
+      get(polys);
+      clear();
+      for(typename std::list<polygon_45_with_holes_data<coordinate_type> >::iterator itr = polys.begin();
+          itr != polys.end(); ++itr) {
+        //polygon_90_set_data<coordinate_type> psref;
+        //psref.insert(view_as<polygon_90_concept>((*itr).self_));
+        //rectangle_data<coordinate_type> prerect;
+        //psref.extents(prerect);
+        //polygon_45_data<coordinate_type> testpoly((*itr).self_);
+        if(resize_poly_down((*itr).self_.coords_, -west_shrinking, -east_shrinking, -south_shrinking, -north_shrinking)) {
+          iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+            begin_input(view_as<polygon_90_concept>((*itr).self_), LOW, orient_, false, true, COUNTERCLOCKWISE), 
+            end_input(view_as<polygon_90_concept>((*itr).self_), HIGH, orient_, false, true, COUNTERCLOCKWISE);
+          insert(begin_input, end_input, orient_);
+          //iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+          //  begin_input2(view_as<polygon_90_concept>((*itr).self_), LOW, orient_, false, true, COUNTERCLOCKWISE); 
+          //polygon_90_set_data<coordinate_type> pstest;
+          //pstest.insert(begin_input2, end_input, orient_);
+          //psref.shrink2(west_shrinking, east_shrinking, south_shrinking, north_shrinking);
+          //if(!equivalence(psref, pstest)) {
+          //  std::cout << "test failed\n";
+          //}
+          for(typename std::list<polygon_45_data<coordinate_type> >::iterator itrh = (*itr).holes_.begin();
+              itrh != (*itr).holes_.end(); ++itrh) {
+            //rectangle_data<coordinate_type> rect;
+            //psref.extents(rect);
+            //polygon_90_set_data<coordinate_type> psrefhole;
+            //psrefhole.insert(prerect);
+            //psrefhole.insert(view_as<polygon_90_concept>(*itrh), true);
+            //polygon_45_data<coordinate_type> testpoly(*itrh);
+            resize_poly_up((*itrh).coords_, -west_shrinking, -east_shrinking, -south_shrinking, -north_shrinking);
+            iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+              begin_input2(view_as<polygon_90_concept>(*itrh), LOW, orient_, true, true), 
+              end_input2(view_as<polygon_90_concept>(*itrh), HIGH, orient_, true, true);
+            insert(begin_input2, end_input2, orient_);
+            //polygon_90_set_data<coordinate_type> pstesthole;
+            //pstesthole.insert(rect);
+            //iterator_geometry_to_set<polygon_90_concept, view_of<polygon_90_concept, polygon_45_data<coordinate_type> > >
+            //  begin_input2(view_as<polygon_90_concept>(*itrh), LOW, orient_, true, true); 
+            //pstesthole.insert(begin_input2, end_input, orient_);
+            //psrefhole.shrink2(west_shrinking, east_shrinking, south_shrinking, north_shrinking);
+            //if(!equivalence(psrefhole, pstesthole)) {
+            //  std::cout << (winding(testpoly) == CLOCKWISE) << std::endl;
+            //  std::cout << (winding(*itrh) == CLOCKWISE) << std::endl;
+            //  polygon_90_set_data<coordinate_type> c(psrefhole);
+            //  c.clean();
+            //  polygon_90_set_data<coordinate_type> a(pstesthole);
+            //  polygon_90_set_data<coordinate_type> b(pstesthole);
+            //  a.sort();
+            //  b.clean();
+            //  std::cout << "test hole failed\n";
+            //  //std::cout << testpoly << std::endl;
+            //}
+          }
+        }
+      }
+      return *this;
+    }
+
+    polygon_90_set_data&
+    shrink2(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;
+      ::boost::polygon::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;
+      rects.reserve(data_.size() / 2); 
+      //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&
+    shrink(direction_2d dir, typename coordinate_traits<coordinate_type>::unsigned_area_type shrinking) {
+      if(dir == WEST)
+        return shrink(shrinking, 0, 0, 0);
+      if(dir == EAST)
+        return shrink(0, shrinking, 0, 0);
+      if(dir == SOUTH)
+        return shrink(0, 0, shrinking, 0);
+      return shrink(0, 0, 0, shrinking);
+    }
+
+    polygon_90_set_data&
+    bloat(direction_2d dir, typename coordinate_traits<coordinate_type>::unsigned_area_type shrinking) {
+      if(dir == WEST)
+        return bloat(shrinking, 0, 0, 0);
+      if(dir == EAST)
+        return bloat(0, shrinking, 0, 0);
+      if(dir == SOUTH)
+        return bloat(0, 0, shrinking, 0);
+      return bloat(0, 0, 0, shrinking);
+    }
+
+    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;
+    }
+    template <typename scaling_type>
+    polygon_90_set_data& scale_with(const 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(std::size_t 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 ) 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();
+      ::boost::polygon::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_; return *this; }
+    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
+

test/external/boost/polygon/polygon_90_set_traits.hpp

@@ -0,0 +1,362 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_SET_TRAITS_HPP
+#define BOOST_POLYGON_POLYGON_90_SET_TRAITS_HPP
+namespace boost { namespace polygon{
+
+  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&) { return HORIZONTAL; }
+
+    static inline bool clean(const T&) { return false; }
+
+    static inline bool sorted(const T&) { 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 gtl_or<
+      typename is_manhattan_polygonal_concept<typename geometry_concept<std::list<T> >::type>::type,
+      typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type>::type type;
+  };
+  template <typename T>
+  struct is_polygon_90_set_type<std::vector<T> > { 
+    typedef typename gtl_or<
+      typename is_manhattan_polygonal_concept<typename geometry_concept<std::vector<T> >::type>::type,
+      typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::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 gtl_or<
+      typename gtl_same_type<polygon_90_set_concept, typename geometry_concept<std::list<T> >::type>::type, 
+      typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type>::type type;
+  };
+  template <typename T>
+  struct is_mutable_polygon_90_set_type<std::vector<T> > { 
+    typedef typename gtl_or<
+      typename gtl_same_type<polygon_90_set_concept, typename geometry_concept<std::vector<T> >::type>::type, 
+      typename is_manhattan_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::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 ) {
+    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 enable_if<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 enable_if<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
+

test/external/boost/polygon/polygon_90_with_holes_data.hpp

@@ -0,0 +1,116 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_90_WITH_HOLES_DATA_HPP
+#define BOOST_POLYGON_POLYGON_90_WITH_HOLES_DATA_HPP
+namespace boost { namespace polygon{
+#include "isotropy.hpp"
+#include "polygon_90_data.hpp"
+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;
+  }
+
+  template <typename T2>
+  inline polygon_90_with_holes_data& operator=(const T2& rvalue);
+
+  // 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 std::size_t 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 std::size_t size_holes() const {
+    return holes_.size();
+  }
+
+private:
+  polygon_90_data<coordinate_type> self_;
+  std::list<hole_type> holes_; 
+};
+}
+}
+#endif
+

test/external/boost/polygon/polygon_data.hpp

@@ -0,0 +1,70 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_DATA_HPP
+#define BOOST_POLYGON_POLYGON_DATA_HPP
+namespace boost { namespace polygon{
+struct polygon_concept;
+template <typename T>
+class polygon_data {
+public:
+  typedef polygon_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_data() : coords_() {} //do nothing default constructor
+
+  template<class iT>
+  inline polygon_data(iT input_begin, iT input_end) : coords_(input_begin, input_end) {}
+
+  template<class iT>
+  inline polygon_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_data(const polygon_data& that) : coords_(that.coords_) {}
+  
+  // assignment operator (since we have dynamic memory do a deep copy)
+  inline polygon_data& operator=(const polygon_data& that) {
+    coords_ = that.coords_;
+    return *this;
+  }
+
+  template <typename T2>
+  inline polygon_data& operator=(const T2& rvalue);
+
+  inline bool operator==(const polygon_data& that) const {
+    if(coords_.size() != that.coords_.size()) return false;
+    for(std::size_t i = 0; i < coords_.size(); ++i) {
+      if(coords_[i] != that.coords_[i]) return false;
+    }
+    return true;
+  }
+
+  inline bool operator!=(const polygon_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(); }
+
+public:
+  std::vector<point_data<coordinate_type> > coords_; 
+};
+
+}
+}
+#endif
+

test/external/boost/polygon/polygon_set_concept.hpp

@@ -0,0 +1,581 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_SET_CONCEPT_HPP
+#define BOOST_POLYGON_POLYGON_SET_CONCEPT_HPP
+#include "polygon_set_data.hpp"
+#include "detail/polygon_simplify.hpp"
+namespace boost { namespace polygon{
+
+  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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< typename is_mutable_polygon_set_type<polygon_set_type>::type,
+                      void>::type
+  get_trapezoids(output_container_type& output, const polygon_set_type& polygon_set) {
+    polygon_set_data<typename polygon_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 enable_if< typename is_mutable_polygon_set_type<polygon_set_type>::type,
+                      void>::type
+  get_trapezoids(output_container_type& output, const polygon_set_type& polygon_set,
+                 orientation_2d orient) {
+    polygon_set_data<typename polygon_set_traits<polygon_set_type>::coordinate_type> ps;
+    assign(ps, polygon_set);
+    ps.get_trapezoids(output, orient);
+  }
+
+  //equivalence
+  template <typename polygon_set_type_1, typename polygon_set_type_2>
+  typename enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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(std::size_t i = 0; i < polys.size(); ++i) {
+      retval += area(polys[i]);
+    }
+    return retval;
+  }
+
+  template <typename polygon_set_type>
+  typename enable_if< typename is_mutable_polygon_set_type<polygon_set_type>::type,
+                      std::size_t>::type
+  simplify(polygon_set_type& polygon_set, typename coordinate_traits<
+           typename polygon_set_traits<polygon_set_type>::coordinate_type
+           >::coordinate_distance threshold) {
+    typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+    typedef polygon_with_holes_data<Unit> p_type;
+    std::vector<p_type> polys;
+    assign(polys, polygon_set);
+    std::size_t retval = 0;
+    for(std::size_t i = 0; i < polys.size(); ++i) {
+      retval += detail::simplify_detail::simplify(polys[i].self_.coords_, 
+                                                  polys[i].self_.coords_, threshold);
+      for(typename std::list<polygon_data<Unit> >::iterator itrh = 
+            polys[i].holes_.begin(); itrh != (polys[i].holes_.end()); ++itrh) {
+        retval += detail::simplify_detail::simplify((*itrh).coords_, 
+                                                    (*itrh).coords_, threshold);
+      }
+    }
+    assign(polygon_set, polys);
+    return retval;
+  }
+
+  template <typename polygon_set_type, typename coord_type>
+  typename enable_if< typename is_mutable_polygon_set_type<polygon_set_type>::type,
+                       polygon_set_type>::type &
+  resize(polygon_set_type& polygon_set, coord_type resizing, bool corner_fill_arcs = false, int num_circle_segments = 0) {
+    typedef typename polygon_set_traits<polygon_set_type>::coordinate_type Unit;
+    clean(polygon_set);
+    polygon_set_data<Unit> ps;
+    assign(ps, polygon_set);
+    ps.resize(resizing, corner_fill_arcs,num_circle_segments);
+    assign(polygon_set, ps);
+    return polygon_set;
+  }
+
+  template <typename polygon_set_type>
+  typename enable_if< typename is_mutable_polygon_set_type<polygon_set_type>::type,
+                       polygon_set_type>::type &
+  bloat(polygon_set_type& polygon_set,
+        typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type bloating) {
+    return resize(polygon_set, bloating);
+  }
+
+  template <typename polygon_set_type>
+  typename enable_if< typename is_mutable_polygon_set_type<polygon_set_type>::type,
+                       polygon_set_type>::type &
+  shrink(polygon_set_type& polygon_set,
+        typename coordinate_traits<typename polygon_set_traits<polygon_set_type>::coordinate_type>::unsigned_area_type shrinking) {
+    return resize(polygon_set, -(typename polygon_set_traits<polygon_set_type>::coordinate_type)shrinking);
+  }
+
+  //interact
+  template <typename polygon_set_type_1, typename polygon_set_type_2>
+  typename enable_if< 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,
+    polygon_set_type_1>::type&
+  interact(polygon_set_type_1& polygon_set_1, const polygon_set_type_2& polygon_set_2) {
+    polygon_set_data<typename polygon_set_traits<polygon_set_type_1>::coordinate_type> ps1;
+    assign(ps1, polygon_set_1);
+    polygon_set_data<typename polygon_set_traits<polygon_set_type_2>::coordinate_type> ps2;
+    assign(ps2, polygon_set_2);
+    ps1.interact(ps2);
+    assign(polygon_set_1, ps1);
+    return polygon_set_1;
+  }
+
+  template <typename polygon_set_type>
+  typename enable_if< 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 enable_if< 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 enable_if< 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 enable_if< 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;
+  }
+
+  namespace operators {
+
+  struct yes_ps_ob : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4 < yes_ps_ob, 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);
+  }
+
+  struct yes_ps_op : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4 < yes_ps_op,
+    typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type, 
+    typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type, 
+    typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type>
+    ::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);
+  }
+  
+  struct yes_ps_os : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4 < yes_ps_os, 
+    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);
+  }
+
+  struct yes_ps_oa : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4 < yes_ps_oa,
+    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);
+  }
+
+  struct yes_ps_ox : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4 < yes_ps_ox,
+    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);
+  }
+  
+  struct yes_ps_om : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+    typename enable_if< typename gtl_and_4 < yes_ps_om,
+    typename gtl_if<typename is_any_polygon_set_type<geometry_type_1>::type>::type, 
+    typename gtl_if<typename is_any_polygon_set_type<geometry_type_2>::type>::type, 
+    typename gtl_if<typename is_either_polygon_set_type<geometry_type_1, geometry_type_2>::type>::type>
+    ::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);
+  }
+ 
+  struct yes_ps_ope : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_4< yes_ps_ope, gtl_yes, 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);
+  }
+
+  struct yes_ps_obe : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< yes_ps_obe, 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);
+  }
+
+  struct yes_ps_ose : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< yes_ps_ose, 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);
+  }
+
+  struct yes_ps_oae : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if<
+    typename gtl_and_3< yes_ps_oae, 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);
+  }
+
+  struct yes_ps_oxe : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< typename gtl_and_3< yes_ps_oxe, 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);
+  }
+
+  struct yes_ps_ome : gtl_yes {};
+
+  template <typename geometry_type_1, typename geometry_type_2>
+  typename enable_if< 
+    typename gtl_and_3< yes_ps_ome, 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);
+  }
+
+  // TODO: Dafna, test these four resizing operators
+  struct y_ps_rpe : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3< y_ps_rpe, typename is_mutable_polygon_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);
+  }
+
+  struct y_ps_rme : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps_rme, typename gtl_if<typename is_mutable_polygon_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);
+  }
+
+  struct y_ps_rp : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps_rp, typename gtl_if<typename is_mutable_polygon_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+(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+    geometry_type_1 retval(lvalue);
+    retval += rvalue;
+    return retval;
+  }
+
+  struct y_ps_rm : gtl_yes {};
+
+  template <typename geometry_type_1, typename coordinate_type_1>
+  typename enable_if< typename gtl_and_3<y_ps_rm, typename gtl_if<typename is_mutable_polygon_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-(const geometry_type_1& lvalue, coordinate_type_1 rvalue) {
+    geometry_type_1 retval(lvalue);
+    retval -= rvalue;
+    return retval;
+  }
+
+
+  } //end operators namespace
+
+  template <typename T>
+  struct view_of<polygon_45_set_concept, T> {
+    typedef typename get_coordinate_type<T, typename geometry_concept<T>::type >::type coordinate_type;
+    T* tp;
+    std::vector<polygon_45_with_holes_data<coordinate_type> > polys;
+    view_of(const T& obj) : tp(), polys() {
+      std::vector<polygon_with_holes_data<coordinate_type> > gpolys;
+      assign(gpolys, obj);
+      for(typename std::vector<polygon_with_holes_data<coordinate_type> >::iterator itr = gpolys.begin();
+          itr != gpolys.end(); ++itr) {
+        polys.push_back(polygon_45_with_holes_data<coordinate_type>());
+        assign(polys.back(), view_as<polygon_45_with_holes_concept>(*itr));
+      }
+    }
+    view_of(T& obj) : tp(&obj), polys() {
+      std::vector<polygon_with_holes_data<coordinate_type> > gpolys;
+      assign(gpolys, obj);
+      for(typename std::vector<polygon_with_holes_data<coordinate_type> >::iterator itr = gpolys.begin();
+          itr != gpolys.end(); ++itr) {
+        polys.push_back(polygon_45_with_holes_data<coordinate_type>());
+        assign(polys.back(), view_as<polygon_45_with_holes_concept>(*itr));
+      }
+    }
+
+    typedef typename std::vector<polygon_45_with_holes_data<coordinate_type> >::const_iterator iterator_type;
+    typedef view_of operator_arg_type;
+
+    inline iterator_type begin() const {
+      return polys.begin();
+    }
+
+    inline iterator_type end() const {
+      return polys.end();
+    }
+
+    inline orientation_2d orient() const { return HORIZONTAL; }
+
+    inline bool clean() const { return false; }
+
+    inline bool sorted() const { return false; }
+
+    inline T& get() { return *tp; }
+  };
+
+  template <typename T>
+  struct polygon_45_set_traits<view_of<polygon_45_set_concept, T> > {
+    typedef typename view_of<polygon_45_set_concept, T>::coordinate_type coordinate_type;
+    typedef typename view_of<polygon_45_set_concept, T>::iterator_type iterator_type;
+    typedef view_of<polygon_45_set_concept, T> operator_arg_type;
+
+    static inline iterator_type begin(const view_of<polygon_45_set_concept, T>& polygon_set) {
+      return polygon_set.begin();
+    }
+
+    static inline iterator_type end(const view_of<polygon_45_set_concept, T>& polygon_set) {
+      return polygon_set.end();
+    }
+
+    static inline orientation_2d orient(const view_of<polygon_45_set_concept, T>& polygon_set) { 
+      return polygon_set.orient(); }
+
+    static inline bool clean(const view_of<polygon_45_set_concept, T>& polygon_set) { 
+      return polygon_set.clean(); }
+
+    static inline bool sorted(const view_of<polygon_45_set_concept, T>& polygon_set) { 
+      return polygon_set.sorted(); }
+
+  };
+
+  template <typename T>
+  struct geometry_concept<view_of<polygon_45_set_concept, T> > {
+    typedef polygon_45_set_concept type;
+  };
+
+  template <typename T>
+  struct get_coordinate_type<view_of<polygon_45_set_concept, T>, polygon_45_set_concept> {
+    typedef typename view_of<polygon_45_set_concept, T>::coordinate_type type;
+  };
+  template <typename T>
+  struct get_iterator_type_2<view_of<polygon_45_set_concept, T>, polygon_45_set_concept> {
+    typedef typename view_of<polygon_45_set_concept, T>::iterator_type type;
+    static type begin(const view_of<polygon_45_set_concept, T>& t) { return t.begin(); }
+    static type end(const view_of<polygon_45_set_concept, T>& t) { return t.end(); }
+  };
+}
+}
+#endif

test/external/boost/polygon/polygon_set_traits.hpp

@@ -0,0 +1,130 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_SET_TRAITS_HPP
+#define BOOST_POLYGON_POLYGON_SET_TRAITS_HPP
+namespace boost { namespace polygon{
+
+  struct polygon_set_concept {};
+
+  //default definition of polygon set traits works for any model of polygon , polygon with holes or any vector or list thereof
+  template <typename T>
+  struct polygon_set_traits {
+    typedef typename get_coordinate_type<T, typename geometry_concept<T>::type >::type coordinate_type;
+    typedef typename get_iterator_type<T>::type iterator_type;
+    typedef T operator_arg_type;
+
+    static inline iterator_type begin(const T& polygon_set) {
+      return get_iterator_type<T>::begin(polygon_set);
+    }
+
+    static inline iterator_type end(const T& polygon_set) {
+      return get_iterator_type<T>::end(polygon_set);
+    }
+
+    static inline bool clean(const T& ) { return false; }
+
+    static inline bool sorted(const T& ) { return false; }
+  };
+
+  template <typename T>
+  struct is_polygonal_concept { typedef gtl_no type; };
+  template <>
+  struct is_polygonal_concept<polygon_concept> { typedef gtl_yes type; };
+  template <>
+  struct is_polygonal_concept<polygon_with_holes_concept> { typedef gtl_yes type; };
+  template <>
+  struct is_polygonal_concept<polygon_set_concept> { typedef gtl_yes type; };
+
+  template <typename T>
+  struct is_polygon_set_type {
+    typedef typename is_polygonal_concept<typename geometry_concept<T>::type>::type type;
+  };
+  template <typename T>
+  struct is_polygon_set_type<std::list<T> > { 
+    typedef typename gtl_or<
+      typename is_polygonal_concept<typename geometry_concept<std::list<T> >::type>::type,
+      typename is_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type>::type type;
+  };
+  template <typename T>
+  struct is_polygon_set_type<std::vector<T> > { 
+    typedef typename gtl_or<
+      typename is_polygonal_concept<typename geometry_concept<std::vector<T> >::type>::type,
+      typename is_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type>::type type;
+  };
+
+  template <typename T>
+  struct is_mutable_polygon_set_type {
+    typedef typename gtl_same_type<polygon_set_concept, typename geometry_concept<T>::type>::type type;
+  };
+  template <typename T>
+  struct is_mutable_polygon_set_type<std::list<T> > { 
+    typedef typename gtl_or<
+      typename gtl_same_type<polygon_set_concept, typename geometry_concept<std::list<T> >::type>::type, 
+      typename is_polygonal_concept<typename geometry_concept<typename std::list<T>::value_type>::type>::type>::type type;
+  };
+  template <typename T>
+  struct is_mutable_polygon_set_type<std::vector<T> > { 
+    typedef typename gtl_or<
+      typename gtl_same_type<polygon_set_concept, typename geometry_concept<std::vector<T> >::type>::type,
+      typename is_polygonal_concept<typename geometry_concept<typename std::vector<T>::value_type>::type>::type>::type type;
+  };
+
+  template <typename T>
+  struct polygon_set_mutable_traits {};
+  template <typename T>
+  struct polygon_set_mutable_traits<std::list<T> > {
+    template <typename input_iterator_type>
+    static inline void set(std::list<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end) {
+      polygon_set.clear();
+      polygon_set_data<typename polygon_set_traits<std::list<T> >::coordinate_type> ps;
+      ps.insert(input_begin, input_end);
+      ps.get(polygon_set);
+    }
+  };
+  template <typename T>
+  struct polygon_set_mutable_traits<std::vector<T> > {
+    template <typename input_iterator_type>
+    static inline void set(std::vector<T>& polygon_set, input_iterator_type input_begin, input_iterator_type input_end) {
+      polygon_set.clear();
+      polygon_set_data<typename polygon_set_traits<std::list<T> >::coordinate_type> ps;
+      ps.insert(input_begin, input_end);
+      ps.get(polygon_set);
+    }
+  };
+
+  template <typename T>
+  struct polygon_set_mutable_traits<polygon_set_data<T> > {
+    template <typename input_iterator_type>
+    static inline void set(polygon_set_data<T>& polygon_set, 
+                           input_iterator_type input_begin, input_iterator_type input_end) {
+      polygon_set.set(input_begin, input_end);
+    }
+  };
+  template <typename T>
+  struct polygon_set_traits<polygon_set_data<T> > {
+    typedef typename polygon_set_data<T>::coordinate_type coordinate_type;
+    typedef typename polygon_set_data<T>::iterator_type iterator_type;
+    typedef typename polygon_set_data<T>::operator_arg_type operator_arg_type;
+
+    static inline iterator_type begin(const polygon_set_data<T>& polygon_set) {
+      return polygon_set.begin();
+    }
+
+    static inline iterator_type end(const polygon_set_data<T>& polygon_set) {
+      return polygon_set.end();
+    }
+
+    static inline bool clean(const polygon_set_data<T>& polygon_set) { polygon_set.clean(); return true; }
+
+    static inline bool sorted(const polygon_set_data<T>& polygon_set) { polygon_set.sort(); return true; }
+
+  };
+}  
+}
+#endif
+

test/external/boost/polygon/polygon_with_holes_data.hpp

@@ -0,0 +1,108 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_POLYGON_WITH_HOLES_DATA_HPP
+#define BOOST_POLYGON_POLYGON_WITH_HOLES_DATA_HPP
+#include "isotropy.hpp"
+#include "polygon_data.hpp"
+namespace boost { namespace polygon{
+  struct polygon_with_holes_concept;
+  template <typename T>
+  class polygon_with_holes_data {
+public:
+  typedef polygon_with_holes_concept geometry_type;
+  typedef T coordinate_type;
+  typedef typename polygon_data<T>::iterator_type iterator_type;
+  typedef typename std::list<polygon_data<coordinate_type> >::const_iterator iterator_holes_type;
+  typedef polygon_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_with_holes_data() : self_(), holes_() {} //do nothing default constructor
+
+  template<class iT>
+  inline polygon_with_holes_data(iT input_begin, iT input_end) : self_(), holes_() {
+    set(input_begin, input_end);
+  }
+
+  template<class iT, typename hiT>
+  inline polygon_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_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_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_with_holes_data(const polygon_with_holes_data& that) : self_(that.self_), 
+                                                                  holes_(that.holes_) {}
+  
+  // assignment operator (since we have dynamic memory do a deep copy)
+  inline polygon_with_holes_data& operator=(const polygon_with_holes_data& that) {
+    self_ = that.self_;
+    holes_ = that.holes_;
+    return *this;
+  }
+
+  template <typename T2>
+  inline polygon_with_holes_data& operator=(const T2& rvalue);
+
+  // 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 std::size_t 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 std::size_t size_holes() const {
+    return holes_.size();
+  }
+
+public:
+  polygon_data<coordinate_type> self_;
+  std::list<hole_type> holes_; 
+  };
+  
+
+}
+}
+#endif
+

test/external/boost/polygon/rectangle_data.hpp

@@ -0,0 +1,64 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_RECTANGLE_DATA_HPP
+#define BOOST_POLYGON_RECTANGLE_DATA_HPP
+
+#include "isotropy.hpp"
+//interval
+#include "interval_data.hpp"
+
+namespace boost { namespace polygon{
+
+template <typename T>
+class rectangle_data {
+public:
+  typedef T coordinate_type;
+  typedef interval_data<T> interval_type;
+  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);
+    ranges_[VERTICAL] = interval_data<T>(yl, yh);
+  }
+  template <typename interval_type_1, typename interval_type_2>
+  inline rectangle_data(const interval_type_1& hrange,
+                        const interval_type_2& vrange):ranges_() {
+    set(HORIZONTAL, hrange); set(VERTICAL, vrange); }
+
+  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;
+  }
+  template <typename T2>
+  inline rectangle_data& operator=(const T2& rvalue);
+
+  template <typename T2>
+  inline bool operator==(const T2& rvalue) const;
+  template <typename T2>
+  inline bool operator!=(const T2& rvalue) const { return !((*this) == rvalue); }
+
+  inline interval_data<coordinate_type> get(orientation_2d orient) const {
+    return ranges_[orient.to_int()]; }
+  inline coordinate_type get(direction_2d dir) const {
+    return ranges_[orientation_2d(dir).to_int()].get(direction_1d(dir));
+  }
+  inline void set(direction_2d dir, coordinate_type value) {
+    return ranges_[orientation_2d(dir).to_int()].set(direction_1d(dir), value);
+  }
+  template <typename interval_type_1>
+  inline void set(orientation_2d orient, const interval_type_1& interval); 
+private:
+  interval_data<coordinate_type> ranges_[2]; 
+};
+
+
+}
+}
+#endif
+

test/external/boost/polygon/rectangle_traits.hpp

@@ -0,0 +1,38 @@
+/*
+  Copyright 2008 Intel Corporation
+ 
+  Use, modification and distribution are subject to the Boost Software License,
+  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_RECTANGLE_TRAITS_HPP
+#define BOOST_POLYGON_RECTANGLE_TRAITS_HPP
+namespace boost { namespace polygon{
+
+  template <typename T, typename enable = gtl_yes>
+  struct rectangle_traits {};
+  template <typename T>
+  struct rectangle_traits<T, gtl_no> {};
+
+  template <typename T>
+  struct rectangle_traits<T, typename gtl_same_type<typename T::interval_type, typename T::interval_type>::type> {
+    typedef typename T::coordinate_type coordinate_type;
+    typedef typename T::interval_type interval_type;
+    static inline interval_type get(const T& rectangle, orientation_2d orient) {
+      return rectangle.get(orient); }
+  };
+
+  template <typename T>
+  struct rectangle_mutable_traits {
+    template <typename T2>
+    static inline void set(T& rectangle, orientation_2d orient, const T2& interval) {
+      rectangle.set(orient, interval); }
+    template <typename T2, typename T3>
+    static inline T construct(const T2& interval_horizontal,
+                              const T3& interval_vertical) {
+      return T(interval_horizontal, interval_vertical); }
+  };
+}
+}
+#endif
+

test/external/boost/polygon/transform.hpp

@@ -0,0 +1,501 @@
+/*
+    Copyright 2008 Intel Corporation
+ 
+    Use, modification and distribution are subject to the Boost Software License,
+    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+*/
+#ifndef BOOST_POLYGON_TRANSFORM_HPP
+#define BOOST_POLYGON_TRANSFORM_HPP
+#include "isotropy.hpp"
+#include "point_3d_concept.hpp"
+namespace boost { namespace polygon{
+// Transformation of Coordinate Systems
+// Enum meaning:
+// Select which direction_3d to change the positive direction of each
+// axis in the old coordinate system to map it to the new coordiante system.
+// The first direction_3d listed for each enum is the direction to map the
+// positive horizontal direction to.
+// The second direction_3d listed for each enum is the direction to map the
+// positive vertical direction to.
+// The third direction_3d listed for each enum is the direction to map the
+// positive proximal direction to.
+// The zero position bit (LSB) indicates whether the horizontal axis flips
+// when transformed.
+// The 1st postion bit indicates whether the vertical axis flips when 
+// transformed.
+// The 2nd position bit indicates whether the horizontal and vertical axis
+// swap positions when transformed.
+// Note that the first eight values are the complete set of 2D transforms.
+// The 3rd position bit indicates whether the proximal axis flips when
+// transformed.
+// The 4th position bit indicates whether the proximal and horizontal axis are
+// swapped when transformed.  It changes the meaning of the 2nd position bit
+// to mean that the horizontal and vertical axis are swapped in their new
+// positions, naturally.
+// The 5th position bit (MSB) indicates whether the proximal and vertical axis
+// are swapped when transformed.  It is mutually exclusive with the 4th postion
+// bit, making the maximum legal value 48 (decimal).  It similarly changes the
+// meaning of the 2nd position bit to mean that the horizontal and vertical are
+// swapped in their new positions.
+// Enum Values:
+// 000000 EAST NORTH UP 
+// 000001 WEST NORTH UP 
+// 000010 EAST SOUTH UP 
+// 000011 WEST SOUTH UP 
+// 000100 NORTH EAST UP 
+// 000101 SOUTH EAST UP 
+// 000110 NORTH WEST UP 
+// 000111 SOUTH WEST UP 
+// 001000 EAST NORTH DOWN 
+// 001001 WEST NORTH DOWN 
+// 001010 EAST SOUTH DOWN 
+// 001011 WEST SOUTH DOWN 
+// 001100 NORTH EAST DOWN 
+// 001101 SOUTH EAST DOWN 
+// 001110 NORTH WEST DOWN 
+// 001111 SOUTH WEST DOWN 
+// 010000 UP NORTH EAST 
+// 010001 DOWN NORTH EAST 
+// 010010 UP SOUTH EAST 
+// 010011 DOWN SOUTH EAST 
+// 010100 NORTH UP EAST 
+// 010101 SOUTH UP EAST 
+// 010110 NORTH DOWN EAST 
+// 010111 SOUTH DOWN EAST 
+// 011000 UP NORTH WEST 
+// 011001 DOWN NORTH WEST 
+// 011010 UP SOUTH WEST 
+// 011011 DOWN SOUTH WEST 
+// 011100 NORTH UP WEST 
+// 011101 SOUTH UP WEST 
+// 011110 NORTH DOWN WEST 
+// 011111 SOUTH DOWN WEST 
+// 100000 EAST UP NORTH 
+// 100001 WEST UP NORTH 
+// 100010 EAST DOWN NORTH 
+// 100011 WEST DOWN NORTH 
+// 100100 UP EAST NORTH 
+// 100101 DOWN EAST NORTH 
+// 100110 UP WEST NORTH 
+// 100111 DOWN WEST NORTH 
+// 101000 EAST UP SOUTH 
+// 101001 WEST UP SOUTH 
+// 101010 EAST DOWN SOUTH 
+// 101011 WEST DOWN SOUTH 
+// 101100 UP EAST SOUTH 
+// 101101 DOWN EAST SOUTH 
+// 101110 UP WEST SOUTH 
+// 101111 DOWN WEST SOUTH 
+class axis_transformation {
+public:
+  // Enum Names and values
+  // NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
+  // ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0, 
+  // WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X = 1,
+  // ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y = 2,
+  // WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3, 
+  // NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY = 4,
+  // SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5, 
+  // NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6, 
+  // SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7, 
+  // END_2D_TRANSFORM = 7,
+  // END = 8, EAST_NORTH_DOWN = 8, 
+  // WND = 9, WEST_NORTH_DOWN = 9, 
+  // ESD = 10, EAST_SOUTH_DOWN = 10, 
+  // WSD = 11, WEST_SOUTH_DOWN = 11, 
+  // NED = 12, NORTH_EAST_DOWN = 12, 
+  // SED = 13, SOUTH_EAST_DOWN = 13, 
+  // NWD = 14, NORTH_WEST_DOWN = 14, 
+  // SWD = 15, SOUTH_WEST_DOWN = 15, 
+  // UNE = 16, UP_NORTH_EAST = 16, 
+  // DNE = 17, DOWN_NORTH_EAST = 17, 
+  // USE = 18, UP_SOUTH_EAST = 18, 
+  // DSE = 19, DOWN_SOUTH_EAST = 19, 
+  // NUE = 20, NORTH_UP_EAST = 20, 
+  // SUE = 21, SOUTH_UP_EAST = 21, 
+  // NDE = 22, NORTH_DOWN_EAST = 22, 
+  // SDE = 23, SOUTH_DOWN_EAST = 23, 
+  // UNW = 24, UP_NORTH_WEST = 24, 
+  // DNW = 25, DOWN_NORTH_WEST = 25, 
+  // USW = 26, UP_SOUTH_WEST = 26, 
+  // DSW = 27, DOWN_SOUTH_WEST = 27, 
+  // NUW = 28, NORTH_UP_WEST = 28, 
+  // SUW = 29, SOUTH_UP_WEST = 29, 
+  // NDW = 30, NORTH_DOWN_WEST = 30, 
+  // SDW = 31, SOUTH_DOWN_WEST = 31, 
+  // EUN = 32, EAST_UP_NORTH = 32, 
+  // WUN = 33, WEST_UP_NORTH = 33, 
+  // EDN = 34, EAST_DOWN_NORTH = 34, 
+  // WDN = 35, WEST_DOWN_NORTH = 35, 
+  // UEN = 36, UP_EAST_NORTH = 36, 
+  // DEN = 37, DOWN_EAST_NORTH = 37, 
+  // UWN = 38, UP_WEST_NORTH = 38, 
+  // DWN = 39, DOWN_WEST_NORTH = 39, 
+  // EUS = 40, EAST_UP_SOUTH = 40, 
+  // WUS = 41, WEST_UP_SOUTH = 41, 
+  // EDS = 42, EAST_DOWN_SOUTH = 42, 
+  // WDS = 43, WEST_DOWN_SOUTH = 43, 
+  // UES = 44, UP_EAST_SOUTH = 44, 
+  // DES = 45, DOWN_EAST_SOUTH = 45, 
+  // UWS = 46, UP_WEST_SOUTH = 46, 
+  // DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47 
+  enum ATR {
+    NULL_TRANSFORM = 0, BEGIN_TRANSFORM = 0,
+    ENU = 0, EAST_NORTH_UP = 0, EN = 0, EAST_NORTH = 0, 
+    WNU = 1, WEST_NORTH_UP = 1, WN = 1, WEST_NORTH = 1, FLIP_X       = 1,
+    ESU = 2, EAST_SOUTH_UP = 2, ES = 2, EAST_SOUTH = 2, FLIP_Y       = 2,
+    WSU = 3, WEST_SOUTH_UP = 3, WS = 3, WEST_SOUTH = 3, FLIP_XY      = 3,
+    NEU = 4, NORTH_EAST_UP = 4, NE = 4, NORTH_EAST = 4, SWAP_XY      = 4,
+    SEU = 5, SOUTH_EAST_UP = 5, SE = 5, SOUTH_EAST = 5, ROTATE_LEFT  = 5,
+    NWU = 6, NORTH_WEST_UP = 6, NW = 6, NORTH_WEST = 6, ROTATE_RIGHT = 6,
+    SWU = 7, SOUTH_WEST_UP = 7, SW = 7, SOUTH_WEST = 7, FLIP_SWAP_XY = 7, END_2D_TRANSFORM = 7,
+    END = 8, EAST_NORTH_DOWN = 8, FLIP_Z = 8,
+    WND = 9, WEST_NORTH_DOWN = 9, 
+    ESD = 10, EAST_SOUTH_DOWN = 10, 
+    WSD = 11, WEST_SOUTH_DOWN = 11, 
+    NED = 12, NORTH_EAST_DOWN = 12, 
+    SED = 13, SOUTH_EAST_DOWN = 13, 
+    NWD = 14, NORTH_WEST_DOWN = 14, 
+    SWD = 15, SOUTH_WEST_DOWN = 15, 
+    UNE = 16, UP_NORTH_EAST = 16, 
+    DNE = 17, DOWN_NORTH_EAST = 17, 
+    USE = 18, UP_SOUTH_EAST = 18, 
+    DSE = 19, DOWN_SOUTH_EAST = 19, 
+    NUE = 20, NORTH_UP_EAST = 20, 
+    SUE = 21, SOUTH_UP_EAST = 21, 
+    NDE = 22, NORTH_DOWN_EAST = 22, 
+    SDE = 23, SOUTH_DOWN_EAST = 23, 
+    UNW = 24, UP_NORTH_WEST = 24, 
+    DNW = 25, DOWN_NORTH_WEST = 25, 
+    USW = 26, UP_SOUTH_WEST = 26, 
+    DSW = 27, DOWN_SOUTH_WEST = 27, 
+    NUW = 28, NORTH_UP_WEST = 28, 
+    SUW = 29, SOUTH_UP_WEST = 29, 
+    NDW = 30, NORTH_DOWN_WEST = 30, 
+    SDW = 31, SOUTH_DOWN_WEST = 31, 
+    EUN = 32, EAST_UP_NORTH = 32, 
+    WUN = 33, WEST_UP_NORTH = 33, 
+    EDN = 34, EAST_DOWN_NORTH = 34, 
+    WDN = 35, WEST_DOWN_NORTH = 35, 
+    UEN = 36, UP_EAST_NORTH = 36, 
+    DEN = 37, DOWN_EAST_NORTH = 37, 
+    UWN = 38, UP_WEST_NORTH = 38, 
+    DWN = 39, DOWN_WEST_NORTH = 39, 
+    EUS = 40, EAST_UP_SOUTH = 40, 
+    WUS = 41, WEST_UP_SOUTH = 41, 
+    EDS = 42, EAST_DOWN_SOUTH = 42, 
+    WDS = 43, WEST_DOWN_SOUTH = 43, 
+    UES = 44, UP_EAST_SOUTH = 44, 
+    DES = 45, DOWN_EAST_SOUTH = 45, 
+    UWS = 46, UP_WEST_SOUTH = 46, 
+    DWS = 47, DOWN_WEST_SOUTH = 47, END_TRANSFORM = 47 
+  };
+  
+  // Individual axis enum values indicate which axis an implicit individual
+  // axis will be mapped to.
+  // The value of the enum paired with an axis provides the information
+  // about what the axis will transform to.
+  // Three individual axis values, one for each axis, are equivalent to one
+  // ATR enum value, but easier to work with because they are independent.
+  // Converting to and from the individual axis values from the ATR value
+  // is a convenient way to implement tranformation related functionality.
+  // Enum meanings:
+  // PX: map to positive x axis
+  // NX: map to negative x axis
+  // PY: map to positive y axis
+  // NY: map to negative y axis
+  // PZ: map to positive z axis
+  // NZ: map to negative z axis
+  enum INDIVIDUAL_AXIS {
+    PX = 0,
+    NX = 1,
+    PY = 2,
+    NY = 3,
+    PZ = 4,
+    NZ = 5
+  };
+
+  inline axis_transformation() : atr_(NULL_TRANSFORM) {}
+  inline axis_transformation(ATR atr) : atr_(atr) {}
+  inline axis_transformation(const axis_transformation& atr) : atr_(atr.atr_) {}
+  explicit axis_transformation(const orientation_3d& orient);
+  explicit axis_transformation(const direction_3d& dir);
+  explicit axis_transformation(const orientation_2d& orient);
+  explicit axis_transformation(const direction_2d& dir);
+
+  // assignment operator 
+  axis_transformation& operator=(const axis_transformation& a);
+
+  // assignment operator 
+  axis_transformation& operator=(const ATR& atr);
+
+  // equivalence operator
+  bool operator==(const axis_transformation& a) const;
+
+  // inequivalence operator
+  bool operator!=(const axis_transformation& a) const;
+
+  // ordering
+  bool operator<(const axis_transformation& a) const;
+
+  // concatenation operator 
+  axis_transformation operator+(const axis_transformation& a) const;
+
+  // concatenate this with that
+  axis_transformation& operator+=(const axis_transformation& a);
+
+  // populate_axis_array writes the three INDIVIDUAL_AXIS values that the
+  // ATR enum value of 'this' represent into axis_array
+  void populate_axis_array(INDIVIDUAL_AXIS axis_array[]) const;
+
+  // it is recommended that the directions stored in an array
+  // in the caller code for easier isotropic access by orientation value
+  inline void get_directions(direction_2d& horizontal_dir,
+                             direction_2d& vertical_dir) const {
+    bool bit2 = (atr_ & 4) != 0;
+    bool bit1 = (atr_ & 2) != 0;
+    bool bit0 = (atr_ & 1) != 0;      
+    vertical_dir = direction_2d((direction_2d_enum)(((int)(!bit2) << 1) + !bit1));
+    horizontal_dir = direction_2d((direction_2d_enum)(((int)(bit2) << 1) + !bit0));
+  }
+
+  // it is recommended that the directions stored in an array
+  // in the caller code for easier isotropic access by orientation value
+  inline void get_directions(direction_3d& horizontal_dir,
+                             direction_3d& vertical_dir,
+                             direction_3d& proximal_dir) const {
+    bool bit5 = (atr_ & 32) != 0;
+    bool bit4 = (atr_ & 16) != 0;
+    bool bit3 = (atr_ & 8) != 0;
+    bool bit2 = (atr_ & 4) != 0;
+    bool bit1 = (atr_ & 2) != 0;
+    bool bit0 = (atr_ & 1) != 0;   
+    proximal_dir = direction_3d((direction_2d_enum)((((int)(!bit4 & !bit5)) << 2) +
+                                                    ((int)(bit5) << 1) + 
+                                                    !bit3));
+    vertical_dir = direction_3d((direction_2d_enum)((((int)((bit4 & bit2) | (bit5 & !bit2))) << 2)+
+                                                    ((int)(!bit5 & !bit2) << 1) + 
+                                                    !bit1));
+    horizontal_dir = direction_3d((direction_2d_enum)((((int)((bit5 & bit2) | 
+                                                              (bit4 & !bit2))) << 2) +
+                                                      ((int)(bit2 & !bit5) << 1) + 
+                                                      !bit0));
+  }
+  
+  // combine_axis_arrays concatenates this_array and that_array overwriting
+  // the result into this_array
+  static void combine_axis_arrays (INDIVIDUAL_AXIS this_array[],
+                                   const INDIVIDUAL_AXIS that_array[]);
+
+  // write_back_axis_array converts an array of three INDIVIDUAL_AXIS values
+  // to the ATR enum value and sets 'this' to that value
+  void write_back_axis_array(const INDIVIDUAL_AXIS this_array[]);
+
+  // behavior is deterministic but undefined in the case where illegal
+  // combinations of directions are passed in. 
+  axis_transformation& set_directions(const direction_2d& horizontal_dir,
+                                 const direction_2d& vertical_dir);
+  // behavior is deterministic but undefined in the case where illegal
+  // combinations of directions are passed in.
+  axis_transformation& set_directions(const direction_3d& horizontal_dir,
+                                 const direction_3d& vertical_dir,
+                                 const direction_3d& proximal_dir);
+
+  // transform the two coordinates by reference using the 2D portion of this
+  template <typename coordinate_type>
+  void transform(coordinate_type& x, coordinate_type& y) const;
+
+  // transform the three coordinates by reference
+  template <typename coordinate_type>
+  void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;
+
+  // invert the 2D portion of this
+  axis_transformation& invert_2d();
+
+  // get the inverse of the 2D portion of this
+  axis_transformation inverse_2d() const;
+
+  // invert this axis_transformation
+  axis_transformation& invert();
+
+  // get the inverse axis_transformation of this
+  axis_transformation inverse() const;
+
+  //friend std::ostream& operator<< (std::ostream& o, const axis_transformation& r);
+  //friend std::istream& operator>> (std::istream& i, axis_transformation& r);
+
+private:
+  ATR atr_;
+};
+
+
+// Scaling object to be used to store the scale factor for each axis
+
+// For use by the transformation object, in that context the scale factor
+// is the amount that each axis scales by when transformed.
+// If the horizontal value of the Scale is 10 that means the horizontal
+// axis of the input is multiplied by 10 when the transformation is applied.
+template <typename scale_factor_type>
+class anisotropic_scale_factor {
+public:
+  inline anisotropic_scale_factor()
+#ifndef BOOST_POLYGON_MSVC
+    : scale_() 
+#endif
+  {
+    scale_[0] = 1;
+    scale_[1] = 1;
+    scale_[2] = 1;
+  } 
+  inline anisotropic_scale_factor(scale_factor_type xscale, scale_factor_type yscale)
+#ifndef BOOST_POLYGON_MSVC
+    : scale_() 
+#endif 
+  {
+    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) 
+#ifndef BOOST_POLYGON_MSVC
+    : scale_() 
+#endif   
+  {
+    scale_[0] = xscale;
+    scale_[1] = yscale;
+    scale_[2] = zscale;
+  } 
+
+  // get a component of the anisotropic_scale_factor by orientation
+  scale_factor_type get(orientation_3d orient) const;
+  scale_factor_type get(orientation_2d orient) const { return get(orientation_3d(orient)); }
+
+  // set a component of the anisotropic_scale_factor by orientation
+  void set(orientation_3d orient, scale_factor_type value);
+  void set(orientation_2d orient, scale_factor_type value) { set(orientation_3d(orient), value); }
+
+  scale_factor_type x() const;
+  scale_factor_type y() const;
+  scale_factor_type z() const;
+  void x(scale_factor_type value);
+  void y(scale_factor_type value);
+  void z(scale_factor_type value);
+
+  // concatination operator (convolve scale factors)
+  anisotropic_scale_factor operator+(const anisotropic_scale_factor& s) const;
+
+  // concatinate this with that
+  const anisotropic_scale_factor& operator+=(const anisotropic_scale_factor& s);
+
+  // transform this scale with an axis_transform
+  anisotropic_scale_factor& transform(axis_transformation atr);
+
+  // scale the two coordinates
+  template <typename coordinate_type>
+  void scale(coordinate_type& x, coordinate_type& y) const;
+
+  // scale the three coordinates
+  template <typename coordinate_type>
+  void scale(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;
+
+  // invert this scale factor to give the reverse scale factor
+  anisotropic_scale_factor& invert(); 
+
+private:
+  scale_factor_type scale_[3];
+
+  //friend std::ostream& operator<< (std::ostream& o, const Scale& r);
+  //friend std::istream& operator>> (std::istream& i, Scale& r);
+};
+
+// Transformation object, stores and provides services for transformations
+
+// Transformation object stores an axistransformation, a scale factor and a translation.
+// The tranlation is the position of the origin of the new system of coordinates in the old system.
+// The scale scales the coordinates before they are transformed.
+template <typename coordinate_type>
+class transformation {
+public:
+  transformation();
+  transformation(axis_transformation atr);
+  transformation(axis_transformation::ATR atr);
+  template <typename point_type>
+  transformation(const point_type& p);
+  template <typename point_type>
+  transformation(axis_transformation atr, const point_type& p);
+  template <typename point_type>
+  transformation(axis_transformation atr, const point_type& referencePt, const point_type& destinationPt);
+  transformation(const transformation& tr);
+
+  // equivalence operator 
+  bool operator==(const transformation& tr) const;
+
+  // inequivalence operator 
+  bool operator!=(const transformation& tr) const;
+
+  // ordering
+  bool operator<(const transformation& tr) const;
+
+  // concatenation operator 
+  transformation operator+(const transformation& tr) const;
+
+  // concatenate this with that
+  const transformation& operator+=(const transformation& tr);
+
+  // get the axis_transformation portion of this
+  inline axis_transformation get_axis_transformation() const {return atr_;}
+
+  // set the axis_transformation portion of this
+  void set_axis_transformation(const axis_transformation& atr);
+
+  // get the translation portion of this as a point3d
+  template <typename point_type>
+  void get_translation(point_type& translation) const;
+
+  // set the translation portion of this with a point3d
+  template <typename point_type>
+  void set_translation(const point_type& p);
+
+  // apply the 2D portion of this transformation to the two coordinates given
+  void transform(coordinate_type& x, coordinate_type& y) const;
+
+  // apply this transformation to the three coordinates given
+  void transform(coordinate_type& x, coordinate_type& y, coordinate_type& z) const;
+
+  // invert this transformation
+  transformation& invert();
+    
+  // get the inverse of this transformation
+  transformation inverse() const;
+
+  inline void get_directions(direction_2d& horizontal_dir,
+                             direction_2d& vertical_dir) const {
+    return atr_.get_directions(horizontal_dir, vertical_dir); }
+
+  inline void get_directions(direction_3d& horizontal_dir,
+                             direction_3d& vertical_dir,
+                             direction_3d& proximal_dir) const {
+    return atr_.get_directions(horizontal_dir, vertical_dir, proximal_dir); }
+
+private:
+  axis_transformation atr_;
+  point_3d_data<coordinate_type> p_;
+
+  template <typename point_type>
+  void construct_dispatch(axis_transformation atr, point_type p, point_concept tag);
+  template <typename point_type>
+  void construct_dispatch(axis_transformation atr, point_type p, point_3d_concept tag);
+  template <typename point_type>
+  void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_concept tag);
+  template <typename point_type>
+  void construct_dispatch(axis_transformation atr, point_type rp, point_type dp, point_3d_concept tag);
+
+  //friend std::ostream& operator<< (std::ostream& o, const transformation& tr);
+  //friend std::istream& operator>> (std::istream& i, transformation& tr);
+};
+}
+}
+#include "detail/transform_detail.hpp"
+#endif
+