Boost logo

Boost-Commit :

From: lucanus.j.simonson_at_[hidden]
Date: 2008-05-19 13:06:44


Author: ljsimons
Date: 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
New Revision: 45547
URL: http://svn.boost.org/trac/boost/changeset/45547

Log:
added lazy iterators input to booleans algorithm and fixed all warnings
Added:
   sandbox/gtl/gtl/iterator_geometry_to_set.h (contents, props changed)
   sandbox/gtl/gtl/polygon_set_wrapper.h (contents, props changed)
Text files modified:
   sandbox/gtl/gtl/gtl.h | 7 +++++--
   sandbox/gtl/gtl/interval_concept.h | 7 +++----
   sandbox/gtl/gtl/isotropy.h | 2 +-
   sandbox/gtl/gtl/iterator_vertex_orient_conversion.h | 8 +++++---
   sandbox/gtl/gtl/point_data.h | 6 ++++++
   sandbox/gtl/gtl/polygon_concept.h | 9 ++++++++-
   sandbox/gtl/gtl/polygon_formation.h | 6 +++---
   sandbox/gtl/gtl/polygon_set_data.h | 5 +++++
   sandbox/gtl/gtl/polygon_set_traits.h | 10 +++++-----
   sandbox/gtl/gtl/polygon_set_view.h | 6 +++---
   sandbox/gtl/gtl/rectangle_concept.h | 6 ++++--
   sandbox/gtl/gtl/rectangle_data.h | 2 +-
   12 files changed, 49 insertions(+), 25 deletions(-)

Modified: sandbox/gtl/gtl/gtl.h
==============================================================================
--- sandbox/gtl/gtl/gtl.h (original)
+++ sandbox/gtl/gtl/gtl.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -57,6 +57,7 @@
 #include "polygon_formation.h"
 #include "rectangle_formation.h"
 #include "iterator_vertex_orient_conversion.h"
+#include "iterator_geometry_to_set.h"
 
 //polygon set data types
 #include "polygon_set_data.h"
@@ -67,6 +68,8 @@
 //geometry traits
 #include "geometry_traits.h"
 
+#include "polygon_set_wrapper.h"
+
 //defintions
 #include "post_geometry_traits_definitions.h"
 
@@ -76,8 +79,8 @@
 template <typename geometry_type_1, typename geometry_type_2>
 bool contains(const geometry_type_1& geometry_object, const geometry_type_2& contained_geometry_object,
               bool consider_touch = true) {
- typename geometry_traits<geometry_type_1>::geometry_concept().contains(geometry_object, contained_geometry_object,
- consider_touch, typename geometry_traits<geometry_type_2>::geometry_concept());
+ return typename geometry_traits<geometry_type_1>::geometry_concept().contains(geometry_object, contained_geometry_object,
+ consider_touch, typename geometry_traits<geometry_type_2>::geometry_concept());
 }
 
 template <typename geometry_type_1, typename geometry_type_2>

Modified: sandbox/gtl/gtl/interval_concept.h
==============================================================================
--- sandbox/gtl/gtl/interval_concept.h (original)
+++ sandbox/gtl/gtl/interval_concept.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -60,9 +60,9 @@
       get(interval2, HIGH);
   }
 
