Boost-Commit mailing page: [Boost-commit] svn:boost r74333 - in sandbox/graph-intrusive_layout: . boost boost/detail boost/detail/metafunction boost/graph boost/graph/detail boost/graph/keywords libs libs/graph libs/graph/doc libs/graph/doc/images libs/graph/example

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r74333 - in sandbox/graph-intrusive_layout: . boost boost/detail boost/detail/metafunction boost/graph boost/graph/detail boost/graph/keywords libs libs/graph libs/graph/doc libs/graph/doc/images libs/graph/example
From: sponage_at_[hidden]
Date: 2011-09-10 10:10:19

Author: expaler
Date: 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
New Revision: 74333
URL: http://svn.boost.org/trac/boost/changeset/74333

Log:
Added Boost.Graph.IntrusiveLayout candidate sublibrary
Added:
   sandbox/graph-intrusive_layout/
   sandbox/graph-intrusive_layout/boost/
   sandbox/graph-intrusive_layout/boost.png (contents, props changed)
   sandbox/graph-intrusive_layout/boost/detail/
   sandbox/graph-intrusive_layout/boost/detail/index_predicate.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/detail/make_value_factory.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/detail/metafunction/
   sandbox/graph-intrusive_layout/boost/detail/metafunction/data_type.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/
   sandbox/graph-intrusive_layout/boost/graph/basic_add_edge_function.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/basic_vert_insert_iterator.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/detail/
   sandbox/graph-intrusive_layout/boost/graph/detail/default_origin.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/detail/default_scale.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/detail/intrusive_layout_params.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/
   sandbox/graph-intrusive_layout/boost/graph/keywords/dimension_count.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/dimensions.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/edge_function.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/has_square_origin.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/inscribed_radius.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/is_zeta.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/origin.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/point_factory.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/position_index_map.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/position_map.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/scale.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/vertex_centroid_distance.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/vertex_iterator.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/keywords/wraparound_policy.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/set_bitset_grid_layout.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/set_bt_cubic_hcomb_layout.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/set_orthogonal_grid_layout.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/boost/graph/set_upsilon_tessel_layout.hpp (contents, props changed)
   sandbox/graph-intrusive_layout/libs/
   sandbox/graph-intrusive_layout/libs/graph/
   sandbox/graph-intrusive_layout/libs/graph/doc/
   sandbox/graph-intrusive_layout/libs/graph/doc/Jamroot (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/basic_add_edge_function.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/basic_add_edge_function.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/basic_vert_insert_iterator.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/basic_vert_insert_iterator.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/boostbook.css (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_bitset_grid_verts.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_bitset_grid_verts.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_bt_cubic_hcomb_verts.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_bt_cubic_hcomb_verts.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_ortho_grid_verts.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_ortho_grid_verts.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_upsilon_tessel_verts.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/count_upsilon_tessel_verts.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/
   sandbox/graph-intrusive_layout/libs/graph/doc/images/alert.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/blank.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/caution.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/draft.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/home.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/important.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/next.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/next_disabled.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/note.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/prev.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/prev_disabled.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/smiley.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/tip.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/toc-blank.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/toc-minus.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/toc-plus.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/up.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/up_disabled.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/images/warning.png (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/intrusive_layout.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_bitset_grid_layout.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_bitset_grid_layout.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_bt_cubic_hcomb_layout.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_bt_cubic_hcomb_layout.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_orthogonal_grid_layout.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_orthogonal_grid_layout.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_upsilon_tessel_layout.html (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/doc/set_upsilon_tessel_layout.qbk (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/example/
   sandbox/graph-intrusive_layout/libs/graph/example/bitruncated_cubic_honeycomb.cpp (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/example/bitset_grid_layouts.cpp (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/example/orthogonal_grid_layouts.cpp (contents, props changed)
   sandbox/graph-intrusive_layout/libs/graph/example/upsilon_tessellation_layout.cpp (contents, props changed)

Added: sandbox/graph-intrusive_layout/boost.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/boost/detail/index_predicate.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/detail/index_predicate.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,23 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_DETAIL_INDEX_PREDICATE_HPP_INCLUDED
+#define BOOST_DETAIL_INDEX_PREDICATE_HPP_INCLUDED
+
+namespace boost { namespace detail {
+
+ template <bool ReturnValue>
+ struct index_predicate
+ {
+ template <typename T>
+ inline bool operator[](T const&) const
+ {
+ return ReturnValue;
+ }
+ };
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_INDEX_PREDICATE_HPP_INCLUDED
+

Added: sandbox/graph-intrusive_layout/boost/detail/make_value_factory.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/detail/make_value_factory.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,21 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_DETAIL_MAKE_VALUE_FACTORY_HPP
+#define BOOST_DETAIL_MAKE_VALUE_FACTORY_HPP
+
+#include <boost/functional/value_factory.hpp>
+
+namespace boost { namespace detail {
+
+ template <typename T>
+ inline value_factory<T> make_value_factory(T const&)
+ {
+ return value_factory<T>();
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_MAKE_VALUE_FACTORY_HPP
+

Added: sandbox/graph-intrusive_layout/boost/detail/metafunction/data_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/detail/metafunction/data_type.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,52 @@
+// Copyright (C) 2007-2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_DETAIL_METAFUNCTION_DATA_TYPE_HPP_INCLUDED
+#define BOOST_DETAIL_METAFUNCTION_DATA_TYPE_HPP_INCLUDED
+
+#include <boost/ref.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_volatile.hpp>
+#include <boost/type_traits/remove_all_extents.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace detail {
+
+ template <typename T>
+ struct data_type
+ {
+ private:
+ typedef typename ::boost::remove_const<
+ typename ::boost::remove_reference<
+ typename ::boost::remove_pointer<
+ typename ::boost::remove_volatile<
+ typename ::boost::remove_all_extents<
+ typename ::boost::unwrap_reference<T>::type
+ >::type
+ >::type
+ >::type
+ >::type
+ >::type
+ lower_type;
+
+ public:
+ typedef typename ::boost::mpl::eval_if<
+ ::boost::is_same<T,lower_type>
+ , ::boost::mpl::identity<T>
+ , data_type<lower_type>
+ >::type
+ type;
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,data_type,(T))
+ };
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_METAFUNCTION_DATA_TYPE_HPP_INCLUDED
+

Added: sandbox/graph-intrusive_layout/boost/graph/basic_add_edge_function.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/basic_add_edge_function.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,97 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_BASIC_ADD_EDGE_FUNCTION_HPP
+#define BOOST_GRAPH_BASIC_ADD_EDGE_FUNCTION_HPP
+
+#include <boost/tr1/type_traits.hpp>
+#include <boost/graph/graph_traits.hpp>
+
+//[reference__basic_add_edge_function__definition
+namespace boost {
+
+ template <typename Graph, bool Is2Way>
+ class basic_add_edge_function
+ {
+ //<-
+ Graph& _graph;
+ //->
+
+ public:
+ explicit basic_add_edge_function(Graph& graph);
+
+ void
+ operator()(
+ typename graph_traits<Graph>::vertex_descriptor u
+ , typename graph_traits<Graph>::vertex_descriptor v
+ );
+ };
+
+ //<-
+ template <typename Graph, bool Is2Way>
+ basic_add_edge_function<Graph,Is2Way>::basic_add_edge_function(
+ Graph& graph
+ ) : _graph(graph)
+ {
+ }
+
+ template <typename Graph, bool Is2Way>
+ inline void
+ basic_add_edge_function<Graph,Is2Way>::operator()(
+ typename graph_traits<Graph>::vertex_descriptor u
+ , typename graph_traits<Graph>::vertex_descriptor v
+ )
+ {
+ add_edge(u, v, _graph);
+
+ if (
+ Is2Way && ::std::tr1::is_base_of<
+ directed_tag
+ , typename graph_traits<Graph>::directed_category
+ >::value
+ )
+ {
+ add_edge(v, u, _graph);
+ }
+ }
+ //->
+} // namespace boost
+//]
+
+//[reference__basic_2way_edge_adder__prototype
+namespace boost {
+
+ template <typename Graph>
+ basic_add_edge_function<Graph,true> basic_2way_edge_adder(Graph& graph);
+
+ //<-
+ template <typename Graph>
+ inline basic_add_edge_function<Graph,true>
+ basic_2way_edge_adder(Graph& graph)
+ {
+ return basic_add_edge_function<Graph,true>(graph);
+ }
+ //->
+} // namespace boost
+//]
+
+//[reference__basic_edge_adder__prototype
+namespace boost {
+
+ template <typename Graph>
+ basic_add_edge_function<Graph,false> basic_edge_adder(Graph& graph);
+
+ //<-
+ template <typename Graph>
+ inline basic_add_edge_function<Graph,false> basic_edge_adder(Graph& graph)
+ {
+ return basic_add_edge_function<Graph,false>(graph);
+ }
+ //->
+} // namespace boost
+//]
+
+#endif // BOOST_GRAPH_BASIC_ADD_EDGE_FUNCTION_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/basic_vert_insert_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/basic_vert_insert_iterator.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,123 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_BASIC_VERT_INSERT_ITERATOR_HPP
+#define BOOST_GRAPH_BASIC_VERT_INSERT_ITERATOR_HPP
+
+#include <boost/config.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+
+#ifndef BOOST_NO_SFINAE
+#include <boost/tr1/type_traits.hpp>
+#include <boost/utility/enable_if.hpp>
+#endif
+
+//[reference__basic_vertex_insert_iterator__definition
+namespace boost {
+
+ template <typename Graph>
+ class basic_vertex_insert_iterator
+ : public ::boost::iterator_facade<
+ basic_vertex_insert_iterator<Graph>
+ , typename graph_traits<Graph>::vertex_descriptor
+ , forward_traversal_tag
+ >
+ {
+ //<-
+#ifndef BOOST_NO_SFINAE
+ struct enabler
+ {
+ };
+#endif
+
+ mutable Graph& _graph;
+ mutable typename graph_traits<Graph>::vertex_descriptor _vertex;
+ //->
+
+ public:
+ explicit basic_vertex_insert_iterator(Graph& graph);
+
+ template <typename OtherGraph>
+ basic_vertex_insert_iterator(
+ basic_vertex_insert_iterator<OtherGraph> const& other
+//<-
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ ::std::tr1::is_convertible<OtherGraph&,Graph&>
+ , enabler
+ >::type = enabler()
+#endif
+//->
+ );
+
+ //<-
+#if !BOOST_WORKAROUND(__GNUC__, == 2)
+ private:
+ friend class ::boost::iterator_core_access;
+#endif
+
+ typename graph_traits<Graph>::vertex_descriptor& dereference() const;
+
+ void increment();
+ //->
+ };
+
+ //<-
+ template <typename Graph>
+ basic_vertex_insert_iterator<Graph>::basic_vertex_insert_iterator(
+ Graph& graph
+ ) : _graph(graph), _vertex(graph_traits<Graph>::null_vertex())
+ {
+ }
+
+ template <typename Graph>
+ template <typename OtherGraph>
+ basic_vertex_insert_iterator<Graph>::basic_vertex_insert_iterator(
+ basic_vertex_insert_iterator<OtherGraph> const& other
+#ifndef BOOST_NO_SFINAE
+ , typename ::boost::enable_if<
+ ::std::tr1::is_convertible<OtherGraph&,Graph&>
+ , enabler
+ >::type
+#endif
+ ) : _graph(other._graph), _vertex(other._vertex)
+ {
+ }
+
+ template <typename Graph>
+ inline typename graph_traits<Graph>::vertex_descriptor&
+ basic_vertex_insert_iterator<Graph>::dereference() const
+ {
+ return _vertex = add_vertex(_graph);
+ }
+
+ template <typename Graph>
+ inline void basic_vertex_insert_iterator<Graph>::increment()
+ {
+ }
+ //->
+} // namespace boost
+//]
+
+//[reference__basic_vertex_inserter__prototype
+namespace boost {
+
+ template <typename Graph>
+ basic_vertex_insert_iterator<Graph> basic_vertex_inserter(Graph& graph);
+
+ //<-
+ template <typename Graph>
+ inline basic_vertex_insert_iterator<Graph>
+ basic_vertex_inserter(Graph& graph)
+ {
+ return basic_vertex_insert_iterator<Graph>(graph);
+ }
+ //->
+} // namespace boost
+//]
+
+#endif // BOOST_GRAPH_BASIC_VERT_INSERT_ITERATOR_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/detail/default_origin.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/detail/default_origin.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,94 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_DETAIL_DEFAULT_ORIGIN_HPP
+#define BOOST_GRAPH_DETAIL_DEFAULT_ORIGIN_HPP
+
+#include <boost/utility/value_init.hpp>
+
+namespace boost { namespace detail {
+
+ template <typename Point, typename PositionIndexMap, typename Dimension>
+ inline Point&
+ build_default_origin(
+ Point const& point
+ , PositionIndexMap position_index
+ , Dimension const dimension_count
+ )
+ {
+ Point& result = const_cast<Point&>(point);
+
+ for (Dimension dim = initialized_value; dim < dimension_count; ++dim)
+ {
+ result[position_index[dim]] = initialized_value;
+ }
+
+ return result;
+ }
+
+ template <typename Dimension>
+ class default_origin
+ {
+ template <typename PositionIndexMap>
+ class dispatch
+ {
+ Dimension const _dimension_count;
+ PositionIndexMap _position_index;
+
+ public:
+ inline dispatch(
+ Dimension const dimension_count
+ , PositionIndexMap position_index
+ ) : _dimension_count(dimension_count)
+ , _position_index(position_index)
+ {
+ }
+
+ template <typename Point>
+ inline Point& operator()(Point const& point) const
+ {
+ return build_default_origin(
+ point
+ , _position_index
+ , _dimension_count
+ );
+ }
+ };
+
+ Dimension const _dimension_count;
+
+ public:
+ inline explicit default_origin(Dimension const dimension_count)
+ : _dimension_count(dimension_count)
+ {
+ }
+
+ template <typename PositionIndexMap>
+ inline dispatch<PositionIndexMap>
+ operator()(PositionIndexMap position_index) const
+ {
+ return dispatch<
+ PositionIndexMap
+ >(_dimension_count, position_index);
+ }
+ };
+
+ template <typename Dimension>
+ inline default_origin<Dimension>
+ make_default_origin(Dimension const dimension_count)
+ {
+ return default_origin<Dimension>(dimension_count);
+ }
+
+ template <typename DimensionCount>
+ inline default_origin<typename DimensionCount::value_type>
+ make_default_origin_ic(DimensionCount)
+ {
+ return make_default_origin(DimensionCount::value);
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_GRAPH_DETAIL_DEFAULT_ORIGIN_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/detail/default_scale.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/detail/default_scale.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,94 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_DETAIL_DEFAULT_SCALE_HPP
+#define BOOST_GRAPH_DETAIL_DEFAULT_SCALE_HPP
+
+#include <boost/utility/value_init.hpp>
+
+namespace boost { namespace detail {
+
+ template <typename Point, typename PositionIndexMap, typename Dimension>
+ inline Point&
+ build_default_scale(
+ Point const& point
+ , PositionIndexMap position_index
+ , Dimension const dimension_count
+ )
+ {
+ Point& result = const_cast<Point&>(point);
+
+ for (Dimension dim = initialized_value; dim < dimension_count; ++dim)
+ {
+ result[position_index[dim]] = typename Point::value_type(1);
+ }
+
+ return result;
+ }
+
+ template <typename Dimension>
+ class default_scale
+ {
+ template <typename PositionIndexMap>
+ class dispatch
+ {
+ Dimension const _dimension_count;
+ PositionIndexMap _position_index;
+
+ public:
+ inline dispatch(
+ Dimension const dimension_count
+ , PositionIndexMap position_index
+ ) : _dimension_count(dimension_count)
+ , _position_index(position_index)
+ {
+ }
+
+ template <typename Point>
+ inline Point& operator()(Point const& point) const
+ {
+ return build_default_scale(
+ point
+ , _position_index
+ , _dimension_count
+ );
+ }
+ };
+
+ Dimension const _dimension_count;
+
+ public:
+ inline explicit default_scale(Dimension const dimension_count)
+ : _dimension_count(dimension_count)
+ {
+ }
+
+ template <typename PositionIndexMap>
+ inline dispatch<PositionIndexMap>
+ operator()(PositionIndexMap position_index) const
+ {
+ return dispatch<
+ PositionIndexMap
+ >(_dimension_count, position_index);
+ }
+ };
+
+ template <typename Dimension>
+ inline default_scale<Dimension>
+ make_default_scale(Dimension const dimension_count)
+ {
+ return default_scale<Dimension>(dimension_count);
+ }
+
+ template <typename DimensionCount>
+ inline default_scale<typename DimensionCount::value_type>
+ make_default_scale_ic(DimensionCount)
+ {
+ return make_default_scale(DimensionCount::value);
+ }
+}} // namespace boost::detail
+
+#endif // BOOST_GRAPH_DETAIL_DEFAULT_SCALE_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/detail/intrusive_layout_params.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/detail/intrusive_layout_params.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,168 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_DETAIL_INTRUSIVE_LAYOUT_PARAMS_HPP
+#define BOOST_GRAPH_DETAIL_INTRUSIVE_LAYOUT_PARAMS_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/graph/keywords/dimension_count.hpp>
+#include <boost/graph/keywords/dimensions.hpp>
+#include <boost/graph/keywords/has_square_origin.hpp>
+#include <boost/graph/keywords/inscribed_radius.hpp>
+#include <boost/graph/keywords/is_zeta.hpp>
+#include <boost/graph/keywords/origin.hpp>
+#include <boost/graph/keywords/point_factory.hpp>
+#include <boost/graph/keywords/position_index_map.hpp>
+#include <boost/graph/keywords/position_map.hpp>
+#include <boost/graph/keywords/scale.hpp>
+#include <boost/graph/keywords/vertex_centroid_distance.hpp>
+#include <boost/graph/keywords/wraparound_policy.hpp>
+
+#define BOOST_BGL_INTRUSIVE_LAYOUT_DECLARE_PARAMS \
+BOOST_BGL_ONE_PARAM_CREF(dimension_count, dimension_count) \
+BOOST_BGL_ONE_PARAM_CREF(dimensions, dimensions) \
+BOOST_BGL_ONE_PARAM_CREF(has_square_origin, has_square_origin) \
+BOOST_BGL_ONE_PARAM_CREF(inscribed_radius, inscribed_radius) \
+BOOST_BGL_ONE_PARAM_CREF(is_zeta, is_zeta) \
+BOOST_BGL_ONE_PARAM_CREF(origin, origin) \
+BOOST_BGL_ONE_PARAM_CREF(point_factory, point_factory) \
+BOOST_BGL_ONE_PARAM_CREF(position_index_map, position_index_map) \
+BOOST_BGL_ONE_PARAM_CREF(position_map, position_map) \
+BOOST_BGL_ONE_PARAM_CREF(scale, scale) \
+BOOST_BGL_ONE_PARAM_CREF(vertex_centroid_distance, vertex_centroid_distance) \
+BOOST_BGL_ONE_PARAM_CREF(wraparound_policy, wraparound_policy) \
+//
+
+namespace boost {
+ namespace detail {
+
+ template <typename T, typename Tag, typename Base = no_property>
+ struct intrusive_layout_params : Base
+ {
+ typedef intrusive_layout_params self;
+ typedef Base next_type;
+ typedef Tag tag_type;
+ typedef T value_type;
+
+ T m_value;
+
+ intrusive_layout_params(T v = T()) : Base(), m_value(v)
+ {
+ }
+
+ intrusive_layout_params(T v, Base const& b)
+ : Base(b), m_value(v)
+ {
+ }
+
+#define BOOST_BGL_ONE_PARAM_REF(name, key) \
+ template <typename PType> \
+ inline intrusive_layout_params< \
+ ::boost::reference_wrapper<PType> \
+ , BOOST_PP_CAT(key, _t) \
+ , self \
+ > \
+ name(PType& p) const \
+ { \
+ typedef intrusive_layout_params< \
+ ::boost::reference_wrapper<PType> \
+ , BOOST_PP_CAT(key, _t) \
+ , self \
+ > \
+ Params; \
+ return Params(::boost::ref(p), *this); \
+ } \
+//
+
+#define BOOST_BGL_ONE_PARAM_CREF(name, key) \
+ template <typename PType> \
+ inline intrusive_layout_params< \
+ PType \
+ , BOOST_PP_CAT(key, _t) \
+ , self \
+ > \
+ name(PType const& p) const \
+ { \
+ typedef intrusive_layout_params< \
+ PType \
+ , BOOST_PP_CAT(key, _t) \
+ , self \
+ > \
+ Params; \
+ return Params(p, *this); \
+ } \
+//
+
+ BOOST_BGL_INTRUSIVE_LAYOUT_DECLARE_PARAMS
+
+#undef BOOST_BGL_ONE_PARAM_CREF
+#undef BOOST_BGL_ONE_PARAM_REF
+ };
+
+ typedef intrusive_layout_params<char,unused_tag_type>
+ no_intrusive_layout_params;
+
+ template <>
+ struct convert_bgl_params_to_boost_parameter<no_intrusive_layout_params>
+ {
+ typedef ::boost::parameter::aux::empty_arg_list type;
+
+ static type conv(no_property const&)
+ {
+ return type();
+ }
+ };
+ } // namespace detail
+
+ inline detail::no_intrusive_layout_params
+ make_intrusive_layout_params()
+ {
+ return detail::no_intrusive_layout_params();
+ }
+
+#define BOOST_BGL_ONE_PARAM_REF(name, key) \
+ template <typename PType> \
+ inline detail::intrusive_layout_params< \
+ ::boost::reference_wrapper<PType> \
+ , BOOST_PP_CAT(key, _t) \
+ > \
+ name(PType& p) \
+ { \
+ typedef detail::intrusive_layout_params< \
+ ::boost::reference_wrapper<PType> \
+ , BOOST_PP_CAT(key, _t) \
+ > \
+ Params; \
+ return Params(::boost::ref(p)); \
+ } \
+//
+
+#define BOOST_BGL_ONE_PARAM_CREF(name, key) \
+ template <typename PType> \
+ inline detail::intrusive_layout_params< \
+ PType \
+ , BOOST_PP_CAT(key, _t) \
+ > \
+ name(PType const& p) \
+ { \
+ typedef detail::intrusive_layout_params< \
+ PType \
+ , BOOST_PP_CAT(key, _t) \
+ > \
+ Params; \
+ return Params(p); \
+ } \
+//
+
+ BOOST_BGL_INTRUSIVE_LAYOUT_DECLARE_PARAMS
+
+#undef BOOST_BGL_ONE_PARAM_CREF
+#undef BOOST_BGL_ONE_PARAM_REF
+} // namespace boost
+
+#undef BOOST_BGL_INTRUSIVE_LAYOUT_DECLARE_PARAMS
+
+#endif // BOOST_GRAPH_DETAIL_INTRUSIVE_LAYOUT_PARAMS_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/dimension_count.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/dimension_count.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_DIMENSION_COUNT_HPP
+#define BOOST_GRAPH_KEYWORDS_DIMENSION_COUNT_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(dimension_count);
+ }} // namespace graph::keywords
+
+ struct dimension_count_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<dimension_count_t>
+ {
+ typedef boost::graph::keywords::tag::dimension_count type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_DIMENSION_COUNT_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/dimensions.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/dimensions.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_DIMENSIONS_HPP
+#define BOOST_GRAPH_KEYWORDS_DIMENSIONS_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(dimensions);
+ }} // namespace graph::keywords
+
+ struct dimensions_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<dimensions_t>
+ {
+ typedef boost::graph::keywords::tag::dimensions type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_DIMENSIONS_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/edge_function.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/edge_function.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,17 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_EDGE_FUNCTION_HPP
+#define BOOST_GRAPH_KEYWORDS_EDGE_FUNCTION_HPP
+
+#include <boost/parameter/name.hpp>
+
+namespace boost { namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(edge_function);
+}}} // namespace boost::graph::keywords
+
+#endif // BOOST_GRAPH_KEYWORDS_EDGE_FUNCTION_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/has_square_origin.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/has_square_origin.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_HAS_SQUARE_ORIGIN_HPP
+#define BOOST_GRAPH_KEYWORDS_HAS_SQUARE_ORIGIN_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(has_square_origin);
+ }} // namespace graph::keywords
+
+ struct has_square_origin_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<has_square_origin_t>
+ {
+ typedef boost::graph::keywords::tag::has_square_origin type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_HAS_SQUARE_ORIGIN_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/inscribed_radius.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/inscribed_radius.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_INSCRIBED_RADIUS_HPP
+#define BOOST_GRAPH_KEYWORDS_INSCRIBED_RADIUS_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(inscribed_radius);
+ }} // namespace graph::keywords
+
+ struct inscribed_radius_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<inscribed_radius_t>
+ {
+ typedef boost::graph::keywords::tag::inscribed_radius type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_INSCRIBED_RADIUS_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/is_zeta.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/is_zeta.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_IS_ZETA_HPP
+#define BOOST_GRAPH_KEYWORDS_IS_ZETA_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(is_zeta);
+ }} // namespace graph::keywords
+
+ struct is_zeta_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<is_zeta_t>
+ {
+ typedef boost::graph::keywords::tag::is_zeta type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_IS_ZETA_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/origin.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/origin.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_ORIGIN_HPP
+#define BOOST_GRAPH_KEYWORDS_ORIGIN_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(origin);
+ }} // namespace graph::keywords
+
+ struct origin_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<origin_t>
+ {
+ typedef boost::graph::keywords::tag::origin type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_ORIGIN_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/point_factory.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/point_factory.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_POINT_FACTORY_HPP
+#define BOOST_GRAPH_KEYWORDS_POINT_FACTORY_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(point_factory);
+ }} // namespace graph::keywords
+
+ struct point_factory_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<point_factory_t>
+ {
+ typedef boost::graph::keywords::tag::point_factory type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_POINT_FACTORY_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/position_index_map.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/position_index_map.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_POSITION_INDEX_MAP_HPP
+#define BOOST_GRAPH_KEYWORDS_POSITION_INDEX_MAP_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(position_index_map);
+ }} // namespace graph::keywords
+
+ struct position_index_map_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<position_index_map_t>
+ {
+ typedef boost::graph::keywords::tag::position_index_map type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_POSITION_INDEX_MAP_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/position_map.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/position_map.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_POSITION_MAP_HPP
+#define BOOST_GRAPH_KEYWORDS_POSITION_MAP_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(position_map);
+ }} // namespace graph::keywords
+
+ struct position_map_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<position_map_t>
+ {
+ typedef boost::graph::keywords::tag::position_map type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_POSITION_MAP_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/scale.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/scale.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_SCALE_HPP
+#define BOOST_GRAPH_KEYWORDS_SCALE_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(scale);
+ }} // namespace graph::keywords
+
+ struct scale_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<scale_t>
+ {
+ typedef boost::graph::keywords::tag::scale type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_SCALE_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/vertex_centroid_distance.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/vertex_centroid_distance.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_VERTEX_CENTROID_DISTANCE_HPP
+#define BOOST_GRAPH_KEYWORDS_VERTEX_CENTROID_DISTANCE_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(vertex_centroid_distance);
+ }} // namespace graph::keywords
+
+ struct vertex_centroid_distance_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<vertex_centroid_distance_t>
+ {
+ typedef boost::graph::keywords::tag::vertex_centroid_distance type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_VERTEX_CENTROID_DISTANCE_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/vertex_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/vertex_iterator.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,17 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_VERTEX_ITERATOR_HPP
+#define BOOST_GRAPH_KEYWORDS_VERTEX_ITERATOR_HPP
+
+#include <boost/parameter/name.hpp>
+
+namespace boost { namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(vertex_iterator);
+}}} // namespace boost::graph::keywords
+
+#endif // BOOST_GRAPH_KEYWORDS_VERTEX_ITERATOR_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/keywords/wraparound_policy.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/keywords/wraparound_policy.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,33 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_KEYWORDS_WRAPAROUND_POLICY_HPP
+#define BOOST_GRAPH_KEYWORDS_WRAPAROUND_POLICY_HPP
+
+#include <boost/graph/named_function_params.hpp>
+#include <boost/parameter/name.hpp>
+
+namespace boost {
+ namespace graph { namespace keywords {
+
+ BOOST_PARAMETER_NAME(wraparound_policy);
+ }} // namespace graph::keywords
+
+ struct wraparound_policy_t
+ {
+ };
+
+ namespace detail {
+
+ template <>
+ struct convert_one_keyword<wraparound_policy_t>
+ {
+ typedef boost::graph::keywords::tag::wraparound_policy type;
+ };
+ } // namespace detail
+} // namespace boost
+
+#endif // BOOST_GRAPH_KEYWORDS_WRAPAROUND_POLICY_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/set_bitset_grid_layout.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/set_bitset_grid_layout.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,356 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_HPP
+#define BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_HPP
+
+#include <numeric>
+#include <functional>
+#include <vector>
+#include <bitset>
+#include <boost/preprocessor/comparison/less.hpp>
+#include <boost/parameter.hpp>
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/apply_wrap.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/functional/value_factory.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/detail/intrusive_layout_params.hpp>
+#include <boost/graph/keywords/dimension_count.hpp>
+#include <boost/graph/keywords/edge_function.hpp>
+#include <boost/graph/keywords/position_map.hpp>
+#include <boost/graph/keywords/vertex_iterator.hpp>
+#include <boost/detail/metafunction/data_type.hpp>
+
+#if BOOST_PP_LESS(3, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_TAKES_ALL_PARAMS
+#endif
+
+namespace boost {
+ namespace detail {
+
+ template <typename BitSet>
+ struct bitset_grid_layout_bit_count
+ {
+ template <typename BitCount>
+ struct apply
+ {
+ typedef BitCount type;
+ };
+ };
+
+ template < ::std::size_t N>
+ struct bitset_grid_layout_bit_count< ::std::bitset<N> >
+ {
+ template <typename T>
+ struct apply
+ {
+ typedef ::boost::mpl::integral_c< ::std::size_t,N> type;
+ };
+ };
+
+ template <typename PositionMap, typename BitCount>
+ inline ::std::size_t
+ count_bitset_grid_layout_vertices_impl(
+ PositionMap
+ , BitCount
+ )
+ {
+ typedef typename ::boost::property_traits<PositionMap>::value_type
+ PositionMapValue;
+ typedef typename ::boost::mpl::apply_wrap1<
+ bitset_grid_layout_bit_count<PositionMapValue>
+ , BitCount
+ >::type
+ ActualBitCount;
+
+ return 1 << ActualBitCount::value;
+ }
+
+ template <typename BitSet>
+ struct bitset_grid_layout_point_factory
+ {
+ template <typename BitCount>
+ struct apply
+ {
+ struct type
+ {
+ typedef BitSet result_type;
+
+ result_type operator()() const
+ {
+ return result_type(BitCount::value);
+ }
+ };
+ };
+ };
+
+ template < ::std::size_t N>
+ struct bitset_grid_layout_point_factory< ::std::bitset<N> >
+ {
+ template <typename T>
+ struct apply
+ {
+ struct type
+ {
+ typedef ::std::bitset<N> result_type;
+
+ result_type operator()() const
+ {
+ return result_type();
+ }
+ };
+ };
+ };
+
+ template <>
+ struct bitset_grid_layout_point_factory<int>
+ {
+ template <typename BitCount>
+ struct apply
+ {
+ struct type
+ {
+ typedef ::std::bitset<BitCount::value> result_type;
+
+ result_type operator()() const
+ {
+ return result_type();
+ }
+ };
+ };
+ };
+
+ template <
+ typename VertexIterator
+ , typename EdgeAdder
+ , typename PositionMap
+ , typename BitCount
+ >
+ void
+ set_bitset_grid_layout_impl(
+ VertexIterator v_itr
+ , EdgeAdder edge_adder
+ , PositionMap position
+ , BitCount const&
+ )
+ {
+ typedef typename ::boost::iterator_value<VertexIterator>::type
+ Vertex;
+ typedef typename ::boost::property_traits<PositionMap>::value_type
+ PositionMapValue;
+ typedef typename ::boost::mpl::apply_wrap1<
+ bitset_grid_layout_bit_count<PositionMapValue>
+ , BitCount
+ >::type
+ ActualBitCount;
+ typedef typename ::boost::mpl::apply_wrap1<
+ bitset_grid_layout_point_factory<PositionMapValue>
+ , BitCount
+ >::type
+ BitSetFactory;
+ typedef typename BitSetFactory::result_type
+ BitSet;
+ ::std::size_t const bit_count = ActualBitCount::value;
+ BOOST_STATIC_ASSERT((1 < bit_count));
+ ::std::size_t const vert_count = 1 << bit_count;
+ typedef ::boost::multi_array<Vertex,bit_count> VertexArray;
+ typedef typename VertexArray::index VAI;
+ typedef ::boost::array<VAI,bit_count> Index;
+
+ Index size;
+
+ for (::std::size_t bit_index = 0; bit_index < bit_count; ++bit_index)
+ {
+ size[bit_index] = bit_count;
+ }
+
+ VertexArray vertex_array(size);
+ ::std::vector<Index> indices(1 << bit_count);
+ Index index;
+ typename ::std::vector<Index>::iterator i_itr, i_end = indices.end();
+
+ for (::std::size_t bit_index = 0; bit_index < bit_count; ++bit_index)
+ {
+ index[bit_index] = 0;
+ }
+
+ BitSetFactory bitset_factory;
+
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr, ++v_itr)
+ {
+ BitSet bit_set = bitset_factory();
+ ::std::size_t bit_index = 0;
+
+ while (bit_index < bit_count)
+ {
+ bit_set[bit_index] = index[bit_index] ? true : false;
+ ++bit_index;
+ }
+
+ put(position, vertex_array(*i_itr = index) = *v_itr, bit_set);
+
+ for (
+ ++index[--bit_index];
+ bit_index && (index[bit_index] == 2);
+ ++index[--bit_index]
+ )
+ {
+ index[bit_index] = 0;
+ }
+ }
+
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr)
+ {
+ for (
+ ::std::size_t bit_index = 0;
+ bit_index < bit_count;
+ ++bit_index
+ )
+ {
+ index = *i_itr;
+
+ if (!index[bit_index])
+ {
+ index[bit_index] = 1;
+ edge_adder(vertex_array(*i_itr), vertex_array(index));
+ }
+ }
+ }
+ }
+ } // namespace detail
+
+ template <typename T, typename Tag, typename Base>
+ inline ::std::size_t
+ count_bitset_grid_layout_vertices(
+ detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimension_count
+ , ::boost::mpl::integral_c< ::std::size_t,0>
+ >::type
+ >::type
+ BitCount;
+
+ return detail::count_bitset_grid_layout_vertices_impl(
+ position_map
+ , arg_pack[
+ ::boost::graph::keywords::_dimension_count
+ || value_factory<BitCount>()
+ ]
+ );
+ }
+
+#if BOOST_PP_LESS(1, BOOST_PARAMETER_MAX_ARITY)
+ BOOST_PARAMETER_FUNCTION(
+ (::std::size_t)
+ , count_bitset_grid_layout_vertices
+ , ::boost::graph::keywords::tag
+ , (deduced
+ (optional
+ (position_map
+ , *(is_property_map< ::boost::mpl::_>)
+ , dummy_property_map()
+ )
+ (dimension_count
+ , *(::boost::mpl::not_<is_property_map< ::boost::mpl::_> >)
+ , (::boost::mpl::integral_c< ::std::size_t,0>())
+ )
+ )
+ )
+ )
+ {
+ return detail::count_bitset_grid_layout_vertices_impl(
+ position_map
+ , dimension_count
+ );
+ }
+#endif // 1 < BOOST_PARAMETER_MAX_ARITY
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename T
+ , typename Tag
+ , typename Base
+ >
+ inline void
+ set_bitset_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimension_count
+ , ::boost::mpl::integral_c< ::std::size_t,0>
+ >::type
+ >::type
+ BitCount;
+
+ detail::set_bitset_grid_layout_impl(
+ vertex_iterator
+ , edge_function
+ , arg_pack[
+ ::boost::graph::keywords::_position_map
+ || value_factory<dummy_property_map>()
+ ]
+ , arg_pack[
+ ::boost::graph::keywords::_dimension_count
+ || value_factory<BitCount>()
+ ]
+ );
+ }
+
+#if defined(BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_TAKES_ALL_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_bitset_grid_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ )
+ (deduced
+ (optional
+ (position_map
+ , *(is_property_map< ::boost::mpl::_>)
+ , dummy_property_map()
+ )
+ (dimension_count
+ , *(::boost::mpl::not_<is_property_map< ::boost::mpl::_> >)
+ , (::boost::mpl::integral_c< ::std::size_t,0>())
+ )
+ )
+ )
+ )
+ {
+ detail::set_bitset_grid_layout_impl(
+ vertex_iterator
+ , edge_function
+ , position_map
+ , dimension_count
+ );
+ return true;
+ }
+#endif // BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_TAKES_ALL_PARAMS
+} // namespace boost
+
+#endif // BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/set_bt_cubic_hcomb_layout.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/set_bt_cubic_hcomb_layout.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,597 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_SET_BT_CUBIC_HCOMB_LAYOUT_HPP
+#define BOOST_GRAPH_SET_BT_CUBIC_HCOMB_LAYOUT_HPP
+
+#include <numeric>
+#include <functional>
+#include <vector>
+#include <boost/preprocessor/comparison/less.hpp>
+#include <boost/parameter.hpp>
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/functional/value_factory.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/detail/intrusive_layout_params.hpp>
+#include <boost/graph/keywords/dimensions.hpp>
+#include <boost/graph/keywords/edge_function.hpp>
+#include <boost/graph/keywords/inscribed_radius.hpp>
+#include <boost/graph/keywords/origin.hpp>
+#include <boost/graph/keywords/point_factory.hpp>
+#include <boost/graph/keywords/position_map.hpp>
+#include <boost/graph/keywords/vertex_iterator.hpp>
+#include <boost/graph/keywords/wraparound_policy.hpp>
+#include <boost/detail/metafunction/data_type.hpp>
+#include <boost/detail/index_predicate.hpp>
+#include <boost/detail/make_value_factory.hpp>
+#include <boost/graph/detail/default_origin.hpp>
+
+#if BOOST_PP_LESS(8, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+#elif BOOST_PP_LESS(4, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_5_PARAMS
+#endif
+
+namespace boost {
+ namespace detail {
+
+ template <typename PositionIndexMap, typename Scalar, typename Dimensions>
+ ::std::size_t
+ count_bitruncated_cubic_honeycomb_layout_vertices_impl(
+ PositionIndexMap position_index
+ , Scalar inscribed_radius
+ , Dimensions const& dimensions
+ )
+ {
+ ::std::size_t const dim_count = 3;
+ Scalar const inscribed_diameter = inscribed_radius * 2;
+
+ ::boost::array< ::std::size_t,dim_count> size_1, size_2;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ size_1[dim] = static_cast< ::std::size_t>(
+ (dimensions[dim] + inscribed_radius) / inscribed_diameter
+ );
+ size_2[dim] = static_cast< ::std::size_t>(
+ dimensions[dim] / inscribed_diameter
+ );
+ }
+
+ return ::std::accumulate(
+ size_1.begin()
+ , size_1.end()
+ , 1
+ , ::std::multiplies< ::std::size_t>()
+ ) + ::std::accumulate(
+ size_2.begin()
+ , size_2.end()
+ , 1
+ , ::std::multiplies< ::std::size_t>()
+ );
+ }
+
+ template <
+ typename VertexIterator
+ , typename EdgeAdder
+ , typename PositionMap
+ , typename PositionIndexMap
+ , typename Scalar
+ , typename Dimensions
+ , typename Point
+ , typename PointFactory
+ , typename WraparoundPolicy
+ >
+ void
+ set_bitruncated_cubic_honeycomb_layout_impl(
+ VertexIterator v_itr
+ , EdgeAdder edge_adder
+ , PositionMap position
+ , PositionIndexMap position_index
+ , Scalar inscribed_radius
+ , Dimensions const& dimensions
+ , Point const& origin
+ , PointFactory point_factory
+ , WraparoundPolicy const& wraparound_policy
+ )
+ {
+ typedef typename ::boost::iterator_value<VertexIterator>::type Vertex;
+ ::std::size_t const dim_count = 3;
+ typedef ::boost::multi_array<Vertex,dim_count> VertexArray;
+ typedef typename VertexArray::index VAI;
+ typedef ::boost::array<VAI,dim_count> Index;
+
+ Scalar const inscribed_diameter = inscribed_radius * 2;
+ Index size_1, size_2;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ size_1[dim] = static_cast< ::std::size_t>(
+ (dimensions[dim] + inscribed_radius) / inscribed_diameter
+ );
+ size_2[dim] = static_cast< ::std::size_t>(
+ dimensions[dim] / inscribed_diameter
+ );
+ }
+
+ VertexArray vertex_array_1(size_1);
+ VertexArray vertex_array_2(size_2);
+ ::std::vector<Index> indices_1(
+ ::std::accumulate(
+ size_1.begin()
+ , size_1.end()
+ , 1
+ , ::std::multiplies<VAI>()
+ )
+ );
+ ::std::vector<Index> indices_2(
+ ::std::accumulate(
+ size_2.begin()
+ , size_2.end()
+ , 1
+ , ::std::multiplies<VAI>()
+ )
+ );
+ Index index;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ index[position_index[dim_index]] = 0;
+ }
+
+ typename ::std::vector<Index>::iterator i_itr;
+ typename ::std::vector<Index>::iterator i_1_end = indices_1.end();
+
+ for (i_itr = indices_1.begin(); i_itr != i_1_end; ++i_itr, ++v_itr)
+ {
+ Point point = point_factory();
+ ::std::size_t dim_index = 0;
+
+ while (dim_index < dim_count)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ point[dim] = inscribed_diameter * index[dim] + origin[dim];
+ ++dim_index;
+ }
+
+ put(position, vertex_array_1(*i_itr = index) = *v_itr, point);
+
+ for (
+ ++index[position_index[--dim_index]];
+ dim_index && (
+ index[position_index[dim_index]]
+ == size_1[position_index[dim_index]]
+ );
+ ++index[position_index[--dim_index]]
+ )
+ {
+ index[position_index[dim_index]] = 0;
+ }
+ }
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ index[position_index[dim_index]] = 0;
+ }
+
+ typename ::std::vector<Index>::iterator i_2_end = indices_2.end();
+
+ for (i_itr = indices_2.begin(); i_itr != i_2_end; ++i_itr, ++v_itr)
+ {
+ Point point = point_factory();
+ ::std::size_t dim_index = 0;
+
+ while (dim_index < dim_count)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ point[dim] = (
+ inscribed_diameter * index[dim]
+ + origin[dim]
+ + inscribed_radius
+ );
+ ++dim_index;
+ }
+
+ put(position, vertex_array_2(*i_itr = index) = *v_itr, point);
+
+ for (
+ ++index[position_index[--dim_index]];
+ dim_index && (
+ index[position_index[dim_index]]
+ == size_2[position_index[dim_index]]
+ );
+ ++index[position_index[--dim_index]]
+ )
+ {
+ index[position_index[dim_index]] = 0;
+ }
+ }
+
+ bool add_diagonal;
+
+ for (i_itr = indices_1.begin(); i_itr != i_1_end; ++i_itr)
+ {
+ index = *i_itr;
+ add_diagonal = true;
+
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ if (add_diagonal && (index[dim] == size_2[dim]))
+ {
+ add_diagonal = false;
+ }
+ }
+
+ if (add_diagonal)
+ {
+ edge_adder(vertex_array_1(index), vertex_array_2(index));
+ }
+ }
+
+ for (i_itr = indices_2.begin(); i_itr != i_2_end; ++i_itr)
+ {
+ index = *i_itr;
+ add_diagonal = true;
+
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ if (++index[dim] == size_1[dim])
+ {
+ if (wraparound_policy[dim])
+ {
+ index[dim] = 0;
+ }
+ else
+ {
+ add_diagonal = false;
+ }
+ }
+ }
+
+ if (add_diagonal)
+ {
+ edge_adder(vertex_array_2(*i_itr), vertex_array_1(index));
+ }
+ }
+
+ for (i_itr = indices_1.begin(); i_itr != i_1_end; ++i_itr)
+ {
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ index = *i_itr;
+
+ if (++index[dim] == size_1[dim])
+ {
+ if (wraparound_policy[dim])
+ {
+ index[dim] = 0;
+ edge_adder(
+ vertex_array_1(*i_itr)
+ , vertex_array_1(index)
+ );
+ }
+ }
+ else
+ {
+ edge_adder(vertex_array_1(*i_itr), vertex_array_1(index));
+ }
+ }
+ }
+
+ Index other_index;
+
+ for (i_itr = indices_2.begin(); i_itr != i_2_end; ++i_itr)
+ {
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ index = *i_itr;
+ add_diagonal = false;
+
+ if (++index[dim] == size_2[dim])
+ {
+ if (wraparound_policy[dim] && (size_1[dim] == size_2[dim]))
+ {
+ index[dim] = 0;
+ edge_adder(
+ vertex_array_2(*i_itr)
+ , vertex_array_2(index)
+ );
+ edge_adder(
+ vertex_array_2(*i_itr)
+ , vertex_array_1(index)
+ );
+ add_diagonal = true;
+ }
+ }
+ else
+ {
+ edge_adder(vertex_array_2(*i_itr), vertex_array_2(index));
+ edge_adder(vertex_array_2(*i_itr), vertex_array_1(index));
+ add_diagonal = true;
+ }
+
+ if (add_diagonal)
+ {
+ for (
+ ::std::size_t dim_index2 = dim_index + 1;
+ dim_index2 < dim_count;
+ ++dim_index2
+ )
+ {
+ ::std::size_t const dim2 = position_index[dim_index2];
+
+ other_index = index;
+
+ if (++other_index[dim2] == size_2[dim2])
+ {
+ if (
+ wraparound_policy[dim2]
+ && (size_1[dim2] == size_2[dim2])
+ )
+ {
+ other_index[dim2] = 0;
+ edge_adder(
+ vertex_array_1(other_index)
+ , vertex_array_2(*i_itr)
+ );
+ }
+ }
+ else
+ {
+ edge_adder(
+ vertex_array_1(other_index)
+ , vertex_array_2(*i_itr)
+ );
+ }
+ }
+ }
+ }
+ }
+ }
+ } // namespace detail
+
+ template <typename T, typename Tag, typename Base>
+ inline ::std::size_t
+ count_bitruncated_cubic_honeycomb_layout_vertices(
+ detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ return detail::count_bitruncated_cubic_honeycomb_layout_vertices_impl(
+ arg_pack[
+ ::boost::graph::keywords::_position_index_map
+ || value_factory<identity_property_map>()
+ ]
+ , arg_pack[::boost::graph::keywords::_inscribed_radius | 1]
+ , arg_pack[::boost::graph::keywords::_dimensions]
+ );
+ }
+
+#if BOOST_PP_LESS(2, BOOST_PARAMETER_MAX_ARITY)
+ BOOST_PARAMETER_FUNCTION(
+ (::std::size_t)
+ , count_bitruncated_cubic_honeycomb_layout_vertices
+ , ::boost::graph::keywords::tag
+ , (required
+ (dimensions, *)
+ )
+ (optional
+ (inscribed_radius
+ , *
+ , 1
+ )
+ (position_index_map
+ , *
+ , identity_property_map()
+ )
+ )
+ )
+ {
+ return detail::count_bitruncated_cubic_honeycomb_layout_vertices_impl(
+ position_index_map
+ , inscribed_radius
+ , dimensions
+ );
+ }
+#endif // 2 < BOOST_PARAMETER_MAX_ARITY
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename T
+ , typename Tag
+ , typename Base
+ >
+ inline void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::position_index_map
+ , identity_property_map
+ >::type
+ PositionIndexMap;
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimensions
+ >::type
+ >::type
+ Point;
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::point_factory
+ , value_factory<Point>
+ >::type
+ PointFactory;
+
+ PointFactory point_factory = arg_pack[
+ ::boost::graph::keywords::_point_factory
+ || value_factory<value_factory<Point> >()
+ ];
+ PositionIndexMap position_index = arg_pack[
+ ::boost::graph::keywords::_position_index_map
+ || value_factory<identity_property_map>()
+ ];
+
+ detail::set_bitruncated_cubic_honeycomb_layout_impl(
+ vertex_iterator
+ , edge_function
+ , arg_pack[
+ ::boost::graph::keywords::_position_map
+ || value_factory<dummy_property_map>()
+ ]
+ , position_index
+ , arg_pack[::boost::graph::keywords::_inscribed_radius | 1]
+ , arg_pack[::boost::graph::keywords::_dimensions]
+ , arg_pack[
+ ::boost::graph::keywords::_origin
+ | detail::build_default_origin(
+ point_factory()
+ , position_index
+ , 3
+ )
+ ]
+ , point_factory
+ , arg_pack[
+ ::boost::graph::keywords::_wraparound_policy
+ | detail::index_predicate<false>()
+ ]
+ );
+ }
+
+#if defined(BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_bitruncated_cubic_honeycomb_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ (dimensions, *)
+ )
+ (optional
+ (inscribed_radius
+ , *
+ , 1
+ )
+ (wraparound_policy
+ , *
+ , detail::index_predicate<false>()
+ )
+ (point_factory
+ , *
+ , detail::make_value_factory(dimensions)
+ )
+ (position_index_map
+ , *
+ , identity_property_map()
+ )
+ (position_map
+ , *
+ , dummy_property_map()
+ )
+ (origin
+ , *
+ , detail::make_default_origin
+ (3)(position_index_map)(point_factory())
+ )
+ )
+ )
+ {
+ detail::set_bitruncated_cubic_honeycomb_layout_impl(
+ vertex_iterator
+ , edge_function
+ , position_map
+ , position_index_map
+ , inscribed_radius
+ , dimensions
+ , origin
+ , point_factory
+ , wraparound_policy
+ );
+ return true;
+ }
+#elif defined(BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_5_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_bitruncated_cubic_honeycomb_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ (dimensions, *)
+ )
+ (optional
+ (inscribed_radius
+ , *
+ , 1
+ )
+ (wraparound_policy
+ , *
+ , detail::index_predicate<false>()
+ )
+ )
+ )
+ {
+ set_bitruncated_cubic_honeycomb_layout(
+ vertex_iterator
+ , edge_function
+ , make_intrusive_layout_params().dimensions(
+ dimensions
+ ).inscribed_radius(
+ inscribed_radius
+ ).wraparound_policy(
+ wraparound_policy
+ )
+ );
+ return true;
+ }
+#endif // BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_*_PARAMS
+} // namespace boost
+
+#endif // BOOST_GRAPH_SET_BT_CUBIC_HCOMB_LAYOUT_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/set_orthogonal_grid_layout.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/set_orthogonal_grid_layout.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,590 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_HPP
+#define BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_HPP
+
+#include <numeric>
+#include <functional>
+#include <vector>
+#include <boost/preprocessor/comparison/less.hpp>
+#include <boost/parameter.hpp>
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/functional/value_factory.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/detail/intrusive_layout_params.hpp>
+#include <boost/graph/keywords/dimensions.hpp>
+#include <boost/graph/keywords/dimension_count.hpp>
+#include <boost/graph/keywords/edge_function.hpp>
+#include <boost/graph/keywords/is_zeta.hpp>
+#include <boost/graph/keywords/origin.hpp>
+#include <boost/graph/keywords/point_factory.hpp>
+#include <boost/graph/keywords/position_map.hpp>
+#include <boost/graph/keywords/scale.hpp>
+#include <boost/graph/keywords/vertex_iterator.hpp>
+#include <boost/graph/keywords/wraparound_policy.hpp>
+#include <boost/detail/metafunction/data_type.hpp>
+#include <boost/detail/index_predicate.hpp>
+#include <boost/detail/make_value_factory.hpp>
+#include <boost/graph/detail/default_scale.hpp>
+#include <boost/graph/detail/default_origin.hpp>
+
+#if BOOST_PP_LESS(10, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_ALL_PARAMS
+#elif BOOST_PP_LESS(4, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_5_PARAMS
+#endif
+
+namespace boost {
+ namespace detail {
+
+ template <
+ typename PositionIndexMap
+ , typename Dimensions
+ , typename Scale
+ , typename DimensionCount
+ >
+ ::std::size_t
+ count_orthogonal_grid_layout_vertices_impl(
+ PositionIndexMap position_index
+ , Dimensions const& dimensions
+ , Scale const& scale
+ , DimensionCount const&
+ )
+ {
+ ::std::size_t const dim_count = DimensionCount::value;
+ BOOST_STATIC_ASSERT((1 < dim_count));
+
+ ::boost::array< ::std::size_t,dim_count> size;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ size[dim] = static_cast< ::std::size_t>(
+ dimensions[dim] / scale[dim]
+ );
+ }
+
+ return ::std::accumulate(
+ size.begin()
+ , size.end()
+ , 1
+ , ::std::multiplies< ::std::size_t>()
+ );
+ }
+
+ template <
+ typename VertexIterator
+ , typename EdgeAdder
+ , typename PositionMap
+ , typename PositionIndexMap
+ , typename Dimensions
+ , typename Scale
+ , typename Point
+ , typename DimensionCount
+ , typename PointFactory
+ , typename WraparoundPolicy
+ >
+ void
+ set_orthogonal_grid_layout_impl(
+ VertexIterator v_itr
+ , EdgeAdder edge_adder
+ , bool is_zeta
+ , PositionMap position
+ , PositionIndexMap position_index
+ , Dimensions const& dimensions
+ , Scale const& scale
+ , Point const& origin
+ , DimensionCount const&
+ , PointFactory point_factory
+ , WraparoundPolicy const& wraparound_policy
+ )
+ {
+ typedef typename ::boost::iterator_value<VertexIterator>::type Vertex;
+ ::std::size_t const dim_count = DimensionCount::value;
+ BOOST_STATIC_ASSERT((1 < dim_count));
+ typedef ::boost::multi_array<Vertex,dim_count> VertexArray;
+ typedef typename VertexArray::index VAI;
+ typedef ::boost::array<VAI,dim_count> Index;
+
+ Index size;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ size[dim] = static_cast< ::std::size_t>(
+ dimensions[dim] / scale[dim]
+ );
+ }
+
+ VertexArray vertex_array(size);
+ ::std::vector<Index> indices(
+ ::std::accumulate(
+ size.begin()
+ , size.end()
+ , 1
+ , ::std::multiplies<VAI>()
+ )
+ );
+ Index index;
+ typename ::std::vector<Index>::iterator i_itr, i_end = indices.end();
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ index[position_index[dim_index]] = 0;
+ }
+
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr, ++v_itr)
+ {
+ Point point = point_factory();
+ ::std::size_t dim_index = 0;
+
+ while (dim_index < dim_count)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ point[dim] = scale[dim] * index[dim] + origin[dim];
+ ++dim_index;
+ }
+
+ put(position, vertex_array(*i_itr = index) = *v_itr, point);
+
+ for (
+ ++index[position_index[--dim_index]];
+ dim_index && (
+ index[position_index[dim_index]]
+ == size[position_index[dim_index]]
+ );
+ ++index[position_index[--dim_index]]
+ )
+ {
+ index[position_index[dim_index]] = 0;
+ }
+ }
+
+ if (is_zeta)
+ {
+ ::std::size_t neighbor_count = 1;
+
+ for (::std::size_t dim = 0; dim < dim_count; ++dim)
+ {
+ neighbor_count *= 3;
+ }
+
+ neighbor_count >>= 1;
+
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr)
+ {
+ for (::std::size_t neighbor_index = neighbor_count;;)
+ {
+ bool can_add_edge = true, is_not_loop_edge = false;
+ std::size_t neighbor_mod = neighbor_index;
+
+ index = *i_itr;
+
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ switch (neighbor_mod % 3)
+ {
+ case 0:
+ {
+ if (index[dim])
+ {
+ --index[dim];
+ is_not_loop_edge = true;
+ }
+ else if (wraparound_policy[dim])
+ {
+ index[dim] = size[dim] - 1;
+ is_not_loop_edge = true;
+ }
+ else
+ {
+ can_add_edge = false;
+ }
+
+ break;
+ }
+
+ case 2:
+ {
+ if (++index[dim] == size[dim])
+ {
+ if (wraparound_policy[dim])
+ {
+ index[dim] = 0;
+ is_not_loop_edge = true;
+ }
+ else
+ {
+ can_add_edge = false;
+ }
+ }
+ else
+ {
+ is_not_loop_edge = true;
+ }
+
+ break;
+ }
+ }
+
+ neighbor_mod /= 3;
+ }
+
+ if (can_add_edge && is_not_loop_edge)
+ {
+ edge_adder(vertex_array(*i_itr), vertex_array(index));
+ }
+
+ if (neighbor_index)
+ {
+ --neighbor_index;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr)
+ {
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ index = *i_itr;
+
+ if (++index[dim] == size[dim])
+ {
+ index[dim] = 0;
+
+ if (wraparound_policy[dim])
+ {
+ edge_adder(
+ vertex_array(*i_itr)
+ , vertex_array(index)
+ );
+ }
+ }
+ else
+ {
+ edge_adder(vertex_array(*i_itr), vertex_array(index));
+ }
+ }
+ }
+ }
+ }
+ } // namespace detail
+
+ template <typename T, typename Tag, typename Base>
+ inline ::std::size_t
+ count_orthogonal_grid_layout_vertices(
+ detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::position_index_map
+ , identity_property_map
+ >::type
+ PositionIndexMap;
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimensions
+ >::type
+ >::type
+ Point;
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimension_count
+ , ::boost::mpl::integral_c< ::std::size_t,2>
+ >::type
+ >::type
+ DimensionCount;
+
+ PositionIndexMap position_index = arg_pack[
+ ::boost::graph::keywords::_position_index_map
+ || value_factory<identity_property_map>()
+ ];
+
+ return detail::count_orthogonal_grid_layout_vertices_impl(
+ position_index
+ , arg_pack[::boost::graph::keywords::_dimensions]
+ , arg_pack[
+ ::boost::graph::keywords::_scale
+ | detail::build_default_scale(
+ arg_pack[
+ ::boost::graph::keywords::_point_factory
+ || value_factory<value_factory<Point> >()
+ ]()
+ , position_index
+ , DimensionCount::value
+ )
+ ]
+ , arg_pack[
+ ::boost::graph::keywords::_dimension_count
+ || value_factory<DimensionCount>()
+ ]
+ );
+ }
+
+#if BOOST_PP_LESS(4, BOOST_PARAMETER_MAX_ARITY)
+ BOOST_PARAMETER_FUNCTION(
+ (::std::size_t)
+ , count_orthogonal_grid_layout_vertices
+ , ::boost::graph::keywords::tag
+ , (required
+ (dimensions, *)
+ )
+ (optional
+ (dimension_count
+ , *
+ , (::boost::mpl::integral_c< ::std::size_t,2>())
+ )
+ (point_factory
+ , *
+ , detail::make_value_factory(dimensions)
+ )
+ (position_index_map
+ , *
+ , identity_property_map()
+ )
+ (scale
+ , *
+ , detail::make_default_scale_ic
+ (dimension_count)(position_index_map)(point_factory())
+ )
+ )
+ )
+ {
+ return detail::count_orthogonal_grid_layout_vertices_impl(
+ position_index_map
+ , dimensions
+ , scale
+ , dimension_count
+ );
+ }
+#endif // 4 < BOOST_PARAMETER_MAX_ARITY
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename T
+ , typename Tag
+ , typename Base
+ >
+ inline void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::position_index_map
+ , identity_property_map
+ >::type
+ PositionIndexMap;
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimensions
+ >::type
+ >::type
+ Point;
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::point_factory
+ , value_factory<Point>
+ >::type
+ PointFactory;
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimension_count
+ , ::boost::mpl::integral_c< ::std::size_t,2>
+ >::type
+ >::type
+ DimensionCount;
+
+ PointFactory point_factory = arg_pack[
+ ::boost::graph::keywords::_point_factory
+ || value_factory<value_factory<Point> >()
+ ];
+ PositionIndexMap position_index = arg_pack[
+ ::boost::graph::keywords::_position_index_map
+ || value_factory<boost::identity_property_map>()
+ ];
+
+ detail::set_orthogonal_grid_layout_impl(
+ vertex_iterator
+ , edge_function
+ , arg_pack[::boost::graph::keywords::_is_zeta | false]
+ , arg_pack[
+ ::boost::graph::keywords::_position_map
+ || value_factory<dummy_property_map>()
+ ]
+ , position_index
+ , arg_pack[::boost::graph::keywords::_dimensions]
+ , arg_pack[
+ ::boost::graph::keywords::_scale
+ | detail::build_default_scale(
+ point_factory()
+ , position_index
+ , DimensionCount::value
+ )
+ ]
+ , arg_pack[
+ ::boost::graph::keywords::_origin
+ | detail::build_default_origin(
+ point_factory()
+ , position_index
+ , DimensionCount::value
+ )
+ ]
+ , arg_pack[
+ ::boost::graph::keywords::_dimension_count
+ || value_factory<DimensionCount>()
+ ]
+ , point_factory
+ , arg_pack[
+ ::boost::graph::keywords::_wraparound_policy
+ | detail::index_predicate<false>()
+ ]
+ );
+ }
+
+#if defined(BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_ALL_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_orthogonal_grid_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ (dimensions, *)
+ )
+ (optional
+ (dimension_count
+ , *
+ , (::boost::mpl::integral_c< ::std::size_t,2>())
+ )
+ (is_zeta
+ , *
+ , false
+ )
+ (wraparound_policy
+ , *
+ , detail::index_predicate<false>()
+ )
+ (point_factory
+ , *
+ , detail::make_value_factory(dimensions)
+ )
+ (position_index_map
+ , *
+ , identity_property_map()
+ )
+ (scale
+ , *
+ , detail::make_default_scale_ic
+ (dimension_count)(position_index_map)(point_factory())
+ )
+ (position_map
+ , *
+ , dummy_property_map()
+ )
+ (origin
+ , *
+ , detail::make_default_origin_ic
+ (dimension_count)(position_index_map)(point_factory())
+ )
+ )
+ )
+ {
+ detail::set_orthogonal_grid_layout_impl(
+ vertex_iterator
+ , edge_function
+ , is_zeta
+ , position_map
+ , position_index_map
+ , dimensions
+ , scale
+ , origin
+ , dimension_count
+ , point_factory
+ , wraparound_policy
+ );
+ return true;
+ }
+#elif defined(BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_5_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_orthogonal_grid_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ (dimensions, *)
+ )
+ (optional
+ (dimension_count
+ , *
+ , (::boost::mpl::integral_c< ::std::size_t,2>())
+ )
+ (is_zeta
+ , *
+ , false
+ )
+ )
+ )
+ {
+ set_orthogonal_grid_layout(
+ vertex_iterator
+ , edge_function
+ , make_intrusive_layout_params().dimensions(
+ dimensions
+ ).dimension_count(
+ dimension_count
+ ).is_zeta(
+ is_zeta
+ )
+ );
+ return true;
+ }
+#endif // BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_*_PARAMS
+} // namespace boost
+
+#endif // BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_HPP
+

