source: glemon/mapstorage.cc @ 2:fdb8a163000f

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all cop       ies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#include "i18n.h"
#include <limits>
#include <cmath>
#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <gtkmm.h>
#include "file_import_dialog.h"
#include <mapstorage.h>
#include <gui_writer.h>
#include <gui_reader.h>
#include <lemon/graph_to_eps.h>
#include <lemon/lgf_reader.h>
#include <lemon/lgf_writer.h>

const int i_d=20;
const double a_d=0.05;
const double p_d=40000;

MapStorage::MapStorage() :
  gui_sect_save_dest(LGF_FILE),
  node_coords_save_dest(SpecMapSaveOpts::GUI_SECT),
  arrow_coords_save_dest(SpecMapSaveOpts::GUI_SECT),
  modified(false),
  file_name(""),
  max_node_label(0),
  max_arc_label(0),
  node_coords_one_map_name("coord"),
  node_coords_two_maps_1_name("coord_x"),
  node_coords_two_maps_2_name("coord_y"),
  arrow_coords_one_map_name("arrow"),
  arrow_coords_two_maps_1_name("arrow_x"),
  arrow_coords_two_maps_2_name("arrow_y"),
  iterations(i_d),
  attraction(a_d),
  propulsation(p_d),
  node_coords_x(digraph),
  node_coords_y(digraph),
  arrow_coords_x(digraph),
  arrow_coords_y(digraph),
  node_label(digraph),
  arc_label(digraph),
  background_set(false)
{
  node_coords.setXMap(node_coords_x);
  node_coords.setYMap(node_coords_y);
  arrow_coords.setXMap(arrow_coords_x);
  arrow_coords.setYMap(arrow_coords_y);

  active_nodemaps.resize(NODE_PROPERTY_NUM);
  for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      active_nodemaps[i]="";
    }

  active_arcmaps.resize(EDGE_PROPERTY_NUM);
  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      active_arcmaps[i]="";
    }
}

MapStorage::~MapStorage()
{
  clear();
}

void MapStorage::createNodeMap(const std::string& name, MapValue::Type type,
    MapValue def_val)
{
  NodeMapStore::const_iterator it = nodemaps.find(name);
  if (it != nodemaps.end())
    throw Error("Node map " + name + " already exists.");

  switch (type)
  {
    case MapValue::NUMERIC:
      nodemaps[name] = new NumericNodeMapData(digraph, def_val);
      break;
    case MapValue::STRING:
      nodemaps[name] = new StringNodeMapData(digraph, def_val);
      break;
  }

  nodemaps[name]->default_value = def_val;

  signal_node_map.emit(name, type);
}

void MapStorage::createArcMap(const std::string& name, MapValue::Type type,
    MapValue def_val)
{
  ArcMapStore::const_iterator it = arcmaps.find(name);
  if (it != arcmaps.end())
    throw Error("Arc map " + name + " already exists.");

  switch (type)
  {
    case MapValue::NUMERIC:
      arcmaps[name] = new NumericArcMapData(digraph, def_val);
      break;
    case MapValue::STRING:
      arcmaps[name] = new StringArcMapData(digraph, def_val);
      break;
  }

  arcmaps[name]->default_value = def_val;

  signal_arc_map.emit(name, type);
}

void MapStorage::changeActiveMap(bool itisarc, int prop, std::string mapname)
{
  if(itisarc)
    {
      active_arcmaps[prop]=mapname;
    }
  else
    {
      active_nodemaps[prop]=mapname;
    }
  signal_prop.emit(itisarc, prop);
}

void MapStorage::broadcastActiveMaps()
{
  for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      signal_map_win.emit(false, i, active_nodemaps[i]);
    }
  
  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      signal_map_win.emit(true, i, active_arcmaps[i]);
    }
}

std::string MapStorage::getActiveArcMap(int prop)
{
  return active_arcmaps[prop];
}

std::string MapStorage::getActiveNodeMap(int prop)
{
  return active_nodemaps[prop];
}

std::vector<std::string> MapStorage::getArcMapList(MapType type)
{
  if (type == ALL)
  {
    std::vector<std::string> ret;
    for (ArcMapStore::const_iterator it = arcmaps.begin();
        it != arcmaps.end(); ++it)
    {
      ret.push_back(it->first);
    }
    return ret;
  }
  else
  {
    std::vector<std::string> ret;
    for (ArcMapStore::const_iterator it = arcmaps.begin();
        it != arcmaps.end(); ++it)
    {
      ArcMapData* data = getArcMapData(it->first);
      MapValue::Type t = data->type();
      if ((t == MapValue::NUMERIC && (type & NUM)) ||
          (t == MapValue::STRING && (type & STR)))
      {
        ret.push_back(it->first);
      }
    }
    return ret;
  }
}

std::vector<std::string> MapStorage::getNodeMapList(MapType type)
{
  if (type == ALL)
  {
    std::vector<std::string> ret;
    for (NodeMapStore::const_iterator it = nodemaps.begin();
        it != nodemaps.end(); ++it)
    {
      ret.push_back(it->first);
    }
    return ret;
  }
  else
  {
    std::vector<std::string> ret;
    for (NodeMapStore::const_iterator it = nodemaps.begin();
        it != nodemaps.end(); ++it)
    {
      NodeMapData* data = getNodeMapData(it->first);
      MapValue::Type t = data->type();
      if ((t == MapValue::NUMERIC && (type & NUM)) ||
          (t == MapValue::STRING && (type & STR)))
      {
        ret.push_back(it->first);
      }
    }
    return ret;
  }
}

