inside.hpp

 
#ifndef UFO_CONTAINER_TREE_PREDICATE_INSIDE_HPP
#define UFO_CONTAINER_TREE_PREDICATE_INSIDE_HPP
 
// UFO
#include <ufo/container/tree/predicate/filter.hpp>
#include <ufo/container/tree/predicate/spatial.hpp>
#include <ufo/geometry/inside.hpp>
#include <ufo/geometry/intersects.hpp>
 
// STL
#include <type_traits>
 
namespace ufo::pred
{
template <class Geometry, bool Negated = false>
struct Inside {
    Geometry geometry;
};
 
template <class Geometry, bool Negated>
[[nodiscard]] constexpr Inside<Geometry, !Negated> operator!(
    Inside<Geometry, Negated> const& p) noexcept
{
    return Inside<Geometry, !Negated>{p.geometry};
}
 
template <class Geometry, bool Negated>
struct Filter<Inside<Geometry, Negated>> {
    using Pred = Inside<Geometry, Negated>;
 
    template <class Tree>
    static constexpr void init(Pred&, Tree const&) noexcept
    {
    }
 
    template <class Value>
    [[nodiscard]] static constexpr bool returnableValue(Pred const&  p,
                                                        Value const& v) noexcept
    {
        if constexpr (Negated) {
            if constexpr (is_pair_v<std::remove_cvref_t<Value>>) {
                return !inside(v.first, p.geometry);
            } else {
                return !inside(v, p.geometry);
            }
        } else {
            if constexpr (is_pair_v<std::remove_cvref_t<Value>>) {
                return inside(v.first, p.geometry);
            } else {
                return inside(v, p.geometry);
            }
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnable(Pred const& p, Tree const& t,
                                                   typename Tree::Node const& n) noexcept
    {
        if constexpr (Negated) {
            return !inside(t.bounds(n), p.geometry);
        } else {
            return inside(t.bounds(n), p.geometry);
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const& p, Tree const& t,
                                                    typename Tree::Node const& n) noexcept
    {
        if constexpr (Negated) {
            return !inside(t.bounds(n), p.geometry);
        } else {
            return intersects(t.bounds(n), p.geometry);
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnableRay(Pred const& p, Tree const& t,
                                                      typename Tree::Node const& n,
                                                      typename Tree::Ray const&) noexcept
    {
        return returnable(p, t, n);
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversableRay(Pred const& p, Tree const& t,
                                                       typename Tree::Node const& n,
                                                       typename Tree::Ray const&) noexcept
    {
        return traversable(p, t, n);
    }
};
 
namespace detail
{
template <class Geometry, bool Negated>
struct is_spatial_pred<Inside<Geometry, Negated>> : std::true_type {
};
}  // namespace detail
 
}  // namespace ufo::pred
 
#endif  // UFO_CONTAINER_TREE_PREDICATE_INSIDE_HPP