OSMDatastructure/Coordinates.cs

@@ -47,6 +47,6 @@ public class Coordinates
     public override string ToString()
     {
         return
-            $"lat:{latitude.ToString(NumberFormatInfo.InvariantInfo)} lon:{longitude.ToString(CultureInfo.InvariantCulture)}";
+            $"COORDINATES Lat: {this.latitude.ToString(NumberFormatInfo.InvariantInfo)} Lon: {this.longitude.ToString(CultureInfo.InvariantCulture)}";
     }
 }

OSMDatastructure/OsmEdge.cs

@@ -19,6 +19,6 @@ public class OsmEdge
 
     public override string ToString()
     {
-        return $"w:{wayId} n1:{startId} n2:{neighborId} in r:{neighborRegion}";
+        return $"EDGE WayID: {wayId} StartID: {startId} NeighborID: {neighborId} in {neighborRegion}";
     }
 }

OSMDatastructure/OsmNode.cs

@@ -1,6 +1,3 @@
-using System.ComponentModel;
-using System.Runtime.Serialization;
-
 namespace OSMDatastructure.Graph;
 
 [Serializable]
@@ -14,14 +11,6 @@ public class OsmNode
     [NonSerialized]public double currentPathWeight = double.MaxValue;
     [NonSerialized]public double currentPathLength = double.MaxValue;
     [NonSerialized]public double directDistanceToGoal = double.MaxValue;
-
-    [OnDeserialized]
-    internal void SetDefaultValues(StreamingContext context)
-    {
-        currentPathWeight = double.MaxValue;
-        currentPathLength = double.MaxValue;
-        directDistanceToGoal = double.MaxValue;
-    }
     
     public OsmNode(ulong nodeId, float lat, float lon)
     {
@@ -39,10 +28,10 @@ public class OsmNode
     
     public OsmEdge? GetEdgeToNode(OsmNode n)
     {
-        HashSet<OsmEdge> e = edges.Where(edge => edge.neighborId == n.nodeId).ToHashSet();
+        foreach (OsmEdge e in this.edges)
-        if (e.Count > 0)
+            if (e.neighborId == n.nodeId)
-            return e.First();
+                return e;
-        else return null;
+        return null;
     }
 
     public override bool Equals(object? obj)
@@ -50,11 +39,22 @@ public class OsmNode
         return obj != null && obj.GetType() == this.GetType() && ((OsmNode)obj).nodeId == this.nodeId;
     }
 
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(coordinates);
+    }
+
     public override string ToString()
     {
-        if(previousPathNode is not null)
+        if(this.previousPathNode != null)
-            return $"{nodeId} {coordinates} ec:{edges.Count} d:{directDistanceToGoal} w:{currentPathWeight} l:{currentPathLength} p:{previousPathNode.nodeId}";
+            return string.Format(
-        return
+                "NODE {0} Edges-Count: {1} previousPathNode: {2} currentPathWeight: {3} currentPathLength: {4} directDistanceToGoal: {5}",
-            $"{nodeId} {coordinates} ec:{edges.Count} d:{directDistanceToGoal} w:{currentPathWeight} l:{currentPathLength} null";
+                this.coordinates.ToString(), this.edges.Count, this.previousPathNode.coordinates.ToString(),
+                this.currentPathWeight, this.currentPathLength, this.directDistanceToGoal);
+        else
+            return string.Format(
+                "NODE {0} Edges-Count: {1} previousPathNode: NO PREVIOUS NODE currentPathWeight: {2} currentPathLength: {3} directDistanceToGoal: {4}",
+                this.coordinates.ToString(), this.edges.Count, 
+                this.currentPathWeight, this.currentPathLength, this.directDistanceToGoal);
     }
 }

OSMDatastructure/Tag.cs

@@ -39,36 +39,36 @@ public class Tag
             case "highway":
                 try
                 {
-                    return new Tag(TagType.highway, (WayType)Enum.Parse(typeof(WayType), value, true));
+                    return new Tag(Tag.TagType.highway, (Tag.WayType)Enum.Parse(typeof(Tag.WayType), value, true));
                 }
                 catch (ArgumentException)
                 {
-                    return new Tag(TagType.highway, WayType.unclassified);
+                    return new Tag(Tag.TagType.highway, Tag.WayType.unclassified);
                 }
             case "maxspeed":
                 try
                 {
                     byte speed = Convert.ToByte(value);
                     if (speed == 255)
-                        return new Tag(TagType.highway, false);
+                        return new Tag(Tag.TagType.highway, false);
                     else
-                        return new Tag(TagType.maxspeed, speed);
+                        return new Tag(Tag.TagType.maxspeed, speed);
                 }
                 catch (Exception)
                 {
                     //Console.WriteLine(e);
                     //Console.WriteLine("Continuing...");
-                    return new Tag(TagType.maxspeed, byte.MaxValue);
+                    return new Tag(Tag.TagType.maxspeed, byte.MaxValue);
                 }
             case "oneway":
                 switch (value)
                 {
                     case "yes":
-                        return new Tag(TagType.oneway, true);
+                        return new Tag(Tag.TagType.oneway, true);
                     case "-1":
-                        return new Tag(TagType.forward, false);
+                        return new Tag(Tag.TagType.forward, false);
                     case "no":
-                        return new Tag(TagType.oneway, false);
+                        return new Tag(Tag.TagType.oneway, false);
                 }
 
                 break;