sigc::signal<void, bool, int> MapStorage::signal_prop_ch()
{
  return signal_prop;
}

int MapStorage::readFromFile(const std::string &filename)
{
  using std::vector;
  using std::map;
  using std::string;

  //reading content of file
  LgfContents content(filename);
  try
    {
      content.run();
    }
  catch (Exception& error)
    {
      Gtk::MessageDialog mdialog(error.what());
      mdialog.run();
      clear();
      return 1;
    }

  // check whether the .conf file exists
  bool gui_data_in_conf = g_file_test((filename + ".conf").c_str(),
      (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR));

  // check whether the .lgf file contains a gui section
  bool gui_data_in_lgf = false;
  {
    for(int i=0;i<content.extraSectionNum();i++)
      {
        if(content.extraSection(i)=="gui")
          {
            gui_data_in_lgf = true;
          }
      }
  }

  bool gui_data_found = gui_data_in_lgf || gui_data_in_conf;

  // ask for user input if both exist
  bool use_gui_data_in_lgf = false;
  if (gui_data_in_conf && gui_data_in_lgf)
  {
    Gtk::MessageDialog mdialog(_("<b>Found both ") + filename +
        _(".conf and a gui section in ") + filename + _(".</b>"), true,
        Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE);
          mdialog.add_button(_("Use the ._conf file"), 1);
          mdialog.add_button(_("Use the _gui section"), 2);
    switch (mdialog.run())
    {
      case 1:
        use_gui_data_in_lgf = false;
        break;
      case 2:
        use_gui_data_in_lgf = true;
        break;
      case Gtk::RESPONSE_NONE:
        return 1;
    }
  }
  else
  {
    use_gui_data_in_lgf = gui_data_in_lgf;
  }

  if (gui_data_found)
  {
    GUISectData gui_data;
    if (use_gui_data_in_lgf)
    {
      // read the gui section from the .lgf file
      try
      {
        sectionReader(filename).sectionStream("gui", GuiReader(this, gui_data)).run();
        gui_sect_save_dest = LGF_FILE;
      }
      catch (Exception& error)
      {
        clear();
        return 1;
      }
    }
    else
    {
      // read the gui section from the .conf file
      try
      {
        sectionReader(filename + ".conf").sectionStream("gui", GuiReader(this, gui_data)).run();
        gui_sect_save_dest = CONF_FILE;
      }
      catch (Exception& error)
      {
        clear();
        return 1;
      }
    }

    // read the digraph and maps form the .lgf file
    try
    {
      std::string node_coord_xmap_name, node_coord_ymap_name;
      std::string arrow_coord_xmap_name, arrow_coord_ymap_name;

      if (gui_data.node_coords_save_dest ==
          MapStorage::SpecMapSaveOpts::NESET_SECT)
      {
        switch (gui_data.node_coords_save_map_num)
        {
          case SpecMapSaveOpts::ONE_MAP:
            node_coord_xmap_name = gui_data.node_coords_one_map_name + ":x";
            node_coord_ymap_name = gui_data.node_coords_one_map_name + ":y";
            node_coords_one_map_name = gui_data.node_coords_one_map_name;
            break;
          case SpecMapSaveOpts::TWO_MAPS:
            node_coord_xmap_name = gui_data.node_coords_two_maps_1_name;
            node_coord_ymap_name = gui_data.node_coords_two_maps_2_name;
            node_coords_two_maps_1_name = gui_data.node_coords_two_maps_1_name;
            node_coords_two_maps_2_name = gui_data.node_coords_two_maps_2_name;
            break;
        }
        node_coords_save_dest = gui_data.node_coords_save_dest;
        node_coords_save_map_num = gui_data.node_coords_save_map_num;
      }

      if (gui_data.arrow_coords_save_dest ==
          MapStorage::SpecMapSaveOpts::NESET_SECT)
      {
        switch (gui_data.arrow_coords_save_map_num)
        {
          case SpecMapSaveOpts::ONE_MAP:
            arrow_coord_xmap_name = gui_data.arrow_coords_one_map_name + ":x";
            arrow_coord_ymap_name = gui_data.arrow_coords_one_map_name + ":y";
            arrow_coords_one_map_name = gui_data.arrow_coords_one_map_name;
            break;
          case SpecMapSaveOpts::TWO_MAPS:
            arrow_coord_xmap_name = gui_data.arrow_coords_two_maps_1_name;
            arrow_coord_ymap_name = gui_data.arrow_coords_two_maps_2_name;
            arrow_coords_two_maps_1_name =
              gui_data.arrow_coords_two_maps_1_name;
            arrow_coords_two_maps_2_name =
              gui_data.arrow_coords_two_maps_2_name;
            break;
        }
        arrow_coords_save_dest = gui_data.arrow_coords_save_dest;
        arrow_coords_save_map_num = gui_data.arrow_coords_save_map_num;
      }
      readLGF(filename, true,
          gui_data.main_node_map_names, gui_data.main_arc_map_names,
          gui_data.node_map_types, gui_data.arc_map_types,
          node_coord_xmap_name, node_coord_ymap_name,
          arrow_coord_xmap_name, arrow_coord_ymap_name);
    }
    catch (Exception& error)
    {
      clear();
      return 1;
    }

    // add the maps from the gui section
    for (vector<string>::const_iterator
        it = gui_data.gui_node_map_names.begin();
        it != gui_data.gui_node_map_names.end(); ++it)
    {
      string map_name = *it;
      switch (gui_data.node_map_types[map_name])
      {
        case MapValue::NUMERIC:
          {
            createNodeMap(map_name, MapValue::NUMERIC, double());
            NumericNodeMap& dmap = getNumericNodeMap(map_name);
            map<int, double>& smap = *gui_data.numeric_node_maps[map_name];
            for (NodeIt n(digraph); n != INVALID; ++n)
            {
              dmap[n] = smap[node_label[n]];
            }
            break;
          }
        case MapValue::STRING:
          {
            createNodeMap(map_name, MapValue::STRING, string());
            StringNodeMap& dmap = getStringNodeMap(map_name);
            map<int, string>& smap = *gui_data.string_node_maps[map_name];
            for (NodeIt n(digraph); n != INVALID; ++n)
            {
              dmap[n] = smap[node_label[n]];
            }
            break;
          }
      }
      getNodeMapData(map_name)->save_dest = GUI_SECT;
    }
    for (vector<string>::const_iterator
        it = gui_data.gui_arc_map_names.begin();
        it != gui_data.gui_arc_map_names.end(); ++it)
    {
      string map_name = *it;
      switch (gui_data.arc_map_types[map_name])
      {
        case MapValue::NUMERIC:
          {
            createArcMap(map_name, MapValue::NUMERIC, double());
            NumericArcMap& dmap = getNumericArcMap(map_name);
            map<int, double>& smap = *gui_data.numeric_arc_maps[map_name];
            for (ArcIt e(digraph); e != INVALID; ++e)
            {
              dmap[e] = smap[arc_label[e]];
            }
            break;
          }
        case MapValue::STRING:
          {
            createArcMap(map_name, MapValue::STRING, string());
            StringArcMap& dmap = getStringArcMap(map_name);
            map<int, string>& smap = *gui_data.string_arc_maps[map_name];
            for (ArcIt e(digraph); e != INVALID; ++e)
            {
              dmap[e] = smap[arc_label[e]];
            }
            break;
          }
      }
      getArcMapData(map_name)->save_dest = GUI_SECT;
    }

    // restore the node coordinate maps
    if (gui_data.node_coords_save_dest ==
        MapStorage::SpecMapSaveOpts::GUI_SECT)
    {
      for (NodeIt n(digraph); n != INVALID; ++n)
      {
        node_coords.set(n, gui_data.node_coord_map[node_label[n]]);
      }
      node_coords_save_dest = gui_data.node_coords_save_dest;
    }
    // restore the arrow coordinate maps
    if (gui_data.arrow_coords_save_dest ==
        MapStorage::SpecMapSaveOpts::GUI_SECT)
    {
      for (ArcIt e(digraph); e != INVALID; ++e)
      {
        arrow_coords.set(e, gui_data.arrow_coord_map[arc_label[e]]);
      }
      arrow_coords_save_dest = gui_data.arrow_coords_save_dest;
    }
  }
  else
  {
    // there is no gui section neither in the .lgf file nor in the .conf file
    {
      if (content.nodeSectionNum() < 1)
      {
        Gtk::MessageDialog mdialog("No nodeset found in file.");
        mdialog.run();
        clear();
        return 1;
      }

      if (content.arcSectionNum() < 1)
      {
        Gtk::MessageDialog mdialog("No arcset found in file.");
        mdialog.run();
        clear();
        return 1;
      }

      std::vector<std::string> nodeMapNames = content.nodeMapNames(0);
      std::vector<std::string> arcMapNames = content.arcMapNames(0);
      
      bool read_arc_label = true;
      if (std::find(arcMapNames.begin(), arcMapNames.end(), "label") ==
          arcMapNames.end())
      {
        read_arc_label = false;
      }

      nodeMapNames.erase(
          std::remove(nodeMapNames.begin(), nodeMapNames.end(), "label"),
          nodeMapNames.end());

      arcMapNames.erase(
          std::remove(arcMapNames.begin(), arcMapNames.end(), "label"),
          arcMapNames.end());

      FileImportDialog::ImportData data(nodeMapNames, arcMapNames);
      FileImportDialog fidialog(&data);
      int response = fidialog.run();
      if (response == Gtk::RESPONSE_OK)
      {
        try
        {
          std::string node_coord_xmap_name, node_coord_ymap_name;
          std::string arrow_coord_xmap_name, arrow_coord_ymap_name;
          bool gen_node_coords = false;
          bool gen_arrow_coords = false;

          switch (data.node_coord_load_from)
          {
            case FileImportDialog::ImportData::ONE_MAP:
              node_coord_xmap_name = data.node_coord_one_map_name + ":x";
              node_coord_ymap_name = data.node_coord_one_map_name + ":y";
              node_coords_one_map_name = data.node_coord_one_map_name;

              node_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
              node_coords_save_map_num = SpecMapSaveOpts::ONE_MAP;
              break;
            case FileImportDialog::ImportData::TWO_MAPS:
              node_coord_xmap_name = data.node_coord_two_maps_1_name;
              node_coord_ymap_name = data.node_coord_two_maps_2_name;
              node_coords_two_maps_1_name = data.node_coord_two_maps_1_name;
              node_coords_two_maps_2_name = data.node_coord_two_maps_2_name;

              node_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
              node_coords_save_map_num = SpecMapSaveOpts::TWO_MAPS;
              break;
            case FileImportDialog::ImportData::DONT_READ:
              node_coord_xmap_name = "";
              node_coord_ymap_name = "";

              node_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
              gen_node_coords = true;
              break;
          }

          switch (data.arrow_coord_load_from)
          {
            case FileImportDialog::ImportData::ONE_MAP:
              arrow_coord_xmap_name = data.arrow_coord_one_map_name + ":x";
              arrow_coord_ymap_name = data.arrow_coord_one_map_name + ":y";
              arrow_coords_one_map_name = data.arrow_coord_one_map_name;

              arrow_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
              arrow_coords_save_map_num = SpecMapSaveOpts::ONE_MAP;
              break;
            case FileImportDialog::ImportData::TWO_MAPS:
              arrow_coord_xmap_name = data.arrow_coord_two_maps_1_name;
              arrow_coord_ymap_name = data.arrow_coord_two_maps_2_name;
              arrow_coords_two_maps_1_name = data.arrow_coord_two_maps_1_name;
              arrow_coords_two_maps_2_name = data.arrow_coord_two_maps_2_name;

              arrow_coords_save_dest = SpecMapSaveOpts::NESET_SECT;
              arrow_coords_save_map_num = SpecMapSaveOpts::TWO_MAPS;
              break;
            case FileImportDialog::ImportData::DONT_READ:
              arrow_coord_xmap_name = "";
              arrow_coord_ymap_name = "";

              arrow_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
              gen_arrow_coords = true;
              break;
          }

          // read arc and node maps
          std::vector<std::string> node_map_names;
          std::vector<std::string> arc_map_names;
          std::map<std::string, MapValue::Type> node_map_types;
          std::map<std::string, MapValue::Type> arc_map_types;
          for (std::vector<std::string>::const_iterator it =
              data.numeric_node_map_names.begin();
              it != data.numeric_node_map_names.end(); ++it)
          {
            node_map_names.push_back(*it);
            node_map_types[*it] = MapValue::NUMERIC;
          }
          for (std::vector<std::string>::const_iterator it =
              data.string_node_map_names.begin();
              it != data.string_node_map_names.end(); ++it)
          {
            node_map_names.push_back(*it);
            node_map_types[*it] = MapValue::STRING;
          }
          for (std::vector<std::string>::const_iterator it =
              data.numeric_arc_map_names.begin();
              it != data.numeric_arc_map_names.end(); ++it)
          {
            arc_map_names.push_back(*it);
            arc_map_types[*it] = MapValue::NUMERIC;
          }
          for (std::vector<std::string>::const_iterator it =
              data.string_arc_map_names.begin();
              it != data.string_arc_map_names.end(); ++it)
          {
            arc_map_names.push_back(*it);
            arc_map_types[*it] = MapValue::STRING;
          }

          readLGF(filename, read_arc_label,
              node_map_names, arc_map_names,
              node_map_types, arc_map_types,
              node_coord_xmap_name, node_coord_ymap_name,
              arrow_coord_xmap_name, arrow_coord_ymap_name);

          // generate arc labels
          if (!read_arc_label)
          {
            int l = 0;
            for (ArcIt e(digraph); e != INVALID; ++e)
            {
              arc_label[e] = l++;
            }
          }

          if (gen_node_coords)
          {
            // generate node coordinates
            int node_num = 0;
            for (NodeIt n(digraph); n != INVALID; ++n) { node_num++; }
            const double pi = 3.142;
            double step = 2 * pi / (double) node_num;
            int i = 0;
            for (NodeIt n(digraph); n != INVALID; ++n)
            {
              setNodeCoords(n,
                  XY(250.0 * std::cos(i * step),
                    250.0 * std::sin(i * step)));
              i++;
            }
          }
          if (gen_arrow_coords)
          {
            // generate arrow coordinates
            for (ArcIt e(digraph); e != INVALID; ++e)
            {
              if (digraph.source(e) == digraph.target(e))
              {
                setArrowCoords(e,
                    getNodeCoords(digraph.source(e)) + XY(0.0, 80.0));
              }
              else
              {
                setArrowCoords(e,
                    (getNodeCoords(digraph.source(e)) +
                     getNodeCoords(digraph.target(e))) / 2.0);
              }
            }
          }
        }
        catch (Exception& error)
        {
          clear();
          return 1;
        }
      }
      else
      {
        clear();
        return 1;
      }
    }
  }

  // set max_node_label
  {
    max_node_label = std::numeric_limits<int>::min();
    for (NodeIt n(digraph); n != INVALID; ++n)
    {
      if (node_label[n] > max_node_label)
      {
        max_node_label = node_label[n];
      }
    }
  }
  // set max_arc_label
  {
    max_arc_label = std::numeric_limits<int>::min();
    for (ArcIt e(digraph); e != INVALID; ++e)
    {
      if (arc_label[e] > max_arc_label)
      {
        max_arc_label = arc_label[e];
      }
    }
  }

  return 0;
}

