Boost-Commit mailing page: [Boost-commit] svn:boost r78291 - in sandbox/gtl: boost/polygon doc libs/polygon/test

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r78291 - in sandbox/gtl: boost/polygon doc libs/polygon/test
From: sydorchuk.andriy_at_[hidden]
Date: 2012-05-01 07:34:08

Author: asydorchuk
Date: 2012-05-01 07:34:07 EDT (Tue, 01 May 2012)
New Revision: 78291
URL: http://svn.boost.org/trac/boost/changeset/78291

Log:
Updating tests/docs/sources for segment concept.

Text files modified:
   sandbox/gtl/boost/polygon/segment_concept.hpp | 187 +++++++++++++++++----------------------
   sandbox/gtl/doc/gtl_segment_concept.htm | 154 +++++++++++++++++---------------
   sandbox/gtl/libs/polygon/test/polygon_segment_test.cpp | 59 +++++++++--
   3 files changed, 207 insertions(+), 193 deletions(-)

Modified: sandbox/gtl/boost/polygon/segment_concept.hpp
==============================================================================
--- sandbox/gtl/boost/polygon/segment_concept.hpp (original)
+++ sandbox/gtl/boost/polygon/segment_concept.hpp 2012-05-01 07:34:07 EDT (Tue, 01 May 2012)
@@ -534,7 +534,46 @@
 return segment;
 }

-struct y_s_e_intersects : gtl_yes {};
+ struct y_s_abuts1 : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_abuts1,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ abuts(const Segment1& segment1, const Segment2& segment2, direction_1d dir) {
+ return dir.to_int() ? equivalence(low(segment2) , high(segment1)) :
+ equivalence(low(segment1) , high(segment2));
+ }
+
+ struct y_s_abuts2 : gtl_yes {};
+
+ template <typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_3<
+ y_s_abuts2,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ abuts(const Segment1& segment1, const Segment2& segment2) {
+ return abuts(segment1, segment2, HIGH) || abuts(segment1, segment2, LOW);
+ }
+
+ struct y_s_e_intersects : gtl_yes {};

 template <typename Segment1, typename Segment2>
 typename enable_if<
@@ -568,6 +607,48 @@
 typename paf::half_edge(l2, h2));
 }

+ struct y_s_intersect : gtl_yes {};
+
+ // Set point to the intersection of segment and b
+ template <typename Point, typename Segment1, typename Segment2>
+ typename enable_if<
+ typename gtl_and_4<
+ y_s_intersect,
+ typename is_mutable_point_concept<
+ typename geometry_concept<Point>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment1>::type
+ >::type,
+ typename is_segment_concept<
+ typename geometry_concept<Segment2>::type
+ >::type
+ >::type,
+ bool
+ >::type
+ intersection(Point& intersection,
+ const Segment1& segment1,
+ const Segment2& segment2,
+ bool projected = false,
+ bool round_closest = false) {
+ typedef polygon_arbitrary_formation<
+ typename segment_coordinate_type<Segment1>::type
+ > paf;
+ typename paf::Point pt;
+ typename paf::Point l1, h1, l2, h2;
+ assign(l1, low(segment1));
+ assign(h1, high(segment1));
+ assign(l2, low(segment2));
+ assign(h2, high(segment2));
+ typename paf::half_edge he1(l1, h1), he2(l2, h2);
+ typename paf::compute_intersection_pack pack;
+ if (pack.compute_intersection(pt, he1, he2, projected, round_closest)) {
+ assign(intersection, pt);
+ return true;
+ }
+ return false;
+ }
+
 struct y_s_e_dist : gtl_yes {};

 template <typename Segment, typename Point>
@@ -638,110 +719,6 @@
 return (subres1 < subres2) ? subres1 : subres2;
 }

