MPTools.h

Go to the documentation of this file.

#ifndef MP_TOOLS_H_
#define MP_TOOLS_H_
 
#define CLEARANCE_UTILS_AVAILABLE 1
#define MED_AXIS_AVAILABLE 1
#define POINT_CONSTRUCTION_AVAILABLE 1
#define REACHABILITY_UTIL_AVAILABLE 1
#define SAFE_INTERVAL_TOOL_AVAILABLE 1
#define SKELETON_CLEARANCE_AVAILABLE 1
#define TOPOLOGICAL_MAP_AVAILABLE 1
#define TET_GEN_DECOMP_AVAILABLE 1
#define REEB_GRAPH_AVAILABLE 1
#define MEAN_CURVE_SKEL_AVAILABLE 1
#define WRENCH_ACCESS_TOOL_AVAILABLE 1
 
#include <string>
#include <unordered_map>
 
#include "Utilities/XMLNode.h"
 
#ifdef CLEARANCE_UTILS_AVAILABLE
    #include "ClearanceUtilities.h"
#endif
 
#ifdef MED_AXIS_AVAILABLE
    #include "MedialAxisUtilities.h"
#endif
 
#ifdef MEAN_CURVE_SKEL_AVAILABLE
    #include "MeanCurvatureSkeleton3D.h"
#endif
 
#ifdef REEB_GRAPH_AVAILABLE
    #include "ReebGraphConstruction.h"
#endif
 
#ifdef SAFE_INTERVAL_TOOL_AVAILABLE
    #include "SafeIntervalTool.h"
#endif
 
#ifdef SKELETON_CLEARANCE_AVAILABLE
    #include "SkeletonClearanceUtility.h"
#endif
 
#ifdef TET_GEN_DECOMP_AVAILABLE
    #include "TetGenDecomposition.h"
    class WorkspaceDecomposition;
#endif
 
#ifdef TOPOLOGICAL_MAP_AVAILABLE
    #include "TopologicalMap.h"
#endif
 
#ifdef REACHABILITY_UTIL_AVAILABLE
    #include "ReachabilityUtil.h"
#endif
 
#ifdef POINT_CONSTRUCTION_AVAILABLE
    #include "PointConstruction.h"
#endif
 
#ifdef WRENCH_ACCESS_TOOL_AVAILABLE
    #include "WrenchAccessibilityTool.h"
#endif
 
 
class MPLibrary;
 
 
class MPToolsType final {
 
 
 
 
 
  template <typename Utility>
  using LabelMap = std::unordered_map<std::string, Utility*>;
 
 
  MPLibrary* const m_library; 
 
  #ifdef CLEARANCE_UTILS_AVAILABLE
  LabelMap<ClearanceUtility>         m_clearanceUtils;
  #endif
 
  #ifdef MED_AXIS_AVAILABLE
  LabelMap<MedialAxisUtility>        m_medialAxisUtils;
  #endif
 
  #ifdef SKELETON_CLEARANCE_AVAILABLE
  LabelMap<SkeletonClearanceUtility> m_skeletonUtils;
  #endif
  
  #ifdef TOPOLOGICAL_MAP_AVAILABLE
  LabelMap<TopologicalMap>           m_topologicalMaps;
  #endif
  
  #ifdef SAFE_INTERVAL_TOOL_AVAILABLE
  LabelMap<SafeIntervalTool>         m_safeIntervalTools;
  #endif
 
  #ifdef REACHABILITY_UTIL_AVAILABLE
  LabelMap<ReachabilityUtil>         m_reachabilityUtils;
  #endif
  
  #ifdef POINT_CONSTRUCTION_AVAILABLE
  LabelMap<PointConstruction>        m_pointConstruction;
  #endif
 
  #ifdef WRENCH_ACCESS_TOOL_AVAILABLE
  LabelMap<WrenchAccessibilityTool>  m_wrenchAccessibilityTools;
  #endif
 
  #ifdef TET_GEN_DECOMP_AVAILABLE
  std::unordered_map<std::string, TetGenDecomposition> m_tetgens;
  std::unordered_map<std::string, const WorkspaceDecomposition*> m_decompositions;
  #endif
 
 
  public:
 
 
    MPToolsType(MPLibrary* const _library);
 
    void ParseXML(XMLNode& _node);
 
    void Initialize();
 
    void Uninitialize();
 