void MapStorage::writeToFile(const std::string &filename)
{
  // relabel nodes and arcs
  int i = 0;
  for (NodeIt n(digraph); n != INVALID; ++n)
  {
    node_label[n] = i++;
  }
  max_node_label = i-1;
  i = 0;
  for (ArcIt e(digraph); e != INVALID; ++e)
  {
    arc_label[e] = i++;
  }
  max_arc_label = i-1;

  // write .lgf file
  {
    DigraphWriter<Digraph> gwriter(filename, digraph);

    gwriter.nodeMap("label", node_label);
    gwriter.arcMap("label", arc_label);

    // write node maps
    for (NodeMapStore::const_iterator it = nodemaps.begin();
        it != nodemaps.end(); ++it)
    {
      if (it->second->save_dest == NESET_SECT)
      {
        switch (it->second->type())
        {
          case MapValue::NUMERIC:
            gwriter.nodeMap(it->first, getNumericNodeMap(it->first));
            break;
          case MapValue::STRING:
            gwriter.nodeMap(it->first, getStringNodeMap(it->first));
            break;
        }
      }
    }

    // write arc maps
    for (ArcMapStore::const_iterator it = arcmaps.begin();
        it != arcmaps.end(); ++it)
    {
      if (it->second->save_dest == NESET_SECT)
      {
        switch (it->second->type())
        {
          case MapValue::NUMERIC:
            gwriter.arcMap(it->first, getNumericArcMap(it->first));
            break;
          case MapValue::STRING:
            gwriter.arcMap(it->first, getStringArcMap(it->first));
            break;
        }
      }
    }

    // write node coordinates
    switch (getNodeCoordsSaveDest())
    {
      case MapStorage::SpecMapSaveOpts::GUI_SECT:
        break;
      case MapStorage::SpecMapSaveOpts::NESET_SECT:
        switch (getNodeCoordsSaveMapNum())
        {
          case MapStorage::SpecMapSaveOpts::ONE_MAP:
            gwriter.nodeMap(node_coords_one_map_name + ":x",
                node_coords_x);
            gwriter.nodeMap(node_coords_one_map_name + ":y",
                node_coords_y);
            break;
          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
            gwriter.nodeMap(node_coords_two_maps_1_name,
                node_coords_x);
            gwriter.nodeMap(node_coords_two_maps_2_name,
                node_coords_y);
            break;
        }
        break;
    }

    // write arrow coordinates
    switch (getArrowCoordsSaveDest())
    {
      case MapStorage::SpecMapSaveOpts::GUI_SECT:
        break;
      case MapStorage::SpecMapSaveOpts::NESET_SECT:
        switch (getArrowCoordsSaveMapNum())
        {
          case MapStorage::SpecMapSaveOpts::ONE_MAP:
            gwriter.arcMap(arrow_coords_one_map_name + ":x",
                arrow_coords_x);
            gwriter.arcMap(arrow_coords_one_map_name + ":y",
                arrow_coords_y);
            break;
          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
            gwriter.arcMap(arrow_coords_two_maps_1_name,
                arrow_coords_x);
            gwriter.arcMap(arrow_coords_two_maps_2_name,
                arrow_coords_y);
            break;
        }
        break;
    }

    if (gui_sect_save_dest == LGF_FILE)
    {
      GuiWriter gui_writer(this);
      gui_writer.write(gwriter.ostream());
      gwriter.run();
    }
    else
    {
      gwriter.run();
    }
  }

  // write .conf file
  if (gui_sect_save_dest == CONF_FILE)
  {
    DigraphWriter<Digraph> lwriter(filename + ".conf", digraph);
    GuiWriter gui_writer(this);
    gui_writer.write(lwriter.ostream());
    lwriter.run();
  }
}

