MeVisLab/Standard/Sources/ML/MLVesselGraph/mlGraph.h

Go to the documentation of this file.

// **InsertLicense** code
#ifndef __mlGraph_H
#define __mlGraph_H

// Include dll-specific settings.
#include "mlVesselGraphSystem.h"

// ThirdParty/System includes
#include "mlSystemWarningsDisable.h"
#include <boost/iterator/transform_iterator.hpp>
#include <boost/shared_ptr.hpp>
#include <map>
#include "mlSystemWarningsRestore.h"

// ML includes
#include "mlBase.h"
#include "mlImageVector.h"
#include "mlSubImageBoxd.h"
#include "mlVector3.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.
ML_START_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};

  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    //
  };

  //----------------------------------------------------------

  //----------------------------------------------------------
  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);

  virtual Graph* deepCopy() const { return new Graph(*this); };
  
  virtual ~Graph();

  //------------------------------------------------------

  //------------------------------------------------------
  static bool hasVesselVoxels;

  //---------------------------------------------------------

  //---------------------------------------------------------

  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(pos.x, pos.y, 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;}
  int     extX()           const {return _imgExt.x;}
  int     extY()           const {return _imgExt.y;}
  int     extZ()           const {return _imgExt.z;}

  void    setVoxelExt(Vector3 v) {_voxelExt = v;}
  Vector3    getVoxelExt()  const {return _voxelExt;}

  int getNumCluster() const { return _numCluster; }

  bool   getFlag()            const { return _bFlag;}
  void   setFlag(bool bFlag)  { _bFlag = bFlag;}

  void closeSkeletonGaps();

  MLint  splitEdge (MLint edgeID, size_t skeletonIndex);
  bool   mergeEdges(VesselEdge* parent, VesselEdge* child);

  void clampToImage();
  
  //-------------------------------------------------------

  //-------------------------------------------------------
  virtual void addStateToTree(TreeNode* parent) const;
  ML_SET_ADDSTATE_VERSION(3);
  virtual void readStateFromTree(TreeNode* parent);

  int getVersion( void ) { return _version; }
  void setCurrentVersion( void ) { _version = getAddStateVersion(); }
  void setVersion( int version ) { _version = version; }

  //--------------------------------------------------------

  //--------------------------------------------------------
  Graph &operator = (const  Graph& g);
  //Allocate new graph with same properties as this (slowly).
  Graph *newGraph(bool bXml=true) const;
  //friend void copyVessels(Graph &copy,const Graph &source);

  //---------------------------------------------------------

  //---------------------------------------------------------
  int separateGraph();

  bool directGraph(float FloodThresh);

  void stripCycles();

  void setRootIdToAllChildren();
  
  void purifyGraph();

  //------------------------------------------------------

  //------------------------------------------------------
  SubImageBoxd getBoundingBox() const;

  //------------------------------------------------------

  //------------------------------------------------------
  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; }

#ifdef ML_DEPRECATED
  ML_DEPRECATED static Graph* skeletonGraphFromBase( Base* a_base );
#endif
  
protected:
  template <typename ResultType, typename ParameterType>
  static ResultType getSecond(const ParameterType& p) { return p.second; }

  bool _bFlag;

  bool    _isWorld;
  Matrix4    _toWorldMatrix;
  ImageVector  _imgExt;
  Vector3  _voxelExt;

  std::map<MLint, VesselNode*> _nodes;
  std::map<MLint, VesselEdge*> _edges;
  std::map<MLint, VesselNode*> _roots;

  int _numCluster;

private:
  int _version;

  PropertyManager::Pointer _nodePropertyManager;
  PropertyManager::Pointer _edgePropertyManager;
  PropertyManager::Pointer _skeletonPropertyManager;

  //------------------------------------------------------

  //------------------------------------------------------
   ActionType   _action;
   GraphAction *_actionCBObject;

  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 _setRootIdToChildren(int rootId, VesselNode* node, VesselEdge* predEdge);
  
  //-----------------------------------------------------------


  static double MIN_SKELETON_LABEL;
  static double MAX_SKELETON_LABEL;

  void reorderItems();

  bool _isContainedInImageExtent(const Vector3& pos, const Matrix4& toVoxelMatrix);

  ML_CLASS_HEADER(Graph);
};

ML_END_NAMESPACE


#endif