KDTreeRG.h

Go to the documentation of this file.

#ifndef _KDTreeRG_
#define _KDTreeRG_
 
#include <ostream>
#include <vector>
#include <vapor/Grid.h>
 
#include "nanoflann.hpp"
 
struct kdtree;
 
namespace VAPoR {
//
//
class VDF_API KDTreeRG {
public:
    //
    KDTreeRG(const Grid &xg, const Grid &yg);
 
    //
    // KDTreeRG( const Grid &xg, const Grid &yg, const Grid &zg );
 
    virtual ~KDTreeRG();
 
    //
    void Nearest(const std::vector<float> &coordu, std::vector<size_t> &index) const;
 
    void Nearest(const std::vector<double> &coordu, std::vector<size_t> &index) const
    {
        std::vector<float> coordu_f;
        for (int i = 0; i < coordu.size(); i++) coordu_f.push_back(coordu[i]);
        this->Nearest(coordu_f, index);
    }
 
    std::vector<size_t> GetDimensions() const { return (_dims); }
 
private:
    class PointCloud2D {
    public:
        // Constructor
        PointCloud2D(const Grid &xg, const Grid &yg)
        {
            VAssert(xg.GetDimensions() == yg.GetDimensions());
            VAssert(xg.GetNumDimensions() <= 2);
 
            // number of elements
            auto   dims = xg.GetDimensions();
            size_t nelem = 1;
            for (int i = 0; i < dims.size(); i++) nelem *= dims[i];
            this->X.resize(nelem);
            this->Y.resize(nelem);
 
            // Store the point coordinates in the k-d tree
            Grid::ConstIterator xitr = xg.cbegin();
            Grid::ConstIterator yitr = yg.cbegin();
 
            for (size_t i = 0; i < nelem; ++i, ++xitr, ++yitr) {
                this->X[i] = *xitr;
                this->Y[i] = *yitr;
            }
        }    // end of the Constructor
 
        // Must return the number of data points
        inline size_t kdtree_get_point_count() const
        {
            VAssert(X.size() == Y.size());
            return X.size();
        }
 
        // Returns the dim'th component of the idx'th point in the class:
        // Since this is inlined and the "dim" argument is typically an immediate value, the
        //  "if/else's" are actually solved at compile time.
        inline float kdtree_get_pt(const size_t idx, int dim) const
        {
            if (dim == 0)
                return X[idx];
            else
                return Y[idx];
        }
 
        // Optional bounding-box computation: return false to default to a standard bbox computation loop.
        //   Return true if the BBOX was already computed by the class and returned in "bb"
        //   so it can be avoided to redo it again.
        //   Look at bb.size() to find out the expected dimensionality (e.g. 2 or 3 for point clouds)
        template<class BBOX> bool kdtree_get_bbox(BBOX & /* bb */) const { return false; }
 
    private:
        std::vector<float> X, Y;
 
    };    // end of class PointCloud2D
 
    typedef nanoflann::KDTreeSingleIndexAdaptor<nanoflann::L2_Simple_Adaptor<float, PointCloud2D>, PointCloud2D, 2 /* dimension */> KDTreeType;
 
    PointCloud2D        _points;
    KDTreeType          _kdtree;
    std::vector<size_t> _dims;
};    // end of class KDTreeRG.
 
class VDF_API KDTreeRGSubset {
public:
    KDTreeRGSubset();
 
    //
    KDTreeRGSubset(const KDTreeRG *kdtreerg, const std::vector<size_t> &min, const std::vector<size_t> &max);
    ~KDTreeRGSubset() {}
 
    //
    void Nearest(const std::vector<float> &coordu, std::vector<size_t> &coord) const;
 
    void Nearest(const std::vector<double> &coordu, std::vector<size_t> &index) const
    {
        std::vector<float> coordu_f;
        for (int i = 0; i < coordu.size(); i++) coordu_f.push_back(coordu[i]);
        Nearest(coordu_f, index);
    }
 
    std::vector<size_t> GetDimensions() const
    {
        std::vector<std::size_t> dims;
        for (int i = 0; i < _min.size(); i++) { dims.push_back(_max[i] - _min[i] + 1); }
        return (dims);
    }
 
private:
    const KDTreeRG *    _kdtree;
    std::vector<size_t> _min;
    std::vector<size_t> _max;
};
 
};    // namespace VAPoR
 
#endif