COIN-OR::LEMON - Graph Library

source: lemon-0.x/gui/mapstorage.cc @ 2071:00c4ce4f4170

Last change on this file since 2071:00c4ce4f4170 was 2065:780e27579198, checked in by Akos Ladanyi, 14 years ago

filter loop edges

File size: 11.3 KB
Line 
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
8MapStorage::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
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}
52
53int 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
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)
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 == "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
387void 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
411void 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
452void MapStorage::ArrowPosReadOK()
453{
454  arrow_pos_read_ok = true;
455}
456
457void 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}
Note: See TracBrowser for help on using the repository browser.