source: glemon-0.x/graph_displayer_canvas.cc @ 168:a5f82cbbc1e4

#include "graph_displayer_canvas.h"
#include <lemon/random.h>
#include <cmath>

GraphDisplayerCanvas::GraphDisplayerCanvas(NoteBookTab & mainw) :
  nodesmap(mainw.mapstorage.graph), edgesmap(mainw.mapstorage.graph), edgetextmap(mainw.mapstorage.graph),
  nodetextmap(mainw.mapstorage.graph), displayed_graph(*(root()), 0, 0),
  isbutton(0), active_item(NULL), target_item(NULL), nodemap_to_edit(""),
  edgemap_to_edit(""), autoscale(true), zoomtrack(false), radius_size(20), edge_width(10),
  iterations(20), attraction(0.05), propulsation(40000), was_redesigned(false), mytab(mainw)
{
  //base event handler is move tool
  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
  actual_tool=MOVE;

  active_node=INVALID;
  active_edge=INVALID;
  forming_edge=INVALID;
}

GraphDisplayerCanvas::~GraphDisplayerCanvas()
{
  for (NodeIt n((mytab.mapstorage).graph); n != INVALID; ++n)
    {
      delete nodesmap[n];
      delete nodetextmap[n];
    }
  
  for (EdgeIt e((mytab.mapstorage).graph); e != INVALID; ++e)
    {
      delete edgesmap[e];
      delete edgetextmap[e];
    }
}

void GraphDisplayerCanvas::propertyChange(bool itisedge, int prop)
{
  if(itisedge)
    {
      propertyUpdate(Edge(INVALID), prop);
    }
  else
    {
      propertyUpdate(Node(INVALID), prop);
    }
}

void GraphDisplayerCanvas::propertyUpdate(Edge edge)
{
  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      propertyUpdate(edge, i);
    }
}

void GraphDisplayerCanvas::propertyUpdate(Node node)
{
  for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      propertyUpdate(node, i);
    }
}

void GraphDisplayerCanvas::propertyUpdate(Node node, int prop)
{
  //dummy=dummy;

  std::string mapname=mytab.getActiveNodeMap(prop);

  if(mapname!="")
    {
      if( ( ((mytab.mapstorage).nodemap_storage).find(mapname) != ((mytab.mapstorage).nodemap_storage).end() ) )
        {
          switch(prop)
            {
            case N_RADIUS:
              changeNodeRadius(mapname, node);
              break;
            case N_COLOR:
              changeNodeColor(mapname, node);
              break;
            case N_TEXT:
              changeNodeText(mapname, node);
              break;
            default:
              std::cerr<<"Error\n";
            }
        }
    }
  else //mapname==""
    {
      Node node=INVALID;        
      switch(prop)
        {
        case N_RADIUS:
          resetNodeRadius(node);
          break;
        case N_COLOR:
          resetNodeColor(node);
          break;
        case N_TEXT:
          resetNodeText(node);
          break;
        default:
          std::cerr<<"Error\n";
        }
    }

}

void GraphDisplayerCanvas::propertyUpdate(Edge edge, int prop)
{
  //dummy=dummy;

  std::string mapname=mytab.getActiveEdgeMap(prop);

  if(mapname!="")
    {
      if( ( ((mytab.mapstorage).edgemap_storage).find(mapname) != ((mytab.mapstorage).edgemap_storage).end() ) )
        {
          switch(prop)
            {
            case E_WIDTH:
              changeEdgeWidth(mapname, edge);
              break;
            case E_COLOR:
              changeEdgeColor(mapname, edge);
              break;
            case E_TEXT:
              changeEdgeText(mapname, edge);
              break;
            default:
              std::cerr<<"Error\n";
            }
        }
    }
  else //mapname==""
    {
      switch(prop)
        {
        case E_WIDTH:
          resetEdgeWidth(edge);
          break;
        case E_COLOR:
          resetEdgeColor(edge);
          break;
        case E_TEXT:
          resetEdgeText(edge);
          break;
        default:
          std::cerr<<"Error\n";
        }
    }
}

void GraphDisplayerCanvas::drawGraph()
{
  //first edges are drawn, to hide joining with nodes later

  for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
  {
    if (mytab.mapstorage.graph.source(i) == mytab.mapstorage.graph.target(i))
    {
      edgesmap[i]=new LoopEdge(displayed_graph, i, *this);
    }
    else
    {
      edgesmap[i]=new BrokenEdge(displayed_graph, i, *this);
    }
    //initializing edge-text as well, to empty string

    XY text_pos=mytab.mapstorage.arrow_pos[i];
    text_pos+=(XY(10,10));

    edgetextmap[i]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
    edgetextmap[i]->property_fill_color().set_value("darkgreen");
    edgetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
    edgetextmap[i]->raise_to_top();
  }

  //afterwards nodes come to be drawn

  for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
  {
    //drawing bule nodes, with black line around them

    nodesmap[i]=new Gnome::Canvas::Ellipse(
        displayed_graph,
        (mytab.mapstorage).coords[i].x-20,
        (mytab.mapstorage).coords[i].y-20,
        (mytab.mapstorage).coords[i].x+20,
        (mytab.mapstorage).coords[i].y+20);
    *(nodesmap[i]) << Gnome::Canvas::Properties::fill_color("blue");
    *(nodesmap[i]) << Gnome::Canvas::Properties::outline_color("black");
    nodesmap[i]->raise_to_top();

    //initializing edge-text as well, to empty string

    XY text_pos(
        ((mytab.mapstorage).coords[i].x+node_property_defaults[N_RADIUS]+5),
        ((mytab.mapstorage).coords[i].y+node_property_defaults[N_RADIUS]+5));

    nodetextmap[i]=new Gnome::Canvas::Text(displayed_graph,
        text_pos.x, text_pos.y, "");
    nodetextmap[i]->property_fill_color().set_value("darkblue");
    nodetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
    nodetextmap[i]->raise_to_top();
  }

  updateScrollRegion();
}

