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

using System.Collections.Generic;
using HeuristicLab.Problems.RoutePlanning.Osm;
namespace HeuristicLab.Problems.RoutePlanning.Graph {
  public class Graph {
    private IDataSource dataSource;
    private Dictionary<Node, List<Node>> vertexEdges;
    private Dictionary<long, Vertex<Node>> vertices;
    private Dictionary<Way, Dictionary<long, List<Vertex<Node>>>> resolvedList;

    public Graph(IDataSource ds) {
      dataSource = ds;
      vertexEdges = new Dictionary<Node, List<Node>>();
      vertices = new Dictionary<long, Vertex<Node>>();
      resolvedList = new Dictionary<Way, Dictionary<long, List<Vertex<Node>>>>();
    }

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

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

    public Dictionary<long, float> GetNeighbors(long id) {
      Vertex<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<Vertex<Node>> vertices = GetNeighborVerticesOnEdge(edge, vertex);
        foreach (Vertex<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 List<Vertex<Node>> GetNeighborVerticesOnEdge(Way edge, Vertex<Node> vertex) {
      List<Vertex<Node>> neighbors = new List<Vertex<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, Vertex<Node> source, Vertex<Node> target) {
      double distance = Utils.Distance(source.Node.Point, target.Node.Point);
      int speed = 0;

      //TODO: 
      HighwayType highwayType = edge.HighwayTag;
      switch (highwayType) {
        case HighwayType.bridleway:
        case HighwayType.bus_guideway:
        case HighwayType.raceway:
        case HighwayType.cycleway:
        case HighwayType.footway:
        case HighwayType.steps:
        case HighwayType.null_type:
          speed = 1;
          break;

        case HighwayType.path:
        case HighwayType.service:
        case HighwayType.pedestrian:
        case HighwayType.living_street:
          speed = 15;
          break;

        case HighwayType.road:
        case HighwayType.track:
          speed = 30;
          break;

        case HighwayType.tertiary:
        case HighwayType.tertiary_link:
        case HighwayType.secondary:
        case HighwayType.secondary_link:
          speed = 80;
          break;

        case HighwayType.unclassified:
        case HighwayType.residential:
          speed = 50;
          break;

        case HighwayType.trunk:
        case HighwayType.trunk_link:
        case HighwayType.primary:
        case HighwayType.primary_link:
          speed = 100;
          break;
        case HighwayType.motorway:
        case HighwayType.motorway_link:
          speed = 130;
          break;

        default:
          speed = 1;
          break;
      }

      double weight = (distance / speed) * 3.6;
      return (float)weight;
    }

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

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