- struct y_s_abuts1 : gtl_yes {};
-
- template <typename Segment1, typename Segment2>
- typename enable_if<
- typename gtl_and_3<
- y_s_abuts1,
- typename is_segment_concept<
- typename geometry_concept<Segment1>::type
- >::type,
- typename is_segment_concept<
- typename geometry_concept<Segment2>::type
- >::type
- >::type,
- bool
- >::type
- abuts(const Segment1& segment1, const Segment2& segment2, direction_1d dir) {
- return dir.to_int() ? equivalence(low(segment2) , high(segment1)) :
- equivalence(low(segment1) , high(segment2));
- }
-
- struct y_s_abuts2 : gtl_yes {};
-
- template <typename Segment1, typename Segment2>
- typename enable_if<
- typename gtl_and_3<
- y_s_abuts2,
- typename is_segment_concept<
- typename geometry_concept<Segment1>::type
- >::type,
- typename is_segment_concept<
- typename geometry_concept<Segment2>::type
- >::type
- >::type,
- bool
- >::type
- abuts(const Segment1& segment1, const Segment2& segment2) {
- return abuts(segment1, segment2, HIGH) || abuts(segment1, segment2, LOW);
- }
-
- struct y_s_e_bintersect : gtl_yes {};
-
- template <typename Segment1, typename Segment2>
- typename enable_if<
- typename gtl_and_3<
- y_s_e_bintersect,
- typename is_segment_concept<
- typename geometry_concept<Segment1>::type
- >::type,
- typename is_segment_concept<
- typename geometry_concept<Segment2>::type
- >::type
- >::type,
- bool
- >::type
- boundaries_intersect(const Segment1& segment1, const Segment2& segment2,
- bool consider_touch = true) {
- return (contains(segment1, low(segment2), consider_touch) ||
- contains(segment1, high(segment2), consider_touch)) &&
- (contains(segment2, low(segment1), consider_touch) ||
- contains(segment2, high(segment1), consider_touch));
- }
-
- struct y_s_intersect : gtl_yes {};
-
- // Set point to the intersection of segment and b
- template <typename Point, typename Segment1, typename Segment2>
- typename enable_if<
- typename gtl_and_4<
- y_s_intersect,
- typename is_mutable_point_concept<
- typename geometry_concept<Point>::type
- >::type,
- typename is_segment_concept<
- typename geometry_concept<Segment1>::type
- >::type,
- typename is_segment_concept<
- typename geometry_concept<Segment2>::type
- >::type
- >::type,
- bool
- >::type
- intersection(Point& intersection,
- const Segment1& segment1,
- const Segment2& segment2,
- bool projected = false,
- bool round_closest = false) {
- typedef polygon_arbitrary_formation<
- typename segment_coordinate_type<Segment1>::type
- > paf;
- typename paf::Point pt;
- typename paf::Point l1, h1, l2, h2;
- assign(l1, low(segment1));
- assign(h1, high(segment1));
- assign(l2, low(segment2));
- assign(h2, high(segment2));
- typename paf::half_edge he1(l1, h1), he2(l2, h2);
- typename paf::compute_intersection_pack pack;
- if (pack.compute_intersection(pt, he1, he2, projected, round_closest)) {
- assign(intersection, pt);
- return true;
- }
- return false;
- }
-
 template <class T>
 template <class Segment>
 segment_data<T>& segment_data<T>::operator=(const Segment& rvalue) {

Modified: sandbox/gtl/doc/gtl_segment_concept.htm
==============================================================================
--- sandbox/gtl/doc/gtl_segment_concept.htm (original)
+++ sandbox/gtl/doc/gtl_segment_concept.htm 2012-05-01 07:34:07 EDT (Tue, 01 May 2012)
@@ -1,5 +1,6 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:(null)1="http://www.w3.org/TR/REC-html40" lang="en"><head><title>Boost Polygon Library: Segment Concept</title>
@@ -9,6 +10,8 @@

+
+



@@ -88,7 +91,7 @@
 <h1>Segment Concept</h1>
 
 The segment concept tag is segment_concept
- To register a user defined type as a model of segment
+ To register a user defined type as a model of the segment
concept, specialize the geometry concept meta-function for that
type.  In the example below CSegment is registered as a model of
the segment concept.
@@ -96,10 +99,9 @@
struct geometry_concept<CSegment>
{ typedef segment_concept type; };
 The semantic of a segment is
-that it has an low and high point.  A
-std::pair<std::pair<int, int>, std::pair<int,int>>,
-boost::tuple<boost::tuple<int, int>, boost::tuple<int,
-int>> or boost::array<int, 4> could all be made models of
+that it has a low and high point.  A
+std::pair<Point, Point>,
+boost::tuple<Point, Point> or boost::array<Point, 2> could all be made models of
segment by simply providing indirect access to their elements through
traits, however, these objects cannot be made a model of both segment
and interval in the same compilation unit, for obvious reason that
@@ -107,9 +109,10 @@
also because it would make overloading generic function by concept
ambiguous if a type modeled more than one concept.
 Below is shown the default
-segment traits.  Specialization of these traits is required for
+segment traits. Specialization of these traits is required for
types that don't conform to the default behavior.

+
 template <typename Segment> 
 struct segment_traits { 
   typedef typename Segment::coordinate_type coordinate_type; 
@@ -120,8 +123,8 @@
   } 
 }; 
 template <typename Segment> 
