source: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm.Data/XmlDataSource.cs @ 8471

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using HeuristicLab.Problems.RoutePlanning.Graph;
namespace HeuristicLab.Problems.RoutePlanning.Osm.Data {
  public class XmlDataSource : IDataSource {
    private FileInfo file;

    private IDictionary<long, Node> nodes;
    private IDictionary<long, Way> ways;
    private IDictionary<long, Relation> relations;

    private IDictionary<long, List<long>> nodeWays;


    #region Properties

    public bool IsReadOnly {
      get {
        if (file.Exists && file.IsReadOnly) {
          return true;
        }
        return false;
      }
    }

    public string Name {
      get { return file.Name; }
    }

    #endregion

    #region Constructors

    public XmlDataSource(string filename) {
      file = new FileInfo(filename);

      nodes = new Dictionary<long, Node>();
      ways = new Dictionary<long, Way>();
      relations = new Dictionary<long, Relation>();

      nodeWays = new Dictionary<long, List<long>>();

      ReadData();
    }

    #endregion

    #region Public Methods

    public Node GetNode(long nodeId) {
      if (nodes.ContainsKey(nodeId)) {
        return nodes[nodeId];
      }
      return null;
    }

    public Way GetWay(long wayId) {
      if (ways.ContainsKey(wayId)) {
        return ways[wayId];
      }
      return null;
    }

    public List<Way> GetWays(Node node) {
      if (nodeWays.ContainsKey(node.Id)) {
        List<long> wayIds = nodeWays[node.Id];
        List<Way> result = new List<Way>(wayIds.Count);
        for (int i = 0; i < wayIds.Count; i++) {
          result.Add(GetWay(wayIds[i]));
        }
        return result;
      }
      return null;
    }

    public Relation GetRelation(long relationId) {
      if (relations.ContainsKey(relationId)) {
        return relations[relationId];
      }
      return null;
    }

    public IGraph GetRoutingGraph() {
      IGraph graph = new Graph.Graph();
      foreach (Way way in ways.Values) {
        List<Node> nodes = way.Nodes;
        for (int i = 0; i < way.Nodes.Count - 1; i++) {
          Vertex v1 = new Vertex(nodes[i].Id, nodes[i].Longitude, nodes[i].Latitude);
          graph.AddVertex(v1);
          Vertex v2 = new Vertex(nodes[i + 1].Id, nodes[i + 1].Longitude, nodes[i + 1].Latitude);
          if (v1.Id == 370626403) {
            Console.WriteLine();
          }
          graph.AddVertex(v2);
          if (way.OneWay) {
            Edge<Vertex> edge = new Edge<Vertex>(v1, v2);
            edge.Category = (short)way.HighwayTag;
            graph.AddEdge(edge);
          } else {
            Edge<Vertex> edgeForward = new Edge<Vertex>(v1, v2);
            edgeForward.Category = (short)way.HighwayTag;
            graph.AddEdge(edgeForward);

            Edge<Vertex> edgeBackward = new Edge<Vertex>(v2, v1);
            edgeForward.Category = (short)way.HighwayTag;
            graph.AddEdge(edgeBackward);
          }

        }
      }
      return graph;
    }

    #endregion

    #region Private Methods

