query.h

/*
 This Source Code Form is subject to the terms of the Mozilla Public
 License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
 
#pragma once
 
#include "./defines.h"
#include "./indexSquaredDistance.h"
#include "../Common/Containers/limitedPriorityQueue.h"
 
#include PONCA_MULTIARCH_INCLUDE_STD(cmath)
#include PONCA_MULTIARCH_INCLUDE_STD(limits)
 
namespace Ponca
{
 
#define DECLARE_INDEX_QUERY_CLASS(OUT_TYPE)                                                                           \
                         \
                                          \
                                                    \
                                                          \
                                                                                                               \
                                                                  \
    template <typename Index, typename Scalar>                                                                        \
    struct OUT_TYPE##IndexQuery : Query<QueryInputIsIndex<Index>, QueryOutputIs##OUT_TYPE<Index, Scalar>>             \
    {                                                                                                                 \
                                                              \
        using Base = Query<QueryInputIsIndex<Index>, QueryOutputIs##OUT_TYPE<Index, Scalar>>;                         \
                                                                  \
        using Base::Base;                                                                                             \
    };
 
#define DECLARE_POINT_QUERY_CLASS(OUT_TYPE)                                                                     \
                \
                                    \
                                              \
                                                    \
                                                                                              \
                                                            \
    template <typename Index, typename DataPoint>                                                               \
    struct OUT_TYPE##PointQuery                                                                                 \
        : Query<QueryInputIsPosition<DataPoint>, QueryOutputIs##OUT_TYPE<Index, typename DataPoint::Scalar>>    \
    {                                                                                                           \
                                                        \
        using Base =                                                                                            \
            Query<QueryInputIsPosition<DataPoint>, QueryOutputIs##OUT_TYPE<Index, typename DataPoint::Scalar>>; \
                                                            \
        using Base::Base;                                                                                       \
    };
 
 
    // Base classes
 
    struct QueryInputBase
    {
    };
 
    struct QueryOutputBase
    {
        struct DummyOutputParameter
        {
        };
    };
 
    template <typename InputType_>
    struct QueryInput : public QueryInputBase
    {
        using InputType = InputType_;
 
        PONCA_MULTIARCH inline QueryInput(InputType input) : m_input(input) {}
 
        PONCA_MULTIARCH inline const InputType& input() const { return m_input; }
 
    protected:
        PONCA_MULTIARCH inline void setInput(const InputType& input) { m_input = input; }
 
    private:
        InputType m_input;
    };
 
    template <typename Index>
    struct QueryInputIsIndex : public QueryInput<Index>
    {
        using Base = QueryInput<Index>;
        using InputType = typename Base::InputType;
 
        PONCA_MULTIARCH inline QueryInputIsIndex(const InputType& point = -1) : Base(point) {}
 
        PONCA_MULTIARCH inline void operator()(const InputType& point = InputType::Zero()) { Base::setInput(point); }
 
    protected:
        template <typename IndexType>
        PONCA_MULTIARCH inline bool skipIndexFunctor(IndexType idx) const
        {
            return Base::input() == idx;
        };
        template <typename VectorType, typename Container>
        PONCA_MULTIARCH inline const VectorType getInputPosition(const Container& c)
        {
            return c[Base::input()].pos();
        }
    };
 
    template <typename DataPoint>
    struct QueryInputIsPosition : public QueryInput<typename DataPoint::VectorType>
    {
        using Base = QueryInput<typename DataPoint::VectorType>;
        using InputType = typename Base::InputType;
 
        PONCA_MULTIARCH inline QueryInputIsPosition(const InputType& point = InputType::Zero()) : Base(point) {}
 
        PONCA_MULTIARCH inline void operator()(const InputType& point = InputType::Zero()) { Base::setInput(point); }
 
    protected:
        template <typename IndexType>
        PONCA_MULTIARCH inline bool skipIndexFunctor(IndexType idx) const
        {
            return false;
        };
        template <typename VectorType = typename DataPoint::VectorType, typename Container>
        PONCA_MULTIARCH inline const VectorType getInputPosition(const Container&)
        {
            return Base::input();
        }
    };
 
    template <typename Index, typename Scalar>
    struct QueryOutputIsRange : public QueryOutputBase
    {
        using OutputParameter = Scalar;
 
        PONCA_MULTIARCH inline QueryOutputIsRange(OutputParameter radius = OutputParameter(0))
            : m_squared_radius(PONCA_MULTIARCH_STD_MATH_NAMESPACE(pow)(radius, OutputParameter(2)))
        {
        }
 
        PONCA_MULTIARCH inline void operator()(OutputParameter radius) { setRadius(radius); }
 
        PONCA_MULTIARCH inline Scalar radius() const
        {
            PONCA_MULTIARCH_STD_MATH(sqrt);
            return sqrt(m_squared_radius);
        }
 
        PONCA_MULTIARCH inline Scalar squaredRadius() const { return m_squared_radius; }
 
        PONCA_MULTIARCH inline void setRadius(Scalar radius) { setSquaredRadius(radius * radius); }
 
        PONCA_MULTIARCH inline void setSquaredRadius(Scalar radius) { m_squared_radius = radius; }
 
    protected:
        PONCA_MULTIARCH inline void reset() {}
        PONCA_MULTIARCH inline Scalar descentDistanceThreshold() const { return m_squared_radius; }
        Scalar m_squared_radius{0};
    };
 
    template <typename Index, typename Scalar>
    struct QueryOutputIsNearest : public QueryOutputBase
    {
        using OutputParameter = typename QueryOutputBase::DummyOutputParameter;
 
        PONCA_MULTIARCH QueryOutputIsNearest() {}
 
        PONCA_MULTIARCH inline void operator()() {}
 
        PONCA_MULTIARCH Index get() const { return m_nearest; }
 
    protected:
        PONCA_MULTIARCH void reset()
        {
            m_nearest          = -1;
            m_squared_distance = PONCA_MULTIARCH_CU_STD_NAMESPACE(numeric_limits)<Scalar>::max();
        }
        PONCA_MULTIARCH inline Scalar descentDistanceThreshold() const { return m_squared_distance; }
 
        Index m_nearest{-1};
        Scalar m_squared_distance{PONCA_MULTIARCH_CU_STD_NAMESPACE(numeric_limits) < Scalar > ::max()};
    };
 
    template <typename Index, typename Scalar>
    struct QueryOutputIsKNearest : public QueryOutputBase
    {
        using OutputParameter = Index;
 
        PONCA_MULTIARCH inline QueryOutputIsKNearest(OutputParameter k = 0) : m_queue(k) {}
 
        PONCA_MULTIARCH inline void operator()(OutputParameter k)
        {
            m_queue = limited_priority_queue<IndexSquaredDistance<Index, Scalar>>(k);
        }
 
        PONCA_MULTIARCH inline limited_priority_queue<IndexSquaredDistance<Index, Scalar>>& queue() { return m_queue; }
 
    protected:
        PONCA_MULTIARCH void reset()
        {
            m_queue.clear();
            m_queue.push({-1, PONCA_MULTIARCH_CU_STD_NAMESPACE(numeric_limits) < Scalar > ::max()});
        }
        PONCA_MULTIARCH inline Scalar descentDistanceThreshold() const { return m_queue.bottom().squared_distance; }
        limited_priority_queue<IndexSquaredDistance<Index, Scalar>> m_queue;
    };
 
    template <typename Input_, typename Output_>
    struct Query : public Input_, public Output_
    {
        using QueryInType = Input_;
        using QueryOutType = Output_;
 
        static_assert(std::is_base_of<QueryInputBase, QueryInType>::value,
                      "QueryInType must inherit Ponca::QueryInputBase");
        static_assert(std::is_base_of<QueryOutputBase, QueryOutType>::value,
                      "QueryInType must inherit Ponca::QueryInputBase");
 
        PONCA_MULTIARCH inline Query(const typename QueryInType::InputType& in) : QueryInType(in), QueryOutType() {}
 
        PONCA_MULTIARCH inline Query(const typename QueryOutType::OutputParameter& outParam,
                                     const typename QueryInType::InputType& in)
            : QueryOutType(outParam), QueryInType(in)
        {
        }
 
        template <typename Base, typename... outputType>
        PONCA_MULTIARCH inline Base& operator()(const typename QueryInType::InputType& in, outputType&&... out)
        {
            QueryInType::operator()(in);
            QueryOutType::operator()(std::forward<outputType>(out)...);
            return *((Base*)(this));
        }
 
        template <typename Base>
        PONCA_MULTIARCH inline Base& operator()(const typename QueryInType::InputType& in)
        {
            QueryInType::operator()(in);
            return *((Base*)(this));
        }
    };
 
    DECLARE_INDEX_QUERY_CLASS(KNearest) // KNearestIndexQuery
    DECLARE_INDEX_QUERY_CLASS(Nearest)  // NearestIndexQuery
    DECLARE_INDEX_QUERY_CLASS(Range)    // RangeIndexQuery
    DECLARE_POINT_QUERY_CLASS(KNearest) // KNearestPointQuery
    DECLARE_POINT_QUERY_CLASS(Nearest)  // NearestPointQuery
    DECLARE_POINT_QUERY_CLASS(Range)    // RangePointQuery
 
 
#undef DECLARE_INDEX_QUERY_CLASS
#undef DECLARE_POINT_QUERY_CLASS
} // namespace Ponca