COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

source: glemon/mapstorage.cc @ 2:fdb8a163000f

Last change on this file since 2:fdb8a163000f was 1:67188bd752db, checked in by Peter Hegyi <hegyi@…>, 16 years ago

SVN revision 3500 made compilable with Lemon 1.0.
File size: 40.0 KB
Line 
1/* -*- C++ -*-
2 *
3 * This file is a part of LEMON, a generic C++ optimization library
4 *
5 * Copyright (C) 2003-2006
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 *
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all cop       ies. For
11 * precise terms see the accompanying LICENSE file.
12 *
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
15 * purpose.
16 *
17 */
18
19#include "i18n.h"
20#include <limits>
21#include <cmath>
22#include <iostream>
23#include <fstream>
24#include <string>
25#include <algorithm>
26#include <gtkmm.h>
27#include "file_import_dialog.h"
28#include <mapstorage.h>
29#include <gui_writer.h>
30#include <gui_reader.h>
31#include <lemon/graph_to_eps.h>
32#include <lemon/lgf_reader.h>
33#include <lemon/lgf_writer.h>
34
35const int i_d=20;
36const double a_d=0.05;
37const double p_d=40000;
38
39MapStorage::MapStorage() :
40  gui_sect_save_dest(LGF_FILE),
41  node_coords_save_dest(SpecMapSaveOpts::GUI_SECT),
42  arrow_coords_save_dest(SpecMapSaveOpts::GUI_SECT),
43  modified(false),
44  file_name(""),
45  max_node_label(0),
46  max_arc_label(0),
47  node_coords_one_map_name("coord"),
48  node_coords_two_maps_1_name("coord_x"),
49  node_coords_two_maps_2_name("coord_y"),
50  arrow_coords_one_map_name("arrow"),
51  arrow_coords_two_maps_1_name("arrow_x"),
52  arrow_coords_two_maps_2_name("arrow_y"),
53  iterations(i_d),
54  attraction(a_d),
55  propulsation(p_d),
56  node_coords_x(digraph),
57  node_coords_y(digraph),
58  arrow_coords_x(digraph),
59  arrow_coords_y(digraph),
60  node_label(digraph),
61  arc_label(digraph),
62  background_set(false)
63{
64  node_coords.setXMap(node_coords_x);
65  node_coords.setYMap(node_coords_y);
66  arrow_coords.setXMap(arrow_coords_x);
67  arrow_coords.setYMap(arrow_coords_y);
68
69  active_nodemaps.resize(NODE_PROPERTY_NUM);
70  for(int i=0;i<NODE_PROPERTY_NUM;i++)
71    {
72      active_nodemaps[i]="";
73    }
74
75  active_arcmaps.resize(EDGE_PROPERTY_NUM);
76  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
77    {
78      active_arcmaps[i]="";
79    }
80}
81
82MapStorage::~MapStorage()
83{
84  clear();
85}
86
87void MapStorage::createNodeMap(const std::string& name, MapValue::Type type,
88    MapValue def_val)
89{
90  NodeMapStore::const_iterator it = nodemaps.find(name);
91  if (it != nodemaps.end())
92    throw Error("Node map " + name + " already exists.");
93
94  switch (type)
95  {
96    case MapValue::NUMERIC:
97      nodemaps[name] = new NumericNodeMapData(digraph, def_val);
98      break;
99    case MapValue::STRING:
100      nodemaps[name] = new StringNodeMapData(digraph, def_val);
101      break;
102  }
103
104  nodemaps[name]->default_value = def_val;
105
106  signal_node_map.emit(name, type);
107}
108
109void MapStorage::createArcMap(const std::string& name, MapValue::Type type,
110    MapValue def_val)
111{
112  ArcMapStore::const_iterator it = arcmaps.find(name);
113  if (it != arcmaps.end())
114    throw Error("Arc map " + name + " already exists.");
115
116  switch (type)
117  {
118    case MapValue::NUMERIC:
119      arcmaps[name] = new NumericArcMapData(digraph, def_val);
120      break;
121    case MapValue::STRING:
122      arcmaps[name] = new StringArcMapData(digraph, def_val);
123      break;
124  }
125
126  arcmaps[name]->default_value = def_val;
127
128  signal_arc_map.emit(name, type);
129}
130
131void MapStorage::changeActiveMap(bool itisarc, int prop, std::string mapname)
132{
133  if(itisarc)
134    {
135      active_arcmaps[prop]=mapname;
136    }
137  else
138    {
139      active_nodemaps[prop]=mapname;
140    }
141  signal_prop.emit(itisarc, prop);
142}
143
144void MapStorage::broadcastActiveMaps()
145{
146  for(int i=0;i<NODE_PROPERTY_NUM;i++)
147    {
148      signal_map_win.emit(false, i, active_nodemaps[i]);
149    }
150 
151  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
152    {
153      signal_map_win.emit(true, i, active_arcmaps[i]);
154    }
155}
156
157std::string MapStorage::getActiveArcMap(int prop)
158{
159  return active_arcmaps[prop];
160}
161
162std::string MapStorage::getActiveNodeMap(int prop)
163{
164  return active_nodemaps[prop];
165}
166
167std::vector<std::string> MapStorage::getArcMapList(MapType type)
168{
169  if (type == ALL)
170  {
171    std::vector<std::string> ret;
172    for (ArcMapStore::const_iterator it = arcmaps.begin();
173        it != arcmaps.end(); ++it)
174    {
175      ret.push_back(it->first);
176    }
177    return ret;
178  }
179  else
180  {
181    std::vector<std::string> ret;
182    for (ArcMapStore::const_iterator it = arcmaps.begin();
183        it != arcmaps.end(); ++it)
184    {
185      ArcMapData* data = getArcMapData(it->first);
186      MapValue::Type t = data->type();
187      if ((t == MapValue::NUMERIC && (type & NUM)) ||
188          (t == MapValue::STRING && (type & STR)))
189      {
190        ret.push_back(it->first);
191      }
192    }
193    return ret;
194  }
195}
196
197std::vector<std::string> MapStorage::getNodeMapList(MapType type)
198{
199  if (type == ALL)
200  {
201    std::vector<std::string> ret;
202    for (NodeMapStore::const_iterator it = nodemaps.begin();
203        it != nodemaps.end(); ++it)
204    {
205      ret.push_back(it->first);
206    }
207    return ret;
208  }
209  else
210  {
211    std::vector<std::string> ret;
212    for (NodeMapStore::const_iterator it = nodemaps.begin();
213        it != nodemaps.end(); ++it)
214    {
215      NodeMapData* data = getNodeMapData(it->first);
216      MapValue::Type t = data->type();
217      if ((t == MapValue::NUMERIC && (type & NUM)) ||
218          (t == MapValue::STRING && (type & STR)))
219      {
220        ret.push_back(it->first);
221      }
222    }
223    return ret;
224  }
225}
226
227sigc::signal<void, bool, int> MapStorage::signal_prop_ch()
228{
229  return signal_prop;
230}
231
232int MapStorage::readFromFile(const std::string &filename)
233{
234  using std::vector;
235  using std::map;
236  using std::string;
237
238  //reading content of file
239  LgfContents content(filename);
240  try
241    {
242      content.run();
243    }
244  catch (Exception& error)
245    {
246      Gtk::MessageDialog mdialog(error.what());
247      mdialog.run();
248      clear();
249      return 1;
250    }
251
252  // check whether the .conf file exists
253  bool gui_data_in_conf = g_file_test((filename + ".conf").c_str(),
254      (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR));
255
256  // check whether the .lgf file contains a gui section
257  bool gui_data_in_lgf = false;
258  {
259    for(int i=0;i<content.extraSectionNum();i++)
260      {
261        if(content.extraSection(i)=="gui")
262          {
263            gui_data_in_lgf = true;
264          }
265      }
266  }
267
268  bool gui_data_found = gui_data_in_lgf || gui_data_in_conf;
269
270  // ask for user input if both exist
271  bool use_gui_data_in_lgf = false;
272  if (gui_data_in_conf && gui_data_in_lgf)
273  {
274    Gtk::MessageDialog mdialog(_("<b>Found both ") + filename +
275        _(".conf and a gui section in ") + filename + _(".</b>"), true,
276        Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE);
277          mdialog.add_button(_("Use the ._conf file"), 1);
278          mdialog.add_button(_("Use the _gui section"), 2);
279    switch (mdialog.run())
280    {
281      case 1:
282        use_gui_data_in_lgf = false;
283        break;
284      case 2:
285        use_gui_data_in_lgf = true;
286        break;
287      case Gtk::RESPONSE_NONE:
288        return 1;
289    }
290  }
291  else
292  {
293    use_gui_data_in_lgf = gui_data_in_lgf;
294  }
295
296  if (gui_data_found)
297  {
298    GUISectData gui_data;
299    if (use_gui_data_in_lgf)
300    {
301      // read the gui section from the .lgf file
302      try
303      {
304        sectionReader(filename).sectionStream("gui", GuiReader(this, gui_data)).run();
305        gui_sect_save_dest = LGF_FILE;
306      }
307      catch (Exception& error)
308      {
309        clear();
310        return 1;
311      }
312    }
313    else
314    {
315      // read the gui section from the .conf file
316      try
317      {
318        sectionReader(filename + ".conf").sectionStream("gui", GuiReader(this, gui_data)).run();
319        gui_sect_save_dest = CONF_FILE;
320      }
321      catch (Exception& error)
322      {
323        clear();
324        return 1;
325      }
326    }
327
328    // read the digraph and maps form the .lgf file
329    try
330    {
331      std::string node_coord_xmap_name, node_coord_ymap_name;
332      std::string arrow_coord_xmap_name, arrow_coord_ymap_name;
333
334      if (gui_data.node_coords_save_dest ==
335          MapStorage::SpecMapSaveOpts::NESET_SECT)
336      {
337        switch (gui_data.node_coords_save_map_num)
338        {
339          case SpecMapSaveOpts::ONE_MAP:
340            node_coord_xmap_name = gui_data.node_coords_one_map_name + ":x";
341            node_coord_ymap_name = gui_data.node_coords_one_map_name + ":y";
342            node_coords_one_map_name = gui_data.node_coords_one_map_name;
343            break;
344          case SpecMapSaveOpts::TWO_MAPS:
345            node_coord_xmap_name = gui_data.node_coords_two_maps_1_name;
346            node_coord_ymap_name = gui_data.node_coords_two_maps_2_name;
347            node_coords_two_maps_1_name = gui_data.node_coords_two_maps_1_name;
348            node_coords_two_maps_2_name = gui_data.node_coords_two_maps_2_name;
349            break;
350        }
351        node_coords_save_dest = gui_data.node_coords_save_dest;
352        node_coords_save_map_num = gui_data.node_coords_save_map_num;
353      }
354
355      if (gui_data.arrow_coords_save_dest ==
356          MapStorage::SpecMapSaveOpts::NESET_SECT)
357      {
358        switch (gui_data.arrow_coords_save_map_num)
359        {
360          case SpecMapSaveOpts::ONE_MAP:
361            arrow_coord_xmap_name = gui_data.arrow_coords_one_map_name + ":x";
362            arrow_coord_ymap_name = gui_data.arrow_coords_one_map_name + ":y";
363            arrow_coords_one_map_name = gui_data.arrow_coords_one_map_name;
364            break;
365          case SpecMapSaveOpts::TWO_MAPS:
366            arrow_coord_xmap_name = gui_data.arrow_coords_two_maps_1_name;
367            arrow_coord_ymap_name = gui_data.arrow_coords_two_maps_2_name;
368            arrow_coords_two_maps_1_name =
369              gui_data.arrow_coords_two_maps_1_name;
370            arrow_coords_two_maps_2_name =
371              gui_data.arrow_coords_two_maps_2_name;
372            break;
373        }
374        arrow_coords_save_dest = gui_data.arrow_coords_save_dest;
375        arrow_coords_save_map_num = gui_data.arrow_coords_save_map_num;
376      }
377      readLGF(filename, true,
378          gui_data.main_node_map_names, gui_data.main_arc_map_names,
379          gui_data.node_map_types, gui_data.arc_map_types,
380          node_coord_xmap_name, node_coord_ymap_name,
381          arrow_coord_xmap_name, arrow_coord_ymap_name);
382    }
383    catch (Exception& error)
384    {
385      clear();
386      return 1;
387    }
388
389    // add the maps from the gui section
390    for (vector<string>::const_iterator
391        it = gui_data.gui_node_map_names.begin();
392        it != gui_data.gui_node_map_names.end(); ++it)
393    {
394      string map_name = *it;
395      switch (gui_data.node_map_types[map_name])
396      {
397        case MapValue::NUMERIC:
398          {
399            createNodeMap(map_name, MapValue::NUMERIC, double());
400            NumericNodeMap& dmap = getNumericNodeMap(map_name);
401            map<int, double>& smap = *gui_data.numeric_node_maps[map_name];
402            for (NodeIt n(digraph); n != INVALID; ++n)
403            {
404              dmap[n] = smap[node_label[n]];
405            }
406            break;
407          }
408        case MapValue::STRING:
409          {
410            createNodeMap(map_name, MapValue::STRING, string());
411            StringNodeMap& dmap = getStringNodeMap(map_name);
412            map<int, string>& smap = *gui_data.string_node_maps[map_name];
413            for (NodeIt n(digraph); n != INVALID; ++n)
414            {
415              dmap[n] = smap[node_label[n]];
416            }
417            break;
418          }
419      }
420      getNodeMapData(map_name)->save_dest = GUI_SECT;
421    }
422    for (vector<string>::const_iterator
423        it = gui_data.gui_arc_map_names.begin();
424        it != gui_data.gui_arc_map_names.end(); ++it)
425    {
426      string map_name = *it;
427      switch (gui_data.arc_map_types[map_name])
428      {
429        case MapValue::NUMERIC:
430          {
431            createArcMap(map_name, MapValue::NUMERIC, double());
432            NumericArcMap& dmap = getNumericArcMap(map_name);
433            map<int, double>& smap = *gui_data.numeric_arc_maps[map_name];
434            for (ArcIt e(digraph); e != INVALID; ++e)
435            {
436              dmap[e] = smap[arc_label[e]];
437            }
438            break;
439          }
440        case MapValue::STRING:
441          {
442            createArcMap(map_name, MapValue::STRING, string());
443            StringArcMap& dmap = getStringArcMap(map_name);
444            map<int, string>& smap = *gui_data.string_arc_maps[map_name];
445            for (ArcIt e(digraph); e != INVALID; ++e)
446            {
447              dmap[e] = smap[arc_label[e]];
448            }
449            break;
450          }
451      }
452      getArcMapData(map_name)->save_dest = GUI_SECT;
453    }
454
455    // restore the node coordinate maps
456    if (gui_data.node_coords_save_dest ==
457        MapStorage::SpecMapSaveOpts::GUI_SECT)
458    {
459      for (NodeIt n(digraph); n != INVALID; ++n)
460      {
461        node_coords.set(n, gui_data.node_coord_map[node_label[n]]);
462      }
463      node_coords_save_dest = gui_data.node_coords_save_dest;
464    }
465    // restore the arrow coordinate maps
466    if (gui_data.arrow_coords_save_dest ==
467        MapStorage::SpecMapSaveOpts::GUI_SECT)
468    {
469      for (ArcIt e(digraph); e != INVALID; ++e)
470      {
471        arrow_coords.set(e, gui_data.arrow_coord_map[arc_label[e]]);
472      }
473      arrow_coords_save_dest = gui_data.arrow_coords_save_dest;
474    }
475  }
476  else
477  {
478    // there is no gui section neither in the .lgf file nor in the .conf file
479    {
480      if (content.nodeSectionNum() < 1)
481      {
482        Gtk::MessageDialog mdialog("No nodeset found in file.");
483        mdialog.run();
484        clear();
485        return 1;
486      }
487
488      if (content.arcSectionNum() < 1)
489      {
490        Gtk::MessageDialog mdialog("No arcset found in file.");
491        mdialog.run();
492        clear();
493        return 1;
494      }
495
496      std::vector<std::string> nodeMapNames = content.nodeMapNames(0);
497      std::vector<std::string> arcMapNames = content.arcMapNames(0);
498     
499      bool read_arc_label = true;
500      if (std::find(arcMapNames.begin(), arcMapNames.end(), "label") ==
501          arcMapNames.end())
502      {
503        read_arc_label = false;
504      }
505
506      nodeMapNames.erase(
507          std::remove(nodeMapNames.begin(), nodeMapNames.end(), "label"),
508          nodeMapNames.end());
509
510      arcMapNames.erase(
511          std::remove(arcMapNames.begin(), arcMapNames.end(), "label"),
512          arcMapNames.end());
513
514      FileImportDialog::ImportData data(nodeMapNames, arcMapNames);
515      FileImportDialog fidialog(&data);
516      int response = fidialog.run();
517      if (response == Gtk::RESPONSE_OK)
518      {
519        try
520        {
521          std::string node_coord_xmap_name, node_coord_ymap_name;
522          std::string arrow_coord_xmap_name, arrow_coord_ymap_name;
523          bool gen_node_coords = false;
524          bool gen_arrow_coords = false;
525
526          switch (data.node_coord_load_from)
527          {
528            case FileImportDialog::ImportData::ONE_MAP:
529              node_coord_xmap_name = data.node_coord_one_map_name + ":x";
530              node_coord_ymap_name = data.node_coord_one_map_name + ":y";
531              node_coords_one_map_name = data.node_coord_one_map_name;
532
533              node_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
534              node_coords_save_map_num = SpecMapSaveOpts::ONE_MAP;
535              break;
536            case FileImportDialog::ImportData::TWO_MAPS:
537              node_coord_xmap_name = data.node_coord_two_maps_1_name;
538              node_coord_ymap_name = data.node_coord_two_maps_2_name;
539              node_coords_two_maps_1_name = data.node_coord_two_maps_1_name;
540              node_coords_two_maps_2_name = data.node_coord_two_maps_2_name;
541
542              node_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
543              node_coords_save_map_num = SpecMapSaveOpts::TWO_MAPS;
544              break;
545            case FileImportDialog::ImportData::DONT_READ:
546              node_coord_xmap_name = "";
547              node_coord_ymap_name = "";
548
549              node_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
550              gen_node_coords = true;
551              break;
552          }
553
554          switch (data.arrow_coord_load_from)
555          {
556            case FileImportDialog::ImportData::ONE_MAP:
557              arrow_coord_xmap_name = data.arrow_coord_one_map_name + ":x";
558              arrow_coord_ymap_name = data.arrow_coord_one_map_name + ":y";
559              arrow_coords_one_map_name = data.arrow_coord_one_map_name;
560
561              arrow_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
562              arrow_coords_save_map_num = SpecMapSaveOpts::ONE_MAP;
563              break;
564            case FileImportDialog::ImportData::TWO_MAPS:
565              arrow_coord_xmap_name = data.arrow_coord_two_maps_1_name;
566              arrow_coord_ymap_name = data.arrow_coord_two_maps_2_name;
567              arrow_coords_two_maps_1_name = data.arrow_coord_two_maps_1_name;
568              arrow_coords_two_maps_2_name = data.arrow_coord_two_maps_2_name;
569
570              arrow_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
571              arrow_coords_save_map_num = SpecMapSaveOpts::TWO_MAPS;
572              break;
573            case FileImportDialog::ImportData::DONT_READ:
574              arrow_coord_xmap_name = "";
575              arrow_coord_ymap_name = "";
576
577              arrow_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
578              gen_arrow_coords = true;
579              break;
580          }
581
582          // read arc and node maps
583          std::vector<std::string> node_map_names;
584          std::vector<std::string> arc_map_names;
585          std::map<std::string, MapValue::Type> node_map_types;
586          std::map<std::string, MapValue::Type> arc_map_types;
587          for (std::vector<std::string>::const_iterator it =
588              data.numeric_node_map_names.begin();
589              it != data.numeric_node_map_names.end(); ++it)
590          {
591            node_map_names.push_back(*it);
592            node_map_types[*it] = MapValue::NUMERIC;
593          }
594          for (std::vector<std::string>::const_iterator it =
595              data.string_node_map_names.begin();
596              it != data.string_node_map_names.end(); ++it)
597          {
598            node_map_names.push_back(*it);
599            node_map_types[*it] = MapValue::STRING;
600          }
601          for (std::vector<std::string>::const_iterator it =
602              data.numeric_arc_map_names.begin();
603              it != data.numeric_arc_map_names.end(); ++it)
604          {
605            arc_map_names.push_back(*it);
606            arc_map_types[*it] = MapValue::NUMERIC;
607          }
608          for (std::vector<std::string>::const_iterator it =
609              data.string_arc_map_names.begin();
610              it != data.string_arc_map_names.end(); ++it)
611          {
612            arc_map_names.push_back(*it);
613            arc_map_types[*it] = MapValue::STRING;
614          }
615
616          readLGF(filename, read_arc_label,
617              node_map_names, arc_map_names,
618              node_map_types, arc_map_types,
619              node_coord_xmap_name, node_coord_ymap_name,
620              arrow_coord_xmap_name, arrow_coord_ymap_name);
621
622          // generate arc labels
623          if (!read_arc_label)
624          {
625            int l = 0;
626            for (ArcIt e(digraph); e != INVALID; ++e)
627            {
628              arc_label[e] = l++;
629            }
630          }
631
632          if (gen_node_coords)
633          {
634            // generate node coordinates
635            int node_num = 0;
636            for (NodeIt n(digraph); n != INVALID; ++n) { node_num++; }
637            const double pi = 3.142;
638            double step = 2 * pi / (double) node_num;
639            int i = 0;
640            for (NodeIt n(digraph); n != INVALID; ++n)
641            {
642              setNodeCoords(n,
643                  XY(250.0 * std::cos(i * step),
644                    250.0 * std::sin(i * step)));
645              i++;
646            }
647          }
648          if (gen_arrow_coords)
649          {
650            // generate arrow coordinates
651            for (ArcIt e(digraph); e != INVALID; ++e)
652            {
653              if (digraph.source(e) == digraph.target(e))
654              {
655                setArrowCoords(e,
656                    getNodeCoords(digraph.source(e)) + XY(0.0, 80.0));
657              }
658              else
659              {
660                setArrowCoords(e,
661                    (getNodeCoords(digraph.source(e)) +
662                     getNodeCoords(digraph.target(e))) / 2.0);
663              }
664            }
665          }
666        }
667        catch (Exception& error)
668        {
669          clear();
670          return 1;
671        }
672      }
673      else
674      {
675        clear();
676        return 1;
677      }
678    }
679  }
680
681  // set max_node_label
682  {
683    max_node_label = std::numeric_limits<int>::min();
684    for (NodeIt n(digraph); n != INVALID; ++n)
685    {
686      if (node_label[n] > max_node_label)
687      {
688        max_node_label = node_label[n];
689      }
690    }
691  }
692  // set max_arc_label
693  {
694    max_arc_label = std::numeric_limits<int>::min();
695    for (ArcIt e(digraph); e != INVALID; ++e)
696    {
697      if (arc_label[e] > max_arc_label)
698      {
699        max_arc_label = arc_label[e];
700      }
701    }
702  }
703
704  return 0;
705}
706
707void MapStorage::writeToFile(const std::string &filename)
708{
709  // relabel nodes and arcs
710  int i = 0;
711  for (NodeIt n(digraph); n != INVALID; ++n)
712  {
713    node_label[n] = i++;
714  }
715  max_node_label = i-1;
716  i = 0;
717  for (ArcIt e(digraph); e != INVALID; ++e)
718  {
719    arc_label[e] = i++;
720  }
721  max_arc_label = i-1;
722
723  // write .lgf file
724  {
725    DigraphWriter<Digraph> gwriter(filename, digraph);
726
727    gwriter.nodeMap("label", node_label);
728    gwriter.arcMap("label", arc_label);
729
730    // write node maps
731    for (NodeMapStore::const_iterator it = nodemaps.begin();
732        it != nodemaps.end(); ++it)
733    {
734      if (it->second->save_dest == NESET_SECT)
735      {
736        switch (it->second->type())
737        {
738          case MapValue::NUMERIC:
739            gwriter.nodeMap(it->first, getNumericNodeMap(it->first));
740            break;
741          case MapValue::STRING:
742            gwriter.nodeMap(it->first, getStringNodeMap(it->first));
743            break;
744        }
745      }
746    }
747
748    // write arc maps
749    for (ArcMapStore::const_iterator it = arcmaps.begin();
750        it != arcmaps.end(); ++it)
751    {
752      if (it->second->save_dest == NESET_SECT)
753      {
754        switch (it->second->type())
755        {
756          case MapValue::NUMERIC:
757            gwriter.arcMap(it->first, getNumericArcMap(it->first));
758            break;
759          case MapValue::STRING:
760            gwriter.arcMap(it->first, getStringArcMap(it->first));
761            break;
762        }
763      }
764    }
765
766    // write node coordinates
767    switch (getNodeCoordsSaveDest())
768    {
769      case MapStorage::SpecMapSaveOpts::GUI_SECT:
770        break;
771      case MapStorage::SpecMapSaveOpts::NESET_SECT:
772        switch (getNodeCoordsSaveMapNum())
773        {
774          case MapStorage::SpecMapSaveOpts::ONE_MAP:
775            gwriter.nodeMap(node_coords_one_map_name + ":x",
776                node_coords_x);
777            gwriter.nodeMap(node_coords_one_map_name + ":y",
778                node_coords_y);
779            break;
780          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
781            gwriter.nodeMap(node_coords_two_maps_1_name,
782                node_coords_x);
783            gwriter.nodeMap(node_coords_two_maps_2_name,
784                node_coords_y);
785            break;
786        }
787        break;
788    }
789
790    // write arrow coordinates
791    switch (getArrowCoordsSaveDest())
792    {
793      case MapStorage::SpecMapSaveOpts::GUI_SECT:
794        break;
795      case MapStorage::SpecMapSaveOpts::NESET_SECT:
796        switch (getArrowCoordsSaveMapNum())
797        {
798          case MapStorage::SpecMapSaveOpts::ONE_MAP:
799            gwriter.arcMap(arrow_coords_one_map_name + ":x",
800                arrow_coords_x);
801            gwriter.arcMap(arrow_coords_one_map_name + ":y",
802                arrow_coords_y);
803            break;
804          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
805            gwriter.arcMap(arrow_coords_two_maps_1_name,
806                arrow_coords_x);
807            gwriter.arcMap(arrow_coords_two_maps_2_name,
808                arrow_coords_y);
809            break;
810        }
811        break;
812    }
813
814    if (gui_sect_save_dest == LGF_FILE)
815    {
816      GuiWriter gui_writer(this);
817      gui_writer.write(gwriter.ostream());
818      gwriter.run();
819    }
820    else
821    {
822      gwriter.run();
823    }
824  }
825
826  // write .conf file
827  if (gui_sect_save_dest == CONF_FILE)
828  {
829    DigraphWriter<Digraph> lwriter(filename + ".conf", digraph);
830    GuiWriter gui_writer(this);
831    gui_writer.write(lwriter.ostream());
832    lwriter.run();
833  }
834}
835
836void MapStorage::clear()
837{
838  for (NodeMapStore::iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
839  {
840    delete it->second;
841    nodemaps.erase(it);
842  }
843  for (ArcMapStore::iterator it = arcmaps.begin(); it != arcmaps.end(); ++it)
844  {
845    delete it->second;
846    arcmaps.erase(it);
847  }
848  digraph.clear();
849  file_name = "";
850  modified = false;
851  max_node_label = 0;
852  max_arc_label = 0;
853  background_set = false;
854
855  gui_sect_save_dest = LGF_FILE;
856  node_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
857  arrow_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
858  node_coords_one_map_name = "coord";
859  node_coords_two_maps_1_name = "coord_x";
860  node_coords_two_maps_2_name = "coord_y";
861  arrow_coords_one_map_name = "arrow";
862  arrow_coords_two_maps_1_name = "arrow_x";
863  arrow_coords_two_maps_2_name = "arrow_y";
864
865  for(int i=0;i<NODE_PROPERTY_NUM;i++)
866    {
867      changeActiveMap(false, i, "");
868      signal_map_win.emit(false, i, "");
869    }
870 
871  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
872    {
873      changeActiveMap(true, i, "");
874      signal_map_win.emit(true, i, "");
875    }
876
877  attraction=a_d;
878  propulsation=p_d;
879  iterations=i_d;
880
881  signal_design_win.emit(attraction, propulsation, iterations);
882}
883
884void MapStorage::mapChanged(bool itisarc, std::string mapname)
885{
886  if(itisarc)
887  {
888    for(int i=0;i<EDGE_PROPERTY_NUM;i++)
889    {
890      if(active_arcmaps[i]==mapname)
891      {
892        signal_prop.emit(itisarc, i);
893      }
894    }
895  }
896  else
897  {
898    for(int i=0;i<NODE_PROPERTY_NUM;i++)
899    {
900      if(active_nodemaps[i]==mapname)
901      {
902        signal_prop.emit(itisarc, i);
903      }
904    }
905  }
906}
907
908void MapStorage::get_design_data(double & attraction_p, double & propulsation_p, int & iterations_p)
909{
910  attraction_p=attraction;
911  propulsation_p=propulsation;
912  iterations_p=iterations;
913}
914
915void MapStorage::set_attraction(double attraction_p)
916{
917  attraction=attraction_p;
918}
919
920void MapStorage::set_propulsation(double propulsation_p)
921{
922  propulsation=propulsation_p;
923}
924
925void MapStorage::set_iteration(int iterations_p)
926{
927  iterations=iterations_p;
928}
929
930void MapStorage::redesign_data_changed()
931{
932  signal_design_win.emit(attraction, propulsation, iterations);
933}
934
935XY MapStorage::getNodeCoords(Node n) const
936{
937  return node_coords[n];
938}
939
940void MapStorage::setNodeCoords(Node n, XY c)
941{
942  node_coords.set(n, c);
943}
944
945XY MapStorage::getArrowCoords(Arc e) const
946{
947  return arrow_coords[e];
948}
949
950void MapStorage::setArrowCoords(Arc e, XY c)
951{
952  arrow_coords.set(e, c);
953}
954
955MapValue MapStorage::get(const std::string& name, Node node) const
956{
957  NodeMapData* data = getNodeMapData(name);
958  return data->get(node);
959}
960
961void MapStorage::set(const std::string& name, Node node, MapValue val)
962{
963  NodeMapData* data = getNodeMapData(name);
964  data->set(node, val);
965}
966
967MapValue MapStorage::get(const std::string& name, Arc arc) const
968{
969  ArcMapData* data = getArcMapData(name);
970  return data->get(arc);
971}
972
973void MapStorage::set(const std::string& name, Arc arc, MapValue val)
974{
975  ArcMapData* data = getArcMapData(name);
976  data->set(arc, val);
977}
978
979const std::string& MapStorage::getFileName() const
980{
981  return file_name;
982}
983
984void MapStorage::setFileName(const std::string& fn)
985{
986  file_name = fn;
987}
988
989bool MapStorage::getModified() const
990{
991  return modified;
992}
993
994void MapStorage::setModified(bool m)
995{
996  modified = m;
997}
998
999Node MapStorage::addNode(XY coords)
1000{
1001  Node node = digraph.addNode();
1002
1003  setNodeCoords(node, coords);
1004
1005  max_node_label++;
1006
1007  node_label[node] = max_node_label;
1008
1009  std::vector<std::string> node_maps = getNodeMapList();
1010  for (std::vector<std::string>::const_iterator it = node_maps.begin();
1011      it != node_maps.end(); ++it)
1012  {
1013    NodeMapData* data = getNodeMapData(*it);
1014    set(*it, node, data->default_value);
1015  }
1016
1017  return node;
1018}
1019
1020Arc MapStorage::addArc(Node from, Node to)
1021{
1022  Arc arc = digraph.addArc(from, to);
1023
1024  if (from == to)
1025  {
1026    setArrowCoords(arc, getNodeCoords(from) + XY(0.0, 80.0));
1027  }
1028  else
1029  {
1030    setArrowCoords(arc, (getNodeCoords(from) + getNodeCoords(to)) / 2.0);
1031  }
1032
1033  max_arc_label++;
1034
1035  arc_label[arc] = max_arc_label;
1036
1037  std::vector<std::string> arc_maps = getArcMapList();
1038  for (std::vector<std::string>::const_iterator it = arc_maps.begin();
1039      it != arc_maps.end(); ++it)
1040  {
1041    ArcMapData* data = getArcMapData(*it);
1042    set(*it, arc, data->default_value);
1043  }
1044  return arc;
1045}
1046
1047MapStorage::NumericNodeMap& MapStorage::getNumericNodeMap(const std::string& name)
1048{
1049  NodeMapData* data = getNodeMapData(name);
1050  if (data->type() != MapValue::NUMERIC)
1051    throw Error("Numeric node map " + name + " does not exists.");
1052  return static_cast<NumericNodeMapData*>(data)->map;
1053}
1054
1055MapStorage::StringNodeMap& MapStorage::getStringNodeMap(const std::string& name)
1056{
1057  NodeMapData* data = getNodeMapData(name);
1058  if (data->type() != MapValue::STRING)
1059    throw Error("String node map " + name + " does not exists.");
1060  return static_cast<StringNodeMapData*>(data)->map;
1061}
1062
1063MapStorage::NumericArcMap& MapStorage::getNumericArcMap(const std::string& name)
1064{
1065  ArcMapData* data = getArcMapData(name);
1066  if (data->type() != MapValue::NUMERIC)
1067    throw Error("Numeric arc map " + name + " does not exists.");
1068  return static_cast<NumericArcMapData*>(data)->map;
1069}
1070
1071MapStorage::StringArcMap& MapStorage::getStringArcMap(const std::string& name)
1072{
1073  ArcMapData* data = getArcMapData(name);
1074  if (data->type() != MapValue::STRING)
1075    throw Error("String arc map " + name + " does not exists.");
1076  return static_cast<StringArcMapData*>(data)->map;
1077}
1078
1079MapValueArcMap MapStorage::getArcMap(const std::string& name)
1080{
1081  return MapValueArcMap(name, this);
1082}
1083
1084MapValueNodeMap MapStorage::getNodeMap(const std::string& name)
1085{
1086  return MapValueNodeMap(name, this);
1087}
1088
1089int MapStorage::getLabel(Node n) const
1090{
1091  return node_label[n];
1092}
1093
1094int MapStorage::getLabel(Arc e) const
1095{
1096  return arc_label[e];
1097}
1098
1099MapStorage::GuiSectSaveDest MapStorage::getGUIDataSaveLocation()
1100{
1101  return gui_sect_save_dest;
1102}
1103
1104void MapStorage::setGUIDataSaveLocation(MapStorage::GuiSectSaveDest dest)
1105{
1106  gui_sect_save_dest = dest;
1107}
1108
1109MapStorage::MapSaveDest MapStorage::getNodeMapSaveDest(std::string name) const
1110{
1111  NodeMapData *data = getNodeMapData(name);
1112  return data->save_dest;
1113}
1114
1115MapStorage::MapSaveDest MapStorage::getArcMapSaveDest(std::string name) const
1116{
1117  ArcMapData *data = getArcMapData(name);
1118  return data->save_dest;
1119}
1120
1121void MapStorage::setNodeMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
1122{
1123  NodeMapData *data = getNodeMapData(name);
1124  data->save_dest = dest;
1125}
1126
1127void MapStorage::setArcMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
1128{
1129  ArcMapData *data = getArcMapData(name);
1130  data->save_dest = dest;
1131}
1132
1133MapStorage::ArcMapData* MapStorage::getArcMapData(std::string name) const
1134{
1135  ArcMapStore::const_iterator it = arcmaps.find(name);
1136  if (it != arcmaps.end())
1137    return it->second;
1138  else
1139    throw Error("Arc map " + name + " does not exists.");
1140}
1141
1142MapStorage::NodeMapData* MapStorage::getNodeMapData(std::string name) const
1143{
1144  NodeMapStore::const_iterator it = nodemaps.find(name);
1145  if (it != nodemaps.end())
1146    return it->second;
1147  else
1148    throw Error("Node map " + name + " does not exists.");
1149}
1150
1151MapValue::Type MapStorage::getNodeMapElementType(std::string name) const
1152{
1153  NodeMapData *data = getNodeMapData(name);
1154  return data->type();
1155}
1156
1157MapValue::Type MapStorage::getArcMapElementType(std::string name) const
1158{
1159  ArcMapData *data = getArcMapData(name);
1160  return data->type();
1161}
1162
1163const MapStorage::NodeLabelMap& MapStorage::getNodeLabelMap()
1164{
1165  return node_label;
1166}
1167
1168const MapStorage::ArcLabelMap& MapStorage::getArcLabelMap()
1169{
1170  return arc_label;
1171}
1172
1173const Digraph& MapStorage::getDigraph()
1174{
1175  return digraph;
1176}
1177
1178bool MapStorage::nodeMapExists(std::string name)
1179{
1180  NodeMapStore::const_iterator it = nodemaps.find(name);
1181  if (it == nodemaps.end())
1182    return false;
1183  else
1184    return true;
1185}
1186
1187bool MapStorage::arcMapExists(std::string name)
1188{
1189  ArcMapStore::const_iterator it = arcmaps.find(name);
1190  if (it == arcmaps.end())
1191    return false;
1192  else
1193    return true;
1194}
1195
1196std::vector<std::string> MapStorage::getArcMaps(MapType type)
1197{
1198  std::vector<std::string> maps;
1199  for (ArcMapStore::const_iterator it = arcmaps.begin(); it != arcmaps.end(); ++it)
1200  {
1201    if (it->second->type() & type)
1202    {
1203      maps.push_back(it->first);
1204    }
1205  }
1206  return maps;
1207}
1208
1209std::vector<std::string> MapStorage::getNodeMaps(MapType type)
1210{
1211  std::vector<std::string> maps;
1212  for (NodeMapStore::const_iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
1213  {
1214    if (it->second->type() & type)
1215    {
1216      maps.push_back(it->first);
1217    }
1218  }
1219  return maps;
1220}
1221
1222MapStorage::NodeCoordMap& MapStorage::getNodeCoordMap()
1223{
1224  return node_coords;
1225}
1226
1227MapStorage::ArrowCoordMap& MapStorage::getArrowCoordMap()
1228{
1229  return arrow_coords;
1230}
1231
1232MapStorage::SpecMapSaveOpts::Dest MapStorage::getNodeCoordsSaveDest()
1233{
1234  return node_coords_save_dest;
1235}
1236
1237MapStorage::SpecMapSaveOpts::Dest MapStorage::getArrowCoordsSaveDest()
1238{
1239  return arrow_coords_save_dest;
1240}
1241
1242void MapStorage::setNodeCoordsSaveDest(MapStorage::SpecMapSaveOpts::Dest dest)
1243{
1244  node_coords_save_dest = dest;
1245}
1246
1247void MapStorage::setArrowCoordsSaveDest(MapStorage::SpecMapSaveOpts::Dest dest)
1248{
1249  arrow_coords_save_dest = dest;
1250}
1251
1252MapStorage::SpecMapSaveOpts::MapNum MapStorage::getNodeCoordsSaveMapNum()
1253{
1254  return node_coords_save_map_num;
1255}
1256
1257MapStorage::SpecMapSaveOpts::MapNum MapStorage::getArrowCoordsSaveMapNum()
1258{
1259  return arrow_coords_save_map_num;
1260}
1261
1262void MapStorage::setNodeCoordsSaveMapNum(MapStorage::SpecMapSaveOpts::MapNum num)
1263{
1264  node_coords_save_map_num = num;
1265}
1266
1267void MapStorage::setArrowCoordsSaveMapNum(MapStorage::SpecMapSaveOpts::MapNum num)
1268{
1269  arrow_coords_save_map_num = num;
1270}
1271
1272const std::string& MapStorage::getNodeCoordsOneMapName()
1273{
1274  return node_coords_one_map_name;
1275}
1276const std::string& MapStorage::getNodeCoordsTwoMaps1Name()
1277{
1278  return node_coords_two_maps_1_name;
1279}
1280const std::string& MapStorage::getNodeCoordsTwoMaps2Name()
1281{
1282  return node_coords_two_maps_2_name;
1283}
1284
1285void MapStorage::setNodeCoordsOneMapName(const std::string& name)
1286{
1287  node_coords_one_map_name = name;
1288}
1289void MapStorage::setNodeCoordsTwoMaps1Name(const std::string& name)
1290{
1291  node_coords_two_maps_1_name = name;
1292}
1293void MapStorage::setNodeCoordsTwoMaps2Name(const std::string& name)
1294{
1295  node_coords_two_maps_2_name = name;
1296}
1297
1298const std::string& MapStorage::getArrowCoordsOneMapName()
1299{
1300  return arrow_coords_one_map_name;
1301}
1302const std::string& MapStorage::getArrowCoordsTwoMaps1Name()
1303{
1304  return arrow_coords_two_maps_1_name;
1305}
1306const std::string& MapStorage::getArrowCoordsTwoMaps2Name()
1307{
1308  return arrow_coords_two_maps_2_name;
1309}
1310
1311void MapStorage::setArrowCoordsOneMapName(const std::string& name)
1312{
1313  arrow_coords_one_map_name = name;
1314}
1315void MapStorage::setArrowCoordsTwoMaps1Name(const std::string& name)
1316{
1317  arrow_coords_two_maps_1_name = name;
1318}
1319void MapStorage::setArrowCoordsTwoMaps2Name(const std::string& name)
1320{
1321  arrow_coords_two_maps_2_name = name;
1322}
1323
1324void MapStorage::readLGF(
1325    const std::string& filename,
1326    bool read_arc_label,
1327    const std::vector<std::string>& node_map_names,
1328    const std::vector<std::string>& arc_map_names,
1329    const std::map<std::string, MapValue::Type>& node_map_types,
1330    const std::map<std::string, MapValue::Type>& arc_map_types,
1331    const std::string& node_coord_xmap_name,
1332    const std::string& node_coord_ymap_name,
1333    const std::string& arrow_coord_xmap_name,
1334    const std::string& arrow_coord_ymap_name)
1335{
1336  using std::vector;
1337  using std::map;
1338  using std::string;
1339
1340  DigraphReader<Digraph> greader(filename, digraph);
1341
1342  // read the label maps
1343  greader.nodeMap("label", node_label);
1344  if (read_arc_label)
1345    greader.arcMap("label", arc_label);
1346
1347  // read the node maps
1348  for (vector<string>::const_iterator
1349      it = node_map_names.begin();
1350      it != node_map_names.end(); ++it)
1351  {
1352    switch (node_map_types.find(*it)->second)
1353    {
1354      case MapValue::NUMERIC:
1355        {
1356          createNodeMap(*it, MapValue::NUMERIC, double());
1357          greader.nodeMap(*it, getNumericNodeMap(*it));
1358          break;
1359        }
1360      case MapValue::STRING:
1361        {
1362          createNodeMap(*it, MapValue::STRING, string());
1363          greader.nodeMap(*it, getStringNodeMap(*it));
1364          break;
1365        }
1366    }
1367    getNodeMapData(*it)->save_dest = NESET_SECT;
1368  }
1369
1370  // read the arc maps
1371  for (vector<string>::const_iterator
1372      it = arc_map_names.begin();
1373      it != arc_map_names.end(); ++it)
1374  {
1375    switch (arc_map_types.find(*it)->second)
1376    {
1377      case MapValue::NUMERIC:
1378        {
1379          createArcMap(*it, MapValue::NUMERIC, double());
1380          greader.arcMap(*it, getNumericArcMap(*it));
1381          break;
1382        }
1383      case MapValue::STRING:
1384        {
1385          createArcMap(*it, MapValue::STRING, string());
1386          greader.arcMap(*it, getStringArcMap(*it));
1387          break;
1388        }
1389    }
1390    getArcMapData(*it)->save_dest = NESET_SECT;
1391  }
1392
1393  // read the node coordinate maps
1394  if (node_coord_xmap_name != "")
1395    greader.nodeMap(node_coord_xmap_name, node_coords_x);
1396  if (node_coord_ymap_name != "")
1397    greader.nodeMap(node_coord_ymap_name, node_coords_y);
1398
1399  // read the arrow coordinate maps
1400  if (arrow_coord_xmap_name != "")
1401    greader.arcMap(arrow_coord_xmap_name, arrow_coords_x);
1402  if (arrow_coord_ymap_name != "")
1403    greader.arcMap(arrow_coord_ymap_name, arrow_coords_y);
1404
1405  greader.run();
1406}
1407
1408void MapStorage::setBackground(const std::string& file_name)
1409{
1410  if (file_name == background_file_name) return;
1411  if (file_name == "")
1412  {
1413    background_file_name = "";
1414    background_set = false;
1415  }
1416  else
1417  {
1418    background_file_name = file_name;
1419    background_set = true;
1420  }
1421  signal_background.emit();
1422}
1423
1424const std::string& MapStorage::getBackgroundFilename()
1425{
1426  return background_file_name;
1427}
1428
1429bool MapStorage::isBackgroundSet()
1430{
1431  return background_set;
1432}
1433
1434double MapStorage::getBackgroundScaling()
1435{
1436  return background_scaling;
1437}
1438
1439void MapStorage::setBackgroundScaling(double scaling)
1440{
1441  background_scaling = scaling;
1442}
1443
1444void MapStorage::exportDigraphToEPS(std::vector<bool> options, std::string filename, std::string shapemap)
1445{
1446  Digraph::NodeMap<int> _shapes(digraph, 0);
1447  Digraph::NodeMap<int> _nodeColors(digraph, 0);
1448  Digraph::ArcMap<int> _arcColors(digraph, 0);
1449  Digraph::NodeMap<double> _nodeSizes(digraph, 6.0);
1450  Digraph::ArcMap<double> _arcWidths(digraph, 1.0);
1451  bool _drawArrows=options[ARROWS];
1452  bool _enableParallel=options[PAR];
1453
1454  std::string emptyString="";
1455  Digraph::NodeMap<std::string> _nodeTextMap(digraph,emptyString);
1456
1457  //_nodeTextMap=(Digraph::NodeMap<void> *)&emptyStringMap;
1458
1459  if(options[N_MAPS])
1460    {
1461      if(active_nodemaps[N_RADIUS]!="")
1462        {
1463          _nodeSizes=getNumericNodeMap(active_nodemaps[N_RADIUS]);
1464        }
1465      if(active_nodemaps[N_COLOR]!="")
1466        {
1467          for(NodeIt ni(digraph);ni!=INVALID;++ni)
1468            {
1469              _nodeColors[ni]=(int)get(active_nodemaps[N_COLOR], ni);
1470            }
1471        }
1472      if(active_nodemaps[N_TEXT]!="")
1473        {
1474          for(NodeIt ni(digraph);ni!=INVALID;++ni)
1475            {
1476              std::ostringstream o;
1477              o << get(active_nodemaps[N_TEXT], ni);
1478              _nodeTextMap[ni]=o.str();       
1479            }
1480        }
1481    }
1482  if(options[E_MAPS])
1483    {
1484      if(active_arcmaps[E_WIDTH]!="")
1485        {
1486          _arcWidths=getNumericArcMap(active_arcmaps[E_WIDTH]);
1487        }
1488      if(active_arcmaps[E_COLOR]!="")
1489        {
1490          for(ArcIt ei(digraph);ei!=INVALID;++ei)
1491            {
1492              _arcColors[ei]=(int)get(active_arcmaps[E_COLOR], ei);
1493            }
1494        }
1495    }
1496  if(shapemap!="Default values")
1497    {
1498      double min = std::numeric_limits<double>::max();
1499      double max = std::numeric_limits<double>::min();
1500      for (NodeIt n(digraph); n != INVALID; ++n)
1501      {
1502        double v = static_cast<double>(get(shapemap, n));
1503        if (v < min) min = v;
1504        if (v > max) max = v;
1505      }
1506      if((min>=0)&&(max<=4))
1507        {
1508          NumericNodeMap& map = static_cast<NumericNodeMapData*>(getNodeMapData(shapemap))->map;
1509          for (NodeIt n(digraph); n != INVALID; ++n)
1510          {
1511            _shapes[n] = static_cast<int>(map[n]);
1512          }
1513        }
1514    }
1515
1516  Palette palette;
1517  Palette paletteW(true);
1518
1519  graphToEps(digraph,filename).
1520    title("Sample .eps figure (fits to A4)").
1521    copyright("(C) 2006 LEMON Project").
1522    absoluteNodeSizes().absoluteArcWidths().
1523    nodeScale(2).nodeSizes(_nodeSizes).
1524    coords(node_coords).
1525    nodeShapes(_shapes).
1526    nodeColors(composeMap(paletteW,_nodeColors)).
1527    arcColors(composeMap(palette,_arcColors)).
1528    arcWidthScale(0.3).arcWidths(_arcWidths).
1529    nodeTexts(_nodeTextMap).nodeTextSize(7).
1530    enableParallel(_enableParallel).parArcDist(5).
1531    drawArrows(_drawArrows).arrowWidth(7).arrowLength(7).
1532    run();
1533
1534}
Note: See TracBrowser for help on using the repository browser.