void MapStorage::clear()
{
  for (NodeMapStore::iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
  {
    delete it->second;
    nodemaps.erase(it);
  }
  for (ArcMapStore::iterator it = arcmaps.begin(); it != arcmaps.end(); ++it)
  {
    delete it->second;
    arcmaps.erase(it);
  }
  digraph.clear();
  file_name = "";
  modified = false;
  max_node_label = 0;
  max_arc_label = 0;
  background_set = false;

  gui_sect_save_dest = LGF_FILE;
  node_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
  arrow_coords_save_dest = SpecMapSaveOpts::GUI_SECT;
  node_coords_one_map_name = "coord";
  node_coords_two_maps_1_name = "coord_x";
  node_coords_two_maps_2_name = "coord_y";
  arrow_coords_one_map_name = "arrow";
  arrow_coords_two_maps_1_name = "arrow_x";
  arrow_coords_two_maps_2_name = "arrow_y";

  for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      changeActiveMap(false, i, "");
      signal_map_win.emit(false, i, "");
    }
  
  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      changeActiveMap(true, i, "");
      signal_map_win.emit(true, i, "");
    }

  attraction=a_d;
  propulsation=p_d;
  iterations=i_d;

  signal_design_win.emit(attraction, propulsation, iterations);
}

void MapStorage::mapChanged(bool itisarc, std::string mapname)
{
  if(itisarc)
  {
    for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      if(active_arcmaps[i]==mapname)
      {
        signal_prop.emit(itisarc, i);
      }
    }
  }
  else
  {
    for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      if(active_nodemaps[i]==mapname)
      {
        signal_prop.emit(itisarc, i);
      }
    }
  }
}

