mlGraph.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_GRAPH_H
#define ML_GRAPH_H
 
// Include dll-specific settings.
#include "mlVesselGraphSystem.h"
 
#include "VesselGraphTypes.h"
 
// ThirdParty/System includes
#include "VesselGraphDisableWarnings.h"
#include <boost/iterator/transform_iterator.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <map>
#include "VesselGraphRestoreWarnings.h"
 
// MLVesselGraph includes
#include "Properties/mlPropertyManager.h"
 
// Be sure that all your modules are part of the ml. So collisions
// with names in system files or other libraries are minimized.
VESSELGRAPH_BEGIN_NAMESPACE
 
// Forward-declarations
class GraphAction;
class VesselEdge;
class VesselNode;
 
 
class VESSELGRAPH_EXPORT Graph : public Base
{
 
friend class GraphAnalyser;
friend class SaveTreeData;
friend class LoadTreeData;
public:
 
  enum {node,edge};
 
  //----------------------------------------------------------
  //----------------------------------------------------------
  Graph();
 
  Graph( const Graph& g, bool reorder=false );
 
  Graph( const Graph& g, const VesselNode* root, bool reorder=false );
 
  Graph( const Graph& g, const std::vector<const VesselNode*> &roots, bool reorder=false );
 
  Graph( Graph& g, int clusterId, bool reorder=false);
 
#ifdef VESSELGRAPH_USE_MPIF
    Graph* deepCopy() const          { return new Graph(*this); };
#else
    Graph* deepCopy() const override { return new Graph(*this); };
#endif
 
  ~Graph() override;
 
  //---------------------------------------------------------
  //---------------------------------------------------------
 
  VesselEdge* createEdge(VesselNode* predNode, VesselNode* succNode, MLint useId=-1);
  VesselEdge* createEdge(MLint predNodeId, MLint succNodeId, MLint useId=-1);
 
  VesselNode* createNode(const Vector3& pos=Vector3(0), MLint useId=-1);
  VesselNode* createNode(const ImageVector& pos, MLint useId=-1) { return this->createNode(Vector3(static_cast<MLdouble>(pos.x), static_cast<MLdouble>(pos.y), static_cast<MLdouble>(pos.z)), useId); };
 
  void insertRoot(VesselNode* node);
 
 
 
  //---------------------------------------------------------
  //---------------------------------------------------------
 
  void addGraph(const Graph& g) {
    std::map<const VesselNode*, VesselNode*> nodeMapping;
    std::map<const VesselEdge*, VesselEdge*> edgeMapping;
    std::map<const VesselNode*, VesselNode*> rootMapping;
    this->addGraph(g, nodeMapping, edgeMapping, rootMapping);
  }
 
  void addGraph(const Graph& g, std::map<const VesselNode*, VesselNode*>& nodeMapping, std::map<const VesselEdge*, VesselEdge*>& edgeMapping, std::map<const VesselNode*, VesselNode*>& rootMapping);
 
  void addSubtrees(const std::vector<const VesselNode*>& roots);
 
  void copyParts(const std::vector<const VesselNode*>& nodes, const std::vector<const VesselEdge*>& edges, const std::vector<const VesselNode*>& roots) {
    std::map<const VesselNode*, VesselNode*> nodeMapping;
    std::map<const VesselEdge*, VesselEdge*> edgeMapping;
    std::map<const VesselNode*, VesselNode*> rootMapping;
    this->copyParts(nodes, edges, roots, nodeMapping, edgeMapping, rootMapping);
  }
 
  void copyParts(const std::vector<const VesselNode*>& nodes, const std::vector<const VesselEdge*>& edges, const std::vector<const VesselNode*>& roots, std::map<const VesselNode*, VesselNode*>& nodeMapping, std::map<const VesselEdge*, VesselEdge*>& edgeMapping, std::map<const VesselNode*, VesselNode*>& rootMapping);
 
 
  //--------------------------------------------------------
  //--------------------------------------------------------
  bool removeEdge(VesselEdge* edge, bool removeEmptyNodes=true);
  bool removeNode(VesselNode* node);
  void removeRoot(VesselNode* r);
  void clearRoots();
  void clearGraph();
 
 
  typedef std::map<MLint, VesselNode*> NodeMap;
  typedef boost::function< VesselNode* (const NodeMap::value_type &) > NodeAccess;
  typedef boost::function< const VesselNode* (const NodeMap::value_type &) > ConstNodeAccess;
  typedef boost::transform_iterator<NodeAccess, NodeMap::iterator> NodeIterator;
  typedef boost::transform_iterator<ConstNodeAccess, NodeMap::const_iterator> ConstNodeIterator;
 
