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

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------
#ifndef __mlVesselEdge_H
#define __mlVesselEdge_H

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

// ml includes 
#include "mlLinearAlgebra.h"
#include "mlTreeNode.h"

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

ML_START_NAMESPACE

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

public:
  VesselEdge(const VesselEdge &other);
  ~VesselEdge();

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

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



  VesselNode* predNode() { return _predNode; }
  const VesselNode* predNode() const { return _predNode; }

  VesselNode* succNode() { return _succNode; }
  const VesselNode* succNode() const { return _succNode; }

  void setPred(VesselNode* node);

  void setSucc(VesselNode* node);

  bool isPred(const VesselNode* node) const { return _predNode==node; }
  bool isSucc(const VesselNode* node) const { return _succNode==node; }

  void switchDirection();

  //void refreshIds();

  void setCycle() { _cycle = true; }
  void unsetCycle() { _cycle = false; } 
  bool isCycle() const { return _cycle; }




  double distance(Vector3 vp) const { return getDistanceAndNearestSkeletonIndex(vp).first; };

  std::pair<MLdouble, size_t> getDistanceAndNearestSkeletonIndex(const Vector3& pos) const;

  Vector3 extent() const;

  SubImageBoxd getBoundingBox() const;

  void transform(const Matrix4& m);

  void convertToVoxel(Matrix4* mat);
  void convertToWorld(Matrix4* mat);



  virtual void addStateToTree(TreeNode* parent) const;

  ML_SET_ADDSTATE_VERSION(3);

  virtual void readStateFromTree(TreeNode* parent);  


  STATIC_GRAPH_PROPERTY(MLdouble, averageMinDistance, AverageMinDistance);
  STATIC_GRAPH_PROPERTY(MLdouble, length, Length);
  STATIC_GRAPH_PROPERTY(MLdouble, STLength, STLength);
  STATIC_GRAPH_PROPERTY(MLdouble, volume, Volume);
  STATIC_GRAPH_PROPERTY(MLdouble, STVolume, STVolume);
  STATIC_GRAPH_PROPERTY(Vector3, STBarycenter, STBarycenter);
  STATIC_GRAPH_PROPERTY(MLint, hierarchy, Hierarchy);
  STATIC_GRAPH_PROPERTY(MLint, label, Label);
  STATIC_GRAPH_PROPERTY(MLdouble, weight, Weight);

  typedef double (VesselEdge::*EdgeGetFkt) (void) const;     
  typedef void  (VesselEdge::*EdgeSetFkt) (double);          

  void setSTLabel(int nLabel);

  void setSTLabel(Graph *pGraph);

  bool markST( int a_label, float r, float g, float b, float a, Vector3 pos, int snap );
  bool markEdge( int a_label, float r, float g, float b, float a, Vector3 pos, int snap );



  Skeleton* createSkeleton(const Vector3& pos=Vector3(0), float minDistance = 0.0f, float maxDistance = 0.0f);
  Skeleton* createSkeleton(const ImageVector& pos, float minDistance = 0.0f, float maxDistance = 0.0f) { return createSkeleton(Vector3(pos.x, pos.y, pos.z), minDistance, maxDistance); }
  Skeleton* createSkeleton(const Skeleton* skeletonTemplate);

  void removeLeadingSkeletons(size_t count);
  void removeTrailingSkeletons(size_t count);
  void removeSkeleton(size_t index);

  size_t numSkeletons(void) const { return _skeletons.size(); }
  Skeleton* skeleton(size_t index) { return _skeletons.at(index); }
  const Skeleton* skeleton(size_t index) const { return _skeletons.at(index); }

  void skeletonsAscending(std::vector<Skeleton*> &skeletons);

  void skeletonsAscending(std::vector<const Skeleton*> &skeletons) const;

  void skeletonsDescending(std::vector<Skeleton*> &skeletons);

  void skeletonsDescending(std::vector<const Skeleton*> &skeletons) const;

  void orderSkeletonsAscending();

  void skeletonsAscending(std::vector<Skeleton>& skeletons) const;

  void skeletonsDescending(std::vector<Skeleton>& skeletons) const;

  bool skeletonsAreAscending() const;

  //void addSkeleton(const Skeleton &skel) { _skeletons.push_back(skel);}
  void clearSkeletons();
  Skeleton* frontSkeleton()              {return _skeletons.front();}
  Skeleton* backSkeleton()               {return _skeletons.back();}
  const Skeleton* frontSkeleton() const  {return _skeletons.front();}
  const Skeleton* backSkeleton() const   {return _skeletons.back();}

  Skeleton *skeleton(Vector3 pos,int itemType) { return const_cast<Skeleton*>(const_cast<const VesselEdge*>(this)->skeleton(pos, itemType)); }

  const Skeleton *skeleton(Vector3 pos,int itemType) const;

  size_t getVoxelNum() const;

  void smooth(unsigned int numSmoothingPasses, float positionSmoothingFactor, float radiusSmoothingFactor, float smoothingLimit = 0.0f );

private:
  VesselEdge(Graph& graph, MLint id);

  void readOldGraphEdgeStateFromTree(TreeNode* parent);
  void readOldVesselEdgeStateFromTree(TreeNode* parent);

  VesselNode* _predNode;
  VesselNode* _succNode;

  //long _succId;
  //long _predId;

  bool _cycle;

  std::vector <Skeleton*> _skeletons;

  ML_ABSTRACT_CLASS_HEADER(VesselEdge)
};

#ifdef ML_DEPRECATED




ML_DEPRECATED typedef VesselEdge GraphEdge;
#endif // ML_DEPRECATED

ML_END_NAMESPACE

#endif // __mlVesselEdge_H