source: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Graph/OsmGraph.cs @ 8508

using System.Collections.Generic;
using HeuristicLab.Problems.RoutePlanning.Osm;
namespace HeuristicLab.Problems.RoutePlanning.Graph {
  public class OsmGraph {
    private IDataSource dataSource;

    public OsmGraph(IDataSource ds) {
      dataSource = ds;
    }

    public OsmVertex<Node> GetVertex(long id) {
      return new OsmVertex<Node>(dataSource.GetNode(id));
    }

    public List<Way> GetEdges(OsmVertex<Node> vertex) {
      return dataSource.GetWays(vertex.Node);
    }

    public Dictionary<long, float> GetNeighbors(long id) {
      OsmVertex<Node> vertex = GetVertex(id);
      Dictionary<long, float> neighbors = new Dictionary<long, float>();
      List<Way> edges = GetEdges(vertex);
      foreach (Way edge in edges) {
        //TODO: check if edge can be traversed (eg. highway tag for car roads, ...)

        // get all naighbours of current vertex on this edge
        List<OsmVertex<Node>> vertices = GetNeighborVerticesOnEdge(edge, vertex);
        foreach (OsmVertex<Node> neighbor in vertices) {
          if (edge.CanBeTraversed(vertex.Node, neighbor.Node)) {
            float weight = GetWeight(edge, vertex, neighbor);
            neighbors[neighbor.Node.Id] = weight;
          }
        }
      }
      return neighbors;
    }

    public Dictionary<long, float> GetNeighborsReversed(long id) {
      OsmVertex<Node> vertex = GetVertex(id);
      Dictionary<long, float> neighbors = new Dictionary<long, float>();
      List<Way> edges = GetEdges(vertex);
      foreach (Way edge in edges) {
        List<OsmVertex<Node>> vertices = GetNeighborVerticesOnEdge(edge, vertex);
        foreach (OsmVertex<Node> neighbor in vertices) {
          if (edge.CanBeTraversed(neighbor.Node, vertex.Node)) {
            float weight = GetWeight(edge, vertex, neighbor);
            neighbors[neighbor.Node.Id] = weight;
          }
        }
      }
      return neighbors;
    }

    public List<OsmVertex<Node>> GetNeighborVerticesOnEdge(Way edge, OsmVertex<Node> vertex) {
      List<OsmVertex<Node>> neighbors = new List<OsmVertex<Node>>();
      for (int i = 0; i < edge.Nodes.Count; i++) {
        Node node = edge.Nodes[i];
        if (node.Id == vertex.Node.Id) {
          if (i > 0) {
            neighbors.Add(GetVertex(edge.Nodes[i - 1].Id));
          }
          if (i < edge.Nodes.Count - 1) {
            neighbors.Add(GetVertex(edge.Nodes[i + 1].Id));
          }
        }
      }
      return neighbors;
    }

    public float GetWeight(Way edge, OsmVertex<Node> source, OsmVertex<Node> target) {
      double distance = Utils.Distance(source.Node.Point, target.Node.Point);
      //double distance = Utils.LocationDistance(source.Node.Point, target.Node.Point);
      int speed = edge.GetMaxSpeed();
      double weight = (distance / speed) * 3.6;
      //double weight = (distance / speed);
      return (float)weight;
    }

    public float EstimatedCosts(long sourceId, long targetId) {
      OsmVertex<Node> source = GetVertex(sourceId);
      OsmVertex<Node> target = GetVertex(targetId);
      return EstimatedCosts(source, target);
    }

    public float EstimatedCosts(OsmVertex<Node> source, OsmVertex<Node> target) {
      double distance = Utils.Distance(source.Node.Point, target.Node.Point);
      //double distance = Utils.LocationDistance(source.Node.Point, target.Node.Point);
      int speed = 130;
      double costs = (distance / speed) * 3.6;
      //double costs = (distance / speed);
      return (float)costs;
    }
  }
}