Added: sandbox/graph-intrusive_layout/boost/graph/set_upsilon_tessel_layout.hpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/boost/graph/set_upsilon_tessel_layout.hpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,535 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#ifndef BOOST_GRAPH_SET_UPSILON_TESSEL_LAYOUT_HPP
+#define BOOST_GRAPH_SET_UPSILON_TESSEL_LAYOUT_HPP
+
+#include <numeric>
+#include <functional>
+#include <vector>
+#include <boost/preprocessor/comparison/less.hpp>
+#include <boost/parameter.hpp>
+#include <boost/parameter/preprocessor.hpp>
+#include <boost/tr1/type_traits.hpp>
+#include <boost/functional/value_factory.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/array.hpp>
+#include <boost/multi_array.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/detail/intrusive_layout_params.hpp>
+#include <boost/graph/keywords/dimensions.hpp>
+#include <boost/graph/keywords/edge_function.hpp>
+#include <boost/graph/keywords/has_square_origin.hpp>
+#include <boost/graph/keywords/origin.hpp>
+#include <boost/graph/keywords/point_factory.hpp>
+#include <boost/graph/keywords/position_map.hpp>
+#include <boost/graph/keywords/vertex_centroid_distance.hpp>
+#include <boost/graph/keywords/vertex_iterator.hpp>
+#include <boost/graph/keywords/wraparound_policy.hpp>
+#include <boost/detail/metafunction/data_type.hpp>
+#include <boost/detail/index_predicate.hpp>
+#include <boost/detail/make_value_factory.hpp>
+#include <boost/graph/detail/default_origin.hpp>
+
+#if BOOST_PP_LESS(9, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_ALL_PARAMS
+#elif BOOST_PP_LESS(4, BOOST_PARAMETER_MAX_ARITY)
+#define BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_5_PARAMS
+#endif
+
+namespace boost {
+ namespace detail {
+
+ template <typename PositionIndexMap, typename Scalar, typename Dimensions>
+ ::std::size_t
+ count_upsilon_tessellation_layout_vertices_impl(
+ PositionIndexMap position_index
+ , Scalar vertex_centroid_distance
+ , Dimensions const& dimensions
+ )
+ {
+ ::std::size_t const dim_count = 2;
+
+ ::boost::array< ::std::size_t,dim_count> size;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ size[dim] = static_cast< ::std::size_t>(
+ dimensions[dim] / vertex_centroid_distance
+ );
+ }
+
+ return ::std::accumulate(
+ size.begin()
+ , size.end()
+ , 1
+ , ::std::multiplies< ::std::size_t>()
+ );
+ }
+
+ template <
+ typename VertexIterator
+ , typename EdgeAdder
+ , typename PositionMap
+ , typename PositionIndexMap
+ , typename Scalar
+ , typename Dimensions
+ , typename Point
+ , typename PointFactory
+ , typename WraparoundPolicy
+ >
+ void
+ set_upsilon_tessellation_layout_impl(
+ VertexIterator v_itr
+ , EdgeAdder edge_adder
+ , bool has_square_origin
+ , PositionMap position
+ , PositionIndexMap position_index
+ , Scalar vertex_centroid_distance
+ , Dimensions const& dimensions
+ , Point const& origin
+ , PointFactory point_factory
+ , WraparoundPolicy const& wraparound_policy
+ )
+ {
+ typedef typename ::boost::iterator_value<VertexIterator>::type Vertex;
+ ::std::size_t const dim_count = 2;
+ typedef ::boost::multi_array<Vertex,dim_count> VertexArray;
+ typedef typename VertexArray::index VAI;
+ typedef ::boost::array<VAI,dim_count> Index;
+
+ Index size;
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ size[dim] = static_cast< ::std::size_t>(
+ dimensions[dim] / vertex_centroid_distance
+ );
+ }
+
+ VertexArray vertex_array(size);
+ ::std::vector<Index> indices(
+ ::std::accumulate(
+ size.begin()
+ , size.end()
+ , 1
+ , ::std::multiplies<VAI>()
+ )
+ );
+ Index index;
+ typename ::std::vector<Index>::iterator i_itr, i_end = indices.end();
+
+ for (::std::size_t dim_index = 0; dim_index < dim_count; ++dim_index)
+ {
+ index[position_index[dim_index]] = 0;
+ }
+
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr, ++v_itr)
+ {
+ Point point = point_factory();
+ ::std::size_t dim_index = 0;
+
+ while (dim_index < dim_count)
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ point[dim] = (
+ vertex_centroid_distance * index[dim] + origin[dim]
+ );
+ ++dim_index;
+ }
+
+ put(position, vertex_array(*i_itr = index) = *v_itr, point);
+
+ for (
+ ++index[position_index[--dim_index]];
+ dim_index && (
+ index[position_index[dim_index]]
+ == size[position_index[dim_index]]
+ );
+ ++index[position_index[--dim_index]]
+ )
+ {
+ index[position_index[dim_index]] = 0;
+ }
+ }
+
+ ::std::size_t neighbor_count = 1;
+
+ for (::std::size_t dim = 0; dim < dim_count; ++dim)
+ {
+ neighbor_count *= 3;
+ }
+
+ neighbor_count >>= 1;
+
+ for (i_itr = indices.begin(); i_itr != i_end; ++i_itr)
+ {
+ if (
+ (
+ ::std::accumulate(
+ i_itr->begin()
+ , i_itr->end()
+ , 0
+ , ::std::plus<VAI>()
+ ) & 1
+ )
+ == (has_square_origin ? 1 : 0)
+ )
+ {
+ for (::std::size_t neighbor_index = neighbor_count;;)
+ {
+ bool can_add_edge = true;
+ ::std::size_t change_count = 0;
+ ::std::size_t neighbor_mod = neighbor_index;
+
+ index = *i_itr;
+
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ switch (neighbor_mod % 3)
+ {
+ case 2:
+ {
+ if (index[dim])
+ {
+ --index[dim];
+ ++change_count;
+ }
+ else if (wraparound_policy[dim])
+ {
+ index[dim] = size[dim] - 1;
+ ++change_count;
+ }
+ else
+ {
+ can_add_edge = false;
+ }
+
+ break;
+ }
+
+ case 0:
+ {
+ if (++index[dim] == size[dim])
+ {
+ if (wraparound_policy[dim])
+ {
+ index[dim] = 0;
+ ++change_count;
+ }
+ else
+ {
+ can_add_edge = false;
+ }
+ }
+ else
+ {
+ ++change_count;
+ }
+
+ break;
+ }
+ }
+
+ neighbor_mod /= 3;
+ }
+
+ if (can_add_edge)
+ {
+ switch (change_count)
+ {
+ case 0:
+ can_add_edge = false;
+ case 1:
+ break;
+ default:
+ can_add_edge = (
+ (
+ ::std::accumulate(
+ index.begin()
+ , index.end()
+ , 0
+ , ::std::plus<VAI>()
+ ) & 1
+ )
+ == (has_square_origin ? 1 : 0)
+ );
+ }
+ }
+
+ if (can_add_edge)
+ {
+ edge_adder(vertex_array(*i_itr), vertex_array(index));
+ }
+
+ if (neighbor_index)
+ {
+ --neighbor_index;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ else
+ {
+ for (
+ ::std::size_t dim_index = 0;
+ dim_index < dim_count;
+ ++dim_index
+ )
+ {
+ ::std::size_t const dim = position_index[dim_index];
+
+ index = *i_itr;
+
+ if (++index[dim] == size[dim])
+ {
+ if (wraparound_policy[dim] && !(size[dim] & 1))
+ {
+ index[dim] = 0;
+ edge_adder(
+ vertex_array(*i_itr)
+ , vertex_array(index)
+ );
+ }
+ }
+ else
+ {
+ edge_adder(vertex_array(*i_itr), vertex_array(index));
+ }
+ }
+ }
+ }
+ }
+ } // namespace detail
+
+ template <typename T, typename Tag, typename Base>
+ inline ::std::size_t
+ count_upsilon_tessellation_layout_vertices(
+ detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ return detail::count_upsilon_tessellation_layout_vertices_impl(
+ arg_pack[
+ ::boost::graph::keywords::_position_index_map
+ || value_factory<identity_property_map>()
+ ]
+ , arg_pack[::boost::graph::keywords::_vertex_centroid_distance | 1]
+ , arg_pack[::boost::graph::keywords::_dimensions]
+ );
+ }
+
+#if BOOST_PP_LESS(2, BOOST_PARAMETER_MAX_ARITY)
+ BOOST_PARAMETER_FUNCTION(
+ (::std::size_t)
+ , count_upsilon_tessellation_layout_vertices
+ , ::boost::graph::keywords::tag
+ , (required
+ (dimensions, *)
+ )
+ (optional
+ (vertex_centroid_distance
+ , *
+ , 1
+ )
+ (position_index_map
+ , *
+ , identity_property_map()
+ )
+ )
+ )
+ {
+ return detail::count_upsilon_tessellation_layout_vertices_impl(
+ position_index_map
+ , vertex_centroid_distance
+ , dimensions
+ );
+ }
+#endif // 2 < BOOST_PARAMETER_MAX_ARITY
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename T
+ , typename Tag
+ , typename Base
+ >
+ inline void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , detail::intrusive_layout_params<T,Tag,Base> const& params
+ )
+ {
+ typedef detail::intrusive_layout_params<T,Tag,Base> Params;
+ BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(Params, params)
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::position_index_map
+ , identity_property_map
+ >::type
+ PositionIndexMap;
+ typedef typename ::boost::detail::data_type<
+ typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::dimensions
+ >::type
+ >::type
+ Point;
+ typedef typename ::boost::parameter::binding<
+ arg_pack_type
+ , ::boost::graph::keywords::tag::point_factory
+ , value_factory<Point>
+ >::type
+ PointFactory;
+
+ PointFactory point_factory = arg_pack[
+ ::boost::graph::keywords::_point_factory
+ || value_factory<value_factory<Point> >()
+ ];
+ PositionIndexMap position_index = arg_pack[
+ ::boost::graph::keywords::_position_index_map
+ || value_factory<identity_property_map>()
+ ];
+
+ detail::set_upsilon_tessellation_layout_impl(
+ vertex_iterator
+ , edge_function
+ , arg_pack[::boost::graph::keywords::_has_square_origin | false]
+ , arg_pack[
+ ::boost::graph::keywords::_position_map
+ || value_factory<dummy_property_map>()
+ ]
+ , position_index
+ , arg_pack[::boost::graph::keywords::_vertex_centroid_distance | 1]
+ , arg_pack[::boost::graph::keywords::_dimensions]
+ , arg_pack[
+ ::boost::graph::keywords::_origin
+ | detail::build_default_origin(
+ point_factory()
+ , position_index
+ , 2
+ )
+ ]
+ , point_factory
+ , arg_pack[
+ ::boost::graph::keywords::_wraparound_policy
+ | detail::index_predicate<false>()
+ ]
+ );
+ }
+
+#if defined(BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_ALL_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_upsilon_tessellation_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ (dimensions, *)
+ )
+ (optional
+ (vertex_centroid_distance
+ , *
+ , 1
+ )
+ (has_square_origin
+ , *
+ , false
+ )
+ (wraparound_policy
+ , *
+ , detail::index_predicate<false>()
+ )
+ (point_factory
+ , *
+ , detail::make_value_factory(dimensions)
+ )
+ (position_index_map
+ , *
+ , identity_property_map()
+ )
+ (position_map
+ , *
+ , dummy_property_map()
+ )
+ (origin
+ , *
+ , detail::make_default_origin
+ (2)(position_index_map)(point_factory())
+ )
+ )
+ )
+ {
+ detail::set_upsilon_tessellation_layout_impl(
+ vertex_iterator
+ , edge_function
+ , has_square_origin
+ , position_map
+ , position_index_map
+ , vertex_centroid_distance
+ , dimensions
+ , origin
+ , point_factory
+ , wraparound_policy
+ );
+ return true;
+ }
+#elif defined(BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_5_PARAMS)
+ BOOST_PARAMETER_FUNCTION(
+ (bool)
+ , set_upsilon_tessellation_layout
+ , ::boost::graph::keywords::tag
+ , (required
+ (vertex_iterator, *)
+ (edge_function, *)
+ (dimensions, *)
+ )
+ (optional
+ (vertex_centroid_distance
+ , *
+ , 1
+ )
+ (has_square_origin
+ , *
+ , false
+ )
+ )
+ )
+ {
+ set_upsilon_tessellation_layout(
+ vertex_iterator
+ , edge_function
+ , make_intrusive_layout_params().dimensions(
+ dimensions
+ ).vertex_centroid_distance(
+ vertex_centroid_distance
+ ).has_square_origin(
+ has_square_origin
+ )
+ );
+ return true;
+ }
+#endif // BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_*_PARAMS
+} // namespace boost
+
+#endif // BOOST_GRAPH_SET_UPSILON_TESSEL_LAYOUT_HPP
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/Jamroot
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/Jamroot 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,29 @@
+project html ;
+import boostbook : boostbook ;
+using quickbook ;
+
+xml intrusive_layout
+ :
+ intrusive_layout.qbk
+ ;
+boostbook quickbook
+ :
+ intrusive_layout
+ :
+ <xsl:param>admon.graphics.path=doc/images/
+ <xsl:param>navig.graphics.path=doc/images/
+ <xsl:param>boost.root=http://www.boost.org
+ <xsl:param>boost.libraries=http://www.boost.org/libs/libraries.htm
+ <xsl:param>boost.image.src=../../boost.png
+ <xsl:param>boost.image.alt="C++ Boost"
+ <xsl:param>boost.image.w=277
+ <xsl:param>boost.image.h=86
+ <xsl:param>html.stylesheet=doc/boostbook.css
+ <xsl:param>nav.layout=none
+ <xsl:param>chunk.section.depth=1
+ <xsl:param>chunk.first.sections=1
+ <xsl:param>generate.section.toc.level=0
+ <xsl:param>toc.section.depth=0
+ <xsl:param>toc.max.depth=0
+ ;
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/basic_add_edge_function.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/basic_add_edge_function.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,349 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>basic_add_edge_function</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="basic_vert_insert_iterator.html" title="basic_vertex_insert_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="basic_vert_insert_iterator.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.basic_add_edge_function"></a><a class="link" href="basic_add_edge_function.html" title="basic_add_edge_function"><code class="computeroutput">basic_add_edge_function</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_add_edge_function.synopsis"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Graph, bool Is2Way>
+ class basic_add_edge_function
+ {
+
+ public:
+ explicit basic_add_edge_function(Graph& graph);
+
+ void
+ operator()(
+ typename graph_traits<Graph>::vertex_descriptor u
+ , typename graph_traits<Graph>::vertex_descriptor v
+ );
+ };
+
+} // namespace boost
+</pre>
+
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Graph>
+ basic_add_edge_function<Graph,true> basic_2way_edge_adder(Graph& graph);
+
+} // namespace boost
+</pre>
+
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Graph>
+ basic_add_edge_function<Graph,false> basic_edge_adder(Graph& graph);
+
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_add_edge_function.description"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ This simple function object type allows layout algorithms to indicate which
+ vertices should be neighbors without having to modify the underlying graph
+ structure themselves. It will serve your needs if the graph does not possess
+ any internal edge property maps, or if the edge properties can be initialized
+ later on.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_add_edge_function.definition"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/basic_add_edge_function.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_add_edge_function.tpl_param"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.tpl_param" title="Template Parameters">Template Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Requirements
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">Graph</code>
+ 
+ </td>
+<td>
+ 
+ The type of graph to whom this function object will add edges.
+ 
+ </td>
+<td>
+ 
+ It must model the Mutable Graph concept.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">Is2Way</code>
+ 
+ </td>
+<td>
+ 
+ A boolean constant that controls whether or not the input vertices
+ will be biconnected. If <code class="computeroutput">Graph</code>
+ is undirected, then adjacent vertices will be biconnected anyway,
+ but it makes a difference for directed graphs.
+ 
+ </td>
+<td>
+ </td>
+</tr>
+</tbody>
+</table></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="index.basic_add_edge_function.tpl_param.model_of"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.tpl_param.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+
+ Binary Function
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="index.basic_add_edge_function.tpl_param.public_bases"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.tpl_param.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+
+ None.
+ 
+</div>
+<div class="variablelist">
+Notation
+<dl>
+<dt><code class="computeroutput">graph</code></dt>
+<dd>
+ An object of type <code class="computeroutput">Graph</code>.
+ </dd>
+<dt><code class="computeroutput">f</code></dt>
+<dd>
+ An object of type <code class="computeroutput">basic_add_edge_function</code>.
+ </dd>
+<dt><code class="computeroutput">u</code>, <code class="computeroutput">v</code></dt>
+<dd>
+ Objects of type <code class="literal">graph_traits<Graph>::vertex_descriptor</code>.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_add_edge_function.members"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.members" title="Members">Members</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ Constructor
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">basic_add_edge_function(graph)</code>
+ 
+ </td>
+<td>
+ 
+ Constructs a new <code class="computeroutput">basic_add_edge_function</code>
+ object that will add edges to the specified graph.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Function call operator
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">f(u,
+ v)</code>
+ 
+ </td>
+<td>
+ 
+ Calls <code class="literal">add_edge(u,
+ v)</code>. If <code class="computeroutput">Is2Way</code>
+ is <code class="computeroutput">true</code> and the graph
+ is directed, also calls <code class="literal">add_edge(v,
+ u)</code>.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_add_edge_function.non_members"></a><a class="link" href="basic_add_edge_function.html#index.basic_add_edge_function.non_members" title="Non-members">Non-members</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ Two-way construction function
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">basic_2way_edge_adder(graph)</code>
+ 
+ </td>
+<td>
+ 
+ Constructs and returns a new <code class="computeroutput">basic_add_edge_function</code>
+ object that will add two-way edges to the specified graph.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ One-way construction function
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">basic_edge_adder(graph)</code>
+ 
+ </td>
+<td>
+ 
+ Constructs and returns a new <code class="computeroutput">basic_add_edge_function</code>
+ object that will add one-way edges to the specified graph.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="basic_vert_insert_iterator.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/basic_add_edge_function.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/basic_add_edge_function.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,111 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:basic_add_edge_function `basic_add_edge_function`]
+
+[section Synopsis]
+[reference__basic_add_edge_function__definition]
+[reference__basic_2way_edge_adder__prototype]
+[reference__basic_edge_adder__prototype]
+[endsect]
+
+[section Description]
+This simple function object type allows layout algorithms to indicate which
+vertices should be neighbors without having to modify the underlying graph
+structure themselves. It will serve your needs if the graph does not possess
+any internal edge property maps, or if the edge properties can be initialized
+later on.
+[endsect]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_basic_add_edge_function_hpp__>
+``
+[endsect]
+
+[section:tpl_param Template Parameters]
+[table
+ [[Parameter][Description][Requirements]]
+ [
+ [`Graph`]
+ [The type of graph to whom this function object will add edges.]
+ [It must model the __Mutable_Graph__ concept.]
+ ]
+ [
+ [`Is2Way`]
+ [
+ A boolean constant that controls whether or not the input vertices
+ will be biconnected. If `Graph` is undirected, then adjacent
+ vertices will be biconnected anyway, but it makes a difference for
+ directed graphs.
+ ]
+ []
+ ]
+]
+
+[section:model_of Model of]
+__Binary_Function__
+[endsect]
+
+[section:public_bases Public Base Classes]
+None.
+[endsect]
+
+[variablelist Notation
+ [[`graph`][An object of type `Graph`.]]
+ [[`f`][An object of type `basic_add_edge_function`.]]
+ [[`u`, `v`][Objects of type [^_graph_traits_<Graph>::vertex_descriptor].]]
+]
+[endsect]
+
+[section Members]
+[table
+ [[Name][Expression][Description]]
+ [
+ [Constructor]
+ [`basic_add_edge_function(graph)`]
+ [
+ Constructs a new `basic_add_edge_function` object that will add
+ edges to the specified graph.
+ ]
+ ]
+ [
+ [Function call operator]
+ [`f(u, v)`]
+ [
+ Calls [^_add_edge_(u, v)]. If `Is2Way` is `true` and the graph is
+ directed, also calls [^_add_edge_(v, u)].
+ ]
+ ]
+]
+[endsect]
+
+[section Non-members]
+[table
+ [[Name][Expression][Description]]
+ [
+ [Two-way construction function]
+ [`basic_2way_edge_adder(graph)`]
+ [
+ Constructs and returns a new `basic_add_edge_function` object that
+ will add two-way edges to the specified graph.
+ ]
+ ]
+ [
+ [One-way construction function]
+ [`basic_edge_adder(graph)`]
+ [
+ Constructs and returns a new `basic_add_edge_function` object that
+ will add one-way edges to the specified graph.
+ ]
+ ]
+]
+[endsect]
+
+[endsect] [/ basic_add_edge_function]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/basic_vert_insert_iterator.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/basic_vert_insert_iterator.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,332 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>basic_vertex_insert_iterator</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="count_bitset_grid_verts.html" title="count_bitset_grid_layout_vertices">
+<link rel="next" href="basic_add_edge_function.html" title="basic_add_edge_function">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_bitset_grid_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="basic_add_edge_function.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.basic_vert_insert_iterator"></a><a class="link" href="basic_vert_insert_iterator.html" title="basic_vertex_insert_iterator"><code class="computeroutput">basic_vertex_insert_iterator</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_vert_insert_iterator.synopsis"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.synopsis" title="Synopsis">Synopsis</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Graph>
+ class basic_vertex_insert_iterator
+ : public ::boost::iterator_facade<
+ basic_vertex_insert_iterator<Graph>
+ , typename graph_traits<Graph>::vertex_descriptor
+ , forward_traversal_tag
+ >
+ {
+
+ public:
+ explicit basic_vertex_insert_iterator(Graph& graph);
+
+ template <typename OtherGraph>
+ basic_vertex_insert_iterator(
+ basic_vertex_insert_iterator<OtherGraph> const& other
+ );
+
+ };
+
+} // namespace boost
+</pre>
+
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Graph>
+ basic_vertex_insert_iterator<Graph> basic_vertex_inserter(Graph& graph);
+
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_vert_insert_iterator.description"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ Since some popular graph types provide a <code class="computeroutput">clear()</code> member function but not a <code class="computeroutput">resize()</code>
+ member function, it may not be possible to reserve enough vertices for layout
+ algorithms to work in some cases. This iterator facade enables the layout
+ algorithms to add vertices on the fly. It will serve your needs if the graph
+ does not possess any internal vertex property maps, or if the vertex properties
+ can be initialized later on.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_vert_insert_iterator.definition"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/basic_vert_insert_iterator.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_vert_insert_iterator.tpl_param"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.tpl_param" title="Template Parameters">Template
+ Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Requirements
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+ <code class="computeroutput">Graph</code>
+ 
+ </td>
+<td>
+ 
+ The type of the graph to whom this iterator will add vertices.
+ 
+ </td>
+<td>
+ 
+ It must model the Mutable Graph concept.
+ 
+ </td>
+</tr></tbody>
+</table></div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="index.basic_vert_insert_iterator.tpl_param.model_of"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.tpl_param.model_of" title="Model of">Model
+ of</a>
+</h4></div></div></div>
+<pre class="programlisting">* Readable Iterator
+* Incrementable Iterator
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="index.basic_vert_insert_iterator.tpl_param.public_bases"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.tpl_param.public_bases" title="Public Base Classes">Public
+ Base Classes</a>
+</h4></div></div></div>
+
+ iterator_facade
+ 
+</div>
+<div class="variablelist">
+Notation
+<dl>
+<dt><code class="computeroutput">graph</code></dt>
+<dd>
+ An object of type <code class="computeroutput">Graph</code>.
+ </dd>
+<dt><code class="computeroutput">itr</code></dt>
+<dd>
+ An object of type <code class="computeroutput">basic_vertex_insert_iterator</code>.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_vert_insert_iterator.members"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.members" title="Members">Members</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ Constructor
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">basic_vertex_insert_iterator(graph)</code>
+ 
+ </td>
+<td>
+ 
+ Constructs a new <code class="computeroutput">basic_vertex_insert_iterator</code>
+ object that will add vertices to the specified graph.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Dereference operator
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">*itr</code>
+ 
+ </td>
+<td>
+ 
+ Adds a new vertex to the graph, then returns the representative
+ vertex descriptor.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Pre-increment operator
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">++itr</code>
+ 
+ </td>
+<td>
+ 
+ No-op.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ Post-increment operator
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">itr++</code>
+ 
+ </td>
+<td>
+ 
+ No-op.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.basic_vert_insert_iterator.non_members"></a><a class="link" href="basic_vert_insert_iterator.html#index.basic_vert_insert_iterator.non_members" title="Non-members">Non-members</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Name
+ 
+ </th>
+<th>
+ 
+ Expression
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+</tr></thead>
+<tbody><tr>
+<td>
+ 
+ Construction function
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">basic_vertex_inserter(graph)</code>
+ 
+ </td>
+<td>
+ 
+ Constructs and returns a new <code class="computeroutput">basic_vertex_insert_iterator</code>
+ object that will add vertices to the specified graph.
+ 
+ </td>
+</tr></tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_bitset_grid_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="basic_add_edge_function.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/basic_vert_insert_iterator.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/basic_vert_insert_iterator.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,105 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:basic_vert_insert_iterator `basic_vertex_insert_iterator`]
+
+[section Synopsis]
+[reference__basic_vertex_insert_iterator__definition]
+[reference__basic_vertex_inserter__prototype]
+[endsect]
+
+[section Description]
+Since some popular graph types provide a `clear()` member function but not a
+`resize()` member function, it may not be possible to reserve enough vertices
+for layout algorithms to work in some cases. This iterator facade enables the
+layout algorithms to add vertices on the fly. It will serve your needs if the
+graph does not possess any internal vertex property maps, or if the vertex
+properties can be initialized later on.
+[endsect]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_basic_vert_insert_iterator_hpp__>
+``
+[endsect]
+
+[section:tpl_param Template Parameters]
+[table
+ [[Parameter][Description][Requirements]]
+ [
+ [`Graph`]
+ [The type of the graph to whom this iterator will add vertices.]
+ [It must model the __Mutable_Graph__ concept.]
+ ]
+]
+
+[section:model_of Model of]
+
+ * __Readable_Iterator__
+ * __Incrementable_Iterator__
+
+[endsect]
+
+[section:public_bases Public Base Classes]
+__iterator_facade__
+[endsect]
+
+[variablelist Notation
+ [[`graph`][An object of type `Graph`.]]
+ [[`itr`][An object of type `basic_vertex_insert_iterator`.]]
+]
+[endsect]
+
+[section Members]
+[table
+ [[Name][Expression][Description]]
+ [
+ [Constructor]
+ [`basic_vertex_insert_iterator(graph)`]
+ [
+ Constructs a new `basic_vertex_insert_iterator` object that will
+ add vertices to the specified graph.
+ ]
+ ]
+ [
+ [Dereference operator]
+ [`*itr`]
+ [
+ Adds a new vertex to the graph, then returns the representative
+ __vertex_descriptor__.
+ ]
+ ]
+ [
+ [Pre-increment operator]
+ [`++itr`]
+ [No-op.]
+ ]
+ [
+ [Post-increment operator]
+ [`itr++`]
+ [No-op.]
+ ]
+]
+[endsect]
+
+[section Non-members]
+[table
+ [[Name][Expression][Description]]
+ [
+ [Construction function]
+ [`basic_vertex_inserter(graph)`]
+ [
+ Constructs and returns a new `basic_vertex_insert_iterator` object
+ that will add vertices to the specified graph.
+ ]
+ ]
+]
+[endsect]
+
+[endsect] [/ basic_vertex_insert_iterator]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/boostbook.css
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/boostbook.css 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,588 @@
+/*=============================================================================
+ Copyright (c) 2004 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Distributed under the Boost Software License, Version 1.0. (See accompany-
+ ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+/*=============================================================================
+ Body defaults
+=============================================================================*/
+
+ body
+ {
+ margin: 1em;
+ font-family: sans-serif;
+ }
+
+/*=============================================================================
+ Paragraphs
+=============================================================================*/
+
+ p
+ {
+ text-align: left;
+ font-size: 10pt;
+ line-height: 1.15;
+ }
+
+/*=============================================================================
+ Program listings
+=============================================================================*/
+
+ /* Code on paragraphs */
+ p tt.computeroutput
+ {
+ font-size: 9pt;
+ }
+
+ pre.synopsis
+ {
+ font-size: 90%;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ .programlisting,
+ .screen
+ {
+ font-size: 9pt;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ /* Program listings in tables don't get borders */
+ td .programlisting,
+ td .screen
+ {
+ margin: 0pc 0pc 0pc 0pc;
+ padding: 0pc 0pc 0pc 0pc;
+ }
+
+/*=============================================================================
+ Headings
+=============================================================================*/
+
+ h1, h2, h3, h4, h5, h6
+ {
+ text-align: left;
+ margin: 1em 0em 0.5em 0em;
+ font-weight: bold;
+ }
+
+ h1 { font: 140% }
+ h2 { font: bold 140% }
+ h3 { font: bold 130% }
+ h4 { font: bold 120% }
+ h5 { font: italic 110% }
+ h6 { font: italic 100% }
+
+ /* Top page titles */
+ title,
+ h1.title,
+ h2.title
+ h3.title,
+ h4.title,
+ h5.title,
+ h6.title,
+ .refentrytitle
+ {
+ font-weight: bold;
+ margin-bottom: 1pc;
+ }
+
+ h1.title { font-size: 140% }
+ h2.title { font-size: 140% }
+ h3.title { font-size: 130% }
+ h4.title { font-size: 120% }
+ h5.title { font-size: 110% }
+ h6.title { font-size: 100% }
+
+ .section h1
+ {
+ margin: 0em 0em 0.5em 0em;
+ font-size: 140%;
+ }
+
+ .section h2 { font-size: 140% }
+ .section h3 { font-size: 130% }
+ .section h4 { font-size: 120% }
+ .section h5 { font-size: 110% }
+ .section h6 { font-size: 100% }
+
+ /* Code on titles */
+ h1 tt.computeroutput { font-size: 140% }
+ h2 tt.computeroutput { font-size: 140% }
+ h3 tt.computeroutput { font-size: 130% }
+ h4 tt.computeroutput { font-size: 120% }
+ h5 tt.computeroutput { font-size: 110% }
+ h6 tt.computeroutput { font-size: 100% }
+
+/*=============================================================================
+ Author
+=============================================================================*/
+
+ h3.author
+ {
+ font-size: 100%
+ }
+
+/*=============================================================================
+ Lists
+=============================================================================*/
+
+ li
+ {
+ font-size: 10pt;
+ line-height: 1.3;
+ }
+
+ /* Unordered lists */
+ ul
+ {
+ text-align: left;
+ }
+
+ /* Ordered lists */
+ ol
+ {
+ text-align: left;
+ }
+
+/*=============================================================================
+ Links
+=============================================================================*/
+
+ a
+ {
+ text-decoration: none; /* no underline */
+ }
+
+ a:hover
+ {
+ text-decoration: underline;
+ }
+
+/*=============================================================================
+ Spirit style navigation
+=============================================================================*/
+
+ .spirit-nav
+ {
+ text-align: right;
+ }
+
+ .spirit-nav a
+ {
+ color: white;
+ padding-left: 0.5em;
+ }
+
+ .spirit-nav img
+ {
+ border-width: 0px;
+ }
+
+/*=============================================================================
+ Copyright footer
+=============================================================================*/
+ .copyright-footer
+ {
+ text-align: right;
+ font-size: 70%;
+ }
+
+ .copyright-footer p
+ {
+ text-align: right;
+ font-size: 80%;
+ }
+
+/*=============================================================================
+ Table of contents
+=============================================================================*/
+
+ .toc
+ {
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.1pc 1pc 0.1pc 1pc;
+ font-size: 80%;
+ line-height: 1.15;
+ }
+
+ .boost-toc
+ {
+ float: right;
+ padding: 0.5pc;
+ }
+
+/*=============================================================================
+ Tables
+=============================================================================*/
+
+ .table-title,
+ div.table p.title
+ {
+ margin-left: 4%;
+ padding-right: 0.5em;
+ padding-left: 0.5em;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ width: 92%;
+ margin-left: 4%;
+ margin-right: 4%;
+ }
+
+ div.informaltable table,
+ div.table table
+ {
+ padding: 4px;
+ }
+
+ /* Table Cells */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ padding: 0.5em;
+ text-align: left;
+ font-size: 9pt;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ padding: 0.5em 0.5em 0.5em 0.5em;
+ border: 1pt solid white;
+ font-size: 80%;
+ }
+
+ table.simplelist
+ {
+ width: auto !important;
+ margin: 0em !important;
+ padding: 0em !important;
+ border: none !important;
+ }
+ table.simplelist td
+ {
+ margin: 0em !important;
+ padding: 0em !important;
+ text-align: left !important;
+ font-size: 9pt !important;
+ border: none !important;
+ }
+
+/*=============================================================================
+ Blurbs
+=============================================================================*/
+
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ font-size: 9pt; /* A little bit smaller than the main text */
+ line-height: 1.2;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ p.blurb img
+ {
+ padding: 1pt;
+ }
+
+/*=============================================================================
+ Variable Lists
+=============================================================================*/
+
+ /* Make the terms in definition lists bold */
+ div.variablelist dl dt,
+ span.term
+ {
+ font-weight: bold;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td
+ {
+ text-align: left;
+ vertical-align: top;
+ padding: 0em 2em 0em 0em;
+ font-size: 10pt;
+ margin: 0em 0em 0.5em 0em;
+ line-height: 1;
+ }
+
+ div.variablelist dl dt
+ {
+ margin-bottom: 0.2em;
+ }
+
+ div.variablelist dl dd
+ {
+ margin: 0em 0em 0.5em 2em;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td p,
+ div.variablelist dl dd p
+ {
+ margin: 0em 0em 0.5em 0em;
+ line-height: 1;
+ }
+
+/*=============================================================================
+ Misc
+=============================================================================*/
+
+ /* Title of books and articles in bibliographies */
+ span.title
+ {
+ font-style: italic;
+ }
+
+ span.underline
+ {
+ text-decoration: underline;
+ }
+
+ span.strikethrough
+ {
+ text-decoration: line-through;
+ }
+
+ /* Copyright, Legal Notice */
+ div div.legalnotice p
+ {
+ text-align: left
+ }
+
+/*=============================================================================
+ Colors
+=============================================================================*/
+
+ @media screen
+ {
+ body {
+ background-color: #FFFFFF;
+ }
+
+ /* Links */
+ a
+ {
+ color: #005a9c;
+ }
+
+ a:visited
+ {
+ color: #9c5a9c;
+ }
+
+ h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+ h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+ h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+ {
+ text-decoration: none; /* no underline */
+ color: #000000;
+ }
+
+ /* Syntax Highlighting */
+ .keyword { color: #0000AA; }
+ .identifier { color: #000000; }
+ .special { color: #707070; }
+ .preprocessor { color: #402080; }
+ .char { color: teal; }
+ .comment { color: #800000; }
+ .string { color: teal; }
+ .number { color: teal; }
+ .white_bkd { background-color: #FFFFFF; }
+ .dk_grey_bkd { background-color: #999999; }
+
+ /* Copyright, Legal Notice */
+ .copyright
+ {
+ color: #666666;
+ font-size: small;
+ }
+
+ div div.legalnotice p
+ {
+ color: #666666;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ td .programlisting,
+ td .screen
+ {
+ border: 0px solid #DCDCDC;
+ }
+
+ /* Blurbs */
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid #DCDCDC;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ background-color: #F0F0F0;
+ border: 1px solid #DCDCDC;
+ }
+
+ .copyright-footer
+ {
+ color: #8F8F8F;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ color: #00A000;
+ }
+ }
+
+ @media print
+ {
+ /* Links */
+ a
+ {
+ color: black;
+ }
+
+ a:visited
+ {
+ color: black;
+ }
+
+ .spirit-nav
+ {
+ display: none;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid gray;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid gray;
+ }
+
+ td .programlisting,
+ td .screen
+ {
+ border: 0px solid #DCDCDC;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid gray;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ border: 1px solid gray;
+ border-collapse: collapse;
+ }
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid gray;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ border: 1px solid gray;
+ }
+
+ table.simplelist tr td
+ {
+ border: none !important;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ font-weight: bold;
+ }
+ }
+
+/*=============================================================================
+ Images
+=============================================================================*/
+
+ span.inlinemediaobject img
+ {
+ vertical-align: middle;
+ }
+
+/*==============================================================================
+ Super and Subscript: style so that line spacing isn't effected, see
+ http://www.adobe.com/cfusion/communityengine/index.cfm?event=showdetails&productId=1&postId=5341
+==============================================================================*/
+
+sup,
+sub {
+ height: 0;
+ line-height: 1;
+ vertical-align: baseline;
+ _vertical-align: bottom;
+ position: relative;
+
+}
+
+sup {
+ bottom: 1ex;
+}
+
+sub {
+ top: .5ex;
+}
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_bitset_grid_verts.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_bitset_grid_verts.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,196 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>count_bitset_grid_layout_vertices</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="set_bitset_grid_layout.html" title="set_bitset_grid_layout">
+<link rel="next" href="basic_vert_insert_iterator.html" title="basic_vertex_insert_iterator">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_bitset_grid_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="basic_vert_insert_iterator.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.count_bitset_grid_verts"></a><a class="link" href="count_bitset_grid_verts.html" title="count_bitset_grid_layout_vertices"><code class="computeroutput">count_bitset_grid_layout_vertices</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bitset_grid_verts.prototype"></a><a class="link" href="count_bitset_grid_verts.html#index.count_bitset_grid_verts.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Params>
+ std::size_t count_bitset_grid_layout_vertices(Params const& params);
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that takes in Boost.Parameter
+ keywords is defined if you don't set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than 2.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename DimensionCount, typename PositionMap>
+ std::size_t
+ count_bitset_grid_layout_vertices(
+ DimensionCount dimension_count
+ , PositionMap position_map
+ );
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bitset_grid_verts.description"></a><a class="link" href="count_bitset_grid_verts.html#index.count_bitset_grid_verts.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ Returns the number of times that the <a class="link" href="set_bitset_grid_layout.html" title="set_bitset_grid_layout"><code class="computeroutput">set_bitset_grid_layout()</code></a>
+ algorithm will dereference and increment its vertex iterator if passed the
+ same arguments to this function.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bitset_grid_verts.definition"></a><a class="link" href="count_bitset_grid_verts.html#index.count_bitset_grid_verts.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_bitset_grid_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bitset_grid_verts.type_requirements"></a><a class="link" href="count_bitset_grid_verts.html#index.count_bitset_grid_verts.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `DimensionCount` must model the MPL Integral Constant concept.
+* `PositionMap` must model the Writable Property Map concept.
+* If the value type of `PositionMap` is not an instantiation of
+ std::bitset, then the value that `DimensionCount` represents must be
+ greater than 1.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bitset_grid_verts.parameters"></a><a class="link" href="count_bitset_grid_verts.html#index.count_bitset_grid_verts.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimension_count</code>
+ 
+ </td>
+<td>
+ 
+ An MPL Integral Constant representing
+ the number of bits in each bitset to be associated with each vertex.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ If the value type of <code class="computeroutput">PositionMap</code>
+ is an instantiation of std::bitset, then an MPL Integral Constant representing
+ its size; otherwise required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_map</code>
+ 
+ </td>
+<td>
+ 
+ Required only if the value type of <code class="computeroutput">PositionMap</code>
+ is an instantiation of std::bitset.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">dummy_property_map()</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ These two parameters can be deduced by type. However, if for some reason
+ you need to specify their names, remember that the BGL
+ prefixes each Boost.Parameter
+ keyword with an underscore and defines it in the <code class="computeroutput">boost::graph::keywords</code>
+ namespace.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_bitset_grid_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="basic_vert_insert_iterator.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_bitset_grid_verts.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_bitset_grid_verts.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,95 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:count_bitset_grid_verts `count_bitset_grid_layout_vertices`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename Params>
+ std::size_t count_bitset_grid_layout_vertices(Params const& params);
+} // namespace boost
+``
+
+The function prototype that takes in __Boost_Parameter__ keywords is defined if
+you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than 2.
+
+``
+namespace boost {
+
+ template <typename DimensionCount, typename PositionMap>
+ std::size_t
+ count_bitset_grid_layout_vertices(
+ DimensionCount dimension_count
+ , PositionMap position_map
+ );
+} // namespace boost
+``
+[endsect]
+
+[section Description]
+Returns the number of times that the __set_bitset_grid_layout__ algorithm will
+dereference and increment its vertex iterator if passed the same arguments to
+this function.
+[endsect]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_bitset_grid_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `DimensionCount` must model the __MPL_Integral_Constant__ concept.
+ * `PositionMap` must model the __Writable_Property_Map__ concept.
+ * If the value type of `PositionMap` is not an instantiation of
+ __std_bitset__, then the value that `DimensionCount` represents must be
+ greater than 1.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`dimension_count`]
+ [
+ An __MPL_Integral_Constant__ representing the number of bits in
+ each bitset to be associated with each vertex.
+ ]
+ []
+ [
+ If the value type of `PositionMap` is an instantiation of
+ __std_bitset__, then an __MPL_Integral_Constant__ representing its
+ size; otherwise required.
+ ]
+ ]
+ [
+ [`position_map`]
+ [
+ Required only if the value type of `PositionMap` is an
+ instantiation of __std_bitset__.
+ ]
+ []
+ [`dummy_property_map()`]
+ ]
+]
+
+These two parameters can be deduced by type. However, if for some reason
+you need to specify their names, remember that the __BGL__ prefixes each
+__Boost_Parameter__ keyword with an underscore and defines it in the
+`boost::graph::keywords` namespace.
+[endsect] [/ Parameters]
+
+[endsect] [/ count_bitset_grid_layout_vertices]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_bt_cubic_hcomb_verts.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_bt_cubic_hcomb_verts.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,221 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>count_bitruncated_cubic_honeycomb_layout_vertices</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="set_bt_cubic_hcomb_layout.html" title="set_bitruncated_cubic_honeycomb_layout">
+<link rel="next" href="set_bitset_grid_layout.html" title="set_bitset_grid_layout">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_bt_cubic_hcomb_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="set_bitset_grid_layout.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.count_bt_cubic_hcomb_verts"></a><a class="link" href="count_bt_cubic_hcomb_verts.html" title="count_bitruncated_cubic_honeycomb_layout_vertices"><code class="computeroutput">count_bitruncated_cubic_honeycomb_layout_vertices</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bt_cubic_hcomb_verts.prototype"></a><a class="link" href="count_bt_cubic_hcomb_verts.html#index.count_bt_cubic_hcomb_verts.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Params>
+ std::size_t
+ count_bitruncated_cubic_honeycomb_layout_vertices(
+ Params const& params
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that takes in Boost.Parameter
+ keywords is defined if you don't set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than 3.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Dimensions, typename Scalar, typename PositionIndexMap>
+ std::size_t
+ count_bitruncated_cubic_honeycomb_layout_vertices(
+ Dimensions const& dimensions
+ , Scalar inscribed_radius
+ , PositionIndexMap position_index_map
+ );
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bt_cubic_hcomb_verts.description"></a><a class="link" href="count_bt_cubic_hcomb_verts.html#index.count_bt_cubic_hcomb_verts.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ Returns the number of times that the <a class="link" href="set_bt_cubic_hcomb_layout.html" title="set_bitruncated_cubic_honeycomb_layout"><code class="computeroutput">set_bitruncated_cubic_honeycomb_layout()</code></a> algorithm will dereference and increment
+ its vertex iterator if passed the same arguments to this function.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bt_cubic_hcomb_verts.definition"></a><a class="link" href="count_bt_cubic_hcomb_verts.html#index.count_bt_cubic_hcomb_verts.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_bt_cubic_hcomb_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bt_cubic_hcomb_verts.type_requirements"></a><a class="link" href="count_bt_cubic_hcomb_verts.html#index.count_bt_cubic_hcomb_verts.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+* `Scalar` must be a numeric type.
+* `Scalar` and the return types of the index operators of `Dimensions` must
+ be interoperable arithmetic-wise.
+* `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_bt_cubic_hcomb_verts.parameters"></a><a class="link" href="count_bt_cubic_hcomb_verts.html#index.count_bt_cubic_hcomb_verts.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimensions</code>
+ 
+ </td>
+<td>
+ 
+ The physical size of the resulting layout.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">inscribed_radius</code>
+ 
+ </td>
+<td>
+ 
+ The radius of the sphere inscribed by the truncated octahedron
+ that each vertex represents. See the <a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.description" title="Description">description</a>
+ for further information.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">1</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_index_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different dimensional
+ planes.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values in the range <code class="computeroutput">[0, 2]</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">identity_property_map()</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_bt_cubic_hcomb_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="set_bitset_grid_layout.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_bt_cubic_hcomb_verts.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_bt_cubic_hcomb_verts.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,106 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:count_bt_cubic_hcomb_verts
+`count_bitruncated_cubic_honeycomb_layout_vertices`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename Params>
+ std::size_t
+ count_bitruncated_cubic_honeycomb_layout_vertices(
+ Params const& params
+ );
+} // namespace boost
+``
+
+The function prototype that takes in __Boost_Parameter__ keywords is defined if
+you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than 3.
+
+``
+namespace boost {
+
+ template <typename Dimensions, typename Scalar, typename PositionIndexMap>
+ std::size_t
+ count_bitruncated_cubic_honeycomb_layout_vertices(
+ Dimensions const& dimensions
+ , Scalar inscribed_radius
+ , PositionIndexMap position_index_map
+ );
+} // namespace boost
+``
+[endsect]
+
+[section Description]
+Returns the number of times that the __set_bitruncated_cubic_honeycomb_layout__
+algorithm will dereference and increment its vertex iterator if passed the same
+arguments to this function.
+[endsect]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_bt_cubic_hcomb_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+ * `Scalar` must be a numeric type.
+ * `Scalar` and the return types of the index operators of `Dimensions` must
+ be interoperable arithmetic-wise.
+ * `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`dimensions`]
+ [The physical size of the resulting layout.]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`inscribed_radius`]
+ [
+ The radius of the sphere inscribed by the truncated octahedron that
+ each vertex represents. See the
+ __set_bitruncated_cubic_honeycomb_layout__description__ for further
+ information.
+ ]
+ []
+ [`1`]
+ ]
+ [
+ [`position_index_map`]
+ [
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different
+ dimensional planes.
+ ]
+ [The index operator must accept values in the range `[0, 2]`.]
+ [[^_identity_property_map_()]]
+ ]
+]
+[endsect]
+
+[endsect] [/ set_bitruncated_cubic_honeycomb_layout]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_ortho_grid_verts.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_ortho_grid_verts.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,291 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>count_orthogonal_grid_layout_vertices</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="set_orthogonal_grid_layout.html" title="set_orthogonal_grid_layout">
+<link rel="next" href="set_upsilon_tessel_layout.html" title="set_upsilon_tessellation_layout">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_orthogonal_grid_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="set_upsilon_tessel_layout.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.count_ortho_grid_verts"></a><a class="link" href="count_ortho_grid_verts.html" title="count_orthogonal_grid_layout_vertices"><code class="computeroutput">count_orthogonal_grid_layout_vertices</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_ortho_grid_verts.prototype"></a><a class="link" href="count_ortho_grid_verts.html#index.count_ortho_grid_verts.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Params>
+ std::size_t count_orthogonal_grid_layout_vertices(Params const& params);
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that takes in Boost.Parameter
+ keywords is defined if you don't set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than its default value of 5.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename Dimensions
+ , typename DimensionCount
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename Scale
+ >
+ std::size_t
+ count_orthogonal_grid_layout_vertices(
+ Dimensions const& dimensions
+ , DimensionCount dimension_count
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , Scale const& scale
+ );
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_ortho_grid_verts.description"></a><a class="link" href="count_ortho_grid_verts.html#index.count_ortho_grid_verts.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ Returns the number of times that the <a class="link" href="set_orthogonal_grid_layout.html" title="set_orthogonal_grid_layout"><code class="computeroutput">set_orthogonal_grid_layout()</code></a>
+ algorithm will dereference and increment its vertex iterator if passed the
+ same arguments to this function.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_ortho_grid_verts.definition"></a><a class="link" href="count_ortho_grid_verts.html#index.count_ortho_grid_verts.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_orthogonal_grid_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_ortho_grid_verts.type_requirements"></a><a class="link" href="count_ortho_grid_verts.html#index.count_ortho_grid_verts.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+* If `point_factory` is not specified, then `Dimensions` must model the
+ Default Constructible concept.
+* `DimensionCount` must model the MPL Integral Constant concept.
+* The value that `DimensionCount` represents must be greater than 1.
+* `PointFactory` must model the Generator concept.
+* The return type of `PointFactory` must be convertible to `Scale`.
+* `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+* `Scale` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+* If neither `point_factory` nor `scale` are specified, then `Dimensions`
+ must be convertible to `Scale`.
+* The return types of the index operators of `Dimensions` and `Scale` must be
+ interoperable arithmetic-wise.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_ortho_grid_verts.parameters"></a><a class="link" href="count_ortho_grid_verts.html#index.count_ortho_grid_verts.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimensions</code>
+ 
+ </td>
+<td>
+ 
+ The physical size of the resulting layout.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ Furthermore, If <code class="computeroutput">point_factory</code>
+ is not specified, then the default constructor of <code class="computeroutput">Dimensions</code> must ensure that the
+ object returned fulfills this requirement.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimension_count</code>
+ 
+ </td>
+<td>
+ 
+ An MPL Integral Constant representing
+ the number of dimensions the resulting layout will straddle.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ An MPL Integral Constant representing
+ the value <code class="computeroutput">2</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">point_factory</code>
+ 
+ </td>
+<td>
+ 
+ A function that constructs and returns <code class="computeroutput">Point</code>
+ objects. Required if the default constructor of <code class="computeroutput">Point</code>
+ does not exist or prevents its index operator from fulfilling its
+ runtime requirement.
+ 
+ </td>
+<td>
+ 
+ The index operator of each object returned must accept values returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">value_factory<Dimensions>()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_index_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different orthogonal layouts to reside on different dimensional
+ planes.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values in the range <code class="computeroutput">[0, DimensionCount::value)</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">identity_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">scale</code>
+ 
+ </td>
+<td>
+ 
+ An object representing the distance between two adjacent vertices
+ in each dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ A <code class="computeroutput">Point</code> whose index
+ operator returns one for each of the input dimensions returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_orthogonal_grid_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="set_upsilon_tessel_layout.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_ortho_grid_verts.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_ortho_grid_verts.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,150 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:count_ortho_grid_verts `count_orthogonal_grid_layout_vertices`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename Params>
+ std::size_t count_orthogonal_grid_layout_vertices(Params const& params);
+} // namespace boost
+``
+
+The function prototype that takes in __Boost_Parameter__ keywords is defined if
+you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than its default value of 5.
+
+``
+namespace boost {
+
+ template <
+ typename Dimensions
+ , typename DimensionCount
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename Scale
+ >
+ std::size_t
+ count_orthogonal_grid_layout_vertices(
+ Dimensions const& dimensions
+ , DimensionCount dimension_count
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , Scale const& scale
+ );
+} // namespace boost
+``
+[endsect]
+
+[section Description]
+Returns the number of times that the __set_orthogonal_grid_layout__ algorithm
+will dereference and increment its vertex iterator if passed the same
+arguments to this function.
+[endsect]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_orthogonal_grid_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+ * If `point_factory` is not specified, then `Dimensions` must model the
+ __Default_Constructible__ concept.
+ * `DimensionCount` must model the __MPL_Integral_Constant__ concept.
+ * The value that `DimensionCount` represents must be greater than 1.
+ * `PointFactory` must model the __Generator__ concept.
+ * The return type of `PointFactory` must be convertible to `Scale`.
+ * `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+ * `Scale` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+ * If neither `point_factory` nor `scale` are specified, then `Dimensions`
+ must be convertible to `Scale`.
+ * The return types of the index operators of `Dimensions` and `Scale` must be
+ interoperable arithmetic-wise.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`dimensions`]
+ [The physical size of the resulting layout.]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`. Furthermore, If `point_factory`
+ is not specified, then the default constructor of `Dimensions`
+ must ensure that the object returned fulfills this requirement.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`dimension_count`]
+ [
+ An __MPL_Integral_Constant__ representing the number of dimensions
+ the resulting layout will straddle.
+ ]
+ []
+ [An __MPL_Integral_Constant__ representing the value `2`.]
+ ]
+ [
+ [`point_factory`]
+ [
+ A function that constructs and returns `Point` objects. Required
+ if the default constructor of `Point` does not exist or prevents
+ its index operator from fulfilling its runtime requirement.
+ ]
+ [
+ The index operator of each object returned must accept values
+ returned by the index operator of `position_index_map`.
+ ]
+ [[^_value_factory_<Dimensions>()]]
+ ]
+ [
+ [`position_index_map`]
+ [
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different orthogonal layouts to reside on different dimensional
+ planes.
+ ]
+ [
+ The index operator must accept values in the range
+ `[0, DimensionCount::value)`.
+ ]
+ [[^_identity_property_map_()]]
+ ]
+ [
+ [`scale`]
+ [
+ An object representing the distance between two adjacent vertices
+ in each dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [
+ A `Point` whose index operator returns one for each of the input
+ dimensions returned by the index operator of `position_index_map`.
+ ]
+ ]
+]
+[endsect] [/ Parameters]
+
+[endsect] [/ count_orthogonal_grid_layout_vertices]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_upsilon_tessel_verts.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_upsilon_tessel_verts.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,218 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>count_upsilon_tessellation_layout_vertices</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="set_upsilon_tessel_layout.html" title="set_upsilon_tessellation_layout">
+<link rel="next" href="set_bt_cubic_hcomb_layout.html" title="set_bitruncated_cubic_honeycomb_layout">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_upsilon_tessel_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="set_bt_cubic_hcomb_layout.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.count_upsilon_tessel_verts"></a><a class="link" href="count_upsilon_tessel_verts.html" title="count_upsilon_tessellation_layout_vertices"><code class="computeroutput">count_upsilon_tessellation_layout_vertices</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_upsilon_tessel_verts.prototype"></a><a class="link" href="count_upsilon_tessel_verts.html#index.count_upsilon_tessel_verts.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Params>
+ std::size_t
+ count_upsilon_tessellation_layout_vertices(Params const& params);
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that takes in Boost.Parameter
+ keywords is defined if you don't set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than 3.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename Dimensions, typename Scalar, typename PositionIndexMap>
+ std::size_t
+ count_upsilon_tessellation_layout_vertices(
+ Dimensions const& dimensions
+ , Scalar vertex_centroid_distance
+ , PositionIndexMap position_index_map
+ );
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_upsilon_tessel_verts.description"></a><a class="link" href="count_upsilon_tessel_verts.html#index.count_upsilon_tessel_verts.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ Returns the number of times that the <a class="link" href="set_upsilon_tessel_layout.html" title="set_upsilon_tessellation_layout"><code class="computeroutput">set_upsilon_tessellation_layout()</code></a>
+ algorithm will dereference and increment its vertex iterator if passed the
+ same arguments to this function.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_upsilon_tessel_verts.definition"></a><a class="link" href="count_upsilon_tessel_verts.html#index.count_upsilon_tessel_verts.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_upsilon_tessel_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_upsilon_tessel_verts.type_requirements"></a><a class="link" href="count_upsilon_tessel_verts.html#index.count_upsilon_tessel_verts.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+* `Scalar` must be a numeric type.
+* `Scalar` and the return types of the index operators of `Dimensions` must
+ be interoperable arithmetic-wise.
+* `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.count_upsilon_tessel_verts.parameters"></a><a class="link" href="count_upsilon_tessel_verts.html#index.count_upsilon_tessel_verts.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimensions</code>
+ 
+ </td>
+<td>
+ 
+ The physical size of the resulting layout.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">vertex_centroid_distance</code>
+ 
+ </td>
+<td>
+ 
+ The distance between two orthogonally adjacent vertices.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">1</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_index_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different dimensional
+ planes.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values in the range <code class="computeroutput">[0, 1]</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">identity_property_map()</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="set_upsilon_tessel_layout.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="set_bt_cubic_hcomb_layout.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/count_upsilon_tessel_verts.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/count_upsilon_tessel_verts.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,99 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:count_upsilon_tessel_verts
+`count_upsilon_tessellation_layout_vertices`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename Params>
+ std::size_t
+ count_upsilon_tessellation_layout_vertices(Params const& params);
+} // namespace boost
+``
+
+The function prototype that takes in __Boost_Parameter__ keywords is defined if
+you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than 3.
+
+``
+namespace boost {
+
+ template <typename Dimensions, typename Scalar, typename PositionIndexMap>
+ std::size_t
+ count_upsilon_tessellation_layout_vertices(
+ Dimensions const& dimensions
+ , Scalar vertex_centroid_distance
+ , PositionIndexMap position_index_map
+ );
+} // namespace boost
+``
+[endsect]
+
+[section Description]
+Returns the number of times that the __set_upsilon_tessellation_layout__
+algorithm will dereference and increment its vertex iterator if passed the same
+arguments to this function.
+[endsect]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_upsilon_tessel_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+ * `Scalar` must be a numeric type.
+ * `Scalar` and the return types of the index operators of `Dimensions` must
+ be interoperable arithmetic-wise.
+ * `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`dimensions`]
+ [The physical size of the resulting layout.]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`vertex_centroid_distance`]
+ [The distance between two orthogonally adjacent vertices.]
+ []
+ [`1`]
+ ]
+ [
+ [`position_index_map`]
+ [
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different
+ dimensional planes.
+ ]
+ [The index operator must accept values in the range `[0, 1]`.]
+ [[^_identity_property_map_()]]
+ ]
+]
+[endsect]
+
+[endsect] [/ count_upsilon_tessellation_layout_vertices]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/alert.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/blank.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/caution.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/draft.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/home.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/important.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/next.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/next_disabled.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/note.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/prev.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/prev_disabled.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/smiley.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/tip.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/toc-blank.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/toc-minus.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/toc-plus.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/up.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/up_disabled.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/images/warning.png
==============================================================================
Binary file. No diff available.

Added: sandbox/graph-intrusive_layout/libs/graph/doc/intrusive_layout.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/intrusive_layout.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,104 @@
+[reference index
+ [quickbook 1.5]
+ [version 0.1]
+ [authors [Enage, Cromwell D.]]
+ [copyright 2011 Cromwell D. Enage]
+ [purpose Layout algorithms that add vertices and edges]
+ [license
+ Distributed under 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])
+ ]
+]
+
+[/ General links.]
+[def __bitruncated_cubic_honeycomb__ [@http://en.wikipedia.org/wiki/Bitruncated_cubic_honeycomb bitruncated cubic honeycomb]]
+[def __truncated_octahedra__ [@http://en.wikipedia.org/wiki/Truncated_octahedron truncated octahedra]]
+[def __truncated_octahedron__ [@http://en.wikipedia.org/wiki/Truncated_octahedron truncated octahedron]]
+[def __upsilon_tessellation__ [@http://www.astrolog.org/labyrnth/algrithm.htm upsilon tessellation]]
+[def __zeta_layout__ [@http://www.astrolog.org/labyrnth/algrithm.htm zeta layout]]
+
+[/ General concept links.]
+[def __Binary_Function__ [@http://www.sgi.com/tech/stl/BinaryFunction.html [*Binary Function]]]
+[def __Generator__ [@http://www.sgi.com/tech/stl/Generator.html [*Generator]]]
+
+[/ STL reference links in text.]
+[def __std_bitset__ [@http://www.sgi.com/tech/stl/bitset.html `std::bitset`]]
+
+[/ Boost library links.]
+[def __Boost_Parameter__ [@boost:libs/parameter/doc/html/index.html Boost.Parameter]]
+[def __BGL__ [@boost:libs/graph/doc/index.html BGL]]
+
+[/ Boost concept links.]
+[def __Default_Constructible__ [@http://www.sgi.com/tech/stl/DefaultConstructible.html [*Default Constructible]]]
+[def __Copy_Constructible__ [@boost:libs/utility/CopyConstructible.html [*Copy Constructible]]]
+[def __Assignable__ [@boost:libs/utility/Assignable.html [*Assignable]]]
+[def __MPL_Integral_Constant__ [@boost:libs/mpl/doc/refmanual/integral-constant.html [*MPL Integral Constant]]]
+[def __Readable_Iterator__ [@boost:/libs/iterator/doc/ReadableIterator.html [*Readable Iterator]]]
+[def __Incrementable_Iterator__ [@boost:/libs/iterator/doc/IncrementableIterator.html [*Incrementable Iterator]]]
+[def __Writable_Property_Map__ [@boost:/libs/property_map/doc/WritablePropertyMap.html [*Writable Property Map]]]
+[def __Vertex_List_Graph__ [@boost:libs/graph/doc/VertexListGraph.html [*Vertex List Graph]]]
+[def __Mutable_Graph__ [@boost:libs/graph/doc/MutableGraph.html [*Mutable Graph]]]
+
+[/ Boost reference links in text.]
+[def __old_style_named_parameters__ [@boost:libs/graph/doc/bgl_named_params.html old-style named parameters]]
+[def __vertex_descriptor__ [@boost:libs/graph/doc/graph_traits.html vertex descriptor]]
+[def __vertex_iterator__ [@boost:libs/graph/doc/graph_traits.html vertex iterator]]
+[def __edge_descriptor_type__ [@boost:libs/graph/doc/graph_traits.html edge descriptor type]]
+[def __iterator_facade__ [@boost:libs/iterator/doc/iterator_facade.html `iterator_facade`]]
+[def __iterator_adaptor__ [@boost:libs/iterator/doc/iterator_adaptor.html `iterator_adaptor`]]
+
+[/ Boost reference links in code.]
+[def _value_factory_ [@boost:libs/functional/factory/doc/html/ value_factory]]
+[def _identity_property_map_ [@boost:/libs/property_map/doc/identity_property_map.html identity_property_map]]
+[def _graph_traits_ [@boost:libs/graph/doc/graph_traits.html graph_traits]]
+[def _vertices_ [@boost:libs/graph/doc/VertexListGraph.html vertices]]
+[def _add_vertex_ [@boost:libs/graph/doc/MutableGraph.html add_vertex]]
+[def _add_edge_ [@boost:libs/graph/doc/MutableGraph.html add_edge]]
+
+[/ Header and source file links.]
+[def __boost_graph_basic_vert_insert_iterator_hpp__ [@../../boost/graph/basic_vert_insert_iterator.hpp boost/graph/basic_vert_insert_iterator.hpp]]
+[def __boost_graph_basic_add_edge_function_hpp__ [@../../boost/graph/basic_add_edge_function.hpp boost/graph/basic_add_edge_function.hpp]]
+[def __boost_graph_set_orthogonal_grid_layout_hpp__ [@../../boost/graph/set_orthogonal_grid_layout.hpp boost/graph/set_orthogonal_grid_layout.hpp]]
+[def __boost_graph_set_upsilon_tessel_layout_hpp__ [@../../boost/graph/set_upsilon_tessel_layout.hpp boost/graph/set_upsilon_tessel_layout.hpp]]
+[def __boost_graph_set_bt_cubic_hcomb_layout_hpp__ [@../../boost/graph/set_bt_cubic_hcomb_layout.hpp boost/graph/set_bt_cubic_hcomb_layout.hpp]]
+[def __boost_graph_set_bitset_grid_layout_hpp__ [@../../boost/graph/set_bitset_grid_layout.hpp boost/graph/set_bitset_grid_layout.hpp]]
+[def __example_orthogonal_grid_layouts_cpp__ [@example/orthogonal_grid_layouts.cpp]]
+[def __example_upsilon_tessellation_layout_cpp__ [@example/upsilon_tessellation_layout.cpp]]
+[def __example_bitruncated_cubic_honeycomb_cpp__ [@example/bitruncated_cubic_honeycomb.cpp]]
+[def __example_bitset_grid_layouts_cpp__ [@example/bitset_grid_layouts.cpp]]
+
+[/ Internal links.]
+[def _count_orthogonal_grid_layout_vertices_ [link index.count_ortho_grid_verts count_orthogonal_grid_layout_vertices]]
+[def _count_upsilon_tessellation_layout_vertices_ [link index.count_upsilon_tessel_verts count_upsilon_tessellation_layout_vertices]]
+[def _count_bitruncated_cubic_honeycomb_layout_vertices_ [link index.count_bt_cubic_hcomb_verts count_bitruncated_cubic_honeycomb_layout_vertices]]
+[def _count_bitset_grid_layout_vertices_ [link index.count_bitset_grid_verts count_bitset_grid_layout_vertices]]
+[def __set_orthogonal_grid_layout__ [link index.set_orthogonal_grid_layout `set_orthogonal_grid_layout()`]]
+[def __set_upsilon_tessellation_layout__ [link index.set_upsilon_tessel_layout `set_upsilon_tessellation_layout()`]]
+[def __set_bitruncated_cubic_honeycomb_layout__ [link index.set_bt_cubic_hcomb_layout `set_bitruncated_cubic_honeycomb_layout()`]]
+[def __count_bitset_grid_layout_vertices__ [link index.count_bitset_grid_verts `count_bitset_grid_layout_vertices()`]]
+[def __set_bitset_grid_layout__ [link index.set_bitset_grid_layout `set_bitset_grid_layout()`]]
+[def __set_orthogonal_grid_layout__description__ [link index.set_orthogonal_grid_layout.description description]]
+[def __set_upsilon_tessellation_layout__description__ [link index.set_upsilon_tessel_layout.description description]]
+[def __set_bitruncated_cubic_honeycomb_layout__description__ [link index.set_bt_cubic_hcomb_layout.description description]]
+
+[/ Autogenerate reference documentation directly from code.]
+[/ Bypass Doxygen.]
+[import ../../../boost/graph/basic_vert_insert_iterator.hpp]
+[import ../../../boost/graph/basic_add_edge_function.hpp]
+[import ../example/orthogonal_grid_layouts.cpp]
+[import ../example/upsilon_tessellation_layout.cpp]
+[import ../example/bitruncated_cubic_honeycomb.cpp]
+[import ../example/bitset_grid_layouts.cpp]
+
+[include set_orthogonal_grid_layout.qbk]
+[include count_ortho_grid_verts.qbk]
+[include set_upsilon_tessel_layout.qbk]
+[include count_upsilon_tessel_verts.qbk]
+[include set_bt_cubic_hcomb_layout.qbk]
+[include count_bt_cubic_hcomb_verts.qbk]
+[include set_bitset_grid_layout.qbk]
+[include count_bitset_grid_verts.qbk]
+[include basic_vert_insert_iterator.qbk]
+[include basic_add_edge_function.qbk]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_bitset_grid_layout.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_bitset_grid_layout.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,348 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>set_bitset_grid_layout</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="count_bt_cubic_hcomb_verts.html" title="count_bitruncated_cubic_honeycomb_layout_vertices">
+<link rel="next" href="count_bitset_grid_verts.html" title="count_bitset_grid_layout_vertices">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_bt_cubic_hcomb_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_bitset_grid_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.set_bitset_grid_layout"></a><a class="link" href="set_bitset_grid_layout.html" title="set_bitset_grid_layout"><code class="computeroutput">set_bitset_grid_layout</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bitset_grid_layout.prototype"></a><a class="link" href="set_bitset_grid_layout.html#index.set_bitset_grid_layout.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_bitset_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that explicitly takes in all parameters is defined
+ if the <code class="computeroutput">BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_TAKES_ALL_PARAMS</code>
+ preprocessor token is defined--that is, if you set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 4 or higher. (You may also choose to leave it at its default value of
+ 5.)
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename DimensionCount
+ , typename PositionMap
+ >
+ void
+ set_bitset_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , DimensionCount dimension_count
+ , PositionMap position_map
+ );
+} // namespace boost
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bitset_grid_layout.description"></a><a class="link" href="set_bitset_grid_layout.html#index.set_bitset_grid_layout.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ This algorithm performs layout of directed or undirected graphs, associating
+ each vertex with a bitset representation of its logical index. The edge function
+ will be invoked for each pair of vertices whose bitsets differ by exactly
+ one bit.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bitset_grid_layout.definition"></a><a class="link" href="set_bitset_grid_layout.html#index.set_bitset_grid_layout.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_bitset_grid_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bitset_grid_layout.type_requirements"></a><a class="link" href="set_bitset_grid_layout.html#index.set_bitset_grid_layout.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `VertexIterator` must model the Readable Iterator and
+ Incrementable Iterator concepts.
+* `EdgeFunction` must model the Binary Function concept.
+* The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+* `DimensionCount` must model the MPL Integral Constant concept.
+* `PositionMap` must model the Writable Property Map concept.
+* The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+* If the value type of `PositionMap` is not an instantiation of
+ std::bitset, then the value that `DimensionCount` represents must be
+ greater than 1.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bitset_grid_layout.parameters"></a><a class="link" href="set_bitset_grid_layout.html#index.set_bitset_grid_layout.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">vertex_iterator</code>
+ 
+ </td>
+<td>
+ 
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ 
+ </td>
+<td>
+ 
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by <code class="literal"><a class="link" href="count_bitset_grid_verts.html" title="count_bitset_grid_layout_vertices">count_bitset_grid_layout_vertices</a>(dimension_count,
+ position_map)</code>.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">edge_function</code>
+ 
+ </td>
+<td>
+ 
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid argument.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimension_count</code>
+ 
+ </td>
+<td>
+ 
+ An MPL Integral Constant representing
+ the number of bits in each bitset to be associated with each vertex.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ If the value type of <code class="computeroutput">PositionMap</code>
+ is an instantiation of std::bitset, then an MPL Integral Constant representing
+ its size; otherwise required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each vertex to an object representing a bitset in the resulting
+ layout.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid key.
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">dummy_property_map()</code>
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ The last two parameters can be deduced by type. However, if for some reason
+ you need to specify their names, remember that the BGL
+ prefixes each Boost.Parameter
+ keyword with an underscore and defines it in the <code class="computeroutput">boost::graph::keywords</code>
+ namespace.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bitset_grid_layout.example"></a><a class="link" href="set_bitset_grid_layout.html#index.set_bitset_grid_layout.example" title="Example">Example</a>
+</h3></div></div></div>
+
+ The first graph will have a layout of bitsets, each carrying four bits. The
+ size of each bitset is fixed at compile time, but the position map holds
+ this information, so the <a class="link" href="count_bitset_grid_verts.html" title="count_bitset_grid_layout_vertices"><code class="computeroutput">count_bitset_grid_layout_vertices()</code></a>
+ function must take it in. In order for this function to be called during
+ construction of the graph, the position map must be external to the graph.
+ 
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef boost::adjacency_list<boost::vecS,boost::setS,boost::directedS>
+ MidGraph;
+ typedef std::map<
+ boost::graph_traits<MidGraph>::vertex_descriptor
+ , std::bitset<4>
+ >
+ Vertex2BitsMap;
+
+ Vertex2BitsMap v2b_map;
+ boost::associative_property_map<Vertex2BitsMap> pos_map(v2b_map);
+ MidGraph mid_graph(boost::count_bitset_grid_layout_vertices(pos_map));
+
+ boost::set_bitset_grid_layout(
+ boost::vertices(mid_graph).first
+ , boost::basic_2way_edge_adder(mid_graph)
+ , boost::position_map(pos_map)
+ );
+ boost::print_graph(mid_graph, pos_map);
+ std::cout << std::endl;
+ </pre>
+
+ 
+
+ The bitsets in the layout of the second graph will carry five bits each.
+ This time, the memory will be allocated at runtime, so the <code class="computeroutput">dimension_count</code> parameter is required.
+ Note that the order of the last two arguments can differ from the positional
+ definition of the layout function.
+ 
+
+
+
+<pre class="programlisting"> typedef boost::vertex_distance_t PositionTag;
+
+ boost::mpl::int_<5> bit_count;
+ boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,boost::dynamic_bitset<> >
+ > big_graph(
+ boost::count_bitset_grid_layout_vertices(bit_count)
+ );
+
+ boost::set_bitset_grid_layout(
+ boost::vertices(big_graph).first
+ , boost::basic_edge_adder(big_graph)
+ , boost::get(PositionTag(), big_graph)
+ , bit_count
+ );
+ boost::print_graph(big_graph, boost::get(PositionTag(), big_graph));
+
+ return 0;
+}
+</pre>
+
+ 
+
+ The complete example program can be compiled from this file: <example/bitset_grid_layouts.cpp>.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_bt_cubic_hcomb_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_bitset_grid_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_bitset_grid_layout.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_bitset_grid_layout.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,166 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:set_bitset_grid_layout `set_bitset_grid_layout`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_bitset_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+``
+
+The function prototype that explicitly takes in all parameters is defined if
+the `BOOST_GRAPH_SET_BITSET_GRID_LAYOUT_TAKES_ALL_PARAMS` preprocessor
+token is defined--that is, if you set `BOOST_PARAMETER_MAX_ARITY` to 4 or
+higher. (You may also choose to leave it at its default value of 5.)
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename DimensionCount
+ , typename PositionMap
+ >
+ void
+ set_bitset_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , DimensionCount dimension_count
+ , PositionMap position_map
+ );
+} // namespace boost
+``
+[endsect] [/ Prototype]
+
+[section Description]
+This algorithm performs layout of directed or undirected graphs, associating
+each vertex with a bitset representation of its logical index. The edge
+function will be invoked for each pair of vertices whose bitsets differ by
+exactly one bit.
+[endsect] [/ Description]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_bitset_grid_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `VertexIterator` must model the __Readable_Iterator__ and
+ __Incrementable_Iterator__ concepts.
+ * `EdgeFunction` must model the __Binary_Function__ concept.
+ * The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+ * `DimensionCount` must model the __MPL_Integral_Constant__ concept.
+ * `PositionMap` must model the __Writable_Property_Map__ concept.
+ * The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+ * If the value type of `PositionMap` is not an instantiation of
+ __std_bitset__, then the value that `DimensionCount` represents must be
+ greater than 1.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`vertex_iterator`]
+ [
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ ]
+ [
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by [^_count_bitset_grid_layout_vertices_(dimension_count,
+ position_map)].
+ ]
+ [None; always required.]
+ ]
+ [
+ [`edge_function`]
+ [
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid argument.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`dimension_count`]
+ [
+ An __MPL_Integral_Constant__ representing the number of bits in
+ each bitset to be associated with each vertex.
+ ]
+ []
+ [
+ If the value type of `PositionMap` is an instantiation of
+ __std_bitset__, then an __MPL_Integral_Constant__ representing its
+ size; otherwise required.
+ ]
+ ]
+ [
+ [`position_map`]
+ [
+ Maps each vertex to an object representing a bitset in the
+ resulting layout.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid key.
+ ]
+ [`dummy_property_map()`]
+ ]
+]
+
+The last two parameters can be deduced by type. However, if for some reason
+you need to specify their names, remember that the __BGL__ prefixes each
+__Boost_Parameter__ keyword with an underscore and defines it in the
+`boost::graph::keywords` namespace.
+[endsect] [/ Parameters]
+
+[section Example]
+The first graph will have a layout of bitsets, each carrying four bits. The
+size of each bitset is fixed at compile time, but the position map holds this
+information, so the __count_bitset_grid_layout_vertices__ function must take it
+in. In order for this function to be called during construction of the graph,
+the position map must be external to the graph.
+
+[example__bitset_grid_layouts__static]
+
+The bitsets in the layout of the second graph will carry five bits each. This
+time, the memory will be allocated at runtime, so the `dimension_count`
+parameter is required. Note that the order of the last two arguments can
+differ from the positional definition of the layout function.
+
+[example__bitset_grid_layouts__dynamic]
+
+The complete example program can be compiled from this file:
+<__example_bitset_grid_layouts_cpp__>.
+[endsect]
+
+[endsect] [/ set_bitset_grid_layout]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_bt_cubic_hcomb_layout.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_bt_cubic_hcomb_layout.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,523 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>set_bitruncated_cubic_honeycomb_layout</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="count_upsilon_tessel_verts.html" title="count_upsilon_tessellation_layout_vertices">
+<link rel="next" href="count_bt_cubic_hcomb_verts.html" title="count_bitruncated_cubic_honeycomb_layout_vertices">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_upsilon_tessel_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_bt_cubic_hcomb_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.set_bt_cubic_hcomb_layout"></a><a class="link" href="set_bt_cubic_hcomb_layout.html" title="set_bitruncated_cubic_honeycomb_layout"><code class="computeroutput">set_bitruncated_cubic_honeycomb_layout</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bt_cubic_hcomb_layout.prototype"></a><a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that explicitly takes in all parameters is defined
+ if the <code class="computeroutput">BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS</code>
+ preprocessor token is defined--that is, if you set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 9 or higher.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ , typename WraparoundPolicy
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename PositionMap
+ , typename Point
+ >
+ void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar inscribed_radius
+ , WraparoundPolicy const& wraparound_policy
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , PositionMap position_map
+ , Point const& origin
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ Otherwise, the following function prototype is defined if the <code class="computeroutput">BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_5_PARAMS</code>
+ preprocessor token is defined--that is, if you don't
+ set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than its default value of 5.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ , typename WraparoundPolicy
+ >
+ void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar inscribed_radius
+ , WraparoundPolicy const& wraparound_policy
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ If you need to pass in any additional arguments, then either you must set
+ <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 9 or higher, or you must use the first prototype instead.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bt_cubic_hcomb_layout.description"></a><a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ This algorithm performs layout of directed or undirected graphs, positioning
+ each vertex at the centroid of a <a href="http://en.wikipedia.org/wiki/Truncated_octahedron" target="_top">truncated
+ octahedron</a> in a <a href="http://en.wikipedia.org/wiki/Bitruncated_cubic_honeycomb" target="_top">bitruncated
+ cubic honeycomb</a> that fits the specified dimensions. The edge function
+ will be invoked for each pair of vertices whose corresponding <a href="http://en.wikipedia.org/wiki/Truncated_octahedron" target="_top">truncated
+ octahedra</a> share a face in the honeycomb.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bt_cubic_hcomb_layout.definition"></a><a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_bt_cubic_hcomb_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bt_cubic_hcomb_layout.type_requirements"></a><a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `VertexIterator` must model the Readable Iterator and
+ Incrementable Iterator concepts.
+* `EdgeFunction` must model the Binary Function concept.
+* The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+* `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+* If `point_factory` is not specified, then `Dimensions` must model the
+ Default Constructible concept.
+* `Scalar` must be a numeric type.
+* `WraparoundPolicy` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is `bool`.
+* `PointFactory` must model the Generator concept.
+* The return type of `PointFactory` must be convertible to `Point`.
+* `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+* `PositionMap` must model the Writable Property Map concept.
+* The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+* `Point` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+* `Point` must be usable as the value type of `PositionMap`.
+* If neither `point_factory` nor `origin` are specified, then `Dimensions`
+ must be convertible to `Point`.
+* `Scalar` and the return types of the index operators of `Dimensions` and
+ `Point` must be interoperable arithmetic-wise.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bt_cubic_hcomb_layout.parameters"></a><a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">vertex_iterator</code>
+ 
+ </td>
+<td>
+ 
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ 
+ </td>
+<td>
+ 
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by <code class="literal"><a class="link" href="count_bt_cubic_hcomb_verts.html" title="count_bitruncated_cubic_honeycomb_layout_vertices">count_bitruncated_cubic_honeycomb_layout_vertices</a>(dimensions,
+ inscribed_radius, position_index_map)</code>.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">edge_function</code>
+ 
+ </td>
+<td>
+ 
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid argument.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimensions</code>
+ 
+ </td>
+<td>
+ 
+ The physical size of the resulting layout.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ Furthermore, If <code class="computeroutput">point_factory</code>
+ is not specified, then the default constructor of <code class="computeroutput">Dimensions</code> must ensure that the
+ object returned fulfills this requirement.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">inscribed_radius</code>
+ 
+ </td>
+<td>
+ 
+ The radius of the sphere inscribed by the <a href="http://en.wikipedia.org/wiki/Truncated_octahedron" target="_top">truncated
+ octahedron</a> that each vertex represents. See the <a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.description" title="Description">description</a>
+ for further information.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">1</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">wraparound_policy</code>
+ 
+ </td>
+<td>
+ 
+ An object whose index operator returns a boolean flag indicating
+ whether or not the algorithm will allow edges to wrap around in
+ the specified dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ An object whose index operator always returns <code class="computeroutput">false</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">point_factory</code>
+ 
+ </td>
+<td>
+ 
+ A function that constructs and returns <code class="computeroutput">Point</code>
+ objects. Required if the default constructor of <code class="computeroutput">Point</code>
+ does not exist or prevents its index operator from fulfilling its
+ runtime requirement.
+ 
+ </td>
+<td>
+ 
+ The index operator of each object returned must accept values returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">value_factory<Dimensions>()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_index_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different dimensional
+ planes.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values in the range <code class="computeroutput">[0, 2]</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">identity_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each vertex to a <code class="computeroutput">Point</code>
+ object representing a position in the resulting layout.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid key.
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">dummy_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">origin</code>
+ 
+ </td>
+<td>
+ 
+ An object representing the vertex position whose coordinates are
+ at the lower bound of each dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ A <code class="computeroutput">Point</code> whose index
+ operator returns zero for each of the input dimensions returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ Remember that the BGL
+ prefixes each Boost.Parameter
+ keyword with an underscore and defines it in the <code class="computeroutput">boost::graph::keywords</code>
+ namespace.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_bt_cubic_hcomb_layout.example"></a><a class="link" href="set_bt_cubic_hcomb_layout.html#index.set_bt_cubic_hcomb_layout.example" title="Example">Example</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef boost::numeric::ublas::vector<double> Point;
+ typedef boost::vertex_distance_t PositionTag;
+
+ Point dimensions(3);
+
+ dimensions(0) = dimensions(1) = 7.0;
+ dimensions(2) = 8.0;
+
+ boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,Point>
+ > graph(
+ boost::count_bitruncated_cubic_honeycomb_layout_vertices(dimensions)
+ );
+ boost::array<bool,3> wraparound_policy = {{false, true, true}};
+
+#ifdef BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+ boost::set_bitruncated_cubic_honeycomb_layout(
+ boost::vertices(graph).first
+ , boost::basic_2way_edge_adder(graph)
+ , dimensions
+ , boost::graph::keywords::_wraparound_policy = wraparound_policy
+ , boost::graph::keywords::_point_factory = boost::phoenix::val(Point(3))
+ , boost::graph::keywords::_position_map = boost::get(
+ PositionTag()
+ , graph
+ )
+ );
+#else // !BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+ boost::set_bitruncated_cubic_honeycomb_layout(
+ boost::vertices(graph).first
+ , boost::basic_2way_edge_adder(graph)
+ , boost::dimensions(
+ dimensions
+ ).wraparound_policy(
+ wraparound_policy
+ ).point_factory(
+ boost::phoenix::val(Point(3))
+ ).position_map(
+ boost::get(PositionTag(), graph)
+ )
+ );
+#endif // BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+ boost::print_graph(graph, boost::get(PositionTag(), graph));
+
+ return 0;
+}
+</pre>
+
+ 
+
+ The complete example program can be compiled from this file: <example/bitruncated_cubic_honeycomb.cpp>.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_upsilon_tessel_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_bt_cubic_hcomb_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_bt_cubic_hcomb_layout.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_bt_cubic_hcomb_layout.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,268 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:set_bt_cubic_hcomb_layout `set_bitruncated_cubic_honeycomb_layout`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+``
+
+The function prototype that explicitly takes in all parameters is defined if
+the `BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS` preprocessor
+token is defined--that is, if you set `BOOST_PARAMETER_MAX_ARITY` to 9 or
+higher.
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ , typename WraparoundPolicy
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename PositionMap
+ , typename Point
+ >
+ void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar inscribed_radius
+ , WraparoundPolicy const& wraparound_policy
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , PositionMap position_map
+ , Point const& origin
+ );
+} // namespace boost
+``
+
+Otherwise, the following function prototype is defined if the
+`BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_5_PARAMS` preprocessor token
+is defined--that is, if you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than
+its default value of 5.
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ , typename WraparoundPolicy
+ >
+ void
+ set_bitruncated_cubic_honeycomb_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar inscribed_radius
+ , WraparoundPolicy const& wraparound_policy
+ );
+} // namespace boost
+``
+
+If you need to pass in any additional arguments, then either you must set
+`BOOST_PARAMETER_MAX_ARITY` to 9 or higher, or you must use the first prototype
+instead.
+[endsect] [/ Prototype]
+
+[section Description]
+This algorithm performs layout of directed or undirected graphs, positioning
+each vertex at the centroid of a __truncated_octahedron__ in a
+__bitruncated_cubic_honeycomb__ that fits the specified dimensions. The edge
+function will be invoked for each pair of vertices whose corresponding
+__truncated_octahedra__ share a face in the honeycomb.
+[endsect] [/ Description]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_bt_cubic_hcomb_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `VertexIterator` must model the __Readable_Iterator__ and
+ __Incrementable_Iterator__ concepts.
+ * `EdgeFunction` must model the __Binary_Function__ concept.
+ * The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+ * `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+ * If `point_factory` is not specified, then `Dimensions` must model the
+ __Default_Constructible__ concept.
+ * `Scalar` must be a numeric type.
+ * `WraparoundPolicy` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is `bool`.
+ * `PointFactory` must model the __Generator__ concept.
+ * The return type of `PointFactory` must be convertible to `Point`.
+ * `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+ * `PositionMap` must model the __Writable_Property_Map__ concept.
+ * The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+ * `Point` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+ * `Point` must be usable as the value type of `PositionMap`.
+ * If neither `point_factory` nor `origin` are specified, then `Dimensions`
+ must be convertible to `Point`.
+ * `Scalar` and the return types of the index operators of `Dimensions` and
+ `Point` must be interoperable arithmetic-wise.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`vertex_iterator`]
+ [
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ ]
+ [
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by
+ [^_count_bitruncated_cubic_honeycomb_layout_vertices_(dimensions,
+ inscribed_radius, position_index_map)].
+ ]
+ [None; always required.]
+ ]
+ [
+ [`edge_function`]
+ [
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid argument.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`dimensions`]
+ [The physical size of the resulting layout.]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`. Furthermore, If `point_factory`
+ is not specified, then the default constructor of `Dimensions`
+ must ensure that the object returned fulfills this requirement.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`inscribed_radius`]
+ [
+ The radius of the sphere inscribed by the __truncated_octahedron__
+ that each vertex represents. See the
+ __set_bitruncated_cubic_honeycomb_layout__description__ for further
+ information.
+ ]
+ []
+ [`1`]
+ ]
+ [
+ [`wraparound_policy`]
+ [
+ An object whose index operator returns a boolean flag indicating
+ whether or not the algorithm will allow edges to wrap around in
+ the specified dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [An object whose index operator always returns `false`.]
+ ]
+ [
+ [`point_factory`]
+ [
+ A function that constructs and returns `Point` objects. Required
+ if the default constructor of `Point` does not exist or prevents
+ its index operator from fulfilling its runtime requirement.
+ ]
+ [
+ The index operator of each object returned must accept values
+ returned by the index operator of `position_index_map`.
+ ]
+ [[^_value_factory_<Dimensions>()]]
+ ]
+ [
+ [`position_index_map`]
+ [
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different
+ dimensional planes.
+ ]
+ [The index operator must accept values in the range `[0, 2]`.]
+ [[^_identity_property_map_()]]
+ ]
+ [
+ [`position_map`]
+ [
+ Maps each vertex to a `Point` object representing a position in the
+ resulting layout.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid key.
+ ]
+ [`dummy_property_map()`]
+ ]
+ [
+ [`origin`]
+ [
+ An object representing the vertex position whose coordinates are
+ at the lower bound of each dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [
+ A `Point` whose index operator returns zero for each of the input
+ dimensions returned by the index operator of `position_index_map`.
+ ]
+ ]
+]
+
+Remember that the __BGL__ prefixes each __Boost_Parameter__ keyword with an
+underscore and defines it in the `boost::graph::keywords` namespace.
+[endsect] [/ Parameters]
+
+[section Example]
+[example__bitruncated_cubic_honeycomb]
+
+The complete example program can be compiled from this file:
+<__example_bitruncated_cubic_honeycomb_cpp__>.
+[endsect]
+
+[endsect] [/ set_bitruncated_cubic_honeycomb_layout]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_orthogonal_grid_layout.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_orthogonal_grid_layout.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,601 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>set_orthogonal_grid_layout</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="../index.html" title="index 0.1">
+<link rel="next" href="count_ortho_grid_verts.html" title="count_orthogonal_grid_layout_vertices">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_ortho_grid_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.set_orthogonal_grid_layout"></a><a class="link" href="set_orthogonal_grid_layout.html" title="set_orthogonal_grid_layout"><code class="computeroutput">set_orthogonal_grid_layout</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_orthogonal_grid_layout.prototype"></a><a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that explicitly takes in all parameters is defined
+ if the <code class="computeroutput">BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_ALL_PARAMS</code>
+ preprocessor token is defined--that is, if you set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 11 or higher.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename DimensionCount
+ , typename WraparoundPolicy
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename Scale
+ , typename PositionMap
+ , typename Point
+ >
+ void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , DimensionCount dimension_count
+ , bool is_zeta
+ , WraparoundPolicy const& wraparound_policy
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , Scale const& scale
+ , PositionMap position_map
+ , Point const& origin
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ Otherwise, the following function prototype is defined if the <code class="computeroutput">BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_5_PARAMS</code>
+ preprocessor token is defined--that is, if you don't
+ set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than its default value of 5.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename DimensionCount
+ >
+ void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , DimensionCount dimension_count
+ , bool is_zeta
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ If you need to pass in any additional arguments, then either you must set
+ <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 11 or higher, or you must use the first prototype instead.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_orthogonal_grid_layout.description"></a><a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ This algorithm performs layout of directed or undirected graphs, positioning
+ each vertex at a point in a standard rectangular grid that fits the specified
+ dimensions. The edge function will be invoked for each pair of vertices that
+ are horizontally or vertically next to each other in the layout. If a zeta layout is
+ requested, then the edge function will also be invoked for each pair of vertices
+ that are diagonally next to each other.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_orthogonal_grid_layout.definition"></a><a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_orthogonal_grid_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_orthogonal_grid_layout.type_requirements"></a><a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `VertexIterator` must model the Readable Iterator and
+ Incrementable Iterator concepts.
+* `EdgeFunction` must model the Binary Function concept.
+* The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+* `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+* If `point_factory` is not specified, then `Dimensions` must model the
+ Default Constructible concept.
+* `DimensionCount` must model the MPL Integral Constant concept.
+* The value that `DimensionCount` represents must be greater than 1.
+* `WraparoundPolicy` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is `bool`.
+* `PointFactory` must model the Generator concept.
+* The return type of `PointFactory` must be convertible to `Point`.
+* `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+* `Scale` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+* If neither `point_factory` nor `scale` are specified, then `Dimensions`
+ must be convertible to `Scale`.
+* `PositionMap` must model the Writable Property Map concept.
+* The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+* `Point` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+* `Point` must be usable as the value type of `PositionMap`.
+* If neither `point_factory` nor `origin` are specified, then `Dimensions`
+ must be convertible to `Point`.
+* The return types of the index operators of `Dimensions`, `Scale`, and
+ `Point` must be interoperable arithmetic-wise.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_orthogonal_grid_layout.parameters"></a><a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">vertex_iterator</code>
+ 
+ </td>
+<td>
+ 
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ 
+ </td>
+<td>
+ 
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by <code class="literal"><a class="link" href="count_ortho_grid_verts.html" title="count_orthogonal_grid_layout_vertices">count_orthogonal_grid_layout_vertices</a>(dimensions,
+ dimension_count, point_factory, position_index_map, scale)</code>.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">edge_function</code>
+ 
+ </td>
+<td>
+ 
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid argument.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimensions</code>
+ 
+ </td>
+<td>
+ 
+ The physical size of the resulting layout.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ Furthermore, If <code class="computeroutput">point_factory</code>
+ is not specified, then the default constructor of <code class="computeroutput">Dimensions</code> must ensure that the
+ object returned fulfills this requirement.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimension_count</code>
+ 
+ </td>
+<td>
+ 
+ An MPL Integral Constant representing
+ the number of dimensions the resulting layout will straddle.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ An MPL Integral Constant representing
+ the value <code class="computeroutput">2</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">is_zeta</code>
+ 
+ </td>
+<td>
+ 
+ A boolean flag that controls whether or not the algorithm will
+ recognize diagonal edges. In two dimensions, setting this flag
+ to <code class="computeroutput">true</code> means that
+ a vertex will have 8 neighbors instead of 4; in three dimensions,
+ a vertex will have 26 neighbors instead of 6; in N dimensions,
+ a vertex will have (3 ^ N - 1) neighbors instead of 2 * N (assuming
+ wraparound is allowed for all dimensions). See the <a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.description" title="Description">description</a>
+ for further information.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">false</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">wraparound_policy</code>
+ 
+ </td>
+<td>
+ 
+ An object whose index operator returns a boolean flag indicating
+ whether or not the algorithm will allow edges to wrap around in
+ the specified dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ An object whose index operator always returns <code class="computeroutput">false</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">point_factory</code>
+ 
+ </td>
+<td>
+ 
+ A function that constructs and returns <code class="computeroutput">Point</code>
+ objects. Required if the default constructor of <code class="computeroutput">Point</code>
+ does not exist or prevents its index operator from fulfilling its
+ runtime requirement.
+ 
+ </td>
+<td>
+ 
+ The index operator of each object returned must accept values returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">value_factory<Dimensions>()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_index_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different orthogonal layouts to reside on different dimensional
+ planes.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values in the range <code class="computeroutput">[0, DimensionCount::value)</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">identity_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">scale</code>
+ 
+ </td>
+<td>
+ 
+ An object representing the distance between two adjacent vertices
+ in each dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ A <code class="computeroutput">Point</code> whose index
+ operator returns one for each of the input dimensions returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each vertex to a <code class="computeroutput">Point</code>
+ object representing a position in the resulting layout.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid key.
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">dummy_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">origin</code>
+ 
+ </td>
+<td>
+ 
+ An object representing the vertex position whose coordinates are
+ at the lower bound of each dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ A <code class="computeroutput">Point</code> whose index
+ operator returns zero for each of the input dimensions returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ Remember that the BGL
+ prefixes each Boost.Parameter
+ keyword with an underscore and defines it in the <code class="computeroutput">boost::graph::keywords</code>
+ namespace.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_orthogonal_grid_layout.example"></a><a class="link" href="set_orthogonal_grid_layout.html#index.set_orthogonal_grid_layout.example" title="Example">Example</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef boost::numeric::ublas::vector<double> Point;
+ typedef boost::vertex_distance_t PositionTag;
+
+ Point origin(3), scale(3), dimensions(3);
+
+ scale(0) = 2.0;
+ scale(1) = scale(2) = 1.0;
+ dimensions(0) = dimensions(1) = 6.0;
+ dimensions(2) = 3.0;
+
+ boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,Point>
+ > graph(
+ boost::count_orthogonal_grid_layout_vertices(
+ dimensions
+ , boost::mpl::int_<3>()
+ , boost::graph::keywords::_scale = scale
+ )
+ );
+ boost::array<bool,3> wraparound_policy = {{true, false, true}};
+
+ origin(0) = -2.0;
+ origin(1) = -2.5;
+ origin(2) = -1.0;
+ boost::set_orthogonal_grid_layout(
+ boost::vertices(graph).first
+ , boost::basic_2way_edge_adder(graph)
+ , boost::position_map(
+ boost::get(PositionTag(), graph)
+ ).is_zeta(
+ true
+ ).dimension_count(
+ boost::mpl::int_<3>()
+ ).dimensions(
+ dimensions
+ ).scale(
+ scale
+ ).origin(
+ origin
+ ).point_factory(
+ boost::phoenix::val(Point(3))
+ ).wraparound_policy(
+ wraparound_policy
+ )
+ );
+ boost::print_graph(graph, boost::get(PositionTag(), graph));
+ std::cout << std::endl;
+ graph.clear();
+ boost::set_orthogonal_grid_layout(
+ boost::basic_vertex_inserter(graph)
+ , boost::basic_2way_edge_adder(graph)
+ , dimensions
+ , boost::graph::keywords::_scale = scale
+ , boost::graph::keywords::_origin = origin
+ , boost::graph::keywords::_position_map = boost::get(
+ PositionTag()
+ , graph
+ )
+ , boost::graph::keywords::_point_factory = boost::phoenix::val(Point(2))
+ , boost::graph::keywords::_wraparound_policy = wraparound_policy
+ );
+ boost::print_graph(graph, boost::get(PositionTag(), graph));
+
+ return 0;
+}
+</pre>
+
+ 
+
+ The complete example program can be compiled from this file: <example/orthogonal_grid_layouts.cpp>.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_ortho_grid_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_orthogonal_grid_layout.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_orthogonal_grid_layout.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,306 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:set_orthogonal_grid_layout `set_orthogonal_grid_layout`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+``
+
+The function prototype that explicitly takes in all parameters is defined if
+the `BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_ALL_PARAMS` preprocessor
+token is defined--that is, if you set `BOOST_PARAMETER_MAX_ARITY` to 11 or
+higher.
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename DimensionCount
+ , typename WraparoundPolicy
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename Scale
+ , typename PositionMap
+ , typename Point
+ >
+ void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , DimensionCount dimension_count
+ , bool is_zeta
+ , WraparoundPolicy const& wraparound_policy
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , Scale const& scale
+ , PositionMap position_map
+ , Point const& origin
+ );
+} // namespace boost
+``
+
+Otherwise, the following function prototype is defined if the
+`BOOST_GRAPH_SET_ORTHOGONAL_GRID_LAYOUT_TAKES_5_PARAMS` preprocessor token is
+defined--that is, if you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than its
+default value of 5.
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename DimensionCount
+ >
+ void
+ set_orthogonal_grid_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , DimensionCount dimension_count
+ , bool is_zeta
+ );
+} // namespace boost
+``
+
+If you need to pass in any additional arguments, then either you must set
+`BOOST_PARAMETER_MAX_ARITY` to 11 or higher, or you must use the first
+prototype instead.
+[endsect] [/ Prototype]
+
+[section Description]
+This algorithm performs layout of directed or undirected graphs, positioning
+each vertex at a point in a standard rectangular grid that fits the specified
+dimensions. The edge function will be invoked for each pair of vertices that
+are horizontally or vertically next to each other in the layout. If a
+__zeta_layout__ is requested, then the edge function will also be invoked for
+each pair of vertices that are diagonally next to each other.
+[endsect] [/ Description]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_orthogonal_grid_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `VertexIterator` must model the __Readable_Iterator__ and
+ __Incrementable_Iterator__ concepts.
+ * `EdgeFunction` must model the __Binary_Function__ concept.
+ * The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+ * `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+ * If `point_factory` is not specified, then `Dimensions` must model the
+ __Default_Constructible__ concept.
+ * `DimensionCount` must model the __MPL_Integral_Constant__ concept.
+ * The value that `DimensionCount` represents must be greater than 1.
+ * `WraparoundPolicy` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is `bool`.
+ * `PointFactory` must model the __Generator__ concept.
+ * The return type of `PointFactory` must be convertible to `Point`.
+ * `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+ * `Scale` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+ * If neither `point_factory` nor `scale` are specified, then `Dimensions`
+ must be convertible to `Scale`.
+ * `PositionMap` must model the __Writable_Property_Map__ concept.
+ * The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+ * `Point` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+ * `Point` must be usable as the value type of `PositionMap`.
+ * If neither `point_factory` nor `origin` are specified, then `Dimensions`
+ must be convertible to `Point`.
+ * The return types of the index operators of `Dimensions`, `Scale`, and
+ `Point` must be interoperable arithmetic-wise.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`vertex_iterator`]
+ [
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ ]
+ [
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by [^_count_orthogonal_grid_layout_vertices_(dimensions,
+ dimension_count, point_factory, position_index_map, scale)].
+ ]
+ [None; always required.]
+ ]
+ [
+ [`edge_function`]
+ [
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid argument.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`dimensions`]
+ [The physical size of the resulting layout.]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`. Furthermore, If `point_factory`
+ is not specified, then the default constructor of `Dimensions`
+ must ensure that the object returned fulfills this requirement.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`dimension_count`]
+ [
+ An __MPL_Integral_Constant__ representing the number of dimensions
+ the resulting layout will straddle.
+ ]
+ []
+ [An __MPL_Integral_Constant__ representing the value `2`.]
+ ]
+ [
+ [`is_zeta`]
+ [
+ A boolean flag that controls whether or not the algorithm will
+ recognize diagonal edges. In two dimensions, setting this flag to
+ `true` means that a vertex will have 8 neighbors instead of 4; in
+ three dimensions, a vertex will have 26 neighbors instead of 6;
+ in N dimensions, a vertex will have (3 ^ N - 1) neighbors instead
+ of 2 * N (assuming wraparound is allowed for all dimensions). See
+ the __set_orthogonal_grid_layout__description__ for further
+ information.
+ ]
+ []
+ [`false`]
+ ]
+ [
+ [`wraparound_policy`]
+ [
+ An object whose index operator returns a boolean flag indicating
+ whether or not the algorithm will allow edges to wrap around in
+ the specified dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [An object whose index operator always returns `false`.]
+ ]
+ [
+ [`point_factory`]
+ [
+ A function that constructs and returns `Point` objects. Required
+ if the default constructor of `Point` does not exist or prevents
+ its index operator from fulfilling its runtime requirement.
+ ]
+ [
+ The index operator of each object returned must accept values
+ returned by the index operator of `position_index_map`.
+ ]
+ [[^_value_factory_<Dimensions>()]]
+ ]
+ [
+ [`position_index_map`]
+ [
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different orthogonal layouts to reside on different dimensional
+ planes.
+ ]
+ [
+ The index operator must accept values in the range
+ `[0, DimensionCount::value)`.
+ ]
+ [[^_identity_property_map_()]]
+ ]
+ [
+ [`scale`]
+ [
+ An object representing the distance between two adjacent vertices
+ in each dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [
+ A `Point` whose index operator returns one for each of the input
+ dimensions returned by the index operator of `position_index_map`.
+ ]
+ ]
+ [
+ [`position_map`]
+ [
+ Maps each vertex to a `Point` object representing a position in the
+ resulting layout.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid key.
+ ]
+ [`dummy_property_map()`]
+ ]
+ [
+ [`origin`]
+ [
+ An object representing the vertex position whose coordinates are
+ at the lower bound of each dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [
+ A `Point` whose index operator returns zero for each of the input
+ dimensions returned by the index operator of `position_index_map`.
+ ]
+ ]
+]
+
+Remember that the __BGL__ prefixes each __Boost_Parameter__ keyword with an
+underscore and defines it in the `boost::graph::keywords` namespace.
+[endsect] [/ Parameters]
+
+[section Example]
+[example__orthogonal_grid_layouts]
+
+The complete example program can be compiled from this file:
+<__example_orthogonal_grid_layouts_cpp__>.
+[endsect]
+
+[endsect] [/ set_orthogonal_grid_layout]
+

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_upsilon_tessel_layout.html
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_upsilon_tessel_layout.html 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,548 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>set_upsilon_tessellation_layout</title>
+<link rel="stylesheet" href="../doc/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<link rel="home" href="../index.html" title="index 0.1">
+<link rel="up" href="../index.html" title="index 0.1">
+<link rel="prev" href="count_ortho_grid_verts.html" title="count_orthogonal_grid_layout_vertices">
+<link rel="next" href="count_upsilon_tessel_verts.html" title="count_upsilon_tessellation_layout_vertices">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr><td valign="top"><img alt="C++ Boost" width="277" height="86" src="../../../boost.png"></td></tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_ortho_grid_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_upsilon_tessel_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="index.set_upsilon_tessel_layout"></a><a class="link" href="set_upsilon_tessel_layout.html" title="set_upsilon_tessellation_layout"><code class="computeroutput">set_upsilon_tessellation_layout</code></a>
+</h2></div></div></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_upsilon_tessel_layout.prototype"></a><a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.prototype" title="Prototype">Prototype</a>
+</h3></div></div></div>
+
+ The function prototype that takes in <a href="http://www.boost.org/libs/graph/doc/bgl_named_params.html" target="_top">old-style
+ named parameters</a> is always defined.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ The function prototype that explicitly takes in all parameters is defined
+ if the <code class="computeroutput">BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_ALL_PARAMS</code>
+ preprocessor token is defined--that is, if you set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 10 or higher.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ , typename WraparoundPolicy
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename PositionMap
+ , typename Point
+ >
+ void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar vertex_centroid_distance
+ , bool has_square_origin
+ , WraparoundPolicy const& wraparound_policy
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , PositionMap position_map
+ , Point const& origin
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ Otherwise, the following function prototype is defined if the <code class="computeroutput">BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_5_PARAMS</code>
+ preprocessor token is defined--that is, if you don't
+ set <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ lower than its default value of 5.
+ 
+
+
+
+<pre class="programlisting">namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ >
+ void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar vertex_centroid_distance
+ , bool has_square_origin
+ );
+} // namespace boost
+</pre>
+
+ 
+
+ If you need to pass in any additional arguments, then either you must set
+ <code class="computeroutput">BOOST_PARAMETER_MAX_ARITY</code>
+ to 10 or higher, or you must use the first prototype instead.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_upsilon_tessel_layout.description"></a><a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.description" title="Description">Description</a>
+</h3></div></div></div>
+
+ This algorithm performs layout of directed or undirected graphs, positioning
+ each vertex at the centroid of a square or an octagon in an <a href="http://www.astrolog.org/labyrnth/algrithm.htm" target="_top">upsilon
+ tessellation</a> that fits the specified dimensions. The edge function
+ will be invoked for each pair of vertices whose corresponding polygons share
+ a physical edge in the tessellation.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_upsilon_tessel_layout.definition"></a><a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.definition" title="Where Defined">Where Defined</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">#include <boost/graph/set_upsilon_tessel_layout.hpp>
+</pre>
+
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_upsilon_tessel_layout.type_requirements"></a><a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.type_requirements" title="Type Requirements">Type
+ Requirements</a>
+</h3></div></div></div>
+<pre class="programlisting">* `VertexIterator` must model the Readable Iterator and
+ Incrementable Iterator concepts.
+* `EdgeFunction` must model the Binary Function concept.
+* The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+* `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+* If `point_factory` is not specified, then `Dimensions` must model the
+ Default Constructible concept.
+* `Scalar` must be a numeric type.
+* `WraparoundPolicy` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is `bool`.
+* `PointFactory` must model the Generator concept.
+* The return type of `PointFactory` must be convertible to `Point`.
+* `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+* `PositionMap` must model the Writable Property Map concept.
+* The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+* `Point` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+* `Point` must be usable as the value type of `PositionMap`.
+* If neither `point_factory` nor `origin` are specified, then `Dimensions`
+ must be convertible to `Point`.
+* `Scalar` and the return types of the index operators of `Dimensions` and
+ `Point` must be interoperable arithmetic-wise.
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_upsilon_tessel_layout.parameters"></a><a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.parameters" title="Parameters">Parameters</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Parameter
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Runtime requirements
+ 
+ </th>
+<th>
+ 
+ Default
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ <code class="computeroutput">vertex_iterator</code>
+ 
+ </td>
+<td>
+ 
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ 
+ </td>
+<td>
+ 
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by <code class="literal"><a class="link" href="count_upsilon_tessel_verts.html" title="count_upsilon_tessellation_layout_vertices">count_upsilon_tessellation_layout_vertices</a>(dimensions,
+ vertex_centroid_distance, position_index_map)</code>.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">edge_function</code>
+ 
+ </td>
+<td>
+ 
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid argument.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">dimensions</code>
+ 
+ </td>
+<td>
+ 
+ The physical size of the resulting layout.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ Furthermore, If <code class="computeroutput">point_factory</code>
+ is not specified, then the default constructor of <code class="computeroutput">Dimensions</code> must ensure that the
+ object returned fulfills this requirement.
+ 
+ </td>
+<td>
+ 
+ None; always required.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">vertex_centroid_distance</code>
+ 
+ </td>
+<td>
+ 
+ The distance between two orthogonally adjacent vertices.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">1</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">has_square_origin</code>
+ 
+ </td>
+<td>
+ 
+ A boolean flag that controls whether the vertex at the origin represents
+ a square or an octagon. See the <a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.description" title="Description">description</a>
+ for further information.
+ 
+ </td>
+<td>
+ </td>
+<td>
+ 
+ <code class="computeroutput">false</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">wraparound_policy</code>
+ 
+ </td>
+<td>
+ 
+ An object whose index operator returns a boolean flag indicating
+ whether or not the algorithm will allow edges to wrap around in
+ the specified dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ An object whose index operator always returns <code class="computeroutput">false</code>.
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">point_factory</code>
+ 
+ </td>
+<td>
+ 
+ A function that constructs and returns <code class="computeroutput">Point</code>
+ objects. Required if the default constructor of <code class="computeroutput">Point</code>
+ does not exist or prevents its index operator from fulfilling its
+ runtime requirement.
+ 
+ </td>
+<td>
+ 
+ The index operator of each object returned must accept values returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">value_factory<Dimensions>()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_index_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different dimensional
+ planes.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values in the range <code class="computeroutput">[0, 1]</code>.
+ 
+ </td>
+<td>
+ 
+ <code class="literal">identity_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">position_map</code>
+ 
+ </td>
+<td>
+ 
+ Maps each vertex to a <code class="computeroutput">Point</code>
+ object representing a position in the resulting layout.
+ 
+ </td>
+<td>
+ 
+ Each vertex descriptor dereferenced from <code class="computeroutput">vertex_iterator</code>
+ must be a valid key.
+ 
+ </td>
+<td>
+ 
+ <code class="computeroutput">dummy_property_map()</code>
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">origin</code>
+ 
+ </td>
+<td>
+ 
+ An object representing the vertex position whose coordinates are
+ at the lower bound of each dimension.
+ 
+ </td>
+<td>
+ 
+ The index operator must accept values returned by the index operator
+ of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+<td>
+ 
+ A <code class="computeroutput">Point</code> whose index
+ operator returns zero for each of the input dimensions returned
+ by the index operator of <code class="computeroutput">position_index_map</code>.
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+
+ Remember that the BGL
+ prefixes each Boost.Parameter
+ keyword with an underscore and defines it in the <code class="computeroutput">boost::graph::keywords</code>
+ namespace.
+ 
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="index.set_upsilon_tessel_layout.example"></a><a class="link" href="set_upsilon_tessel_layout.html#index.set_upsilon_tessel_layout.example" title="Example">Example</a>
+</h3></div></div></div>
+
+
+
+<pre class="programlisting">int main()
+{
+ typedef boost::numeric::ublas::vector<double> Point;
+ typedef boost::vertex_distance_t PositionTag;
+ typedef boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,Point>
+ >
+ Graph;
+
+ Point dimensions(2);
+
+ dimensions(0) = 5.0;
+ dimensions(1) = 4.0;
+
+ Graph g(boost::count_upsilon_tessellation_layout_vertices(dimensions));
+ boost::array<bool,2> wraparound_policy = {{true, false}};
+
+ boost::set_upsilon_tessellation_layout(
+ boost::vertices(g).first
+ , boost::basic_2way_edge_adder(g)
+ , boost::dimensions(
+ dimensions
+ ).has_square_origin(
+ true
+ ).wraparound_policy(
+ wraparound_policy
+ ).point_factory(
+ boost::phoenix::val(Point(2))
+ ).position_map(
+ boost::get(PositionTag(), g)
+ )
+ );
+ boost::print_graph(g, boost::get(PositionTag(), g));
+ std::cout << std::endl;
+
+ boost::graph_traits<Graph>::vertex_iterator vi, vi_end;
+
+ for (std::tr1::tie(vi, vi_end) = boost::vertices(g); vi != vi_end; ++vi)
+ {
+ boost::clear_vertex(*vi, g);
+ }
+
+ wraparound_policy[1] = true;
+ boost::set_upsilon_tessellation_layout(
+ boost::vertices(g).first
+ , boost::basic_2way_edge_adder(g)
+ , dimensions
+ , boost::graph::keywords::_wraparound_policy = wraparound_policy
+ , boost::graph::keywords::_point_factory = boost::phoenix::val(Point(2))
+ , boost::graph::keywords::_position_map = boost::get(PositionTag(), g)
+ );
+ boost::print_graph(g, boost::get(PositionTag(), g));
+
+ return 0;
+}
+</pre>
+
+ 
+
+ The complete example program can be compiled from this file: <example/upsilon_tessellation_layout.cpp>.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2011 Cromwell D. Enage
+ Distributed under 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)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="count_ortho_grid_verts.html"><img src="../doc/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../doc/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../doc/images/home.png" alt="Home"></a><a accesskey="n" href="count_upsilon_tessel_verts.html"><img src="../doc/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/graph-intrusive_layout/libs/graph/doc/set_upsilon_tessel_layout.qbk
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/doc/set_upsilon_tessel_layout.qbk 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,274 @@
+[/=============================================================================
+ Copyright (C) 2011 Cromwell D. Enage
+
+ Distributed under 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])
+=============================================================================/]
+
+[section:set_upsilon_tessel_layout `set_upsilon_tessellation_layout`]
+
+[section Prototype]
+The function prototype that takes in __old_style_named_parameters__ is always
+defined.
+
+``
+namespace boost {
+
+ template <typename VertexIterator, typename EdgeFunction, typename Params>
+ void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Params const& params
+ );
+} // namespace boost
+``
+
+The function prototype that explicitly takes in all parameters is defined if
+the `BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_ALL_PARAMS` preprocessor
+token is defined--that is, if you set `BOOST_PARAMETER_MAX_ARITY` to 10 or
+higher.
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ , typename WraparoundPolicy
+ , typename PointFactory
+ , typename PositionIndexMap
+ , typename PositionMap
+ , typename Point
+ >
+ void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar vertex_centroid_distance
+ , bool has_square_origin
+ , WraparoundPolicy const& wraparound_policy
+ , PointFactory point_factory
+ , PositionIndexMap position_index_map
+ , PositionMap position_map
+ , Point const& origin
+ );
+} // namespace boost
+``
+
+Otherwise, the following function prototype is defined if the
+`BOOST_GRAPH_SET_UPSILON_TESSELLATION_LAYOUT_TAKES_5_PARAMS` preprocessor token
+is defined--that is, if you /don't/ set `BOOST_PARAMETER_MAX_ARITY` lower than
+its default value of 5.
+
+``
+namespace boost {
+
+ template <
+ typename VertexIterator
+ , typename EdgeFunction
+ , typename Dimensions
+ , typename Scalar
+ >
+ void
+ set_upsilon_tessellation_layout(
+ VertexIterator vertex_iterator
+ , EdgeFunction edge_function
+ , Dimensions const& dimensions
+ , Scalar vertex_centroid_distance
+ , bool has_square_origin
+ );
+} // namespace boost
+``
+
+If you need to pass in any additional arguments, then either you must set
+`BOOST_PARAMETER_MAX_ARITY` to 10 or higher, or you must use the first
+prototype instead.
+[endsect] [/ Prototype]
+
+[section Description]
+This algorithm performs layout of directed or undirected graphs, positioning
+each vertex at the centroid of a square or an octagon in an
+__upsilon_tessellation__ that fits the specified dimensions. The edge function
+will be invoked for each pair of vertices whose corresponding polygons share a
+physical edge in the tessellation.
+[endsect] [/ Description]
+
+[section:definition Where Defined]
+``
+#include <__boost_graph_set_upsilon_tessel_layout_hpp__>
+``
+[endsect]
+
+[section Type Requirements]
+
+ * `VertexIterator` must model the __Readable_Iterator__ and
+ __Incrementable_Iterator__ concepts.
+ * `EdgeFunction` must model the __Binary_Function__ concept.
+ * The value type of `VertexIterator` must be convertible to both the first
+ and second argument types of `EdgeFunction`.
+ * `Dimensions` must implement an index operator that accepts an integer type
+ as a valid argument and whose return type is a reference to a numeric type.
+ * If `point_factory` is not specified, then `Dimensions` must model the
+ __Default_Constructible__ concept.
+ * `Scalar` must be a numeric type.
+ * `WraparoundPolicy` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is `bool`.
+ * `PointFactory` must model the __Generator__ concept.
+ * The return type of `PointFactory` must be convertible to `Point`.
+ * `PositionIndexMap` must implement an index operator that accepts an integer
+ type as a valid argument and whose return type is also an integer type.
+ * `PositionMap` must model the __Writable_Property_Map__ concept.
+ * The value type of `VertexIterator` must be usable as the key type of
+ `PositionMap`.
+ * `Point` must implement an index operator that accepts an integer type as a
+ valid argument and whose return type is a reference to a numeric type.
+ * `Point` must be usable as the value type of `PositionMap`.
+ * If neither `point_factory` nor `origin` are specified, then `Dimensions`
+ must be convertible to `Point`.
+ * `Scalar` and the return types of the index operators of `Dimensions` and
+ `Point` must be interoperable arithmetic-wise.
+
+[endsect]
+
+[section Parameters]
+[table
+ [[Parameter][Description][Runtime requirements][Default]]
+ [
+ [`vertex_iterator`]
+ [
+ An iterator over the vertices of a graph. The algorithm will store
+ copies of the vertex descriptors dereferenced from it.
+ ]
+ [
+ If this iterator points to the beginning of a range of vertices
+ in a graph, then this range must at least as large as the value
+ returned by
+ [^_count_upsilon_tessellation_layout_vertices_(dimensions,
+ vertex_centroid_distance, position_index_map)].
+ ]
+ [None; always required.]
+ ]
+ [
+ [`edge_function`]
+ [
+ A function that is invoked each time the algorithm recognizes the
+ input vertices as edges.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid argument.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`dimensions`]
+ [The physical size of the resulting layout.]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`. Furthermore, If `point_factory`
+ is not specified, then the default constructor of `Dimensions`
+ must ensure that the object returned fulfills this requirement.
+ ]
+ [None; always required.]
+ ]
+ [
+ [`vertex_centroid_distance`]
+ [The distance between two orthogonally adjacent vertices.]
+ []
+ [`1`]
+ ]
+ [
+ [`has_square_origin`]
+ [
+ A boolean flag that controls whether the vertex at the origin
+ represents a square or an octagon. See the
+ __set_upsilon_tessellation_layout__description__ for further
+ information.
+ ]
+ []
+ [`false`]
+ ]
+ [
+ [`wraparound_policy`]
+ [
+ An object whose index operator returns a boolean flag indicating
+ whether or not the algorithm will allow edges to wrap around in
+ the specified dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [An object whose index operator always returns `false`.]
+ ]
+ [
+ [`point_factory`]
+ [
+ A function that constructs and returns `Point` objects. Required
+ if the default constructor of `Point` does not exist or prevents
+ its index operator from fulfilling its runtime requirement.
+ ]
+ [
+ The index operator of each object returned must accept values
+ returned by the index operator of `position_index_map`.
+ ]
+ [[^_value_factory_<Dimensions>()]]
+ ]
+ [
+ [`position_index_map`]
+ [
+ Maps each dimension index to a unique integer. Specify an argument
+ for this parameter if, for example, a 3-D application calls for
+ different upsilon tessellation layouts to reside on different
+ dimensional planes.
+ ]
+ [The index operator must accept values in the range `[0, 1]`.]
+ [[^_identity_property_map_()]]
+ ]
+ [
+ [`position_map`]
+ [
+ Maps each vertex to a `Point` object representing a position in the
+ resulting layout.
+ ]
+ [
+ Each vertex descriptor dereferenced from `vertex_iterator` must be
+ a valid key.
+ ]
+ [`dummy_property_map()`]
+ ]
+ [
+ [`origin`]
+ [
+ An object representing the vertex position whose coordinates are
+ at the lower bound of each dimension.
+ ]
+ [
+ The index operator must accept values returned by the index
+ operator of `position_index_map`.
+ ]
+ [
+ A `Point` whose index operator returns zero for each of the input
+ dimensions returned by the index operator of `position_index_map`.
+ ]
+ ]
+]
+
+Remember that the __BGL__ prefixes each __Boost_Parameter__ keyword with an
+underscore and defines it in the `boost::graph::keywords` namespace.
+[endsect] [/ Parameters]
+
+[section Example]
+[example__upsilon_tessellation_layout]
+
+The complete example program can be compiled from this file:
+<__example_upsilon_tessellation_layout_cpp__>.
+[endsect]
+
+[endsect] [/ set_upsilon_tessellation_layout]
+