void MapStorage::get_design_data(double & attraction_p, double & propulsation_p, int & iterations_p)
{
  attraction_p=attraction;
  propulsation_p=propulsation;
  iterations_p=iterations;
}

void MapStorage::set_attraction(double attraction_p)
{
  attraction=attraction_p;
}

void MapStorage::set_propulsation(double propulsation_p)
{
  propulsation=propulsation_p;
}

void MapStorage::set_iteration(int iterations_p)
{
  iterations=iterations_p;
}

void MapStorage::redesign_data_changed()
{
  signal_design_win.emit(attraction, propulsation, iterations);
}

XY MapStorage::getNodeCoords(Node n) const
{
  return node_coords[n];
}

void MapStorage::setNodeCoords(Node n, XY c)
{
  node_coords.set(n, c);
}

XY MapStorage::getArrowCoords(Arc e) const
{
  return arrow_coords[e];
}

void MapStorage::setArrowCoords(Arc e, XY c)
{
  arrow_coords.set(e, c);
}

MapValue MapStorage::get(const std::string& name, Node node) const
{
  NodeMapData* data = getNodeMapData(name);
  return data->get(node);
}

void MapStorage::set(const std::string& name, Node node, MapValue val)
{
  NodeMapData* data = getNodeMapData(name);
  data->set(node, val);
}

