diff options
Diffstat (limited to 'boost/geometry/geometries')
19 files changed, 1011 insertions, 29 deletions
diff --git a/boost/geometry/geometries/adapted/boost_polygon/ring.hpp b/boost/geometry/geometries/adapted/boost_polygon/ring.hpp index 93b21fee94..490fa45fe9 100644 --- a/boost/geometry/geometries/adapted/boost_polygon/ring.hpp +++ b/boost/geometry/geometries/adapted/boost_polygon/ring.hpp @@ -69,7 +69,26 @@ struct push_back<boost::polygon::polygon_data<CoordinateType> > } }; +template <typename CoordinateType> +struct resize<boost::polygon::polygon_data<CoordinateType> > +{ + typedef boost::polygon::point_data<CoordinateType> point_type; + static inline void apply(boost::polygon::polygon_data<CoordinateType>& data, + std::size_t new_size) + { + // Boost.Polygon's polygons are not resizable. So create a temporary vector, + // resize it and set it to the original. Of course: this is not efficient. + // But there seems no other way (without using a wrapper) + std::vector<point_type> temporary_vector + ( + boost::polygon::begin_points(data), + boost::polygon::end_points(data) + ); + temporary_vector.resize(new_size); + data.set(temporary_vector.begin(), temporary_vector.end()); + } +}; } // namespace traits diff --git a/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp b/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp index 825ef8061f..1616369da1 100644 --- a/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp +++ b/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp @@ -150,7 +150,7 @@ public : } } - void resize(std::size_t new_size) + void resize(std::size_t /*new_size*/) { if (m_do_hole) { diff --git a/boost/geometry/geometries/concepts/check.hpp b/boost/geometry/geometries/concepts/check.hpp index f8001f0d12..07ef84f4a4 100644 --- a/boost/geometry/geometries/concepts/check.hpp +++ b/boost/geometry/geometries/concepts/check.hpp @@ -18,17 +18,23 @@ #include <boost/concept_check.hpp> #include <boost/concept/requires.hpp> - #include <boost/type_traits/is_const.hpp> +#include <boost/variant/variant_fwd.hpp> #include <boost/geometry/core/tag.hpp> +#include <boost/geometry/core/tags.hpp> #include <boost/geometry/geometries/concepts/box_concept.hpp> #include <boost/geometry/geometries/concepts/linestring_concept.hpp> +#include <boost/geometry/geometries/concepts/multi_point_concept.hpp> +#include <boost/geometry/geometries/concepts/multi_linestring_concept.hpp> +#include <boost/geometry/geometries/concepts/multi_polygon_concept.hpp> #include <boost/geometry/geometries/concepts/point_concept.hpp> #include <boost/geometry/geometries/concepts/polygon_concept.hpp> #include <boost/geometry/geometries/concepts/ring_concept.hpp> +#include <boost/geometry/geometries/concepts/segment_concept.hpp> +#include <boost/geometry/algorithms/not_implemented.hpp> namespace boost { namespace geometry { @@ -53,59 +59,122 @@ class check namespace dispatch { -template <typename GeometryTag, typename Geometry, bool IsConst> -struct check +template +< + typename Geometry, + typename GeometryTag = typename geometry::tag<Geometry>::type, + bool IsConst = boost::is_const<Geometry>::type::value +> +struct check : not_implemented<GeometryTag> {}; template <typename Geometry> -struct check<point_tag, Geometry, true> +struct check<Geometry, point_tag, true> : detail::concept_check::check<concept::ConstPoint<Geometry> > {}; template <typename Geometry> -struct check<point_tag, Geometry, false> +struct check<Geometry, point_tag, false> : detail::concept_check::check<concept::Point<Geometry> > {}; template <typename Geometry> -struct check<linestring_tag, Geometry, true> +struct check<Geometry, linestring_tag, true> : detail::concept_check::check<concept::ConstLinestring<Geometry> > {}; template <typename Geometry> -struct check<linestring_tag, Geometry, false> +struct check<Geometry, linestring_tag, false> : detail::concept_check::check<concept::Linestring<Geometry> > {}; template <typename Geometry> -struct check<polygon_tag, Geometry, true> +struct check<Geometry, ring_tag, true> + : detail::concept_check::check<concept::ConstRing<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, ring_tag, false> + : detail::concept_check::check<concept::Ring<Geometry> > +{}; + +template <typename Geometry> +struct check<Geometry, polygon_tag, true> : detail::concept_check::check<concept::ConstPolygon<Geometry> > {}; template <typename Geometry> -struct check<polygon_tag, Geometry, false> +struct check<Geometry, polygon_tag, false> : detail::concept_check::check<concept::Polygon<Geometry> > {}; template <typename Geometry> -struct check<box_tag, Geometry, true> +struct check<Geometry, box_tag, true> : detail::concept_check::check<concept::ConstBox<Geometry> > {}; template <typename Geometry> -struct check<box_tag, Geometry, false> +struct check<Geometry, box_tag, false> : detail::concept_check::check<concept::Box<Geometry> > {}; +template <typename Geometry> +struct check<Geometry, segment_tag, true> + : detail::concept_check::check<concept::ConstSegment<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, segment_tag, false> + : detail::concept_check::check<concept::Segment<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, multi_point_tag, true> + : detail::concept_check::check<concept::ConstMultiPoint<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, multi_point_tag, false> + : detail::concept_check::check<concept::MultiPoint<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, multi_linestring_tag, true> + : detail::concept_check::check<concept::ConstMultiLinestring<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, multi_linestring_tag, false> + : detail::concept_check::check<concept::MultiLinestring<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, multi_polygon_tag, true> + : detail::concept_check::check<concept::ConstMultiPolygon<Geometry> > +{}; + + +template <typename Geometry> +struct check<Geometry, multi_polygon_tag, false> + : detail::concept_check::check<concept::MultiPolygon<Geometry> > +{}; + } // namespace dispatch #endif @@ -122,13 +191,16 @@ namespace detail { -template <typename Geometry, bool IsConst> -struct checker : dispatch::check - < - typename tag<Geometry>::type, - Geometry, - IsConst - > +template <typename Geometry> +struct checker : dispatch::check<Geometry> +{}; + +template <BOOST_VARIANT_ENUM_PARAMS(typename T)> +struct checker<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> > +{}; + +template <BOOST_VARIANT_ENUM_PARAMS(typename T)> +struct checker<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const> {}; @@ -143,7 +215,7 @@ struct checker : dispatch::check template <typename Geometry> inline void check() { - detail::checker<Geometry, boost::is_const<Geometry>::type::value> c; + detail::checker<Geometry> c; boost::ignore_unused_variable_warning(c); } diff --git a/boost/geometry/geometries/concepts/multi_linestring_concept.hpp b/boost/geometry/geometries/concepts/multi_linestring_concept.hpp new file mode 100644 index 0000000000..f13f7ac7e8 --- /dev/null +++ b/boost/geometry/geometries/concepts/multi_linestring_concept.hpp @@ -0,0 +1,91 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP + + +#include <boost/concept_check.hpp> +#include <boost/range/concepts.hpp> +#include <boost/range/metafunctions.hpp> + + +#include <boost/geometry/geometries/concepts/linestring_concept.hpp> + + +namespace boost { namespace geometry { namespace concept +{ + + +/*! +\brief multi-linestring concept +\ingroup concepts +\par Formal definition: +The multi linestring concept is defined as following: +- there must be a specialization of traits::tag defining multi_linestring_tag as + type +- it must behave like a Boost.Range +- its range value must fulfil the Linestring concept + +*/ +template <typename Geometry> +class MultiLinestring +{ +#ifndef DOXYGEN_NO_CONCEPT_MEMBERS + typedef typename boost::range_value<Geometry>::type linestring_type; + + BOOST_CONCEPT_ASSERT( (concept::Linestring<linestring_type>) ); + BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) ); + + +public : + + BOOST_CONCEPT_USAGE(MultiLinestring) + { + Geometry* mls = 0; + traits::clear<Geometry>::apply(*mls); + traits::resize<Geometry>::apply(*mls, 0); + linestring_type* ls = 0; + traits::push_back<Geometry>::apply(*mls, *ls); + } +#endif +}; + + +/*! +\brief concept for multi-linestring (const version) +\ingroup const_concepts +*/ +template <typename Geometry> +class ConstMultiLinestring +{ +#ifndef DOXYGEN_NO_CONCEPT_MEMBERS + typedef typename boost::range_value<Geometry>::type linestring_type; + + BOOST_CONCEPT_ASSERT( (concept::ConstLinestring<linestring_type>) ); + BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) ); + + +public : + + BOOST_CONCEPT_USAGE(ConstMultiLinestring) + { + } +#endif +}; + +}}} // namespace boost::geometry::concept + + +#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP diff --git a/boost/geometry/geometries/concepts/multi_point_concept.hpp b/boost/geometry/geometries/concepts/multi_point_concept.hpp new file mode 100644 index 0000000000..81c087166f --- /dev/null +++ b/boost/geometry/geometries/concepts/multi_point_concept.hpp @@ -0,0 +1,90 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP + + +#include <boost/concept_check.hpp> +#include <boost/range/concepts.hpp> +#include <boost/range/metafunctions.hpp> + + +#include <boost/geometry/geometries/concepts/point_concept.hpp> + + +namespace boost { namespace geometry { namespace concept +{ + + +/*! +\brief MultiPoint concept +\ingroup concepts +\par Formal definition: +The multi point concept is defined as following: +- there must be a specialization of traits::tag defining multi_point_tag as type +- it must behave like a Boost.Range +- its range value must fulfil the Point concept + +*/ +template <typename Geometry> +class MultiPoint +{ +#ifndef DOXYGEN_NO_CONCEPT_MEMBERS + typedef typename boost::range_value<Geometry>::type point_type; + + BOOST_CONCEPT_ASSERT( (concept::Point<point_type>) ); + BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) ); + + +public : + + BOOST_CONCEPT_USAGE(MultiPoint) + { + Geometry* mp = 0; + traits::clear<Geometry>::apply(*mp); + traits::resize<Geometry>::apply(*mp, 0); + point_type* point = 0; + traits::push_back<Geometry>::apply(*mp, *point); + } +#endif +}; + + +/*! +\brief concept for multi-point (const version) +\ingroup const_concepts +*/ +template <typename Geometry> +class ConstMultiPoint +{ +#ifndef DOXYGEN_NO_CONCEPT_MEMBERS + typedef typename boost::range_value<Geometry>::type point_type; + + BOOST_CONCEPT_ASSERT( (concept::ConstPoint<point_type>) ); + BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) ); + + +public : + + BOOST_CONCEPT_USAGE(ConstMultiPoint) + { + } +#endif +}; + +}}} // namespace boost::geometry::concept + + +#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP diff --git a/boost/geometry/geometries/concepts/multi_polygon_concept.hpp b/boost/geometry/geometries/concepts/multi_polygon_concept.hpp new file mode 100644 index 0000000000..b13d330f3c --- /dev/null +++ b/boost/geometry/geometries/concepts/multi_polygon_concept.hpp @@ -0,0 +1,91 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP + + +#include <boost/concept_check.hpp> +#include <boost/range/concepts.hpp> +#include <boost/range/metafunctions.hpp> + +#include <boost/geometry/geometries/concepts/polygon_concept.hpp> + + +namespace boost { namespace geometry { namespace concept +{ + + +/*! +\brief multi-polygon concept +\ingroup concepts +\par Formal definition: +The multi polygon concept is defined as following: +- there must be a specialization of traits::tag defining multi_polygon_tag + as type +- it must behave like a Boost.Range +- its range value must fulfil the Polygon concept + +*/ +template <typename Geometry> +class MultiPolygon +{ +#ifndef DOXYGEN_NO_CONCEPT_MEMBERS + typedef typename boost::range_value<Geometry>::type polygon_type; + + BOOST_CONCEPT_ASSERT( (concept::Polygon<polygon_type>) ); + BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) ); + + +public : + + BOOST_CONCEPT_USAGE(MultiPolygon) + { + Geometry* mp = 0; + traits::clear<Geometry>::apply(*mp); + traits::resize<Geometry>::apply(*mp, 0); + polygon_type* poly = 0; + traits::push_back<Geometry>::apply(*mp, *poly); + } +#endif +}; + + +/*! +\brief concept for multi-polygon (const version) +\ingroup const_concepts +*/ +template <typename Geometry> +class ConstMultiPolygon +{ +#ifndef DOXYGEN_NO_CONCEPT_MEMBERS + typedef typename boost::range_value<Geometry>::type polygon_type; + + BOOST_CONCEPT_ASSERT( (concept::ConstPolygon<polygon_type>) ); + BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) ); + + +public : + + BOOST_CONCEPT_USAGE(ConstMultiPolygon) + { + } +#endif +}; + + +}}} // namespace boost::geometry::concept + + +#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP diff --git a/boost/geometry/geometries/geometries.hpp b/boost/geometry/geometries/geometries.hpp index cda55c1d28..de9e2b1fd9 100644 --- a/boost/geometry/geometries/geometries.hpp +++ b/boost/geometry/geometries/geometries.hpp @@ -18,6 +18,10 @@ #include <boost/geometry/geometries/linestring.hpp> #include <boost/geometry/geometries/polygon.hpp> +#include <boost/geometry/geometries/multi_point.hpp> +#include <boost/geometry/geometries/multi_linestring.hpp> +#include <boost/geometry/geometries/multi_polygon.hpp> + #include <boost/geometry/geometries/box.hpp> #include <boost/geometry/geometries/ring.hpp> #include <boost/geometry/geometries/segment.hpp> diff --git a/boost/geometry/geometries/multi_linestring.hpp b/boost/geometry/geometries/multi_linestring.hpp new file mode 100644 index 0000000000..2ba8e7196b --- /dev/null +++ b/boost/geometry/geometries/multi_linestring.hpp @@ -0,0 +1,80 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_GEOMETRY_GEOMETRIES_MULTI_LINESTRING_HPP +#define BOOST_GEOMETRY_GEOMETRIES_MULTI_LINESTRING_HPP + +#include <memory> +#include <vector> + +#include <boost/concept/requires.hpp> + +#include <boost/geometry/core/tags.hpp> +#include <boost/geometry/geometries/concepts/linestring_concept.hpp> + + +namespace boost { namespace geometry +{ + + +namespace model +{ + +/*! +\brief multi_line, a collection of linestring +\details Multi-linestring can be used to group lines belonging to each other, + e.g. a highway (with interruptions) +\ingroup geometries + +\qbk{before.synopsis, +[heading Model of] +[link geometry.reference.concepts.concept_multi_linestring MultiLineString Concept] +} +*/ +template +< + typename LineString, + template<typename, typename> class Container = std::vector, + template<typename> class Allocator = std::allocator +> +class multi_linestring : public Container<LineString, Allocator<LineString> > +{ + BOOST_CONCEPT_ASSERT( (concept::Linestring<LineString>) ); +}; + + +} // namespace model + + +#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS +namespace traits +{ + +template +< + typename LineString, + template<typename, typename> class Container, + template<typename> class Allocator +> +struct tag< model::multi_linestring<LineString, Container, Allocator> > +{ + typedef multi_linestring_tag type; +}; + +} // namespace traits +#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS + + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_GEOMETRIES_MULTI_LINESTRING_HPP diff --git a/boost/geometry/geometries/multi_point.hpp b/boost/geometry/geometries/multi_point.hpp new file mode 100644 index 0000000000..d0a782a1de --- /dev/null +++ b/boost/geometry/geometries/multi_point.hpp @@ -0,0 +1,94 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_GEOMETRY_GEOMETRIES_MULTI_POINT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_MULTI_POINT_HPP + +#include <memory> +#include <vector> + +#include <boost/concept/requires.hpp> + +#include <boost/geometry/core/tags.hpp> +#include <boost/geometry/geometries/concepts/point_concept.hpp> + + +namespace boost { namespace geometry +{ + +namespace model +{ + + +/*! +\brief multi_point, a collection of points +\ingroup geometries +\tparam Point \tparam_point +\tparam Container \tparam_container +\tparam Allocator \tparam_allocator +\details Multipoint can be used to group points belonging to each other, + e.g. a constellation, or the result set of an intersection +\qbk{before.synopsis, +[heading Model of] +[link geometry.reference.concepts.concept_multi_point MultiPoint Concept] +} +*/ +template +< + typename Point, + template<typename, typename> class Container = std::vector, + template<typename> class Allocator = std::allocator +> +class multi_point : public Container<Point, Allocator<Point> > +{ + BOOST_CONCEPT_ASSERT( (concept::Point<Point>) ); + + typedef Container<Point, Allocator<Point> > base_type; + +public : + /// \constructor_default{multi_point} + inline multi_point() + : base_type() + {} + + /// \constructor_begin_end{multi_point} + template <typename Iterator> + inline multi_point(Iterator begin, Iterator end) + : base_type(begin, end) + {} +}; + +} // namespace model + + +#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS +namespace traits +{ + +template +< + typename Point, + template<typename, typename> class Container, + template<typename> class Allocator +> +struct tag< model::multi_point<Point, Container, Allocator> > +{ + typedef multi_point_tag type; +}; + +} // namespace traits +#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_GEOMETRIES_MULTI_POINT_HPP diff --git a/boost/geometry/geometries/multi_polygon.hpp b/boost/geometry/geometries/multi_polygon.hpp new file mode 100644 index 0000000000..228074cd34 --- /dev/null +++ b/boost/geometry/geometries/multi_polygon.hpp @@ -0,0 +1,77 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_GEOMETRY_GEOMETRIES_MULTI_POLYGON_HPP +#define BOOST_GEOMETRY_GEOMETRIES_MULTI_POLYGON_HPP + +#include <memory> +#include <vector> + +#include <boost/concept/requires.hpp> + +#include <boost/geometry/core/tags.hpp> +#include <boost/geometry/geometries/concepts/polygon_concept.hpp> + +namespace boost { namespace geometry +{ + +namespace model +{ + +/*! +\brief multi_polygon, a collection of polygons +\details Multi-polygon can be used to group polygons belonging to each other, + e.g. Hawaii +\ingroup geometries + +\qbk{before.synopsis, +[heading Model of] +[link geometry.reference.concepts.concept_multi_polygon MultiPolygon Concept] +} +*/ +template +< + typename Polygon, + template<typename, typename> class Container = std::vector, + template<typename> class Allocator = std::allocator +> +class multi_polygon : public Container<Polygon, Allocator<Polygon> > +{ + BOOST_CONCEPT_ASSERT( (concept::Polygon<Polygon>) ); +}; + + +} // namespace model + + +#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS +namespace traits +{ + +template +< + typename Polygon, + template<typename, typename> class Container, + template<typename> class Allocator +> +struct tag< model::multi_polygon<Polygon, Container, Allocator> > +{ + typedef multi_polygon_tag type; +}; + +} // namespace traits +#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_GEOMETRIES_MULTI_POLYGON_HPP diff --git a/boost/geometry/geometries/point.hpp b/boost/geometry/geometries/point.hpp index b40a47355d..a25340c463 100644 --- a/boost/geometry/geometries/point.hpp +++ b/boost/geometry/geometries/point.hpp @@ -28,6 +28,12 @@ namespace boost { namespace geometry { +// Silence warning C4127: conditional expression is constant +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable : 4127) +#endif + namespace model { @@ -65,7 +71,7 @@ public: {} /// @brief Constructor to set one, two or three values - inline point(CoordinateType const& v0, CoordinateType const& v1 = 0, CoordinateType const& v2 = 0) + explicit inline point(CoordinateType const& v0, CoordinateType const& v1 = 0, CoordinateType const& v2 = 0) { if (DimensionCount >= 1) m_values[0] = v0; if (DimensionCount >= 2) m_values[1] = v1; @@ -173,6 +179,10 @@ struct access<model::point<CoordinateType, DimensionCount, CoordinateSystem>, Di } // namespace traits #endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + }} // namespace boost::geometry #endif // BOOST_GEOMETRY_GEOMETRIES_POINT_HPP diff --git a/boost/geometry/geometries/pointing_segment.hpp b/boost/geometry/geometries/pointing_segment.hpp new file mode 100644 index 0000000000..681752ef2d --- /dev/null +++ b/boost/geometry/geometries/pointing_segment.hpp @@ -0,0 +1,143 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2014, Oracle and/or its affiliates. + +// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle + +// Licensed under the Boost Software License version 1.0. +// http://www.boost.org/users/license.html + +#ifndef BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP + +#include <cstddef> + +#include <boost/assert.hpp> +#include <boost/concept/assert.hpp> +#include <boost/core/addressof.hpp> +#include <boost/mpl/if.hpp> +#include <boost/type_traits/is_const.hpp> + +#include <boost/geometry/geometries/concepts/point_concept.hpp> + +#include <boost/geometry/core/access.hpp> +#include <boost/geometry/core/coordinate_type.hpp> + + +namespace boost { namespace geometry +{ + +namespace model +{ + +// const or non-const segment type that is meant to be +// * default constructible +// * copy constructible +// * assignable +// referring_segment does not fit these requirements, hence the +// pointing_segment class +// +// this class is used by the segment_iterator as its value type +template <typename ConstOrNonConstPoint> +class pointing_segment +{ + BOOST_CONCEPT_ASSERT( ( + typename boost::mpl::if_ + < + boost::is_const<ConstOrNonConstPoint>, + concept::Point<ConstOrNonConstPoint>, + concept::ConstPoint<ConstOrNonConstPoint> + > + ) ); + + typedef ConstOrNonConstPoint point_type; + +public: + point_type* first; + point_type* second; + + inline pointing_segment() + : first(NULL) + , second(NULL) + {} + + inline pointing_segment(point_type const& p1, point_type const& p2) + : first(boost::addressof(p1)) + , second(boost::addressof(p2)) + {} +}; + + +} // namespace model + + +// Traits specializations for segment above +#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS +namespace traits +{ + +template <typename Point> +struct tag<model::pointing_segment<Point> > +{ + typedef segment_tag type; +}; + +template <typename Point> +struct point_type<model::pointing_segment<Point> > +{ + typedef Point type; +}; + +template <typename Point, std::size_t Dimension> +struct indexed_access<model::pointing_segment<Point>, 0, Dimension> +{ + typedef model::pointing_segment<Point> segment_type; + typedef typename geometry::coordinate_type + < + segment_type + >::type coordinate_type; + + static inline coordinate_type get(segment_type const& s) + { + BOOST_ASSERT( s.first != NULL ); + return geometry::get<Dimension>(*s.first); + } + + static inline void set(segment_type& s, coordinate_type const& value) + { + BOOST_ASSERT( s.first != NULL ); + geometry::set<Dimension>(*s.first, value); + } +}; + + +template <typename Point, std::size_t Dimension> +struct indexed_access<model::pointing_segment<Point>, 1, Dimension> +{ + typedef model::pointing_segment<Point> segment_type; + typedef typename geometry::coordinate_type + < + segment_type + >::type coordinate_type; + + static inline coordinate_type get(segment_type const& s) + { + BOOST_ASSERT( s.second != NULL ); + return geometry::get<Dimension>(*s.second); + } + + static inline void set(segment_type& s, coordinate_type const& value) + { + BOOST_ASSERT( s.second != NULL ); + geometry::set<Dimension>(*s.second, value); + } +}; + + + +} // namespace traits +#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS + +}} // namespace boost::geometry + +#endif // BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP diff --git a/boost/geometry/geometries/register/box.hpp b/boost/geometry/geometries/register/box.hpp index 838c2bb5fc..71a7077a66 100644 --- a/boost/geometry/geometries/register/box.hpp +++ b/boost/geometry/geometries/register/box.hpp @@ -105,7 +105,7 @@ template <> struct indexed_access<Box, max_corner, 1> \ /*! \brief \brief_macro{box} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX, box} The +\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX, box} The box may contain template parameters, which must be specified then. \param Box \param_macro_type{Box} \param Point Point type on which box is based. Might be two or three-dimensional @@ -128,7 +128,7 @@ namespace boost { namespace geometry { namespace traits { \ /*! \brief \brief_macro{box} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX_TEMPLATED, box} +\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX_TEMPLATED, box} \details_macro_templated{box, point} \param Box \param_macro_type{Box} \param MinCorner minimum corner (should be public member or method) @@ -149,10 +149,10 @@ namespace boost { namespace geometry { namespace traits { \ /*! \brief \brief_macro{box} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX_2D_4VALUES, box} +\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX_2D_4VALUES, box} \param Box \param_macro_type{Box} \param Point Point type reported as point_type by box. Must be two dimensional. - Note that these box tyeps do not contain points, but they must have a + Note that these box tyeps do not contain points, but they must have a related point_type \param Left Left side (must be public member or method) \param Bottom Bottom side (must be public member or method) diff --git a/boost/geometry/geometries/register/linestring.hpp b/boost/geometry/geometries/register/linestring.hpp index b064398746..cfc7dcaed2 100644 --- a/boost/geometry/geometries/register/linestring.hpp +++ b/boost/geometry/geometries/register/linestring.hpp @@ -22,7 +22,7 @@ /*! \brief \brief_macro{linestring} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_LINESTRING, linestring} The +\details \details_macro{BOOST_GEOMETRY_REGISTER_LINESTRING, linestring} The linestring may contain template parameters, which must be specified then. \param Linestring \param_macro_type{linestring} @@ -41,7 +41,7 @@ namespace boost { namespace geometry { namespace traits { \ /*! \brief \brief_macro{templated linestring} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_LINESTRING_TEMPLATED, templated linestring} +\details \details_macro{BOOST_GEOMETRY_REGISTER_LINESTRING_TEMPLATED, templated linestring} \details_macro_templated{linestring, point} \param Linestring \param_macro_type{linestring (without template parameters)} diff --git a/boost/geometry/geometries/register/multi_linestring.hpp b/boost/geometry/geometries/register/multi_linestring.hpp new file mode 100644 index 0000000000..ad11289d11 --- /dev/null +++ b/boost/geometry/geometries/register/multi_linestring.hpp @@ -0,0 +1,59 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP +#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP + +#include <boost/geometry/core/tag.hpp> +#include <boost/geometry/core/tags.hpp> + +/*! +\brief \brief_macro{multi_linestring} +\ingroup register +\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING, multi_linestring} The + multi_linestring may contain template parameters, which must be specified then. +\param MultiLineString \param_macro_type{multi_linestring} + +\qbk{ +[heading Example] +[register_multi_linestring] +[register_multi_linestring_output] +} +*/ +#define BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING(MultiLineString) \ +namespace boost { namespace geometry { namespace traits { \ + template<> struct tag<MultiLineString> { typedef multi_linestring_tag type; }; \ +}}} + + +/*! +\brief \brief_macro{templated multi_linestring} +\ingroup register +\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING_TEMPLATED, templated multi_linestring} + \details_macro_templated{multi_linestring, linestring} +\param MultiLineString \param_macro_type{multi_linestring (without template parameters)} + +\qbk{ +[heading Example] +[register_multi_linestring_templated] +[register_multi_linestring_templated_output] +} +*/ +#define BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING_TEMPLATED(MultiLineString) \ +namespace boost { namespace geometry { namespace traits { \ + template<typename LineString> struct tag< MultiLineString<LineString> > { typedef multi_linestring_tag type; }; \ +}}} + + +#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP diff --git a/boost/geometry/geometries/register/multi_point.hpp b/boost/geometry/geometries/register/multi_point.hpp new file mode 100644 index 0000000000..4e875ae0cd --- /dev/null +++ b/boost/geometry/geometries/register/multi_point.hpp @@ -0,0 +1,59 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POINT_HPP +#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POINT_HPP + +#include <boost/geometry/core/tag.hpp> +#include <boost/geometry/core/tags.hpp> + +/*! +\brief \brief_macro{multi_point} +\ingroup register +\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POINT, multi_point} The + multi_point may contain template parameters, which must be specified then. +\param MultiPoint \param_macro_type{multi_point} + +\qbk{ +[heading Example] +[register_multi_point] +[register_multi_point_output] +} +*/ +#define BOOST_GEOMETRY_REGISTER_MULTI_POINT(MultiPoint) \ +namespace boost { namespace geometry { namespace traits { \ + template<> struct tag<MultiPoint> { typedef multi_point_tag type; }; \ +}}} + + +/*! +\brief \brief_macro{templated multi_point} +\ingroup register +\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POINT_TEMPLATED, templated multi_point} + \details_macro_templated{multi_point, point} +\param MultiPoint \param_macro_type{multi_point (without template parameters)} + +\qbk{ +[heading Example] +[register_multi_point_templated] +[register_multi_point_templated_output] +} +*/ +#define BOOST_GEOMETRY_REGISTER_MULTI_POINT_TEMPLATED(MultiPoint) \ +namespace boost { namespace geometry { namespace traits { \ + template<typename Point> struct tag< MultiPoint<Point> > { typedef multi_point_tag type; }; \ +}}} + + +#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POINT_HPP diff --git a/boost/geometry/geometries/register/multi_polygon.hpp b/boost/geometry/geometries/register/multi_polygon.hpp new file mode 100644 index 0000000000..1c3818b551 --- /dev/null +++ b/boost/geometry/geometries/register/multi_polygon.hpp @@ -0,0 +1,59 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + + +#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP +#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP + +#include <boost/geometry/core/tag.hpp> +#include <boost/geometry/core/tags.hpp> + +/*! +\brief \brief_macro{multi_polygon} +\ingroup register +\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POLYGON, multi_polygon} The + multi_polygon may contain template parameters, which must be specified then. +\param MultiPolygon \param_macro_type{multi_polygon} + +\qbk{ +[heading Example] +[register_multi_polygon] +[register_multi_polygon_output] +} +*/ +#define BOOST_GEOMETRY_REGISTER_MULTI_POLYGON(MultiPolygon) \ +namespace boost { namespace geometry { namespace traits { \ + template<> struct tag<MultiPolygon> { typedef multi_polygon_tag type; }; \ +}}} + + +/*! +\brief \brief_macro{templated multi_polygon} +\ingroup register +\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POLYGON_TEMPLATED, templated multi_polygon} + \details_macro_templated{multi_polygon, polygon} +\param MultiPolygon \param_macro_type{multi_polygon (without template parameters)} + +\qbk{ +[heading Example] +[register_multi_polygon_templated] +[register_multi_polygon_templated_output] +} +*/ +#define BOOST_GEOMETRY_REGISTER_MULTI_POLYGON_TEMPLATED(MultiPolygon) \ +namespace boost { namespace geometry { namespace traits { \ + template<typename Polygon> struct tag< MultiPolygon<Polygon> > { typedef multi_polygon_tag type; }; \ +}}} + + +#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP diff --git a/boost/geometry/geometries/register/ring.hpp b/boost/geometry/geometries/register/ring.hpp index fb6cb67200..761e46fbc4 100644 --- a/boost/geometry/geometries/register/ring.hpp +++ b/boost/geometry/geometries/register/ring.hpp @@ -22,7 +22,7 @@ /*! \brief \brief_macro{ring} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_RING, ring} The +\details \details_macro{BOOST_GEOMETRY_REGISTER_RING, ring} The ring may contain template parameters, which must be specified then. \param Ring \param_macro_type{ring} @@ -41,7 +41,7 @@ namespace boost { namespace geometry { namespace traits { \ /*! \brief \brief_macro{templated ring} \ingroup register -\details \details_macro{BOOST_GEOMETRY_REGISTER_RING_TEMPLATED, templated ring} +\details \details_macro{BOOST_GEOMETRY_REGISTER_RING_TEMPLATED, templated ring} \details_macro_templated{ring, point} \param Ring \param_macro_type{ring (without template parameters)} diff --git a/boost/geometry/geometries/variant.hpp b/boost/geometry/geometries/variant.hpp new file mode 100644 index 0000000000..9db11d5a82 --- /dev/null +++ b/boost/geometry/geometries/variant.hpp @@ -0,0 +1,34 @@ +// Boost.Geometry (aka GGL, Generic Geometry Library) + +// Copyright (c) 2008-2012 Bruno Lalande, Paris, France. +// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands. +// Copyright (c) 2009-2012 Mateusz Loskot, London, UK. + +// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library +// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. + +// Use, modification and distribution is subject to the Boost Software License, +// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_GEOMETRY_GEOMETRIES_VARIANT_GEOMETRY_HPP +#define BOOST_GEOMETRY_GEOMETRIES_VARIANT_GEOMETRY_HPP + + +#include <boost/variant/variant_fwd.hpp> + + +namespace boost { namespace geometry { + + +template <BOOST_VARIANT_ENUM_PARAMS(typename T)> +struct point_type<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> > + : point_type<T0> +{}; + + +} // namespace geometry +} // namespace boost + + +#endif // BOOST_GEOMETRY_GEOMETRIES_VARIANT_GEOMETRY_HPP |