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

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#ifndef __mlVesselNode_H
#define __mlVesselNode_H

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

// graph classes 
#include "mlBaseGraphItem.h"
#include "mlVesselEdge.h"
#include "mlPropertiesMacros.h"

ML_START_NAMESPACE

class VESSELGRAPH_EXPORT VesselNode : public BaseGraphItem
{
friend class Graph;
friend class VesselEdge;
friend class LoadTreeData;

public:
#ifdef ML_DEPRECATED
  ML_DEPRECATED VesselNode(const VesselNode& other);
#endif

  ~VesselNode() { assert(_edges.empty()); }

#ifdef ML_DEPRECATED
  ML_DEPRECATED VesselNode& operator=(const VesselNode& other);
#endif
  
  void copyProperties(const VesselNode* other);

  bool operator==(const VesselNode& other) const;
  bool operator!=(const VesselNode& other) const { return !(*this==other); }



  bool isRoot() const;
  bool isEnd() const;
  bool isBranch() const;
  int  nodeType() const;

  size_t getEdgeNum() const { return _edges.size(); }
  VesselEdge* getDepEdge(size_t i) { return _edges[i]; }
  const VesselEdge* getDepEdge(size_t i) const { return _edges[i]; }
  // Get pointer to edge array
  std::vector<VesselEdge*>* edges() { return &_edges; }

  VesselNode* getDepNode(size_t i); 
  const VesselNode* getDepNode(size_t i)const; 
  bool isPred(size_t i) const { return _edges[i]->succNode()==this; }
  bool isSucc(size_t i) const { return _edges[i]->predNode()==this; }
  bool isCycle(size_t i)const { return _edges[i]->isCycle(); }

  bool closeCycle();
  VesselNode* getPredNode();
  const VesselNode* getPredNode() const;
  VesselEdge* getPredEdge();
  const VesselEdge* getPredEdge() const;


  STATIC_GRAPH_PROPERTY(Vector3, pos, Pos);

  void setVectorPos(const ImageVector& position) { setPos(Vector3(static_cast<MLdouble>(position.x), static_cast<MLdouble>(position.y), static_cast<MLdouble>(position.z))); }
  ImageVector getVectorPos() const { return ImageVector(static_cast<int>(getPos()[0]), static_cast<int>(getPos()[1]), static_cast<int>(getPos()[2]), 0, 0, 0); }

  double distance(Vector3 position) const { return (position-getPos()).length(); }

  void transform(const Matrix4& m);

  void convertToVoxel(Matrix4* mat);

  void convertToWorld(Matrix4* mat);



  virtual void addStateToTree(TreeNode* parent) const;

  ML_SET_ADDSTATE_VERSION(2);

  virtual void readStateFromTree(TreeNode* parent);  


  STATIC_GRAPH_PROPERTY(MLint, label, Label);
  STATIC_GRAPH_PROPERTY(MLdouble, minDistance, MinDistance);
  STATIC_GRAPH_PROPERTY(MLdouble, drainVolume, DrainVolume);
  STATIC_GRAPH_PROPERTY(MLdouble, maxPathLength, MaxPathLength);

  STATIC_GRAPH_PROPERTY(MLdouble, weight, Weight);

  STATIC_GRAPH_PROPERTY(MLint16, shortLabel, ShortLabel);

  STATIC_GRAPH_PROPERTY(MLuint32, enumLabel, EnumLabel);

  typedef MLdouble (VesselNode::*NodeGetFkt) (void) const;     
  typedef void     (VesselNode::*NodeSetFkt) (const MLdouble&);    


private:
  VesselNode(Graph& graph, MLint id, const Vector3& pos);
  
  void readOldGraphNodeStateFromTree(TreeNode* parent);
  void readOldVesselNodeStateFromTree(TreeNode* parent);



  void addEdge   (VesselEdge *edge);
  void removeEdge(VesselEdge *edge);

  std::vector<VesselEdge*> _edges; 

  ML_ABSTRACT_CLASS_HEADER(VesselNode)
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef VesselNode GraphNode;
#endif // ML_DEPRECATED

ML_END_NAMESPACE

#endif // __mlVesselNode_H