Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r56786 - in sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output: . html
From: barend.gehrels_at_[hidden]
Date: 2009-10-13 12:09:48

Author: barendgehrels
Date: 2009-10-13 12:09:45 EDT (Tue, 13 Oct 2009)
New Revision: 56786
URL: http://svn.boost.org/trac/boost/changeset/56786

Log:
Added doc and example folders
Some doc changes in sources plus some moves to extension
Added:
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/01__point__example_8cpp-example.html (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/02__linestring__example_8cpp-example.html (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/03__polygon__example_8cpp-example.html (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/06__transformation__example_8cpp-example.html (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07__graph__route__example_8cpp-example.html (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07_graph_route_example_svg.png (contents, props changed)
   sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07_graph_route_example_text.png (contents, props changed)

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/01__point__example_8cpp-example.html
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/01__point__example_8cpp-example.html 2009-10-13 12:09:45 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,144 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Generic Geometry Library</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+<body style="background-image: url(images/draft.png);">
+
+<table cellpadding="2" width="100%">
+<tbody>
+<tr>
+<td valign="top">
+<img alt="GGL" src="images/ggl-logo-big.png" height="80" width="200">
+  
+</td>
+<td valign="top" align="right">
+<img alt="Boost C++ Libraries" src="images/proposed_boost.png" height="86" width="277">
+</td>
+</tr>
+</tbody>
+</table>
+
+<div class="navigation" id="top">
+ <div class="tabs">
+ <ul>
+ <li>Main Page</li>
+ <li>Related Pages</li>
+ <li>Modules</li>
+ <li>Namespaces</li>
+ <li>Classes</li>
+ <li>Files</li>
+ <li>Examples</li>
+ </ul>
+ </div>
+</div>
+<div class="contents">
+<h1>01_point_example.cpp</h1>In most cases the documentation gives small examples of how to use the algorithms or classes. The point example is a slightly larger example giving the an idea of how to use different algorithms from the library, related to points. It shows<ul>
+<li>the usage of include files</li><li>how to declare points, using different coordinate types</li><li>how to construct points, specifying coordinates, initializing to zero or to infinite</li><li>how to compare points to each other</li><li>how points can be streamed as OGC text</li><li>calculating the distance from point to point</li></ul>
+
+<div class="fragment"><pre class="fragment">// Generic Geometry Library
+//
+// Copyright Barend Gehrels 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Point Example - showing Cartesian points
+
+#include <iostream>
+
+#include <ggl/ggl.hpp>
+#include <<a class="code" href="cartesian2d_8hpp.html">ggl/geometries/cartesian2d.hpp</a>>
+
+
+int main()
+{
+ using namespace ggl;
+
+ <a name="_a0"></a><a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> world(1, 2);
+ std::cout << "Hello (" << world.<a name="a1"></a><a class="code" href="classggl_1_1point__xy.html#a7803d55e0758a659d618583b757b272" title="Get x-value.">x</a>() << "," << world.<a name="a2"></a><a class="code" href="classggl_1_1point__xy.html#a83e59f4d401b1a4c6f037979c57260f" title="Get y-value.">y</a>() << ")" << std::endl;
+ std::cout << "Hello " << <a name="a3"></a><a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">dsv</a>(world) << std::endl;
+
+ // Construct two points using constructor with two values
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> a(1, 2);
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> b(5, 6);
+
+ // The distance between them can be calculated
+ std::cout << "distance a-b is " << <a name="a4"></a><a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">distance</a>(a,b) << std::endl;
+
+ // Cartesian points have .x() and .y() for getting and setting coordinate values
+ a.<a class="code" href="classggl_1_1point__xy.html#a7803d55e0758a659d618583b757b272" title="Get x-value.">x</a>(3);
+ a.<a class="code" href="classggl_1_1point__xy.html#a83e59f4d401b1a4c6f037979c57260f" title="Get y-value.">y</a>(4);
+ b.<a class="code" href="classggl_1_1point__xy.html#a7803d55e0758a659d618583b757b272" title="Get x-value.">x</a>(7);
+ b.<a class="code" href="classggl_1_1point__xy.html#a83e59f4d401b1a4c6f037979c57260f" title="Get y-value.">y</a>(8);
+ std::cout << "a:" << world.<a class="code" href="classggl_1_1point__xy.html#a7803d55e0758a659d618583b757b272" title="Get x-value.">x</a>() << " " << world.<a class="code" href="classggl_1_1point__xy.html#a83e59f4d401b1a4c6f037979c57260f" title="Get y-value.">y</a>() << std::endl;
+ std::cout << "distance a-b is " << <a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">distance</a>(a,b) << std::endl;
+
+ // Several ways of construction:
+ // 1: default constructor, required for every point
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> c1;
+
+ // 2: for Cartesian points: constructor with two values
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> c2(1,1);
+
+ // Until here, we assumed Cartesian points, having x,y coordinates. However, the Geometry Library
+ // uses a coordinate agnostic approach. This means that internally there is never referred
+ // to the name of coordinate axes. Points might also have more than 2 dimensions. Spherical
+ // points (which normally have theta/phi) and geographic points (which are referred to by
+ // latitude/longitude) are also possible.
+
+ // Below we do not show all kind of points, but we show the coordinate agnostic ways of
+ // constructing points, assigning values and retrieving values without .x/.y
+ // Developers using Cartesian points can of course still use .x() and .y(), which is more readable.
+
+ // 3: for any point, and other geometry objects: the "make" object generator
+ // (this one requires to specify the point-type). We say this is coordinate agnostic
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> c3 = make<point_2d>(1,1);
+
+ // 4: there is also an assign algorithm, in the same way as make, but not returning
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> c4;
+ <a name="a5"></a><a class="code" href="group__access.html#ge58b5c7b493d0112202dc139af200c73" title="assign two values to a 2D point">assign</a>(c4, 1, 1);
+
+ // 5: there is also a parse algorithm which takes strings (not so useful here, but
+ // convenient for geographic points using "32N", "18E" etc).
+ //point_2d c5 = parse<point_2d>("1", "1");
+
+ // The coordinate agnostic way of getting and setting
+ // without referring to .x() and .y()
+ set<0>(a, 2); // set first coordinate to 2
+ set<1>(a, 3); // set second coordinate to 3
+ std::cout << get<0>(a) << "," << get<1>(a) << std::endl;
+
+ // set<2>(a, 4); try to set third coordinate, this won't compile for a 2D point
+
+ // Other examples show other types of points, geometries and more algorithms
+
+ return 0;
+}
+</pre></div> </div>
+<hr size="1">
+<table width="100%">
+<tbody>
+<tr>
+<td align="left">
+October 13, 2009
+</td>
+<td align="right">
+Copyright © 1995-2009 Barend Gehrels, Geodan, Amsterdam 
+Copyright © 2008-2009 Bruno Lalande, Paris 
+Copyright © 2009 Mateusz Loskot, Cadcorp, London 
+
+</td>
+</tr>
+</tbody>
+</table>
+
+<address style="text-align: right;">
+Documentation is generated by Doxygen
+</address>
+</body>
+</html>

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/02__linestring__example_8cpp-example.html
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/02__linestring__example_8cpp-example.html 2009-10-13 12:09:45 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,277 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Generic Geometry Library</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+<body style="background-image: url(images/draft.png);">
+
+<table cellpadding="2" width="100%">
+<tbody>
+<tr>
+<td valign="top">
+<img alt="GGL" src="images/ggl-logo-big.png" height="80" width="200">
+  
+</td>
+<td valign="top" align="right">
+<img alt="Boost C++ Libraries" src="images/proposed_boost.png" height="86" width="277">
+</td>
+</tr>
+</tbody>
+</table>
+
+<div class="navigation" id="top">
+ <div class="tabs">
+ <ul>
+ <li>Main Page</li>
+ <li>Related Pages</li>
+ <li>Modules</li>
+ <li>Namespaces</li>
+ <li>Classes</li>
+ <li>Files</li>
+ <li>Examples</li>
+ </ul>
+ </div>
+</div>
+<div class="contents">
+<h1>02_linestring_example.cpp</h1>The linestring example shows how linestrings can be declared and used and shows some more algorithms. One of the important concepts of the Generic Geometry Library is that it is totally built upon the standard library, using the standard containers such as std::vector.
+A linestring is, as explained elsewhere in this documentation, not much more than a vector of points. Most algorithms run on linestrings, but can also run on any iterator pair. And all algorithms on std::vector can be used on geometry::linestring.
+The sample shows this, shows some algorithms:<ul>
+<li>geometry::envelope</li><li>geometry::length</li><li>geometry::distance</li><li>geometry::simplify</li><li>geometry::for_each</li><li>geometry::intersection</li></ul>
+
+This documentation illustrates the simplify algorithm and the intersection algorithm with some pictures.
+The simplify algorithm simplifies a linestring. Simplification means that the less important points are removed from the line and that the points that are most important for the shape of a line are kept. Simplification is done using the well known Douglas Peucker algorithm. The library user can specify the distance or tolerance, which indicates how much the linestring should be simplified.
+The image below shows the original and simplified linestring: <div align="center">
+<img src="simplify_linestring.png" alt="simplify_linestring.png">
+</div>
+ The blue line is the original linestring; the red line is the simplified line which has one point less. In geographical applications simplification can reduce a linestring to its basic form containing only 10% of its original points.
+The intersection algorithm intersects two geometries which each other, delivering a third geometry. In the case of the example a linestring is intersected with a box. Intersection with a box is often called a clip. The image below illustrates the intersection. <div align="center">
+<img src="clip_linestring.png" alt="clip_linestring.png">
+</div>
+ The yellow line is intersected with the blue box. The intersection result, painted in red, contains three linestrings.
+<div class="fragment"><pre class="fragment">// Generic Geometry Library
+//
+// Copyright Barend Gehrels 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Linestring Example
+
+#include <algorithm> // for reverse, unique
+#include <iostream>
+#include <iterator>
+#include <utility>
+#include <vector>
+
+#include <ggl/ggl.hpp>
+#include <<a class="code" href="cartesian2d_8hpp.html">ggl/geometries/cartesian2d.hpp</a>>
+// Optional includes to handle c-arrays as points, std::vectors as linestrings
+#include <<a class="code" href="c__array__cartesian_8hpp.html">ggl/geometries/adapted/c_array_cartesian.hpp</a>>
+#include <<a class="code" href="std__as__linestring_8hpp.html">ggl/geometries/adapted/std_as_linestring.hpp</a>>
+
+template <typename P>
+struct point_equal
+{
+ inline bool operator()(P const& left, P const& right) const
+ {
+ return <a name="a0"></a><a class="code" href="group__boolean__relations.html#g122b1fd835cee0742da7c97dfdda94c5" title="Calculate if two geometries are equals.">ggl::equals</a>(left, right);
+ }
+};
+
+
+template<typename P>
+inline void translate_function(P& p)
+{
+ p.x(p.x() + 100.0);
+}
+
+template<typename P>
+struct scale_functor
+{
+ inline void operator()(P& p)
+ {
+ p.x(p.x() * 1000.0);
+ p.y(p.y() * 1000.0);
+ }
+};
+
+int main(void)
+{
+ using namespace ggl;
+
+ // Define a linestring, which is a vector of points, and add some points
+ // (we add them deliberately in different ways)
+ <a name="_a1"></a><a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">linestring_2d</a> ls;
+
+ // points can be created using "make" and added to a linestring using the std:: "push_back"
+ ls.push_back(make<point_2d>(1.1, 1.1));
+
+ // points can also be assigned using "assign" and added to a linestring using "append"
+ <a name="_a2"></a><a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> lp;
+ <a name="a3"></a><a class="code" href="group__access.html#ge58b5c7b493d0112202dc139af200c73" title="assign two values to a 2D point">assign</a>(lp, 2.5, 2.1);
+ <a name="a4"></a><a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ls, lp);
+
+ // Lines can be streamed using DSV (delimiter separated values)
+ std::cout << <a name="a5"></a><a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(ls) << std::endl;
+
+ // The bounding box of linestrings can be calculated
+ <a name="_a6"></a><a class="code" href="classggl_1_1box.html" title="Class box: defines a box made of two describing points.">box_2d</a> b;
+ <a name="a7"></a><a class="code" href="group__envelope.html#g376bdcefa676ef2b705656b690767b36" title="Calculate envelope of a geometry, using a specified strategy.">envelope</a>(ls, b);
+ std::cout << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(b) << std::endl;
+
+ // The length of the line can be calulated
+ std::cout << "length: " << <a name="a8"></a><a class="code" href="group__length.html#g7e3572634111ae0252a474a7f435c5aa" title="Calculate length of a geometry.">length</a>(ls) << std::endl;
+
+ // All things from std::vector can be called, because a linestring is a vector
+ std::cout << "number of points 1: " << ls.size() << std::endl;
+
+ // All things from boost ranges can be called because a linestring is considered as a range
+ std::cout << "number of points 2: " << boost::size(ls) << std::endl;
+
+ // Generic function from geometry/OGC delivers the same value
+ std::cout << "number of points 3: " << <a name="a9"></a><a class="code" href="group__access.html#g8d58faff2722b073b44c24f19577e267" title="get number of points">num_points</a>(ls) << std::endl;
+
+ // The distance from a point to a linestring can be calculated
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> p(1.9, 1.2);
+ std::cout << "distance of " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(p)
+ << " to line: " << <a name="a10"></a><a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">distance</a>(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 = <a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">distance</a>(p, <a name="_a11"></a><a class="code" href="structggl_1_1segment.html" title="Class segment: small containing two (templatized) point references.">segment<point_2d ></a>(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} };
+ <a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ls, c);
+ std::cout << "appended: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(ls) << std::endl;
+
+ // Output as iterator-pair on a vector
+ {
+ std::vector<point_2d> v;
+ std::copy(ls.begin(), ls.end(), std::back_inserter(v));
+
+ std::cout
+ << "as vector: "
+ << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(v)
+ << std::endl;
+
+ std::cout
+ << "as it-pair: "
+ << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(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: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(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<point_2d> pv(ls.begin(), ls.end());
+ std::cout << "length: " << <a class="code" href="group__length.html#g7e3572634111ae0252a474a7f435c5aa" title="Calculate length of a geometry.">length</a>(pv) << std::endl;
+
+ // If there are double points in the line, you can use unique to remove them
+ // So we add the last point, print, make a unique copy and print
+ ls.push_back(ls.back());
+ ls.insert(ls.begin(), ls.front());
+ std::cout << "extra duplicate points: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(ls) << std::endl;
+
+ {
+ <a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">linestring_2d</a> ls_copy;
+ std::unique_copy(ls.begin(), ls.end(), std::back_inserter(ls_copy),
+ point_equal<point_2d>());
+ ls = ls_copy;
+ std::cout << "uniquecopy: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(ls) << std::endl;
+ }
+
+ // Lines can be simplified. This removes points, but preserves the shape
+ <a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">linestring_2d</a> ls_simplified;
+ <a name="a12"></a><a class="code" href="group__simplify.html#g188e72f668c33ac75ad08653625a7cbb" title="Simplify a geometry.">simplify</a>(ls, std::back_inserter(ls_simplified), 0.5);
+ std::cout << "simplified: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(ls_simplified) << std::endl;
+
+
+ // for_each:
+ // 1) Lines can be visited with std::for_each
+ // 2) for_each_point is also defined for all geometries
+ // 3) for_each_segment is defined for all geometries to all segments
+ // 4) loop is defined for geometries to visit segments
+ // with state apart, and to be able to break out (not shown here)
+ {
+ <a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">linestring_2d</a> lscopy = ls;
+ std::for_each(lscopy.begin(), lscopy.end(), translate_function<point_2d>);
+ <a name="a13"></a><a class="code" href="group__loop.html#g71cb52ab6490726f9030b464aa2f5e8a" title="Calls functor for geometry.">for_each_point</a>(lscopy, scale_functor<point_2d>());
+ <a class="code" href="group__loop.html#g71cb52ab6490726f9030b464aa2f5e8a" title="Calls functor for geometry.">for_each_point</a>(lscopy, translate_function<point_2d>);
+ std::cout << "modified line: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(lscopy) << std::endl;
+ }
+
+ // Lines can be clipped using a clipping box. Clipped lines are added to the output iterator
+ <a class="code" href="classggl_1_1box.html" title="Class box: defines a box made of two describing points.">box_2d</a> cb(<a name="a14"></a><a class="code" href="namespaceggl.html#440bc7037bbf1ba7118d6952d71b8e00">point_2d</a>(1.5, 1.5), <a class="code" href="namespaceggl.html#440bc7037bbf1ba7118d6952d71b8e00">point_2d</a>(4.5, 2.5));
+
+ std::vector<linestring_2d> clipped;
+ intersection<linestring_2d> (cb, ls, std::back_inserter(clipped));
+
+ // Also possible: clip-output to a vector of vectors
+ std::vector<std::vector<point_2d> > vector_out;
+ intersection<std::vector<point_2d> >(cb, ls, std::back_inserter(vector_out));
+
+ std::cout << "clipped output as vector:" << std::endl;
+ for (std::vector<std::vector<point_2d> >::const_iterator it
+ = vector_out.begin(); it != vector_out.end(); ++it)
+ {
+ std::cout << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(*it) << std::endl;
+ }
+
+ // Calculate the convex hull of the linestring
+ <a name="_a15"></a><a class="code" href="classggl_1_1polygon.html" title="The polygon contains an outer ring and zero or more inner rings.">polygon_2d</a> hull;
+ <a name="a16"></a><a class="code" href="group__convex__hull.html#gc1989428c0a32cd2fd48272cd6833e18" title="Calculate the convex hull of a geometry.">convex_hull</a>(ls, std::back_inserter(hull.<a name="a17"></a><a class="code" href="classggl_1_1polygon.html#be04d3ead04813a25be1a219076358a8">outer</a>()));
+ std::cout << "Convex hull:" << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(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 <a name="_a18"></a><a class="code" href="classggl_1_1point.html" title="Basic point class, having coordinates defined in a neutral way.">point<float, 3, cs::cartesian></a> <a name="_a19"></a><a class="code" href="structggl_1_1point__type.html" title="Meta-function which defines point type of any geometry.">point_type</a>;
+ typedef <a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">linestring<point_type></a> 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));
+
+ // 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: " << <a class="code" href="group__length.html#g7e3572634111ae0252a474a7f435c5aa" title="Calculate length of a geometry.">length</a>(line3d) << " line: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(line3d) << std::endl;
+
+ // With DSV you can also use other delimiters, e.g. JSON style
+ std::cout << "JSON: "
+ << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(ls, ", ", "[", "]", ", ", "[ ", " ]")
+ << std::endl;
+
+ return 0;
+}
+</pre></div> </div>
+<hr size="1">
+<table width="100%">
+<tbody>
+<tr>
+<td align="left">
+October 13, 2009
+</td>
+<td align="right">
+Copyright © 1995-2009 Barend Gehrels, Geodan, Amsterdam 
+Copyright © 2008-2009 Bruno Lalande, Paris 
+Copyright © 2009 Mateusz Loskot, Cadcorp, London 
+
+</td>
+</tr>
+</tbody>
+</table>
+
+<address style="text-align: right;">
+Documentation is generated by Doxygen
+</address>
+</body>
+</html>

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/03__polygon__example_8cpp-example.html
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/03__polygon__example_8cpp-example.html 2009-10-13 12:09:45 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,213 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Generic Geometry Library</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+<body style="background-image: url(images/draft.png);">
+
+<table cellpadding="2" width="100%">
+<tbody>
+<tr>
+<td valign="top">
+<img alt="GGL" src="images/ggl-logo-big.png" height="80" width="200">
+  
+</td>
+<td valign="top" align="right">
+<img alt="Boost C++ Libraries" src="images/proposed_boost.png" height="86" width="277">
+</td>
+</tr>
+</tbody>
+</table>
+
+<div class="navigation" id="top">
+ <div class="tabs">
+ <ul>
+ <li>Main Page</li>
+ <li>Related Pages</li>
+ <li>Modules</li>
+ <li>Namespaces</li>
+ <li>Classes</li>
+ <li>Files</li>
+ <li>Examples</li>
+ </ul>
+ </div>
+</div>
+<div class="contents">
+<h1>03_polygon_example.cpp</h1>The polygon example shows some examples of what can be done with polygons in the Generic Geometry Library: the outer ring and the inner rings how to calculate the area of a polygon how to get the centroid, and how to get an often more interesting label point how to correct the polygon such that it is clockwise and closed within: the well-known point in polygon algorithm how to use polygons which use another container, or which use different containers for points and for inner rings how polygons can be intersected, or clipped, using a clipping box
+The illustrations below show the usage of the within algorithm and the intersection algorithm.
+The within algorithm results in true if a point lies completly within a polygon. If it lies exactly on a border it is not considered as within and if it is inside a hole it is also not within the polygon. This is illustrated below, where only the point in the middle is within the polygon.
+<div align="center">
+<img src="within_polygon.png" alt="within_polygon.png">
+</div>
+
+The clipping algorithm, called intersection, is illustrated below:
+<div align="center">
+<img src="clip_polygon.png" alt="clip_polygon.png">
+</div>
+
+The yellow polygon, containing a hole, is clipped with the blue rectangle, resulting in a multi_polygon of three polygons, drawn in red. The hole is vanished.
+include polygon_example.cpp
+<div class="fragment"><pre class="fragment">// Generic Geometry Library
+//
+// Copyright Barend Gehrels 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Polygon Example
+
+#include <algorithm> // for reverse, unique
+#include <iostream>
+#include <string>
+
+#include <ggl/ggl.hpp>
+#include <<a class="code" href="cartesian2d_8hpp.html">ggl/geometries/cartesian2d.hpp</a>>
+#include <<a class="code" href="c__array__cartesian_8hpp.html">ggl/geometries/adapted/c_array_cartesian.hpp</a>>
+#include <<a class="code" href="std__as__linestring_8hpp.html">ggl/geometries/adapted/std_as_linestring.hpp</a>>
+
+std::string boolstr(bool v)
+{
+ return v ? "true" : "false";
+}
+
+int main(void)
+{
+ using namespace ggl;
+
+ // Define a polygon and fill the outer ring.
+ // In most cases you will read it from a file or database
+ <a name="_a0"></a><a class="code" href="classggl_1_1polygon.html" title="The polygon contains an outer ring and zero or more inner rings.">polygon_2d</a> 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},
+ {3.4, 2.0}, {4.1, 3.0}, {5.3, 2.6}, {5.4, 1.2}, {4.9, 0.8}, {2.9, 0.7},
+ {2.0, 1.3} // closing point is opening point
+ };
+ <a name="a1"></a><a class="code" href="group__access.html#ge58b5c7b493d0112202dc139af200c73" title="assign two values to a 2D point">assign</a>(poly, coor);
+ }
+
+ // Polygons should be closed, and directed clockwise. If you're not sure if that is the case,
+ // call the correct algorithm
+ <a name="a2"></a><a class="code" href="namespaceggl.html#de63f8bac74d1e2a56c2d2712eceb8af">correct</a>(poly);
+
+ // Polygons can be streamed as text
+ // (or more precisely: as DSV (delimiter separated values))
+ std::cout << <a name="a3"></a><a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(poly) << std::endl;
+
+ // As with lines, bounding box of polygons can be calculated
+ <a name="_a4"></a><a class="code" href="classggl_1_1box.html" title="Class box: defines a box made of two describing points.">box_2d</a> b;
+ <a name="a5"></a><a class="code" href="group__envelope.html#g376bdcefa676ef2b705656b690767b36" title="Calculate envelope of a geometry, using a specified strategy.">envelope</a>(poly, b);
+ std::cout << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(b) << std::endl;
+
+ // The area of the polygon can be calulated
+ std::cout << "area: " << <a name="a6"></a><a class="code" href="group__area.html#g3ebfdefe9c756498730b6d93b83338b3" title="Calculate area of a geometry.">area</a>(poly) << std::endl;
+
+ // And the centroid, which is the center of gravity
+ <a name="_a7"></a><a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> cent;
+ <a name="a8"></a><a class="code" href="group__centroid.html#g2b743cdd7177313b561780ba87c633cd" title="Calculate centroid.">centroid</a>(poly, cent);
+ std::cout << "centroid: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(cent) << std::endl;
+
+ // Actually in most cases you don't want the centroid, which is only defined for polygons.
+ // You want a nice labelpoint instead. Call labelpoint in those cases, which is defined
+ // for all geometries
+ /* not yet in preview, syntax might change
+ std::cout << "labelpoints: ";
+ label_info<0>(poly, , std::ostream_iterator<point_2d>(std::cout, " "));
+ std::cout << std::endl;
+ */
+
+ // The number of points have to called per ring separately
+ std::cout << "number of points in outer ring: " << poly.<a name="a9"></a><a class="code" href="classggl_1_1polygon.html#be04d3ead04813a25be1a219076358a8">outer</a>().size() << std::endl;
+
+ // Polygons can have one or more inner rings, also called holes, donuts, islands, interior rings.
+ // Let's add one
+ {
+ poly.<a name="a10"></a><a class="code" href="classggl_1_1polygon.html#0d41c7b42a1444fdc759550644c7924e">inners</a>().resize(1);
+ <a name="_a11"></a><a class="code" href="classggl_1_1linear__ring.html" title="A linear_ring (linear linear_ring) is a closed line which should not be selfintersecting...">linear_ring<point_2d></a>& inner = poly.<a class="code" href="classggl_1_1polygon.html#0d41c7b42a1444fdc759550644c7924e">inners</a>().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} };
+ <a class="code" href="group__access.html#ge58b5c7b493d0112202dc139af200c73" title="assign two values to a 2D point">assign</a>(inner, coor);
+ }
+
+ <a class="code" href="namespaceggl.html#de63f8bac74d1e2a56c2d2712eceb8af">correct</a>(poly);
+
+ std::cout << "with inner ring:" << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(poly) << std::endl;
+ // The area of the polygon is changed of course
+ std::cout << "new area of polygon: " << <a class="code" href="group__area.html#g3ebfdefe9c756498730b6d93b83338b3" title="Calculate area of a geometry.">area</a>(poly) << std::endl;
+ <a class="code" href="group__centroid.html#g2b743cdd7177313b561780ba87c633cd" title="Calculate centroid.">centroid</a>(poly, cent);
+ std::cout << "new centroid: " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(cent) << std::endl;
+
+ // You can test whether points are within a polygon
+ std::cout << "point in polygon:"
+ << " p1: " << boolstr(<a name="a12"></a><a class="code" href="group__boolean__relations.html#g95d6465a12b762c77df41369a039f6dc" title="Within check.">within</a>(make<point_2d>(3.0, 2.0), poly))
+ << " p2: " << boolstr(<a class="code" href="group__boolean__relations.html#g95d6465a12b762c77df41369a039f6dc" title="Within check.">within</a>(make<point_2d>(3.7, 2.0), poly))
+ << " p3: " << boolstr(<a class="code" href="group__boolean__relations.html#g95d6465a12b762c77df41369a039f6dc" title="Within check.">within</a>(make<point_2d>(4.4, 2.0), poly))
+ << std::endl;
+
+ // You can call for_each or for_each_segment on polygons to, this will visit all points / segments
+ // in outer ring and inner rings
+ //for_each(poly, f);
+
+ // 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
+ <a class="code" href="classggl_1_1box.html" title="Class box: defines a box made of two describing points.">box_2d</a> 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<polygon_2d>(cb, poly, std::back_inserter(v));
+ std::cout << "Clipped output polygons" << std::endl;
+ for (polygon_list::const_iterator it = v.begin(); it != v.end(); ++it)
+ {
+ std::cout << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(*it) << std::endl;
+ }
+
+ <a class="code" href="classggl_1_1polygon.html" title="The polygon contains an outer ring and zero or more inner rings.">polygon_2d</a> hull;
+ <a name="a13"></a><a class="code" href="group__convex__hull.html#gc1989428c0a32cd2fd48272cd6833e18" title="Calculate the convex hull of a geometry.">convex_hull</a>(poly, std::back_inserter(hull.<a class="code" href="classggl_1_1polygon.html#be04d3ead04813a25be1a219076358a8">outer</a>()));
+ std::cout << "Convex hull:" << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(hull) << std::endl;
+
+ // If you really want:
+ // 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 <a class="code" href="classggl_1_1polygon.html" title="The polygon contains an outer ring and zero or more inner rings.">polygon<point_2d, std::vector, std::deque></a> polygon_type;
+ polygon_type poly2;
+ <a name="_a14"></a><a class="code" href="structggl_1_1ring__type.html" title="Meta-function which defines ring type of (multi)polygon geometry.">ring_type<polygon_type>::type</a>& ring = <a name="a15"></a><a class="code" href="group__access.html#gf92470d0612da7f0e118d296e7fcfe01" title="Function to get the exterior_ring ring of a polygon.">exterior_ring</a>(poly2);
+ <a name="a16"></a><a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ring, make<point_2d>(2.8, 1.9));
+ <a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ring, make<point_2d>(2.9, 2.4));
+ <a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ring, make<point_2d>(3.3, 2.2));
+ <a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ring, make<point_2d>(3.2, 1.8));
+ <a class="code" href="group__access.html#g8cfdebdb885a95bacb1305744f0d0d7c" title="Appends one or more points to a linestring, linear-ring, polygon, multi.">append</a>(ring, make<point_2d>(2.8, 1.9));
+ std::cout << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(poly2) << std::endl;
+
+ return 0;
+}
+</pre></div> </div>
+<hr size="1">
+<table width="100%">
+<tbody>
+<tr>
+<td align="left">
+October 13, 2009
+</td>
+<td align="right">
+Copyright © 1995-2009 Barend Gehrels, Geodan, Amsterdam 
+Copyright © 2008-2009 Bruno Lalande, Paris 
+Copyright © 2009 Mateusz Loskot, Cadcorp, London 
+
+</td>
+</tr>
+</tbody>
+</table>
+
+<address style="text-align: right;">
+Documentation is generated by Doxygen
+</address>
+</body>
+</html>

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/06__transformation__example_8cpp-example.html
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/06__transformation__example_8cpp-example.html 2009-10-13 12:09:45 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,112 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Generic Geometry Library</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+<body style="background-image: url(images/draft.png);">
+
+<table cellpadding="2" width="100%">
+<tbody>
+<tr>
+<td valign="top">
+<img alt="GGL" src="images/ggl-logo-big.png" height="80" width="200">
+  
+</td>
+<td valign="top" align="right">
+<img alt="Boost C++ Libraries" src="images/proposed_boost.png" height="86" width="277">
+</td>
+</tr>
+</tbody>
+</table>
+
+<div class="navigation" id="top">
+ <div class="tabs">
+ <ul>
+ <li>Main Page</li>
+ <li>Related Pages</li>
+ <li>Modules</li>
+ <li>Namespaces</li>
+ <li>Classes</li>
+ <li>Files</li>
+ <li>Examples</li>
+ </ul>
+ </div>
+</div>
+<div class="contents">
+<h1>06_transformation_example.cpp</h1>This sample demonstrates the usage of transformations in the Generic Geometry Library. Behind the screens this is done using with the uBLAS matrix/vector library.
+<div class="fragment"><pre class="fragment">// Generic Geometry Library
+//
+// Copyright Barend Gehrels 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Transformation Example
+
+#include <iostream>
+
+#include <ggl/ggl.hpp>
+#include <<a class="code" href="cartesian2d_8hpp.html">ggl/geometries/cartesian2d.hpp</a>>
+#include <<a class="code" href="c__array__cartesian_8hpp.html">ggl/geometries/adapted/c_array_cartesian.hpp</a>>
+#include <<a class="code" href="std__as__linestring_8hpp.html">ggl/geometries/adapted/std_as_linestring.hpp</a>>
+
+int main()
+{
+ using namespace ggl;
+
+ <a name="_a0"></a><a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> p(1, 1);
+ <a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">point_2d</a> p2;
+
+ // Example: translate a point over (5,5)
+ <a name="_a1"></a><a class="code" href="structggl_1_1strategy_1_1transform_1_1translate__transformer.html" title="Transformation strategy to translate in Cartesian system.">strategy::transform::translate_transformer<point_2d, point_2d></a> translate(5, 5);
+
+ <a name="a2"></a><a class="code" href="group__transform.html#ge33cee2442ebab063f9c987121cd3500" title="Transforms from one geometry to another geometry using a strategy.">transform</a>(p, p2, translate);
+ std::cout << "transformed point " << <a name="a3"></a><a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(p2) << std::endl;
+
+ // Transform a polygon
+ <a name="_a4"></a><a class="code" href="classggl_1_1polygon.html" title="The polygon contains an outer ring and zero or more inner rings.">polygon_2d</a> 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)
+ <a name="a5"></a><a class="code" href="group__access.html#ge58b5c7b493d0112202dc139af200c73" title="assign two values to a 2D point">assign</a>(poly, coor);
+ //read_wkt("POLYGON((0 0,0 7,4 2,2 0,0 0))", poly);
+ <a class="code" href="group__transform.html#ge33cee2442ebab063f9c987121cd3500" title="Transforms from one geometry to another geometry using a strategy.">transform</a>(poly, poly2, translate);
+
+ std::cout << "source polygon " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(poly) << std::endl;
+ std::cout << "transformed polygon " << <a class="code" href="namespaceggl.html#3399b7516122f515a1ea5ee5fdf49ce4" title="Main DSV-streaming function.">ggl::dsv</a>(poly2) << std::endl;
+
+ // Many more transformations are possible:
+ // - from Cartesian to Spherical coordinate systems and back
+ // - from Cartesian to Cartesian (mapping, affine transformations) and back (inverse)
+ // - Map Projections
+ // - from Degree to Radian and back in spherical or geographic coordinate systems
+
+ return 0;
+}
+</pre></div> </div>
+<hr size="1">
+<table width="100%">
+<tbody>
+<tr>
+<td align="left">
+October 13, 2009
+</td>
+<td align="right">
+Copyright © 1995-2009 Barend Gehrels, Geodan, Amsterdam 
+Copyright © 2008-2009 Bruno Lalande, Paris 
+Copyright © 2009 Mateusz Loskot, Cadcorp, London 
+
+</td>
+</tr>
+</tbody>
+</table>
+
+<address style="text-align: right;">
+Documentation is generated by Doxygen
+</address>
+</body>
+</html>

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07__graph__route__example_8cpp-example.html
==============================================================================
--- (empty file)
+++ sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07__graph__route__example_8cpp-example.html 2009-10-13 12:09:45 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,482 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Generic Geometry Library</title>
+<link href="doxygen.css" rel="stylesheet" type="text/css">
+<link href="tabs.css" rel="stylesheet" type="text/css">
+</head>
+<body style="background-image: url(images/draft.png);">
+
+<table cellpadding="2" width="100%">
+<tbody>
+<tr>
+<td valign="top">
+<img alt="GGL" src="images/ggl-logo-big.png" height="80" width="200">
+  
+</td>
+<td valign="top" align="right">
+<img alt="Boost C++ Libraries" src="images/proposed_boost.png" height="86" width="277">
+</td>
+</tr>
+</tbody>
+</table>
+
+<div class="navigation" id="top">
+ <div class="tabs">
+ <ul>
+ <li>Main Page</li>
+ <li>Related Pages</li>
+ <li>Modules</li>
+ <li>Namespaces</li>
+ <li>Classes</li>
+ <li>Files</li>
+ <li>Examples</li>
+ </ul>
+ </div>
+</div>
+<div class="contents">
+<h1>07_graph_route_example.cpp</h1>The graph route example shows how GGL can be combined with Boost.Graph. The sample does the following things:<ul>
+<li>it reads roads (included in the distribution, stored on disk in the form of a text file containing geometries and names)</li><li>it reads cities</li><li>it creates a graph from the roads</li><li>it connects each city to the nearest vertex in the graph</li><li>it calculates the shortest route between each pair of cities</li><li>it outputs the distance over the road, and also of the air</li><li>it creates an SVG image with the roads, the cities, and the first calculated route</li></ul>
+
+Note that this example is useful, but it is only an example. It could be built in many different ways. For example:<ul>
+<li>the roads/cities could be read from a database using SOCI, or from a shapefile using shapelib</li><li>it could support oneway roads and roads on different levels (disconnected bridges)</li><li>it currently uses tuples but that could be anything</li><li>etc</li></ul>
+
+The SVG looks like: <div align="center">
+<img src="07_graph_route_example_svg.png" alt="07_graph_route_example_svg.png">
+</div>
+
+The output screen looks like: <div align="center">
+<img src="07_graph_route_example_text.png" alt="07_graph_route_example_text.png">
+</div>
+
+<div class="fragment"><pre class="fragment">// Generic Geometry Library
+//
+// Copyright Barend Gehrels 1995-2009, Geodan Holding B.V. Amsterdam, the Netherlands.
+// Copyright Bruno Lalande 2008, 2009
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// Example showing GGL combined with Boost.Graph, calculating shortest routes
+// input: two WKT's, provided in subfolder data
+// output: text, + an SVG, displayable in e.g. Firefox)
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <limits>
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/foreach.hpp>
+
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/dijkstra_shortest_paths.hpp>
+
+#include <ggl/ggl.hpp>
+#include <<a class="code" href="less_8hpp.html">ggl/util/less.hpp</a>>
+#include <<a class="code" href="cartesian2d_8hpp.html">ggl/geometries/cartesian2d.hpp</a>>
+
+
+// Yes, this example currently uses some extensions:
+
+ // For input:
+ #include <ggl/extensions/gis/io/wkt/read_wkt.hpp>
+
+ // For output:
+ #include <<a class="code" href="write__svg_8hpp.html">ggl/extensions/io/svg/write_svg.hpp</a>>
+
+ // For distance-calculations over the Earth:
+ #include <ggl/extensions/gis/geographic/strategies/andoyer.hpp>
+
+
+
+// Read an ASCII file containing WKT's, fill a vector of tuples
+// The tuples consist of at least <0> a geometry and <1> an identifying string
+template <typename Geometry, typename Tuple, typename Box>
+void read_wkt(std::string const& filename, std::vector<Tuple>& tuples, Box& box)
+{
+ std::ifstream cpp_file(filename.c_str());
+ if (cpp_file.is_open())
+ {
+ while (! cpp_file.eof() )
+ {
+ std::string line;
+ std::getline(cpp_file, line);
+ Geometry geometry;
+ boost::trim(line);
+ if (! line.empty() && ! boost::starts_with(line, "#"))
+ {
+ std::string name;
+
+ // Split at ';', if any
+ std::string::size_type pos = line.find(";");
+ if (pos != std::string::npos)
+ {
+ name = line.substr(pos + 1);
+ line.erase(pos);
+
+ boost::trim(line);
+ boost::trim(name);
+ }
+
+ Geometry geometry;
+ ggl::read_wkt(line, geometry);
+
+ Tuple tuple(geometry, name);
+
+ tuples.push_back(tuple);
+ <a name="a0"></a><a class="code" href="group__combine.html#gf2336ad085ad8b79cde5a759ab229199" title="Combines a box with another geometry (box, point).">ggl::combine</a>(box, ggl::make_envelope<Box>(geometry,
+ // Todo: necessary for latlong, but should not be, solve this
+ <a name="_a1"></a><a class="code" href="structggl_1_1strategy_1_1envelope_1_1combine__xy.html">ggl::strategy::envelope::combine_xy</a>
+ <
+ typename <a name="_a2"></a><a class="code" href="structggl_1_1point__type.html" title="Meta-function which defines point type of any geometry.">ggl::point_type<Geometry>::type</a>,
+ Box
+ >()));
+ }
+ }
+ }
+}
+
+// Boilerplate code to initialize the SVG XML.
+// Note that this is (on purpose) not part of the library but of this sample.
+// GGL itself only streams small pieces of SVG, in any coordinate system
+void svg_header(std::ofstream& stream)
+{
+ stream << "<?xml version=\"1.0\" standalone=\"no\"?>" << std::endl;
+ stream << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"" << std::endl;
+ stream << "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">" << std::endl;
+
+ stream << "<svg width=\"100%\" height=\"100%\" version=\"1.1\"" << std::endl;
+ stream << "xmlns=\"http://www.w3.org/2000/svg\">" << std::endl;
+}
+
+
+// Code to define properties for Boost Graph's
+enum vertex_ggl_property_t { vertex_ggl_property };
+enum edge_ggl_property_t { edge_ggl_property };
+namespace boost
+{
+ BOOST_INSTALL_PROPERTY(vertex, ggl_property);
+ BOOST_INSTALL_PROPERTY(edge, ggl_property);
+}
+
+// Define properties for vertex
+template <typename Point>
+struct ggl_vertex_property
+{
+ ggl_vertex_property()
+ {
+ <a name="a3"></a><a class="code" href="group__access.html#g2fba6ded1fb6ecc7dba897b55c70f2d0" title="assign zero values to a box, point">ggl::assign_zero</a>(location);
+ }
+ ggl_vertex_property(Point const& loc)
+ {
+ location = loc;
+ }
+
+ Point location;
+};
+
+// Define properties for edge
+template <typename Linestring>
+struct ggl_edge_property
+{
+ ggl_edge_property(Linestring const& line)
+ : m_line(line)
+ {
+ m_length = <a name="a4"></a><a class="code" href="group__length.html#g7e3572634111ae0252a474a7f435c5aa" title="Calculate length of a geometry.">ggl::length</a>(line);
+ }
+
+ inline operator double() const
+ {
+ return m_length;
+ }
+
+ inline Linestring const& line() const
+ {
+ return m_line;
+ }
+
+private :
+ double m_length;
+ Linestring m_line;
+};
+
+// Utility function to add a vertex to a graph. It might exist already. Then do not insert,
+// but return vertex descriptor back. It might not exist. Then add it (and return).
+// To efficiently handle this, a std::map is used.
+template <typename M, typename K, typename G>
+inline typename boost::graph_traits<G>::vertex_descriptor find_or_insert(M& map, K const& key, G& graph)
+{
+ typename M::const_iterator it = map.find(key);
+ if (it == map.end())
+ {
+ // Add a vertex to the graph
+ typename boost::graph_traits<G>::vertex_descriptor new_vertex
+ = boost::add_vertex(graph);
+
+ // Set the property (= location)
+ boost::put(<a name="a5"></a><a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(vertex_ggl_property, graph), new_vertex,
+ ggl_vertex_property<typename M::key_type>(key));
+
+ // Add to the map, using POINT as key
+ map[key] = new_vertex;
+ return new_vertex;
+ }
+ return it->second;
+}
+
+template
+<
+ typename Line,
+ typename Graph,
+ typename RoadTupleVector,
+ typename CityTupleVector
+>
+void add_roads_and_connect_cities(Graph& graph,
+ RoadTupleVector const& roads,
+ CityTupleVector& cities)
+{
+ typedef typename <a class="code" href="structggl_1_1point__type.html" title="Meta-function which defines point type of any geometry.">ggl::point_type<Line>::type</a> point_type;
+
+ typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_type;
+
+ // Define a map to be used during graph filling
+ // Maps from point to vertex-id's
+ typedef std::map<point_type, vertex_type, ggl::less<point_type> > map_type;
+ map_type map;
+
+
+ // Fill the graph
+ typedef typename boost::range_value<RoadTupleVector>::type road_type;
+ BOOST_FOREACH(road_type const& road, roads)
+ {
+ // Find or add begin/end point of these line
+ vertex_type from = find_or_insert(map, road.get<0>().front(), graph);
+ vertex_type to = find_or_insert(map, road.get<0>().back(), graph);
+ boost::add_edge(from, to, ggl_edge_property<Line>(road.get<0>()), graph);
+ }
+
+ // Find nearest graph vertex for each city, using the map
+ typedef typename boost::range_value<CityTupleVector>::type city_type;
+ BOOST_FOREACH(city_type& city, cities)
+ {
+ double min_distance = 1e300;
+ for(typename map_type::const_iterator it = map.begin(); it != map.end(); ++it)
+ {
+ double dist = <a name="a6"></a><a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">ggl::distance</a>(it->first, city.get<0>());
+ if (dist < min_distance)
+ {
+ min_distance = dist;
+ // Set the vertex
+ city.get<2>() = it->second;
+ }
+ }
+ }
+}
+
+template <typename Graph, typename Route>
+inline void add_edge_to_route(Graph const& graph,
+ typename boost::graph_traits<Graph>::vertex_descriptor vertex1,
+ typename boost::graph_traits<Graph>::vertex_descriptor vertex2,
+ Route& route)
+{
+ std::pair
+ <
+ typename boost::graph_traits<Graph>::edge_descriptor,
+ bool
+ > opt_edge = boost::edge(vertex1, vertex2, graph);
+ if (opt_edge.second)
+ {
+ // Get properties of edge and of vertex
+ ggl_edge_property<Route> const& edge_prop =
+ <a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(<a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(edge_ggl_property, graph), opt_edge.first);
+
+ ggl_vertex_property<typename ggl::point_type<Route>::type> const& vertex_prop =
+ <a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(<a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(vertex_ggl_property, graph), vertex2);
+
+ // Depending on how edge connects to vertex, copy it forward or backward
+ if (<a name="a7"></a><a class="code" href="group__boolean__relations.html#g122b1fd835cee0742da7c97dfdda94c5" title="Calculate if two geometries are equals.">ggl::equals</a>(edge_prop.line().front(), vertex_prop.location))
+ {
+ std::copy(edge_prop.line().begin(), edge_prop.line().end(),
+ std::back_inserter(route));
+ }
+ else
+ {
+ std::reverse_copy(edge_prop.line().begin(), edge_prop.line().end(),
+ std::back_inserter(route));
+ }
+ }
+}
+
+
+template <typename Graph, typename Route>
+inline void build_route(Graph const& graph,
+ std::vector<typename boost::graph_traits<Graph>::vertex_descriptor> const& predecessors,
+ typename boost::graph_traits<Graph>::vertex_descriptor vertex1,
+ typename boost::graph_traits<Graph>::vertex_descriptor vertex2,
+ Route& route)
+{
+ typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_type;
+ vertex_type pred = predecessors[vertex2];
+
+ add_edge_to_route(graph, vertex2, pred, route);
+ while (pred != vertex1)
+ {
+ add_edge_to_route(graph, predecessors[pred], pred, route);
+ pred = predecessors[pred];
+ }
+}
+
+
+int main()
+{
+ // Define a point in the Geographic coordinate system
+ typedef <a name="_a8"></a><a class="code" href="classggl_1_1point.html" title="Basic point class, having coordinates defined in a neutral way.">ggl::point<double, 2, ggl::cs::geographic<ggl::degree></a> > point_type;
+
+ typedef <a name="_a9"></a><a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">ggl::linestring<point_type></a> line_type;
+
+ // Define the graph, lateron containing the road network
+ typedef boost::adjacency_list
+ <
+ boost::vecS, boost::vecS, boost::undirectedS
+ , boost::property<vertex_ggl_property_t, ggl_vertex_property<point_type> >
+ , boost::property<edge_ggl_property_t, ggl_edge_property<line_type> >
+ > graph_type;
+
+ typedef boost::graph_traits<graph_type>::vertex_descriptor vertex_type;
+
+
+ // Init a bounding box, lateron used to define SVG map
+ <a name="_a10"></a><a class="code" href="classggl_1_1box.html" title="Class box: defines a box made of two describing points.">ggl::box_2d</a> box;
+ <a name="a11"></a><a class="code" href="group__access.html#gaa27514a7d1c16133d28dd5601cd32fd" title="assign to a box inverse infinite">ggl::assign_inverse</a>(box);
+
+ // Read the cities
+ typedef boost::tuple<point_type, std::string, vertex_type> city_type;
+ std::vector<city_type> cities;
+ read_wkt<point_type>("data/cities.wkt", cities, box);
+
+ // Read the road network
+ typedef boost::tuple<line_type, std::string> road_type;
+ std::vector<road_type> roads;
+ read_wkt<line_type>("data/roads.wkt", roads, box);
+
+
+ graph_type graph;
+
+ // Add roads and connect cities
+ add_roads_and_connect_cities<line_type>(graph, roads, cities);
+
+ double const km = 1000.0;
+ std::cout << "distances, all in KM" << std::endl
+ << std::fixed << std::setprecision(0);
+
+ // Main functionality: calculate shortest routes from/to all cities
+
+ // For the first one, the complete route is stored as a linestring
+ bool first = true;
+ line_type route;
+
+ int const n = boost::num_vertices(graph);
+ BOOST_FOREACH(city_type const& city1, cities)
+ {
+ std::vector<vertex_type> predecessors(n);
+ std::vector<double> costs(n);
+
+ // Call Dijkstra (without named-parameter to be compatible with all VC)
+ boost::dijkstra_shortest_paths(graph, city1.get<2>(),
+ &predecessors[0], &costs[0],
+ <a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(edge_ggl_property, graph),
+ <a class="code" href="group__access.html#g6cf833a7f9622af2fc05fd94aa61153f" title="get a coordinate value of a point / nsphere">boost::get</a>(boost::vertex_index, graph),
+ std::less<double>(), std::plus<double>(),
+ (std::numeric_limits<double>::max)(), double(),
+ boost::dijkstra_visitor<boost::null_visitor>());
+
+ BOOST_FOREACH(city_type const& city2, cities)
+ {
+ if (! <a class="code" href="group__boolean__relations.html#g122b1fd835cee0742da7c97dfdda94c5" title="Calculate if two geometries are equals.">boost::equals</a>(city1.get<1>(), city2.get<1>()))
+ {
+ double <a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">distance</a> = costs[city2.get<2>()] / km;
+ double acof = <a class="code" href="group__distance.html#g22a618786d2601e9201896a8346c161b" title="Calculate distance between two geometries with a specified strategy.">ggl::distance</a>(city1.get<0>(), city2.get<0>()) / km;
+
+ std::cout
+ << std::setiosflags (std::ios_base::left) << std::setw(15)
+ << city1.get<1>() << " - "
+ << std::setiosflags (std::ios_base::left) << std::setw(15)
+ << city2.get<1>()
+ << " -> through the air: " << std::setw(4) << acof
+ << " , over the road: " << std::setw(4) << distance
+ << std::endl;
+
+ if (first)
+ {
+ build_route(graph, predecessors,
+ city1.get<2>(), city2.get<2>(),
+ route);
+ first = false;
+ }
+ }
+ }
+ }
+
+ // Create the SVG
+ typedef <a name="_a12"></a><a class="code" href="classggl_1_1point__xy.html" title="2D point in Cartesian coordinate system">ggl::point_xy<int></a> svg_point_type;
+ std::ofstream stream("routes.svg");
+ svg_header(stream);
+
+ <a name="_a13"></a><a class="code" href="structggl_1_1strategy_1_1transform_1_1map__transformer.html" title="Transformation strategy to do map from one to another Cartesian system.">ggl::strategy::transform::map_transformer</a>
+ <
+ point_type,
+ svg_point_type, true, true
+ > matrix(box, 1000, 800);
+
+ // Map roads
+ BOOST_FOREACH(road_type const& road, roads)
+ {
+ <a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">ggl::linestring<svg_point_type></a> line;
+ <a name="a14"></a><a class="code" href="group__transform.html#ge33cee2442ebab063f9c987121cd3500" title="Transforms from one geometry to another geometry using a strategy.">ggl::transform</a>(road.get<0>(), line, matrix);
+ stream << <a name="a15"></a><a class="code" href="group__svg.html#g98ba8f58eaff68c96c23f9d9a90bc4fd" title="Main svg function to stream geometries as SVG.">ggl::svg</a>(line, "stroke:rgb(128,128,128);stroke-width:1") << std::endl;
+ }
+
+ // Map the calculated route as thicker green transparent markation
+ {
+ <a class="code" href="classggl_1_1linestring.html" title="A linestring (named so by OGC) is a collection (default a vector) of points.">ggl::linestring<svg_point_type></a> line;
+ <a class="code" href="group__transform.html#ge33cee2442ebab063f9c987121cd3500" title="Transforms from one geometry to another geometry using a strategy.">ggl::transform</a>(route, line, matrix);
+ stream << <a class="code" href="group__svg.html#g98ba8f58eaff68c96c23f9d9a90bc4fd" title="Main svg function to stream geometries as SVG.">ggl::svg</a>(line, "stroke:rgb(0, 255, 0);stroke-width:6;opacity:0.5") << std::endl;
+ }
+
+ // Map cities
+ BOOST_FOREACH(city_type const& city, cities)
+ {
+ svg_point_type point;
+ <a class="code" href="group__transform.html#ge33cee2442ebab063f9c987121cd3500" title="Transforms from one geometry to another geometry using a strategy.">ggl::transform</a>(city.get<0>(), point, matrix);
+ stream << <a class="code" href="group__svg.html#g98ba8f58eaff68c96c23f9d9a90bc4fd" title="Main svg function to stream geometries as SVG.">ggl::svg</a>(point, "fill:rgb(255,255,0);stroke:rgb(0,0,0);stroke-width:1") << std::endl;
+ }
+
+ stream << "</svg>" << std::endl;
+
+ return 0;
+}
+</pre></div> </div>
+<hr size="1">
+<table width="100%">
+<tbody>
+<tr>
+<td align="left">
+October 13, 2009
+</td>
+<td align="right">
+Copyright © 1995-2009 Barend Gehrels, Geodan, Amsterdam 
+Copyright © 2008-2009 Bruno Lalande, Paris 
+Copyright © 2009 Mateusz Loskot, Cadcorp, London 
+
+</td>
+</tr>
+</tbody>
+</table>
+
+<address style="text-align: right;">
+Documentation is generated by Doxygen
+</address>
+</body>
+</html>

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07_graph_route_example_svg.png
==============================================================================
Binary file. No diff available.

Added: sandbox/ggl/formal_review_request/libs/ggl/doc/doxygen_output/html/07_graph_route_example_text.png
==============================================================================
Binary file. No diff available.

Date view	Thread view	Subject view	Author view

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