  typedef std::map<MLint, VesselEdge*> EdgeMap;
  typedef boost::function< VesselEdge* (const EdgeMap::value_type &) > EdgeAccess;
  typedef boost::function< const VesselEdge* (const EdgeMap::value_type &) > ConstEdgeAccess;
  typedef boost::transform_iterator<EdgeAccess, EdgeMap::iterator> EdgeIterator;
  typedef boost::transform_iterator<ConstEdgeAccess, EdgeMap::const_iterator> ConstEdgeIterator;
 
  //---------------------------------------------------------
  //--------------------------------------------------------
 
  NodeIterator beginNode() { return boost::make_transform_iterator( _nodes.begin(), &getSecond< VesselNode*, NodeMap::value_type > ); }
  NodeIterator endNode  () { return boost::make_transform_iterator( _nodes.end(), &getSecond< VesselNode*, NodeMap::value_type > ); }
 
  ConstNodeIterator beginNode() const { return boost::make_transform_iterator( _nodes.begin(), &getSecond< const VesselNode*, NodeMap::value_type > ); }
  ConstNodeIterator endNode  () const { return boost::make_transform_iterator( _nodes.end(), &getSecond< const VesselNode*, NodeMap::value_type > ); }
 
  EdgeIterator beginEdge() { return boost::make_transform_iterator( _edges.begin(), &getSecond< VesselEdge*, EdgeMap::value_type > ); }
  EdgeIterator endEdge  () { return boost::make_transform_iterator( _edges.end(), &getSecond< VesselEdge*, EdgeMap::value_type > ); }
 
  ConstEdgeIterator beginEdge() const { return boost::make_transform_iterator( _edges.begin(), &getSecond< const VesselEdge*, EdgeMap::value_type > ); }
  ConstEdgeIterator endEdge  () const { return boost::make_transform_iterator( _edges.end(), &getSecond< const VesselEdge*, EdgeMap::value_type > ); }
 
  NodeIterator beginRoot() { return boost::make_transform_iterator( _roots.begin(), &getSecond< VesselNode*, NodeMap::value_type > ); }
  NodeIterator endRoot  () { return boost::make_transform_iterator( _roots.end(), &getSecond< VesselNode*, NodeMap::value_type > ); }
 
  ConstNodeIterator beginRoot() const { return boost::make_transform_iterator( _roots.begin(), &getSecond< const VesselNode*, NodeMap::value_type > ); }
  ConstNodeIterator endRoot  () const { return boost::make_transform_iterator( _roots.end(), &getSecond< const VesselNode*, NodeMap::value_type > ); }
 
  size_t numNodes() const {return _nodes.size();};
  size_t numEdges() const {return _edges.size();};
  size_t numRoots() const {return _roots.size();};
 
  const VesselNode* getIdNode(MLint id) const;
  VesselNode* getIdNode(MLint id);
  const VesselEdge* getIdEdge(MLint id) const;
  VesselEdge* getIdEdge(MLint id);
 
  const VesselNode* getNode(Vector3 pos) const;
  VesselNode* getNode(Vector3 pos);
  const VesselEdge* getEdge(Vector3 pos) const;
  VesselEdge* getEdge(Vector3 pos);
  const VesselNode* getRoot(Vector3 pos) const;
  VesselNode* getRoot(Vector3 pos);
 
  const VesselNode* getNode(size_t index) const;
  VesselNode* getNode(size_t index);
 
  const VesselEdge* getEdge(size_t index) const;
  VesselEdge* getEdge(size_t index);
 
  const VesselNode* getRoot(size_t index) const;
  VesselNode* getRoot(size_t index);
 
  size_t getIndex(const VesselNode* node) const;
  size_t getIndex(const VesselEdge* edge) const;
 
 
  PropertyManager::Pointer getNodePropertyManager() { return _nodePropertyManager; }
  PropertyManager::ConstPointer getNodePropertyManager() const { return _nodePropertyManager; }
 
  PropertyManager::Pointer getEdgePropertyManager() { return _edgePropertyManager; }
  PropertyManager::ConstPointer getEdgePropertyManager() const { return _edgePropertyManager; }
 
  PropertyManager::Pointer getSkeletonPropertyManager() { return _skeletonPropertyManager; }
  PropertyManager::ConstPointer getSkeletonPropertyManager() const { return _skeletonPropertyManager; }
 
  //---------------------------------------------------------
  //---------------------------------------------------------
  void transform(const Matrix4& m);
 
  void setToWorldMatrix(const Matrix4 *m);
  void setToWorldMatrix(const Matrix4 &m);
  const Matrix4 *getToWorldMatrix() const;
  void getToWorldMatrix(float *mat) const;
  Matrix4 getToVoxelMatrix() const;
 
  void setToWorld(void)  {_isWorld=true;}
  void setToVoxel(void)  {_isWorld=false;}
  bool isWorld()         const {return _isWorld;}
  void worldVoxelConvert();
  void convertToVoxel(void);
  void convertToWorld(void);
 
