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 <cmath>
 
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_;
 
        inline QueryInput(InputType input) : m_input(input) {}
 
        inline const InputType &input() const { return m_input; }
    protected:
        inline void editInput(const InputType& input) { m_input = input; }
    
    private:
        const InputType m_input;
    };
 
 
    template <typename Index>
    struct QueryInputIsIndex : public QueryInput<Index> {
        using Base = QueryInput<Index>;
        using InputType = typename Base::InputType;
 
        inline QueryInputIsIndex(const InputType &point = -1)
                : Base(point) {}
    protected:
        template <typename IndexType>
        inline bool skipIndexFunctor(IndexType idx) const {return Base::input() == idx;};
        template <typename Container>
        inline auto getInputPosition(const Container &c) -> const typename Container::value_type::VectorType
        { 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;
 
        inline QueryInputIsPosition(const InputType &point = InputType::Zero())
                : Base(point) {}
    protected:
        template <typename IndexType>
        inline bool skipIndexFunctor(IndexType idx) const {return false;};
        template <typename Container>
        inline auto getInputPosition(const Container &) -> const typename Container::value_type::VectorType
        { return Base::input(); }
    };
 
    template<typename Index, typename Scalar>
    struct QueryOutputIsRange : public QueryOutputBase {
        using OutputParameter = Scalar;
 
        inline QueryOutputIsRange(OutputParameter radius = OutputParameter(0))
                : m_squared_radius(std::pow(radius, OutputParameter(2))) {}
 
        inline Scalar radius() const { return std::sqrt(m_squared_radius); }
 
        inline Scalar squared_radius() const { return m_squared_radius; }
 
        inline void set_radius(Scalar radius) { m_squared_radius = std::pow(radius, 2); }
 
        inline void set_squared_radius(Scalar radius) { m_squared_radius = radius; }
 
    protected:
        inline void reset() { }
        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;
 
        QueryOutputIsNearest() {}
 
        Index get() const { return m_nearest; }
 
    protected:
        void reset() {
            m_nearest = -1;
            m_squared_distance = std::numeric_limits<Scalar>::max();
        }
        inline Scalar descentDistanceThreshold() const { return m_squared_distance; }
 
        Index m_nearest {-1};
        Scalar m_squared_distance {std::numeric_limits<Scalar>::max()};
    };
 
    template<typename Index, typename Scalar>
    struct QueryOutputIsKNearest : public QueryOutputBase {
        using OutputParameter = Index;
 
        inline QueryOutputIsKNearest(OutputParameter k = 0) : m_queue(k) {}
 
        inline limited_priority_queue<IndexSquaredDistance<Index, Scalar>> &queue() { return m_queue; }
 
    protected:
        void reset() {
            m_queue.clear();
            m_queue.push({-1,std::numeric_limits<Scalar>::max()});
        }
        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");
 
        inline Query(const typename QueryInType::InputType &in)
                : QueryInType(in), QueryOutType() {}
 
        inline Query(const typename QueryOutType::OutputParameter &outParam,
                     const typename QueryInType::InputType &in)
                : QueryOutType(outParam), QueryInType(in) {}
    };
 
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
}