KDTreeLinkerToolsT.h

Go to the documentation of this file.

#ifndef LAR_KD_TREE_LINKER_TOOLS_TEMPLATED_H
#define LAR_KD_TREE_LINKER_TOOLS_TEMPLATED_H 1

#include "Api/PandoraContentApi.h"

#include "Objects/CaloHit.h"
#include "Objects/CartesianVector.h"

#include "Pandora/PandoraInternal.h"

#include <array>
#include <vector>

namespace pandora
{
class Algorithm;
}

//------------------------------------------------------------------------------------------------------------------------------------------

namespace lar_content
{

template <unsigned DIM>
class KDTreeBoxT
{
public:
    KDTreeBoxT();

    template <typename... Ts>
    KDTreeBoxT(Ts... dimargs);

    std::array<float, DIM> dimmin; 
    std::array<float, DIM> dimmax; 
};

typedef KDTreeBoxT<2> KDTreeBox;
typedef KDTreeBoxT<3> KDTreeCube;

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
class KDTreeNodeInfoT
{
public:
    KDTreeNodeInfoT();

    template <typename... Ts>
    KDTreeNodeInfoT(const DATA &d, Ts... dimargs);

    DATA data;                   
    std::array<float, DIM> dims; 
};

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
class KDTreeNodeT
{
public:
    KDTreeNodeT();

    void setAttributs(const KDTreeBoxT<DIM> &regionBox, const KDTreeNodeInfoT<DATA, DIM> &infoToStore);

    void setAttributs(const KDTreeBoxT<DIM> &regionBox);