MapValue MapStorage::get(const std::string& name, Arc arc) const
{
  ArcMapData* data = getArcMapData(name);
  return data->get(arc);
}

void MapStorage::set(const std::string& name, Arc arc, MapValue val)
{
  ArcMapData* data = getArcMapData(name);
  data->set(arc, val);
}

const std::string& MapStorage::getFileName() const
{
  return file_name;
}

void MapStorage::setFileName(const std::string& fn)
{
  file_name = fn;
}

bool MapStorage::getModified() const
{
  return modified;
}

void MapStorage::setModified(bool m)
{
  modified = m;
}

Node MapStorage::addNode(XY coords)
{
  Node node = digraph.addNode();

  setNodeCoords(node, coords);

  max_node_label++;

  node_label[node] = max_node_label;

  std::vector<std::string> node_maps = getNodeMapList();
  for (std::vector<std::string>::const_iterator it = node_maps.begin();
      it != node_maps.end(); ++it)
  {
    NodeMapData* data = getNodeMapData(*it);
    set(*it, node, data->default_value);
  }

  return node;
}

Arc MapStorage::addArc(Node from, Node to)
{
  Arc arc = digraph.addArc(from, to);

  if (from == to)
  {
    setArrowCoords(arc, getNodeCoords(from) + XY(0.0, 80.0));
  }
  else
  {
    setArrowCoords(arc, (getNodeCoords(from) + getNodeCoords(to)) / 2.0);
  }

  max_arc_label++;

  arc_label[arc] = max_arc_label;

  std::vector<std::string> arc_maps = getArcMapList();
  for (std::vector<std::string>::const_iterator it = arc_maps.begin();
      it != arc_maps.end(); ++it)
  {
    ArcMapData* data = getArcMapData(*it);
    set(*it, arc, data->default_value);
  }
  return arc;
}

MapStorage::NumericNodeMap& MapStorage::getNumericNodeMap(const std::string& name)
{
  NodeMapData* data = getNodeMapData(name);
  if (data->type() != MapValue::NUMERIC)
    throw Error("Numeric node map " + name + " does not exists.");
  return static_cast<NumericNodeMapData*>(data)->map;
}

MapStorage::StringNodeMap& MapStorage::getStringNodeMap(const std::string& name)
{
  NodeMapData* data = getNodeMapData(name);
  if (data->type() != MapValue::STRING)
    throw Error("String node map " + name + " does not exists.");
  return static_cast<StringNodeMapData*>(data)->map;
}

MapStorage::NumericArcMap& MapStorage::getNumericArcMap(const std::string& name)
{
  ArcMapData* data = getArcMapData(name);
  if (data->type() != MapValue::NUMERIC)
    throw Error("Numeric arc map " + name + " does not exists.");
  return static_cast<NumericArcMapData*>(data)->map;
}

MapStorage::StringArcMap& MapStorage::getStringArcMap(const std::string& name)
{
  ArcMapData* data = getArcMapData(name);
  if (data->type() != MapValue::STRING)
    throw Error("String arc map " + name + " does not exists.");
  return static_cast<StringArcMapData*>(data)->map;
}

MapValueArcMap MapStorage::getArcMap(const std::string& name)
{
  return MapValueArcMap(name, this);
}

MapValueNodeMap MapStorage::getNodeMap(const std::string& name)
{
  return MapValueNodeMap(name, this);
}

int MapStorage::getLabel(Node n) const
{
  return node_label[n];
}

int MapStorage::getLabel(Arc e) const
{
  return arc_label[e];
}

MapStorage::GuiSectSaveDest MapStorage::getGUIDataSaveLocation()
{
  return gui_sect_save_dest;
}

void MapStorage::setGUIDataSaveLocation(MapStorage::GuiSectSaveDest dest)
{
  gui_sect_save_dest = dest;
}

MapStorage::MapSaveDest MapStorage::getNodeMapSaveDest(std::string name) const
{
  NodeMapData *data = getNodeMapData(name);
  return data->save_dest;
}

MapStorage::MapSaveDest MapStorage::getArcMapSaveDest(std::string name) const
{
  ArcMapData *data = getArcMapData(name);
  return data->save_dest;
}

void MapStorage::setNodeMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
{
  NodeMapData *data = getNodeMapData(name);
  data->save_dest = dest;
}

void MapStorage::setArcMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
{
  ArcMapData *data = getArcMapData(name);
  data->save_dest = dest;
}

MapStorage::ArcMapData* MapStorage::getArcMapData(std::string name) const
{
  ArcMapStore::const_iterator it = arcmaps.find(name);
  if (it != arcmaps.end())
    return it->second;
  else
    throw Error("Arc map " + name + " does not exists.");
}

MapStorage::NodeMapData* MapStorage::getNodeMapData(std::string name) const
{
  NodeMapStore::const_iterator it = nodemaps.find(name);
  if (it != nodemaps.end())
    return it->second;
  else
    throw Error("Node map " + name + " does not exists.");
}

MapValue::Type MapStorage::getNodeMapElementType(std::string name) const
{
  NodeMapData *data = getNodeMapData(name);
  return data->type();
}

MapValue::Type MapStorage::getArcMapElementType(std::string name) const
{
  ArcMapData *data = getArcMapData(name);
  return data->type();
}