    ~MPToolsType();
 
 
    #ifdef CLEARANCE_UTILS_AVAILABLE
 
    ClearanceUtility* GetClearanceUtility(const std::string& _label)
        const;
 
    void SetClearanceUtility(const std::string& _label,
        ClearanceUtility* const _utility);
 
    #endif
    
    #ifdef MED_AXIS_AVAILABLE
 
    MedialAxisUtility* GetMedialAxisUtility(const std::string& _label)
        const;
 
    void SetMedialAxisUtility(const std::string& _label,
        MedialAxisUtility* const _utility);
 
    #endif
 
    #ifdef SKELETON_CLEARANCE_AVAILABLE
 
    SkeletonClearanceUtility* GetSkeletonClearanceUtility(
        const std::string& _label) const;
 
    void SetSkeletonClearanceUtility(const std::string& _label,
        SkeletonClearanceUtility* const _utility);
 
    #endif
 
    #ifdef TOPOLOGICAL_MAP_AVAILABLE
 
    TopologicalMap* GetTopologicalMap(const std::string& _label) const;
 
    void SetTopologicalMap(const std::string& _label,
        TopologicalMap* const _utility);
 
    #endif
 
    #ifdef SAFE_INTERVAL_TOOL_AVAILABLE
 
    SafeIntervalTool* GetSafeIntervalTool(const std::string& _label)
        const;
 
    void SetSafeIntervalTool(const std::string& _label,
        SafeIntervalTool* const _utility);
 
    #endif
 
    #ifdef TET_GEN_DECOMP_AVAILABLE
 
    const WorkspaceDecomposition* GetDecomposition(const std::string& _label);
 
    void SetDecomposition(const std::string& _label,
        const WorkspaceDecomposition* _decomposition);
 
    #endif
 
    #ifdef REACHABILITY_UTIL_AVAILABLE
 
    ReachabilityUtil* GetReachabilityUtil(const std::string& _label) const;
 
    void SetReachabilityUtil(const std::string& _label,
        ReachabilityUtil* _util);
 
    #endif
 
    #ifdef POINT_CONSTRUCTION_AVAILABLE
 
    PointConstruction* GetPointConstruction(const std::string& _label) const;
 
    void SetPointConstruction(const std::string& _label,
        PointConstruction* _util);
 
    #endif
 
    #ifdef WRENCH_ACCESS_TOOL_AVAILABLE
    WrenchAccessibilityTool* GetWrenchAccessibilityTool(const std::string& _label) const;
 
    void SetWrenchAccessibilityTool(const std::string& _label,
        WrenchAccessibilityTool* const _utility);
 
    #endif
 
  private:
 
 
    template <typename Utility>
    Utility* GetUtility(const std::string& _label,
        const LabelMap<Utility>& _map) const;
 
 
    template <typename Utility>
    void SetUtility(const std::string& _label, Utility* _utility,
        LabelMap<Utility>& _map) const;
 
 
};
 
/*---------------------------------- Helpers ---------------------------------*/
 
template <typename Utility>
inline
Utility*
MPToolsType::
GetUtility(const std::string& _label, const LabelMap<Utility>& _map) const {
  try {
    return _map.at(_label);
  }
  catch(const std::out_of_range&) {
    Utility dummy;
    throw RunTimeException(WHERE) << "Requested " << dummy.GetName()
                                  << " '" << _label  << "' does not exist.";
  }
  catch(const std::exception& _e) {
    Utility dummy;
    throw RunTimeException(WHERE) << "Error when fetching " << dummy.GetName()
                                  << " '" << _label << "': " << _e.what();
  }
  catch(...) {
    Utility dummy;
    throw RunTimeException(WHERE) << "Error when fetching " << dummy.GetName()
                                  << " '" << _label << "': (unknown).";
  }
}
 
 
template <typename Utility>
void
MPToolsType::
SetUtility(const std::string& _label, Utility* _utility,
    LabelMap<Utility>& _map) const {
  // Set the library pointer.
  _utility->SetMPLibrary(m_library);
 
  // Check if this label is already in use.
  auto iter = _map.find(_label);
  const bool alreadyExists = iter != _map.end();
 
  // If the label already exists, we need to release the previous utility first.
  if(alreadyExists) {
    delete iter->second;
    iter->second = _utility;
  }
  else
    _map.insert({_label, _utility});
}
 
#endif