Added: sandbox/graph-intrusive_layout/libs/graph/example/bitruncated_cubic_honeycomb.cpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/example/bitruncated_cubic_honeycomb.cpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,76 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+//#define BOOST_PARAMETER_MAX_ARITY 9
+
+#include <iostream>
+#include <boost/preprocessor/comparison/less.hpp>
+#include <boost/array.hpp>
+#include <boost/phoenix/core/value.hpp>
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/io.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/graph_selectors.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/properties.hpp>
+#include <boost/graph/basic_vert_insert_iterator.hpp>
+#include <boost/graph/basic_add_edge_function.hpp>
+#include <boost/graph/set_bt_cubic_hcomb_layout.hpp>
+
+//[example__bitruncated_cubic_honeycomb
+int main()
+{
+ typedef boost::numeric::ublas::vector<double> Point;
+ typedef boost::vertex_distance_t PositionTag;
+
+ Point dimensions(3);
+
+ dimensions(0) = dimensions(1) = 7.0;
+ dimensions(2) = 8.0;
+
+ boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,Point>
+ > graph(
+ boost::count_bitruncated_cubic_honeycomb_layout_vertices(dimensions)
+ );
+ boost::array<bool,3> wraparound_policy = {{false, true, true}};
+
+#ifdef BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+ boost::set_bitruncated_cubic_honeycomb_layout(
+ boost::vertices(graph).first
+ , boost::basic_2way_edge_adder(graph)
+ , dimensions
+ , boost::graph::keywords::_wraparound_policy = wraparound_policy
+ , boost::graph::keywords::_point_factory = boost::phoenix::val(Point(3))
+ , boost::graph::keywords::_position_map = boost::get(
+ PositionTag()
+ , graph
+ )
+ );
+#else // !BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+ boost::set_bitruncated_cubic_honeycomb_layout(
+ boost::vertices(graph).first
+ , boost::basic_2way_edge_adder(graph)
+ , boost::dimensions(
+ dimensions
+ ).wraparound_policy(
+ wraparound_policy
+ ).point_factory(
+ boost::phoenix::val(Point(3))
+ ).position_map(
+ boost::get(PositionTag(), graph)
+ )
+ );
+#endif // BOOST_GRAPH_SET_BITRUNCATED_CUBIC_HONEYCOMB_TAKES_ALL_PARAMS
+ boost::print_graph(graph, boost::get(PositionTag(), graph));
+
+ return 0;
+}
+//]
+