- template <typename interval_type, typename coordinate_type>
+ template <typename interval_type>
   static bool contains(const interval_type& interval,
- coordinate_type value, bool consider_touch) {
+ typename interval_traits<interval_type>::coordinate_type value, bool consider_touch) {
     if(consider_touch) {
       return value <= get<HIGH>(interval) && value >= get<LOW>(interval);
     } else {
@@ -72,8 +72,7 @@
 
   template <typename interval_type, typename interval_type_2>
   static bool contains(const interval_type& interval,
- const interval_type_2& value, bool consider_touch,
- interval_concept concept) {
+ const interval_type_2& value, bool consider_touch, interval_concept tag) {
     return contains(interval, get(value, LOW), consider_touch) &&
       contains(interval, get(value, HIGH), consider_touch);
   }

Modified: sandbox/gtl/gtl/isotropy.h
==============================================================================
--- sandbox/gtl/gtl/isotropy.h (original)
+++ sandbox/gtl/gtl/isotropy.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -32,7 +32,7 @@
   bool operator==(direction_1d d) const { return (val_ == d.val_); }
   bool operator!=(direction_1d d) const { return !((*this) == d); }
   unsigned int to_int(void) const { return val_; }
- direction_1d& backward() { val_ ^ 1; }
+ direction_1d& backward() { val_ ^= 1; return *this; }
 };
 
 class direction_2d;

Added: sandbox/gtl/gtl/iterator_geometry_to_set.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/iterator_geometry_to_set.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -0,0 +1,309 @@
+/*
+ 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).
+*/
+template <typename concept_type, typename geometry_type>
+class iterator_geometry_to_set {};
+
+template <typename concept_type, typename iterator_type>
+class iterator_geometry_range_to_set {
+ typedef typename iterator_type::value_type geometry_type;
+ typedef iterator_geometry_to_set<concept_type, geometry_type> internal_iterator_type;
+ typedef typename internal_iterator_type::value_type value_type;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type* pointer; //immutable
+ typedef const value_type& reference; //immutable
+private:
+ iterator_type itr_;
+ mutable internal_iterator_type itrb_, itre_;
+ mutable bool dereferenced_;
+ orientation_2d orient_;
+public:
+ iterator_geometry_range_to_set(iterator_type itr,
+ orientation_2d orient = HORIZONTAL) :
+ itr_(itr), dereferenced_(false), orient_(orient) {}
+
+ inline iterator_geometry_range_to_set& operator++() {
+ if(!dereferenced_) **this;
+ if(itrb_ == itre_) {
+ ++itr_;
+ dereferenced_ = false;
+ } else {
+ ++itrb_;
+ if(itrb_ == itre_) {
+ ++itr_;
+ dereferenced_ = false;
+ }
+ }
+ return *this;
+ }
+ inline iterator_geometry_range_to_set operator++(int) {
+ iterator_geometry_range_to_set tmp(*this);
+ ++(*this);
+ return tmp;
+ }
+ inline bool operator==(const iterator_geometry_range_to_set& that) const {
+ return (itr_ == that.itr_);
+ }
+ inline bool operator!=(const iterator_geometry_range_to_set& that) const {
+ return !(*this == that);
+ }
+ inline reference operator*() const {
+ if(!dereferenced_) {
+ itrb_ = iterator_geometry_to_set<concept_type, geometry_type>(*itr_, LOW, orient_);
+ itre_ = iterator_geometry_to_set<concept_type, geometry_type>(*itr_, HIGH, orient_);
+ dereferenced_ = true;
+ }
+ return *itrb_;
+ }
+};
+
+template <typename rectangle_type>
+class iterator_geometry_to_set<rectangle_concept, rectangle_type> {
+public:
+ 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_;
+public:
+ iterator_geometry_to_set() : corner_(4) {}
+ iterator_geometry_to_set(const rectangle_type& rectangle, direction_1d dir,
+ orientation_2d orient = HORIZONTAL) : corner_(0), orient_(orient) {
+ rectangle_concept::assign(rectangle_, rectangle);
+ if(dir == HIGH) corner_ = 4;
+ }
+ inline iterator_geometry_to_set& operator++() {
+ ++corner_;
+ return *this;
+ }
+ inline 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 = interval_concept::get(rectangle_concept::get(rectangle_, orient_.get_perpendicular()), LOW);
+ vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), LOW);
+ vertex_.second.second = 1;
+ } else if(corner_ == 1) {
+ vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), HIGH);
+ vertex_.second.second = -1;
+ } else if(corner_ == 2) {
+ vertex_.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_.get_perpendicular()), HIGH);
+ vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), LOW);
+ } else {
+ vertex_.second.first = interval_concept::get(rectangle_concept::get(rectangle_, orient_), HIGH);
+ vertex_.second.second = 1;
+ }
+ return vertex_;
+ }
+};
+
+template <typename polygon_type>
+class iterator_geometry_to_set<polygon_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_;
+ iterator_compact_to_points<typename polygon_traits<polygon_type>::iterator_type,
+ point_data<typename polygon_traits<polygon_type>::coordinate_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() : polygon_index(-1) {}
+ iterator_geometry_to_set(const polygon_type& polygon, direction_1d dir, orientation_2d orient = HORIZONTAL, bool is_hole = false) :
+ is_hole_(is_hole), orient_(orient), polygon_index(0) {
+ itrb = polygon_concept::begin_points(polygon);
+ itre = polygon_concept::end_points(polygon);
+ use_wrap = false;
+ if(itrb == itre || dir == HIGH || polygon_concept::size(polygon) < 4) {
+ polygon_index = -1;
+ } else {
+ direction_1d wdir = polygon_concept::winding(polygon);
+ multiplier_ = wdir == LOW ? -1 : 1;
+ if(is_hole_) multiplier_ *= -1;
+ first_pt = pts[0] = *itrb;
+ ++itrb;
+ second_pt = pts[1] = *itrb;
+ ++itrb;
+ pts[2] = *itrb;
+ }
+ evaluate_();
+ }
+
+ inline iterator_geometry_to_set& operator++() {
+ ++polygon_index;
+ if(itrb == itre) {
+ if(first_pt == pts[1]) polygon_index = -1;
+ else {
+ pts[0] = pts[1];
+ pts[1] = pts[2];
+ if(first_pt == pts[2]) {
+ pts[2] = second_pt;
+ } else {
+ pts[2] = first_pt;
+ }
+ }
+ } else {
+ ++itrb;
+ pts[0] = pts[1];
+ pts[1] = pts[2];
+ if(itrb == itre) {
+ if(first_pt == pts[2]) {
+ pts[2] = second_pt;
+ } else {
+ pts[2] = first_pt;
+ }
+ } else {
+ pts[2] = *itrb;
+ }
+ }
+ evaluate_();
+ return *this;
+ }
+ inline 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[0].get(HORIZONTAL) != pts[1].get(HORIZONTAL)) {
+ vertex_.second.second = -1;
+ } else {
+ vertex_.second.second = 1;
+ }
+ vertex_.second.second *= multiplier_;
+ }
+};
+
+template <typename polygon_with_holes_type>
+class iterator_geometry_to_set<polygon_with_holes_concept, polygon_with_holes_type> {
+public:
+ typedef typename rectangle_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_concept, polygon_with_holes_type> itrb, itre;
+ iterator_geometry_to_set<polygon_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 started_holes;
+public:
+ iterator_geometry_to_set() {}
+ iterator_geometry_to_set(const polygon_with_holes_type& polygon, direction_1d dir,
+ orientation_2d orient = HORIZONTAL) : orient_(orient) {
+ itre = iterator_geometry_to_set<polygon_concept, polygon_with_holes_type>(polygon, HIGH, orient);
+ itrhe = polygon_with_holes_concept::end_holes(polygon);
+ if(dir == HIGH) {
+ itrb = itre;
+ itrhb = itrhe;
+ started_holes = true;
+ } else {
+ itrb = iterator_geometry_to_set<polygon_concept, polygon_with_holes_type>(polygon, LOW, orient);
+ itrhb = polygon_with_holes_concept::begin_holes(polygon);
+ started_holes = false;
+ }
+ }
+ inline iterator_geometry_to_set& operator++() {
+ //this code can be folded with flow control factoring
+ if(itrb == itre) {
+ if(itrhib == itrhie) {
+ if(itrhb != itrhe) {
+ itrhib = iterator_geometry_to_set<polygon_concept,
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, true);
+ itrhie = iterator_geometry_to_set<polygon_concept,
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, true);
+ ++itrhb;
+ } else {
+ itrhib = itrhie = iterator_geometry_to_set<polygon_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_concept,
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, true);
+ itrhie = iterator_geometry_to_set<polygon_concept,
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, true);
+ ++itrhb;
+ } else {
+ itrhib = itrhie = iterator_geometry_to_set<polygon_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_concept,
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, LOW, orient_, true);
+ itrhie = iterator_geometry_to_set<polygon_concept,
+ typename polygon_with_holes_traits<polygon_with_holes_type>::hole_type>(*itrhb, HIGH, orient_, true);
+ ++itrhb;
+ }
+ }
+ }
+ return *this;
+ }
+ inline 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;
+ }
+};

