mlVesselNode.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_VESSEL_NODE_H
#define ML_VESSEL_NODE_H
 
 
 
#include "mlVesselGraphSystem.h"
#include "VesselGraphTypes.h"
#include "mlBaseGraphItem.h"
#include "mlVesselEdge.h"
#include "mlPropertiesMacros.h"
 
VESSELGRAPH_BEGIN_NAMESPACE
 
class VESSELGRAPH_EXPORT VesselNode : public BaseGraphItem
{
friend class Graph;
friend class VesselEdge;
friend class LoadTreeData;
 
public:
  ~VesselNode() override { assert(_edges.empty()); }
 
  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]; }
  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(const Vector3& position) const { return (position - getPos()).length(); }
 
  void transform(const Matrix4& m);
 
  void convertToVoxel(Matrix4* mat);
 
  void convertToWorld(Matrix4* mat);
 
  STATIC_GRAPH_PROPERTY(MLint, label, Label);
  STATIC_GRAPH_PROPERTY(MLdouble, minDistance, MinDistance);
  STATIC_GRAPH_PROPERTY(MLdouble, maxPathLength, MaxPathLength);
 
  STATIC_GRAPH_PROPERTY(MLdouble, weight, Weight);
 
  typedef MLdouble (VesselNode::*NodeGetFkt) () const;           
  typedef void   (VesselNode::*NodeSetFkt) (const MLdouble&);    
 
 
private:
  VesselNode(Graph& graph, MLint id, const Vector3& pos);
 
  void addEdge   (VesselEdge *edge);
  void removeEdge(VesselEdge *edge);
 
  std::vector<VesselEdge*> _edges;
 
  STATIC_GRAPH_PROPERTY(MLdouble, drainVolume, DrainVolume);
  STATIC_GRAPH_PROPERTY(MLint16, shortLabel, ShortLabel);
 
  STATIC_GRAPH_PROPERTY(MLuint32, enumLabel, EnumLabel);
 
public:
  void addStateToTree(TreeNode* parent) const override;
 
  ML_SET_ADDSTATE_VERSION(2);
 
  void readStateFromTree(TreeNode* parent) override;
 
private:
  void readOldGraphNodeStateFromTree(TreeNode* parent);
  void readOldVesselNodeStateFromTree(TreeNode* parent);
 
  ML_ABSTRACT_CLASS_HEADER(VesselNode)
};
 
 
VESSELGRAPH_END_NAMESPACE
 
#endif // __mlVesselNode_H