|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r67003 - sandbox/geometry/libs/geometry/example
From: barend.gehrels_at_[hidden]
Date: 2010-12-04 07:11:22
Author: barendgehrels
Date: 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
New Revision: 67003
URL: http://svn.boost.org/trac/boost/changeset/67003
Log:
Samples now without cartesian2d headerfile
Text files modified:
sandbox/geometry/libs/geometry/example/01_point_example.cpp | 27 ++++++-----
sandbox/geometry/libs/geometry/example/02_linestring_example.cpp | 91 ++++++++++++++++++++-------------------
sandbox/geometry/libs/geometry/example/03_polygon_example.cpp | 47 ++++++++++---------
sandbox/geometry/libs/geometry/example/05_a_overlay_polygon_example.cpp | 17 ++++---
sandbox/geometry/libs/geometry/example/05_b_overlay_linestring_polygon_example.cpp | 12 ++--
sandbox/geometry/libs/geometry/example/06_a_transformation_example.cpp | 10 ++--
sandbox/geometry/libs/geometry/example/06_b_transformation_example.cpp | 19 ++++---
sandbox/geometry/libs/geometry/example/07_a_graph_route_example.cpp | 3
sandbox/geometry/libs/geometry/example/07_b_graph_route_example.cpp | 3
9 files changed, 119 insertions(+), 110 deletions(-)
Modified: sandbox/geometry/libs/geometry/example/01_point_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/01_point_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/01_point_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -13,19 +13,18 @@
#include <boost/geometry/geometry.hpp>
#include <boost/geometry/geometries/adapted/tuple_cartesian.hpp>
#include <boost/geometry/geometries/adapted/c_array_cartesian.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
int main()
{
using namespace boost::geometry;
- // GGL contains several point types:
- // 1: it's own generic type
+ // Boost.Geometry contains several point types:
+ // 1: its own generic type
model::point<double, 2, cs::cartesian> pt1;
- // 2: it's own type targetted to Cartesian (x,y) coordinates
- model::d2::point pt2;
+ // 2: its own type targetted to Cartesian (x,y) coordinates
+ model::d2::point_xy<double> pt2;
// 3: it supports Boost tuple's (by including the headerfile)
boost::tuple<double, double> pt3;
@@ -33,7 +32,11 @@
// 4: it supports normal arrays
double pt4[2];
- // 5: there are more variants, and you can create your own.
+ // 5: in the past there was a typedef. But users can do that themselves:
+ typedef model::d2::point_xy<double> point_2d;
+ point_2d pt5;
+
+ // 6: there are more variants, and you can create your own.
// (see therefore the custom_point example)
// All these types are handled the same way. We show here
@@ -53,16 +56,16 @@
// Several ways of construction and setting point values
// 1: default, empty constructor, causing no initialization at all
- model::d2::point p1;
+ model::d2::point_xy<double> p1;
// 2: as shown above, assign
- model::d2::point p2;
+ model::d2::point_xy<double> p2;
assign(p2, 1, 1);
// 3: using "set" function
// set uses the concepts behind, such that it can be applied for
// every point-type (like assign)
- model::d2::point p3;
+ model::d2::point_xy<double> p3;
set<0>(p3, 1);
set<1>(p3, 1);
// set<2>(p3, 1); //will result in compile-error
@@ -71,11 +74,11 @@
// 3: for any point type, and other geometry objects:
// there is the "make" object generator
// (this one requires to specify the point-type).
- model::d2::point p4 = make<model::d2::point>(1,1);
+ model::d2::point_xy<double> p4 = make<model::d2::point_xy<double>>(1,1);
- // 5: for the d2::point type only: constructor with two values
- model::d2::point p5(1,1);
+ // 5: for the d2::point_xy<...> type only: constructor with two values
+ model::d2::point_xy<double> p5(1,1);
// 6: for boost tuples you can of course use make_tuple
Modified: sandbox/geometry/libs/geometry/example/02_linestring_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/02_linestring_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/02_linestring_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -15,7 +15,6 @@
#include <vector>
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
// Optional includes to handle c-arrays as points, std::vectors as linestrings
#include <boost/geometry/geometries/adapted/c_array_cartesian.hpp>
#include <boost/geometry/geometries/adapted/std_as_linestring.hpp>
@@ -71,23 +70,26 @@
// Define a linestring, which is a vector of points, and add some points
// (we add them deliberately in different ways)
- model::d2::linestring ls;
+ typedef model::d2::point_xy<double> point_2d;
+ typedef model::linestring<point_2d> linestring_2d;
+ linestring_2d ls;
// points can be created using "make" and added to a linestring using the std:: "push_back"
- ls.push_back(make<model::d2::point>(1.1, 1.1));
+ ls.push_back(make<point_2d>(1.1, 1.1));
// points can also be assigned using "assign" and added to a linestring using "append"
- model::d2::point lp;
+ point_2d lp;
assign(lp, 2.5, 2.1);
append(ls, lp);
// Lines can be streamed using DSV (delimiter separated values)
- std::cout << boost::geometry::dsv(ls) << std::endl;
+ std::cout << dsv(ls) << std::endl;
// The bounding box of linestrings can be calculated
- model::d2::box b;
+ typedef model::box<point_2d> box_2d;
+ box_2d b;
envelope(ls, b);
- std::cout << boost::geometry::dsv(b) << std::endl;
+ std::cout << dsv(b) << std::endl;
// The length of the line can be calulated
std::cout << "length: " << length(ls) << std::endl;
@@ -102,44 +104,44 @@
std::cout << "number of points 3: " << num_points(ls) << std::endl;
// The distance from a point to a linestring can be calculated
- model::d2::point p(1.9, 1.2);
- std::cout << "distance of " << boost::geometry::dsv(p)
+ point_2d p(1.9, 1.2);
+ std::cout << "distance of " << dsv(p)
<< " to line: " << distance(p, ls) << std::endl;
// A linestring is a vector. However, some algorithms consider "segments",
// which are the line pieces between two points of a linestring.
- double d = distance(p, model::segment<model::d2::point >(ls.front(), ls.back()));
+ double d = distance(p, model::segment<point_2d >(ls.front(), ls.back()));
std::cout << "distance: " << d << std::endl;
// Add some three points more, let's do it using a classic array.
// (See documentation for picture of this linestring)
const double c[][2] = { {3.1, 3.1}, {4.9, 1.1}, {3.1, 1.9} };
append(ls, c);
- std::cout << "appended: " << boost::geometry::dsv(ls) << std::endl;
+ std::cout << "appended: " << dsv(ls) << std::endl;
// Output as iterator-pair on a vector
{
- std::vector<model::d2::point> v;
+ std::vector<point_2d> v;
std::copy(ls.begin(), ls.end(), std::back_inserter(v));
std::cout
<< "as vector: "
- << boost::geometry::dsv(v)
+ << dsv(v)
<< std::endl;
std::cout
<< "as it-pair: "
- << boost::geometry::dsv(std::make_pair(v.begin(), v.end()))
+ << dsv(std::make_pair(v.begin(), v.end()))
<< std::endl;
}
// All algorithms from std can be used: a linestring is a vector
std::reverse(ls.begin(), ls.end());
- std::cout << "reversed: " << boost::geometry::dsv(ls) << std::endl;
+ std::cout << "reversed: " << dsv(ls) << std::endl;
std::reverse(boost::begin(ls), boost::end(ls));
// The other way, using a vector instead of a linestring, is also possible
- std::vector<model::d2::point> pv(ls.begin(), ls.end());
+ std::vector<point_2d> pv(ls.begin(), ls.end());
std::cout << "length: " << length(pv) << std::endl;
// If there are double points in the line, you can use unique to remove them
@@ -148,24 +150,24 @@
// (sidenote, we have to make copies, because
// ls.push_back(ls.back()) often succeeds but
// IS dangerous and erroneous!
- model::d2::point last = ls.back(), first = ls.front();
+ point_2d last = ls.back(), first = ls.front();
ls.push_back(last);
ls.insert(ls.begin(), first);
}
- std::cout << "extra duplicate points: " << boost::geometry::dsv(ls) << std::endl;
+ std::cout << "extra duplicate points: " << dsv(ls) << std::endl;
{
- model::d2::linestring ls_copy;
+ linestring_2d ls_copy;
std::unique_copy(ls.begin(), ls.end(), std::back_inserter(ls_copy),
- boost::geometry::equal_to<model::d2::point>());
+ boost::geometry::equal_to<point_2d>());
ls = ls_copy;
- std::cout << "uniquecopy: " << boost::geometry::dsv(ls) << std::endl;
+ std::cout << "uniquecopy: " << dsv(ls) << std::endl;
}
// Lines can be simplified. This removes points, but preserves the shape
- model::d2::linestring ls_simplified;
+ linestring_2d ls_simplified;
simplify(ls, ls_simplified, 0.5);
- std::cout << "simplified: " << boost::geometry::dsv(ls_simplified) << std::endl;
+ std::cout << "simplified: " << dsv(ls_simplified) << std::endl;
// for_each:
@@ -175,51 +177,50 @@
// 4) loop is defined for geometries to visit segments
// with state apart, and to be able to break out (not shown here)
{
- model::d2::linestring lscopy = ls;
- std::for_each(lscopy.begin(), lscopy.end(), translate_function<model::d2::point>);
- for_each_point(lscopy, scale_functor<model::d2::point>());
- for_each_point(lscopy, translate_function<model::d2::point>);
- std::cout << "modified line: " << boost::geometry::dsv(lscopy) << std::endl;
+ linestring_2d lscopy = ls;
+ std::for_each(lscopy.begin(), lscopy.end(), translate_function<point_2d>);
+ for_each_point(lscopy, scale_functor<point_2d>());
+ for_each_point(lscopy, translate_function<point_2d>);
+ std::cout << "modified line: " << dsv(lscopy) << std::endl;
}
// Lines can be clipped using a clipping box. Clipped lines are added to the output iterator
- model::d2::box cb(model::d2::point(1.5, 1.5), model::d2::point(4.5, 2.5));
+ box_2d cb(point_2d(1.5, 1.5), point_2d(4.5, 2.5));
- std::vector<model::d2::linestring> clipped;
- intersection_inserter<model::d2::linestring> (cb, ls, std::back_inserter(clipped));
+ std::vector<linestring_2d> clipped;
+ intersection_inserter<linestring_2d> (cb, ls, std::back_inserter(clipped));
// Also possible: clip-output to a vector of vectors
- std::vector<std::vector<model::d2::point> > vector_out;
- intersection_inserter<std::vector<model::d2::point> >(cb, ls, std::back_inserter(vector_out));
+ std::vector<std::vector<point_2d> > vector_out;
+ intersection_inserter<std::vector<point_2d> >(cb, ls, std::back_inserter(vector_out));
std::cout << "clipped output as vector:" << std::endl;
- for (std::vector<std::vector<model::d2::point> >::const_iterator it
+ for (std::vector<std::vector<point_2d> >::const_iterator it
= vector_out.begin(); it != vector_out.end(); ++it)
{
- std::cout << boost::geometry::dsv(*it) << std::endl;
+ std::cout << dsv(*it) << std::endl;
}
// Calculate the convex hull of the linestring
- model::d2::polygon hull;
+ model::polygon<point_2d> hull;
convex_hull(ls, hull);
- std::cout << "Convex hull:" << boost::geometry::dsv(hull) << std::endl;
+ std::cout << "Convex hull:" << dsv(hull) << std::endl;
// All the above assumed 2D Cartesian linestrings. 3D is possible as well
// Let's define a 3D point ourselves, this time using 'float'
- typedef model::point<float, 3, cs::cartesian> point_type;
- typedef model::linestring<point_type> line_type;
- line_type line3d;
- line3d.push_back(make<point_type>(1,2,3));
- line3d.push_back(make<point_type>(4,5,6));
- line3d.push_back(make<point_type>(7,8,9));
+ typedef model::point<float, 3, cs::cartesian> point_3d;
+ model::linestring<point_3d> line3;
+ line3.push_back(make<point_3d>(1,2,3));
+ line3.push_back(make<point_3d>(4,5,6));
+ line3.push_back(make<point_3d>(7,8,9));
// Not all algorithms work on 3d lines. For example convex hull does NOT.
// But, for example, length, distance, simplify, envelope and stream do.
- std::cout << "3D: length: " << length(line3d) << " line: " << boost::geometry::dsv(line3d) << std::endl;
+ std::cout << "3D: length: " << length(line3) << " line: " << dsv(line3) << std::endl;
// With DSV you can also use other delimiters, e.g. JSON style
std::cout << "JSON: "
- << boost::geometry::dsv(ls, ", ", "[", "]", ", ", "[ ", " ]")
+ << dsv(ls, ", ", "[", "]", ", ", "[ ", " ]")
<< std::endl;
return 0;
Modified: sandbox/geometry/libs/geometry/example/03_polygon_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/03_polygon_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/03_polygon_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -13,7 +13,6 @@
#include <string>
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
#include <boost/geometry/geometries/adapted/c_array_cartesian.hpp>
#include <boost/geometry/geometries/adapted/std_as_linestring.hpp>
#include <boost/geometry/multi/multi.hpp>
@@ -27,9 +26,13 @@
{
using namespace boost::geometry;
+ typedef model::d2::point_xy<double> point_2d;
+ typedef model::polygon<point_2d> polygon_2d;
+ typedef model::box<point_2d> box_2d;
+
// Define a polygon and fill the outer ring.
// In most cases you will read it from a file or database
- model::d2::polygon poly;
+ polygon_2d poly;
{
const double coor[][2] = {
{2.0, 1.3}, {2.4, 1.7}, {2.8, 1.8}, {3.4, 1.2}, {3.7, 1.6},
@@ -48,7 +51,7 @@
std::cout << dsv(poly) << std::endl;
// As with lines, bounding box of polygons can be calculated
- model::d2::box b;
+ box_2d b;
envelope(poly, b);
std::cout << dsv(b) << std::endl;
@@ -56,7 +59,7 @@
std::cout << "area: " << area(poly) << std::endl;
// And the centroid, which is the center of gravity
- model::d2::point cent;
+ point_2d cent;
centroid(poly, cent);
std::cout << "centroid: " << dsv(cent) << std::endl;
@@ -65,11 +68,11 @@
// or per polygon (using num_points)
std::cout << "number of points in outer ring: " << poly.outer().size() << std::endl;
- // Polygons can have one or more inner rings, also called holes, donuts, islands, interior rings.
+ // Polygons can have one or more inner rings, also called holes, islands, interior rings.
// Let's add one
{
poly.inners().resize(1);
- model::linear_ring<model::d2::point>& inner = poly.inners().back();
+ model::linear_ring<point_2d>& inner = poly.inners().back();
const double coor[][2] = { {4.0, 2.0}, {4.2, 1.4}, {4.8, 1.9}, {4.4, 2.2}, {4.0, 2.0} };
assign(inner, coor);
@@ -85,18 +88,18 @@
// You can test whether points are within a polygon
std::cout << "point in polygon:"
- << " p1: " << boolstr(within(make<model::d2::point>(3.0, 2.0), poly))
- << " p2: " << boolstr(within(make<model::d2::point>(3.7, 2.0), poly))
- << " p3: " << boolstr(within(make<model::d2::point>(4.4, 2.0), poly))
+ << " p1: " << boolstr(within(make<point_2d>(3.0, 2.0), poly))
+ << " p2: " << boolstr(within(make<point_2d>(3.7, 2.0), poly))
+ << " p3: " << boolstr(within(make<point_2d>(4.4, 2.0), poly))
<< std::endl;
// As with linestrings and points, you can derive from polygon to add, for example,
// fill color and stroke color. Or SRID (spatial reference ID). Or Z-value. Or a property map.
// We don't show this here.
- // Clip the polygon using a bounding box
- model::d2::box cb(make<model::d2::point>(1.5, 1.5), make<model::d2::point>(4.5, 2.5));
- typedef std::vector<model::d2::polygon> polygon_list;
+ // Clip the polygon using a box
+ box_2d cb(make<point_2d>(1.5, 1.5), make<point_2d>(4.5, 2.5));
+ typedef std::vector<polygon_2d> polygon_list;
polygon_list v;
intersection(cb, poly, v);
@@ -106,11 +109,11 @@
std::cout << dsv(*it) << std::endl;
}
- typedef model::multi_polygon<model::d2::polygon> polygon_set;
+ typedef model::multi_polygon<polygon_2d> polygon_set;
polygon_set ps;
union_(cb, poly, ps);
- model::d2::polygon hull;
+ polygon_2d hull;
convex_hull(poly, hull);
std::cout << "Convex hull:" << dsv(hull) << std::endl;
@@ -118,14 +121,14 @@
// You don't have to use a vector, you can define a polygon with a deque
// You can specify the container for the points and for the inner rings independantly
- typedef model::polygon<model::d2::point, true, true, std::deque, std::deque> polygon_type;
- polygon_type poly2;
- ring_type<polygon_type>::type& ring = exterior_ring(poly2);
- append(ring, make<model::d2::point>(2.8, 1.9));
- append(ring, make<model::d2::point>(2.9, 2.4));
- append(ring, make<model::d2::point>(3.3, 2.2));
- append(ring, make<model::d2::point>(3.2, 1.8));
- append(ring, make<model::d2::point>(2.8, 1.9));
+ typedef model::polygon<point_2d, true, true, std::deque, std::deque> deque_polygon;
+ deque_polygon poly2;
+ ring_type<deque_polygon>::type& ring = exterior_ring(poly2);
+ append(ring, make<point_2d>(2.8, 1.9));
+ append(ring, make<point_2d>(2.9, 2.4));
+ append(ring, make<point_2d>(3.3, 2.2));
+ append(ring, make<point_2d>(3.2, 1.8));
+ append(ring, make<point_2d>(2.8, 1.9));
std::cout << dsv(poly2) << std::endl;
return 0;
Modified: sandbox/geometry/libs/geometry/example/05_a_overlay_polygon_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/05_a_overlay_polygon_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/05_a_overlay_polygon_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -16,7 +16,6 @@
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
#include <boost/geometry/geometries/adapted/c_array_cartesian.hpp>
#include <boost/geometry/extensions/io/svg/svg_mapper.hpp>
@@ -26,11 +25,15 @@
{
namespace bg = boost::geometry;
+ typedef bg::model::d2::point_xy<double> point_2d;
+ typedef bg::model::polygon<point_2d> polygon_2d;
+
+
std::ofstream stream("05_a_intersection_polygon_example.svg");
- bg::svg_mapper<bg::model::d2::point> svg(stream, 500, 500);
+ bg::svg_mapper<point_2d> svg(stream, 500, 500);
// Define a polygons and fill the outer rings.
- bg::model::d2::polygon a;
+ polygon_2d a;
{
const double c[][2] = {
{160, 330}, {60, 260}, {20, 150}, {60, 40}, {190, 20}, {270, 130}, {260, 250}, {160, 330}
@@ -41,7 +44,7 @@
std::cout << "A: " << bg::dsv(a) << std::endl;
svg.add(a);
- bg::model::d2::polygon b;
+ polygon_2d b;
{
const double c[][2] = {
{300, 330}, {190, 270}, {150, 170}, {150, 110}, {250, 30}, {380, 50}, {380, 250}, {300, 330}
@@ -57,11 +60,11 @@
// Calculate interesection(s)
- std::vector<bg::model::d2::polygon > intersection;
- bg::intersection<bg::model::d2::polygon>(a, b, intersection);
+ std::vector<polygon_2d> intersection;
+ bg::intersection(a, b, intersection);
std::cout << "Intersection of polygons A and B" << std::endl;
- BOOST_FOREACH(bg::model::d2::polygon const& polygon, intersection)
+ BOOST_FOREACH(polygon_2d const& polygon, intersection)
{
std::cout << bg::dsv(polygon) << std::endl;
svg.map(polygon, "opacity:0.5;fill:none;stroke:rgb(255,0,0);stroke-width:6");
Modified: sandbox/geometry/libs/geometry/example/05_b_overlay_linestring_polygon_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/05_b_overlay_linestring_polygon_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/05_b_overlay_linestring_polygon_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -16,7 +16,6 @@
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
#include <boost/geometry/geometries/adapted/c_array_cartesian.hpp>
#include <boost/geometry/extensions/io/svg/svg_mapper.hpp>
@@ -26,14 +25,15 @@
{
namespace bg = boost::geometry;
- // Define a polygons and fill the outer rings.
- bg::model::d2::linestring ls;
+ typedef bg::model::d2::point_xy<double> point_2d;
+
+ bg::model::linestring<point_2d> ls;
{
const double c[][2] = { {0, 1}, {2, 5}, {5, 3} };
bg::assign(ls, c);
}
- bg::model::d2::polygon p;
+ bg::model::polygon<point_2d> p;
{
const double c[][2] = { {3, 0}, {0, 3}, {4, 5}, {3, 0} };
bg::assign(p, c);
@@ -42,7 +42,7 @@
// Create SVG-mapper
std::ofstream stream("05_b_overlay_linestring_polygon_example.svg");
- bg::svg_mapper<bg::model::d2::point> svg(stream, 500, 500);
+ bg::svg_mapper<point_2d> svg(stream, 500, 500);
// Determine extend by adding geometries
svg.add(p);
svg.add(ls);
@@ -52,7 +52,7 @@
// Calculate intersection points (turn points)
- typedef bg::detail::overlay::turn_info<bg::model::d2::point> turn_info;
+ typedef bg::detail::overlay::turn_info<point_2d> turn_info;
std::vector<turn_info> turns;
bg::detail::get_turns::no_interrupt_policy policy;
bg::get_turns<bg::detail::overlay::assign_null_policy>(ls, p, turns, policy);
Modified: sandbox/geometry/libs/geometry/example/06_a_transformation_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/06_a_transformation_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/06_a_transformation_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -11,7 +11,6 @@
#include <iostream>
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
#include <boost/geometry/geometries/adapted/c_array_cartesian.hpp>
#include <boost/geometry/geometries/adapted/std_as_linestring.hpp>
@@ -19,17 +18,18 @@
{
using namespace boost::geometry;
- model::d2::point p(1, 1);
- model::d2::point p2;
+ typedef model::d2::point_xy<double> point_2d;
+ point_2d p(1, 1);
+ point_2d p2;
// Example: translate a point over (5,5)
- strategy::transform::translate_transformer<model::d2::point, model::d2::point> translate(5, 5);
+ strategy::transform::translate_transformer<point_2d, point_2d> translate(5, 5);
transform(p, p2, translate);
std::cout << "transformed point " << boost::geometry::dsv(p2) << std::endl;
// Transform a polygon
- model::d2::polygon poly, poly2;
+ model::polygon<point_2d> poly, poly2;
const double coor[][2] = { {0, 0}, {0, 7}, {2, 2}, {2, 0}, {0, 0} };
// note that for this syntax you have to include the two
// include files above (c_array_cartesian.hpp, std_as_linestring.hpp)
Modified: sandbox/geometry/libs/geometry/example/06_b_transformation_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/06_b_transformation_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/06_b_transformation_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -16,7 +16,6 @@
#include <sstream>
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
#include <boost/geometry/algorithms/centroid.hpp>
#include <boost/geometry/strategies/transform.hpp>
#include <boost/geometry/strategies/transform/matrix_transformers.hpp>
@@ -106,6 +105,8 @@
{
using namespace boost::geometry::strategy::transform;
+ typedef boost::geometry::model::d2::point_xy<double> point_2d;
+
try
{
std::string file("06_b_transformation_example.svg");
@@ -113,36 +114,36 @@
svg_output<std::ofstream> svg(ofs, 0.5);
// G1 - create subject for affine transformations
- model::d2::polygon g1;
+ model::polygon<point_2d> g1;
read_wkt("POLYGON((50 250, 400 250, 150 50, 50 250))", g1);
std::clog << "source box:\t" << boost::geometry::dsv(g1) << std::endl;
svg.put(g1, "g1");
// G1 - Translate -> G2
- translate_transformer<model::d2::point, model::d2::point> translate(0, 250);
- model::d2::polygon g2;
+ translate_transformer<point_2d, point_2d> translate(0, 250);
+ model::polygon<point_2d> g2;
transform(g1, g2, translate);
std::clog << "translated:\t" << boost::geometry::dsv(g2) << std::endl;
svg.put(g2, "g2=g1.translate(0,250)");
// G2 - Scale -> G3
- scale_transformer<model::d2::point, model::d2::point> scale(0.5, 0.5);
- model::d2::polygon g3;
+ scale_transformer<point_2d, point_2d> scale(0.5, 0.5);
+ model::polygon<point_2d> g3;
transform(g2, g3, scale);
std::clog << "scaled:\t" << boost::geometry::dsv(g3) << std::endl;
svg.put(g3, "g3=g2.scale(0.5,0.5)");
// G3 - Combine rotate and translate -> G4
- rotate_transformer<model::d2::point, model::d2::point, degree> rotate(45);
+ rotate_transformer<point_2d, point_2d, degree> rotate(45);
// Compose matrix for the two transformation
// Create transformer attached to the transformation matrix
- ublas_transformer<model::d2::point, model::d2::point, 2, 2>
+ ublas_transformer<point_2d, point_2d, 2, 2>
combined(boost::numeric::ublas::prod(rotate.matrix(), translate.matrix()));
//combined(rotate.matrix());
// Apply transformation to subject geometry point-by-point
- model::d2::polygon g4;
+ model::polygon<point_2d> g4;
transform(g3, g4, combined);
std::clog << "rotated & translated:\t" << boost::geometry::dsv(g4) << std::endl;
Modified: sandbox/geometry/libs/geometry/example/07_a_graph_route_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/07_a_graph_route_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/07_a_graph_route_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -22,7 +22,6 @@
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
// Yes, this example currently uses some extensions:
@@ -281,7 +280,7 @@
// Init a bounding box, lateron used to define SVG map
- boost::geometry::model::d2::box box;
+ boost::geometry::model::box<point_type> box;
boost::geometry::assign_inverse(box);
// Read the cities
Modified: sandbox/geometry/libs/geometry/example/07_b_graph_route_example.cpp
==============================================================================
--- sandbox/geometry/libs/geometry/example/07_b_graph_route_example.cpp (original)
+++ sandbox/geometry/libs/geometry/example/07_b_graph_route_example.cpp 2010-12-04 07:11:17 EST (Sat, 04 Dec 2010)
@@ -26,7 +26,6 @@
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/geometry/geometry.hpp>
-#include <boost/geometry/geometries/cartesian2d.hpp>
// Yes, this example currently uses some extensions:
@@ -269,7 +268,7 @@
// Init a bounding box, lateron used to define SVG map
- boost::geometry::model::d2::box box;
+ boost::geometry::model::box<point_type> box;
boost::geometry::assign_inverse(box);
graph_type graph;
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