void GraphDisplayerCanvas::clear()
{
  active_node=INVALID;
  active_edge=INVALID;
  forming_edge=INVALID;

  for (NodeIt n((mytab.mapstorage).graph); n != INVALID; ++n)
  {
    delete nodesmap[n];
    delete nodetextmap[n];
  }

  for (EdgeIt e((mytab.mapstorage).graph); e != INVALID; ++e)
  {
    delete edgesmap[e];
    delete edgetextmap[e];
  }
}

void GraphDisplayerCanvas::setView(bool autoscale_p, bool zoomtrack_p, double width_p, double radius_p)
{
  autoscale=autoscale_p;
  edge_width=width_p;
  radius_size=radius_p;

  if((!zoomtrack) && zoomtrack_p)
    {
      fixed_zoom_factor=get_pixels_per_unit();
    }

  zoomtrack=zoomtrack_p;

  propertyChange(false, N_RADIUS);
  propertyChange(true, E_WIDTH);
}

void GraphDisplayerCanvas::getView(bool & autoscale_p, bool & zoomtrack_p, double& width_p, double& radius_p)
{
  autoscale_p=autoscale;
  zoomtrack_p=zoomtrack;
  width_p=edge_width;
  radius_p=radius_size;
}

void GraphDisplayerCanvas::reDesignGraph()
{
  double min_dist=20;
  double init_vector_length=25;

  if(!was_redesigned)
    {
      NodeIt i((mytab.mapstorage).graph);

      dim2::Point<double> init(init_vector_length*rnd(),
                               init_vector_length*rnd());
      moveNode(init.x, init.y, nodesmap[i], i);
      was_redesigned=true;
    }
  

  //iteration counter
  for(int l=0;l<iterations;l++)
    {
      Graph::NodeMap<double> x(mytab.mapstorage.graph);
      Graph::NodeMap<double> y(mytab.mapstorage.graph);
      XYMap<Graph::NodeMap<double> > actual_forces;
      actual_forces.setXMap(x);
      actual_forces.setYMap(y);

      lemon::dim2::Point<double> delta;

      //count actual force for each nodes
      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
        {
          //propulsation of nodes
          for (NodeIt j((mytab.mapstorage).graph); j!=INVALID; ++j)
            {
              if(i!=j)
                {
                  delta=((mytab.mapstorage).coords[i]-(mytab.mapstorage).coords[j]);

                  double length_sqr=delta.normSquare();
                  double length=sqrt(length_sqr);
                  if(length_sqr<min_dist)
                    {
                      length_sqr=min_dist;
                    }

                  //normalize vector
                  delta/=length;

                  //calculating propulsation strength
                  //greater distance menas smaller propulsation strength
                  delta*=propulsation/length_sqr;
                    
                  actual_forces.set(i,(actual_forces[i]+delta));
                }
            }
          //attraction of nodes, to which actual node is bound
          for(OutEdgeIt ei((mytab.mapstorage).graph,i);ei!=INVALID;++ei)
            {
              delta=((mytab.mapstorage).coords[i]-(mytab.mapstorage).coords[mytab.mapstorage.graph.target(ei)]);

              double length_sqr=delta.normSquare();
              double length=sqrt(length_sqr);
              if(length_sqr<min_dist)
                {
                  length_sqr=min_dist;
                }

              //normalize vector
              delta/=length;

              //calculating attraction strength
              //greater distance means greater strength
              delta*=attraction*length;

              actual_forces.set(i,actual_forces[i]-delta);
            }
          for(InEdgeIt ei((mytab.mapstorage).graph,i);ei!=INVALID;++ei)
            {
              delta=((mytab.mapstorage).coords[i]-(mytab.mapstorage).coords[mytab.mapstorage.graph.source(ei)]);

              double length_sqr=delta.normSquare();
              double length=sqrt(length_sqr);
              if(length_sqr<min_dist)
                {
                  length_sqr=min_dist;
                }

              //normalize vector
              delta/=length;

              //calculating attraction strength
              //greater distance means greater strength
              delta*=attraction*length;

              actual_forces.set(i,actual_forces[i]-delta);
            }
        }
      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
        {
          moveNode(actual_forces[i].x, actual_forces[i].y, nodesmap[i], i);
        }
    }
}

void GraphDisplayerCanvas::get_design_data(double & attraction_p, double & propulsation_p, int & iterations_p)
{
  attraction_p=attraction;
  propulsation_p=propulsation;
  iterations_p=iterations;
}

void GraphDisplayerCanvas::set_attraction(double attraction_p)
{
  attraction=attraction_p;
}

void GraphDisplayerCanvas::set_propulsation(double propulsation_p)
{
  propulsation=propulsation_p;
}

void GraphDisplayerCanvas::set_iteration(int iterations_p)
{
  iterations=iterations_p;
}