grid/types/RegularlyFragmentedClusteredPointCloudGrid.hpp

#ifndef __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDCLUSTEREDPOINTGRID_HPP
#define __FIBER_GRID_TYPES_REGULARLYFRAGMENTEDCLUSTEREDPOINTGRID_HPP
 
#include "gridtypesDllApi.h"
 
#include "RegularlyFragmentedGrid.hpp"
 
#include "elementary/aerie/BoundingBox.hpp"
#include "fish/fiber/bundle/Bundle.hpp"
 
 
 
namespace Fiber
{
struct  gridtypes_API FragmentedUniformGrid3DPoints : public RegularlyFragmentedGridWithCartesianVertices<3>
{
 
typedef MemArray<1, Eagle::PhysicalSpace::point>        CoordsArray_t;
 
        RefPtr<UniformCartesianArray> FragmentCoordinates; 
 
        FragmentedUniformGrid3DPoints( const RefPtr<Grid>& grid );
 
        ~FragmentedUniformGrid3DPoints();
 
        RefPtr<CoordsArray_t> getCoords(const MultiIndex<3>&I) const
        {
                return getCoordData(I);
        }
 
        bool    isValid() const
        {
                return FragmentCoordinates.valid();
        } 
 
 
static  FragmentedUniformGrid3DPoints create( Grid&grid, const MultiIndex<3>&nr_fragments, 
                                              const Eagle::point3&start, const Eagle::point3&end );
 
static FragmentedUniformGrid3DPoints create( Grid&grid, const MultiIndex<3>&nr_fragments, 
                                             const Eagle::BoundingBox&bb );
};
 
 
typedef uint32_t vc_index_t;
 
 
struct VertexCluster
{
vc_index_t start;
vc_index_t size;
};
 
struct gridtypes_API RegularlyFragmentedClusteredPointCloudGrid : public FragmentedUniformGrid3DPoints
{
RefPtr<Skeleton> Cell;    // topology storing the cell geometry 
RefPtr<Skeleton> Cluster; // topology storing vertex cluster as the lookup into the cells (sparse), and data thereon 
 
RefPtr<Representation> CellsAsCartesian; // geometry of cells as cartesian chart 
RefPtr<Representation> ClusterAsPoints;  // cluster as points stores start indices of the cluster into the cart. vertices 
RefPtr<Representation> ClusterAsCells;   // cluster as cells sotres an serialized index into the cells 1D -> 3D 
 
RefPtr<RegularlyFragmentedField<3> > CellPositions;            // cell geometry is a uniform grid 
RefPtr<RegularlyFragmentedField<3> > ClusterAsPointsPositions; // positions field with 1D array of cell indices
RefPtr<RegularlyFragmentedField<3> > ClusterAsCellPositions;   // positions field width 1D array of vertex start indices 
 
// types of the data arrays used in the position fields
typedef RefPtr<UniformCartesianArray > CellArray_t;    
typedef RefPtr<MemArray<1, vc_index_t> > ClusterStartsArray_t;
typedef RefPtr<MemArray<1, vc_index_t> > ClusterArray_t;
typedef std::map<vc_index_t, vc_index_t> IndexMap_t;
 
public: 
        RegularlyFragmentedClusteredPointCloudGrid( const RefPtr<Grid>&G ); 
 
        ~RegularlyFragmentedClusteredPointCloudGrid();
 
        struct FragmentWorker
        {
        const RegularlyFragmentedClusteredPointCloudGrid& ClusterGrid;  
        RefPtr<MemArray<1, Eagle::PhysicalSpace::point> > VertexArray;
        CellArray_t CellArray;
        ClusterStartsArray_t ClusterStartsArray;
        ClusterArray_t ClusterArray;
 
        // mapping of 3D MultiIndex of uniform grid to sparse cluster index
        map<vc_index_t, vc_index_t> FullIndexToSparseIndex;
 
