albaPolylineGraph.h

Go to the documentation of this file.

/*=========================================================================
Program:   Multimod Application Framework
Module:    $RCSfile: albaPolylineGraph.h,v $
Language:  C++
Date:      $Date: 2012-04-06 07:54:31 $
Version:   $Revision: 1.1.2.1 $
Authors:   Nigel McFarlane
==========================================================================
Copyright (c) 2001/2005 
CINECA - Interuniversity Consortium (www.cineca.it)
=========================================================================
Modified by Josef Kohout to strip off ALBA stuff from it making it possible
to use in VTK filters (=> wxString was replaced by char*)*/
#ifndef __albaPolylineGraph_h
#define __albaPolylineGraph_h
 
//----------------------------------------------------------------------------
// Include:
//----------------------------------------------------------------------------
#include "albaDefines.h"
#include "vtkPolydata.h"
#include <ostream>
#include <vector>
 
 
//----------------------------------------------------------------------------
// forward declarations :
//----------------------------------------------------------------------------
 
 
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
class ALBA_EXPORT albaPolylineGraph
{
public:  
  const static vtkIdType m_UndefinedId;
  const static int m_UndefinedInt;
  const static char* m_UndefinedName;
 
public:
  //-----------------------------------------------------------------------------
  // public methods
  //-----------------------------------------------------------------------------
  albaPolylineGraph() ;                       
  ~albaPolylineGraph() ;                      
  int GetNumberOfVertices() const ;          
  int GetNumberOfEdges() const ;             
  int GetNumberOfBranches() const ;          
  vtkIdType GetMaxVertexId() const ;         
  vtkIdType GetMaxEdgeId() const ;           
  vtkIdType GetMaxBranchId() const ;         
 
  void GetVertexCoords(vtkIdType v, double *coords) const ;      
  void SetVertexCoords(vtkIdType v, const double *coords) ;      
 
  const char* GetBranchName(vtkIdType b) const ;      
  void SetBranchName(vtkIdType b, const char* name) ; 
  void UnsetBranchName(vtkIdType b) ;                 
  vtkIdType FindBranchName(const char* name) const ;  
 
  double GetBranchLength(vtkIdType b) const;              
  double GetBranchIntervalLength(vtkIdType b, vtkIdType startVertexId, vtkIdType endVertexId) const;
 
  bool IsEdgeDirected(vtkIdType e) const ;                
  void SetEdgeDirected(vtkIdType e, bool directed) ;      
  void ReverseEdge(vtkIdType e) ;                         
 
  double GetEdgeWeight(vtkIdType e) const ;               
  void SetEdgeWeight(vtkIdType e, double wt) ;            
 
  bool AddNewEdge(vtkIdType v0, vtkIdType v1) ;           
 
  void AddNewVertex(double *coords = NULL) ;                
  bool AddNewVertex(vtkIdType v0, double *coords = NULL) ;  
 
  void AddNewBranch(const char* name = NULL) ;               
  bool AddNewBranch(vtkIdType v0, const char* name = NULL) ; 
 
  bool CopyFromPolydata(vtkPolyData *polydata) ;
 
  bool CopyToPolydata(vtkPolyData *polydata) ;
 
  /* Get location of edge in output polydata.
  Returns the cellid and the index on the cell.
  The mapping is set by CopyToPolydata(). */
  void GetOutputCellCorrespondingToEdge(vtkIdType edgeid, vtkIdType *cellid, vtkIdType *index) const ;
 
  /* Get edge id in graph which corresponds to (cellid,index) in the output data
  The mapping is set by CopyToPolydata(). */
  vtkIdType GetEdgeCorrespondingToOutputCell(vtkIdType cellid, vtkIdType index) const ;
 
  /* Get location of branch in output polydata.
  The mapping is set by CopyToPolydata(). */
  void GetOutputCellCorrespondingToBranch(vtkIdType branchid, vtkIdType *cellid) const ;
 
  /* Get branch id in graph corresponding to cell in output polydata.
  The mapping is set by CopyToPolydata().
  NB this returns -1 if the cell does not map to a branch. */
  vtkIdType GetBranchCorrespondingToOutputCell(vtkIdType cellid) const ;
 