    KDTreeNodeInfoT<DATA, DIM> info; 
    KDTreeNodeT<DATA, DIM> *left;    
    KDTreeNodeT<DATA, DIM> *right;   
    KDTreeBoxT<DIM> region;          
};

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename T>
class kdtree_type_adaptor
{
public:
    static const pandora::CartesianVector &position(const T *const t);
};

//------------------------------------------------------------------------------------------------------------------------------------------

std::pair<float, float> minmax(const float a, const float b);

template <typename T>
KDTreeBox fill_and_bound_2d_kd_tree(const MANAGED_CONTAINER<const T *> &points, std::vector<KDTreeNodeInfoT<const T *, 2>> &nodes);

template <typename T>
KDTreeCube fill_and_bound_3d_kd_tree(const MANAGED_CONTAINER<const T *> &points, std::vector<KDTreeNodeInfoT<const T *, 3>> &nodes);

KDTreeBox build_2d_kd_search_region(const pandora::CaloHit *const point, const float x_span, const float z_span);

KDTreeBox build_2d_kd_search_region(const pandora::CartesianVector &pos, const float x_span, const float z_span);

KDTreeCube build_3d_kd_search_region(const pandora::CaloHit *const point, const float x_span, const float y_span, const float z_span);

KDTreeCube build_3d_kd_search_region(const pandora::CartesianVector &pos, const float x_span, const float y_span, const float z_span);

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

template <unsigned DIM>
inline KDTreeBoxT<DIM>::KDTreeBoxT()
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <unsigned DIM>
template <typename... Ts>
inline KDTreeBoxT<DIM>::KDTreeBoxT(Ts... dimargs)
{
    static_assert(sizeof...(dimargs) == 2 * DIM, "Constructor requires 2*DIM args");
    std::vector<float> dims = {dimargs...};

    for (unsigned i = 0; i < DIM; ++i)
    {
        dimmin[i] = dims[2 * i];
        dimmax[i] = dims[2 * i + 1];
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
inline KDTreeNodeInfoT<DATA, DIM>::KDTreeNodeInfoT() :
    data()
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
template <typename... Ts>
inline KDTreeNodeInfoT<DATA, DIM>::KDTreeNodeInfoT(const DATA &d, Ts... dimargs) :
    data(d),
    dims{{dimargs...}}
{
}

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
inline KDTreeNodeT<DATA, DIM>::KDTreeNodeT() :
    left(nullptr),
    right(nullptr)
{
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
inline void KDTreeNodeT<DATA, DIM>::setAttributs(const KDTreeBoxT<DIM> &regionBox, const KDTreeNodeInfoT<DATA, DIM> &infoToStore)
{
    info = infoToStore;
    region = regionBox;
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename DATA, unsigned DIM>
inline void KDTreeNodeT<DATA, DIM>::setAttributs(const KDTreeBoxT<DIM> &regionBox)
{
    region = regionBox;
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename T>
inline const pandora::CartesianVector &kdtree_type_adaptor<T>::position(const T *const t)
{
    return t->GetPosition();
}

template <>
inline const pandora::CartesianVector &kdtree_type_adaptor<const pandora::CaloHit>::position(const pandora::CaloHit *const t)
{
    return t->GetPositionVector();
}

template <>
inline const pandora::CartesianVector &kdtree_type_adaptor<const pandora::CartesianVector>::position(const pandora::CartesianVector *const t)
{
    return *t;
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename T>
KDTreeBox fill_and_bound_2d_kd_tree(const MANAGED_CONTAINER<const T *> &points, std::vector<KDTreeNodeInfoT<const T *, 2>> &nodes)
{
    std::array<float, 2> minpos{{0.f, 0.f}}, maxpos{{0.f, 0.f}};

    unsigned i = 0;

    for (const T *const point : points)
    {
        const pandora::CartesianVector &pos = kdtree_type_adaptor<const T>::position(point);
        nodes.emplace_back(point, pos.GetX(), pos.GetZ());

        if (0 == i)
        {
            minpos[0] = pos.GetX();
            minpos[1] = pos.GetZ();
            maxpos[0] = pos.GetX();
            maxpos[1] = pos.GetZ();
        }
        else
        {
            minpos[0] = std::min(pos.GetX(), minpos[0]);
            minpos[1] = std::min(pos.GetZ(), minpos[1]);
            maxpos[0] = std::max(pos.GetX(), maxpos[0]);
            maxpos[1] = std::max(pos.GetZ(), maxpos[1]);
        }

        ++i;
    }

    return KDTreeBox(minpos[0], maxpos[0], minpos[1], maxpos[1]);
}

//------------------------------------------------------------------------------------------------------------------------------------------

template <typename T>
KDTreeCube fill_and_bound_3d_kd_tree(const MANAGED_CONTAINER<const T *> &points, std::vector<KDTreeNodeInfoT<const T *, 3>> &nodes)
{
    std::array<float, 3> minpos{{0.f, 0.f, 0.f}}, maxpos{{0.f, 0.f, 0.f}};

    unsigned i = 0;

    for (const T *const point : points)
    {
        const pandora::CartesianVector &pos = kdtree_type_adaptor<const T>::position(point);
        nodes.emplace_back(point, pos.GetX(), pos.GetY(), pos.GetZ());

        if (0 == i)
        {
            minpos[0] = pos.GetX();
            minpos[1] = pos.GetY();
            minpos[2] = pos.GetZ();
            maxpos[0] = pos.GetX();
            maxpos[1] = pos.GetY();
            maxpos[2] = pos.GetZ();
        }
        else
        {
            minpos[0] = std::min(pos.GetX(), minpos[0]);
            minpos[1] = std::min(pos.GetY(), minpos[1]);
            minpos[2] = std::min(pos.GetZ(), minpos[2]);
            maxpos[0] = std::max(pos.GetX(), maxpos[0]);
            maxpos[1] = std::max(pos.GetY(), maxpos[1]);
            maxpos[2] = std::max(pos.GetZ(), maxpos[2]);
        }

        ++i;
    }

    return KDTreeCube(minpos[0], maxpos[0], minpos[1], maxpos[1], minpos[2], maxpos[2]);
}

} // namespace lar_content

#endif // LAR_KD_TREE_LINKER_TOOLS_TEMPLATED_H