const MapStorage::NodeLabelMap& MapStorage::getNodeLabelMap()
{
  return node_label;
}

const MapStorage::ArcLabelMap& MapStorage::getArcLabelMap()
{
  return arc_label;
}

const Digraph& MapStorage::getDigraph()
{
  return digraph;
}

bool MapStorage::nodeMapExists(std::string name)
{
  NodeMapStore::const_iterator it = nodemaps.find(name);
  if (it == nodemaps.end())
    return false;
  else
    return true;
}

bool MapStorage::arcMapExists(std::string name)
{
  ArcMapStore::const_iterator it = arcmaps.find(name);
  if (it == arcmaps.end())
    return false;
  else
    return true;
}

std::vector<std::string> MapStorage::getArcMaps(MapType type)
{
  std::vector<std::string> maps;
  for (ArcMapStore::const_iterator it = arcmaps.begin(); it != arcmaps.end(); ++it)
  {
    if (it->second->type() & type)
    {
      maps.push_back(it->first);
    }
  }
  return maps;
}

std::vector<std::string> MapStorage::getNodeMaps(MapType type)
{
  std::vector<std::string> maps;
  for (NodeMapStore::const_iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
  {
    if (it->second->type() & type)
    {
      maps.push_back(it->first);
    }
  }
  return maps;
}

MapStorage::NodeCoordMap& MapStorage::getNodeCoordMap()
{
  return node_coords;
}

MapStorage::ArrowCoordMap& MapStorage::getArrowCoordMap()
{
  return arrow_coords;
}

MapStorage::SpecMapSaveOpts::Dest MapStorage::getNodeCoordsSaveDest()
{
  return node_coords_save_dest;
}

MapStorage::SpecMapSaveOpts::Dest MapStorage::getArrowCoordsSaveDest()
{
  return arrow_coords_save_dest;
}

void MapStorage::setNodeCoordsSaveDest(MapStorage::SpecMapSaveOpts::Dest dest)
{
  node_coords_save_dest = dest;
}

void MapStorage::setArrowCoordsSaveDest(MapStorage::SpecMapSaveOpts::Dest dest)
{
  arrow_coords_save_dest = dest;
}

MapStorage::SpecMapSaveOpts::MapNum MapStorage::getNodeCoordsSaveMapNum()
{
  return node_coords_save_map_num;
}

MapStorage::SpecMapSaveOpts::MapNum MapStorage::getArrowCoordsSaveMapNum()
{
  return arrow_coords_save_map_num;
}

void MapStorage::setNodeCoordsSaveMapNum(MapStorage::SpecMapSaveOpts::MapNum num)
{
  node_coords_save_map_num = num;
}

void MapStorage::setArrowCoordsSaveMapNum(MapStorage::SpecMapSaveOpts::MapNum num)
{
  arrow_coords_save_map_num = num;
}

const std::string& MapStorage::getNodeCoordsOneMapName()
{
  return node_coords_one_map_name;
}
const std::string& MapStorage::getNodeCoordsTwoMaps1Name()
{
  return node_coords_two_maps_1_name;
}
const std::string& MapStorage::getNodeCoordsTwoMaps2Name()
{
  return node_coords_two_maps_2_name;
}

void MapStorage::setNodeCoordsOneMapName(const std::string& name)
{
  node_coords_one_map_name = name;
}
void MapStorage::setNodeCoordsTwoMaps1Name(const std::string& name)
{
  node_coords_two_maps_1_name = name;
}
void MapStorage::setNodeCoordsTwoMaps2Name(const std::string& name)
{
  node_coords_two_maps_2_name = name;
}

const std::string& MapStorage::getArrowCoordsOneMapName()
{
  return arrow_coords_one_map_name;
}
const std::string& MapStorage::getArrowCoordsTwoMaps1Name()
{
  return arrow_coords_two_maps_1_name;
}
const std::string& MapStorage::getArrowCoordsTwoMaps2Name()
{
  return arrow_coords_two_maps_2_name;
}

void MapStorage::setArrowCoordsOneMapName(const std::string& name)
{
  arrow_coords_one_map_name = name;
}
void MapStorage::setArrowCoordsTwoMaps1Name(const std::string& name)
{
  arrow_coords_two_maps_1_name = name;
}
void MapStorage::setArrowCoordsTwoMaps2Name(const std::string& name)
{
  arrow_coords_two_maps_2_name = name;
}

void MapStorage::readLGF(
    const std::string& filename,
    bool read_arc_label,
    const std::vector<std::string>& node_map_names,
    const std::vector<std::string>& arc_map_names,
    const std::map<std::string, MapValue::Type>& node_map_types,
    const std::map<std::string, MapValue::Type>& arc_map_types,
    const std::string& node_coord_xmap_name,
    const std::string& node_coord_ymap_name,
    const std::string& arrow_coord_xmap_name,
    const std::string& arrow_coord_ymap_name)
{
  using std::vector;
  using std::map;
  using std::string;

  DigraphReader<Digraph> greader(filename, digraph);

  // read the label maps
  greader.nodeMap("label", node_label);
  if (read_arc_label)
    greader.arcMap("label", arc_label);

  // read the node maps
  for (vector<string>::const_iterator
      it = node_map_names.begin();
      it != node_map_names.end(); ++it)
  {
    switch (node_map_types.find(*it)->second)
    {
      case MapValue::NUMERIC:
        {
          createNodeMap(*it, MapValue::NUMERIC, double());
          greader.nodeMap(*it, getNumericNodeMap(*it));
          break;
        }
      case MapValue::STRING:
        {
          createNodeMap(*it, MapValue::STRING, string());
          greader.nodeMap(*it, getStringNodeMap(*it));
          break;
        }
    }
    getNodeMapData(*it)->save_dest = NESET_SECT;
  }

  // read the arc maps
  for (vector<string>::const_iterator
      it = arc_map_names.begin();
      it != arc_map_names.end(); ++it)
  {
    switch (arc_map_types.find(*it)->second)
    {
      case MapValue::NUMERIC:
        {
          createArcMap(*it, MapValue::NUMERIC, double());
          greader.arcMap(*it, getNumericArcMap(*it));
          break;
        }
      case MapValue::STRING:
        {
          createArcMap(*it, MapValue::STRING, string());
          greader.arcMap(*it, getStringArcMap(*it));
          break;
        }
    }
    getArcMapData(*it)->save_dest = NESET_SECT;
  }

  // read the node coordinate maps
  if (node_coord_xmap_name != "")
    greader.nodeMap(node_coord_xmap_name, node_coords_x);
  if (node_coord_ymap_name != "")
    greader.nodeMap(node_coord_ymap_name, node_coords_y);

  // read the arrow coordinate maps
  if (arrow_coord_xmap_name != "")
    greader.arcMap(arrow_coord_xmap_name, arrow_coords_x);
  if (arrow_coord_ymap_name != "")
    greader.arcMap(arrow_coord_ymap_name, arrow_coords_y);

  greader.run();
}

void MapStorage::setBackground(const std::string& file_name)
{
  if (file_name == background_file_name) return;
  if (file_name == "")
  {
    background_file_name = "";
    background_set = false;
  }
  else
  {
    background_file_name = file_name;
    background_set = true;
  }
  signal_background.emit();
}

const std::string& MapStorage::getBackgroundFilename()
{
  return background_file_name;
}

bool MapStorage::isBackgroundSet()
{
  return background_set;
}

double MapStorage::getBackgroundScaling()
{
  return background_scaling;
}

void MapStorage::setBackgroundScaling(double scaling)
{
  background_scaling = scaling;
}

void MapStorage::exportDigraphToEPS(std::vector<bool> options, std::string filename, std::string shapemap)
{
  Digraph::NodeMap<int> _shapes(digraph, 0);
  Digraph::NodeMap<int> _nodeColors(digraph, 0);
  Digraph::ArcMap<int> _arcColors(digraph, 0);
  Digraph::NodeMap<double> _nodeSizes(digraph, 6.0);
  Digraph::ArcMap<double> _arcWidths(digraph, 1.0);
  bool _drawArrows=options[ARROWS];
  bool _enableParallel=options[PAR];

  std::string emptyString="";
  Digraph::NodeMap<std::string> _nodeTextMap(digraph,emptyString);

  //_nodeTextMap=(Digraph::NodeMap<void> *)&emptyStringMap;

  if(options[N_MAPS])
    {
      if(active_nodemaps[N_RADIUS]!="")
        {
          _nodeSizes=getNumericNodeMap(active_nodemaps[N_RADIUS]);
        }
      if(active_nodemaps[N_COLOR]!="")
        {
          for(NodeIt ni(digraph);ni!=INVALID;++ni)
            {
              _nodeColors[ni]=(int)get(active_nodemaps[N_COLOR], ni);
            }
        }
      if(active_nodemaps[N_TEXT]!="")
        {
          for(NodeIt ni(digraph);ni!=INVALID;++ni)
            {
              std::ostringstream o;
              o << get(active_nodemaps[N_TEXT], ni);
              _nodeTextMap[ni]=o.str();       
            }
        }
    }
  if(options[E_MAPS])
    {
      if(active_arcmaps[E_WIDTH]!="")
        {
          _arcWidths=getNumericArcMap(active_arcmaps[E_WIDTH]);
        }
      if(active_arcmaps[E_COLOR]!="")
        {
          for(ArcIt ei(digraph);ei!=INVALID;++ei)
            {
              _arcColors[ei]=(int)get(active_arcmaps[E_COLOR], ei);
            }
        }
    }
  if(shapemap!="Default values")
    {
      double min = std::numeric_limits<double>::max();
      double max = std::numeric_limits<double>::min();
      for (NodeIt n(digraph); n != INVALID; ++n)
      {
        double v = static_cast<double>(get(shapemap, n));
        if (v < min) min = v;
        if (v > max) max = v;
      }
      if((min>=0)&&(max<=4))
        {
          NumericNodeMap& map = static_cast<NumericNodeMapData*>(getNodeMapData(shapemap))->map;
          for (NodeIt n(digraph); n != INVALID; ++n)
          {
            _shapes[n] = static_cast<int>(map[n]);
          }
        }
    }

  Palette palette;
  Palette paletteW(true);

  graphToEps(digraph,filename).
    title("Sample .eps figure (fits to A4)").
    copyright("(C) 2006 LEMON Project").
    absoluteNodeSizes().absoluteArcWidths().
    nodeScale(2).nodeSizes(_nodeSizes).
    coords(node_coords).
    nodeShapes(_shapes).
    nodeColors(composeMap(paletteW,_nodeColors)).
    arcColors(composeMap(palette,_arcColors)).
    arcWidthScale(0.3).arcWidths(_arcWidths).
    nodeTexts(_nodeTextMap).nodeTextSize(7).
    enableParallel(_enableParallel).parArcDist(5).
    drawArrows(_drawArrows).arrowWidth(7).arrowLength(7).
    run();

}