Modified: sandbox/gtl/gtl/iterator_vertex_orient_conversion.h
==============================================================================
--- sandbox/gtl/gtl/iterator_vertex_orient_conversion.h (original)
+++ sandbox/gtl/gtl/iterator_vertex_orient_conversion.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -23,8 +23,6 @@
     iter_(iter) {}
   inline iterator_vertex_orient_conversion& operator++() {
     ++iter_;
- vertex_.first = (*iter_).second.first;
- vertex_.second = std::pair<coordinate_type, int>((*iter_).first, (*iter_).second.second);
     return *this;
   }
   inline iterator_vertex_orient_conversion operator++(int) {
@@ -38,6 +36,10 @@
   inline bool operator!=(const iterator_vertex_orient_conversion& that) const {
     return (iter_ != that.iter_);
   }
- inline reference operator*() const { return vertex_; }
+ inline reference operator*() const {
+ vertex_.first = (*iter_).second.first;
+ vertex_.second = std::pair<coordinate_type, int>((*iter_).first, (*iter_).second.second);
+ return vertex_;
+ }
 };
 

Modified: sandbox/gtl/gtl/point_data.h
==============================================================================
--- sandbox/gtl/gtl/point_data.h (original)
+++ sandbox/gtl/gtl/point_data.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -19,6 +19,12 @@
   }
   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 coordinate_type get(orientation_2d orient) const {
     return coords_[orient.to_int()];
   }