        FragmentWorker( const RegularlyFragmentedClusteredPointCloudGrid& cluster_grid, const MultiIndex<3>& frag_index );
  
        bool findCluster( const Eagle::PhysicalSpace::point& query_position, vc_index_t& cluster );
 
        bool findVertexCluster( const Eagle::PhysicalSpace::point& query_position, VertexCluster& vertex_cluster );  
          
 
        bool findVertexClustersOnLine( const Eagle::PhysicalSpace::point& line_start, 
                                       const Eagle::PhysicalSpace::point& line_end, 
                                       double distance, vector<VertexCluster>& vertex_clusters );
          
        RefPtr<Chunk<vc_index_t> > findVertices( const Eagle::PhysicalSpace::point& query_position, double radius );
        
        };
        
static  SkeletonID ClusterCellID()
{
        return SkeletonID(0,2);
} 
 
static  SkeletonID ClusterLookUpID()
{
        return SkeletonID(0,3);
} 
 
 
CellArray_t getCellArray( const MultiIndex<3>&frag ) const; 
 
ClusterStartsArray_t getClusterStartsArray(  const MultiIndex<3>&frag ) const; 
 
ClusterArray_t getClusterLookUpArray( const MultiIndex<3>&frag ) const; 
 
 
 
bool findFragment( const Eagle::PhysicalSpace::point& query_position, MultiIndex<3>& index ) const; 
 
 
 
bool findCell( const Eagle::PhysicalSpace::point& query_position, const MultiIndex<3>&frag_index, MultiIndex<3>&cell_index ) const; 
 
 
 
bool findFragmentAndCell( const Eagle::PhysicalSpace::point& query_position, MultiIndex<3>&frag_index, MultiIndex<3>&cell_index ) const; 
 
 
 
RefPtr<Chunk<MultiIndex<3> > > findCellsManhatten( const Eagle::PhysicalSpace::point& query_position, double radius ) const; 
 
 
 
RefPtr<Chunk<MultiIndex<3> > > findCells( const Eagle::PhysicalSpace::point& query_position, double radius );
 
 
 
RefPtr<Chunk<MultiIndex<3> > > findCells( const Eagle::PhysicalSpace::point& query_position, double radius, const MultiIndex<3>&frag_index  ); 
 
 
 
RefPtr<Chunk<Eagle::PhysicalSpace::point> > findPoints( const Eagle::PhysicalSpace::point& query_position, double radius );
 
 
 
RefPtr<Chunk<Eagle::PhysicalSpace::point> > findPoints( const Eagle::PhysicalSpace::point& query_position, double radius, const MultiIndex<3>& frag_index ); 
 
 
 
/*
PointCluster findPointCluster( const Eagle::PhysicalSpace::point& query_position ); 
 
RefPtr<Chunk<unsigned> > findPointIndices( const Eagle::PhysicalSpace::point& query_position, double radius );
*/ 
static int getCellsWherePointIsInGhostZone( const MultiIndex<3>& current, const MultiIndex<3>& max_cells, const Eagle::PhysicalSpace::point &pos, const Eagle::PhysicalSpace::point &t_min, const Eagle::PhysicalSpace::tvector &t_diag, double ghost_r, Eagle::FixedArray<MultiIndex<3>, 7>& cells );
 
 
static bool create( RefPtr<Grid>& RegularGrid, 
                    const RefPtr<RegularlyFragmentedField<3> >& CellPositions, 
                    const RefPtr<RegularlyFragmentedField<3> >& ClusterAsPointsPositions, 
                    const RefPtr<RegularlyFragmentedField<3> >& ClusterAsCellPositions ); 
 
static bool create( RefPtr<Grid>& grid, 
                    const MultiIndex<3>& fragment_resolution, 
                    const RefPtr<Eagle::BoundingBox>& bb );     
        
};
 
 
 
 
} // namespace Fiber
 
#endif