From: lucanus.j.simonson_at_[hidden]
Date: 2008-05-08 03:00:49
Author: ljsimons
Date: 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
New Revision: 45208
URL: http://svn.boost.org/trac/boost/changeset/45208
Log:
initial checkin
Added:
sandbox/gtl/
sandbox/gtl/boost/
sandbox/gtl/gtl/
sandbox/gtl/gtl/geometry_traits.h (contents, props changed)
sandbox/gtl/gtl/gtl.h (contents, props changed)
sandbox/gtl/gtl/interval_concept.h (contents, props changed)
sandbox/gtl/gtl/interval_data.h (contents, props changed)
sandbox/gtl/gtl/interval_traits.h (contents, props changed)
sandbox/gtl/gtl/isotropy.h (contents, props changed)
sandbox/gtl/gtl/point_3d_concept.h (contents, props changed)
sandbox/gtl/gtl/point_3d_data.h (contents, props changed)
sandbox/gtl/gtl/point_3d_traits.h (contents, props changed)
sandbox/gtl/gtl/point_concept.h (contents, props changed)
sandbox/gtl/gtl/point_data.h (contents, props changed)
sandbox/gtl/gtl/point_traits.h (contents, props changed)
sandbox/gtl/gtl/polygon_concept.h (contents, props changed)
sandbox/gtl/gtl/polygon_data.h (contents, props changed)
sandbox/gtl/gtl/polygon_traits.h (contents, props changed)
sandbox/gtl/gtl/post_concept_definitions.h (contents, props changed)
sandbox/gtl/gtl/post_geometry_traits_definitions.h (contents, props changed)
sandbox/gtl/gtl/rectangle_concept.h (contents, props changed)
sandbox/gtl/gtl/rectangle_data.h (contents, props changed)
sandbox/gtl/gtl/rectangle_traits.h (contents, props changed)
Added: sandbox/gtl/gtl/geometry_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/geometry_traits.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,52 @@
+struct no_type {};
+
+template <typename T>
+struct geometry_traits {
+ typedef no_type geometry_concept;
+};
+template <>
+struct geometry_traits<point_data<int> > {
+ typedef point_concept geometry_concept;
+ typedef int point_get_retval;
+};
+template <>
+struct geometry_traits<point_data<long long> > {
+ typedef point_concept geometry_concept;
+ typedef long long point_get_retval;
+};
+template <>
+struct geometry_traits<rectangle_data<int> > {
+ typedef rectangle_concept geometry_concept;
+ typedef interval_data<int> rectangle_get_retval;
+};
+template <>
+struct geometry_traits<rectangle_data<long long> > {
+ typedef rectangle_concept geometry_concept;
+ typedef interval_data<long long> rectangle_get_retval;
+};
+template <>
+struct geometry_traits<interval_data<int> > {
+ typedef interval_concept geometry_concept;
+};
+template <>
+struct geometry_traits<interval_data<long long> > {
+ typedef interval_concept geometry_concept;
+};
+template <>
+struct geometry_traits<polygon_data<int> > {
+ typedef polygon_concept geometry_concept;
+};
+template <>
+struct geometry_traits<polygon_data<long long> > {
+ typedef polygon_concept geometry_concept;
+};
+template <>
+struct geometry_traits<point_3d_data<int> > {
+ typedef point_3d_concept geometry_concept;
+};
+template <>
+struct geometry_traits<point_3d_data<long long> > {
+ typedef point_3d_concept geometry_concept;
+};
+
+
Added: sandbox/gtl/gtl/gtl.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/gtl.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,70 @@
+//external
+#include <vector>
+#include <iostream>
+
+//isotropy types
+#include "isotropy.h"
+
+//data types
+#include "point_data.h"
+#include "interval_data.h"
+#include "rectangle_data.h"
+#include "point_3d_data.h"
+#include "polygon_data.h"
+
+//traits types
+#include "point_traits.h"
+#include "interval_traits.h"
+#include "rectangle_traits.h"
+#include "point_3d_traits.h"
+#include "polygon_traits.h"
+
+//concept types
+#include "point_concept.h"
+#include "interval_concept.h"
+#include "rectangle_concept.h"
+#include "point_3d_concept.h"
+#include "polygon_concept.h"
+
+//definitions
+#include "post_concept_definitions.h"
+
+//geometry traits
+#include "geometry_traits.h"
+
+//defintions
+#include "post_geometry_traits_definitions.h"
+
+template <typename geometry_type_1, typename geometry_type_2>
+bool contains(const geometry_type_1& geometry_object, const geometry_type_2& contained_geometry_object) {
+ typename geometry_traits<geometry_type_1>::geometry_concept().contains(geometry_object, contained_geometry_object);
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+bool equivilence(const geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ typename geometry_traits<geometry_type_1>::geometry_concept concept_instantiation;
+ return concept_instantiation.equivilence(lvalue, rvalue);
+}
+
+template <typename geometry_type>
+typename component_type<geometry_type>::type
+get(const geometry_type& geometry_object, orientation_2d orient) {
+ return geometry_traits<geometry_type>::geometry_concept::get(geometry_object, orient);
+}
+
+template <typename geometry_type>
+typename component_type<geometry_type>::type
+get(const geometry_type& geometry_object, orientation_3d orient) {
+ return geometry_traits<geometry_type>::geometry_concept::get(geometry_object, orient);
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+geometry_type_1& assign(geometry_type_1& lvalue, geometry_type_2& rvalue) {
+ return geometry_traits<geometry_type_1>::geometry_concept::assign(lvalue, rvalue);
+}
+
+template <typename geometry_type_1, typename geometry_type_2>
+geometry_type_1& operator|(geometry_type_1& lvalue, const geometry_type_2& rvalue) {
+ return assign(lvalue, rvalue);
+}
+
Added: sandbox/gtl/gtl/interval_concept.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/interval_concept.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,68 @@
+struct interval_concept {
+ interval_concept() {}
+
+ template <direction_1d_enum dir, typename T>
+ static inline typename interval_traits<T>::coordinate_type
+ get(const T& interval) {
+ return interval_traits<T>::get(interval, dir);
+ }
+
+ template <typename T>
+ static inline typename interval_traits<T>::coordinate_type
+ get(const T& interval, direction_1d dir) {
+ return interval_traits<T>::get(interval, dir);
+ }
+
+ template <direction_1d_enum dir, typename T, typename coordinate_type>
+ static inline void set(T& interval, coordinate_type value) {
+ set(interval, dir, value);
+ }
+
+ template <typename T, typename coordinate_type>
+ static inline void set(T& interval, direction_1d dir, coordinate_type value) {
+ interval_traits<T>::set(interval, dir, value);
+ if(get<HIGH>(interval) < get<LOW>(interval))
+ interval_traits<T>::set(interval, dir.backward(), value);
+ }
+
+ template <typename T, typename coordinate_type1, typename coordinate_type2>
+ static inline T construct(coordinate_type1 low_value, coordinate_type2 high_value) {
+ if(low_value > high_value) std::swap(low_value, high_value);
+ return interval_traits<T>::construct(low_value, high_value);
+ }
+
+ template <typename T, typename T2>
+ static T copy_construct(const T2& interval) {
+ return construct<T>
+ (get(interval, LOW ),
+ get(interval, HIGH));
+ }
+
+ template <typename interval_type_1, typename interval_type_2>
+ static interval_type_1& assign(interval_type_1& lvalue, const interval_type_2& rvalue) {
+ set(lvalue, LOW, get(rvalue, LOW));
+ set(lvalue, HIGH, get(rvalue, HIGH));
+ return lvalue;
+ }
+
+ template <typename T, typename T2>
+ static bool equivilence(const T& interval1, const T2& interval2) {
+ return get(interval1, LOW) ==
+ get(interval2, LOW) &&
+ get(interval1, HIGH) ==
+ get(interval2, HIGH);
+ }
+
+ template <typename interval_type, typename coordinate_type>
+ static bool contains_coordinate(const interval_type& interval,
+ coordinate_type value, bool consider_touch) {
+ if(consider_touch) {
+ return value <= get<HIGH>(interval) && value >= get<LOW>(interval);
+ } else {
+ return value < get<HIGH>(interval) && value > get<LOW>(interval);
+ }
+ }
+
+};
+
+
Added: sandbox/gtl/gtl/interval_data.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/interval_data.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,26 @@
+template <typename T>
+class interval_data {
+public:
+ typedef T coordinate_type;
+ inline interval_data(){}
+ inline interval_data(coordinate_type low, coordinate_type high) {
+ coords_[LOW] = low; coords_[HIGH] = high;
+ }
+ inline interval_data(const interval_data& that) {
+ (*this) = that;
+ }
+ inline interval_data& operator=(const interval_data& that) {
+ coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
+ }
+ template <typename T2>
+ inline interval_data& operator=(const T2& rvalue);
+ inline coordinate_type get(direction_1d dir) const {
+ return coords_[dir.to_int()];
+ }
+ inline void set(direction_1d dir, coordinate_type value) {
+ coords_[dir.to_int()] = value;
+ }
+private:
+ coordinate_type coords_[2];
+};
+
Added: sandbox/gtl/gtl/interval_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/interval_traits.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,17 @@
+template <typename T>
+struct interval_traits {
+ typedef typename T::coordinate_type coordinate_type;
+
+ static inline coordinate_type get(const T& interval, direction_1d dir) {
+ return interval.get(dir);
+ }
+
+ static inline void set(T& interval, direction_1d dir, coordinate_type value) {
+ interval.set(dir, value);
+ }
+
+ static inline T construct(coordinate_type low_value, coordinate_type high_value) {
+ return T(low_value, high_value);
+ }
+};
+
Added: sandbox/gtl/gtl/isotropy.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/isotropy.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,59 @@
+enum orientation_2d_enum { HORIZONTAL = 0, VERTICAL = 1 };
+enum direction_1d_enum { LOW = 0, HIGH = 1 };
+enum orientation_3d_enum { PROXIMAL = 2 };
+enum winding_direction {
+ counterclockwise_winding = 0,
+ clockwise_winding = 1,
+ unknown_winding = 2
+};
+
+
+class orientation_2d {
+private:
+ unsigned int val_;
+ explicit orientation_2d(int o);
+public:
+ orientation_2d() : val_(HORIZONTAL) {}
+ orientation_2d(const orientation_2d& ori) : val_(ori.val_) {}
+ orientation_2d(const orientation_2d_enum val) : val_(val) {}
+ const orientation_2d& operator=(const orientation_2d& ori) {
+ val_ = ori.val_; return * this; }
+ bool operator==(orientation_2d that) const { return (val_ == that.val_); }
+ bool operator!=(orientation_2d that) const { return (val_ != that.val_); }
+ unsigned int to_int() const { return (val_); }
+ void turn_90() { val_ = val_^ 1; }
+};
+
+class direction_1d {
+private:
+ unsigned int val_;
+ explicit direction_1d(int d);
+public:
+ direction_1d() { val_ = LOW; }
+ direction_1d(const direction_1d& that) : val_(that.val_) {}
+ direction_1d(const direction_1d_enum val) : val_(val) {}
+ const direction_1d& operator = (const direction_1d& d) {
+ val_ = d.val_; return * this; }
+ bool operator==(direction_1d d) const { return (val_ == d.val_); }
+ bool operator!=(direction_1d d) const { return !((*this) == d); }
+ unsigned int to_int(void) const { return val_; }
+ direction_1d& backward() { val_ ^ 1; }
+};
+
+class orientation_3d {
+private:
+ unsigned int val_;
+ explicit orientation_3d(int o);
+public:
+ orientation_3d() : val_((int)HORIZONTAL) {}
+ orientation_3d(const orientation_3d& ori) : val_(ori.val_) {}
+ orientation_3d(const orientation_2d& ori) { val_ = ori.to_int(); }
+ orientation_3d(const orientation_3d_enum val) : val_(val) {}
+ ~orientation_3d() { }
+ const orientation_3d& operator=(const orientation_3d& ori) {
+ val_ = ori.val_; return * this; }
+ bool operator==(orientation_3d that) const { return (val_ == that.val_); }
+ bool operator!=(orientation_3d that) const { return (val_ != that.val_); }
+ unsigned int to_int() const { return (val_); }
+};
+
Added: sandbox/gtl/gtl/point_3d_concept.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/point_3d_concept.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,48 @@
+struct point_3d_concept {
+ point_3d_concept() {}
+
+ template <typename point_3d_type>
+ struct registration {
+ typedef typename point_3d_traits<point_3d_type>::coordinate_type component_type;
+ };
+
+ template <orientation_2d_enum orient, typename T>
+ static inline typename point_traits<T>::coordinate_type get(const T& point) {
+ return point_traits<T>::get(point, orient); }
+
+ template <orientation_3d_enum orient, typename T>
+ static inline typename point_3d_traits<T>::coordinate_type get(const T& point) {
+ return point_3d_traits<T>::get(point, orient); }
+
+ template <typename T>
+ static inline typename point_3d_traits<T>::coordinate_type get(const T& point, orientation_3d orient) {
+ return point_3d_traits<T>::get(point, orient); }
+
+ template <orientation_2d_enum orient, typename T, typename coordinate_type>
+ static inline void set(T& point, coordinate_type value) {
+ point_traits<T>::set(point, orient, value); }
+ template <orientation_3d_enum orient, typename T, typename coordinate_type>
+ static inline void set(T& point, coordinate_type value) {
+ point_traits<T>::set(point, orient, value); }
+ template <typename T, typename coordinate_type>
+ static inline void set(T& point, orientation_3d orient, coordinate_type value) {
+ point_traits<T>::set(point, orient, value); }
+
+ template <typename T, typename coordinate_type1, typename coordinate_type2, typename coordinate_type3>
+ static inline T construct(coordinate_type1 x_value,
+ coordinate_type2 y_value,
+ coordinate_type3 z_value) {
+ return point_3d_traits<T>::construct(x_value, y_value, z_value); }
+
+ template <typename point_3d_type_1, typename point_3d_type_2>
+ static point_3d_type_1& assign(point_3d_type_1& lvalue, const point_3d_type_2& rvalue) {
+ set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
+ set(lvalue, VERTICAL, get(rvalue, VERTICAL));
+ set(lvalue, PROXIMAL, get(rvalue, PROXIMAL));
+ return lvalue;
+ }
+
+
+};
+
+
Added: sandbox/gtl/gtl/point_3d_data.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/point_3d_data.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,23 @@
+template <typename T>
+class point_3d_data {
+public:
+ typedef T coordinate_type;
+ inline point_3d_data(){}
+ inline point_3d_data(coordinate_type x, coordinate_type y) {
+ coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = 0; }
+ inline point_3d_data(coordinate_type x, coordinate_type y, coordinate_type z) {
+ coords_[HORIZONTAL] = x; coords_[VERTICAL] = y; coords_[PROXIMAL] = z; }
+ inline point_3d_data(const point_3d_data& that) { (*this) = that; }
+ inline point_3d_data& operator=(const point_3d_data& that) {
+ coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1];
+ coords_[2] = that.coords_[2]; return *this; }
+ template <typename T2>
+ inline point_3d_data& operator=(const T2& rvalue);
+ inline coordinate_type get(orientation_3d orient) const {
+ return coords_[orient.to_int()]; }
+ inline void set(orientation_3d orient, coordinate_type value) {
+ coords_[orient.to_int()] = value; }
+private:
+ coordinate_type coords_[3];
+};
+
Added: sandbox/gtl/gtl/point_3d_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/point_3d_traits.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,16 @@
+template <typename T>
+struct point_3d_traits {
+ typedef typename T::coordinate_type coordinate_type;
+
+ static inline coordinate_type get(const T& point, orientation_3d orient) {
+ return point.get(orient); }
+
+ static inline void set(T& point, orientation_3d orient, coordinate_type value) {
+ point.set(orient, value); }
+
+ static inline T construct(coordinate_type x_value,
+ coordinate_type y_value,
+ coordinate_type z_value) {
+ return T(x_value, y_value, z_value); }
+};
+
Added: sandbox/gtl/gtl/point_concept.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/point_concept.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,86 @@
+struct point_concept {
+ point_concept() {}
+
+ template <typename point_type>
+ struct registration {
+ typedef typename point_traits<point_type>::coordinate_type component_type;
+ };
+
+ template <typename T>
+ static inline typename point_traits<T>::coordinate_type get(const T& point, orientation_2d orient) {
+ return point_traits<T>::get(point, orient);
+ }
+
+ template <orientation_2d_enum orient, typename T>
+ static inline typename point_traits<T>::coordinate_type get(const T& point) {
+ return get(point, orient);
+ }
+
+ template <typename T, typename coordinate_type>
+ static inline void set(T& point, orientation_2d orient, coordinate_type value) {
+ point_traits<T>::set(point, orient, value);
+ }
+
+ template <orientation_2d_enum orient, typename T, typename coordinate_type>
+ static inline void set(T& point, coordinate_type value) {
+ set(point, orient, value);
+ }
+
+ template <typename point_type>
+ static void x(point_type& point) {
+ return get<HORIZONTAL>(point);
+ }
+
+ template <typename point_type>
+ static void y(point_type& point) {
+ return get<VERTICAL>(point);
+ }
+
+ template <typename point_type, typename coordinate_type>
+ static void x(point_type& point, coordinate_type value) {
+ set<HORIZONTAL>(point, value);
+ }
+
+ template <typename point_type, typename coordinate_type>
+ static void y(point_type& point, coordinate_type value) {
+ set<VERTICAL>(point, value);
+ }
+
+ template <typename T, typename coordinate_type1, typename coordinate_type2>
+ static inline T construct(coordinate_type1 x_value, coordinate_type2 y_value) {
+ return point_traits<T>::construct(x_value, y_value);
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ static point_type_1& assign(point_type_1& lvalue, const point_type_2& rvalue) {
+ set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
+ set(lvalue, VERTICAL, get(rvalue, VERTICAL));
+ return lvalue;
+ }
+
+ template <typename T, typename T2>
+ static inline bool equivilence(const T& point1, const T2& point2) {
+ typename point_traits<T>::coordinate_type x1 = get<HORIZONTAL>(point1);
+ typename point_traits<T2>::coordinate_type x2 = get(point2, HORIZONTAL);
+ typename point_traits<T>::coordinate_type y1 = get(point1, VERTICAL);
+ typename point_traits<T2>::coordinate_type y2 = get<VERTICAL>(point2);
+ return x1 == x2 && y1 == y2;
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ static typename point_traits<point_type_1>::coordinate_type
+ manhattan_distance(const point_type_1& point1, const point_type_2& point2) {
+ return distance(point1, point2, HORIZONTAL) + distance(point1, point2, VERTICAL);
+ }
+
+ template <typename point_type_1, typename point_type_2>
+ static typename point_traits<point_type_1>::coordinate_type
+ distance(const point_type_1& point1, const point_type_2& point2, orientation_2d orient) {
+ typename point_traits<point_type_1>::coordinate_type return_value =
+ get(point1, orient) - get(point2, orient);
+ return return_value < 0 ? -return_value : return_value;
+ }
+
+};
+
+
Added: sandbox/gtl/gtl/point_data.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/point_data.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,24 @@
+template <typename T>
+class point_data {
+public:
+ typedef T coordinate_type;
+ inline point_data(){}
+ inline point_data(coordinate_type x, coordinate_type y) {
+ coords_[HORIZONTAL] = x; coords_[VERTICAL] = y;
+ }
+ inline point_data(const point_data& that) { (*this) = that; }
+ inline point_data& operator=(const point_data& that) {
+ coords_[0] = that.coords_[0]; coords_[1] = that.coords_[1]; return *this;
+ }
+ template <typename T2>
+ inline point_data& operator=(const T2& rvalue);
+ inline coordinate_type get(orientation_2d orient) const {
+ return coords_[orient.to_int()];
+ }
+ inline void set(orientation_2d orient, coordinate_type value) {
+ coords_[orient.to_int()] = value;
+ }
+private:
+ coordinate_type coords_[2];
+};
+
Added: sandbox/gtl/gtl/point_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/point_traits.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,15 @@
+template <typename T>
+struct point_traits {
+ typedef typename T::coordinate_type coordinate_type;
+
+ static inline coordinate_type get(const T& point, orientation_2d orient) {
+ return point.get(orient);
+ }
+ static inline void set(T& point, orientation_2d orient, coordinate_type value) {
+ point.set(orient, value);
+ }
+ static inline T construct(coordinate_type x_value, coordinate_type y_value) {
+ return T(x_value, y_value);
+ }
+};
+
Added: sandbox/gtl/gtl/polygon_concept.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_concept.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,391 @@
+struct polygon_concept {
+ inline polygon_concept() {}
+
+ template <class iterator_type, class point_type>
+ class iterator_points {
+ private:
+ iterator_type iter_;
+ iterator_type iter_end_;
+ point_type pt_;
+ typename point_traits<point_type>::coordinate_type firstX_;
+ orientation_2d orient_;
+ public:
+ inline iterator_points() {}
+ inline iterator_points(iterator_type iter, iterator_type iter_end) :
+ iter_(iter), iter_end_(iter_end), orient_(HORIZONTAL) {
+ if(iter_ != iter_end_) {
+ firstX_ = *iter_;
+ point_concept::set<HORIZONTAL>(pt_, firstX_);
+ ++iter_;
+ if(iter_ != iter_end_) {
+ point_concept::set<VERTICAL>(pt_, *iter_);
+ }
+ }
+ }
+ //use bitwise copy and assign provided by the compiler
+ inline iterator_points& operator++() {
+ ++iter_;
+ if(iter_ == iter_end_) {
+ if(point_concept::get<HORIZONTAL>(pt_) != firstX_) {
+ --iter_;
+ point_concept::set<HORIZONTAL>(pt_, firstX_);
+ }
+ } else {
+ point_concept::set(pt_, orient_, *iter_);
+ orient_.turn_90();
+ }
+ return *this;
+ }
+ inline iterator_points operator++(int) {
+ iterator_points tmp(*this);
+ ++(*this);
+ return tmp;
+ }
+ inline bool operator==(const iterator_points& that) const {
+ return (iter_ == that.iter_);
+ }
+ inline bool operator!=(const iterator_points& that) const {
+ return (iter_ != that.iter_);
+ }
+ inline const point_type& operator*() const { return pt_; }
+ };
+
+ template <class iT, typename coordinate_type>
+ class iterator_points_to_coords {
+ private:
+ iT iter_;
+ orientation_2d orient_;
+ public:
+ inline iterator_points_to_coords() {}
+ inline iterator_points_to_coords(iT iter) : iter_(iter), orient_(HORIZONTAL) {}
+ inline iterator_points_to_coords(const iterator_points_to_coords& that) :
+ iter_(that.iter_), orient_(that.orient_) {}
+ //use bitwise copy and assign provided by the compiler
+ inline iterator_points_to_coords& operator++() {
+ ++iter_;
+ orient_.turn_90();
+ return *this;
+ }
+ inline iterator_points_to_coords operator++(int) {
+ iT tmp(*this);
+ ++(*this);
+ return tmp;
+ }
+ inline bool operator==(const iterator_points_to_coords& that) const {
+ return (iter_ == that.iter_);
+ }
+ inline bool operator!=(const iterator_points_to_coords& that) const {
+ return (iter_ != that.iter_);
+ }
+ inline coordinate_type operator*() { return (*iter_).get(orient_); }
+ };
+
+ 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);
+ }
+
+ template<typename polygon_type, typename rectangle_type>
+ static void set(polygon_type& polygon, const rectangle_type& rect) {
+ typename polygon_traits<polygon_type>::coordinate_type coords[4] =
+ {rectangle_concept::xl(rect), rectangle_concept::yl(rect),
+ rectangle_concept::xh(rect), rectangle_concept::yh(rect)};
+ set(polygon, coords, coords+4);
+ }
+
+ template<typename polygon_type, typename point_iterator_type>
+ static void set_points(polygon_type& polygon, point_iterator_type begin_point, point_iterator_type end_point) {
+ return set(iterator_points_to_coords<point_iterator_type,
+ typename polygon_traits<polygon_type>::coordinate_type>(begin_point),
+ iterator_points_to_coords<point_iterator_type,
+ typename polygon_traits<polygon_type>::coordinate_type>(end_point));
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::iterator_type begin(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::begin(polygon);
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::iterator_type end(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::end(polygon);
+ }
+
+ template <typename polygon_type>
+ static iterator_points<typename polygon_traits<polygon_type>::iterator_type,
+ point_data<typename polygon_traits<polygon_type>::coordinate_type> >
+ begin_points(const polygon_type& polygon) {
+ return iterator_points<typename polygon_traits<polygon_type>::iterator_type,
+ point_data<typename polygon_traits<polygon_type>::coordinate_type> > (begin(polygon), end(polygon));
+ }
+
+ template <typename polygon_type>
+ static iterator_points<typename polygon_traits<polygon_type>::iterator_type,
+ point_data<typename polygon_traits<polygon_type>::coordinate_type> >
+ end_points(const polygon_type& polygon) {
+ return iterator_points<typename polygon_traits<polygon_type>::iterator_type,
+ point_data<typename polygon_traits<polygon_type>::coordinate_type> > (end(polygon), end(polygon));
+ }
+
+ template<typename T, class iT>
+ static T construct(iT inputBegin, iT inputEnd) { return polygon_traits<T>::construct(inputBegin, inputEnd); }
+
+ template<typename polygon_type, typename rectangle_type>
+ static polygon_type construct_from_rectangle(const rectangle_type& rect) {
+ polygon_type poly;
+ set(poly, rect);
+ return poly;
+ }
+
+ template <typename polygon_type, typename polygon_type2>
+ static polygon_type copy_construct(const polygon_type2& polygon) {
+ return construct(polygon_concept::begin(polygon), polygon_concept::end(polygon));
+ }
+
+ template <typename polygon_type>
+ static std::size_t size(const polygon_type& polygon) {
+ return polygon_traits<polygon_type>::size(polygon);
+ }
+
+ template <typename polygon_type_1, typename polygon_type_2>
+ static polygon_type_1& assign(polygon_type_1& lvalue, const polygon_type_2& rvalue) {
+ set(lvalue, begin(rvalue), end(rvalue));
+ return lvalue;
+ }
+
+ template <typename polygon_type>
+ static direction_1d winding(const polygon_type& polygon){
+ winding_direction wd = polygon_traits<polygon_type>::winding(polygon);
+ if(wd != unknown_winding) {
+ return wd == clockwise_winding ? LOW: HIGH;
+ }
+ direction_1d dir = HIGH;
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::iterator iterator;
+ iterator itr = begin(polygon);
+ coordinate_type firstx = *itr;
+ coordinate_type minX = firstx;
+ ++itr;
+ iterator end_itr = end(polygon);
+ if(itr == end_itr) return dir;
+ coordinate_type prevy = *itr;
+ coordinate_type firsty = *itr;
+ ++itr;
+ for( ; itr != end_itr; ++itr) {
+ coordinate_type x = *itr;
+ ++itr;
+ if(itr == end_itr) break;
+ coordinate_type y = *itr;
+ if(x <= minX) {
+ minX = x;
+ //edge directed downward on left side of figure is counterclockwise
+ dir = y < prevy ? HIGH : LOW;
+ }
+ prevy = y;
+ }
+ if(firstx <= minX) {
+ dir = firsty < prevy ? HIGH : LOW;
+ }
+ return dir;
+ }
+
+ template <typename polygon_type>
+ static rectangle_data<typename polygon_traits<polygon_type>::coordinate_type>
+ bounding_box(const polygon_type& polygon) {
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::iterator_type iterator;
+ coordinate_type xmin = 0;
+ coordinate_type ymin = 0;
+ coordinate_type xmax = 0;
+ coordinate_type ymax = 0;
+ bool first_iteration = true;
+ iterator itr_end = end(polygon);
+ for(iterator itr = begin(polygon); itr != itr_end; ++itr) {
+ coordinate_type x = *itr;
+ ++itr;
+ if(itr == itr_end) break;
+ coordinate_type y = *itr;
+ if(first_iteration) {
+ xmin = xmax = x;
+ ymin = ymax = x;
+ first_iteration = false;
+ }
+ xmin = std::min(xmin, x);
+ xmax = std::max(xmax, x);
+ ymin = std::min(ymin, y);
+ ymax = std::max(ymax, y);
+ }
+ typedef rectangle_data<coordinate_type> rectangle_type;
+ rectangle_type return_value = rectangle_concept::construct<rectangle_type>(xmin, ymin, xmax, ymax);
+ return return_value;
+ }
+
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::coordinate_type
+ area(const polygon_type& polygon) {
+ //for (long i = 2; i < _size; i += 2) res += ((double)_vertex[i-1])*((double)(_vertex[i-2] - _vertex[i]));
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::iterator_type iterator;
+ coordinate_type retval = 0;
+ iterator itr = begin(polygon);
+ iterator end_itr = end(polygon);
+ coordinate_type firstx = *itr;
+ coordinate_type prevx = *itr;
+ ++itr;
+ if(itr == end_itr) return 0;
+ coordinate_type prevy = *itr;
+ ++itr;
+ for( ; itr != end_itr; ++itr) {
+ coordinate_type x = *itr;
+ ++itr;
+ if(itr == end_itr) break;
+ coordinate_type y = *itr;
+ retval += (prevy * (prevx - x));
+ prevy = y;
+ prevx = x;
+ }
+ retval += (prevy * (prevx - firstx));
+ return retval >= 0 ? retval : -retval;
+ }
+
+ /// get the perimeter of the rectangle
+ template <typename polygon_type>
+ static typename polygon_traits<polygon_type>::coordinate_type
+ perimeter(const polygon_type& polygon) {
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::iterator_type iterator_type;
+ typedef iterator_points<iterator_type, point_data<coordinate_type> > iterator;
+ coordinate_type return_value = 0;
+ point_data<coordinate_type> previous_point, first_point;
+ iterator itr = begin_points(polygon);
+ iterator itr_end = end_points(polygon);
+ if(itr == itr_end) return return_value;
+ previous_point = first_point = *itr;
+ ++itr;
+ for( ; itr != itr_end; ++itr) {
+ ++itr;
+ if(itr == itr_end) break;
+ point_data<coordinate_type> current_point = *itr;
+ return_value += point_concept::manhattan_distance(current_point, previous_point);
+ previous_point = current_point;
+ }
+ return_value += point_concept::manhattan_distance(previous_point, first_point);
+ return return_value;
+ }
+
+ /// check if point is inside polygon
+ template <typename polygon_type, typename point_type>
+ static bool contains_point(const polygon_type& polygon, const point_type& point,
+ bool consider_touch = true) {
+ typedef typename polygon_traits<polygon_type>::coordinate_type coordinate_type;
+ typedef typename polygon_traits<polygon_type>::iterator_type iterator_type;
+ typedef iterator_points<iterator_type, point_data<coordinate_type> > iterator;
+ iterator iter, iter_end;
+ iter_end = end_points(polygon);
+ iter = begin_points(polygon);
+ point_data<coordinate_type> prev_pt = *iter;
+ unsigned int num = size(polygon);
+ unsigned int counts[2] = {0, 0};
+ for(unsigned int i = 0; i < num; ++i) {
+ if(i == num-1) iter = begin_points(polygon);
+ else ++iter;
+ point_data<coordinate_type> current_pt = *iter;
+ if(point_concept::get<HORIZONTAL>(current_pt) ==
+ point_concept::get<HORIZONTAL>(prev_pt)) {
+ unsigned int index = point_concept::get<HORIZONTAL>(current_pt) >
+ point_concept::get<HORIZONTAL>(point);
+ unsigned int increment = 0;
+ interval_data<coordinate_type> ivl =
+ interval_concept::construct<interval_data<coordinate_type> >(point_concept::get<VERTICAL>(current_pt),
+ point_concept::get<VERTICAL>(prev_pt));
+ if(interval_concept::contains_coordinate(ivl, point_concept::get<VERTICAL>(point), true)) {
+ if(point_concept::get<HORIZONTAL>(current_pt) ==
+ point_concept::get<HORIZONTAL>(point)) return consider_touch;
+ ++increment;
+ if(point_concept::get<VERTICAL>(current_pt) !=
+ point_concept::get<VERTICAL>(point) &&
+ point_concept::get<VERTICAL>(prev_pt) !=
+ point_concept::get<VERTICAL>(point)) {
+ ++increment;
+ }
+ counts[index] += increment;
+ }
+ }
+ prev_pt = current_pt;
+ }
+ //odd count implies boundary condition
+ if(counts[0] % 2 || counts[1] % 2) return consider_touch;
+ //an odd number of edges to the left implies interior pt
+ return counts[0] % 4;
+ }
+
+// //awaiting re-implementation of iterator_edges and edge concept
+// template <typename polygon_type, typename point_type>
+// static point_type project(const polygon_type& polygon, const point_type& point) const {
+// point_type return_value;
+// typedef iterator_edges<typename polygon_traits<polygon_type>::iterator_type,
+// edge_data<typename polygon_traits<polygon_type>::coordinate_type> > iterator;
+// iterator iter = begin_edges();
+// iterator iter_end = end_edges();
+// double dist = 0;
+// bool first_segment = true;
+// for( ; iter != iter_end; ++iter) {
+// point_type segement_point = segment_concept::project_point(*iter, point);
+// double seg_dist = point_concept::euclidian_distance(point, segment_point);
+// if(first_segment || seg_dist < dist) {
+// dist = seg_dist;
+// return_value = segment_point;
+// }
+// }
+// return return_value;
+// }
+
+// //awaiting re-implementation of iterator_edges and edge concept
+// template <typename polygon_type, typename point_type>
+// static point_type project(point_type& result, const polygon_type& polygon,
+// const point_type& point, direction_2d dir) {
+// typedef iterator_edges<typename polygon_traits<polygon_type>::iterator_type,
+// edge_data<typename polygon_traits<polygon_type>::coordinate_type> > iterator;
+// iterator iter = begin_edges();
+// iterator iter_end = end_edges();
+// double dist = 0;
+// bool found = false;
+// bool first_segment = true;
+// for( ; iter != iter_end; ++iter) {
+// point_type segement_point;
+// if(segment_concept::project_point(segment_point, *iter, point, dir)) {
+// found = true;
+// double seg_dist = point_concept::euclidian_distance(point, segment_point);
+// if(first_segment || seg_dist < dist) {
+// dist = seg_dist;
+// result = segment_point;
+// }
+// }
+// return found;
+// }
+
+ template <typename polygon_type, typename coordinate_type_1, typename coordinate_type_2>
+ static void move(polygon_type& polygon, coordinate_type_1 x_displacement, coordinate_type_2 y_displacement) {
+ std::vector<typename polygon_traits<polygon_type>::coordinate_type> coords;
+ coords.reserve(size(polygon));
+ bool pingpong = true;
+ for(typename polygon_traits<polygon_type>::iterator_type iter = begin(polygon);
+ iter != end(polygon); ++iter) {
+ coords.push_back((*iter) + predicated_value(pingpong, x_displacement, y_displacement));
+ pingpong = !pingpong;
+ }
+ set(polygon, coords.begin(), coords.end());
+ }
+
+ /// move polygon by delta in orient
+ template <typename polygon_type, typename coordinate_type_1>
+ static void move(polygon_type& polygon, orientation_2d orient, coordinate_type_1 displacement) {
+ if(orient == HORIZONTAL) {
+ move(displacement, 0);
+ } else {
+ move(0, displacement);
+ }
+ }
+};
+
+
Added: sandbox/gtl/gtl/polygon_data.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_data.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,44 @@
+template <typename T>
+class polygon_data {
+public:
+ typedef T coordinate_type;
+ typedef typename std::vector<coordinate_type>::const_iterator iterator_type;
+
+ inline polygon_data(){;} //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_data& set(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_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);
+
+ /// get begin iterator, returns a pointer to a const Unit
+ inline iterator_type begin() const { return coords_.begin(); }
+
+ /// get end iterator, returns a pointer to a const Unit
+ inline iterator_type end() const { return coords_.end(); }
+
+ inline std::size_t size() const { return coords_.size(); }
+
+private:
+ std::vector<coordinate_type> coords_;
+};
+
Added: sandbox/gtl/gtl/polygon_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/polygon_traits.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,33 @@
+template <class T>
+struct polygon_traits {
+ typedef typename T::coordinate_type coordinate_type;
+ typedef typename T::iterator_type iterator_type;
+
+ /// Get the begin iterator
+ static inline iterator_type begin(const T& t) {
+ return t.begin();
+ }
+
+ /// Get the end iterator
+ static inline iterator_type end(const T& t) {
+ return t.end();
+ }
+
+ /// Set the data of a polygon with the unique coordinates in an iterator, starting with an x
+ template <class iT>
+ static inline T& set(T& t, iT input_begin, iT input_end) {
+ t.set(input_begin, input_end);
+ return t;
+ }
+
+ /// Get the number of sides of the polygon
+ static inline unsigned int size(const T& t) {
+ return t.size();
+ }
+
+ /// Get the winding direction of the polygon
+ static inline winding_direction winding(const T& t) {
+ return unknown_winding;
+ }
+};
+
Added: sandbox/gtl/gtl/post_concept_definitions.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/post_concept_definitions.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,42 @@
+template <typename T>
+template <typename interval_type>
+inline void rectangle_data<T>::set(orientation_2d orient, const interval_type& interval) {
+ ranges_[orient.to_int()].set(LOW, interval_concept::get(interval, LOW));
+ ranges_[orient.to_int()].set(HIGH, interval_concept::get(interval, HIGH));
+}
+
+template <class T>
+template <class T2>
+point_data<T>& point_data<T>::operator=(const T2& rvalue) {
+ point_concept::assign(*this, rvalue);
+ return *this;
+}
+
+template <class T>
+template <class T2>
+interval_data<T>& interval_data<T>::operator=(const T2& rvalue) {
+ interval_concept::assign(*this, rvalue);
+ return *this;
+}
+
+template <class T>
+template <class T2>
+rectangle_data<T>& rectangle_data<T>::operator=(const T2& rvalue) {
+ rectangle_concept::assign(*this, rvalue);
+ return *this;
+}
+
+template <class T>
+template <class T2>
+point_3d_data<T>& point_3d_data<T>::operator=(const T2& rvalue) {
+ point_3d_concept::assign(*this, rvalue);
+ return *this;
+}
+
+template <class T>
+template <class T2>
+polygon_data<T>& polygon_data<T>::operator=(const T2& rvalue) {
+ polygon_concept::assign(*this, rvalue);
+ return *this;
+}
+
Added: sandbox/gtl/gtl/post_geometry_traits_definitions.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/post_geometry_traits_definitions.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,11 @@
+template <typename rectangle_type, typename geometry_type>
+bool rectangle_concept::contains(const rectangle_type& rectangle, const geometry_type& contained_geometry_object) {
+ return rectangle_concept::contains_dispatch(rectangle, contained_geometry_object, typename geometry_traits<geometry_type>::geometry_concept());
+}
+
+template <typename geometry_type>
+struct component_type {
+ typedef typename geometry_traits<geometry_type>::geometry_concept::template
+ registration<geometry_type>::component_type type;
+};
+
Added: sandbox/gtl/gtl/rectangle_concept.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/rectangle_concept.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,106 @@
+struct rectangle_concept {
+ rectangle_concept() {}
+
+ template <typename rectangle_type>
+ struct registration {
+ typedef typename rectangle_traits<rectangle_type>::coordinate_type coordinate_type;
+ typedef interval_data<coordinate_type> component_type;
+ };
+
+ template <orientation_2d_enum orient, typename T>
+ static inline typename rectangle_traits<T>::interval_type
+ get(const T& rectangle) {
+ return rectangle_traits<T>::get(rectangle, orient);
+ }
+
+ template <typename T>
+ static inline typename rectangle_traits<T>::interval_type
+ get(const T& rectangle, orientation_2d orient) {
+ return rectangle_traits<T>::get(rectangle, orient);
+ }
+
+ template <orientation_2d_enum orient, typename T, typename T2>
+ static inline void set(T& rectangle, const T2& interval) {
+ rectangle_traits<T>::set(rectangle, orient, interval);
+ }
+
+ template <typename T, typename T2>
+ static inline void set(T& rectangle, orientation_2d orient, const T2& interval) {
+ rectangle_traits<T>::set(rectangle, orient, interval);
+ }
+
+ template <typename T, typename T2, typename T3>
+ static inline T construct(const T2& interval_horizontal,
+ const T3& interval_vertical) {
+ return rectangle_traits<T>::construct(interval_horizontal, interval_vertical); }
+
+ template <typename T, typename coordinate_type>
+ static inline T construct(coordinate_type xl, coordinate_type yl, coordinate_type xh, coordinate_type yh) {
+ return rectangle_traits<T>::construct(interval_data<coordinate_type>(xl, xh),
+ interval_data<coordinate_type>(yl, yh));
+ }
+
+ template <typename T, typename T2>
+ static T copy_construct(const T2& rectangle) {
+ return construct<T>
+ (get(rectangle, HORIZONTAL),
+ get(rectangle, VERTICAL));
+ }
+
+ template <typename rectangle_type_1, typename rectangle_type_2>
+ static rectangle_type_1& assign(rectangle_type_1& lvalue, const rectangle_type_2& rvalue) {
+ set(lvalue, HORIZONTAL, get(rvalue, HORIZONTAL));
+ set(lvalue, VERTICAL, get(rvalue, VERTICAL));
+ return lvalue;
+ }
+
+ template <typename T, typename T2>
+ static bool equivilence(const T& rect1, const T2& rect2) {
+ return interval_concept::equivilence(get(rect1, HORIZONTAL),
+ get(rect2, HORIZONTAL)) &&
+ interval_concept::equivilence(get(rect1, VERTICAL),
+ get(rect2, VERTICAL));
+ }
+
+ template <typename rectangle_type>
+ static typename rectangle_traits<rectangle_type>::coordinate_type
+ xl(const rectangle_type& rectangle) {
+ return interval_concept::get<LOW>(get<HORIZONTAL>(rectangle));
+ }
+
+ template <typename rectangle_type>
+ static typename rectangle_traits<rectangle_type>::coordinate_type
+ xh(const rectangle_type& rectangle) {
+ return interval_concept::get<HIGH>(get<HORIZONTAL>(rectangle));
+ }
+
+ template <typename rectangle_type>
+ static typename rectangle_traits<rectangle_type>::coordinate_type
+ yl(const rectangle_type& rectangle) {
+ return interval_concept::get<LOW>(get<VERTICAL>(rectangle));
+ }
+
+ template <typename rectangle_type>
+ static typename rectangle_traits<rectangle_type>::coordinate_type
+ yh(const rectangle_type& rectangle) {
+ return interval_concept::get<HIGH>(get<VERTICAL>(rectangle));
+ }
+
+ template <typename rectangle_type, typename rectangle_type2>
+ static bool contains_dispatch(const rectangle_type& rectangle, const rectangle_type2 rectangle_contained, rectangle_concept tag) {
+ std::cout << "rectangle contains rectangle\n";
+ }
+ template <typename rectangle_type, typename point_type>
+ static bool contains_dispatch(const rectangle_type& rectangle, const point_type point_contained, point_concept tag) {
+ std::cout << "rectangle contains point\n";
+ }
+ template <typename concept_type, typename rectangle_type, typename geometry_type>
+ static bool contains(const rectangle_type& rectangle, const geometry_type& contained_geometry_object) {
+ return contains_dispatch(rectangle, contained_geometry_object, concept_type());
+ }
+
+ template <typename rectangle_type, typename geometry_type>
+ static bool contains(const rectangle_type& rectangle, const geometry_type& contained_geometry_object);
+};
+
+
Added: sandbox/gtl/gtl/rectangle_data.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/rectangle_data.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,26 @@
+template <typename T>
+class rectangle_data {
+public:
+ typedef T coordinate_type;
+ inline rectangle_data() {}
+ 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); }
+
+ inline rectangle_data(const rectangle_data& that) { (*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);
+
+ inline interval_data<coordinate_type> get(orientation_2d orient) const {
+ return ranges_[orient.to_int()]; }
+ template <typename interval_type>
+ inline void set(orientation_2d orient, const interval_type& interval);
+private:
+ interval_data<coordinate_type> ranges_[2];
+};
+
Added: sandbox/gtl/gtl/rectangle_traits.h
==============================================================================
--- (empty file)
+++ sandbox/gtl/gtl/rectangle_traits.h 2008-05-08 03:00:46 EDT (Thu, 08 May 2008)
@@ -0,0 +1,18 @@
+template <typename T>
+struct rectangle_traits {
+ typedef typename T::coordinate_type coordinate_type;
+ typedef interval_data<coordinate_type> interval_type;
+
+ static inline interval_type get(const T& rectangle, orientation_2d orient) {
+ return rectangle.get(orient); }
+
+ template <typename 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); }
+};
+