Modified: sandbox/gtl/gtl/polygon_concept.h
==============================================================================
--- sandbox/gtl/gtl/polygon_concept.h (original)
+++ sandbox/gtl/gtl/polygon_concept.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -8,6 +8,12 @@
 struct polygon_concept {
   inline polygon_concept() {}
 
+ template <typename polygon_type>
+ struct registration {
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ };
+
+
   template<typename polygon_type, typename iterator_type>
   static void set(polygon_type& polygon, iterator_type input_begin, iterator_type input_end) {
     polygon_traits<polygon_type>::set(polygon, input_begin, input_end);
@@ -87,7 +93,7 @@
     }
     direction_1d dir = HIGH;
     typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
- typedef typename polygon_traits<polygon_type>::iterator iterator;
+ typedef typename polygon_traits<polygon_type>::iterator_type iterator;
     iterator itr = begin(polygon);
     coordinate_type firstx = *itr;
     coordinate_type minX = firstx;
@@ -312,6 +318,7 @@
       move(0, displacement);
     }
   }
+
 };
 
 

Modified: sandbox/gtl/gtl/polygon_formation.h
==============================================================================
--- sandbox/gtl/gtl/polygon_formation.h (original)
+++ sandbox/gtl/gtl/polygon_formation.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -336,7 +336,7 @@
         //if it is horizontal we need to skip the first element
         pLine_ = at->getTail();
         index_ = at->getTail()->numSegments() - 1;
