COIN-OR::LEMON - Graph Library

source: lemon-0.x/gui/mapstorage.cc @ 1884:9c061834b33b

Last change on this file since 1884:9c061834b33b was 1881:f40cdc2057c2, checked in by Hegyi Péter, 14 years ago

Result of KruskalGUIAlgo is refreshed if displayed, but no more setin a forced way.

File size: 10.8 KB
Line 
1#include "mapstorage.h"
2#include "gui_writer.h"
3#include "gui_reader.h"
4#include <gtkmm.h>
5#include <cmath>
6
7#include <cmath>
8
9MapStorage::MapStorage() : modified(false), file_name(""), arrow_pos_read_ok(false)
10{
11  nodemap_storage["coordinates_x"] = new Graph::NodeMap<double>(graph);
12  coords.setXMap(*nodemap_storage["coordinates_x"]);
13  nodemap_storage["coordinates_y"] = new Graph::NodeMap<double>(graph);
14  coords.setYMap(*nodemap_storage["coordinates_y"]);
15
16  edgemap_storage["arrow_pos_x"] = new Graph::EdgeMap<double>(graph);
17  arrow_pos.setXMap(*edgemap_storage["arrow_pos_x"]);
18  edgemap_storage["arrow_pos_y"] = new Graph::EdgeMap<double>(graph);
19  arrow_pos.setYMap(*edgemap_storage["arrow_pos_y"]);
20
21  nodemap_storage["id"] = new Graph::NodeMap<double>(graph);
22  edgemap_storage["id"] = new Graph::EdgeMap<double>(graph);
23
24  nodemap_default["id"] = 1.0;
25  edgemap_default["id"] = 1.0;
26
27  active_nodemaps.resize(NODE_PROPERTY_NUM);
28  for(int i=0;i<NODE_PROPERTY_NUM;i++)
29    {
30      active_nodemaps[i]="";
31    }
32
33  active_edgemaps.resize(EDGE_PROPERTY_NUM);
34  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
35    {
36      active_edgemaps[i]="";
37    }
38}
39
40MapStorage::~MapStorage()
41{
42  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
43      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
44  {
45    delete it->second;
46  }
47  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
48      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
49  {
50    delete it->second;
51  }
52}
53
54int MapStorage::addNodeMap(const std::string & name, Graph::NodeMap<double> *nodemap, double default_value = 0.0)
55{
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
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
125int MapStorage::addEdgeMap(const std::string & name, Graph::EdgeMap<double> *edgemap, double default_value = 0.0)
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
140double 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
153double 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
166double 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
188double 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
210int 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 == "id")
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 == "id")
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    }
279    GuiReader gui_reader(greader, this);
280    greader.run();
281  } catch (Exception& error) {
282    Gtk::MessageDialog mdialog(error.what());
283    mdialog.run();
284    clear();
285    return 1;
286  }
287
288  if (!read_edge_id)
289  {
290    edgemap_storage["id"] = new Graph::EdgeMap<double>(graph);
291    int i = 1;
292    for (EdgeIt e(graph); e != INVALID; ++e)
293    {
294      (*edgemap_storage["id"])[e] = i++;
295    }
296  }
297
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    {
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));
312      i++;
313    }
314  }
315
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
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  {
329    if ((it->first != "id") &&
330        (it->first != "coordiantes_x") &&
331        (it->first != "coordinates_y"))
332    {
333      nodemap_default[it->first] = 0.0;
334    }
335    else if (it->first == "id")
336    {
337      NodeIt n(graph);
338      double max = (*nodemap_storage["id"])[n];
339      for (; n != INVALID; ++n)
340      {
341        if ((*nodemap_storage["id"])[n] > max)
342          max = (*nodemap_storage["id"])[n];
343      }
344      nodemap_default["id"] = max + 1.0;
345    }
346  }
347  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
348      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
349  {
350    if (it->first != "id")
351    {
352      edgemap_default[it->first] = 0.0;
353    }
354    else
355    {
356      double max = std::numeric_limits<double>::min();
357      for (EdgeIt e(graph); e != INVALID; ++e)
358      {
359        if ((*edgemap_storage["id"])[e] > max)
360          max = (*edgemap_storage["id"])[e];
361      }
362      if (max > std::numeric_limits<double>::min())
363        edgemap_default["id"] = max + 1.0;
364      else
365        edgemap_default["id"] = 1.0;
366    }
367  }
368
369  return 0;
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  {
384    if ((it->first != "arrow_pos_x") &&
385        (it->first != "arrow_pos_y"))
386    {
387      gwriter.writeEdgeMap(it->first, *(it->second));
388    }
389  }
390
391  GuiWriter gui_writer(gwriter, this);
392
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") &&
403        (it->first != "id"))
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  {
412    if ((it->first != "id") &&
413        (it->first != "arrow_pos_x") &&
414        (it->first != "arrow_pos_y"))
415    {
416      delete it->second;
417      edgemap_storage.erase(it);
418    }
419  }
420  for (std::map<std::string, double>::iterator it =
421      nodemap_default.begin(); it != nodemap_default.end(); ++it)
422  {
423    if (it->first != "id")
424      nodemap_default.erase(it);
425  }
426  for (std::map<std::string, double>::iterator it =
427      edgemap_default.begin(); it != edgemap_default.end(); ++it)
428  {
429    if (it->first != "id")
430      edgemap_default.erase(it);
431  }
432  graph.clear();
433  file_name = "";
434  modified = false;
435}
436
437void MapStorage::ArrowPosReadOK()
438{
439  arrow_pos_read_ok = true;
440}
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.