Initial commit

winx64/include/boost/geometry/algorithms/detail/expand/box.hpp

@@ -0,0 +1,129 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_BOX_HPP
+
+#include <cstddef>
+#include <algorithm>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+
+struct box_on_spheroid
+{
+    template <typename BoxOut, typename BoxIn, typename Strategy>
+    static inline void apply(BoxOut& box_out,
+                             BoxIn const& box_in,
+                             Strategy const& strategy)
+    {
+        // normalize both boxes and convert box-in to be of type of box-out
+        BoxOut mbrs[2];
+        detail::envelope::envelope_box_on_spheroid::apply(box_in, mbrs[0], strategy);
+        detail::envelope::envelope_box_on_spheroid::apply(box_out, mbrs[1], strategy);
+
+        // compute the envelope of the two boxes
+        detail::envelope::envelope_range_of_boxes::apply(mbrs, box_out, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Box + box -> new box containing two input boxes
+template
+<
+    typename BoxOut, typename BoxIn,
+    typename StrategyLess, typename StrategyGreater,
+    typename CSTagOut, typename CSTag
+>
+struct expand
+    <
+        BoxOut, BoxIn,
+        StrategyLess, StrategyGreater,
+        box_tag, box_tag,
+        CSTagOut, CSTag
+    > : detail::expand::expand_indexed
+        <
+            0, dimension<BoxIn>::value, StrategyLess, StrategyGreater
+        >
+{
+    BOOST_MPL_ASSERT_MSG((boost::is_same<CSTagOut, CSTag>::value),
+                         COORDINATE_SYSTEMS_MUST_BE_THE_SAME,
+                         (types<CSTagOut, CSTag>()));
+};
+
+template
+<
+    typename BoxOut, typename BoxIn,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, BoxIn,
+        StrategyLess, StrategyGreater,
+        box_tag, box_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::expand::box_on_spheroid
+{};
+
+template
+<
+    typename BoxOut, typename BoxIn,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, BoxIn,
+        StrategyLess, StrategyGreater,
+        box_tag, box_tag,
+        geographic_tag, geographic_tag
+    > : detail::expand::box_on_spheroid
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP

winx64/include/boost/geometry/algorithms/detail/expand/implementation.hpp

@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_IMPLEMENTATION_HPP
+
+#include <boost/geometry/algorithms/detail/expand/point.hpp>
+#include <boost/geometry/algorithms/detail/expand/segment.hpp>
+#include <boost/geometry/algorithms/detail/expand/box.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_IMPLEMENTATION_HPP

winx64/include/boost/geometry/algorithms/detail/expand/indexed.hpp

@@ -0,0 +1,147 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+
+template
+<
+    typename StrategyLess, typename StrategyGreater,
+    std::size_t Index,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct indexed_loop
+{
+    template <typename Box, typename Geometry, typename Strategy>
+    static inline void apply(Box& box, Geometry const& source, Strategy const& strategy)
+    {
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyLess, 1, Box, Dimension
+            >::type less_type;
+
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyGreater, -1, Box, Dimension
+            >::type greater_type;
+
+        typedef typename select_coordinate_type
+                <
+                    Box,
+                    Geometry
+                >::type coordinate_type;
+
+        less_type less;
+        greater_type greater;
+
+        coordinate_type const coord = get<Index, Dimension>(source);
+
+        if (less(coord, get<min_corner, Dimension>(box)))
+        {
+            set<min_corner, Dimension>(box, coord);
+        }
+
+        if (greater(coord, get<max_corner, Dimension>(box)))
+        {
+            set<max_corner, Dimension>(box, coord);
+        }
+
+        indexed_loop
+            <
+                StrategyLess, StrategyGreater,
+                Index, Dimension + 1, DimensionCount
+            >::apply(box, source, strategy);
+    }
+};
+
+
+template
+<
+    typename StrategyLess, typename StrategyGreater,
+    std::size_t Index, std::size_t DimensionCount
+>
+struct indexed_loop
+    <
+        StrategyLess, StrategyGreater,
+        Index, DimensionCount, DimensionCount
+    >
+{
+    template <typename Box, typename Geometry, typename Strategy>
+    static inline void apply(Box&, Geometry const&, Strategy const&) {}
+};
+
+
+
+// Changes a box such that the other box is also contained by the box
+template
+<
+    std::size_t Dimension, std::size_t DimensionCount,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand_indexed
+{
+    template <typename Box, typename Geometry, typename Strategy>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        indexed_loop
+            <
+                StrategyLess, StrategyGreater,
+                0, Dimension, DimensionCount
+            >::apply(box, geometry, strategy);
+
+        indexed_loop
+            <
+                StrategyLess, StrategyGreater,
+                1, Dimension, DimensionCount
+            >::apply(box, geometry, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP

winx64/include/boost/geometry/algorithms/detail/expand/interface.hpp

@@ -0,0 +1,199 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INTERFACE_HPP
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/strategies/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategies/spherical/envelope_segment.hpp>
+#include <boost/geometry/strategies/geographic/envelope_segment.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace resolve_strategy
+{
+
+template <typename Geometry>
+struct expand
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        dispatch::expand<Box, Geometry>::apply(box, geometry, strategy);
+    }
+
+    template <typename Box>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             default_strategy)
+    {
+        typedef typename point_type<Geometry>::type point_type;
+        typedef typename coordinate_type<point_type>::type coordinate_type;
+
+        typedef typename strategy::envelope::services::default_strategy
+                <
+                typename cs_tag<point_type>::type,
+                coordinate_type
+                >::type strategy_type;
+
+        dispatch::expand<Box, Geometry>::apply(box, geometry, strategy_type());
+    }
+};
+
+} //namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+    
+template <typename Geometry>
+struct expand
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        concepts::check<Box>();
+        concepts::check<Geometry const>();
+        concepts::check_concepts_and_equal_dimensions<Box, Geometry const>();
+        
+        resolve_strategy::expand<Geometry>::apply(box, geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct expand<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Box, typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Box& m_box;
+        Strategy const& m_strategy;
+        
+        visitor(Box& box, Strategy const& strategy)
+            : m_box(box)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry>
+        void operator()(Geometry const& geometry) const
+        {
+            return expand<Geometry>::apply(m_box, geometry, m_strategy);
+        }
+    };
+    
+    template <class Box, typename Strategy>
+    static inline void
+    apply(Box& box,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Box, Strategy>(box, strategy),
+                                    geometry);
+    }
+};
+    
+} // namespace resolve_variant
+    
+    
+/***
+*!
+\brief Expands a box using the extend (envelope) of another geometry (box, point)
+\ingroup expand
+\tparam Box type of the box
+\tparam Geometry of second geometry, to be expanded with the box
+\param box box to expand another geometry with, might be changed
+\param geometry other geometry
+\param strategy_less
+\param strategy_greater
+\note Strategy is currently ignored
+ *
+template
+<
+    typename Box, typename Geometry,
+    typename StrategyLess, typename StrategyGreater
+>
+inline void expand(Box& box, Geometry const& geometry,
+            StrategyLess const& strategy_less,
+            StrategyGreater const& strategy_greater)
+{
+    concepts::check_concepts_and_equal_dimensions<Box, Geometry const>();
+
+    dispatch::expand<Box, Geometry>::apply(box, geometry);
+}
+***/
+
+/*!
+\brief Expands (with strategy)
+\ingroup expand
+\tparam Box type of the box
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{expand}
+\param box box to be expanded using another geometry, mutable
+\param geometry \param_geometry geometry which envelope (bounding box)
+\param strategy \param_strategy{expand}
+will be added to the box
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/expand.qbk]}
+ */
+template <typename Box, typename Geometry, typename Strategy>
+inline void expand(Box& box, Geometry const& geometry, Strategy const& strategy)
+{
+
+    resolve_variant::expand<Geometry>::apply(box, geometry, strategy);
+}
+
+/*!
+\brief Expands a box using the bounding box (envelope) of another geometry
+(box, point)
+\ingroup expand
+\tparam Box type of the box
+\tparam Geometry \tparam_geometry
+\param box box to be expanded using another geometry, mutable
+\param geometry \param_geometry geometry which envelope (bounding box) will be
+added to the box
+
+\qbk{[include reference/algorithms/expand.qbk]}
+ */
+template <typename Box, typename Geometry>
+inline void expand(Box& box, Geometry const& geometry)
+{
+    resolve_variant::expand<Geometry>::apply(box, geometry, default_strategy());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INTERFACE_HPP

winx64/include/boost/geometry/algorithms/detail/expand/point.hpp

@@ -0,0 +1,308 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_POINT_HPP
+
+#include <cstddef>
+#include <algorithm>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/algorithms/detail/envelope/transform_units.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+
+template
+<
+    typename StrategyLess, typename StrategyGreater,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_loop
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box& box, Point const& source, Strategy const& strategy)
+    {
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyLess, 1, Point, Dimension
+            >::type less_type;
+
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyGreater, -1, Point, Dimension
+            >::type greater_type;
+
+        typedef typename select_coordinate_type
+            <
+                Point, Box
+            >::type coordinate_type;
+
+        less_type less;
+        greater_type greater;
+
+        coordinate_type const coord = get<Dimension>(source);
+
+        if (less(coord, get<min_corner, Dimension>(box)))
+        {
+            set<min_corner, Dimension>(box, coord);
+        }
+
+        if (greater(coord, get<max_corner, Dimension>(box)))
+        {
+            set<max_corner, Dimension>(box, coord);
+        }
+
+        point_loop
+            <
+                StrategyLess, StrategyGreater, Dimension + 1, DimensionCount
+            >::apply(box, source, strategy);
+    }
+};
+
+
+template
+<
+    typename StrategyLess,
+    typename StrategyGreater,
+    std::size_t DimensionCount
+>
+struct point_loop
+    <
+        StrategyLess, StrategyGreater, DimensionCount, DimensionCount
+    >
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box&, Point const&, Strategy const&) {}
+};
+
+
+// implementation for the spherical equatorial and geographic coordinate systems
+template
+<
+    typename StrategyLess,
+    typename StrategyGreater,
+    std::size_t DimensionCount
+>
+struct point_loop_on_spheroid
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box& box,
+                             Point const& point,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<Box>::type box_point_type;
+        typedef typename coordinate_type<Box>::type box_coordinate_type;
+
+        typedef math::detail::constants_on_spheroid
+            <
+                box_coordinate_type,
+                typename coordinate_system<Box>::type::units
+            > constants;
+
+        // normalize input point and input box
+        Point p_normalized = detail::return_normalized<Point>(point);
+        detail::normalize(box, box);
+
+        // transform input point to be of the same type as the box point
+        box_point_type box_point;
+        detail::envelope::transform_units(p_normalized, box_point);
+
+        box_coordinate_type p_lon = geometry::get<0>(box_point);
+        box_coordinate_type p_lat = geometry::get<1>(box_point);
+
+        typename coordinate_type<Box>::type
+            b_lon_min = geometry::get<min_corner, 0>(box),
+            b_lat_min = geometry::get<min_corner, 1>(box),
+            b_lon_max = geometry::get<max_corner, 0>(box),
+            b_lat_max = geometry::get<max_corner, 1>(box);
+
+        if (math::equals(math::abs(p_lat), constants::max_latitude()))
+        {
+            // the point of expansion is the either the north or the
+            // south pole; the only important coordinate here is the
+            // pole's latitude, as the longitude can be anything;
+            // we, thus, take into account the point's latitude only and return
+            geometry::set<min_corner, 1>(box, (std::min)(p_lat, b_lat_min));
+            geometry::set<max_corner, 1>(box, (std::max)(p_lat, b_lat_max));
+            return;
+        }
+
+        if (math::equals(b_lat_min, b_lat_max)
+            && math::equals(math::abs(b_lat_min), constants::max_latitude()))
+        {
+            // the box degenerates to either the north or the south pole;
+            // the only important coordinate here is the pole's latitude, 
+            // as the longitude can be anything;
+            // we thus take into account the box's latitude only and return
+            geometry::set<min_corner, 0>(box, p_lon);
+            geometry::set<min_corner, 1>(box, (std::min)(p_lat, b_lat_min));
+            geometry::set<max_corner, 0>(box, p_lon);
+            geometry::set<max_corner, 1>(box, (std::max)(p_lat, b_lat_max));
+            return;
+        }
+
+        // update latitudes
+        b_lat_min = (std::min)(b_lat_min, p_lat);
+        b_lat_max = (std::max)(b_lat_max, p_lat);
+
+        // update longitudes
+        if (math::smaller(p_lon, b_lon_min))
+        {
+            box_coordinate_type p_lon_shifted = p_lon + constants::period();
+
+            if (math::larger(p_lon_shifted, b_lon_max))
+            {
+                // here we could check using: ! math::larger(.., ..)
+                if (math::smaller(b_lon_min - p_lon, p_lon_shifted - b_lon_max))
+                {
+                    b_lon_min = p_lon;
+                }
+                else
+                {
+                    b_lon_max = p_lon_shifted;
+                }
+            }
+        }
+        else if (math::larger(p_lon, b_lon_max))
+        {
+            // in this case, and since p_lon is normalized in the range
+            // (-180, 180], we must have that b_lon_max <= 180
+            if (b_lon_min < 0
+                && math::larger(p_lon - b_lon_max,
+                                constants::period() - p_lon + b_lon_min))
+            {
+                b_lon_min = p_lon;
+                b_lon_max += constants::period();
+            }
+            else
+            {
+                b_lon_max = p_lon;
+            }
+        }
+
+        geometry::set<min_corner, 0>(box, b_lon_min);
+        geometry::set<min_corner, 1>(box, b_lat_min);
+        geometry::set<max_corner, 0>(box, b_lon_max);
+        geometry::set<max_corner, 1>(box, b_lat_max);
+
+        point_loop
+            <
+                StrategyLess, StrategyGreater, 2, DimensionCount
+            >::apply(box, point, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Box + point -> new box containing also point
+template
+<
+    typename BoxOut, typename Point,
+    typename StrategyLess, typename StrategyGreater,
+    typename CSTagOut, typename CSTag
+>
+struct expand
+    <
+        BoxOut, Point,
+        StrategyLess, StrategyGreater,
+        box_tag, point_tag,
+        CSTagOut, CSTag
+    > : detail::expand::point_loop
+        <
+            StrategyLess, StrategyGreater, 0, dimension<Point>::value
+        >
+{
+    BOOST_MPL_ASSERT_MSG((boost::is_same<CSTagOut, CSTag>::value),
+                         COORDINATE_SYSTEMS_MUST_BE_THE_SAME,
+                         (types<CSTagOut, CSTag>()));
+};
+
+template
+<
+    typename BoxOut, typename Point,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, Point,
+        StrategyLess, StrategyGreater,
+        box_tag, point_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::expand::point_loop_on_spheroid
+        <
+            StrategyLess, StrategyGreater, dimension<Point>::value
+        >
+{};
+
+template
+<
+    typename BoxOut, typename Point,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, Point,
+        StrategyLess, StrategyGreater,
+        box_tag, point_tag,
+        geographic_tag, geographic_tag
+    > : detail::expand::point_loop_on_spheroid
+        <
+            StrategyLess, StrategyGreater, dimension<Point>::value
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_POINT_HPP

winx64/include/boost/geometry/algorithms/detail/expand/segment.hpp

@@ -0,0 +1,133 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_SEGMENT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_SEGMENT_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp>
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+struct segment
+{
+    template <typename Box, typename Segment, typename Strategy>
+    static inline void apply(Box& box,
+                             Segment const& segment,
+                             Strategy const& strategy)
+    {
+        Box mbrs[2];
+
+        // compute the envelope of the segment
+        typename point_type<Segment>::type p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+        detail::envelope::envelope_segment
+            <
+                dimension<Segment>::value
+            >::apply(p[0], p[1], mbrs[0], strategy);
+
+        // normalize the box
+        detail::envelope::envelope_box_on_spheroid::apply(box, mbrs[1], strategy);
+
+        // compute the envelope of the two boxes
+        detail::envelope::envelope_range_of_boxes::apply(mbrs, box, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Box, typename Segment,
+    typename StrategyLess, typename StrategyGreater,
+    typename CSTagOut, typename CSTag
+>
+struct expand
+    <
+        Box, Segment,
+        StrategyLess, StrategyGreater,
+        box_tag, segment_tag,
+        CSTagOut, CSTag
+    > : detail::expand::expand_indexed
+        <
+            0, dimension<Segment>::value, StrategyLess, StrategyGreater
+        >
+{
+    BOOST_MPL_ASSERT_MSG((boost::is_same<CSTagOut, CSTag>::value),
+                         COORDINATE_SYSTEMS_MUST_BE_THE_SAME,
+                         (types<CSTagOut, CSTag>()));
+};
+
+template
+<
+    typename Box, typename Segment,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        Box, Segment,
+        StrategyLess, StrategyGreater,
+        box_tag, segment_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::expand::segment
+{};
+
+template
+<
+    typename Box, typename Segment,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        Box, Segment,
+        StrategyLess, StrategyGreater,
+        box_tag, segment_tag,
+        geographic_tag, geographic_tag
+    > : detail::expand::segment
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_SEGMENT_HPP