OSMDatastructure/TagManager.cs

@@ -14,7 +14,7 @@ public class TagManager
 
     public object? GetTag(ulong wayId, Tag.TagType key)
     {
-        return ContainsKey(wayId, key) ? wayTagSets[wayId].First(tag => tag.key == key).value : null;
+        return ContainsKey(wayId, key) ? wayTagSets[wayId].First(tag => tag.key == key) : null;
     }
     
     public void AddTag(ulong wayId, string key, string value)

Pathfinding/Pathfinder.cs

@@ -6,13 +6,20 @@ namespace Pathfinding;
 
 public class Pathfinder
 {
-    public static List<OsmNode> CustomAStar(string workingDir, Coordinates start, Coordinates goal, Tag.SpeedType vehicle)
+ /*
+    public static List<OsmNode> CustomAStar(string workingDir, Coordinates start, Coordinates goal, OsmWay.speedType vehicle)
     {
         RegionManager regionManager = new RegionManager(workingDir);
-        Region? startRegion = regionManager.GetRegion(start);
+        Region startRegion, goalRegion;
-        Region? goalRegion = regionManager.GetRegion(goal);
+        try
-        if (startRegion is null || goalRegion is null)
+        {
-            return new List<OsmNode>();
+            startRegion = regionManager.GetRegion(start);
+            goalRegion = regionManager.GetRegion(goal);
+        }
+        catch (FileNotFoundException e)
+        {
+            throw new Exception(string.Format("No region at coordinates {0}", e.FileName), e);
+        }
 
         OsmNode? startNode = ClosestNodeToCoordinates(start, startRegion);
         OsmNode? goalNode = ClosestNodeToCoordinates(goal, goalRegion);
@@ -29,20 +36,25 @@ public class Pathfinder
         {
             //Console.WriteLine("toVisit-length: {0}", toVisit.Count);
             closestNodeToGoal = toVisit.First();
-            foreach (OsmNode node in toVisit.Where(node => node.directDistanceToGoal.Equals(Double.MaxValue)))
+            foreach (OsmNode node in toVisit)
             {
-                node.directDistanceToGoal = Utils.DistanceBetween(node, goalNode);
+                if (node.directDistanceToGoal.Equals(double.MaxValue))
+                {
+                    node.directDistanceToGoal = Utils.DistanceBetween(node, goalNode);
+                }
+                if (node.directDistanceToGoal < closestNodeToGoal.directDistanceToGoal)
+                {
+                    closestNodeToGoal = node;
+                }
             }
 
-            closestNodeToGoal = toVisit.OrderBy(node => node.directDistanceToGoal).First();
+            foreach (OsmWay edge in closestNodeToGoal.edges)
-
-            foreach (OsmEdge edge in closestNodeToGoal.edges)
             {
-                OsmNode? neighbor = regionManager.GetNode(edge.neighborId, edge.neighborRegion);
+                OsmNode? neighbor = regionManager.GetNode(edge.neighborCoordinates);
-                if (neighbor is not null)
+                if (neighbor != null)
                 {
                     double newPotentialWeight =
-                        closestNodeToGoal.currentPathWeight + EdgeWeight(closestNodeToGoal, neighbor, edge.wayId, vehicle, ref regionManager);
+                        closestNodeToGoal.currentPathWeight + edge.GetWeight(closestNodeToGoal, vehicle);
                     if (neighbor.currentPathWeight > newPotentialWeight)
                     {
                         neighbor.previousPathNode = closestNodeToGoal;
@@ -88,32 +100,5 @@ public class Pathfinder
         }
 
         return closest;
-    }
+    }*/
-
-    private static double EdgeWeight(OsmNode node1, OsmNode node2, ulong wayId, Tag.SpeedType vehicle, ref RegionManager regionManager)
-    {
-        TagManager tags = regionManager.GetRegion(node1.coordinates)!.tagManager;
-        double distance = Utils.DistanceBetween(node1, node2);
-        Tag.WayType wayType = (Tag.WayType)tags.GetTag(wayId, Tag.TagType.highway)!;
-        switch (vehicle)
-        {
-            case Tag.SpeedType.pedestrian:
-                byte speed = Tag.defaultSpeedPedestrian[wayType];
-                if(speed is not 0)
-                    return distance / speed;
-                else return Double.PositiveInfinity;
-            case Tag.SpeedType.car: 
-            case Tag.SpeedType.road:
-                byte? maxspeed = (byte?)tags.GetTag(wayId, Tag.TagType.maxspeed);
-                if (maxspeed is not null)
-                    return distance / Convert.ToDouble(maxspeed);
-                else
-                    maxspeed = Tag.defaultSpeedCar[wayType];
-                if(maxspeed is not 0)
-                    return distance / Tag.defaultSpeedCar[wayType];
-                else return Double.PositiveInfinity;;
-            default:
-                return double.PositiveInfinity;
-        }
-    }
 }