  bool SplitBranchAtEdge(vtkIdType b, vtkIdType e) ;
 
  bool SplitBranchAtVertex(vtkIdType b, vtkIdType v) ;
 
  void AddNewVertexToBranch(vtkIdType b, double *coords = NULL) ;
 
  bool AddExistingVertexToBranch(vtkIdType b, vtkIdType v, vtkIdType e = m_UndefinedId) ;
 
  bool AddExistingEdgeToBranch(vtkIdType b, vtkIdType e) ;
 
  void ReverseBranch(vtkIdType b) ;
 
  bool DeleteEdge(vtkIdType i) ;
 
  bool DeleteVertex(vtkIdType i) ;
 
  bool DeleteBranch(vtkIdType i) ;
 
#pragma region BES April 2008
  bool MergeBranches(vtkIdType b1, vtkIdType b2);
 
  bool MergeSimpleJoinedBranchesAtVertex(vtkIdType v);
 
  void MergeSimpleJoinedBranches();
#pragma endregion
 
  bool IsConnected() const ;                                
  bool IsConnectedTree() const ;                            
  void Clear() ;                                            
  bool SelfCheck() const ;                                  
  void PrintSelf(std::ostream& os, const int tabs) const ;  
 
protected:
  //void LogMessageF(const char* format, ...);
 
  //virtual void LogMessage(const char* szMessage) {
  //  //default implementation is to do nothing
  //}
public:
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ALBA_EXPORT Vertex{
  public:
    Vertex() ;                   
    Vertex(double *coords) ;     
    ~Vertex() ;                  
    int GetDegree() const ;                 
    vtkIdType GetEdgeId(int i) const ;      
    void SetEdgeId(int i, vtkIdType e) ;    
    void AddEdgeId(vtkIdType e) ;           
    int FindEdgeId(vtkIdType e) const ;     
    bool DeleteEdgeId(vtkIdType e) ;        
    vtkIdType GetVertexId(int i) const ;    
    void SetVertexId(int i, vtkIdType v) ;  
    void AddVertexId(vtkIdType v) ;         
    int FindVertexId(vtkIdType v) const ;   
    bool DeleteVertexId(vtkIdType v) ;      
    void GetVerticesIdList(vtkIdList *idlist) const ;         
    void GetCoords(double *coords) const ;                    
    void SetCoords(const double *coords) ;                    
    void Clear() ;                                            
    bool SelfCheck() const ;                                  
    void PrintSelf(std::ostream& os, const int tabs) const ;  
  private:
    double m_Coords[3] ;                    
    std::vector<vtkIdType> m_EdgeId ;         
    std::vector<vtkIdType> m_VertexId ;       
  } ;
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ALBA_EXPORT Edge{
  public:
    Edge() ;                                     
    Edge(vtkIdType v0, vtkIdType v1) ;           
    Edge(const Edge& e) ;                        
    ~Edge() ;                                    
    Edge& operator=(const Edge& e) ;             
    vtkIdType GetVertexId(int i) const ;                    
    void SetVertexId(int i, vtkIdType v) ;                  
    void SetVertexIds(vtkIdType v0, vtkIdType v1) ;         
    void GetVerticesIdList(vtkIdList *idlist) const ;       
    vtkIdType GetOtherEndVertexId(vtkIdType v) const ;      
    vtkIdType GetBranchId() const ;                         
    void SetBranchId(vtkIdType b) ;                         
    bool IsVertexPair(vtkIdType v0, vtkIdType v1) const  ;        
    bool IsVertexPairOrdered(vtkIdType v0, vtkIdType v1) const ;  
    void SetDirected(bool directed) ;                             
    bool IsDirected() const ;                                     
    void ReverseDirection() ;                               
    double GetWeight() const ;                                                    
    void SetWeight(double w) ;                                                    
    void GetMappingToOutputPolydata(vtkIdType *cellid, vtkIdType *index) const ;  
    void SetMappingToOutputPolydata(vtkIdType cellid, vtkIdType index) ;          
    bool SelfCheck() const ;                                                      
    void PrintSelf(std::ostream& os, const int tabs) const ;                      
  private:
    vtkIdType m_VertexId[2] ;                                 
    bool m_Directed ;                                         
    double m_Weight ;                                         
    vtkIdType m_BranchId ;                                      
 
    vtkIdType m_OutputPolydataCell ;      
    vtkIdType m_OutputPolydataCellIndex ; 
 
  } ;
 
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class ALBA_EXPORT Branch{
  public:
    Branch(const char* name = NULL) ;                                     
    explicit Branch(vtkIdType startvertex, const char* name = NULL) ; 
    Branch(const Branch& src);
    
    ~Branch() ;                                                           
    int GetNumberOfVertices() const ;                   
    int GetNumberOfEdges() const ;                      
    void GetName(char* name) const ;                    
    const char* GetName() const ;                       
    void SetName(const char *name) ;                   
    void UnsetName() ;                                  
    vtkIdType GetEdgeId(int i) const ;                  
    void SetEdgeId(int i, vtkIdType e) ;                
    void AddEdgeId(vtkIdType e) ;                       
    int FindEdgeId(vtkIdType e) const ;                 
    void InsertEdgeId(int i, vtkIdType e) ;             
    vtkIdType GetLastEdgeId() const ;                   
    vtkIdType GetVertexId(int i) const ;                
    void SetVertexId(int i, vtkIdType v) ;              
    void AddVertexId(vtkIdType v) ;                     
    int FindVertexId(vtkIdType v) const ;               
    void InsertVertexId(int i, vtkIdType v) ;           
    vtkIdType GetLastVertexId() const ;                 
    void DeleteLastVertex() ;                           
    void GetVerticesIdList(vtkIdList *idlist) const ;   
    void ReverseDirection() ;                           
    vtkIdType GetMappingToOutputPolydata() const ;          
    void SetMappingToOutputPolydata(vtkIdType cellid) ;     
    void Clear() ;                                          
    bool SelfCheck() const ;                                  
    void PrintSelf(std::ostream& os, const int tabs) const ;  
 
    Branch& operator=(const Branch& src);
  private:
    //char* m_Name ;                                        ///< name of branch
    wxString m_Name;
    std::vector<vtkIdType> m_VertexId ;                   
    std::vector<vtkIdType> m_EdgeId ;                     
 
    vtkIdType m_OutputPolydataCell ;                    
 
  } ;
 
