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