mlVesselEdge.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_EDGE_H
#define ML_VESSEL_EDGE_H
 
 
 
#include "mlVesselGraphSystem.h"
#include "VesselGraphTypes.h"
#include "mlGraph.h"
#include "mlBaseGraphItem.h"
#include "mlSkeleton.h"
#include "mlPropertiesMacros.h"
 
VESSELGRAPH_BEGIN_NAMESPACE
 
class VesselNode;
class Graph;
 
class VESSELGRAPH_EXPORT VesselEdge : public BaseGraphItem
{
friend class EdgeAnalyser;
friend class Graph;
friend class LoadTreeData;
 
public:
  VesselEdge(const VesselEdge &other);
  ~VesselEdge() override;
 
  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 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);
 
  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);
 
 
  Skeleton* createSkeleton(const Vector3& pos=Vector3(0), double minDistance = 0.0,
    double maxDistance = 0.0);
  Skeleton* createSkeleton(const ImageVector& pos, double minDistance = 0.0,
    double maxDistance = 0.0)
  {
    return createSkeleton(Vector3(static_cast<MLdouble>(pos.x),
                                  static_cast<MLdouble>(pos.y),
                                  static_cast<MLdouble>(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 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, double positionSmoothingFactor, double radiusSmoothingFactor, double smoothingLimit = 0.0f );
 
private:
  VesselEdge(Graph& graph, MLint id);
 
  VesselNode* _predNode;
  VesselNode* _succNode;
 
  bool _cycle;
 
  std::vector <Skeleton*> _skeletons;
 
public:
  void addStateToTree(TreeNode* parent) const override;
 
  ML_SET_ADDSTATE_VERSION(3);
 
  void readStateFromTree(TreeNode* parent) override;
 
  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 );
 
private:
  void readOldGraphEdgeStateFromTree(TreeNode* parent);
  void readOldVesselEdgeStateFromTree(TreeNode* parent);
 
  ML_ABSTRACT_CLASS_HEADER(VesselEdge)
};
 
VESSELGRAPH_END_NAMESPACE
 
#endif // __mlVesselEdge_H