  void    setImgExt(ImageVector v)  {_imgExt = v;}
  ImageVector  getImgExt()      const {return _imgExt;}
  MLint     extX()           const {return _imgExt.x;}
  MLint     extY()           const {return _imgExt.y;}
  MLint     extZ()           const {return _imgExt.z;}
 
  void    setVoxelExt(Vector3 v) {_voxelExt = v;}
  Vector3    getVoxelExt()  const {return _voxelExt;}
 
  MLint  splitEdge (MLint edgeID, size_t skeletonIndex);
  bool   mergeEdges(VesselEdge* parent, VesselEdge* child);
 
  //--------------------------------------------------------
  //--------------------------------------------------------
  Graph &operator = (const  Graph& g);
  Graph *newGraph(bool unusedDeprecated=true) const;
 
  //---------------------------------------------------------
  //---------------------------------------------------------
  int separateGraph();
 
  bool directGraph(double FloodThresh);
 
  void stripCycles();
 
  //------------------------------------------------------
  //------------------------------------------------------
  SubImageBoxd getBoundingBox() const;
 
protected:
  template <typename ResultType, typename ParameterType>
  static ResultType getSecond(const ParameterType& p) { return p.second; }
 
  bool    _isWorld;
  Matrix4    _toWorldMatrix;
  ImageVector  _imgExt;
  Vector3  _voxelExt;
 
  std::map<MLint, VesselNode*> _nodes;
  std::map<MLint, VesselEdge*> _edges;
  std::map<MLint, VesselNode*> _roots;
 
private:
  PropertyManager::Pointer _nodePropertyManager;
  PropertyManager::Pointer _edgePropertyManager;
  PropertyManager::Pointer _skeletonPropertyManager;
 
  MLint nextNodeId() { return _nodes.empty() ? 1 : _nodes.rbegin()->first + 1; };
  MLint nextEdgeId() { return _edges.empty() ? 1 : _edges.rbegin()->first + 1; };
  MLint nextRootId() { return _roots.empty() ? 1 : _roots.rbegin()->first + 1; };
 
  void reorderItems();
 
public:
 
  enum ActionType{
     NoAction =0, // Not changed.
     LabelGraph,  // Skeleton label values changed.
     EditGraph,   // Skeleton label colors changed.
     ModifyRoots, // Roots modified: graph is redirected
     ModifyNodesEdges, // Remove/Insert edges, insert nodes
     NewGraph,         // Everything new
     NumActionTypes    //
  };
 
  int getNumCluster() const { return _numCluster; }
 
  bool   getFlag()            const { return _bFlag;}
  void   setFlag(bool bFlag)  { _bFlag = bFlag;}
 
  void closeSkeletonGaps();
 
  void clampToImage();
 
  //-------------------------------------------------------
  //-------------------------------------------------------
  void addStateToTree(TreeNode* parent) const override;
  ML_SET_ADDSTATE_VERSION(3);
  void readStateFromTree(TreeNode* parent) override;
 
  int getVersion( void ) { return _version; }
  void setCurrentVersion( void ) { _version = getAddStateVersion(); }
  void setVersion( int version ) { _version = version; }
 
#ifndef GRAPH_NO_BINARY_PERSISTENCE
  bool getUseBinaryPersistence() { return _useBinaryPersistence; }
  void useBinaryPersistence(bool use) { _useBinaryPersistence = use; }
  std::string toBinaryData() const;
  void fromBinaryData(const std::string &data);
#endif // GRAPH_NO_BINARY_PERSISTENCE
 
  void setRootIdToAllChildren();
 
  void purifyGraph();
  void removeOrphanNodes();
  //------------------------------------------------------
  //------------------------------------------------------
  void         setAction( ActionType action, std::string sender );
  ActionType   getActionValue(void) const;
  void         setActionValue( ActionType action );
  void         setActionCallBack( GraphAction *cbObj );
 
  //-----------------------------------------------------------
  static double getMinSkeletonLabel( void ) { return MIN_SKELETON_LABEL; }
  static double getMaxSkeletonLabel( void ) { return MAX_SKELETON_LABEL; }
 
protected:
  bool _bFlag;
 
  int _numCluster;
 
 
  //------------------------------------------------------
  //------------------------------------------------------
   ActionType   _action;
   GraphAction *_actionCBObject;
 
  void _setRootIdToChildren(int rootId, VesselNode* node, VesselEdge* predEdge);
 
  //-----------------------------------------------------------
  static double MIN_SKELETON_LABEL;
  static double MAX_SKELETON_LABEL;
 
  bool _isContainedInImageExtent(const Vector3& pos, const Matrix4& toVoxelMatrix);
 
private:
  int _version;
#ifndef GRAPH_NO_BINARY_PERSISTENCE
  bool _useBinaryPersistence;
#endif // GRAPH_NO_BINARY_PERSISTENCE
 
  ML_CLASS_HEADER(Graph);
};
 
VESSELGRAPH_END_NAMESPACE
 
 
#endif