mesh_atlas.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/geometry/conformal_mesh.hpp>
#include <kernel/geometry/mesh_part.hpp>
#include <kernel/geometry/atlas/chart.hpp>
 
// includes, system
#include <map>
#include <deque>
#include <memory>
 
namespace FEAT
{
  namespace Geometry
  {
    template<typename Mesh_>
    class MeshAtlas
    {
    public:
      typedef Mesh_ MeshType;
      typedef Atlas::ChartBase<MeshType> MeshChartType;
      typedef typename MeshType::VertexType VertexType;
 
    protected:
      typedef std::map<String, std::unique_ptr<MeshChartType>> MeshChartMap;
 
      MeshChartMap _chart_map;
 
    public:
      MeshAtlas()
      {
      }
 
      MeshAtlas(MeshAtlas&& other) = default;
 
      MeshAtlas& operator=(MeshAtlas&& other) = default;
 
      MeshAtlas(const MeshAtlas&) = delete;
 
      MeshAtlas& operator=(const MeshAtlas&) = delete;
 
      virtual ~MeshAtlas()
      {
        // map and unique_ptr take care of cleanup
      }
 
      static std::unique_ptr<MeshAtlas> make_unique()
      {
        return std::unique_ptr<MeshAtlas>(new MeshAtlas());
      }
 
      std::size_t bytes() const
      {
        std::size_t s(0);
        for(auto it = _chart_map.begin(); it != _chart_map.end(); ++it)
          s += it->second->bytes();
        return s;
      }
 
      bool add_mesh_chart(const String& name,  std::unique_ptr<MeshChartType> chart, bool replace = false)
      {
        // try to insert
        // note: unique_ptr needs to be moved here, otherwise emplace tries to copy instead
        auto it = _chart_map.emplace(name, std::move(chart));
 
        // insertion successful?
        if(it.second)
          return true;
 
        // a chart with that name already exists. replace?
        if(!replace)
          return false;
 
        // assign new chart
        it.first->second = std::move(chart);
        return true;
      }
 
      std::deque<String> get_chart_names() const
      {
        std::deque<String> names;
        for(auto it = _chart_map.begin(); it != _chart_map.end(); ++it)
        {
          names.push_back((*it).first);
        }
        return names;
      }
 
      const MeshChartMap& get_mesh_chart_map() const
      {
        return _chart_map;
      }
 
      MeshChartType* find_mesh_chart(const String& name)
      {
        auto it = _chart_map.find(name);
        if(it == _chart_map.end())
          return nullptr;
        return (*it).second.get();
      }
 
      const MeshChartType* find_mesh_chart(const String& name) const
      {
        auto it = _chart_map.find(name);
        if(it == _chart_map.end())
          return nullptr;
        return (*it).second.get();
      }
 
      void transform(const VertexType& origin, const VertexType& angles, const VertexType& offset)
      {
        // transform all charts
        for(auto it = _chart_map.begin(); it != _chart_map.end(); ++it)
          it->second->transform(origin, angles, offset);
      }
    }; // class MeshAltas<...>
  } // namespace Geometry
} // namespace FEAT