AIFMesh.hpp

Go to the documentation of this file.

// Copyright (c) 2012-2019 University of Lyon and CNRS (France).
// All rights reserved.
//
// This file is part of MEPP2; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of
// the License, or (at your option) any later version.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#pragma once
 
#include <iostream>
#include <vector>
#include <set>
#include <limits>
#include <stdexcept>
#include <boost/range/iterator_range.hpp>
 
#include "FEVV/DataStructures/AIF/AIFFace.hpp"
#include "FEVV/DataStructures/AIF/AIFVertex.hpp"
#include "FEVV/DataStructures/AIF/AIFEdge.hpp"
 
#include "FEVV/DataStructures/AIF/AIFProperties.h"
#include "FEVV/DataStructures/AIF/AIFCellContainer.h"
 
#include "FEVV/Tools/Container/Helpers.hxx"
 
 
namespace FEVV {
namespace DataStructures {
namespace AIF {
 
class AIFMesh
{
public:
  typedef AIFMesh Self;
  typedef boost::shared_ptr< Self > ptr;
  typedef boost::shared_ptr< Self > ptr_mesh;
  typedef boost::shared_ptr< const Self > ptr_cmesh;
 
  typedef AIFVertex vertex_type;
  typedef AIFEdge edge_type;
  typedef AIFFace face_type;
 
  typedef AIFCellContainer< vertex_type::ptr > VertexContainerType;
  typedef AIFCellContainer< edge_type::ptr > EdgeContainerType;
  typedef AIFCellContainer< face_type::ptr > FaceContainerType;
 
  typedef AIFVertex::CoordinateType CoordinateType;
  typedef AIFPoint< CoordinateType, 3 > Point; // 3D point for geometry
  typedef std::array< CoordinateType, 2 >
      PointUV;                                   // 2D point for texture coords
  typedef AIFVector< CoordinateType, 3 > Vector; // 3D vector
 
  typedef AIFFace::NormalCoordinateType NormalCoordinateType;
  typedef AIFVector< NormalCoordinateType, 3 > Normal; // 3D vector
 
private:
  VertexContainerType m_Vertices;
  EdgeContainerType m_Edges;
  FaceContainerType m_Faces;
 
  PropertyMapContainer m_VertexPropertyMaps;
  PropertyMapContainer m_EdgePropertyMaps;
  PropertyMapContainer m_FacePropertyMaps;
  PropertyMapContainer m_AssocPropertyMaps;
 
public:
  AIFMesh(void);
 
  AIFMesh(const Self &);
 
  ~AIFMesh();
 
  Self &operator=(const Self &); 
public:
  static ptr_mesh New();
  boost::iterator_range< VertexContainerType::const_iterator >
  GetVertices() const
  {
    return boost::make_iterator_range(m_Vertices.cbegin(), m_Vertices.cend());
  }
  boost::iterator_range< VertexContainerType::iterator > GetVertices()
  {
    return boost::make_iterator_range(m_Vertices.begin(), m_Vertices.end());
  }
  inline VertexContainerType::iterator vertices_begin()
  {
    return m_Vertices.begin();
  }
  inline VertexContainerType::iterator vertices_end()
  {
    return m_Vertices.end();
  }
 
  boost::iterator_range< EdgeContainerType::const_iterator > GetEdges() const
  {
    return boost::make_iterator_range(m_Edges.cbegin(), m_Edges.cend());
  }
  boost::iterator_range< EdgeContainerType::iterator > GetEdges()
  {
    return boost::make_iterator_range(m_Edges.begin(), m_Edges.end());
  }
  boost::iterator_range< FaceContainerType::const_iterator > GetFaces() const
  {
    return boost::make_iterator_range(m_Faces.cbegin(), m_Faces.cend());
  }
  boost::iterator_range< FaceContainerType::iterator > GetFaces()
  {
    return boost::make_iterator_range(m_Faces.begin(), m_Faces.end());
  }
  unsigned int GetNumberOfVertices() const
  {
    return static_cast< unsigned int >(m_Vertices.size());
  }
  unsigned int GetNumberOfEdges() const
  {
    return static_cast< unsigned int >(m_Edges.size());
  }
  unsigned int GetNumberOfFaces() const
  {
    return static_cast< unsigned int >(m_Faces.size());
  }
 
