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
{
 
    // 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, int MAX_KNN_SIZE>
    struct QueryOutputIsKNearest : public QueryOutputBase
    {
        using OutputParameter = Index;
        using Queue = LimitedPriorityQueue<IndexSquaredDistance<Index, Scalar>, MAX_KNN_SIZE>;
 
        PONCA_MULTIARCH inline QueryOutputIsKNearest(OutputParameter k = 0) : m_queue(k) {}
 
        PONCA_MULTIARCH inline void operator()(OutputParameter k) { m_queue = Queue(k); }
 
        PONCA_MULTIARCH inline Queue& 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; }
        Queue 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));
        }
    };
 
#define POINT_QUERY_DOC(OUT_TYPE)
                                          \
                                                    \
                                                          \
 
#define INDEX_QUERY_DOC(OUT_TYPE)
                                          \
                                                    \
                                                          \
 
    POINT_QUERY_DOC(KNearest)
    template <typename Index, typename DataPoint, int MAX_KNN_SIZE>
    using KNearestPointQuery =
        Query<QueryInputIsPosition<DataPoint>, QueryOutputIsKNearest<Index, typename DataPoint::Scalar, MAX_KNN_SIZE>>;
    POINT_QUERY_DOC(Nearest)
    template <typename Index, typename DataPoint>
    using NearestPointQuery =
        Query<QueryInputIsPosition<DataPoint>, QueryOutputIsNearest<Index, typename DataPoint::Scalar>>;
    POINT_QUERY_DOC(Range)
    template <typename Index, typename DataPoint>
    using RangePointQuery =
        Query<QueryInputIsPosition<DataPoint>, QueryOutputIsRange<Index, typename DataPoint::Scalar>>;
 
    INDEX_QUERY_DOC(KNearest)
    template <typename Index, typename Scalar, int MAX_KNN_SIZE>
    using KNearestIndexQuery = Query<QueryInputIsIndex<Index>, QueryOutputIsKNearest<Index, Scalar, MAX_KNN_SIZE>>;
    INDEX_QUERY_DOC(Nearest)
    template <typename Index, typename Scalar>
    using NearestIndexQuery = Query<QueryInputIsIndex<Index>, QueryOutputIsNearest<Index, Scalar>>;
    INDEX_QUERY_DOC(Range)
    template <typename Index, typename Scalar>
    using RangeIndexQuery = Query<QueryInputIsIndex<Index>, QueryOutputIsRange<Index, Scalar>>;
 
#undef POINT_QUERY_DOC
#undef INDEX_QUERY_DOC
} // namespace Ponca