COIN-OR::LEMON - Graph Library

Changeset 1860:27a9a75b957b in lemon-0.x for gui/gdc-broken_edge.cc


Ignore:
Timestamp:
12/17/05 21:55:41 (14 years ago)
Author:
Akos Ladanyi
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2432
Message:

Save and load the coordinates of the arrows on the edges.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • gui/gdc-broken_edge.cc

    r1831 r1860  
    22#include <cmath>
    33
    4 GraphDisplayerCanvas::BrokenEdge::BrokenEdge(Gnome::Canvas::Group & g, Gnome::Canvas::Points p, GraphDisplayerCanvas & gc) : Line(g), gdc(gc), isbutton(false)
     4GraphDisplayerCanvas::BrokenEdge::BrokenEdge(Gnome::Canvas::Group & g, Edge _edge, GraphDisplayerCanvas & gc) : Line(g), edge(_edge), gdc(gc), isbutton(false)
    55{
    6   my_points=new Gnome::Art::Point[3];
    7 
    86  arrow=new Gnome::Canvas::Polygon(g);
    97  *arrow << Gnome::Canvas::Properties::fill_color("red");
    108  arrow->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::BrokenEdge::edgeFormerEventHandler));
    119  arrow->lower_to_bottom();
    12   setPoints(p);
     10  draw();
    1311}
    1412
     
    1816}
    1917
    20 void GraphDisplayerCanvas::BrokenEdge::setPoints(Gnome::Canvas::Points p, bool move)
     18void GraphDisplayerCanvas::BrokenEdge::draw()
    2119{
    22   bool set_arrow=false;
    23   //red arrow losts its position-right button
    24   if(!move)
    25     {
    26       if(p.size()==2)
    27         {
    28           set_arrow=true;
    29           Gnome::Canvas::Points points_with_center;
    30           points_with_center.push_back(my_points[0]=p[0]);
    31           points_with_center.push_back(my_points[1]=Gnome::Art::Point( (p[0].get_x()+p[1].get_x())/2+0 , (p[0].get_y()+p[1].get_y())/2 )+0 );
    32           points_with_center.push_back(my_points[2]=p[1]);
    33           property_points().set_value(points_with_center);
    34         } 
    35       if(p.size()==3)
    36         {
    37           set_arrow=true;
    38           property_points().set_value(p);
    39           for(int i=0;i<3;i++)
    40             {
    41               my_points[i]=p[i];
    42             }
    43         }
     20  MapStorage& ms = gdc.mytab.mapstorage;
     21
     22  // update the edge
     23  {
     24    Gnome::Canvas::Points points;
     25    Node source = ms.graph.source(edge);
     26    Node target = ms.graph.target(edge);
     27    points.push_back(Gnome::Art::Point(ms.coords[source].x,
     28          ms.coords[source].y));
     29    points.push_back(Gnome::Art::Point(ms.arrow_pos[edge].x,
     30          ms.arrow_pos[edge].y));
     31    points.push_back(Gnome::Art::Point(ms.coords[target].x,
     32          ms.coords[target].y));
     33    property_points().set_value(points);
     34  }
     35
     36  // update the arrow
     37  {
     38    //calculating coordinates of the direction indicator arrow
     39    XY target(ms.coords[ms.graph.target(edge)]);
     40    XY center(ms.arrow_pos[edge]);
     41
     42    XY unit_vector_in_dir(target-center);
     43    double length=sqrt( unit_vector_in_dir.normSquare() );
     44
     45    //       std::cout << target << " - " << center << " = " << unit_vector_in_dir << "    / " <<unit_vector_in_dir.normSquare() ;
     46    unit_vector_in_dir/=length;
     47    //       std::cout << " = " << unit_vector_in_dir << std::endl;
     48
     49    XY unit_norm_vector(0-unit_vector_in_dir.y, unit_vector_in_dir.x);
     50    //       std::cout << unit_norm_vector << std::endl;
     51
     52    {     
     53      //       /\       // top
     54      //      /  \      //
     55      //      -  -      // c(enter)l(eft), ccl, ccr, cr
     56      //       ||       //
     57      //       ||       // b(ottom)l, br
    4458    }
    45   else
    46     {
    47       //arrow keeps its position-left button
    4859
    49 //       if(p.size()==2)
    50 //              {
    51 //                Gnome::Canvas::Points points;
    52 //                my_points[0]=p[0];
    53 //                my_points[2]=p[1];
    54 //                for(int i=0;i<3;i++)
    55 //                  {
    56 //                    points.push_back(my_points[i]);
    57 //                  }
    58 //                property_points().set_value(points);
    59 //              }
    60       set_arrow=true;
     60    double size=3;
    6161
    62       //////////////////////////////////////////////////////////////////////////////////////////////////////
    63       /////////// keeps shape-with scalar multiplication - version 2.
    64       //////////////////////////////////////////////////////////////////////////////////////////////////////
     62    XY bl (center - unit_vector_in_dir * 3 * size + unit_norm_vector * size );
     63    XY br (center - unit_vector_in_dir * 3 * size - unit_norm_vector * size );
     64    XY ccl(center + unit_vector_in_dir *  size + unit_norm_vector * size );
     65    XY ccr(center + unit_vector_in_dir *  size - unit_norm_vector * size );
     66    XY cl (center + unit_vector_in_dir *  size + unit_norm_vector * 2 * size );
     67    XY cr (center + unit_vector_in_dir *  size - unit_norm_vector * 2 * size );
     68    XY top(center + unit_vector_in_dir * 3 * size);
    6569
    66       if(p.size()==2)
    67         {
    68           //old vector from one to the other node - a
    69           xy<double> a_v(my_points[2].get_x()-my_points[0].get_x(),my_points[2].get_y()-my_points[0].get_y());
    70           //new vector from one to the other node - b
    71           xy<double> b_v(p[1].get_x()-p[0].get_x(),p[1].get_y()-p[0].get_y());
     70    //std::cout << bl << " " << br << " " << ccl << " "  << ccr << " " << cl << " " << cr << " " << top << std::endl;
    7271
    73           double absa=sqrt(a_v.normSquare());
    74           double absb=sqrt(b_v.normSquare());
     72    Gnome::Canvas::Points arrow_points;
     73    arrow_points.push_back(Gnome::Art::Point( bl.x , bl.y  ) );
     74    arrow_points.push_back(Gnome::Art::Point( br.x , br.y  ) );
     75    arrow_points.push_back(Gnome::Art::Point( ccr.x, ccr.y ) );
     76    arrow_points.push_back(Gnome::Art::Point( cr.x , cr.y  ) );
     77    arrow_points.push_back(Gnome::Art::Point( top.x, top.y ) );
     78    arrow_points.push_back(Gnome::Art::Point( cl.x , cl.y  ) );
     79    arrow_points.push_back(Gnome::Art::Point( ccl.x, ccl.y ) );
    7580
    76           if((absa!=0)&&(absb!=0))
    77             {
    78               //old vector from one node to the breakpoint - c
    79               xy<double> c_v(my_points[1].get_x()-my_points[0].get_x(),my_points[1].get_y()-my_points[0].get_y());
    80 
    81               //unit vector with the same direction to a_v
    82               xy<double> a_v_u(a_v.x/absa,a_v.y/absa);
    83 
    84               //normal vector of unit vector with the same direction to a_v
    85               xy<double> a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
    86 
    87               //unit vector with the same direction to b_v
    88               xy<double> b_v_u(b_v.x/absb,b_v.y/absb);
    89 
    90               //normal vector of unit vector with the same direction to b_v
    91               xy<double> b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
    92 
    93               //vector c in a_v_u and a_v_u_n co-ordinate system
    94               xy<double> c_a(c_v*a_v_u,c_v*a_v_u_n);
    95 
    96               //new vector from one node to the breakpoint - d - we have to calculate this one
    97               xy<double> d_v=absb/absa*(c_a.x*b_v_u+c_a.y*b_v_u_n);
    98 
    99               my_points[1]=Gnome::Art::Point(d_v.x+p[0].get_x(),d_v.y+p[0].get_y());
    100 
    101               my_points[0]=p[0];
    102               my_points[2]=p[1];
    103          
    104               Gnome::Canvas::Points points;
    105               for(int i=0;i<3;i++)
    106                 {
    107                   points.push_back(my_points[i]);
    108                 }
    109               property_points().set_value(points);
    110             }
    111           else
    112             {
    113               //if distance is 0, segmentation would be occured
    114               //in calculations, because of division by zero
    115               //But we have luck: the edge cannot be seen in
    116               //this case, so no update needed
    117               set_arrow=false;
    118             }
    119         }
    120     }
    121   if(set_arrow)
    122     {
    123       //calculating coordinates of the direction indicator arrow
    124 
    125       xy<gdouble> target( my_points[2].get_x(), my_points[2].get_y() );
    126       xy<gdouble> center( my_points[1].get_x(), my_points[1].get_y() );
    127 
    128       xy<gdouble> unit_vector_in_dir(target-center);
    129       double length=sqrt( unit_vector_in_dir.normSquare() );
    130 
    131       //       std::cout << target << " - " << center << " = " << unit_vector_in_dir << "    / " <<unit_vector_in_dir.normSquare() ;
    132       unit_vector_in_dir/=length;
    133       //       std::cout << " = " << unit_vector_in_dir << std::endl;
    134 
    135       xy<gdouble> unit_norm_vector(0-unit_vector_in_dir.y, unit_vector_in_dir.x);
    136       //       std::cout << unit_norm_vector << std::endl;
    137 
    138       {     
    139         //       /\       // top
    140         //      /  \      //
    141         //      -  -      // c(enter)l(eft), ccl, ccr, cr
    142         //       ||       //
    143         //       ||       // b(ottom)l, br
    144       }
    145 
    146       double size=3;
    147 
    148       xy<gdouble> bl (center - unit_vector_in_dir * 3 * size + unit_norm_vector * size );
    149       xy<gdouble> br (center - unit_vector_in_dir * 3 * size - unit_norm_vector * size );
    150       xy<gdouble> ccl(center + unit_vector_in_dir *  size + unit_norm_vector * size );
    151       xy<gdouble> ccr(center + unit_vector_in_dir *  size - unit_norm_vector * size );
    152       xy<gdouble> cl (center + unit_vector_in_dir *  size + unit_norm_vector * 2 * size );
    153       xy<gdouble> cr (center + unit_vector_in_dir *  size - unit_norm_vector * 2 * size );
    154       xy<gdouble> top(center + unit_vector_in_dir * 3 * size);
    155          
    156       //std::cout << bl << " " << br << " " << ccl << " "  << ccr << " " << cl << " " << cr << " " << top << std::endl;
    157 
    158       Gnome::Canvas::Points arrow_points;
    159       arrow_points.push_back(Gnome::Art::Point( bl.x , bl.y  ) );
    160       arrow_points.push_back(Gnome::Art::Point( br.x , br.y  ) );
    161       arrow_points.push_back(Gnome::Art::Point( ccr.x, ccr.y ) );
    162       arrow_points.push_back(Gnome::Art::Point( cr.x , cr.y  ) );
    163       arrow_points.push_back(Gnome::Art::Point( top.x, top.y ) );
    164       arrow_points.push_back(Gnome::Art::Point( cl.x , cl.y  ) );
    165       arrow_points.push_back(Gnome::Art::Point( ccl.x, ccl.y ) );
    166 
    167       arrow->property_points().set_value(arrow_points);
    168     }
     81    arrow->property_points().set_value(arrow_points);
     82  }
    16983}
    17084
     
    204118          Gnome::Canvas::Points points_new;
    205119
    206           points_new.push_back(my_points[0]);
    207           points_new.push_back(my_points[1]=Gnome::Art::Point(my_points[1].get_x()+dx,my_points[1].get_y()+dy));
    208           points_new.push_back(my_points[2]);
     120          gdc.mytab.mapstorage.arrow_pos.set(edge, gdc.mytab.mapstorage.arrow_pos[edge] + XY(dx, dy));
    209121
    210           setPoints(points_new);
    211           gdc.textReposition(xy<double>(my_points[1].get_x(),my_points[1].get_y()));
     122          draw();
     123          gdc.textReposition(gdc.mytab.mapstorage.arrow_pos[edge]);
    212124
    213125          clicked_x=e->motion.x;
     
    220132  return true;
    221133}
    222 
    223 xy<double> GraphDisplayerCanvas::BrokenEdge::getArrowPos()
    224 {
    225   xy<double> ret_val(my_points[1].get_x(),my_points[1].get_y());
    226   return ret_val;
    227 }
Note: See TracChangeset for help on using the changeset viewer.