-struct segment_mutable_traits {
-   typedef typename segment_traits<Segment>::point_type point_type; 
+struct segment_mutable_traits { 
+  typedef typename segment_traits<Segment>::point_type point_type; 
 
  static inline void set(Segment& segment, direction_1d dir, const point_type& point) { 
    segment.set(dir, p); 
@@ -151,24 +154,24 @@
void set(Segment& segment, direction_1d dir, 
         const Point& point)</td>
 <td>Sets the low or high endpoint of an object that models a segment to an object that models a
-point, depending on the direction_1d  value.</td>
+point, depending on the direction_1d value.</td>
 </tr>
 <tr>
 <td width="586">template <typename Segment, typename Point1, typename Point2> 
Segment construct(const Point1& low, const Point2& high)</td>
- <td>Construct an object that is a model of segment given the two objects that are models of point.</td>
+ <td>Constructs an object that is a model of segment given the two objects that are models of point.</td>
 </tr>
 <tr>
- <td style="vertical-align: top;">template <typename Segment1, typename Segment2> Segment1 copy_construct(const Segment2& segment)</td>
- <td style="vertical-align: middle; text-align: left;">Copy construct an object that is a model of segment given another segment.</td>
+ <td>template <typename Segment1, typename Segment2> Segment1 copy_construct(const Segment2& segment)</td>
+ <td style="text-align: left;">Copy constructs an object that is a model of segment given another segment.</td>
 </tr>
<tr>
 <td width="586">template
<typename Segment1, typename Segment2> 
 Segment1& assign(Segment1& segment1, 
                 const Segment2& segment2)</td>
- <td>Copies data from the right object that models segment into
-the left object that models segment.</td>
+ <td>Copies data from the second object that models a segment into
+the first object that models a segment.</td>
 </tr>
 <tr>
 <td width="586">template
@@ -176,20 +179,21 @@
bool equivalence(const Segment1& segment1, 
                 const Segment1& segment2)</td>
 <td>Given two objects that model a segment, compares and
-returns true if their low and high values are respectively equal to each
-other.</td>
+returns true if their low and high values are respectively equal.</td>
 </tr>
 <tr>
- <td style="vertical-align: top;">template <typename Segment, typename Point> 
- bool on_above_or_below(const Segment& segment, 
-                       
+ <td>template <typename Segment, typename Point> 
+ int on_above_or_below(const Segment& segment, 
+                      
const Point& point) 
 </td>
- <td>Returns false if an object that is a model of segment and an object that is a model of point are collinear, else true. 
+ <td>Returns 0 if an object that is a model of segment and an object that is a model of point are collinear. 
+Returns 1 if the point object lies to the left of the segment object. 
+Returns -1 if the point object lies to the right of the segment object. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top;">template <typename Segment, typename Point> 
+ <td>template <typename Segment, typename Point> 
 bool contains(const Segment& segment, 
     const Point& value, bool consider_touch) 
 </td>
@@ -197,46 +201,46 @@
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top;">template <typename Segment1, typename Segment2> 
+ <td>template <typename Segment1, typename Segment2> 

 bool contains(const Segment1& segment1, 

     const Segment2& segment2, bool consider_touch)</td>
- <td>Returns true if the first of the objects contains the second one, else false. Both objects represent a model of segment. 
+ <td>Returns true if the first object contains the second one, else false. Both objects model a segment. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment> 
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment> 
point_type low(const Segment& segment) 
 </td>
 <td>Returns the low endpoint of an object that is a model of segment. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment> 
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment> 
point_type high(const Segment& segment)</td>
 <td>Returns the high endpoint of an object that is a model of segment. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment> 
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment> 
point_type center(const Segment& segment)</td>
 <td>Returns the central point of an object that is a model of segment. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment, typename Point> void low(Segment& segment, const Point& point)</td>
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment, typename Point> void low(Segment& segment, const Point& point)</td>
 <td>Sets the low endpoint of an object that is a model of segment. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment, typename Point> 
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment, typename Point> 
void high(Segment& segment, const Point& point)</td>
 <td>Sets the high endpoint of an object that is a model of segment. 
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top;">template <typename Segment> 
+ <td>template <typename Segment> 
 distance_type length(const Segment& segment) 
 </td>
 <td>Returns length of an object that is a model of segment. 
@@ -278,7 +282,7 @@
<typename Segment> 
 Segment& move(Segment& segment, orientation_2d 
    coordinate_difference displacement)</td>
- <td>Adds displacement value to the coordinates of both endpoints of an object
+ <td>Adds displacement value to the x or y coordinates of both endpoints of an object
that is a model of segment indicated by the orientation_2d.</td>
 </tr>
 <tr>
@@ -295,61 +299,63 @@
 <td>Deconvolves both endpoints of an object that models a segment with an object that models a point. </td>
 </tr>
 <tr>
- <td width="586">template
-<typename Segment, typename Point> distance_type euclidean_distance( 
-    const Segment& segment, const Point& point)</td>
- <td>Returns distance from an object that is a model of segment
-to an object that is a model of point.</td>
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment1, typename Segment2> 
+
+
+bool abuts(const Segment1& segment1, 
+
+
+    const Segment2& segment2, direction_1d dir)</td>
+ <td>Returns true if two objects that model a segment abut, depending on the direction_1d value.</td>
 </tr>
 <tr>
- <td style="vertical-align: top;">template
-<typename Segment1, typename Segment2> distance_type euclidean_distance( 
-    const Segment1& segment1, const Segment2& segment2)</td>
- <td style="vertical-align: middle;">Returns distance between two objects that are models of segment.</td>
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Segment1, typename Segment2> 
+
+bool abuts(const Segment1& segment1, 
+
+           const Segment2& segment2)</td>
+ <td>Returns true if two objects that model a segment abut: either the first one to the second one or vice versa.</td>
 </tr>
+
+
 <tr>
- <td style="vertical-align: top;">template <typename Segment1, typename Segment2> 
+ <td>template <typename Segment1, typename Segment2> 
 bool intersects(const Segment1& segment1, 
-                 const Segment2& segment2) 
+                 const Segment2& segment2, 
+                bool consider_touch) 
 </td>
 <td>Returns true if two objects that model a segment intersect, else false. 
 </td>
 </tr>
+
 <tr>
- <td style="vertical-align: top;">template <typename Segment1, typename Segment2> 
+ <td style="font-family: Courier New,Courier,monospace;">template <typename Point, typename Segment1, typename Segment2> 

- bool boundaries_intersect( 
-    const Segment1& segment1, const Segment2& segment2)
- </td>
- <td>Returns true if two objects that model a segment are collinear and overlap, else false. 
- </td>
- </tr>
- <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment1, typename Segment2> 
+bool intersection(Point& point, 

-bool abuts(const Segment1& segment1, 
+    const Segment1& segment1, const Segment2& segment2, 

-    const Segment2& segment2, direction_1d dir)</td>
- <td>Returns true if two objects that model a segment abut, depending on the direction_1d value. 
+    bool projected = false, bool round_closest = false)</td>
+ <td>Returns
+true and computes the intersection point of the two objects that model
+a segment in case those intersect, else returns false.
 </td>
 </tr>
<tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Segment1, typename Segment2> 
-bool abuts(const Segment1& segment1, 
-           const Segment2& segment2) 
+ <td style="font-family: Courier New,Courier,monospace;">template
+<typename Segment, typename Point> distance_type euclidean_distance( 
+    const Segment& segment, const Point& point)
 </td>
- <td>Returns true if two objects that model a segment abut: either the first one to the second one or vice versa. 
+ <td>Returns distance from an object that is a model of segment
+to an object that is a model of point.
 </td>
 </tr>
 <tr>
- <td style="vertical-align: top; font-family: Courier New,Courier,monospace;">template <typename Point, typename Segment1, typename Segment2> 
-bool intersection(Point& point, 
-    const Segment1& segment1, const Segment2& segment2, 
-    bool projected = false, bool round_closest = false) 
+ <td style="font-family: Courier New,Courier,monospace;">template
+<typename Segment1, typename Segment2> distance_type euclidean_distance( 
+    const Segment1& segment1, const Segment2& segment2)
 </td>
- <td>Returns
-true and computes the intersection point of the two objects that model
-a segment. If those don't intersect returns false. 
+ <td>Returns distance between two objects that are models of segment.
 </td>
 </tr>

@@ -367,9 +373,9 @@
library segment data type instead of providing their own.  The data
type is implemented to be convenient to use with the library traits.
 Example code segment_usage.cpp
-demonstrates using the library provided segment data type and functions
+demonstrates using the library provided segment data type and functions.
 <h2>Members</h2>
- <table id="table2" border="1" width="100%">
+ <table style="width: 100%;" id="table2" border="1">
 <tbody>
 <tr>
 <td width="586">geometry_type</td>
@@ -380,8 +386,8 @@
 <td>T</td>
 </tr>
 <tr>
- <td style="vertical-align: top;">point_type</td>
- <td style="vertical-align: top;">point_data<T> 
+ <td>point_type</td>
+ <td>point_data<T> 
 </td>
 </tr>
<tr>
@@ -417,27 +423,27 @@
 </tr>
 <tr>
 <td width="586"> bool operator<(const segment_data& that) const</td>
- <td>Less operator overload. Compares low endpoint then high endpoint to break ties. 
+ <td>Less operator overload. Compares low endpoints then high endpoints to break ties. 
</td>
 </tr>
 <tr>
 <td width="586"> bool operator<=(const segment_data& that) const</td>
- <td>Less or equal operator overload. Compares low endpoint then high endpoint to break ties. 
+ <td>Less or equal operator overload. Compares low endpoints then high endpoints to break ties. 
</td>
 </tr>
 <tr>
 <td width="586"> bool operator>(const segment_data& that) const</td>
- <td>Greater operator overload. Compares low endpoint then high endpoint to break ties. 
+ <td>Greater operator overload. Compares low endpoints then high endpoints to break ties. 
</td>
 </tr>
 <tr>
 <td width="586"> bool operator>=(const segment_data& that) const</td>
- <td>Greater or equal operator overload. Compares low endpoint then high endpoint to break ties. 
+ <td>Greater or equal operator overload. Compares low endpoints then high endpoints to break ties. 
</td>
 </tr>
 <tr>
 <td width="586">point_type get(direction_1d dir) const</td>
- <td>Retrieves the low/high endpoint considering direction.</td>
+ <td>Retrieves the low/high endpoint considering direction value.</td>
 </tr>
 <tr>
 <td width="586">point_type low() const</td>

Modified: sandbox/gtl/libs/polygon/test/polygon_segment_test.cpp
==============================================================================
--- sandbox/gtl/libs/polygon/test/polygon_segment_test.cpp (original)
+++ sandbox/gtl/libs/polygon/test/polygon_segment_test.cpp 2012-05-01 07:34:07 EDT (Tue, 01 May 2012)
@@ -47,7 +47,6 @@
 BOOST_CHECK(segment1 == segment2);
}

-
BOOST_AUTO_TEST_CASE_TEMPLATE(segment_traits_test, T, test_types) {
 typedef point_data<T> point_type ;
 typedef segment_data<T> segment_type;
@@ -294,6 +293,46 @@
 typedef point_data<T> point_type;
 typedef Segment<T> segment_type;

+ segment_type segment1 = construct<segment_type>(point_type(0, 0), point_type(1, 2));
+ segment_type segment2 = construct<segment_type>(point_type(1, 2), point_type(2, 4));
+ segment_type segment3 = construct<segment_type>(point_type(2, 4), point_type(0, 4));
+ segment_type segment4 = construct<segment_type>(point_type(0, 4), point_type(0, 0));
+
+ BOOST_CHECK(abuts(segment1, segment2, HIGH));
+ BOOST_CHECK(abuts(segment2, segment3, HIGH));
+ BOOST_CHECK(abuts(segment3, segment4, HIGH));
+ BOOST_CHECK(abuts(segment4, segment1, HIGH));
+
+ BOOST_CHECK(!abuts(segment1, segment2, LOW));
+ BOOST_CHECK(!abuts(segment2, segment3, LOW));
+ BOOST_CHECK(!abuts(segment3, segment4, LOW));
+ BOOST_CHECK(!abuts(segment4, segment1, LOW));
+
+ BOOST_CHECK(abuts(segment2, segment1));
+ BOOST_CHECK(abuts(segment3, segment2));
+ BOOST_CHECK(abuts(segment4, segment3));
+ BOOST_CHECK(abuts(segment1, segment4));
+
+ BOOST_CHECK(!abuts(segment1, segment3));
+ BOOST_CHECK(!abuts(segment2, segment4));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test8, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
+ point_type point;
+ segment_type segment1 = construct<segment_type>(point_type(0, 0), point_type(2, 2));
+ segment_type segment2 = construct<segment_type>(point_type(1, 1), point_type(3, 3));
+
+ BOOST_CHECK(!intersection(point, segment1, segment2));
+ BOOST_CHECK(intersects(segment1, segment2));
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test9, T, test_types) {
+ typedef point_data<T> point_type;
+ typedef Segment<T> segment_type;
+
 point_type point1(1, 2);
 point_type point2(7, 10);
 segment_type segment1 = construct<segment_type>(point1, point2);
@@ -306,7 +345,7 @@
 BOOST_CHECK(euclidean_distance(segment1, point_type(8, 3)) == 5.0);
}

-BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test8, T, test_types) {
+BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test10, T, test_types) {
 typedef point_data<T> point_type;
 typedef Segment<T> segment_type;

@@ -314,6 +353,8 @@
 segment_type segment2 = construct<segment_type>(point_type(2, 0), point_type(0, 2));
 segment_type segment3 = construct<segment_type>(point_type(1, -7), point_type(10, 5));
 segment_type segment4 = construct<segment_type>(point_type(7, 7), point_type(10, 11));
+ segment_type segment5 = construct<segment_type>(point_type(1, 1), point_type(-1, 3));
+ segment_type segment6 = construct<segment_type>(point_type(0, 0), point_type(1, 1));

 BOOST_CHECK(intersects(segment1, segment2, false));
 BOOST_CHECK(euclidean_distance(segment1, segment2) == 0.0);
@@ -321,16 +362,6 @@
 BOOST_CHECK(euclidean_distance(segment1, segment3) == 5.0);
 BOOST_CHECK(!intersects(segment1, segment4, true));
 BOOST_CHECK(euclidean_distance(segment1, segment4) == 5.0);
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test9, T, test_types) {
- typedef point_data<T> point_type;
- typedef Segment<T> segment_type;
-
-}
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(segment_concept_test10, T, test_types) {
- typedef point_data<T> point_type;
- typedef Segment<T> segment_type;
-
+ BOOST_CHECK(intersects(segment2, segment5, false));
+ BOOST_CHECK(intersects(segment2, segment6, false));
}

Date view	Thread view	Subject view	Author view