COIN-OR::LEMON - Graph Library

source: glemon-0.x/mapstorage.cc @ 134:82e19031c319

gui
Last change on this file since 134:82e19031c319 was 134:82e19031c319, checked in by Akos Ladanyi, 15 years ago

id->label

File size: 10.9 KB
RevLine 
[53]1#include "mapstorage.h"
[98]2#include "gui_writer.h"
3#include "gui_reader.h"
[128]4#include <limits>
5#include <cmath>
[63]6#include <gtkmm.h>
[77]7
[98]8MapStorage::MapStorage() : modified(false), file_name(""), arrow_pos_read_ok(false)
[6]9{
[53]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
[98]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
[134]20  nodemap_storage["label"] = new Graph::NodeMap<double>(graph);
21  edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
[64]22
[134]23  nodemap_default["label"] = 1.0;
24  edgemap_default["label"] = 1.0;
[94]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    }
[53]37}
38
39MapStorage::~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}
[6]52
[118]53int MapStorage::addNodeMap(const std::string & name, Graph::NodeMap<double> *nodemap, double default_value)
[6]54{
[118]55  std::cout << default_value << std::endl;
[46]56  if( nodemap_storage.find(name) == nodemap_storage.end() )
57    {
58      nodemap_storage[name]=nodemap;
[63]59      // set the maps default value
60      nodemap_default[name] = default_value;
[108]61
62      //announce changement in maps
63      signal_node_map.emit(name);
[46]64      return 0;
65    }
66  return 1;
[6]67}
68
[94]69void 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
82std::string MapStorage::getActiveEdgeMap(int prop)
83{
84  return active_edgemaps[prop];
85}
86
87std::string MapStorage::getActiveNodeMap(int prop)
88{
89  return active_nodemaps[prop];
90}
91
92std::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
106std::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
120MapStorage::Signal_Prop MapStorage::signal_prop_ch()
121{
122  return signal_prop;
123}
124
[118]125int MapStorage::addEdgeMap(const std::string & name, Graph::EdgeMap<double> *edgemap, double default_value)
[6]126{
[46]127  if( edgemap_storage.find(name) == edgemap_storage.end() )
128    {
129      edgemap_storage[name]=edgemap;
[63]130      // set the maps default value
131      edgemap_default[name] = default_value;
[108]132
133      //announce changement in maps
134      signal_edge_map.emit(name);
[46]135      return 0;
136    }
137  return 1;
[6]138}
139
140double MapStorage::maxOfNodeMap(const std::string & name)
141{
142  double max=0;
[53]143  for (NodeIt j(graph); j!=INVALID; ++j)
[6]144  {
145    if( (*nodemap_storage[name])[j]>max )
146    {
147      max=(*nodemap_storage[name])[j];
148    }
149  }
150  return max;
151}
152
153double MapStorage::maxOfEdgeMap(const std::string & name)
154{
155  double max=0;
[53]156  for (EdgeIt j(graph); j!=INVALID; ++j)
[6]157  {
158    if( (*edgemap_storage[name])[j]>max )
159    {
160      max=(*edgemap_storage[name])[j];
161    }
162  }
163  return max;
164}
165
166double MapStorage::minOfNodeMap(const std::string & name)
167{
[53]168  NodeIt j(graph);
[58]169  double min;
170  if(j!=INVALID)
171    {
172      min=(*nodemap_storage[name])[j];
173    }
174  else
175    {
176      min=0;
177    }
[6]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
188double MapStorage::minOfEdgeMap(const std::string & name)
189{
[53]190  EdgeIt j(graph);
[58]191  double min;
192  if(j!=INVALID)
193    {
194      min=(*edgemap_storage[name])[j];
195    }
196  else
197    {
198      min=0;
199    }
[53]200  for (EdgeIt j(graph); j!=INVALID; ++j)
[6]201  {
202    if( (*edgemap_storage[name])[j]<min )
203    {
204      min=(*edgemap_storage[name])[j];
205    }
206  }
207  return min;
208}
209
[63]210int MapStorage::readFromFile(const std::string &filename)
[53]211{
212  bool read_x = false;
213  bool read_y = false;
[64]214  bool read_edge_id = false;
[53]215
216  try {
217    LemonReader lreader(filename);
218    ContentReader content(lreader);
219    lreader.run();
220
[101]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
[53]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      }
[134]254      else if (*it == "label")
[53]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    {
[134]268      if (*it == "label")
[53]269      {
270        //std::cout << "read id edgemap" << std::endl;
271      }
272      else
273      {
274        edgemap_storage[*it] = new Graph::EdgeMap<double>(graph);
275        //std::cout << "read " << *it << " edgemap" << std::endl;
276      }
277      greader.readEdgeMap(*it, *edgemap_storage[*it]);
278    }
[98]279    GuiReader gui_reader(greader, this);
[53]280    greader.run();
[101]281  } catch (Exception& error) {
[79]282    Gtk::MessageDialog mdialog(error.what());
[53]283    mdialog.run();
[63]284    clear();
285    return 1;
[53]286  }
287
[64]288  if (!read_edge_id)
289  {
[134]290    edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
[64]291    int i = 1;
292    for (EdgeIt e(graph); e != INVALID; ++e)
293    {
[134]294      (*edgemap_storage["label"])[e] = i++;
[64]295    }
296  }
297
[53]298  if (!read_x || !read_y)
299  {
300    int node_num = 0;
301    for (NodeIt n(graph); n != INVALID; ++n)
302    {
303      node_num++;
304    }
305    const double pi = 3.142;
306    double step = 2 * pi / (double) node_num;
307    int i = 0;
308    for (NodeIt n(graph); n != INVALID; ++n)
309    {
[77]310      nodemap_storage["coordinates_x"]->set(n, 250.0 * std::cos(i * step));
311      nodemap_storage["coordinates_y"]->set(n, 250.0 * std::sin(i * step));
[53]312      i++;
313    }
314  }
[63]315
[98]316  if (!arrow_pos_read_ok)
317  {
318    arrow_pos_read_ok = false;
319    for (EdgeIt e(graph); e != INVALID; ++e)
320    {
321      arrow_pos.set(e, (coords[graph.source(e)] + coords[graph.target(e)]) / 2.0);
322    }
323  }
324
[63]325  // fill in the default values for the maps
326  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
327      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
328  {
[134]329    if ((it->first != "label") &&
[63]330        (it->first != "coordiantes_x") &&
331        (it->first != "coordinates_y"))
332    {
333      nodemap_default[it->first] = 0.0;
334    }
[134]335    else if (it->first == "label")
[64]336    {
337      NodeIt n(graph);
[134]338      double max = (*nodemap_storage["label"])[n];
[64]339      for (; n != INVALID; ++n)
340      {
[134]341        if ((*nodemap_storage["label"])[n] > max)
342          max = (*nodemap_storage["label"])[n];
[64]343      }
[134]344      nodemap_default["label"] = max + 1.0;
[64]345    }
[63]346  }
347  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
348      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
349  {
[134]350    if (it->first != "label")
[63]351    {
352      edgemap_default[it->first] = 0.0;
353    }
[64]354    else
355    {
[67]356      double max = std::numeric_limits<double>::min();
357      for (EdgeIt e(graph); e != INVALID; ++e)
[64]358      {
[134]359        if ((*edgemap_storage["label"])[e] > max)
360          max = (*edgemap_storage["label"])[e];
[64]361      }
[67]362      if (max > std::numeric_limits<double>::min())
[134]363        edgemap_default["label"] = max + 1.0;
[67]364      else
[134]365        edgemap_default["label"] = 1.0;
[64]366    }
[63]367  }
368
369  return 0;
[53]370}
371
372void MapStorage::writeToFile(const std::string &filename)
373{
374  GraphWriter<Graph> gwriter(filename, graph);
375
376  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
377      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
378  {
379    gwriter.writeNodeMap(it->first, *(it->second));
380  }
381  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
382      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
383  {
[98]384    if ((it->first != "arrow_pos_x") &&
385        (it->first != "arrow_pos_y"))
386    {
387      gwriter.writeEdgeMap(it->first, *(it->second));
388    }
[53]389  }
[98]390
391  GuiWriter gui_writer(gwriter, this);
392
[53]393  gwriter.run();
394}
395
396void MapStorage::clear()
397{
398  for (std::map<std::string, Graph::NodeMap<double>*>::iterator it =
399      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
400  {
401    if ((it->first != "coordinates_x") &&
402        (it->first != "coordinates_y") &&
[134]403        (it->first != "label"))
[53]404    {
405      delete it->second;
406      nodemap_storage.erase(it);
407    }
408  }
409  for (std::map<std::string, Graph::EdgeMap<double>*>::iterator it =
410      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
411  {
[134]412    if ((it->first != "label") &&
[98]413        (it->first != "arrow_pos_x") &&
414        (it->first != "arrow_pos_y"))
[53]415    {
416      delete it->second;
417      edgemap_storage.erase(it);
418    }
419  }
[63]420  for (std::map<std::string, double>::iterator it =
421      nodemap_default.begin(); it != nodemap_default.end(); ++it)
422  {
[134]423    if (it->first != "label")
[64]424      nodemap_default.erase(it);
[63]425  }
426  for (std::map<std::string, double>::iterator it =
427      edgemap_default.begin(); it != edgemap_default.end(); ++it)
428  {
[134]429    if (it->first != "label")
[64]430      edgemap_default.erase(it);
[63]431  }
[53]432  graph.clear();
433  file_name = "";
434  modified = false;
435}
[98]436
437void MapStorage::ArrowPosReadOK()
438{
439  arrow_pos_read_ok = true;
440}
[111]441
442void MapStorage::mapChanged(bool itisedge, std::string mapname)
443{
444  if(itisedge)
445    {
446      for(int i=0;i<EDGE_PROPERTY_NUM;i++)
447        {
448          if(active_edgemaps[i]==mapname)
449            {
450              signal_prop.emit(itisedge, i);
451            }
452        }
453    }
454  else
455    {
456      for(int i=0;i<NODE_PROPERTY_NUM;i++)
457        {
458          if(active_nodemaps[i]==mapname)
459            {
460              signal_prop.emit(itisedge, i);
461            }
462        }
463    }
464}
Note: See TracBrowser for help on using the repository browser.