TreeFunctions.hpp

#ifndef __BASEOP_TREEFUNCTIONS_HPP
#define __BASEOP_TREEFUNCTIONS_HPP
 
#include "elementary/aerie/KDTree.hpp"
#include "elementary/aerie/OcTree.hpp"
#include "fish/fiber/field/CreativeArrayBase.hpp"
//#include "omp.h"
 
 
namespace Fiber
{
using namespace MemCore;
 
 
template<int N, class T, class C>
MemCore::RefPtr<Eagle::KDTree<N,T> > createTree (const C& coordinates, const unsigned size)
{
MemCore::RefPtr<Eagle::KDTree<N,T> > tree = new Eagle::KDTree <N,T>();
 
//#pragma omp parallel for
        for (T i = 0; i < size; i++)
                tree->insert(FixedArray<double,N>(coordinates[i], 0.0), i);
 
        assert (tree && "TreeFunctions::createTree ... assert(tree)");
 
        Verbose(50) << "TreeFunctions::createTree ... tree filled ... size = " << size;
 
        return tree;
}
 
 
template<int N, class T, class C>
MemCore::RefPtr<Eagle::KDTree<N,T> > createTree (const C& coordinates, const unsigned size,
                                                 const MemCore::RefPtr<Fiber::CreativeArrayBase>& cab )
{
        if (!cab)
                Verbose(0) << "TreeFunctions::createTree ... no CreativeArrayBase found";
 
        /*
          Note (WB): Code like this can be signficantly shortened:
 
          if (RefPtr a = findInterface)
                return a;
          else
          {
          RefPtr a = createTree();
                cab->addInterface(a);
                return a;
          }
         */
        MemCore::RefPtr<Eagle::KDInterface< N,T > > myKDinterface = cab->findInterface(typeid (Eagle::KDTree < N,T > ));
        MemCore::RefPtr<Eagle::KDTree< N,T > > tree;
 
        if (!myKDinterface)
        {
                tree =  createTree<N,T,C>(coordinates,size);
                myKDinterface = new Eagle::KDInterface<N,T> (tree);
 
                cab->addInterface (myKDinterface);
        }
        else
        {
                tree = myKDinterface->Tree;
                Verbose(50) << "TreeFunctions::createTree ... found cached tree";
        }
 
        return tree;
}
 
template<class T>
MemCore::RefPtr<Eagle::OcTree<T> > createOcTree (const MultiArray<1, Eagle::PhysicalSpace::point>& coordinates, const size_t size,
                                                 const RefPtr<Eagle::BoundingBox>& bb )
{
MemCore::RefPtr<Eagle::OcTree<T> > octree = new Eagle::OcTree <T>( bb );
 
        for (index_t i = 0; i < size; i++)
        {
//              if( i % 10000 == 0)
//              Verbose(0) << coordinates[i] << ", " << size << ", " << bb->minCoord() << "-" << bb->maxCoord();
 
                octree->insert( coordinates[i], i);
        }
        return octree;
}
 
 
template<class T>
MemCore::RefPtr<Eagle::QuadTree<T> > createQuadTree (const MultiArray<1, Eagle::PhysicalSpace::point>& coordinates, const size_t size,
                                                     const RefPtr<Eagle::BoundingBox>& bb )
{
MemCore::RefPtr<Eagle::QuadTree<T> > quad_tree = new Eagle::QuadTree<T>( bb );
 
        for (index_t i = 0; i < size; i++)
        {
//              if( i % 10000 == 0)
//              Verbose(0) << coordinates[i] << ", " << size << ", " << bb->minCoord() << "-" << bb->maxCoord();
 
                quad_tree->insert( coordinates[i], i);
        }
        return quad_tree;
}
 
} // namespace Fiber
 
#endif // __BASEOP_TREEFUNCTIONS_HPP