text: // 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 Adam Wulkiewicz, Lodz, Poland.
  
  // This file was modified by Oracle on 2014, 2015.
  // Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
  
  // Contributed and/or modified by Adam Wulkiewicz, 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.
  
  // 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_ALGORITHMS_EQUALS_HPP
  #define BOOST_GEOMETRY_ALGORITHMS_EQUALS_HPP
  
  
  #include <cstddef>
  #include <vector>
  
  #include <boost/range.hpp>
  
  #include <boost/variant/apply_visitor.hpp>
  #include <boost/variant/static_visitor.hpp>
  #include <boost/variant/variant_fwd.hpp>
  
  #include <boost/geometry/core/access.hpp>
  #include <boost/geometry/core/coordinate_dimension.hpp>
  #include <boost/geometry/core/geometry_id.hpp>
  #include <boost/geometry/core/reverse_dispatch.hpp>
  #include <boost/geometry/core/tags.hpp>
  
  #include <boost/geometry/geometries/concepts/check.hpp>
  
  #include <boost/geometry/algorithms/detail/equals/point_point.hpp>
  #include <boost/geometry/algorithms/detail/not.hpp>
  #include <boost/geometry/algorithms/not_implemented.hpp>
  
  // For trivial checks
  #include <boost/geometry/algorithms/area.hpp>
  #include <boost/geometry/algorithms/length.hpp>
  #include <boost/geometry/util/math.hpp>
  #include <boost/geometry/util/select_coordinate_type.hpp>
  #include <boost/geometry/util/select_most_precise.hpp>
  
  #include <boost/geometry/algorithms/detail/equals/collect_vectors.hpp>
  #include <boost/geometry/algorithms/detail/relate/relate.hpp>
  
  #include <boost/geometry/views/detail/indexed_point_view.hpp>
  
  
  namespace boost { namespace geometry
  {
  
  #ifndef DOXYGEN_NO_DETAIL
  namespace detail { namespace equals
  {
  
  
  template
  <
      std::size_t Dimension,
      std::size_t DimensionCount
  >
  struct box_box
  {
      template <typename Box1, typename Box2>
      static inline bool apply(Box1 const& box1, Box2 const& box2)
      {
          if (!geometry::math::equals(get<min_corner, Dimension>(box1), get<min_corner, Dimension>(box2))
              || !geometry::math::equals(get<max_corner, Dimension>(box1), get<max_corner, Dimension>(box2)))
          {
              return false;
          }
          return box_box<Dimension + 1, DimensionCount>::apply(box1, box2);
      }
  };
  
  template <std::size_t DimensionCount>
  struct box_box<DimensionCount, DimensionCount>
  {
      template <typename Box1, typename Box2>
      static inline bool apply(Box1 const& , Box2 const& )
      {
          return true;
      }
  };
  
  
  struct segment_segment
  {
      template <typename Segment1, typename Segment2>
      static inline bool apply(Segment1 const& segment1, Segment2 const& segment2)
      {
          return equals::equals_point_point(
                      indexed_point_view<Segment1 const, 0>(segment1),
                      indexed_point_view<Segment2 const, 0>(segment2) )
                  ? equals::equals_point_point(
                      indexed_point_view<Segment1 const, 1>(segment1),
                      indexed_point_view<Segment2 const, 1>(segment2) )
                  : ( equals::equals_point_point(
                          indexed_point_view<Segment1 const, 0>(segment1),
                          indexed_point_view<Segment2 const, 1>(segment2) )
                   && equals::equals_point_point(
                          indexed_point_view<Segment1 const, 1>(segment1),
                          indexed_point_view<Segment2 const, 0>(segment2) )
                    );
      }
  };
  
  
  struct area_check
  {
      template <typename Geometry1, typename Geometry2>
      static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2)
      {
          return geometry::math::equals(
                  geometry::area(geometry1),
                  geometry::area(geometry2));
      }
  };
  
  
  struct length_check
  {
      template <typename Geometry1, typename Geometry2>
      static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2)
      {
          return geometry::math::equals(
                  geometry::length(geometry1),
                  geometry::length(geometry2));
      }
  };
  
  
  template <typename TrivialCheck>
  struct equals_by_collection
  {
      template <typename Geometry1, typename Geometry2>
      static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2)
      {
          if (! TrivialCheck::apply(geometry1, geometry2))
          {
              return false;
          }
  
          typedef typename geometry::select_most_precise
              <
                  typename select_coordinate_type
                      <
                          Geometry1, Geometry2
                      >::type,
                  double
              >::type calculation_type;
  
          typedef std::vector<collected_vector<calculation_type> > v;
          v c1, c2;
  
          geometry::collect_vectors(c1, geometry1);
          geometry::collect_vectors(c2, geometry2);
  
          if (boost::size(c1) != boost::size(c2))
          {
              return false;
          }
  
          std::sort(c1.begin(), c1.end());
          std::sort(c2.begin(), c2.end());
  
          // Just check if these vectors are equal.
          return std::equal(c1.begin(), c1.end(), c2.begin());
      }
  };
  
  template<typename Geometry1, typename Geometry2>
  struct equals_by_relate
      : detail::relate::relate_base
          <
              detail::relate::static_mask_equals_type,
              Geometry1,
              Geometry2
          >
  {};
  
  }} // namespace detail::equals
  #endif // DOXYGEN_NO_DETAIL
  
  
  #ifndef DOXYGEN_NO_DISPATCH
  namespace dispatch
  {
  
  template
  <
      typename Geometry1,
      typename Geometry2,
      typename Tag1 = typename tag<Geometry1>::type,
      typename Tag2 = typename tag<Geometry2>::type,
      std::size_t DimensionCount = dimension<Geometry1>::type::value,
      bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
  >
  struct equals: not_implemented<Tag1, Tag2>
  {};
  
  
  // If reversal is needed, perform it
  template
  <
      typename Geometry1, typename Geometry2,
      typename Tag1, typename Tag2,
      std::size_t DimensionCount
  >
  struct equals<Geometry1, Geometry2, Tag1, Tag2, DimensionCount, true>
      : equals<Geometry2, Geometry1, Tag2, Tag1, DimensionCount, false>
  {
      static inline bool apply(Geometry1 const& g1, Geometry2 const& g2)
      {
          return equals
              <
                  Geometry2, Geometry1,
                  Tag2, Tag1,
                  DimensionCount,
                  false
              >::apply(g2, g1);
      }
  };
  
  
  template <typename P1, typename P2, std::size_t DimensionCount, bool Reverse>
  struct equals<P1, P2, point_tag, point_tag, DimensionCount, Reverse>
      : geometry::detail::not_
          <
              detail::disjoint::point_point<P1, P2, 0, DimensionCount>
          >
  {};
  
  
  template <typename Box1, typename Box2, std::size_t DimensionCount, bool Reverse>
  struct equals<Box1, Box2, box_tag, box_tag, DimensionCount, Reverse>
      : detail::equals::box_box<0, DimensionCount>
  {};
  
  
  template <typename Ring1, typename Ring2, bool Reverse>
  struct equals<Ring1, Ring2, ring_tag, ring_tag, 2, Reverse>
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  
  template <typename Polygon1, typename Polygon2, bool Reverse>
  struct equals<Polygon1, Polygon2, polygon_tag, polygon_tag, 2, Reverse>
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  
  template <typename Polygon, typename Ring, bool Reverse>
  struct equals<Polygon, Ring, polygon_tag, ring_tag, 2, Reverse>
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  
  template <typename Ring, typename Box, bool Reverse>
  struct equals<Ring, Box, ring_tag, box_tag, 2, Reverse>
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  
  template <typename Polygon, typename Box, bool Reverse>
  struct equals<Polygon, Box, polygon_tag, box_tag, 2, Reverse>
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  template <typename Segment1, typename Segment2, std::size_t DimensionCount, bool Reverse>
  struct equals<Segment1, Segment2, segment_tag, segment_tag, DimensionCount, Reverse>
      : detail::equals::segment_segment
  {};
  
  template <typename LineString1, typename LineString2, bool Reverse>
  struct equals<LineString1, LineString2, linestring_tag, linestring_tag, 2, Reverse>
      //: detail::equals::equals_by_collection<detail::equals::length_check>
      : detail::equals::equals_by_relate<LineString1, LineString2>
  {};
  
  template <typename LineString, typename MultiLineString, bool Reverse>
  struct equals<LineString, MultiLineString, linestring_tag, multi_linestring_tag, 2, Reverse>
      : detail::equals::equals_by_relate<LineString, MultiLineString>
  {};
  
  template <typename MultiLineString1, typename MultiLineString2, bool Reverse>
  struct equals<MultiLineString1, MultiLineString2, multi_linestring_tag, multi_linestring_tag, 2, Reverse>
      : detail::equals::equals_by_relate<MultiLineString1, MultiLineString2>
  {};
  
  
  template <typename MultiPolygon1, typename MultiPolygon2, bool Reverse>
  struct equals
      <
          MultiPolygon1, MultiPolygon2,
          multi_polygon_tag, multi_polygon_tag,
          2,
          Reverse
      >
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  
  template <typename Polygon, typename MultiPolygon, bool Reverse>
  struct equals
      <
          Polygon, MultiPolygon,
          polygon_tag, multi_polygon_tag,
          2,
          Reverse
      >
      : detail::equals::equals_by_collection<detail::equals::area_check>
  {};
  
  
  } // namespace dispatch
  #endif // DOXYGEN_NO_DISPATCH
  
  
  namespace resolve_variant {
  
  template <typename Geometry1, typename Geometry2>
  struct equals
  {
      static inline bool apply(Geometry1 const& geometry1,
                               Geometry2 const& geometry2)
      {
          concept::check_concepts_and_equal_dimensions
          <
              Geometry1 const,
              Geometry2 const
          >();
  
          return dispatch::equals<Geometry1, Geometry2>
                         ::apply(geometry1, geometry2);
      }
  };
  
  template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
  struct equals<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
  {
      struct visitor: static_visitor<bool>
      {
          Geometry2 const& m_geometry2;
  
          visitor(Geometry2 const& geometry2)
              : m_geometry2(geometry2)
          {}
  
          template <typename Geometry1>
          inline bool operator()(Geometry1 const& geometry1) const
          {
              return equals<Geometry1, Geometry2>
                     ::apply(geometry1, m_geometry2);
          }
  
      };
  
      static inline bool apply(
          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
          Geometry2 const& geometry2
      )
      {
          return apply_visitor(visitor(geometry2), geometry1);
      }
  };
  
  template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
  struct equals<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
  {
      struct visitor: static_visitor<bool>
      {
          Geometry1 const& m_geometry1;
  
          visitor(Geometry1 const& geometry1)
              : m_geometry1(geometry1)
          {}
  
          template <typename Geometry2>
          inline bool operator()(Geometry2 const& geometry2) const
          {
              return equals<Geometry1, Geometry2>
                     ::apply(m_geometry1, geometry2);
          }
  
      };
  
      static inline bool apply(
          Geometry1 const& geometry1,
          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2
      )
      {
          return apply_visitor(visitor(geometry1), geometry2);
      }
  };
  
  template <
      BOOST_VARIANT_ENUM_PARAMS(typename T1),
      BOOST_VARIANT_ENUM_PARAMS(typename T2)
  >
  struct equals<
      boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
      boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
  >
  {
      struct visitor: static_visitor<bool>
      {
          template <typename Geometry1, typename Geometry2>
          inline bool operator()(Geometry1 const& geometry1,
                                 Geometry2 const& geometry2) const
          {
              return equals<Geometry1, Geometry2>
                     ::apply(geometry1, geometry2);
          }
  
      };
  
      static inline bool apply(
          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2
      )
      {
          return apply_visitor(visitor(), geometry1, geometry2);
      }
  };
  
  } // namespace resolve_variant
  
  
  /*!
  \brief \brief_check{are spatially equal}
  \details \details_check12{equals, is spatially equal}. Spatially equal means
      that the same point set is included. A box can therefore be spatially equal
      to a ring or a polygon, or a linestring can be spatially equal to a
      multi-linestring or a segment. This only works theoretically, not all
      combinations are implemented yet.
  \ingroup equals
  \tparam Geometry1 \tparam_geometry
  \tparam Geometry2 \tparam_geometry
  \param geometry1 \param_geometry
  \param geometry2 \param_geometry
  \return \return_check2{are spatially equal}
  
  \qbk{[include reference/algorithms/equals.qbk]}
  
   */
  template <typename Geometry1, typename Geometry2>
  inline bool equals(Geometry1 const& geometry1, Geometry2 const& geometry2)
  {
      return resolve_variant::equals<Geometry1, Geometry2>
                            ::apply(geometry1, geometry2);
  }
  
  
  }} // namespace boost::geometry
  
  
  #endif // BOOST_GEOMETRY_ALGORITHMS_EQUALS_HPP
  
  