Added: sandbox/graph-intrusive_layout/libs/graph/example/bitset_grid_layouts.cpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/example/bitset_grid_layouts.cpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,68 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#include <iostream>
+#include <map>
+#include <bitset>
+#include <boost/mpl/int.hpp>
+#include <boost/dynamic_bitset.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/graph_selectors.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/properties.hpp>
+#include <boost/graph/basic_vert_insert_iterator.hpp>
+#include <boost/graph/basic_add_edge_function.hpp>
+#include <boost/graph/set_bitset_grid_layout.hpp>
+
+//[example__bitset_grid_layouts__static
+int main()
+{
+ typedef boost::adjacency_list<boost::vecS,boost::setS,boost::directedS>
+ MidGraph;
+ typedef std::map<
+ boost::graph_traits<MidGraph>::vertex_descriptor
+ , std::bitset<4>
+ >
+ Vertex2BitsMap;
+
+ Vertex2BitsMap v2b_map;
+ boost::associative_property_map<Vertex2BitsMap> pos_map(v2b_map);
+ MidGraph mid_graph(boost::count_bitset_grid_layout_vertices(pos_map));
+
+ boost::set_bitset_grid_layout(
+ boost::vertices(mid_graph).first
+ , boost::basic_2way_edge_adder(mid_graph)
+ , boost::position_map(pos_map)
+ );
+ boost::print_graph(mid_graph, pos_map);
+ std::cout << std::endl;
+ //]
+
+ //[example__bitset_grid_layouts__dynamic
+ typedef boost::vertex_distance_t PositionTag;
+
+ boost::mpl::int_<5> bit_count;
+ boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,boost::dynamic_bitset<> >
+ > big_graph(
+ boost::count_bitset_grid_layout_vertices(bit_count)
+ );
+
+ boost::set_bitset_grid_layout(
+ boost::vertices(big_graph).first
+ , boost::basic_edge_adder(big_graph)
+ , boost::get(PositionTag(), big_graph)
+ , bit_count
+ );
+ boost::print_graph(big_graph, boost::get(PositionTag(), big_graph));
+
+ return 0;
+}
+//]
+

