gui/mapstorage.cc
author ladanyi
Tue, 02 May 2006 18:23:42 +0000
changeset 2068 6936f130bba2
parent 2063 9535436aaa9f
permissions -rw-r--r--
gLEMON does not compile with gtkmm 2.4.x
     1 #include "mapstorage.h"
     2 #include "gui_writer.h"
     3 #include "gui_reader.h"
     4 #include <limits>
     5 #include <cmath>
     6 #include <gtkmm.h>
     7 
     8 MapStorage::MapStorage() : modified(false), file_name(""), arrow_pos_read_ok(false)
     9 {
    10   nodemap_storage["coordinates_x"] = new Graph::NodeMap<double>(graph);
    11   coords.setXMap(*nodemap_storage["coordinates_x"]);
    12   nodemap_storage["coordinates_y"] = new Graph::NodeMap<double>(graph);
    13   coords.setYMap(*nodemap_storage["coordinates_y"]);
    14 
    15   edgemap_storage["arrow_pos_x"] = new Graph::EdgeMap<double>(graph);
    16   arrow_pos.setXMap(*edgemap_storage["arrow_pos_x"]);
    17   edgemap_storage["arrow_pos_y"] = new Graph::EdgeMap<double>(graph);
    18   arrow_pos.setYMap(*edgemap_storage["arrow_pos_y"]);
    19 
    20   nodemap_storage["label"] = new Graph::NodeMap<double>(graph);
    21   edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
    22 
    23   nodemap_default["label"] = 1.0;
    24   edgemap_default["label"] = 1.0;
    25 
    26   active_nodemaps.resize(NODE_PROPERTY_NUM);
    27   for(int i=0;i<NODE_PROPERTY_NUM;i++)
    28     {
    29       active_nodemaps[i]="";
    30     }
    31 
    32   active_edgemaps.resize(EDGE_PROPERTY_NUM);
    33   for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    34     {
    35       active_edgemaps[i]="";
    36     }
    37 }
    38 
    39 MapStorage::~MapStorage()
    40 {
    41   for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
    42       nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
    43   {
    44     delete it->second;
    45   }
    46   for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
    47       edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
    48   {
    49     delete it->second;
    50   }
    51 }
    52 
    53 int MapStorage::addNodeMap(const std::string & name, Graph::NodeMap<double> *nodemap, double default_value)
    54 {
    55   std::cout << default_value << std::endl;
    56   if( nodemap_storage.find(name) == nodemap_storage.end() )
    57     {
    58       nodemap_storage[name]=nodemap;
    59       // set the maps default value
    60       nodemap_default[name] = default_value;
    61 
    62       //announce changement in maps
    63       signal_node_map.emit(name);
    64       return 0;
    65     }
    66   return 1;
    67 }
    68 
    69 void MapStorage::changeActiveMap(bool itisedge, int prop, std::string mapname)
    70 {
    71   if(itisedge)
    72     {
    73       active_edgemaps[prop]=mapname;
    74     }
    75   else
    76     {
    77       active_nodemaps[prop]=mapname;
    78     }
    79   signal_prop.emit(itisedge, prop);
    80 }
    81 
    82 std::string MapStorage::getActiveEdgeMap(int prop)
    83 {
    84   return active_edgemaps[prop];
    85 }
    86 
    87 std::string MapStorage::getActiveNodeMap(int prop)
    88 {
    89   return active_nodemaps[prop];
    90 }
    91 
    92 std::vector<std::string> MapStorage::getEdgeMapList()
    93 {
    94   std::vector<std::string> eml;
    95   eml.resize(edgemap_storage.size());
    96   int i=0;
    97   std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=beginOfEdgeMaps();
    98   for(;emsi!=endOfEdgeMaps();emsi++)
    99     {
   100       eml[i]=(emsi->first);
   101       i++;
   102     }
   103   return eml;
   104 }
   105 
   106 std::vector<std::string> MapStorage::getNodeMapList()
   107 {
   108   std::vector<std::string> nml;
   109   nml.resize(nodemap_storage.size());
   110   int i=0;
   111   std::map< std::string,Graph::NodeMap<double> * >::iterator nmsi=beginOfNodeMaps();
   112   for(;nmsi!=endOfNodeMaps();nmsi++)
   113     {
   114       nml[i]=(nmsi->first);
   115       i++;
   116     }
   117   return nml;
   118 }
   119 
   120 MapStorage::Signal_Prop MapStorage::signal_prop_ch()
   121 {
   122   return signal_prop;
   123 }
   124 
   125 int MapStorage::addEdgeMap(const std::string & name, Graph::EdgeMap<double> *edgemap, double default_value)
   126 {
   127   if( edgemap_storage.find(name) == edgemap_storage.end() )
   128     {
   129       edgemap_storage[name]=edgemap;
   130       // set the maps default value
   131       edgemap_default[name] = default_value;
   132 
   133       //announce changement in maps
   134       signal_edge_map.emit(name);
   135       return 0;
   136     }
   137   return 1;
   138 }
   139 
   140 double MapStorage::maxOfNodeMap(const std::string & name)
   141 {
   142   double max=0;
   143   for (NodeIt j(graph); j!=INVALID; ++j)
   144   {
   145     if( (*nodemap_storage[name])[j]>max )
   146     {
   147       max=(*nodemap_storage[name])[j];
   148     }
   149   }
   150   return max;
   151 }
   152 
   153 double MapStorage::maxOfEdgeMap(const std::string & name)
   154 {
   155   double max=0;
   156   for (EdgeIt j(graph); j!=INVALID; ++j)
   157   {
   158     if( (*edgemap_storage[name])[j]>max )
   159     {
   160       max=(*edgemap_storage[name])[j];
   161     }
   162   }
   163   return max;
   164 }
   165 
   166 double MapStorage::minOfNodeMap(const std::string & name)
   167 {
   168   NodeIt j(graph);
   169   double min;
   170   if(j!=INVALID)
   171     {
   172       min=(*nodemap_storage[name])[j];
   173     }
   174   else
   175     {
   176       min=0;
   177     }
   178   for (; j!=INVALID; ++j)
   179   {
   180     if( (*nodemap_storage[name])[j]<min )
   181     {
   182       min=(*nodemap_storage[name])[j];
   183     }
   184   }
   185   return min;
   186 }
   187 
   188 double MapStorage::minOfEdgeMap(const std::string & name)
   189 {
   190   EdgeIt j(graph);
   191   double min;
   192   if(j!=INVALID)
   193     {
   194       min=(*edgemap_storage[name])[j];
   195     }
   196   else
   197     {
   198       min=0;
   199     }
   200   for (EdgeIt j(graph); j!=INVALID; ++j)
   201   {
   202     if( (*edgemap_storage[name])[j]<min )
   203     {
   204       min=(*edgemap_storage[name])[j];
   205     }
   206   }
   207   return min;
   208 }
   209 
   210 int MapStorage::readFromFile(const std::string &filename)
   211 {
   212   bool read_x = false;
   213   bool read_y = false;
   214   bool read_edge_id = false;
   215 
   216   try {
   217     LemonReader lreader(filename);
   218     ContentReader content(lreader);
   219     lreader.run();
   220 
   221     if (content.nodeSetNum() < 1)
   222     {
   223       Gtk::MessageDialog mdialog("No nodeset found in file.");
   224       mdialog.run();
   225       clear();
   226       return 1;
   227     }
   228 
   229     if (content.edgeSetNum() < 1)
   230     {
   231       Gtk::MessageDialog mdialog("No edgeset found in file.");
   232       mdialog.run();
   233       clear();
   234       return 1;
   235     }
   236 
   237     const std::vector<std::string>& nodeMapNames = content.nodeSetMaps(0);
   238     const std::vector<std::string>& edgeMapNames = content.edgeSetMaps(0);
   239 
   240     GraphReader<Graph> greader(filename, graph);
   241     for (std::vector<std::string>::const_iterator it = nodeMapNames.begin();
   242         it != nodeMapNames.end(); ++it)
   243     {
   244       if (*it == "coordinates_x")
   245       {
   246         read_x = true;
   247         //std::cout << "read X nodemap" << std::endl;
   248       }
   249       else if (*it == "coordinates_y")
   250       {
   251         read_y = true;
   252         //std::cout << "read Y nodemap" << std::endl;
   253       }
   254       else if (*it == "label")
   255       {
   256         //std::cout << "read id nodemap" << std::endl;
   257       }
   258       else
   259       {
   260         nodemap_storage[*it] = new Graph::NodeMap<double>(graph);
   261         //std::cout << "read " << *it << " nodemap" << std::endl;
   262       }
   263       greader.readNodeMap(*it, *nodemap_storage[*it]);
   264     }
   265     for (std::vector<std::string>::const_iterator it = edgeMapNames.begin();
   266         it != edgeMapNames.end(); ++it)
   267     {
   268       if (*it == "label")
   269       {
   270         //std::cout << "read id edgemap" << std::endl;
   271         read_edge_id = true;
   272       }
   273       else
   274       {
   275         edgemap_storage[*it] = new Graph::EdgeMap<double>(graph);
   276         //std::cout << "read " << *it << " edgemap" << std::endl;
   277       }
   278       greader.readEdgeMap(*it, *edgemap_storage[*it]);
   279     }
   280     GuiReader gui_reader(greader, this);
   281     greader.run();
   282   } catch (Exception& error) {
   283     Gtk::MessageDialog mdialog(error.what());
   284     mdialog.run();
   285     clear();
   286     return 1;
   287   }
   288 
   289   if (!read_edge_id)
   290   {
   291     edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
   292     int i = 1;
   293     for (EdgeIt e(graph); e != INVALID; ++e)
   294     {
   295       (*edgemap_storage["label"])[e] = i++;
   296     }
   297   }
   298 
   299   if (!read_x || !read_y)
   300   {
   301     int node_num = 0;
   302     for (NodeIt n(graph); n != INVALID; ++n)
   303     {
   304       node_num++;
   305     }
   306     const double pi = 3.142;
   307     double step = 2 * pi / (double) node_num;
   308     int i = 0;
   309     for (NodeIt n(graph); n != INVALID; ++n)
   310     {
   311       nodemap_storage["coordinates_x"]->set(n, 250.0 * std::cos(i * step));
   312       nodemap_storage["coordinates_y"]->set(n, 250.0 * std::sin(i * step));
   313       i++;
   314     }
   315   }
   316 
   317   if (!arrow_pos_read_ok)
   318   {
   319     arrow_pos_read_ok = false;
   320     for (EdgeIt e(graph); e != INVALID; ++e)
   321     {
   322       arrow_pos.set(e, (coords[graph.source(e)] + coords[graph.target(e)]) / 2.0);
   323     }
   324   }
   325 
   326   // fill in the default values for the maps
   327   for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
   328       nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
   329   {
   330     if ((it->first != "label") &&
   331         (it->first != "coordiantes_x") &&
   332         (it->first != "coordinates_y"))
   333     {
   334       nodemap_default[it->first] = 0.0;
   335     }
   336     else if (it->first == "label")
   337     {
   338       NodeIt n(graph);
   339       double max = (*nodemap_storage["label"])[n];
   340       for (; n != INVALID; ++n)
   341       {
   342         if ((*nodemap_storage["label"])[n] > max)
   343           max = (*nodemap_storage["label"])[n];
   344       }
   345       nodemap_default["label"] = max + 1.0;
   346     }
   347   }
   348   for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
   349       edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
   350   {
   351     if (it->first != "label")
   352     {
   353       edgemap_default[it->first] = 0.0;
   354     }
   355     else
   356     {
   357       double max = std::numeric_limits<double>::min();
   358       for (EdgeIt e(graph); e != INVALID; ++e)
   359       {
   360         if ((*edgemap_storage["label"])[e] > max)
   361           max = (*edgemap_storage["label"])[e];
   362       }
   363       if (max > std::numeric_limits<double>::min())
   364         edgemap_default["label"] = max + 1.0;
   365       else
   366         edgemap_default["label"] = 1.0;
   367     }
   368   }
   369 
   370   // filter loop edges
   371   for (EdgeIt e(graph); e != INVALID; ++e)
   372   {
   373     if (graph.source(e) == graph.target(e))
   374     {
   375       std::cerr << "Removed loop edge " << (*edgemap_storage["label"])[e]
   376         << " (from " << (*nodemap_storage["label"])[graph.source(e)]
   377         << ", to " << (*nodemap_storage["label"])[graph.target(e)] << ")."
   378         << std::endl;
   379 
   380       graph.erase(e);
   381     }
   382   }
   383 
   384   return 0;
   385 }
   386 
   387 void MapStorage::writeToFile(const std::string &filename)
   388 {
   389   GraphWriter<Graph> gwriter(filename, graph);
   390 
   391   for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
   392       nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
   393   {
   394     gwriter.writeNodeMap(it->first, *(it->second));
   395   }
   396   for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
   397       edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
   398   {
   399     if ((it->first != "arrow_pos_x") &&
   400         (it->first != "arrow_pos_y"))
   401     {
   402       gwriter.writeEdgeMap(it->first, *(it->second));
   403     }
   404   }
   405 
   406   GuiWriter gui_writer(gwriter, this);
   407 
   408   gwriter.run();
   409 }
   410 
   411 void MapStorage::clear()
   412 {
   413   for (std::map<std::string, Graph::NodeMap<double>*>::iterator it =
   414       nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
   415   {
   416     if ((it->first != "coordinates_x") &&
   417         (it->first != "coordinates_y") &&
   418         (it->first != "label"))
   419     {
   420       delete it->second;
   421       nodemap_storage.erase(it);
   422     }
   423   }
   424   for (std::map<std::string, Graph::EdgeMap<double>*>::iterator it =
   425       edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
   426   {
   427     if ((it->first != "label") &&
   428         (it->first != "arrow_pos_x") &&
   429         (it->first != "arrow_pos_y"))
   430     {
   431       delete it->second;
   432       edgemap_storage.erase(it);
   433     }
   434   }
   435   for (std::map<std::string, double>::iterator it =
   436       nodemap_default.begin(); it != nodemap_default.end(); ++it)
   437   {
   438     if (it->first != "label")
   439       nodemap_default.erase(it);
   440   }
   441   for (std::map<std::string, double>::iterator it =
   442       edgemap_default.begin(); it != edgemap_default.end(); ++it)
   443   {
   444     if (it->first != "label")
   445       edgemap_default.erase(it);
   446   }
   447   graph.clear();
   448   file_name = "";
   449   modified = false;
   450 }
   451 
   452 void MapStorage::ArrowPosReadOK()
   453 {
   454   arrow_pos_read_ok = true;
   455 }
   456 
   457 void MapStorage::mapChanged(bool itisedge, std::string mapname)
   458 {
   459   if(itisedge)
   460     {
   461       for(int i=0;i<EDGE_PROPERTY_NUM;i++)
   462 	{
   463 	  if(active_edgemaps[i]==mapname)
   464 	    {
   465 	      signal_prop.emit(itisedge, i);
   466 	    }
   467 	}
   468     }
   469   else
   470     {
   471       for(int i=0;i<NODE_PROPERTY_NUM;i++)
   472 	{
   473 	  if(active_nodemaps[i]==mapname)
   474 	    {
   475 	      signal_prop.emit(itisedge, i);
   476 	    }
   477 	}
   478     }
   479 }