MeshSelectionT.hh

Go to the documentation of this file.

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
*                                                                            *
\*===========================================================================*/






//=============================================================================
//
//
//=============================================================================


#ifndef MESHSELECTION_HH
#define MESHSELECTION_HH


//== INCLUDES =================================================================

#include <OpenMesh/Core/Mesh/Handles.hh>
#include <vector>

//== FORWARDDECLARATIONS ======================================================

//== NAMESPACES ===============================================================

namespace MeshSelection {

//== DEFINITIONS ==============================================================


//===========================================================================
//===========================================================================

template< typename MeshT >
inline
void selectVertices(MeshT* _mesh, const std::vector< int >& _vertices);

template< typename MeshT >
inline
void selectElements(MeshT* _mesh, const std::vector< int >& _vertices, OpenMesh::VertexHandle /*_tag*/)
{
  selectVertices(_mesh, _vertices);
}


template< typename MeshT >
inline
void unselectVertices(MeshT* _mesh, const std::vector< int >& _vertices);

template< typename MeshT >
inline
void selectAllVertices(MeshT* _mesh);

template< typename MeshT >
inline
void clearVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
void invertVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
void selectBoundaryVertices(MeshT* _mesh);

template< typename MeshT >
inline
void shrinkVertexSelection(MeshT* _mesh) ;

template< typename MeshT >
inline
void growVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getVertexSelection(MeshT* _mesh, bool& _invert);

template< typename MeshT >
inline
void selectBoundaryVertices(MeshT* _mesh, const typename MeshT::VertexHandle& _vh);

template< typename MeshT >
inline
void convertVertexToEdgeSelection(MeshT* _mesh, const std::vector< int >& _vertices);

template< typename MeshT >
inline
void convertVertexToEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertVertexToHalfedgeSelection(MeshT* _mesh, const std::vector< int >& _vertices);

template< typename MeshT >
inline
void convertVertexToHalfedgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertVertexToFaceSelection(MeshT* _mesh, const std::vector< int >& _vertices);

template< typename MeshT >
inline
void convertVertexToFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertVertexSelectionToFeatureVertices(MeshT* _mesh);

template< typename MeshT >
inline
void convertFeatureVerticesToVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
void clearFeatureVertices(MeshT* _mesh);

//===========================================================================
//===========================================================================

template< typename MeshT >
inline
void setArea(MeshT* _mesh, const std::vector< int >& _vertices , unsigned int _type, bool _state);

template< typename MeshT >
inline
void setArea(MeshT* _mesh , unsigned int _type, bool _state);

template< typename MeshT >
inline
std::vector< int > getArea(MeshT* _mesh, unsigned int _type);

template< typename MeshT >
inline
std::vector< int > getArea(MeshT* _mesh, unsigned int _type , bool& _invert);

//===========================================================================
//===========================================================================

template< typename MeshT >
inline
void selectEdges(MeshT* _mesh, const std::vector< int >& _edges, const double _dihedral_angle_threshold = 0.0);


template< typename MeshT >
inline
void selectElements(MeshT* _mesh, const std::vector< int >& _edges, OpenMesh::EdgeHandle /*_tag*/)
{
  selectEdges(_mesh, _edges);
}

template< typename MeshT >
inline
void unselectEdges(MeshT* _mesh, const std::vector< int >& _edges);

template< typename MeshT >
inline
void selectAllEdges(MeshT* _mesh);

template< typename MeshT >
inline
void clearEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void invertEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void growEdgeSelection(MeshT* _mesh);

template< typename MeshT >
void selectBoundaryEdges(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getEdgeSelection(MeshT* _mesh, bool& _invert);

template< typename MeshT >
inline
void convertEdgeToVertexSelection(MeshT* _mesh, const std::vector< int >& _edges);

template< typename MeshT >
inline
void convertEdgeToVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertEdgeToFaceSelection(MeshT* _mesh, const std::vector< int >& _edges);

template< typename MeshT >
inline
void convertEdgeToFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertEdgeToHalfedgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertEdgeSelectionToFeatureEdges(MeshT* _mesh);

template< typename MeshT >
inline
void convertFeatureEdgesToEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void clearFeatureEdges(MeshT* _mesh);


//===========================================================================
//===========================================================================

template< typename MeshT >
inline
void selectHalfedges(MeshT* _mesh, const std::vector< int >& _halfedges);

template< typename MeshT >
inline
void selectElements(MeshT* _mesh, const std::vector< int >& _halfedges, OpenMesh::HalfedgeHandle /*_tag*/)
{
  selectHalfedges(_mesh, _halfedges);
}

template< typename MeshT >
inline
void unselectHalfedges(MeshT* _mesh, const std::vector< int >& _halfedges);

template< typename MeshT >
inline
void selectAllHalfedges(MeshT* _mesh);

template< typename MeshT >
inline
void clearHalfedgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void invertHalfedgeSelection(MeshT* _mesh);

template< typename MeshT >
void selectBoundaryHalfedges(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getHalfedgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertHalfedgeToVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertHalfedgeToEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertHalfedgeToFaceSelection(MeshT* _mesh);

//===========================================================================
//===========================================================================

template< typename MeshT >
inline
void selectFaces(MeshT* _mesh, const std::vector< int >& _faces );

template< typename MeshT >
inline
void selectElements(MeshT* _mesh, const std::vector< int >& _faces, OpenMesh::FaceHandle /*_tag*/)
{
  selectFaces(_mesh, _faces);
}

template< typename MeshT >
inline
void unselectFaces(MeshT* _mesh, const std::vector< int >& _faces );

template< typename MeshT >
inline
void selectAllFaces(MeshT* _mesh);

template< typename MeshT >
inline
void clearFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
void invertFaceSelection(MeshT* _mesh);

template< typename MeshT >
void selectBoundaryFaces(MeshT* _mesh);

template< typename MeshT >
inline
void shrinkFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
void growFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
std::vector< int > getFaceSelection(MeshT* _mesh, bool& _invert);

template< typename MeshT >
inline
void convertFaceToVertexSelection(MeshT* _mesh, const std::vector< int >& _faces);

template< typename MeshT >
inline
void convertFaceToVertexSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertFaceToEdgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertFaceToHalfedgeSelection(MeshT* _mesh);

template< typename MeshT >
inline
void convertFaceSelectionToFeatureFaces(MeshT* _mesh);

template< typename MeshT >
inline
void convertFeatureFacesToFaceSelection(MeshT* _mesh);

template< typename MeshT >
inline
void clearFeatureFaces(MeshT* _mesh);

//=============================================================================
} // MeshSelection Namespace
//=============================================================================
#if defined(INCLUDE_TEMPLATES) && !defined(MESHSELECTION_C)
#define MESHSELECTION_TEMPLATES
#include "MeshSelectionT_impl.hh"
#endif
//=============================================================================
#endif // MESHSELECTION_HH defined
//=============================================================================