selector_interface.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__LIBGRID__SELECTOR_INTERFACE__
#define __H__LIBGRID__SELECTOR_INTERFACE__
 
#include <cassert>
#include "lib_grid/grid/grid.h"
 
#ifdef UG_PARALLEL
  #include "lib_grid/parallelization/parallel_grid_layout.h"
  #include "pcl/pcl_interface_communicator.h"
#endif
 
 
namespace ug
{
//  SelectorElements
 
enum SelectorElements
{
  SE_NONE = 0,
  SE_VERTEX = 1,
  SE_EDGE = 1<<1,
  SE_FACE = 1<<2,
  SE_VOLUME = 1 << 3,
  SE_ALL = SE_VERTEX | SE_EDGE | SE_FACE | SE_VOLUME
};
 
//  ISelector
 
class UG_API ISelector : public GridObserver
{
  public:
    typedef byte  status_t;
 
    enum{
      DESELECTED = 0,
      SELECTED = 1
    };
 
  public:
    ISelector(uint supportedElements = SE_ALL);
    ISelector(Grid& grid, uint supportedElements = SE_ALL);
    virtual ~ISelector();
 
  //  virtual methods
    virtual void clear() = 0;
 
  //  selection
 
    inline void select(GridObject* elem, byte status);
    inline void select(GridObject* elem)
    {select(elem, 1);}
 
    template <class TElem>
    inline void select(TElem* elem, byte status);
    template <class TElem>
    inline void select(TElem* elem)
    {select(elem, 1);}
 
    template <class TIterator>
    inline void select(TIterator iterBegin, TIterator iterEnd, byte status = 1);
 
    template <class TElem>
    inline void mark(TElem* elem)
    {select(elem);}
 
    template <class TElem>
    inline void mark(TElem* elem, byte status)
    {select(elem, status);}
  //  deselection
    inline void deselect(GridObject* elem);
    
    template <class TElem>
    inline void deselect(TElem* elem);
    
    template <class TIterator>
    inline void deselect(TIterator iterBegin, TIterator iterEnd);
 
 
    template <class TElem>
    inline void unmark(TElem* elem)
    {deselect(elem);}
 
  //  selection status
 
    inline byte get_selection_status(GridObject* elem) const;
    inline byte get_selection_status(Vertex* vrt) const {if(!elements_are_supported(SE_VERTEX)) return 0; return m_aaSelVRT[vrt];}
    inline byte get_selection_status(Edge* edge) const  {if(!elements_are_supported(SE_EDGE)) return 0; return m_aaSelEDGE[edge];}
    inline byte get_selection_status(Face* face) const    {if(!elements_are_supported(SE_FACE)) return 0; return m_aaSelFACE[face];}
    inline byte get_selection_status(Volume* vol) const   {if(!elements_are_supported(SE_VOLUME)) return 0; return m_aaSelVOL[vol];}
 
    template <class TElem>
    inline byte get_mark(TElem* elem) const 
    {return get_selection_status(elem);}
 
    template <class TElem>
    inline bool is_selected(TElem* elem) const    {return get_selection_status(elem) != 0;}
 
  //  non-virtual methods.
    inline Grid* grid() const   {return m_pGrid;}
 
    virtual GridObjectCollection get_grid_objects() const = 0;
 
 
    inline bool elements_are_supported(uint shElements) const;
 
  //  if enabled, all new elements will be automatically enabled. Disabled by default.
    void enable_autoselection(bool bEnable);
    inline bool autoselection_enabled()   {return m_bAutoselectionEnabled;}
 
  //  if enabled, newly created elements derive their selection status from their parents. Enabled by default.
    void enable_selection_inheritance(bool bEnable);
    inline bool selection_inheritance_enabled()   {return m_bSelectionInheritanceEnabled;}
 
    void enable_strict_inheritance(bool bEnable);
    inline bool strict_inheritance_enabled()  {return m_bStrictInheritanceEnabled;}
  //  grid callbacks
  /*
    virtual void registered_at_grid(Grid* grid);
    virtual void unregistered_from_grid(Grid* grid);
  */
    virtual void grid_to_be_destroyed(Grid* grid);
    virtual void elements_to_be_cleared(Grid* grid);
 