Added: sandbox/graph-intrusive_layout/libs/graph/example/orthogonal_grid_layouts.cpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/example/orthogonal_grid_layouts.cpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,95 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#define BOOST_PARAMETER_MAX_ARITY 11
+
+#include <iostream>
+#include <boost/mpl/int.hpp>
+#include <boost/array.hpp>
+#include <boost/phoenix/core/value.hpp>
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/io.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/graph_selectors.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/properties.hpp>
+#include <boost/graph/basic_vert_insert_iterator.hpp>
+#include <boost/graph/basic_add_edge_function.hpp>
+#include <boost/graph/set_orthogonal_grid_layout.hpp>
+
+//[example__orthogonal_grid_layouts
+int main()
+{
+ typedef boost::numeric::ublas::vector<double> Point;
+ typedef boost::vertex_distance_t PositionTag;
+
+ Point origin(3), scale(3), dimensions(3);
+
+ scale(0) = 2.0;
+ scale(1) = scale(2) = 1.0;
+ dimensions(0) = dimensions(1) = 6.0;
+ dimensions(2) = 3.0;
+
+ boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,Point>
+ > graph(
+ boost::count_orthogonal_grid_layout_vertices(
+ dimensions
+ , boost::mpl::int_<3>()
+ , boost::graph::keywords::_scale = scale
+ )
+ );
+ boost::array<bool,3> wraparound_policy = {{true, false, true}};
+
+ origin(0) = -2.0;
+ origin(1) = -2.5;
+ origin(2) = -1.0;
+ boost::set_orthogonal_grid_layout(
+ boost::vertices(graph).first
+ , boost::basic_2way_edge_adder(graph)
+ , boost::position_map(
+ boost::get(PositionTag(), graph)
+ ).is_zeta(
+ true
+ ).dimension_count(
+ boost::mpl::int_<3>()
+ ).dimensions(
+ dimensions
+ ).scale(
+ scale
+ ).origin(
+ origin
+ ).point_factory(
+ boost::phoenix::val(Point(3))
+ ).wraparound_policy(
+ wraparound_policy
+ )
+ );
+ boost::print_graph(graph, boost::get(PositionTag(), graph));
+ std::cout << std::endl;
+ graph.clear();
+ boost::set_orthogonal_grid_layout(
+ boost::basic_vertex_inserter(graph)
+ , boost::basic_2way_edge_adder(graph)
+ , dimensions
+ , boost::graph::keywords::_scale = scale
+ , boost::graph::keywords::_origin = origin
+ , boost::graph::keywords::_position_map = boost::get(
+ PositionTag()
+ , graph
+ )
+ , boost::graph::keywords::_point_factory = boost::phoenix::val(Point(2))
+ , boost::graph::keywords::_wraparound_policy = wraparound_policy
+ );
+ boost::print_graph(graph, boost::get(PositionTag(), graph));
+
+ return 0;
+}
+//]
+