    private void ReadData() {
      XmlReaderSettings settings = new XmlReaderSettings();
      settings.IgnoreComments = true;
      settings.IgnoreWhitespace = true;

      using (XmlReader reader = XmlReader.Create(file.FullName, settings)) {
        reader.ReadStartElement("osm");
        //reader.ReadStartElement("bounds");
        reader.Read();
        while (reader.LocalName.Equals("node")) {
          Node node = new Node();

          double lat = XmlConvert.ToDouble(reader.GetAttribute("lat"));
          double lon = XmlConvert.ToDouble(reader.GetAttribute("lon"));

          GetBaseAttributes(reader, node);
          node.Latitude = lat;
          node.Longitude = lon;

          reader.Read();
          if (reader.LocalName.Equals("tag")) {
            while (reader.LocalName.Equals("tag")) {
              string key = reader.GetAttribute("k");
              string value = reader.GetAttribute("v");
              node.Tags.Add(key, value);
              reader.Read();
            }
            reader.Read();
          }

          nodes.Add(node.Id, node);
        }
        while (reader.LocalName.Equals("way")) {
          Way way = new Way();
          GetBaseAttributes(reader, way);
          reader.Read();
          bool missingNodes = false;
          while (reader.LocalName.Equals("nd") || reader.LocalName.Equals("tag")) {
            if (reader.LocalName.Equals("nd")) {
              long refNodeId = XmlConvert.ToInt64(reader.GetAttribute("ref"));
              Node refNode = GetNode(refNodeId);
              if (refNode != null) {
                way.Nodes.Add(refNode);
              } else {
                missingNodes = true;
              }

            } else if (reader.LocalName.Equals("tag")) {
              string key = reader.GetAttribute("k");
              string value = reader.GetAttribute("v");
              way.Tags.Add(key, value);
            }
            reader.Read();
          }
          if (missingNodes) {
            // TODO: Error/Trace output 
            // if Way xxx has incomplete nodes. At least one node was missing in the data.
          }
          ways.Add(way.Id, way);
          InsertNodeWayRelation(way);

          reader.Read();
        }
        while (reader.LocalName.Equals("relation")) {
          Relation relation = new Relation();
          GetBaseAttributes(reader, relation);

          reader.Read();
          while (reader.LocalName.Equals("member") || reader.LocalName.Equals("tag")) {
            if (reader.LocalName.Equals("member")) {
              string type = reader.GetAttribute("type");
              long refNodeId = XmlConvert.ToInt64(reader.GetAttribute("ref"));
              string role = reader.GetAttribute("role");
              RelationMember member = new RelationMember();
              member.Role = role;
              if (type == "node") {
                member.Member = GetNode(refNodeId);
              } else if (type == "way") {
                member.Member = GetWay(refNodeId);
              }
              relation.Members.Add(member);
            } else if (reader.LocalName.Equals("tag")) {
              string key = reader.GetAttribute("k");
              string value = reader.GetAttribute("v");
              relation.Tags.Add(key, value);
            }
            reader.Read();
          }

          relations.Add(relation.Id, relation);

          reader.Read();
        }
        reader.Close();
      }
    }

    private void GetBaseAttributes(XmlReader reader, OsmBase obj) {
      obj.Id = XmlConvert.ToInt64(reader.GetAttribute("id"));
      //Console.WriteLine("id:" + obj.Id);

      if (reader.GetAttribute("user") != null) {
        obj.User = reader.GetAttribute("user");
      }
      if (reader.GetAttribute("uid") != null) {
        obj.UserId = XmlConvert.ToInt32(reader.GetAttribute("uid"));
      }
      if (reader.GetAttribute("visible") != null) {
        obj.Visible = XmlConvert.ToBoolean(reader.GetAttribute("visible"));
      }
      if (reader.GetAttribute("version") != null) {
        obj.Version = XmlConvert.ToInt32(reader.GetAttribute("version"));
      }
      if (reader.GetAttribute("changeset") != null) {
        obj.Changeset = XmlConvert.ToInt64(reader.GetAttribute("changeset"));
      }
      if (reader.GetAttribute("timestamp") != null) {
        obj.Timestamp = XmlConvert.ToDateTime(reader.GetAttribute("timestamp"), XmlDateTimeSerializationMode.Utc);
      }

    }

    private void InsertNodeWayRelation(Way way) {
      foreach (Node node in way.Nodes) {
        if (!nodeWays.ContainsKey(node.Id)) {
          nodeWays.Add(node.Id, new List<long>());
        }
        nodeWays[node.Id].Add(way.Id);
      }
    }

    #endregion
  }
}