Pathfinding/RegionManager.cs

@@ -12,21 +12,21 @@ namespace OSMImporter
         {
             this.workingDirectory = workingDirectory;
         }
-
+        
-        public Region? GetRegion(Coordinates coordinates)
+        /// <summary>
+        /// Checks wether the Region is already loaded and returns the Region, or tries to load the Region from file in workingDirectory
+        /// </summary>
+        /// <param name="coordinates">Coordinates of the Region (or within the Region) to load</param>
+        /// <returns>The Region at the specified Coordinates containing Nodes and Connections</returns>
+        /// <exception cref="FileNotFoundException">If the Regionfile can not be found.</exception>
+        public Region GetRegion(Coordinates coordinates)
         {
-            return GetRegion(Coordinates.GetRegionHashCode(coordinates));
+            if(_regions.ContainsKey(Coordinates.GetRegionHashCode(coordinates)))
-        }
+                return _regions[Coordinates.GetRegionHashCode(coordinates)];
-
-        public Region? GetRegion(ulong id)
-        {
-            if(_regions.TryGetValue(id, out Region? value))
-                return value;
             else
             {
-                Region? loadedRegion = LoadRegion(id);
+                Region loadedRegion = LoadRegion(coordinates);
-                if(loadedRegion is not null)
+                _regions.Add(loadedRegion.regionHash, value: loadedRegion);
-                    _regions.Add(loadedRegion!.regionHash, value: loadedRegion);
                 return loadedRegion;
             }
         }
@@ -35,29 +35,22 @@ namespace OSMImporter
         {
             return this._regions.Values.ToArray();
         }
-
+        
-        private Region? LoadRegion(Coordinates coordinates)
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="coordinates">Coordinates of the Region (or within the Region) to load</param>
+        /// <returns>The Region at the specified Coordinates containing Nodes and Connections</returns>
+        /// <exception cref="FileNotFoundException">If the Regionfile can not be found.</exception>
+        private Region LoadRegion(Coordinates coordinates)
         {
-            return LoadRegion(Coordinates.GetRegionHashCode(coordinates));
+            throw new NotImplementedException();
-        }
-
-        private Region? LoadRegion(ulong id)
-        {
-            return Region.FromId(workingDirectory, id);
         }
 
         public OsmNode? GetNode(Coordinates coordinates)
         {
-            Region? regionWithNode = GetRegion(coordinates);
+            Region regionWithNode = GetRegion(coordinates);
-            if (regionWithNode is not null)
+            return regionWithNode.GetNode(coordinates);
-                return regionWithNode.GetNode(coordinates);
-            else return null;
-        }
-
-        public OsmNode? GetNode(ulong nodeId, ulong regionId)
-        {
-            Region? r = GetRegion(regionId);
-            return r?.GetNode(nodeId);
         }
     }
 }

Server/Server.cs

@@ -1,6 +1,5 @@
 using OSMDatastructure;
 using OSMDatastructure.Graph;
-using Pathfinding;
 
 namespace Server;
 
@@ -14,13 +13,15 @@ public class Server
         Console.SetError(newConsole);
        
         //RegionConverter.ConvertXMLToRegions("D:/stuttgart-regbez-latest.osm", "D:/stuttgart-regbez-latest");
-        //RegionConverter.ConvertXMLToRegions("D:/map.osm", "D:/map");
+        RegionConverter.ConvertXMLToRegions("D:/map.osm", "D:/map");
         Console.WriteLine("Loaded");
+        Region? r = Region.FromFile("D:/map/13870001898000.region");
+        Console.WriteLine("loaded region");
 
-        
+        /*
-        Coordinates start = new Coordinates(48.7933989f, 9.8301467f);
+        Coordinates start = new Coordinates(48.243351f, 11.640417f);
-        Coordinates finish = new Coordinates(48.7906258f, 9.8355983f);
+        Coordinates finish = new Coordinates(48.25239f, 11.53272f);
-        OsmNode[] path = Pathfinder.CustomAStar("D:/map", start, finish, Tag.SpeedType.pedestrian).ToArray();
+        OsmNode[] path = Pathfinder.CustomAStar("/home/glax/Downloads/oberbayern-latest", start, finish, OsmEdge.speedType.car).ToArray();
         Console.WriteLine("{0}\n", path[0].ToString());
         for (int i = 0; i < path.Length - 1; i++)
         {
@@ -32,6 +33,6 @@ public class Server
             else
                 Console.WriteLine("NO EDGE\n{0}", n2.ToString());
         }
-        Console.WriteLine();
+        Console.WriteLine();*/
     }
 }