title
Graph Drawing Toolkit

An object-oriented C++ library for handling and drawing graphs

rel_coord_orth.h

Go to the documentation of this file.
00001 
00003 #include <GDT/rm3_undi_graph.h>
00004 #include <GDT/gdt_error.h>
00005 
00006 #ifndef RM3_REL_COORD_ORTH_H
00007 #define RM3_REL_COORD_ORTH_H
00008 
00009 class _grid_line_struct {
00010 
00011   friend class rel_coord_orth;
00012 
00013  private:
00014   
00015   
00016  public:
00017 
00018   int                       _axis;
00019   double                    _coord;
00020   gdt::gdtlist<gdtnode>*    _node_list;  // sequence of nodes met on the grid line
00021   gdt::list_item            _position_into_list;  // grid position into list
00022     
00023   
00024   _grid_line_struct(){
00025     _grid_line_struct::_node_list = new gdt::gdtlist<gdtnode>;
00026     _grid_line_struct::_axis = 0;
00027     _grid_line_struct::_coord = 0;
00028   }
00029 
00030   _grid_line_struct(int axis, double coord) {
00031 
00032     _grid_line_struct::_node_list = new gdt::gdtlist<gdtnode>;
00033     _grid_line_struct::_axis = axis;
00034     _grid_line_struct::_coord = coord;
00035   }
00036 
00037   ~_grid_line_struct(){ delete _node_list; }
00038   
00039   int get_axis() const { return _axis; }
00040   double coord() const { return _coord; }
00041   
00042   void set_axis(int axis) { _axis = axis; }  // 0 = horizontal; 1 = vertical
00043   void set_coord(double c) { _coord = c; }
00044 };
00045 
00046 
00047 typedef _grid_line_struct* grid_line;    
00048 
00049 
00050 class rel_coord_orth {
00051 
00052   private:
00053 
00054   undi_graph ulug;    // underlying undi_graph
00055 
00056   gdt::gdtlist<grid_line>  _grid_line_list[2];           // list of vertical (1) and horizontal (0) grid lines
00057   gdt::gdtmap<gdtnode,grid_line> _grid_line_of_node[2];  // vertical (1) and horizontal (0) grid line of node
00058   gdt::gdtmap<gdtnode, gdt::list_item > _node_pos_into_gl_list[2];
00059   gdt::gdtmap<gdtedge, int> _axis_of_edge;               // 0 for horizontal and 1 for vertical
00060   gdt::gdtmap<int, int> _aux_id;                         // record the id of the node of the undi graph
00061                                                          // from which the node with this id has been generated
00062   bool _redistribution_needed; 
00063     
00064 
00065                         /* 
00066                         PRIVATE_METHOD new_grid_line
00067                         Insert a new last grid line parallel to the axis and return it.
00068                         If "forward" is true the new grid line is inserted as the last grid line of 
00069                         the list; if "forward" is false the grid line is inserted at the 
00070                         beginning of the list. 
00071                         */
00072 
00073                         grid_line 
00074                 new_grid_line
00075                         (
00076                         int axis, 
00077                         bool forward=true
00078                         );  
00079 
00080 
00081                         /* 
00082                         PRIVATE_METHOD new_grid_line
00083                         Insert a new grid line near the input gl and return it.
00084                         If "forward" is true the new grid line is inserted after gl,
00085                         if "forward" is false the new grid line is inserted before gl. 
00086                         */
00087 
00088                         grid_line 
00089                 new_grid_line
00090                         (
00091                         grid_line gl, 
00092                         bool forward=true
00093                         );  
00094 
00095 
00096                         /* 
00097                         PRIVATE_METHOD new_box
00098                         Build a box in the specified position. 
00099                         */
00100 
00101 
00102                         void
00103                 new_box
00104                         (
00105                         gdtnode V,
00106                         int V_id,
00107                         grid_line col, 
00108                         grid_line row,
00109                         gdt::gdtlist<gdtnode>& attached_to_left_border,
00110                         gdt::gdtlist<gdtnode>& attached_to_right_border,
00111                         gdt::gdtlist<gdtedge>&                                  exiting_EDGES,
00112                         gdt::gdtmap<gdtnode,gdtnode>&                           node_2_NODE,
00113                         gdt::gdtmap<gdtnode, gdt::gdtmap< gdtedge, gdtnode > >& NODE_EDGE_2_node,
00114                         gdt::gdtmap<grid_line, int>&                            grid_line_2_NODE_id
00115                         ); 
00116 
00117 
00118 
00119   public:
00120 
00125                 rel_coord_orth
00126                         (void);
00127 
00128 
00133                 ~rel_coord_orth
00134                         (void);
00135 
00136 
00151                 rel_coord_orth
00152                         (
00153                         undi_graph ug,
00154                         algorithm_type alg=ORTH_SIMPLE_PT00
00155                         );  
00156 
00157 
00164                         undi_graph
00165                 get_underlying_undi_graph
00166                         (
00167                         ) const;
00168                         
00169 
00176                         gdt::gdtpoint
00177                 center
00178                         (
00179                         gdtnode n
00180                         ) const;
00181 
00182 
00189                         gdt::gdtpoint
00190                 center
00191                         (
00192                         int id
00193                         ) const;
00194 
00201                         double
00202                 xcoord
00203                         (
00204                         gdtnode n
00205                         ) const;
00206 
00207 
00212                         double
00213                 xcoord
00214                         (
00215                         int id
00216                         ) const;
00217 
00218 
00225                         double
00226                 ycoord
00227                         (
00228                         gdtnode n
00229                         ) const;
00230 
00231 
00236                         double
00237                 ycoord
00238                         (
00239                         int id
00240                         ) const;
00241 
00242 
00252                         inline
00253                         int
00254                 aux_id
00255                         (
00256                         int id
00257                         ) const
00258                         {
00259                         return _aux_id[id];
00260                         }
00261 
00262 
00269                         grid_line
00270                 next_grid_line
00271                         (
00272                         grid_line gl,
00273                         bool forward
00274                         );
00275 
00276 
00277 
00283                         inline
00284                         gdtnode
00285                 new_node
00286                         (
00287                         grid_line l1,
00288                         grid_line l2
00289                         )
00290                         {
00291                         gdtnode n = ulug.new_node();
00292                         insert_node(n,l1,l2);
00293                         return n;
00294                         }
00295 
00296 
00303                         inline
00304                         gdtedge
00305                 new_edge
00306                         (
00307                         gdtnode n1,
00308                         gdtnode n2
00309                         )
00310                         {
00311                         gdtedge e = ulug.new_edge(n1,n2);
00312                         if( _grid_line_of_node[0][n1] == _grid_line_of_node[0][n2] )
00313                                 _axis_of_edge[e]=0;
00314                         else if ( _grid_line_of_node[1][n1] == _grid_line_of_node[1][n2] )
00315                                 _axis_of_edge[e]=1;
00316                         else gdt_error("the two input nodes do not share a grid line");
00317                         return e;
00318                         }
00319 
00320 
00326                         void 
00327                 insert_node
00328                         (
00329                         gdtnode n, 
00330                         grid_line l1, 
00331                         grid_line l2
00332                         );
00333 
00341                         inline
00342                         void 
00343                 redistribute_coords
00344                         (
00345                         double gap
00346                         ) 
00347                         {
00348                         redistribute_coords(0,gap);
00349                         redistribute_coords(1,gap);
00350                         _redistribution_needed = false;
00351                         }
00352 
00360                         inline
00361                         void 
00362                 redistribute_coords_if_needed
00363                         (
00364                         double gap
00365                         ) 
00366                         {
00367                         if( _redistribution_needed )
00368                                 {
00369                                 redistribute_coords(0,gap);
00370                                 redistribute_coords(1,gap);
00371                                 _redistribution_needed = false;
00372                                 }
00373                         }
00374 
00375 
00383                         void 
00384                 redistribute_coords
00385                         (
00386                         int axis, 
00387                         double gap
00388                         );
00389 
00390 
00391   
00392 };
00393 
00394 #endif // RM3_REL_COORD_ORTH_H

Generated on Thu Jan 10 14:48:01 2008 for GDToolkit GAPI by  doxygen 1.5.3