Index: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Graph/Graph.cs
===================================================================
--- branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Graph/Graph.cs	(revision 8301)
+++ branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Graph/Graph.cs	(revision 8308)
@@ -24,14 +24,97 @@
     }
 
-    //public Dictionary<long, float> GetNeighbours(long id) {
-    //  Vertex<Node> vertex = GetVertex(id);
-    //  Dictionary<long, float> neighbors = new Dictionary<long, float>();
-    //  IList<Way> edges = GetEdges(vertex);
-    //  foreach (Way edge in edges) {
+    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, ...)
 
-    //  }
-    //  return null;
-    //}
+        // get all naighbours of current vertex on this edge
+        List<Vertex<Node>> vertices = GetNeighborVerticesOnEdge(edge, vertex);
+        foreach (Vertex<Node> neighbor in vertices) {
+          float weight = GetWeight(edge, vertex, neighbor);
+          neighbors[neighbor.Id] = weight;
+        }
+      }
+      return null;
+    }
 
+    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;
+    }
   }
 }
Index: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/HeuristicLab.Problems.RoutePlanning.csproj
===================================================================
--- branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/HeuristicLab.Problems.RoutePlanning.csproj	(revision 8301)
+++ branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/HeuristicLab.Problems.RoutePlanning.csproj	(revision 8308)
@@ -65,7 +65,9 @@
     <Compile Include="Osm\OsmBase.cs" />
     <Compile Include="Osm\PointD.cs" />
+    <Compile Include="Osm\RectangleD.cs" />
     <Compile Include="Osm\Relation.cs" />
     <Compile Include="Osm\RelationMember.cs" />
     <Compile Include="Osm\TagConstants.cs" />
+    <Compile Include="Osm\Utils.cs" />
     <Compile Include="Osm\Way.cs" />
     <Compile Include="Plugin.cs" />
Index: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/Node.cs
===================================================================
--- branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/Node.cs	(revision 8301)
+++ branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/Node.cs	(revision 8308)
@@ -13,4 +13,8 @@
     }
 
+    public PointD Point {
+      get { return point; }
+    }
+
     public Node() {
       point = new PointD();
Index: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/RectangleD.cs
===================================================================
--- branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/RectangleD.cs	(revision 8308)
+++ branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/RectangleD.cs	(revision 8308)
@@ -0,0 +1,98 @@
+﻿using System;
+using System.Drawing;
+
+namespace HeuristicLab.Problems.RoutePlanning.Osm {
+  public class RectangleD {
+    private const int Digits = 4;
+    private double x;
+    private double y;
+    private double width;
+    private double height;
+
+    #region Properties
+
+    public double X {
+      get { return Math.Round(x, Digits); }
+      set { x = value; }
+    }
+
+    public double Y {
+      get { return Math.Round(y, Digits); }
+      set { y = value; }
+    }
+
+    public double Width {
+      get { return Math.Round(width, Digits); }
+      set { width = value; }
+    }
+
+    public double Height {
+      get { return Math.Round(height, Digits); }
+      set { height = value; }
+    }
+
+    public PointD TopLeft {
+      get { return new PointD(X, Y); }
+    }
+
+    public PointD BottomRight {
+      get { return new PointD(X + Width, Y + Height); }
+    }
+
+    public PointD Center {
+      get { return new PointD(X + Width / 2d, Y + Height / 2d); }
+    }
+
+    public double MaxSide {
+      get { return Math.Max(width, height); }
+    }
+
+    public double MinSide {
+      get { return Math.Min(width, height); }
+    }
+
+    #endregion
+
+    #region Constructors
+
+    public RectangleD(double x, double y, double w, double h) {
+      this.x = x;
+      this.y = y;
+      this.width = w;
+      this.height = h;
+    }
+
+    public RectangleD(RectangleD r) {
+      x = r.X;
+      y = r.Y;
+      width = r.Width;
+      height = r.Height;
+    }
+
+    #endregion
+
+    #region Operators
+
+    public static explicit operator RectangleF(RectangleD r) {
+      return new RectangleF((float)r.X, (float)r.Y, (float)r.Width, (float)r.Height);
+    }
+
+    #endregion
+
+    #region Overridden Methods
+
+    public override bool Equals(object obj) {
+      if (obj is RectangleD) {
+        RectangleD r = (RectangleD)obj;
+        return (X == r.X && Y == r.Y && Width == r.Width && Height == r.Height);
+      }
+      return false;
+    }
+
+    public override int GetHashCode() {
+      return ((RectangleF)this).GetHashCode();
+    }
+
+    #endregion
+  }
+}
Index: branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/Utils.cs
===================================================================
--- branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/Utils.cs	(revision 8308)
+++ branches/RoutePlanning/HeuristicLab.Problems.RoutePlanning/3.3/Osm/Utils.cs	(revision 8308)
@@ -0,0 +1,49 @@
+﻿using System;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.RoutePlanning.Osm {
+  public static class Utils {
+    public static double Distance(PointD p1, PointD p2) {
+      double dx = p2.X - p1.X;
+      double dy = p2.Y - p1.Y;
+      return Math.Sqrt(dx * dx + dy * dy);
+    }
+
+    public static double PathLength(IList<PointD> points) {
+      double length = 0;
+      for (int i = 1; i < points.Count; i++) {
+        length += Distance((PointD)points[i - 1], (PointD)points[i]);
+      }
+      return length;
+    }
+
+    public static RectangleD FindBox(IList<PointD> points) {
+      double minX = double.MaxValue;
+      double maxX = double.MinValue;
+      double minY = double.MaxValue;
+      double maxY = double.MinValue;
+
+      foreach (PointD p in points) {
+        if (p.X < minX)
+          minX = p.X;
+        if (p.X > maxX)
+          maxX = p.X;
+
+        if (p.Y < minY)
+          minY = p.Y;
+        if (p.Y > maxY)
+          maxY = p.Y;
+      }
+      return new RectangleD(minX, minY, maxX - minX, maxY - minY);
+    }
+
+    public static double PathDistance(IList<PointD> path1, IList<PointD> path2) {
+      double distance = 0;
+      for (int i = 0; i < path1.Count; i++) {
+        distance += Distance((PointD)path1[i], (PointD)path2[i]);
+      }
+      return distance / path1.Count;
+    }
+  }
+}
+