Added: sandbox/graph-intrusive_layout/libs/graph/example/upsilon_tessellation_layout.cpp
==============================================================================
--- (empty file)
+++ sandbox/graph-intrusive_layout/libs/graph/example/upsilon_tessellation_layout.cpp 2011-09-10 10:10:13 EDT (Sat, 10 Sep 2011)
@@ -0,0 +1,84 @@
+// Copyright (C) 2011 Cromwell D. Enage
+// Distributed under 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)
+
+#define BOOST_PARAMETER_MAX_ARITY 10
+
+#include <iostream>
+#include <boost/mpl/int.hpp>
+#include <boost/tr1/tuple.hpp>
+#include <boost/array.hpp>
+#include <boost/phoenix/core/value.hpp>
+#include <boost/numeric/ublas/vector.hpp>
+#include <boost/numeric/ublas/io.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/graph_selectors.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/properties.hpp>
+#include <boost/graph/basic_add_edge_function.hpp>
+#include <boost/graph/set_upsilon_tessel_layout.hpp>
+
+//[example__upsilon_tessellation_layout
+int main()
+{
+ typedef boost::numeric::ublas::vector<double> Point;
+ typedef boost::vertex_distance_t PositionTag;
+ typedef boost::adjacency_list<
+ boost::multisetS
+ , boost::listS
+ , boost::undirectedS
+ , boost::property<PositionTag,Point>
+ >
+ Graph;
+
+ Point dimensions(2);
+
+ dimensions(0) = 5.0;
+ dimensions(1) = 4.0;
+
+ Graph g(boost::count_upsilon_tessellation_layout_vertices(dimensions));
+ boost::array<bool,2> wraparound_policy = {{true, false}};
+
+ boost::set_upsilon_tessellation_layout(
+ boost::vertices(g).first
+ , boost::basic_2way_edge_adder(g)
+ , boost::dimensions(
+ dimensions
+ ).has_square_origin(
+ true
+ ).wraparound_policy(
+ wraparound_policy
+ ).point_factory(
+ boost::phoenix::val(Point(2))
+ ).position_map(
+ boost::get(PositionTag(), g)
+ )
+ );
+ boost::print_graph(g, boost::get(PositionTag(), g));
+ std::cout << std::endl;
+
+ boost::graph_traits<Graph>::vertex_iterator vi, vi_end;
+
+ for (std::tr1::tie(vi, vi_end) = boost::vertices(g); vi != vi_end; ++vi)
+ {
+ boost::clear_vertex(*vi, g);
+ }
+
+ wraparound_policy[1] = true;
+ boost::set_upsilon_tessellation_layout(
+ boost::vertices(g).first
+ , boost::basic_2way_edge_adder(g)
+ , dimensions
+ , boost::graph::keywords::_wraparound_policy = wraparound_policy
+ , boost::graph::keywords::_point_factory = boost::phoenix::val(Point(2))
+ , boost::graph::keywords::_position_map = boost::get(PositionTag(), g)
+ );
+ boost::print_graph(g, boost::get(PositionTag(), g));
+
+ return 0;
+}
+//]
+

Date view	Thread view	Subject view	Author view