AIFVertex.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 <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
#include <limits>
#include <stdexcept>
#include <map>
#include <memory> // for unique_ptr
#include <array>
#include <boost/shared_ptr.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/property_map/property_map.hpp>
 
 
namespace FEVV {
namespace DataStructures {
namespace AIF {
 
class AIFEdge;
class AIFFace;
 
class AIFVertex
{
public:
  friend class AIFTopologyHelpers;
 
public:
  typedef AIFVertex self;
  typedef boost::shared_ptr< self > ptr;
  typedef boost::shared_ptr< self > ptr_vertex;
 
  typedef AIFEdge edge_type;
  typedef AIFFace face_type;
  typedef boost::shared_ptr< edge_type > ptr_edge;
  typedef boost::shared_ptr< face_type > ptr_face;
 
  typedef std::vector< ptr_vertex > VertexContainerType;
  typedef std::vector< ptr_edge > EdgeContainerType;
  typedef std::vector< ptr_face > FaceContainerType;
 
  typedef double CoordinateType;
  typedef face_type::NormalCoordinateType NormalCoordinateType;
 
private:
  std::size_t m_Index;
  EdgeContainerType m_Incident_PtrEdges;
 
  static const unsigned int m_d = 3;
 
private:
  FaceContainerType m_Incident_PtrFaces; // is managed via AIFTopologyHelpers
  bool m_Incident_PtrFaces_Computed; // is managed via AIFTopologyHelpers
  VertexContainerType m_One_Ring_Vertices; // is managed via AIFTopologyHelpers
  bool m_Is_One_Ring_Vertices_Computed; // is managed via AIFTopologyHelpers
 
private:
  AIFVertex()
      : m_Index(-1), m_Incident_PtrEdges(), m_Incident_PtrFaces(),
        m_Incident_PtrFaces_Computed(false), m_One_Ring_Vertices(),
        m_Is_One_Ring_Vertices_Computed(false)
  {
  }
 
  AIFVertex(const self &other)
      : m_Index(other.m_Index), // same index for the time being (this should be
                                // the case only in the Clone method)
        m_Incident_PtrEdges(),  // incidence relations are not copied for
                                // vertices
        m_Incident_PtrFaces(),  // incidence relations are not copied for
                                // vertices
        m_Incident_PtrFaces_Computed(false), m_One_Ring_Vertices(),
        m_Is_One_Ring_Vertices_Computed(false)
  {
  }
 
public:
  static ptr_vertex New();
  static ptr_vertex New(const self &other);
  std::size_t GetIndex() const { return m_Index; }
  void SetIndex(std::size_t idx) { m_Index = idx; }
  boost::iterator_range< EdgeContainerType::const_iterator > GetIncidentEdges()
  {
    return boost::make_iterator_range(m_Incident_PtrEdges.cbegin(),
                                      m_Incident_PtrEdges.cend());
  }
 
  unsigned int GetDegree()
  {
    return static_cast< unsigned int >(m_Incident_PtrEdges.size());
  }
 
  void Print() const;
 
  bool operator<(const self &other) const { return this < &other; }
  bool operator==(const self &other) const { return this == &other; }
  bool operator!=(const self &other) const { return !(*this == other); }
  bool operator<=(const self &other) const
  {
    return (*this < other) || (*this == other);
  }
  bool operator>=(const self &other) const { return !(*this < other); }
  bool operator>(const self &other) const { return (other < *this); }
};
 
} // namespace AIF
} // namespace DataStructures
} // namespace FEVV
 
 
#include "FEVV/DataStructures/AIF/AIFVertex.inl"