VertexSelection.hpp

#ifndef VERTEX_SELECTION_HPP
#define VERTEX_SELECTION_HPP
 
#include <vector>
 
#include "gridopDllApi.h"
 
#include "aerie/BoundingBox.hpp"
#include "aerie/KDTree.hpp"
 
#include "ocean/shrimp/PhysicalSpace.hpp"
 
#include "bundle/GridSelector.hpp"
#include "field/OnDemandCreator.hpp"
#include "grid/types/LineSet.hpp"
#include "grid/CartesianChart.hpp"
 
 
 
namespace Fiber
{
 
 
// idx 0: fragment nr
// idx 1: vertex nr
typedef Fiber::MultiIndex<2> VertexSelection_t;
 
 
 
 
struct VertexSelectionComp 
{
        bool operator() (const VertexSelection_t& lhs, const VertexSelection_t& rhs) const
        {
                if( lhs[0] < rhs[0])
                        return true; 
                else if( lhs[0] > rhs[0] )
                        return false; 
                else
                {
                        if( lhs[1] < rhs[1] )
                                return true; 
                        else
                                return false; 
                }
        }
};
 
struct  gridop_API VertexSelectionIterator 
{
        virtual bool apply( const std::string&name, int ref, MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> >& selection ) = 0;
};
 
 
class gridop_API VertexSelection : public MemCore::ReferenceBase<VertexSelection >
{
std::map<int, MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> > > m_ref_to_vertex_index;
std::string m_name; 
// map fagnr to fragsize in selection
std::map<int, std::map<int, size_t> > m_ref_to_fragnr;
 
static Fiber::SkeletonID m_id;
 
public: 
        VertexSelection( const MemCore::RefPtr<Fiber::Grid>& grid, std::string name );
 
        void iterate( VertexSelectionIterator&VSI );
        MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> > getFinestSelection() const; 
        MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> > getSelection( unsigned ref_level ); 
        MemCore::RefPtr<Fiber::MemArray<1, size_t> > getSelection( unsigned ref_level, unsigned FragNr ); 
 
        std::string getName()
        {
                return m_name;
        }
 
        bool empty()
        {
                return m_ref_to_vertex_index.empty();
        } 
 
        // add the other selection into this one, no check for duplicate selections
        void add( VertexSelection& vs ); 
 
        // add other selection and avoid duplicates
        void merge( const VertexSelection& vs ); 
 
        void speak()
        {
        std::map<int, MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> > >::const_iterator it; 
                for( it = m_ref_to_vertex_index.begin(); it != m_ref_to_vertex_index.end(); it++  )
                {
                        std::cout << "ref: " << it->first << ", "; 
                Fiber::MultiArray<1, VertexSelection_t>& m = *it->second; 
                        for( size_t i = 0; i < it->second->Size()[0]; i++ )
                                std::cout << m[i][0] << "-" << m[i][1] << " "; 
                        std::cout << std::endl;
                }
        } 
 
        bool hasRefLevel( int ref )
        {
                return ( m_ref_to_vertex_index.find( ref ) != m_ref_to_vertex_index.end() );
        } 
 
        unsigned getMaxRef() // error check?
        {
                return m_ref_to_vertex_index.rbegin()->first;
        } 
 
        static SkeletonID& getID( int refinement = -1 )
        {
                m_id.setRefinement( 0,0 ); 
                if( refinement > 0) 
                        m_id.setRefinement( 0, refinement ); 
 
                return m_id;
        }
 
};
 
 
extern gridop_API void fillVertexSelection( RefPtr<Grid>& grid, RefPtr<MemArray<1, VertexSelection_t> >& selection );
 
extern gridop_API void growVertexSelection(  MemCore::RefPtr<Fiber::Grid>& grid, MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> >& selection, double radius );
 
extern gridop_API bool getBoundsHelper( const MemCore::RefPtr<Fiber::Representation>& representation, MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> >& selection, MemCore::RefPtr<Eagle::BoundingBox>& bb );
 
 
 
struct gridop_API ComputeBounds : public VertexSelectionIterator
{
//FragmentIDs m_fids;
MemCore::RefPtr<Fiber::Representation> m_representation;
MemCore::RefPtr<Eagle::BoundingBox> bb; 
 
