source: glemon-0.x/mapstorage.cc @ 201:879e47e5b731

/* -*- 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>

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_edge_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(graph),
  node_coords_y(graph),
  arrow_coords_x(graph),
  arrow_coords_y(graph),
  node_label(graph),
  edge_label(graph),
  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_edgemaps.resize(EDGE_PROPERTY_NUM);
  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      active_edgemaps[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(graph, def_val);
      break;
    case MapValue::STRING:
      nodemaps[name] = new StringNodeMapData(graph, def_val);
      break;
  }

  nodemaps[name]->default_value = def_val;

  signal_node_map.emit(name, type);
}

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

  switch (type)
  {
    case MapValue::NUMERIC:
      edgemaps[name] = new NumericEdgeMapData(graph, def_val);
      break;
    case MapValue::STRING:
      edgemaps[name] = new StringEdgeMapData(graph, def_val);
      break;
  }

  edgemaps[name]->default_value = def_val;

  signal_edge_map.emit(name, type);
}

void MapStorage::changeActiveMap(bool itisedge, int prop, std::string mapname)
{
  if(itisedge)
    {
      active_edgemaps[prop]=mapname;
    }
  else
    {
      active_nodemaps[prop]=mapname;
    }
  signal_prop.emit(itisedge, 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_edgemaps[i]);
    }
}

std::string MapStorage::getActiveEdgeMap(int prop)
{
  return active_edgemaps[prop];
}

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

std::vector<std::string> MapStorage::getEdgeMapList(MapType type)
{
  if (type == ALL)
  {
    std::vector<std::string> ret;
    for (EdgeMapStore::const_iterator it = edgemaps.begin();
        it != edgemaps.end(); ++it)
    {
      ret.push_back(it->first);
    }
    return ret;
  }
  else
  {
    std::vector<std::string> ret;
    for (EdgeMapStore::const_iterator it = edgemaps.begin();
        it != edgemaps.end(); ++it)
    {
      EdgeMapData* data = getEdgeMapData(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;

  // 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;
  {
    std::ifstream ifs(filename.c_str());
    std::string line;
    while (getline(ifs, line))
    {
      int pos = line.find("@gui");
      if (pos != std::string::npos)
      {
        bool only_whitespace_before = true;
        for (int i = 0; i < pos; ++i)
        {
          if (!std::isspace(line[i]))
          {
            only_whitespace_before = false;
            break;
          }
        }
        if (only_whitespace_before) 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
      {
        LemonReader lreader(filename);
        GuiReader gui_reader(lreader, this, gui_data);
        lreader.run();
        gui_sect_save_dest = LGF_FILE;
      }
      catch (Exception& error)
      {
        clear();
        return 1;
      }
    }
    else
    {
      // read the gui section from the .conf file
      try
      {
        LemonReader lreader(filename + ".conf");
        GuiReader gui_reader(lreader, this, gui_data);
        lreader.run();
        gui_sect_save_dest = CONF_FILE;
      }
      catch (Exception& error)
      {
        clear();
        return 1;
      }
    }

    // read the graph 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_edge_map_names,
          gui_data.node_map_types, gui_data.edge_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(graph); 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(graph); 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_edge_map_names.begin();
        it != gui_data.gui_edge_map_names.end(); ++it)
    {
      string map_name = *it;
      switch (gui_data.edge_map_types[map_name])
      {
        case MapValue::NUMERIC:
          {
            createEdgeMap(map_name, MapValue::NUMERIC, double());
            NumericEdgeMap& dmap = getNumericEdgeMap(map_name);
            map<int, double>& smap = *gui_data.numeric_edge_maps[map_name];
            for (EdgeIt e(graph); e != INVALID; ++e)
            {
              dmap[e] = smap[edge_label[e]];
            }
            break;
          }
        case MapValue::STRING:
          {
            createEdgeMap(map_name, MapValue::STRING, string());
            StringEdgeMap& dmap = getStringEdgeMap(map_name);
            map<int, string>& smap = *gui_data.string_edge_maps[map_name];
            for (EdgeIt e(graph); e != INVALID; ++e)
            {
              dmap[e] = smap[edge_label[e]];
            }
            break;
          }
      }
      getEdgeMapData(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(graph); 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 (EdgeIt e(graph); e != INVALID; ++e)
      {
        arrow_coords.set(e, gui_data.arrow_coord_map[edge_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
    {
      LemonReader lreader(filename);
      ContentReader content(lreader);
      try
      {
        lreader.run();
      }
      catch (Exception& error)
      {
        Gtk::MessageDialog mdialog(error.what());
        mdialog.run();
        clear();
        return 1;
      }

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

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

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

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

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

      FileImportDialog::ImportData data(nodeMapNames, edgeMapNames);
      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 edge and node maps
          std::vector<std::string> node_map_names;
          std::vector<std::string> edge_map_names;
          std::map<std::string, MapValue::Type> node_map_types;
          std::map<std::string, MapValue::Type> edge_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_edge_map_names.begin();
              it != data.numeric_edge_map_names.end(); ++it)
          {
            edge_map_names.push_back(*it);
            edge_map_types[*it] = MapValue::NUMERIC;
          }
          for (std::vector<std::string>::const_iterator it =
              data.string_edge_map_names.begin();
              it != data.string_edge_map_names.end(); ++it)
          {
            edge_map_names.push_back(*it);
            edge_map_types[*it] = MapValue::STRING;
          }

          readLGF(filename, read_edge_label,
              node_map_names, edge_map_names,
              node_map_types, edge_map_types,
              node_coord_xmap_name, node_coord_ymap_name,
              arrow_coord_xmap_name, arrow_coord_ymap_name);

          // generate edge labels
          if (!read_edge_label)
          {
            int l = 0;
            for (EdgeIt e(graph); e != INVALID; ++e)
            {
              edge_label[e] = l++;
            }
          }

          if (gen_node_coords)
          {
            // generate node coordinates
            int node_num = 0;
            for (NodeIt n(graph); n != INVALID; ++n) { node_num++; }
            const double pi = 3.142;
            double step = 2 * pi / (double) node_num;
            int i = 0;
            for (NodeIt n(graph); 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 (EdgeIt e(graph); e != INVALID; ++e)
            {
              if (graph.source(e) == graph.target(e))
              {
                setArrowCoords(e,
                    getNodeCoords(graph.source(e)) + XY(0.0, 80.0));
              }
              else
              {
                setArrowCoords(e,
                    (getNodeCoords(graph.source(e)) +
                     getNodeCoords(graph.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(graph); n != INVALID; ++n)
    {
      if (node_label[n] > max_node_label)
      {
        max_node_label = node_label[n];
      }
    }
  }
  // set max_edge_label
  {
    max_edge_label = std::numeric_limits<int>::min();
    for (EdgeIt e(graph); e != INVALID; ++e)
    {
      if (edge_label[e] > max_edge_label)
      {
        max_edge_label = edge_label[e];
      }
    }
  }

  return 0;
}

void MapStorage::writeToFile(const std::string &filename)
{
  // relabel nodes and edges
  int i = 0;
  for (NodeIt n(graph); n != INVALID; ++n)
  {
    node_label[n] = i++;
  }
  max_node_label = i-1;
  i = 0;
  for (EdgeIt e(graph); e != INVALID; ++e)
  {
    edge_label[e] = i++;
  }
  max_edge_label = i-1;

  // write .lgf file
  {
    GraphWriter<Graph> gwriter(filename, graph);

    gwriter.writeNodeMap("label", node_label);
    gwriter.writeEdgeMap("label", edge_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.writeNodeMap(it->first, getNumericNodeMap(it->first));
            break;
          case MapValue::STRING:
            gwriter.writeNodeMap(it->first, getStringNodeMap(it->first));
            break;
        }
      }
    }

    // write edge maps
    for (EdgeMapStore::const_iterator it = edgemaps.begin();
        it != edgemaps.end(); ++it)
    {
      if (it->second->save_dest == NESET_SECT)
      {
        switch (it->second->type())
        {
          case MapValue::NUMERIC:
            gwriter.writeEdgeMap(it->first, getNumericEdgeMap(it->first));
            break;
          case MapValue::STRING:
            gwriter.writeEdgeMap(it->first, getStringEdgeMap(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.writeNodeMap(node_coords_one_map_name + ":x",
                node_coords_x);
            gwriter.writeNodeMap(node_coords_one_map_name + ":y",
                node_coords_y);
            break;
          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
            gwriter.writeNodeMap(node_coords_two_maps_1_name,
                node_coords_x);
            gwriter.writeNodeMap(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.writeEdgeMap(arrow_coords_one_map_name + ":x",
                arrow_coords_x);
            gwriter.writeEdgeMap(arrow_coords_one_map_name + ":y",
                arrow_coords_y);
            break;
          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
            gwriter.writeEdgeMap(arrow_coords_two_maps_1_name,
                arrow_coords_x);
            gwriter.writeEdgeMap(arrow_coords_two_maps_2_name,
                arrow_coords_y);
            break;
        }
        break;
    }

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

  // write .conf file
  if (gui_sect_save_dest == CONF_FILE)
  {
    LemonWriter lwriter(filename + ".conf");
    GuiWriter gui_writer(lwriter, this);
    lwriter.run();
  }
}

void MapStorage::clear()
{
  for (NodeMapStore::iterator it = nodemaps.begin(); it != nodemaps.end(); ++it)
  {
    delete it->second;
    nodemaps.erase(it);
  }
  for (EdgeMapStore::iterator it = edgemaps.begin(); it != edgemaps.end(); ++it)
  {
    delete it->second;
    edgemaps.erase(it);
  }
  graph.clear();
  file_name = "";
  modified = false;
  max_node_label = 0;
  max_edge_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 itisedge, std::string mapname)
{
  if(itisedge)
  {
    for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      if(active_edgemaps[i]==mapname)
      {
        signal_prop.emit(itisedge, i);
      }
    }
  }
  else
  {
    for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      if(active_nodemaps[i]==mapname)
      {
        signal_prop.emit(itisedge, 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(Edge e) const
{
  return arrow_coords[e];
}

void MapStorage::setArrowCoords(Edge 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, Edge edge) const
{
  EdgeMapData* data = getEdgeMapData(name);
  return data->get(edge);
}

void MapStorage::set(const std::string& name, Edge edge, MapValue val)
{
  EdgeMapData* data = getEdgeMapData(name);
  data->set(edge, 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 = graph.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;
}

Edge MapStorage::addEdge(Node from, Node to)
{
  Edge edge = graph.addEdge(from, to);

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

  max_edge_label++;

  edge_label[edge] = max_edge_label;

  std::vector<std::string> edge_maps = getEdgeMapList();
  for (std::vector<std::string>::const_iterator it = edge_maps.begin();
      it != edge_maps.end(); ++it)
  {
    EdgeMapData* data = getEdgeMapData(*it);
    set(*it, edge, data->default_value);
  }
  return edge;
}

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::NumericEdgeMap& MapStorage::getNumericEdgeMap(const std::string& name)
{
  EdgeMapData* data = getEdgeMapData(name);
  if (data->type() != MapValue::NUMERIC)
    throw Error("Numeric edge map " + name + " does not exists.");
  return static_cast<NumericEdgeMapData*>(data)->map;
}

MapStorage::StringEdgeMap& MapStorage::getStringEdgeMap(const std::string& name)
{
  EdgeMapData* data = getEdgeMapData(name);
  if (data->type() != MapValue::STRING)
    throw Error("String edge map " + name + " does not exists.");
  return static_cast<StringEdgeMapData*>(data)->map;
}

MapValueEdgeMap MapStorage::getEdgeMap(const std::string& name)
{
  return MapValueEdgeMap(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(Edge e) const
{
  return edge_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::getEdgeMapSaveDest(std::string name) const
{
  EdgeMapData *data = getEdgeMapData(name);
  return data->save_dest;
}

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

void MapStorage::setEdgeMapSaveDest(std::string name, MapStorage::MapSaveDest dest)
{
  EdgeMapData *data = getEdgeMapData(name);
  data->save_dest = dest;
}

MapStorage::EdgeMapData* MapStorage::getEdgeMapData(std::string name) const
{
  EdgeMapStore::const_iterator it = edgemaps.find(name);
  if (it != edgemaps.end())
    return it->second;
  else
    throw Error("Edge 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::getEdgeMapElementType(std::string name) const
{
  EdgeMapData *data = getEdgeMapData(name);
  return data->type();
}

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

const MapStorage::EdgeLabelMap& MapStorage::getEdgeLabelMap()
{
  return edge_label;
}

const Graph& MapStorage::getGraph()
{
  return graph;
}

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

bool MapStorage::edgeMapExists(std::string name)
{
  EdgeMapStore::const_iterator it = edgemaps.find(name);
  if (it == edgemaps.end())
    return false;
  else
    return true;
}

std::vector<std::string> MapStorage::getEdgeMaps(MapType type)
{
  std::vector<std::string> maps;
  for (EdgeMapStore::const_iterator it = edgemaps.begin(); it != edgemaps.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_edge_label,
    const std::vector<std::string>& node_map_names,
    const std::vector<std::string>& edge_map_names,
    const std::map<std::string, MapValue::Type>& node_map_types,
    const std::map<std::string, MapValue::Type>& edge_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;

  GraphReader<Graph> greader(filename, graph);

  // read the label maps
  greader.readNodeMap("label", node_label);
  if (read_edge_label)
    greader.readEdgeMap("label", edge_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.readNodeMap(*it, getNumericNodeMap(*it));
          break;
        }
      case MapValue::STRING:
        {
          createNodeMap(*it, MapValue::STRING, string());
          greader.readNodeMap(*it, getStringNodeMap(*it));
          break;
        }
    }
    getNodeMapData(*it)->save_dest = NESET_SECT;
  }

  // read the edge maps
  for (vector<string>::const_iterator
      it = edge_map_names.begin();
      it != edge_map_names.end(); ++it)
  {
    switch (edge_map_types.find(*it)->second)
    {
      case MapValue::NUMERIC:
        {
          createEdgeMap(*it, MapValue::NUMERIC, double());
          greader.readEdgeMap(*it, getNumericEdgeMap(*it));
          break;
        }
      case MapValue::STRING:
        {
          createEdgeMap(*it, MapValue::STRING, string());
          greader.readEdgeMap(*it, getStringEdgeMap(*it));
          break;
        }
    }
    getEdgeMapData(*it)->save_dest = NESET_SECT;
  }

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

  // read the arrow coordinate maps
  if (arrow_coord_xmap_name != "")
    greader.readEdgeMap(arrow_coord_xmap_name, arrow_coords_x);
  if (arrow_coord_ymap_name != "")
    greader.readEdgeMap(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::exportGraphToEPS(std::vector<bool> options, std::string filename, std::string shapemap)
{
  Graph::NodeMap<int> _shapes(graph, 0);
  Graph::NodeMap<int> _nodeColors(graph, 0);
  Graph::EdgeMap<int> _edgeColors(graph, 0);
  Graph::NodeMap<double> _nodeSizes(graph, 6.0);
  Graph::EdgeMap<double> _edgeWidths(graph, 1.0);
  bool _drawArrows=options[ARROWS];
  bool _enableParallel=options[PAR];

  std::string emptyString="";
  Graph::NodeMap<std::string> _nodeTextMap(graph,emptyString);

  //_nodeTextMap=(Graph::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(graph);ni!=INVALID;++ni)
            {
              _nodeColors[ni]=(int)get(active_nodemaps[N_COLOR], ni);
            }
        }
      if(active_nodemaps[N_TEXT]!="")
        {
          for(NodeIt ni(graph);ni!=INVALID;++ni)
            {
              std::ostringstream o;
              o << get(active_nodemaps[N_TEXT], ni);
              _nodeTextMap[ni]=o.str();       
            }
        }
    }
  if(options[E_MAPS])
    {
      if(active_edgemaps[E_WIDTH]!="")
        {
          _edgeWidths=getNumericEdgeMap(active_edgemaps[E_WIDTH]);
        }
      if(active_edgemaps[E_COLOR]!="")
        {
          for(EdgeIt ei(graph);ei!=INVALID;++ei)
            {
              _edgeColors[ei]=(int)get(active_edgemaps[E_COLOR], ei);
            }
        }
    }
  if(shapemap!="Default values")
    {
      double min = std::numeric_limits<double>::max();
      double max = std::numeric_limits<double>::min();
      for (NodeIt n(graph); 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(graph); n != INVALID; ++n)
          {
            _shapes[n] = static_cast<int>(map[n]);
          }
        }
    }

  Palette palette;
  Palette paletteW(true);

  graphToEps(graph,filename).
    title("Sample .eps figure (fits to A4)").
    copyright("(C) 2006 LEMON Project").
    absoluteNodeSizes().absoluteEdgeWidths().
    nodeScale(2).nodeSizes(_nodeSizes).
    coords(node_coords).
    nodeShapes(_shapes).
    nodeColors(composeMap(paletteW,_nodeColors)).
    edgeColors(composeMap(palette,_edgeColors)).
    edgeWidthScale(0.3).edgeWidths(_edgeWidths).
    nodeTexts(_nodeTextMap).nodeTextSize(7).
    enableParallel(_enableParallel).parEdgeDist(5).
    drawArrows(_drawArrows).arrowWidth(7).arrowLength(7).
    run();

}