  void InsertIsolatedVertex(vertex_type::ptr vertex) { m_Vertices.add(vertex); }
  void InsertIsolatedEdge(edge_type::ptr edge) { m_Edges.add(edge); }
  void InsertIsolatedFace(face_type::ptr face) { m_Faces.add(face); }
  template< typename T >
  void EraseIsolatedCell(AIFCellContainer< T > &container, const T &cell)
  {
    std::size_t idx = cell->GetIndex();
    if (idx != (std::numeric_limits<std::size_t>::max)()) 
    {
      // remove element from container
      std::size_t cLastId = 0; // init to 0 to remove C6001 Warning under VS2019
      if (container[idx]->GetIndex() == idx) // container[idx] should not overflow
        cLastId = container.remove(idx);
      else
      {
        std::cerr << "EraseIsolatedCell: Warning: cell index does not match container index. A linear search is thus done." << std::endl;
        auto it = container.begin(), it_e = container.end();
        for (std::size_t cpt=0; it != it_e; ++it,++cpt)
        {
          if ((*it)->GetIndex() == idx)
          {
            cLastId = container.remove(cpt);
            break;
          }
        }
      }
      // remove entry from property maps
      PropertyMapContainer *pmc = GetPropertyMapContainer<T>();
 
      pmc->removeProperties(idx, cLastId);
      cell->SetIndex((std::numeric_limits<std::size_t>::max)());
    }
  }
  void EraseIsolatedVertex(vertex_type::ptr vertex)
  {
    EraseIsolatedCell(m_Vertices, vertex);
  }
  void EraseIsolatedEdge(edge_type::ptr edge)
  {
    EraseIsolatedCell(m_Edges, edge);
  }
 
  void EraseIsolatedEdge(EdgeContainerType::iterator edge_iter)
  {
    m_Edges.erase(edge_iter);
  }
  void EraseIsolatedFace(face_type::ptr face)
  {
    EraseIsolatedCell(m_Faces, face);
  }
 
  void clear();
public:
  void Print() const;
 
  //---------------------------
  // Property maps management
  //---------------------------
 
  template< typename CellType >
  PropertyMapContainer *GetPropertyMapContainer(void);
 
  template< typename CellType >
  const PropertyMapContainer *GetPropertyMapContainer(void) const;
 
  template< typename CellType, typename T >
  PropertyMap< T > *AddPropertyMap(const std::string &mapName)
  {
    PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->addPropertyMap< T >(mapName);
  }
 
  template< typename CellType, typename T >
  PropertyMap< T > *GetPropertyMap(const std::string &mapName)
  {
    PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->getPropertyMap< T >(mapName);
  }
 
 
  template< typename CellType >
  bool isPropertyMap(const std::string &mapName) const
  {
    const PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->isPropertyMap(mapName);
  }
 
  template< typename CellType >
  bool isAPropertyMapStartingWithPrefix(const std::string &mapPrefixName) const
  {
    const PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->isAPropertyMapStartingWithPrefix(mapPrefixName);
  }
 
  template< typename CellType >
  std::vector< std::string > GetPropertyMapNamesStartingWithPrefix(const std::string &mapPrefixName) const
  {
    const PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->GetPropertyMapNamesStartingWithPrefix(mapPrefixName);
  }
 
  template< typename CellType >
  void RemovePropertyMap(const std::string &mapName)
  {
    PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    pmc->removePropertyMap(mapName);
  }
 
  template< typename CellType, typename T >
  void SetProperty(const std::string &mapName, std::size_t cellId, T value)
  {
    PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    pmc->setProperty< T >(mapName, cellId, value);
  }
 
  template< typename CellType, typename T >
  T &GetProperty(const std::string &mapName, std::size_t cellId)
  {
    PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->getProperty< T >(mapName, cellId);
  }
 
  template< typename CellType, typename T >
  const T &GetProperty(const std::string &mapName, std::size_t cellId) const
  {
    const PropertyMapContainer *pmc = GetPropertyMapContainer< CellType >();
    return pmc->getProperty< T >(mapName, cellId);
  }
 
  //---------------------------
  // Associative property maps management
  //---------------------------
 
  template< typename KeyType, typename ValueType >
  AssocPropertyMap< KeyType, ValueType > *
  AddAssocPropertyMap(const std::string &mapName)
  {
    return m_AssocPropertyMaps.addAssocPropertyMap< KeyType, ValueType >(
        mapName);
  }
 
  template< typename KeyType, typename ValueType >
  AssocPropertyMap< KeyType, ValueType > *
  GetAssocPropertyMap(const std::string &mapName)
  {
    return m_AssocPropertyMaps.getAssocPropertyMap< KeyType, ValueType >(
        mapName);
  }
 
  void RemoveAssocPropertyMap(const std::string &mapName)
  {
    m_AssocPropertyMaps.removePropertyMap(mapName);
  }
 
  bool isAssocPropertyMap(const std::string &mapName)
  {
    return m_AssocPropertyMaps.isPropertyMap(mapName);
  }
 
}; // END OF AIFMesh
 
template<>
PropertyMapContainer *
AIFMesh::GetPropertyMapContainer< AIFVertex::ptr >(void);
template<>
PropertyMapContainer *
AIFMesh::GetPropertyMapContainer< AIFEdge::ptr >(void);
template<>
PropertyMapContainer *
AIFMesh::GetPropertyMapContainer< AIFFace::ptr >(void);
template<>
const PropertyMapContainer *
AIFMesh::GetPropertyMapContainer< AIFVertex::ptr >(void) const;
template<>
const PropertyMapContainer *
AIFMesh::GetPropertyMapContainer< AIFEdge::ptr >(void) const;
template<>
const PropertyMapContainer *
AIFMesh::GetPropertyMapContainer< AIFFace::ptr >(void) const;
 
} // namespace AIF
} // namespace DataStructures
} // namespace FEVV
 
 
#include "FEVV/DataStructures/AIF/AIFMesh.inl"