Current File : //usr/include/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
// Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2012-2020 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
// This file was modified by Oracle on 2016, 2018.
// Modifications copyright (c) 2016-2018 Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
// 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_DETAIL_BUFFER_TURN_IN_PIECE_VISITOR_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_PIECE_VISITOR_HPP
#include <boost/geometry/core/assert.hpp>
#include <boost/geometry/core/config.hpp>
#include <boost/geometry/algorithms/comparable_distance.hpp>
#include <boost/geometry/algorithms/covered_by.hpp>
#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
#include <boost/geometry/geometries/box.hpp>
namespace boost { namespace geometry
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace buffer
{
template
<
typename CsTag,
typename Turns,
typename Pieces,
typename DistanceStrategy
>
class turn_in_piece_visitor
{
Turns& m_turns; // because partition is currently operating on const input only
Pieces const& m_pieces; // to check for piece-type
DistanceStrategy const& m_distance_strategy; // to check if point is on original or one_sided
template <typename Operation, typename Piece>
inline bool skip(Operation const& op, Piece const& piece) const
{
if (op.piece_index == piece.index)
{
return true;
}
Piece const& pc = m_pieces[op.piece_index];
if (pc.left_index == piece.index || pc.right_index == piece.index)
{
if (pc.type == strategy::buffer::buffered_flat_end)
{
// If it is a flat end, don't compare against its neighbor:
// it will always be located on one of the helper segments
return true;
}
if (pc.type == strategy::buffer::buffered_concave)
{
// If it is concave, the same applies: the IP will be
// located on one of the helper segments
return true;
}
}
return false;
}
template <typename NumericType>
inline bool is_one_sided(NumericType const& left, NumericType const& right) const
{
static NumericType const zero = 0;
return geometry::math::equals(left, zero)
|| geometry::math::equals(right, zero);
}
template <typename Point>
inline bool has_zero_distance_at(Point const& point) const
{
return is_one_sided(m_distance_strategy.apply(point, point,
strategy::buffer::buffer_side_left),
m_distance_strategy.apply(point, point,
strategy::buffer::buffer_side_right));
}
public:
inline turn_in_piece_visitor(Turns& turns, Pieces const& pieces,
DistanceStrategy const& distance_strategy)
: m_turns(turns)
, m_pieces(pieces)
, m_distance_strategy(distance_strategy)
{}
template <typename Turn, typename Piece>
inline bool apply(Turn const& turn, Piece const& piece)
{
if (! turn.is_turn_traversable)
{
// Already handled
return true;
}
if (piece.type == strategy::buffer::buffered_flat_end
|| piece.type == strategy::buffer::buffered_concave)
{
// Turns cannot be located within flat-end or concave pieces
return true;
}
if (skip(turn.operations[0], piece) || skip(turn.operations[1], piece))
{
return true;
}
return apply(turn, piece, piece.m_piece_border);
}
template <typename Turn, typename Piece, typename Border>
inline bool apply(Turn const& turn, Piece const& piece, Border const& border)
{
if (! geometry::covered_by(turn.point, border.m_envelope))
{
// Easy check: if turn is not in the (expanded) envelope
return true;
}
if (piece.type == geometry::strategy::buffer::buffered_point)
{
// Optimization for a buffer around points: if distance from center
// is not between min/max radius, it is either inside or outside,
// and more expensive checks are not necessary.
typedef typename Border::radius_type radius_type;
radius_type const d = geometry::comparable_distance(piece.m_center, turn.point);
if (d < border.m_min_comparable_radius)
{
Turn& mutable_turn = m_turns[turn.turn_index];
mutable_turn.is_turn_traversable = false;
return true;
}
if (d > border.m_max_comparable_radius)
{
return true;
}
}
// Check if buffer is one-sided (at this point), because then a point
// on the original is not considered as within.
bool const one_sided = has_zero_distance_at(turn.point);
typename Border::state_type state;
if (! border.point_on_piece(turn.point, one_sided, turn.is_linear_end_point, state))
{
return true;
}
if (state.code() == 1)
{
// It is WITHIN a piece, or on the piece border, but not
// on the offsetted part of it.
// TODO - at further removing rescaling, this threshold can be
// adapted, or ideally, go.
// This threshold is minimized to the point where fragile
// unit tests of hard cases start to fail (5 in multi_polygon)
// But it is acknowlegded that such a threshold depends on the
// scale of the input.
if (state.m_min_distance > 1.0e-5 || ! state.m_close_to_offset)
{
Turn& mutable_turn = m_turns[turn.turn_index];
mutable_turn.is_turn_traversable = false;
// Keep track of the information if this turn was close
// to an offset (without threshold). Because if it was,
// it might have been classified incorrectly and in the
// pretraversal step, it can in hindsight be classified
// as "outside".
mutable_turn.close_to_offset = state.m_close_to_offset;
}
}
return true;
}
};
}} // namespace detail::buffer
#endif // DOXYGEN_NO_DETAIL
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_PIECE_VISITOR_HPP
Mini Shell