  //  element callbacks
    virtual void vertex_created(Grid* grid, Vertex* vrt,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void edge_created(Grid* grid, Edge* e,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void face_created(Grid* grid, Face* f,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void volume_created(Grid* grid, Volume* vol,
                  GridObject* pParent = NULL,
                  bool replacesParent = false);
 
    virtual void vertex_to_be_erased(Grid* grid, Vertex* vrt,
                     Vertex* replacedBy = NULL);
 
    virtual void edge_to_be_erased(Grid* grid, Edge* e,
                     Edge* replacedBy = NULL);
 
    virtual void face_to_be_erased(Grid* grid, Face* f,
                     Face* replacedBy = NULL);
 
    virtual void volume_to_be_erased(Grid* grid, Volume* vol,
                     Volume* replacedBy = NULL);
 
    virtual void vertices_to_be_merged(Grid* grid, Vertex* target,
                     Vertex* elem1, Vertex* elem2);
 
    virtual void edges_to_be_merged(Grid* grid, Edge* target,
                     Edge* elem1, Edge* elem2);
 
    virtual void faces_to_be_merged(Grid* grid, Face* target,
                     Face* elem1, Face* elem2);
 
    virtual void volumes_to_be_merged(Grid* grid, Volume* target,
                     Volume* elem1, Volume* elem2);
 
    virtual bool contains_vertices() const = 0;
 
    virtual bool contains_edges() const = 0;
 
    virtual bool contains_faces() const = 0;
 
    virtual bool contains_volumes() const = 0;
 
 
    virtual void broadcast_selection_states(bool deselect = false,
                        bool includeGhosts = false);
 
  protected:
    typedef Grid::traits<Vertex>::AttachedElementList AttachedVertexList;
    typedef Grid::traits<Edge>::AttachedElementList   AttachedEdgeList;
    typedef Grid::traits<Face>::AttachedElementList     AttachedFaceList;
    typedef Grid::traits<Volume>::AttachedElementList   AttachedVolumeList;
 
    typedef Grid::traits<Vertex>::SectionContainer    VertexSectionContainer;
    typedef Grid::traits<Edge>::SectionContainer    EdgeSectionContainer;
    typedef Grid::traits<Face>::SectionContainer      FaceSectionContainer;
    typedef Grid::traits<Volume>::SectionContainer      VolumeSectionContainer;
 
  protected:
    virtual void add_to_list(Vertex* elem) = 0;
    virtual void add_to_list(Edge* elem) = 0;
    virtual void add_to_list(Face* elem) = 0;
    virtual void add_to_list(Volume* elem) = 0;
 
    virtual void erase_from_list(Vertex* elem) = 0;
    virtual void erase_from_list(Edge* elem) = 0;
    virtual void erase_from_list(Face* elem) = 0;
    virtual void erase_from_list(Volume* elem) = 0;
 
  protected:
 
    void set_grid(Grid* grid);
 
 
  //  Protected non-virtual to avoid virtual calls during construction
    void set_supported_elements(uint shElements);
 
 
  //  Protected non-virtual to avoid virtual calls during construction
    void enable_element_support(uint shElements);
 
 
  //  Protected non-virtual to avoid virtual calls during construction
    void disable_element_support(uint shElements);
 
    inline void mark_selected(Vertex* elem, byte status)  {assert(elements_are_supported(SE_VERTEX)); m_aaSelVRT[elem] = status;}
    inline void mark_selected(Edge* elem, byte status)    {assert(elements_are_supported(SE_EDGE)); m_aaSelEDGE[elem] = status;}
    inline void mark_selected(Face* elem, byte status)      {assert(elements_are_supported(SE_FACE)); m_aaSelFACE[elem] = status;}
    inline void mark_selected(Volume* elem, byte status)    {assert(elements_are_supported(SE_VOLUME)); m_aaSelVOL[elem] = status;}
 
    inline void mark_deselected(Vertex* elem) {assert(elements_are_supported(SE_VERTEX)); m_aaSelVRT[elem] = 0;}
    inline void mark_deselected(Edge* elem)   {assert(elements_are_supported(SE_EDGE)); m_aaSelEDGE[elem] = 0;}
    inline void mark_deselected(Face* elem)     {assert(elements_are_supported(SE_FACE)); m_aaSelFACE[elem] = 0;}
    inline void mark_deselected(Volume* elem)   {assert(elements_are_supported(SE_VOLUME)); m_aaSelVOL[elem] = 0;}
 
    template <class TElem>
    void elems_to_be_merged(Grid* grid, TElem* target,
                TElem* elem1, TElem* elem2);
 
  private:
    ISelector(const ISelector& sel){};
 
    #ifdef UG_PARALLEL
      template <class TIntfcCom>
      void broadcast_selection_states(bool deselect, bool includeGhosts,
                      TIntfcCom& icom);
    #endif
 
  protected:
    Grid* m_pGrid;
    uint  m_supportedElements;
    bool  m_bAutoselectionEnabled;
    bool  m_bSelectionInheritanceEnabled;
    bool  m_bStrictInheritanceEnabled;
    
  //  will use a default constructor
    typedef Attachment<unsigned char>   AUChar;
    AUChar                m_aSelected;
 
    Grid::AttachmentAccessor<Vertex, AUChar>  m_aaSelVRT;
    Grid::AttachmentAccessor<Edge, AUChar>    m_aaSelEDGE;
    Grid::AttachmentAccessor<Face, AUChar>      m_aaSelFACE;
    Grid::AttachmentAccessor<Volume, AUChar>    m_aaSelVOL;
 
    #ifdef UG_PARALLEL
      pcl::InterfaceCommunicator<VertexLayout>  m_icomVRT;
      pcl::InterfaceCommunicator<EdgeLayout>    m_icomEDGE;
      pcl::InterfaceCommunicator<FaceLayout>    m_icomFACE;
      pcl::InterfaceCommunicator<VolumeLayout>  m_icomVOL;
    #endif
};
 
 
}// end of namespace
 
//  include implementation
#include "selector_interface_impl.hpp"
 
#endif