- if(at->getOrient() == HORIZONTAL ^ (orient == HORIZONTAL)) {
+ if((at->getOrient() == HORIZONTAL) ^ (orient == HORIZONTAL)) {
           pLineEnd_ = at->getTail();
           indexEnd_ = pLineEnd_->numSegments() - 1;
           if(index_ == 0) {
@@ -1202,7 +1202,7 @@
       nextPolyLinep = tailp_->writeOut(outVec);
     }
     Unit firsty = outVec[size + 1];
- if(getOrient() == HORIZONTAL ^ !isHole) {
+ if((getOrient() == HORIZONTAL) ^ !isHole) {
       //our first coordinate is a y value, so we need to rotate it to the end
       typename std::vector<Unit>::iterator tmpItr = outVec.begin();
       tmpItr += size;
@@ -1215,7 +1215,7 @@
       nextPolyLinep = nextPolyLinep->writeOut(outVec, startEnd);
       startEnd = nextStartEnd;
     }
- if(getOrient() == HORIZONTAL ^ !isHole) {
+ if((getOrient() == HORIZONTAL) ^ !isHole) {
       //we want to push the y value onto the end since we ought to have ended with an x
       outVec.push_back(firsty); //should never be executed because we want first value to be an x
     }

Modified: sandbox/gtl/gtl/polygon_set_data.h
==============================================================================
--- sandbox/gtl/gtl/polygon_set_data.h (original)
+++ sandbox/gtl/gtl/polygon_set_data.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -119,6 +119,11 @@
     std::sort(data_.begin(), data_.end());
     unsorted_ = false;
   }
+
+ void set(const value_type& value, orientation_2d orient) {
+ data_ = value;
+ orient_ = orient;
+ }
 private:
   orientation_2d orient_;
   mutable value_type data_;

Modified: sandbox/gtl/gtl/polygon_set_traits.h
==============================================================================
--- sandbox/gtl/gtl/polygon_set_traits.h (original)
+++ sandbox/gtl/gtl/polygon_set_traits.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -13,16 +13,16 @@
   typedef typename T::operator_arg_type operator_arg_type;
 
   static inline iterator_type begin(const T& polygon_set) {
- return polygon_set.value.begin();
+ return polygon_set.begin();
   }
 
   static inline iterator_type end(const T& polygon_set) {
- return polygon_set.value.end();
+ return polygon_set.end();
   }
 
- static inline void insert(T& polygon_set, const std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >& value,
- orientation_2d orient) {
- polygon_set.insert(value, orient);
+ static inline void set(T& polygon_set, const std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >& value,
+ orientation_2d orient) {
+ polygon_set.set(value, orient);
   }
 
   static inline orientation_2d orient(const T& polygon_set) { return polygon_set.orient(); }

Modified: sandbox/gtl/gtl/polygon_set_view.h
==============================================================================
--- sandbox/gtl/gtl/polygon_set_view.h (original)
+++ sandbox/gtl/gtl/polygon_set_view.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -91,7 +91,7 @@
                    const rtype& rvalue,
                    orientation_2d orient,
                    op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+ lvalue_(lvalue), rvalue_(rvalue), op_(op), orient_(orient) {}
 
   /// get iterator to begin vertex data
   const value_type& value() const {
@@ -151,7 +151,7 @@
                    const rtype& rvalue,
                    orientation_2d orient,
                    op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+ lvalue_(lvalue), rvalue_(rvalue), op_(op) , orient_(orient) {}
 
   /// get iterator to begin vertex data
   const value_type& value() const {
@@ -201,7 +201,7 @@
                    const rtype& rvalue,
                    orientation_2d orient,
                    op_type op) :
- lvalue_(lvalue), rvalue_(rvalue), orient_(orient), op_(op) {}
+ lvalue_(lvalue), rvalue_(rvalue), op_(op), orient_(orient) {}
 
   /// get iterator to begin vertex data
   const value_type& value() const {

Added: sandbox/gtl/gtl/polygon_set_wrapper.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_set_wrapper.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -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).
+*/
+template <typename T>
+class polygon_set_const_wrapper {
+private:
+ const T& t_;
+public:
+ typedef typename T::value_type geometry_type;
+ typedef typename geometry_traits<geometry_type>::geometry_concept geometry_concept;
+ typedef typename geometry_concept::template registration<geometry_type>::coordinate_type coordinate_type;
+ typedef iterator_geometry_range_to_set<geometry_concept, typename T::const_iterator> iterator_type;
+ typedef polygon_set_const_wrapper operator_arg_type;
+ typedef operator_requires_copy operator_storage_tag;
+
+ polygon_set_const_wrapper(const T& t) : t_(t) {}
+
+ inline iterator_type begin() const {
+ return iterator_type(t_.begin());
+ }
+
+ inline iterator_type end(const T& polygon_set) const {
+ return iterator_type(t_.end());
+ }
+
+ inline orientation_2d orient() const { return HORIZONTAL; }
+
+ inline bool dirty(const T& polygon_set) const { return true; }
+
+ inline bool sorted(const T& polygon_set) const { return false; }
+
+};
+
+template <typename T>
+polygon_set_const_wrapper<T> wrap_const(const T& t) {
+ return polygon_set_const_wrapper<T>(t);
+}
+
+template <typename T>
+class polygon_set_wrapper {
+private:
+ T& t_;
+public:
+ typedef typename T::value_type geometry_type;
+ typedef typename geometry_traits<geometry_type>::geometry_concept geometry_concept;
+ typedef typename geometry_concept::template registration<geometry_type>::coordinate_type coordinate_type;
+ typedef iterator_geometry_range_to_set<geometry_concept, typename T::const_iterator> iterator_type;
+ typedef polygon_set_wrapper operator_arg_type;
+ typedef operator_requires_copy operator_storage_tag;
+
+ inline polygon_set_wrapper(T& t) : t_(t) {}
+
+ inline iterator_type begin() const {
+ return iterator_type(t_.begin());
+ }
+
+ inline iterator_type end(const T& polygon_set) const {
+ return iterator_type(t_.end());
+ }
+
+ inline void set(const std::vector<std::pair<coordinate_type, std::pair<coordinate_type, int> > >& value,
+ orientation_2d orient) {
+ }
+
+ inline orientation_2d orient() const { return HORIZONTAL; }
+
+ inline bool dirty(const T& polygon_set) const { return true; }
+
+ inline bool sorted(const T& polygon_set) const { return false; }
+
+};
+
+template <typename T>
+polygon_set_const_wrapper<T> wrap(const T& t) {
+ return polygon_set_wrapper<T>(t);
+}

Modified: sandbox/gtl/gtl/rectangle_concept.h
==============================================================================
--- sandbox/gtl/gtl/rectangle_concept.h (original)
+++ sandbox/gtl/gtl/rectangle_concept.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -96,12 +96,14 @@
   template <typename rectangle_type, typename rectangle_type2>
   static bool contains(const rectangle_type& rectangle, const rectangle_type2 rectangle_contained,
                                 bool consider_touch, rectangle_concept tag) {
- std::cout << "rectangle contains rectangle\n";
+ return interval_concept::contains(get<HORIZONTAL>(rectangle), get<HORIZONTAL>(rectangle_contained), consider_touch, interval_concept()) &&
+ interval_concept::contains(get<VERTICAL>(rectangle), get<VERTICAL>(rectangle_contained), consider_touch, interval_concept());
   }
   template <typename rectangle_type, typename point_type>
   static bool contains(const rectangle_type& rectangle, const point_type point_contained,
                                 bool consider_touch, point_concept tag) {
- std::cout << "rectangle contains point\n";
+ return interval_concept::contains(get<HORIZONTAL>(rectangle), point_concept::get<HORIZONTAL>(point_contained), consider_touch) &&
+ interval_concept::contains(get<VERTICAL>(rectangle), point_concept::get<VERTICAL>(point_contained), consider_touch);
   }
 
   template <typename rectangle_type_1, typename rectangle_type_2>

Modified: sandbox/gtl/gtl/rectangle_data.h
==============================================================================
--- sandbox/gtl/gtl/rectangle_data.h (original)
+++ sandbox/gtl/gtl/rectangle_data.h 2008-05-19 13:06:42 EDT (Mon, 19 May 2008)
@@ -13,7 +13,7 @@
   template <typename interval_type_1, typename interval_type_2>
   inline rectangle_data(const interval_type_1& hrange,
                         const interval_type_2& vrange) {
- set(HORIZONTAL, hrange); set(VERTICAL, hrange); }
+ set(HORIZONTAL, hrange); set(VERTICAL, vrange); }
 
   inline rectangle_data(const rectangle_data& that) { (*this) = that; }
 


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk