selection_util.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2015:  G-CSC, Goethe University FrankfurtG
 * 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__LIB_GRID__SELECTION_UTIL__
#define __H__LIB_GRID__SELECTION_UTIL__
 
#include <stack>
#include "lib_grid/lg_base.h"
#include "common/ug_config.h"
#include "lib_grid/tools/selector_multi_grid.h"
#include "lib_grid/callbacks/basic_callbacks.h"
 
namespace ug
{
 
//  selection util methods
 
//  CalculateCenter
 
template <class TAAPosVRT>
bool CalculateCenter(typename TAAPosVRT::ValueType& centerOut,
           Selector& sel, TAAPosVRT& aaPos);
 
 
template <class TAAPosVRT>
void TranslateSelection(Selector& sel, const typename TAAPosVRT::ValueType& offset,
            TAAPosVRT& aaPos);
 
 
//  CollectVerticesTouchingSelection
 
UG_API
size_t CollectVerticesTouchingSelection(std::vector<Vertex*>& vrtsOut,
                    ISelector& sel);
 
//  EraseSelectedObjects
 
template <class TSelector>
void EraseSelectedObjects(TSelector& sel);
 
 
//  InvertSelection
 
template <class TSelector, class TIterator>
void InvertSelection(TSelector& sel, TIterator begin, TIterator end);
 
//  InvertSelection
 
template <class TSelector>
void InvertSelection(TSelector& sel);
 
 
 
template <class TElem, class TIterator>
void
SelectAssociated(ISelector& sel, TIterator begin, TIterator end,
         ISelector::status_t status = ISelector::SELECTED);
 
//  SelectAssociatedVertices
 
template <class TSelector, class TElemIterator>
void SelectAssociatedVertices(TSelector& sel, TElemIterator elemsBegin,
                TElemIterator elemsEnd,
                ISelector::status_t status = ISelector::SELECTED);
                
//  SelectAssociatedEdges
 
template <class TSelector, class TElemIterator>
void SelectAssociatedEdges(TSelector& sel, TElemIterator elemsBegin,
               TElemIterator elemsEnd,
               ISelector::status_t status = ISelector::SELECTED);
 
//  SelectAssociatedFaces
 
template <class TSelector, class TElemIterator>
void SelectAssociatedFaces(TSelector& sel, TElemIterator elemsBegin,
               TElemIterator elemsEnd,
               ISelector::status_t status = ISelector::SELECTED);
 
//  SelectAssociatedVolumes
 
template <class TSelector, class TElemIterator>
void SelectAssociatedVolumes(TSelector& sel, TElemIterator elemsBegin,
               TElemIterator elemsEnd,
               ISelector::status_t status = ISelector::SELECTED);
 
 
//UG_API
//void SelectAssociatedGridObjects(Selector& sel,
//                ISelector::status_t status = ISelector::SELECTED);
 
template <class TSelector>
UG_API
void SelectAssociatedGridObjects(TSelector& sel,
                ISelector::status_t status = ISelector::SELECTED);
 
 
template <class TSelector>
UG_API
void CloseSelection (TSelector& sel);
 
 
 
template <class TElem, class TSelector>
void AssignSelectionStateToSides(TSelector& sel, bool recursive);
 
template <class TElemIterator>
void SelectBoundaryElements(ISelector& sel, TElemIterator elemsBegin,
             TElemIterator elemsEnd);
 
template <class TElemIterator>
void SelectInnerElements(ISelector& sel, TElemIterator elemsBegin,
             TElemIterator elemsEnd);
 
template <class TEdgeIterator>
void SelectCreaseEdges(ISelector& sel, TEdgeIterator edgesBegin, TEdgeIterator edgesEnd,
            number minAngle, APosition aVrtPos,
            bool ignoreBoundaryEdges = true,
            ISelector::status_t state = ISelector::SELECTED);
 
 
template <class TIter>
void SelectAreaBoundary(ISelector& sel, const TIter begin, const TIter end);
 
 
template <class TIter>
void SelectInterfaceElements(ISelector& sel, ISubsetHandler& sh,
               const TIter begin, const TIter end,
               bool regardSelectedNbrsOnly = false);
 
 
template <class TElem>
void SelectSubsetElements(ISelector& sel, ISubsetHandler& sh, int subsetIndex,
              ISelector::status_t status = ISelector::SELECTED);
 
 
template <class TSelector>
UG_API
void ExtendSelection(TSelector& sel, size_t extSize,
           ISelector::status_t status = ISelector::SELECTED);
 
 
 
template <class TSelector, class TAAPos>
UG_API
void ExtendSelectionInDirection(
        TSelector& sel,
        size_t extSize,
        const typename TAAPos::ValueType& dir,
        number minAngle,
        number maxAngle,
        const TAAPos& aaPos,
    ISelector::status_t status = ISelector::SELECTED);
 
 
 
template <class TGeomObj>
void SelectionFill(Selector& sel,
             typename Grid::traits<typename TGeomObj::side>::callback cbRegionBoundary);
 
 
template <class TGeomObj, class TAAPos>
bool SelectRegion(Selector& sel, const typename TAAPos::ValueType& p, TAAPos& aaPos,
            typename Grid::traits<typename TGeomObj::side>::callback cbRegionBoundary);
 
//  SelectAssociatedGenealogy
 
UG_API
void SelectAssociatedGenealogy(MGSelector& msel, bool selectAssociatedElements);
 
template <class TAAPos>
void SelectEdgesByDirection(
        Selector& sel,
        TAAPos& aaPos,
        const vector3& dir,
        number minDeviationAngle,
        number maxDeviationAngle,
        bool selectFlipped);
 
template <class TAAPos>
void SelectSubsetEdgesByDirection(
        Selector& sel,
        SubsetHandler& sh,
        int subsetIndex,
        TAAPos& aaPos,
        const vector3& dir,
        number minDeviationAngle,
        number maxDeviationAngle,
        bool selectFlipped);
 
 
//  SelectSmoothEdgePath
 
UG_API
void SelectSmoothEdgePath(Selector& sel, number thresholdDegree,
              number normalWeight,
              bool stopAtSelVrts = true,
              APosition& aPos = aPosition);
 
 
//  SelectShortPolychains
template <class TAAPos>
void SelectShortPolychains(ISelector& sel, number maxLength, bool closedChainsOnly,
               TAAPos aaPos);
 
//  SelectInnerSelectionVertices
 
template <class TSelector>
void SelectInnerSelectionVertices(TSelector& sel);
 
//  SelectInnerSelectionEdges
 
template <class TSelector>
void SelectInnerSelectionEdges(TSelector& sel);
 
//  SelectInnerSelectionFaces
 
template <class TSelector>
void SelectInnerSelectionFaces(TSelector& sel);
 
 
//  DeselectBoundarySelectionVertices
 
template <class TSelector>
void DeselectBoundarySelectionVertices(TSelector& sel);
 
//  DeselectBoundarySelectionEdges
 
template <class TSelector>
void DeselectBoundarySelectionEdges(TSelector& sel);
 
//  DeselectBoundarySelectionFaces
 
template <class TSelector>
void DeselectBoundarySelectionFaces(TSelector& sel);
 
 
//  SelectLinkedElements
 
template <class TElem>
void SelectLinkedElements(ISelector& sel,
      typename Grid::traits<TElem>::callback
          cbIsSelectable = ConsiderAll(),
      typename Grid::traits<typename TElem::side>::callback
          cbIsTraversable = ConsiderAll());
 
                 
//  SelectLinkedFlatFaces
 
UG_API
void SelectLinkedFlatFaces(Selector& sel, number maxDeviationAngle,
               bool ignoreOrientation = false,
               bool stopAtSelectedEdges = false,
               APosition& aPos = aPosition);
 
//  SelectLinkedFlatFaces
 
UG_API
void SelectLinkedFlatAndDegeneratedFaces(Selector& sel,
                     number maxDeviationAngle,
                     bool ignoreOrientation = false,
                     bool stopAtSelectedEdges = false,
                     number degThreshold = SMALL,
                             APosition& aPos = aPosition);
 
//  FaceArea
template <class TAAPosVRT>
UG_API
number FaceArea(ISelector& sel, TAAPosVRT& aaPos);
 
 
 
template <class elem_t>
void GetSelectedElementIndices (const ISelector& sel, std::vector<int>& indsOut);
 
void GetSelectedElementIndices (const ISelector& sel,
                                std::vector<size_t>& vrtIndsOut,
                                std::vector<size_t>& edgeIndsOut,
                                std::vector<size_t>& faceIndsOut,
                                std::vector<size_t>& volIndsOut);
 
template <class elem_t>
void SelectElementsByIndex (ISelector& sel, const std::vector<size_t>& inds);
 
void SelectElementsByIndex (ISelector& sel,
                            const std::vector<size_t>& vrtInds,
                            const std::vector<size_t>& edgeInds,
                            const std::vector<size_t>& faceInds,
                            const std::vector<size_t>& volInds);
 
void SelectSubset(ISelector& sel,
          const ISubsetHandler& sh,
          int si,
          ISelector::status_t status);
 
}// end of namespace
 
 
//  include implementation
#include "selection_util_impl.hpp"
 
#endif