  //-----------------------------------------------------------------------------
  // Public functions which return const pointers to vertices, edges and branches.
  // These allow read-only access to const methods of the nested classes
  //-----------------------------------------------------------------------------
  const Vertex* GetConstVertexPtr(vtkIdType i) const ;   
  const Edge* GetConstEdgePtr(vtkIdType i) const ;       
  const Branch* GetConstBranchPtr(vtkIdType i) const ;   
 
private:
  //-----------------------------------------------------------------------------
  // private methods
  //-----------------------------------------------------------------------------
  void AllocateVertices(int nv) ;             
  void AllocateEdges(int ne) ;                
  void AllocateBranches(int ne) ;             
 
  bool SwapVertexIndices(vtkIdType i, vtkIdType j) ;  
  bool SwapEdgeIndices(vtkIdType i, vtkIdType j) ;    
  bool SwapBranchIndices(vtkIdType i, vtkIdType j) ;  
 
  bool DeleteLastEdge() ;
 
  bool DeleteLastVertex() ;
 
  bool DeleteLastBranch() ;
 
 
  //-----------------------------------------------------------------------------
  // Private functions which return non-const pointers to vertices, edges and branches
  // These give full read and write access to the nested classes,
  // and can only be used by methods of albaPolylineGraph.
  //-----------------------------------------------------------------------------
  Vertex* GetVertexPtr(vtkIdType i) ;         
  Edge* GetEdgePtr(vtkIdType i)  ;            
  Branch* GetBranchPtr(vtkIdType i)  ;        
 
  //-----------------------------------------------------------------------------
  // member variables
  //-----------------------------------------------------------------------------
  std::vector<Vertex> m_Vertex ;                
  std::vector<Edge> m_Edge ;                    
  std::vector<Branch> m_Branch ;                
} ;
 
#endif