        ComputeBounds( const MemCore::RefPtr<Fiber::Representation>& rep )
        : m_representation( rep )
        {}
 
        bool apply( const std::string&name, int ref, 
                    MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> >& selection )
        {
                getBoundsHelper( m_representation, selection, bb ); 
                return true;
        } 
 
                
};
 
 
extern gridop_API MemCore::RefPtr<Eagle::BoundingBox> getVertexSelectionBounds( MemCore::RefPtr<Fiber::Grid>& grid, MemCore::RefPtr<VertexSelection>& vs );
 
 
// no refinement here yet
extern gridop_API MemCore::RefPtr<Eagle::BoundingBox> getVertexSelectionBounds( MemCore::RefPtr<Fiber::Grid>& grid, MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> >& vs);
 
 
extern gridop_API MemCore::RefPtr<VertexSelection> getVertexSelection( MemCore::RefPtr<Fiber::Grid>& grid, const std::string& sel_name );
 
 
extern gridop_API MemCore::RefPtr<VertexSelection> getMergedVertexSelection( const MemCore::RefPtr<Fiber::Grid>& grid, const MemCore::StringList& sel, bool reduce = false );
 
extern gridop_API bool addVertexSelection( MemCore::RefPtr<Fiber::Grid>& grid, 
                                           const std::string& sel_name, 
                                           const MemCore::RefPtr<Fiber::MemArray<1, VertexSelection_t> >& sel_indices,
                                           int refinement_level = -1 );
 
 
                
 
//typedef std::pair<size_t,size_t> VertexSelection_t;
 
struct gridop_API SelectionExtractor : Fiber::FieldFragmentIterator
{
        bool m_found;
        std::string m_name;
        MemCore::RefPtr<Fiber::MemArray<1, size_t> > m_selection;
        
        SelectionExtractor( std::string name)
        : m_found( false )
        , m_name(name)
                {}
        
        bool apply( const MemCore::RefPtr<Fiber::FragmentID>&f,
                    const MemCore::StrongPtr<Fiber::CreativeArrayBase>&DC )
                {
                        if(!f)
                                return true; 
 
                        if( f->Name() == m_name)
                        {
                                m_found = true; 
                                m_selection = DC->create(); 
 
                                return false; // break iteration if found
                        } 
 
                        return true;
                }
};
 
extern gridop_API MemCore::RefPtr<Fiber::Field> getVertexSelectionPositions( MemCore::RefPtr<Fiber::Grid>& grid );
 
 
 
 
 
 
 
 
 
extern gridop_API RefPtr<Field> getCartesianVertexField( GridSelector& gs, double time, string field_name, int ref = 0 );
 
extern gridop_API RefPtr<Representation> getUnRefinedCartesianRepresentation( const RefPtr<Grid>& grid, double time );
extern gridop_API RefPtr<Representation> getUnRefinedCartesianRepresentation( GridSelector& gs, double time );
 
extern gridop_API RefPtr<Representation> getRefinedCartesianRepresentation(  const RefPtr<Grid>& grid, double time, int ref );
 
extern gridop_API RefPtr<Representation> getRefinedCartesianRepresentation( GridSelector& gs, double time, int ref );
 
extern gridop_API RefPtr<Field> getUnRefinedCartesianVertexField( GridSelector& gs, double time, string field_name );
extern gridop_API RefPtr<Field> getRefinedCartesianVertexField( GridSelector& gs, double time, string field_name, int ref);
 
 
/*
 
extern gridop_API bool addVertexSelection( MemCore::RefPtr<Fiber::Grid>& grid, const std::string& sel_name, const MemCore::RefPtr<Fiber::MemArray<1, size_t> >& sel_indices );
 
 
extern gridop_API MemCore::RefPtr<Fiber::MemArray<1, size_t> > getVertexSelectionOld( MemCore::RefPtr<Fiber::Grid>& grid, const std::string& sel_name );
 
*/
 
}
 
#endif // VERTEX_SELECTION_HPP