unnecessary type-conversion.

This way standardized rendering methods can be implemented.

API/Program.cs

@@ -1,4 +1,3 @@
-using System.Text.Json.Serialization;
 using OSMDatastructure;
 using OSMDatastructure.Graph;
 using Pathfinding;
@@ -14,20 +13,18 @@ builder.Services.AddSwaggerGen();
 
 var app = builder.Build();
 
-app.MapGet("/getRoute", (float latStart, float lonStart, float latEnd, float lonEnd, Tag.SpeedType vehicle, double stayOnSameRoadPriority, double useHigherLevelRoadsPriority, double useRoadsWithLessJunctionsPriority) =>
+app.MapGet("/getRoute", (float latStart, float lonStart, float latEnd, float lonEnd, Tag.SpeedType vehicle, double useHigherLevelRoadsPriority, double maxTurnAngle) =>
     {
-        Pathfinder result = new Pathfinder("D:/stuttgart-regbez-latest").AStar(new Coordinates(latStart, lonStart),
+        Pathfinder result = new Pathfinder("D:/stuttgart-regbez-latest", useHigherLevelRoadsPriority,  maxTurnAngle).AStar(new Coordinates(latStart, lonStart),
-            new Coordinates(latEnd, lonEnd), vehicle, useHigherLevelRoadsPriority, stayOnSameRoadPriority,
+            new Coordinates(latEnd, lonEnd), vehicle, 3);
-            useRoadsWithLessJunctionsPriority);
         return result.pathResult;
     } 
 );
 
 app.MapGet("/getShortestRoute", (float latStart, float lonStart, float latEnd, float lonEnd) =>
     {
-        Pathfinder result = new Pathfinder("D:/stuttgart-regbez-latest").AStar(new Coordinates(latStart, lonStart),
+        Pathfinder result = new Pathfinder("D:/stuttgart-regbez-latest", 0, 30).AStar(new Coordinates(latStart, lonStart),
-            new Coordinates(latEnd, lonEnd), Tag.SpeedType.any, 0, 0,
+            new Coordinates(latEnd, lonEnd), Tag.SpeedType.any, 3);
-            0);
         return result.pathResult;
     }
 );

OSMDatastructure/Graph/Coordinates.cs

@@ -21,8 +21,7 @@ public class Coordinates
         if (obj == null || obj.GetType() != this.GetType())
             return false;
         Coordinates convObj = (Coordinates)obj;
-        // ReSharper disable twice CompareOfFloatsByEqualityOperator static values
+        return convObj.latitude.Equals(this.latitude) && convObj.longitude.Equals(longitude);
-        return convObj.latitude == this.latitude && convObj.longitude == this.longitude;
     }
 
     public static ulong GetRegionHashCode(float latitude, float longitude)
@@ -49,6 +48,6 @@ public class Coordinates
     public override string ToString()
     {
         return
-            $"lat:{latitude.ToString(NumberFormatInfo.InvariantInfo)} lon:{longitude.ToString(CultureInfo.InvariantCulture)}";
+            $"Coordinates lat:{latitude.ToString(NumberFormatInfo.InvariantInfo)} lon:{longitude.ToString(CultureInfo.InvariantCulture)}";
     }
 }

OSMDatastructure/Graph/OsmEdge.cs

@@ -22,6 +22,6 @@ public class OsmEdge
 
     public override string ToString()
     {
-        return $"w:{wayId} n1:{startId} n2:{neighborId} in r:{neighborRegion}";
+        return $"Edge wayId:{wayId} n1:{startId} n2:{neighborId} in regionId:{neighborRegion}";
     }
 }

OSMDatastructure/Graph/OsmNode.cs

@@ -12,15 +12,15 @@ public class OsmNode
     public OsmNode(ulong nodeId, float lat, float lon)
     {
         this.nodeId = nodeId;
-        this.edges = new();
+        edges = new();
-        this.coordinates = new Coordinates(lat, lon);
+        coordinates = new Coordinates(lat, lon);
     }
 
     [JsonConstructor]
     public OsmNode(ulong nodeId, Coordinates coordinates)
     {
         this.nodeId = nodeId;
-        this.edges = new();
+        edges = new();
         this.coordinates = coordinates;
     }
     
@@ -29,7 +29,8 @@ public class OsmNode
         HashSet<OsmEdge> e = edges.Where(edge => edge.neighborId == n.nodeId).ToHashSet();
         if (e.Count > 0)
             return e.First();
-        else return null;
+        
+        return null;
     }
 
     public override bool Equals(object? obj)
@@ -39,6 +40,6 @@ public class OsmNode
 
     public override string ToString()
     {
-        return $"{nodeId} {coordinates} ec:{edges.Count}";
+        return $"Node id:{nodeId} coordinates:{coordinates} edges-count:{edges.Count}";
     }
 }

OSMDatastructure/Region.cs

@@ -47,16 +47,12 @@ public class Region
 
     public OsmNode? GetNode(ulong id)
     {
-        if (ContainsNode(id))
+        return ContainsNode(id) ? nodes.First(node => node.nodeId == id) : null;
-            return nodes.First(node => node.nodeId == id);
-        else return null;
     }
 
     public OsmNode? GetNode(Coordinates coordinates)
     {
-        if (ContainsNode(coordinates))
+        return ContainsNode(coordinates) ? nodes.First(node => node.coordinates.Equals(coordinates)) : null;
-            return nodes.First(node => node.coordinates.Equals(coordinates));
-        else return null;
     }
 
 }

OSMDatastructure/Tag.cs

@@ -18,7 +18,7 @@ public class Tag
             switch (key)
             {
                 case TagType.highway:
-                    this.value = (WayType)value.GetByte();
+                    this.value = value.GetByte();
                     break;
                 case TagType.maxspeed:
                     this.value = value.GetByte();
@@ -61,6 +61,7 @@ public class Tag
                 }
                 break;
             case "maxspeed":
+            case "maxspeed:max":
                 try
                 {
                     byte speed = Convert.ToByte(value);
@@ -111,8 +112,8 @@ public class Tag
 
     public static readonly Dictionary<WayType, byte> defaultSpeedCar = new() {
         { WayType.NONE, 0 },
-        { WayType.motorway, 100 },
+        { WayType.motorway, 130 },
-        { WayType.motorroad, 90 },
+        { WayType.motorroad, 100 },
         { WayType.trunk, 85 },
         { WayType.primary, 65 },
         { WayType.secondary, 60 },

OSMDatastructure/TagManager.cs

@@ -1,5 +1,4 @@
 using System.Text.Json.Serialization;
-using OSMDatastructure.Graph;
 
 namespace OSMDatastructure;
 

OSMDatastructure/Utils.cs

@@ -65,12 +65,12 @@ namespace OSMDatastructure
             return d;
         }
 
-        private static double DegreesToRadians(double deg)
+        public static double DegreesToRadians(double deg)
         {
             return deg * Math.PI / 180.0;
         }
 
-        private static double RadiansToDegrees(double rad)
+        public static double RadiansToDegrees(double rad)
         {
             return rad * 180.0 / Math.PI;
         }

Pathfinding/PathNode.cs

@@ -1,4 +1,3 @@
-using System.Diagnostics.Tracing;
 using System.Text.Json.Serialization;
 using OSMDatastructure;
 using OSMDatastructure.Graph;

Pathfinding/PathResult.cs

@@ -1,16 +1,27 @@
+using System.Text.Json;
 using System.Text.Json.Serialization;
 
 namespace Pathfinding;
 
 public class PathResult
 {
+    [JsonInclude]public double distance;
+    [JsonInclude]public double weight;
     [JsonInclude]public TimeSpan calcTime;
     [JsonInclude]public List<PathNode> pathNodes;
     
     [JsonConstructor]
-    public PathResult(TimeSpan calcTime, List<PathNode> pathNodes)
+    public PathResult(TimeSpan calcTime, List<PathNode> pathNodes, double distance, double weight)
     {
         this.calcTime = calcTime;
         this.pathNodes = pathNodes;
+        this.distance = distance;
+        this.weight = weight;
+    }
+
+    public static PathResult PathresultFromFile(string filePath)
+    {
+        return JsonSerializer.Deserialize<PathResult>(new FileStream(filePath, FileMode.Open, FileAccess.Read,
+            FileShare.Read))!;
     }
 }

Pathfinding/Pathfinder.cs

@@ -2,210 +2,227 @@
 using OSMDatastructure;
 using OSMDatastructure.Graph;
 using static OSMDatastructure.Tag;
-using WayType = OSMDatastructure.Tag.WayType;
 
 namespace Pathfinding;
 
-//TODO check parameters for all functions and determine global fields
 public class Pathfinder
 {
 
     public RegionManager regionManager;
-    public readonly string workingDir;
     public PathResult? pathResult;
     public Dictionary<OsmNode, double>? gScore;
+    private Dictionary<OsmNode, OsmNode>? _cameFromDict;
+    private SpeedType _speedType;
+    private double roadPriorityFactor, turnAngle;
 
-    public Pathfinder(string workingDirectory)
+    public Pathfinder(string workingDirectory, double roadPriorityFactor, double turnAngle)
     {
         if (!Path.Exists(workingDirectory))
             throw new DirectoryNotFoundException(workingDirectory);
         regionManager = new(workingDirectory);
-        workingDir = workingDirectory;
+        this.roadPriorityFactor = roadPriorityFactor;
+        this.turnAngle = turnAngle;
     }
-    
+
-    public Pathfinder AStar(Coordinates startCoordinates, Coordinates goalCoordinates,
+    public Pathfinder(RegionManager regionManager, double roadPriorityFactor, double turnAngle)
-        SpeedType vehicle, double heuristicRoadLevelPriority, double heuristicSameRoadPriority,
+    {
-        double heuristicFewJunctionsPriority)
+        this.regionManager = regionManager;
+        this.roadPriorityFactor = roadPriorityFactor;
+        this.turnAngle = turnAngle;
+    }
+
+    public Pathfinder AStar(Coordinates startCoordinates, Coordinates goalCoordinates, SpeedType vehicle, double extraTime)
     {
         DateTime startCalc = DateTime.Now;
-        regionManager = new RegionManager(workingDir);
+        _speedType = vehicle;
-        OsmNode? startNode = regionManager.ClosestNodeToCoordinates(startCoordinates, vehicle);
+        OsmNode? startNode = regionManager.ClosestNodeToCoordinates(startCoordinates, _speedType);
-        OsmNode? goalNode = regionManager.ClosestNodeToCoordinates(goalCoordinates, vehicle);
+        OsmNode? goalNode = regionManager.ClosestNodeToCoordinates(goalCoordinates, _speedType);
         if (startNode is null || goalNode is null)
         {
-            pathResult = new(DateTime.Now - startCalc, new List<PathNode>());
+            pathResult = new(DateTime.Now - startCalc, new List<PathNode>(),0 ,0);
             return this;
         }
 
-        PriorityQueue<OsmNode, double> openSetfScore = new();
+        RPriorityQueue<OsmNode, double> openSetfScore = new();
         openSetfScore.Enqueue(startNode, 0);
-        Dictionary<OsmNode, OsmNode> cameFromDict = new();
         gScore = new() { { startNode, 0 } };
+        _cameFromDict = new();
 
-        while (openSetfScore.Count > 0)
+        bool found = false;
+        bool stop = false;
+        TimeSpan firstFound = TimeSpan.MaxValue;
+        double maxGscore = double.MaxValue;
+
+        while (openSetfScore.Count > 0 && !stop)
         {
-            OsmNode currentNode = openSetfScore.Dequeue();
+            OsmNode currentNode = openSetfScore.Dequeue()!;
             if (currentNode.Equals(goalNode))
             {
-                Console.WriteLine("Path found.");
+                if (!found)
-                this.pathResult = GetPath(cameFromDict, goalNode, DateTime.Now - startCalc);
+                {
-                return this;
+                    firstFound = DateTime.Now - startCalc;
+                    found = true;
+                    Console.WriteLine($"First: {firstFound} Multiplied by {extraTime}: {firstFound.Multiply(extraTime)}");
+                }
+                maxGscore = gScore[goalNode];
             }
 
+            if (found && DateTime.Now - startCalc > firstFound.Multiply(extraTime))
+                stop = true;
+
             foreach (OsmEdge edge in currentNode.edges)
             {
                 OsmNode? neighbor = regionManager.GetNode(edge.neighborId, edge.neighborRegion);
                 if (neighbor is not null)
                 {
-                    double tentativeGScore =
+                    double tentativeGScore = gScore[currentNode] + Weight(currentNode, neighbor, edge);
-                        gScore[currentNode] + Weight(currentNode, neighbor, edge, vehicle);
                     gScore.TryAdd(neighbor, double.MaxValue);
-                    if (tentativeGScore < gScore[neighbor])
+                    if ((!found || (found && tentativeGScore < maxGscore)) && tentativeGScore < gScore[neighbor])
                     {
-                        if (cameFromDict.ContainsKey(neighbor))
+                        if(!_cameFromDict.TryAdd(neighbor, currentNode))
-                            cameFromDict[neighbor] = currentNode;
+                            _cameFromDict[neighbor] = currentNode;
-                        else
+                        gScore[neighbor] = tentativeGScore;
-                            cameFromDict.Add(neighbor, currentNode);
+                        double h = Heuristic(currentNode, neighbor, goalNode, edge);
-                        if (gScore.ContainsKey(neighbor))
-                            gScore[neighbor] = tentativeGScore;
-                        else
-                            gScore.Add(neighbor, tentativeGScore);
-                        double h = Heuristic(currentNode, neighbor, goalNode, edge, vehicle,
-                            heuristicRoadLevelPriority, heuristicFewJunctionsPriority, heuristicSameRoadPriority);
-                        //Console.WriteLine($"Queue: {openSetfScore.Count:00000} Current Distance: {Utils.DistanceBetween(currentNode, goalNode):000000.00} Visited: {cameFromDict.Count:00000} Current heuristic: {h:00000.00}");
                         openSetfScore.Enqueue(neighbor, tentativeGScore + h);
                     }
                 }
             }
         }
-
+        
-        pathResult = new(DateTime.Now - startCalc, new List<PathNode>());
+        TimeSpan calcTime = DateTime.Now - startCalc;
+        if (!found)
+        {
+            pathResult = new(DateTime.Now - startCalc, new List<PathNode>(),0 ,0);
+            Console.Write("No path found.");
+            return this;
+        }
+        else
+        {
+            pathResult = GetPath(goalNode, calcTime);
+        }
+        Console.WriteLine($"Path found. {calcTime} PathLength {pathResult.pathNodes.Count} VisitedNodes {gScore.Count} Distance {pathResult.distance} Duration {pathResult.weight}");
         return this;
     }
+    
+    private double Weight(OsmNode currentNode, OsmNode neighborNode, OsmEdge edge)
+    {
+        double distance = Utils.DistanceBetween(currentNode, neighborNode);
+        double speed = regionManager.GetSpeedForEdge(currentNode, edge.wayId, _speedType);
+
+        double angle = 1;
+        if (_cameFromDict!.ContainsKey(currentNode))
+        {
+            OsmNode previousNode = _cameFromDict[currentNode];
+            Vector v1 = new(currentNode, previousNode);
+            Vector v2 = new(currentNode, neighborNode);
+            double nodeAngle = v1.Angle(v2);
+            if (nodeAngle < turnAngle)
+                angle = 0;
+            else
+                angle = nodeAngle / 180;
+        }
+        double prio = regionManager.GetPriorityForVehicle(_speedType,edge, currentNode) * roadPriorityFactor;
+
+        return distance / (speed * angle + prio + 1);
+    }
+
+    private double Heuristic(OsmNode currentNode, OsmNode neighborNode, OsmNode goalNode, OsmEdge edge)
+    {
+        if (neighborNode.Equals(goalNode)) return 0;
+        double priority = regionManager.GetPriorityForVehicle(_speedType, edge, currentNode);
+        if (priority == 0)
+            return double.MaxValue;
+
+        double distance = Utils.DistanceBetween(neighborNode, goalNode);
+        
+        double speed = regionManager.GetSpeedForEdge(currentNode, edge.wayId, _speedType);
+        
+        double roadPriority = priority * roadPriorityFactor;
+        
+        double angle = 0;
+        if (_cameFromDict!.ContainsKey(currentNode))
+        {
+            OsmNode previousNode = _cameFromDict[currentNode];
+            Vector v1 = new(currentNode, previousNode);
+            Vector v2 = new(currentNode, neighborNode);
+            double nodeAngle = v1.Angle(v2);
+            if (nodeAngle < turnAngle)
+                angle = 0;
+            else
+                angle = nodeAngle / 180;
+        }
+
+        return distance / (speed * angle + roadPriority + 1);
+    }
 
     public void SaveResult(string path)
     {
+        if(File.Exists(path))
+            File.Delete(path);
         FileStream fs = new (path, FileMode.CreateNew);
         JsonSerializer.Serialize(fs, pathResult, JsonSerializerOptions.Default);
         fs.Dispose();
         Console.WriteLine($"Saved result to {path}");
     }
 
-    private PathResult GetPath(Dictionary<OsmNode, OsmNode> cameFromDict, OsmNode goalNode, TimeSpan calcFinished)
+    private PathResult GetPath(OsmNode goalNode, TimeSpan calcFinished)
     {
         List<PathNode> path = new();
         OsmNode currentNode = goalNode;
-        while (cameFromDict.ContainsKey(cameFromDict[currentNode]))
+        double retDistance = 0;
+        double weight = 0;
+        while (_cameFromDict!.ContainsKey(_cameFromDict[currentNode]))
         {
-            OsmEdge? currentEdge = cameFromDict[currentNode].edges.First(edge => edge.neighborId == currentNode.nodeId);
+            OsmEdge? currentEdge = _cameFromDict[currentNode].edges.FirstOrDefault(edge => edge.neighborId == currentNode.nodeId);
             HashSet<Tag>? tags =
-                regionManager.GetRegion(currentNode.coordinates)!.tagManager.GetTagsForWayId(currentEdge.wayId);
+                regionManager.GetRegion(currentNode.coordinates)!.tagManager.GetTagsForWayId(currentEdge!.wayId);
             PathNode? newNode = PathNode.FromOsmNode(currentNode, tags);
             if(newNode is not null)
                 path.Add(newNode);
-            currentNode = cameFromDict[currentNode];
+
+            double distance = Utils.DistanceBetween(currentNode, _cameFromDict[currentNode]);
+            retDistance += distance;
+            weight += regionManager.GetSpeedForEdge(_cameFromDict[currentNode], currentEdge.wayId, _speedType);
+            
+            currentNode = _cameFromDict[currentNode];
         }
 
         path.Reverse();
 
-        return new PathResult(calcFinished, path);
+        return new PathResult(calcFinished, path, retDistance, retDistance / (weight / path.Count));
     }
 
-    private double Weight(OsmNode fromNode, OsmNode neighborNode, OsmEdge edge, SpeedType vehicle)
+    private class Vector
     {
-        double distance = Utils.DistanceBetween(fromNode, neighborNode);
+        public readonly float x, y;
-        double speed = regionManager.GetSpeedForEdge(fromNode, edge.wayId, vehicle);
-        //double prio = GetPriorityVehicleRoad(edge, vehicle, regionManager.GetRegion(fromNode.coordinates)!);
-        return distance / speed;
-    }
 
-    private double Heuristic(OsmNode fromNode, OsmNode neighborNode, OsmNode goalNode, OsmEdge edge, SpeedType vehicle, double roadPriorityFactor, double junctionFactor, double sameRoadFactor)
+        public Vector(float x, float y)
-    {
-        double roadPriority = GetPriorityVehicleRoad(edge, vehicle, regionManager.GetRegion(fromNode.coordinates)!) * roadPriorityFactor;
-        
-        TagManager curTags = regionManager.GetRegion(fromNode.coordinates)!.tagManager;
-        TagManager nextTags = regionManager.GetRegion(neighborNode.coordinates)!.tagManager;
-
-        bool sameName = false;
-        string? curName = (string?)curTags.GetTag(edge.wayId, TagType.name);
-        bool sameRef = false;
-        string? curRef = (string?)curTags.GetTag(edge.wayId, TagType.tagref);
-        if(curName is not null)
-            foreach (OsmEdge pEdge in neighborNode.edges)
-            {
-                if ((string?)nextTags.GetTag(pEdge.wayId, TagType.name) == curName)
-                    sameName = true;
-                if ((string?)nextTags.GetTag(pEdge.wayId, TagType.tagref) == curRef)
-                    sameRef = true;
-            }
-        double sameRoadName = (sameRef || sameName ? 1 : 0) * sameRoadFactor;
-
-        double junctionCount = (neighborNode.edges.Count > 2 ? 0 : 1) * junctionFactor;
-        
-        return Utils.DistanceBetween(neighborNode, goalNode) / (1 + roadPriority + sameRoadName + junctionCount);
-    }
-    
-    private static double GetPriorityVehicleRoad(OsmEdge edge, SpeedType vehicle, Region region)
-    {
-        if (vehicle == SpeedType.any)
-            return 1;
-        WayType? wayType = (WayType?)region.tagManager.GetTag(edge.wayId, TagType.highway);
-        if(wayType is null)
-            return 0;
-        if (vehicle == SpeedType.car)
         {
-            switch (wayType)
+            this.x = x;
-            {
+            this.y = y;
-                case WayType.motorway:
-                case WayType.motorway_link:
-                case WayType.motorroad:
-                case WayType.trunk:
-                case WayType.trunk_link:
-                case WayType.primary:
-                case WayType.primary_link:
-                    return 10;
-                case WayType.secondary:
-                case WayType.secondary_link:
-                    return 7;
-                case WayType.tertiary:
-                case WayType.tertiary_link:
-                    return 5;
-                case WayType.unclassified:
-                case WayType.residential:
-                case WayType.road:
-                case WayType.living_street:
-                    return 2;
-                case WayType.service:
-                case WayType.track:
-                    return 0.0001;
-            }
-        }
-        if (vehicle == SpeedType.pedestrian)
-        {
-            switch (wayType)
-            {
-                case WayType.pedestrian:
-                case WayType.corridor:
-                case WayType.footway:
-                case WayType.path:
-                case WayType.steps:
-                case WayType.residential: 
-                case WayType.living_street:
-                    return 10;
-                case WayType.service:
-                case WayType.cycleway:
-                case WayType.bridleway:
-                case WayType.road:
-                case WayType.track:
-                case WayType.unclassified:
-                    return 5;
-                case WayType.tertiary:
-                case WayType.tertiary_link:
-                case WayType.escape:
-                    return 2;
-            }
         }
 
-        return 0.01;
+        public Vector(OsmNode n1, OsmNode n2)
+        {
+            this.x = n1.coordinates.longitude - n2.coordinates.longitude;
+            this.y = n1.coordinates.latitude - n2.coordinates.latitude;
+        }
+
+        public double Angle(Vector v2)
+        {
+            return Angle(this, v2);
+        }
+
+        public static double Angle(Vector v1, Vector v2)
+        {
+            double dotProd = v1.x * v2.x + v1.y * v2.y;
+            double v1L = Math.Sqrt(v1.x * v1.x + v1.y * v1.y);
+            double v2L = Math.Sqrt(v2.x * v2.x + v2.y * v2.y);
+            double ang = Math.Acos(dotProd / (v1L * v2L));
+            if (ang.Equals(double.NaN))
+                return 0;
+            double angle = Utils.RadiansToDegrees(ang);
+            return angle;
+        }
     }
 }

Pathfinding/RPriorityQueue.cs

@@ -0,0 +1,47 @@
+namespace Pathfinding;
+
+public class RPriorityQueue<TKey, TPriority> where TKey : notnull
+{
+    public Dictionary<TKey, TPriority> queue;
+    public int Count => queue.Count;
+
+    public RPriorityQueue()
+    {
+        queue = new();
+    }
+
+    public void Enqueue(TKey key, TPriority priority)
+    {
+        if (!queue.TryAdd(key, priority))
+            queue[key] = priority;
+    }
+
+    public TKey Dequeue()
+    {
+        TKey retKey = queue.MinBy(item => item.Value).Key;
+        queue.Remove(retKey);
+        return retKey;
+    }
+
+    public int Remove(IEnumerable<TKey> elements)
+    {
+        int before = Count;
+        queue = queue.Where(queueitem => !elements.Contains(queueitem.Key))
+            .ToDictionary(item => item.Key, item => item.Value);
+        return before - Count;
+    }
+
+    public int RemoveExcept(IEnumerable<TKey> exceptKeys)
+    {
+        int before = Count;
+        queue = queue.IntersectBy(exceptKeys, item => item.Key).ToDictionary(item => item.Key, item => item.Value);
+        return before - Count;
+    }
+
+    public int Clear()
+    {
+        int before = Count;
+        queue.Clear();
+        return before;
+    }
+}

Pathfinding/RegionManager.cs

@@ -1,6 +1,8 @@
 using System.Text.Json;
 using OSMDatastructure;
 using OSMDatastructure.Graph;
+using SpeedType = OSMDatastructure.Tag.SpeedType;
+using WayType = OSMDatastructure.Tag.WayType;
 
 namespace Pathfinding
 {
@@ -21,31 +23,32 @@ namespace Pathfinding
 
         public Region? GetRegion(ulong id)
         {
-            if(_regions.TryGetValue(id, out Region? value))
+            if (!_regions.ContainsKey(id))
-                return value;
-            else
             {
                 Region? loadedRegion = RegionFromId(id);
-                if(loadedRegion is not null)
+                if (loadedRegion is not null)
-                    _regions.Add(loadedRegion!.regionHash, value: loadedRegion);
+                    _regions.TryAdd(loadedRegion.regionHash, loadedRegion);
-                return loadedRegion;
+                return _regions[id]; //return from _regions instead of loadedRegion for multithreading/pointers
             }
+            return _regions[id];
         }
 
         public Region[] GetAllRegions()
         {
-            return this._regions.Values.ToArray();
+            return _regions.Values.ToArray();
         }
 
-        private Region? RegionFromFile(string filePath)
+        private static Region? RegionFromFile(string filePath)
         {
-            Region? retRegion = null;
+            if (!File.Exists(filePath))
-            if (File.Exists(filePath))
             {
-                FileStream regionFile = new FileStream(filePath, FileMode.Open);
+                //throw new FileNotFoundException(filePath);
-                retRegion = JsonSerializer.Deserialize<Region>(regionFile, Region.serializerOptions)!;
+                return null;
-                regionFile.Dispose();
             }
+
+            FileStream regionFile = new (filePath, FileMode.Open, FileAccess.Read, FileShare.Read, (int)new FileInfo(filePath).Length, FileOptions.SequentialScan);
+            Region retRegion = JsonSerializer.Deserialize<Region>(regionFile, Region.serializerOptions)!;
+            regionFile.Dispose();
             return retRegion;
         }
 
@@ -61,26 +64,25 @@ namespace Pathfinding
             return r?.GetNode(nodeId);
         }
 
-        public bool TestValidConnectionForType(OsmNode node1, OsmNode node2, Tag.SpeedType type)
+        public bool TestValidConnectionForType(OsmNode node1, OsmNode node2, SpeedType type)
         {
-            foreach (OsmEdge edge in node1.edges)
+            foreach (OsmEdge edge in node1.edges.Where(edge => edge.neighborId.Equals(node2.nodeId)))
             {
-                if (edge.neighborId.Equals(node2.nodeId))
+                return TestValidConnectionForType(node1, edge, type);
-                    return TestValidConnectionForType(node1, edge, type);
             }
 
             return false;
         }
 
-        public bool TestValidConnectionForType(OsmNode node1, OsmEdge edge, Tag.SpeedType type)
+        public bool TestValidConnectionForType(OsmNode node1, OsmEdge edge, SpeedType type)
         {
-            if (type == Tag.SpeedType.any)
+            if (type == SpeedType.any)
                 return true;
             byte speed = GetSpeedForEdge(node1, edge.wayId, type);
             return (speed is not 0);
         }
         
-        public OsmNode? ClosestNodeToCoordinates(Coordinates coordinates, Tag.SpeedType vehicle)
+        public OsmNode? ClosestNodeToCoordinates(Coordinates coordinates, SpeedType vehicle)
         {
             OsmNode? closest = null;
             double distance = double.MaxValue;
@@ -90,7 +92,7 @@ namespace Pathfinding
             foreach (OsmNode node in region.nodes)
             {
                 bool hasConnectionUsingVehicle = true;
-                if (vehicle is not Tag.SpeedType.any)
+                if (vehicle is not SpeedType.any)
                 {
                     hasConnectionUsingVehicle = false;
                     foreach (OsmEdge edge in node.edges)
@@ -111,25 +113,88 @@ namespace Pathfinding
             return closest;
         }
         
-        public byte GetSpeedForEdge(OsmNode node1, ulong wayId, Tag.SpeedType vehicle)
+        public byte GetSpeedForEdge(OsmNode node1, ulong wayId, SpeedType vehicle)
         {
             TagManager tags = GetRegion(node1.coordinates)!.tagManager;
-            Tag.WayType wayType = (Tag.WayType)tags.GetTag(wayId, Tag.TagType.highway)!;
+            WayType wayType = (WayType)tags.GetTag(wayId, Tag.TagType.highway)!;
             byte speed = 0;
             switch (vehicle)
             {
-                case Tag.SpeedType.pedestrian:
+                case SpeedType.pedestrian:
                     speed = Tag.defaultSpeedPedestrian[wayType];
                     return speed;
-                case Tag.SpeedType.car: 
+                case SpeedType.car: 
                     byte? maxSpeed = (byte?)tags.GetTag(wayId, Tag.TagType.maxspeed);
                     speed = Tag.defaultSpeedCar[wayType];
                     return maxSpeed < speed ? (byte)maxSpeed : speed;
-                case Tag.SpeedType.any:
+                case SpeedType.any:
                     return 1;
                 default:
                     return 0;
             }
         }
+        
+        public double GetPriorityForVehicle(SpeedType speedType, OsmEdge edge, OsmNode node)
+        {
+            if (speedType == SpeedType.any)
+                return 1;
+            Region region = GetRegion(node.coordinates)!;
+            WayType? wayType = (WayType?)region.tagManager.GetTag(edge.wayId, Tag.TagType.highway);
+            if(wayType is null)
+                return 0;
+            if (speedType == SpeedType.car)
+            {
+                switch (wayType)
+                {
+                    case WayType.motorway:
+                    case WayType.motorway_link:
+                    case WayType.motorroad:
+                        return 20;
+                    case WayType.trunk:
+                    case WayType.trunk_link:
+                    case WayType.primary:
+                    case WayType.primary_link:
+                        return 10;
+                    case WayType.secondary:
+                    case WayType.secondary_link:
+                    case WayType.tertiary:
+                    case WayType.tertiary_link:
+                        return 6;
+                    case WayType.unclassified:
+                    case WayType.residential:
+                    case WayType.road:
+                    case WayType.living_street:
+                        return 2;
+                }
+            }
+        
+            if (speedType == SpeedType.pedestrian)
+            {
+                switch (wayType)
+                {
+                    case WayType.pedestrian:
+                    case WayType.corridor:
+                    case WayType.footway:
+                    case WayType.path:
+                    case WayType.steps:
+                    case WayType.residential: 
+                    case WayType.living_street:
+                        return 10;
+                    case WayType.service:
+                    case WayType.cycleway:
+                    case WayType.bridleway:
+                    case WayType.road:
+                    case WayType.track:
+                    case WayType.unclassified:
+                        return 5;
+                    case WayType.tertiary:
+                    case WayType.tertiary_link:
+                    case WayType.escape:
+                        return 2;
+                }
+            }
+
+            return 0;
+        }
     }
 }

RenderPath/Bounds.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+using OSMDatastructure.Graph;
+
+namespace RenderPath;
+
+public class Bounds
+{
+    [JsonInclude]public float minLat, maxLat, minLon, maxLon;
+
+    [JsonConstructor]
+    public Bounds(float minLat, float minLon, float maxLat, float maxLon)
+    {
+        this.minLon = minLon;
+        this.maxLat = maxLat;
+        this.maxLon = maxLon;
+        this.minLat = minLat;
+    }
+
+    public static Bounds FromCoords(float lat1, float lon1, float lat2, float lon2)
+    {
+        float minLat = lat1 < lat2 ? lat1 : lat2;
+        float minLon = lon1 < lon2 ? lon1 : lon2;
+        float maxLat = lat1 > lat2 ? lat1 : lat2;
+        float maxLon = lon1 > lon2 ? lon1 : lon2;
+
+        return new Bounds(minLat, minLon, maxLat, maxLon);
+    }
+
+    public static Bounds FromCoords(Coordinates c1, Coordinates c2)
+    {
+        return FromCoords(c1.latitude, c1.longitude, c2.latitude, c2.longitude);
+    }
+}

RenderPath/PNGRenderer.cs

@@ -0,0 +1,44 @@
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace RenderPath;
+
+#pragma warning disable CA1416
+public class PNGRenderer : Renderer
+{
+    private readonly Image _image;
+    private readonly Graphics _graphics;
+
+    public PNGRenderer(int width, int height)
+    {
+        _image = new Bitmap(width, height, PixelFormat.Format32bppPArgb);
+        _graphics = Graphics.FromImage(_image);
+        _graphics.Clear(Color.White);
+    }
+
+    public PNGRenderer(Image renderOver)
+    {
+        _image = renderOver;
+        _graphics = Graphics.FromImage(renderOver);
+    }
+
+    public override void DrawLine(float x1, float y1, float x2, float y2, int width, Color color)
+    {
+        Pen p = new Pen(color, width);
+        _graphics.DrawLine(p, x1, y1, x2, y2);
+    }
+
+    public override void DrawDot(float x, float y, int radius, Color color)
+    {
+        Brush b = new SolidBrush(color);
+        x -= radius / 2f;
+        y -= radius / 2f;
+        _graphics.FillEllipse(b, x, y, radius, radius);
+    }
+
+    public override void Save(string path)
+    {
+        _image.Save($"{path}.png", ImageFormat.Png);
+    }
+}
+#pragma warning restore CA1416

RenderPath/Renderer.cs

@@ -1,51 +1,31 @@
-using System.Diagnostics.CodeAnalysis;
 using System.Drawing;
-using System.Drawing.Imaging;
+using OSMDatastructure;
-using System.Text.Json;
 using OSMDatastructure.Graph;
 using Pathfinding;
 
 namespace RenderPath;
 
-public static class Renderer
+public abstract class Renderer
 {
     private const int ImageMaxSize = 20000;
-    private const float PenThickness = 4;
+    private const int PenThickness = 2;
     private static readonly Color RouteColor = Color.Red;
-    private static readonly Color WeightStartColor = Color.FromArgb(0, 0, 255);
+    private static readonly Color WeightStartColor = Color.FromArgb(127, 0, 100, 255);
-    private static readonly Color WeightCenterColor = Color.FromArgb(255, 255, 0);
+    private static readonly Color WeightEndColor = Color.FromArgb(255, 0, 255, 0);
-    private static readonly Color WeightEndColor = Color.FromArgb(0, 255, 0);
+    private static readonly Color RoadPrioStart = Color.FromArgb(200, 100, 100, 100);
+    private static readonly Color RoadPrioEnd = Color.FromArgb(255, 255, 180, 0);
 
-    public class Bounds
+    public Bounds? bounds;
+
+    public enum RenderType { png, svg}
+    
+    public abstract void DrawLine(float x1, float y1, float x2, float y2, int width, Color color);
+    public abstract void DrawDot(float x, float y, int r, Color color);
+    public abstract void Save(string path);
+    
+    public static Renderer DrawArea(RegionManager rm, RenderType renderType)
     {
-        public readonly float minLat, maxLat, minLon, maxLon;
+        HashSet<OsmNode> nodes = new();
-
-        public Bounds(float minLat, float minLon, float maxLat, float maxLon)
-        {
-            this.minLon = minLon;
-            this.maxLat = maxLat;
-            this.maxLon = maxLon;
-            this.minLat = minLat;
-        }
-    }
-
-    [SuppressMessage("Interoperability", "CA1416:Plattformkompatibilität überprüfen")]
-    public static Image DrawPathfinder(Pathfinder pathfinder)
-    {
-        Console.WriteLine("Rendering loaded Regions");
-        ValueTuple<Image, Bounds> areaRender = DrawArea(pathfinder.regionManager);
-        Console.WriteLine("Rendering gScores (Weights)");
-        ValueTuple<Image, Bounds> areaGScoreRender = DrawGScores(pathfinder.gScore!, areaRender.Item1, areaRender.Item2);
-        Console.WriteLine("Rendering path");
-        ValueTuple<Image, Bounds> areaGScorePathRender = DrawPath(pathfinder.pathResult!, areaGScoreRender.Item1, areaGScoreRender.Item2);
-
-        return areaGScorePathRender.Item1;
-    }
-
-    [SuppressMessage("Interoperability", "CA1416:Plattformkompatibilität überprüfen")]
-    public static ValueTuple<Image, Bounds> DrawArea(RegionManager rm)
-    {
-        HashSet<OsmNode> nodes = new HashSet<OsmNode>();
         foreach (OSMDatastructure.Region r in rm.GetAllRegions())
             nodes = nodes.Concat(r.nodes).ToHashSet();
 
@@ -61,48 +41,50 @@ public static class Renderer
 
         int pixelsX = (int)(lonDiff * scaleFactor);
         int pixelsY = (int)(latDiff * scaleFactor);
-        
-        Image ret = new Bitmap(pixelsX, pixelsY, PixelFormat.Format32bppRgb);
-        Graphics g = Graphics.FromImage(ret);
-        g.Clear(Color.White);
 
-        //TODO Use road priority for roadcolor
+        Renderer renderer;
-        Color start = Color.FromArgb(255, 25, 25, 25);
+        switch (renderType)
-        Color center = Color.FromArgb(255, 0, 0, 0);
+        {
-        Color end = Color.FromArgb(255, 0, 255, 0);
+            case RenderType.svg:
+                renderer = new SVGRenderer(pixelsX, pixelsY);
+                break;
+            default:
+                renderer = new PNGRenderer(pixelsX, pixelsY);
+                break;
+        }
 
         foreach (OsmNode node in nodes)
         {
             foreach (OsmEdge edge in node.edges)
             {
+                double priority = rm.GetPriorityForVehicle(Tag.SpeedType.car, edge, node) / 20;
                 Coordinates c1 = node.coordinates;
                 OsmNode nNode = rm.GetNode(edge.neighborId, edge.neighborRegion)!;
                 Coordinates c2 = nNode.coordinates;
 
-                Pen p = new Pen(GradientPick(0, start, center, end), PenThickness);
                 float x1 = (c1.longitude - minLon) * scaleFactor;
                 float y1 = (maxLat - c1.latitude) * scaleFactor;
                 float x2 = (c2.longitude - minLon) * scaleFactor;
                 float y2 = (maxLat - c2.latitude) * scaleFactor;
                 
-                g.DrawLine(p, x1, y1, x2, y2);
+                renderer.DrawLine(x1, y1, x2, y2, PenThickness, ColorInterp(RoadPrioStart, RoadPrioEnd, priority));
             }
         }
 
-        return new ValueTuple<Image, Bounds>(ret, new Bounds(minLat,minLon,maxLat,maxLon));
+        renderer.bounds = new Bounds(minLat,minLon,maxLat,maxLon);
+        return renderer;
     }
-
+    
-    [SuppressMessage("Interoperability", "CA1416:Plattformkompatibilität überprüfen")]
+    public static Renderer DrawPath(PathResult pathResult, RenderType renderType, Renderer? drawOver)
-    public static ValueTuple<Image, Bounds> DrawPath(PathResult pathResult, Image? renderOver = null, Bounds? bounds = null)
     {
         List<Coordinates> coordinates = new();
         foreach(PathNode node in pathResult.pathNodes)
             coordinates.Add(node.coordinates);
         
-        float minLat = bounds?.minLat ?? coordinates.Min(coords => coords.latitude);
+        float minLat = drawOver?.bounds!.minLat ?? coordinates.Min(coords => coords.latitude);
-        float minLon = bounds?.minLon ?? coordinates.Min(coords => coords.longitude);
+        float minLon = drawOver?.bounds!.minLon ?? coordinates.Min(coords => coords.longitude);
-        float maxLat = bounds?.maxLat ?? coordinates.Max(coords => coords.latitude);
+        float maxLat = drawOver?.bounds!.maxLat ?? coordinates.Max(coords => coords.latitude);
-        float maxLon = bounds?.maxLon ?? coordinates.Max(coords => coords.longitude);
+        float maxLon = drawOver?.bounds!.maxLon ?? coordinates.Max(coords => coords.longitude);
         
         float latDiff = maxLat - minLat;
         float lonDiff = maxLon - minLon;
@@ -112,38 +94,46 @@ public static class Renderer
         int pixelsX = (int)(lonDiff * scaleFactor);
         int pixelsY = (int)(latDiff * scaleFactor);
         
-        Image ret = renderOver ?? new Bitmap(pixelsX, pixelsY, PixelFormat.Format32bppRgb);
+        Renderer renderer;
-        Graphics g = Graphics.FromImage(ret);
+        if(drawOver is null)
-        if(renderOver is null)
+            switch (renderType)
-            g.Clear(Color.White);
+            {
-
+                case RenderType.svg:
-        Pen p = new Pen(RouteColor, PenThickness);
+                    renderer = new SVGRenderer(pixelsX, pixelsY);
+                    break;
+                default:
+                    renderer = new PNGRenderer(pixelsX, pixelsY);
+                    break;
+            }
+        else
+            renderer = drawOver;
 
         for (int i = 0; i < coordinates.Count - 1; i++)
         {
             Coordinates c1 = coordinates[i];
             Coordinates c2 = coordinates[i + 1];
-            Point p1 = new(Convert.ToInt32((c1.longitude - minLon) * scaleFactor),
+            float x1 = (c1.longitude - minLon) * scaleFactor;
-                Convert.ToInt32((maxLat - c1.latitude) * scaleFactor));
+            float y1 = (maxLat - c1.latitude) * scaleFactor;
-            Point p2 = new(Convert.ToInt32((c2.longitude - minLon) * scaleFactor),
+            float x2 = (c2.longitude - minLon) * scaleFactor;
-                Convert.ToInt32((maxLat - c2.latitude) * scaleFactor));
+            float y2 = (maxLat - c2.latitude) * scaleFactor;
-            g.DrawLine(p, p1, p2);
+            
+            renderer.DrawLine(x1, y1, x2, y2, PenThickness, RouteColor);
         }
 
-        return new ValueTuple<Image, Bounds>(ret, new Bounds(minLat,minLon,maxLat,maxLon));
+        renderer.bounds = new Bounds(minLat, minLon, maxLat, maxLon);
+        return renderer;
     }
-
+    
-    [SuppressMessage("Interoperability", "CA1416:Plattformkompatibilität überprüfen")]
+    public static Renderer DrawGScores(Dictionary<OsmNode, double> gScore, RenderType renderType, Renderer? drawOver)
-    public static ValueTuple<Image, Bounds> DrawGScores(Dictionary<OsmNode, double> gScoreDict, Image? renderOver = null,
-        Bounds? bounds = null)
     {
-        float minLat = bounds?.minLat ?? gScoreDict.Min(kv => kv.Key.coordinates.latitude);
+        
-        float minLon = bounds?.minLon ?? gScoreDict.Min(kv => kv.Key.coordinates.longitude);
+        float minLat = drawOver?.bounds!.minLat ?? gScore.Min(kv => kv.Key.coordinates.latitude);
-        float maxLat = bounds?.maxLat ?? gScoreDict.Max(kv => kv.Key.coordinates.latitude);
+        float minLon = drawOver?.bounds!.minLon ?? gScore.Min(kv => kv.Key.coordinates.longitude);
-        float maxLon = bounds?.maxLon ?? gScoreDict.Max(kv => kv.Key.coordinates.longitude);
+        float maxLat = drawOver?.bounds!.maxLat ?? gScore.Max(kv => kv.Key.coordinates.latitude);
+        float maxLon = drawOver?.bounds!.maxLon ?? gScore.Max(kv => kv.Key.coordinates.longitude);
 
-        double minWeight = gScoreDict.Min(kv => kv.Value);
+        double minWeight = gScore.Min(kv => kv.Value);
-        double maxWeight = gScoreDict.Max(kv => kv.Value);
+        double maxWeight = gScore.Max(kv => kv.Value);
         
         float latDiff = maxLat - minLat;
         float lonDiff = maxLon - minLon;
@@ -153,27 +143,45 @@ public static class Renderer
         int pixelsX = (int)(lonDiff * scaleFactor);
         int pixelsY = (int)(latDiff * scaleFactor);
         
-        Image ret = renderOver ?? new Bitmap(pixelsX, pixelsY, PixelFormat.Format32bppRgb);
+        Renderer renderer;
-        Graphics g = Graphics.FromImage(ret);
+        if(drawOver is null)
-        if(renderOver is null)
+            switch (renderType)
-            g.Clear(Color.White);
+            {
-        
+                case RenderType.svg:
-        foreach (KeyValuePair<OsmNode, double> kv in gScoreDict)
+                    renderer = new SVGRenderer(pixelsX, pixelsY);
+                    break;
+                default:
+                    renderer = new PNGRenderer(pixelsX, pixelsY);
+                    break;
+            }
+        else
+            renderer = drawOver;
+
+        foreach (KeyValuePair<OsmNode, double> kv in gScore)
         {
             double percentage = (kv.Value - minWeight) / (maxWeight - minWeight);
-            Brush b = new SolidBrush(GradientPick(percentage, WeightStartColor, WeightCenterColor, WeightEndColor));
-            
             float x = (kv.Key.coordinates.longitude - minLon) * scaleFactor;
             float y = (maxLat - kv.Key.coordinates.latitude) * scaleFactor;
-
+            
-            x -= (PenThickness * 1.5f) / 2;
+            renderer.DrawDot(x, y, PenThickness, ColorInterp(WeightStartColor, WeightEndColor, percentage));
-            y -= (PenThickness * 1.5f) / 2;
-            g.FillEllipse(b, x, y, PenThickness * 1.5f, PenThickness * 1.5f);
         }
 
-        return new ValueTuple<Image, Bounds>(ret, new Bounds(minLat,minLon,maxLat,maxLon));
+        renderer.bounds = new Bounds(minLat,minLon,maxLat,maxLon);
+        return renderer;
     }
+    
+    public static Renderer DrawPathfinder(Pathfinder pathfinder, RenderType renderType)
+    {
+        Console.WriteLine("Rendering loaded Regions");
+        Renderer areaRender = DrawArea(pathfinder.regionManager, renderType);
+        Console.WriteLine("Rendering gScores (Weights)");
+        Renderer areaGScoreRender = DrawGScores(pathfinder.gScore!, renderType, areaRender);
+        Console.WriteLine("Rendering path");
+        Renderer areaGScorePathRender = DrawPath(pathfinder.pathResult!, renderType, areaGScoreRender);
 
+        return areaGScorePathRender;
+    }
+    
     /*
      * https://stackoverflow.com/questions/55601338/get-a-color-value-within-a-gradient-based-on-a-value
      */
@@ -183,12 +191,4 @@ public static class Renderer
             LinearInterp(start.R, end.R, percentage),
             LinearInterp(start.G, end.G, percentage),
             LinearInterp(start.B, end.B, percentage));
-    private static Color GradientPick(double percentage, Color Start, Color Center, Color End) {
-        if (percentage < 0.5)
-            return ColorInterp(Start, Center, percentage / 0.5);
-        else if (percentage == 0.5)
-            return Center;
-        else
-            return ColorInterp(Center, End, (percentage - 0.5)/0.5);
-    }
 }

RenderPath/SVGRenderer.cs

@@ -0,0 +1,92 @@
+using System.Drawing;
+
+namespace RenderPath;
+using System.Xml;
+
+public class SVGRenderer : Renderer
+{
+    private readonly XmlDocument _image;
+    private XmlElement _document;
+    
+    public SVGRenderer(int width, int height)
+    {
+        _image = new XmlDocument();
+        CreateTree(width, height);
+    }
+
+    public SVGRenderer(XmlDocument renderOver)
+    {
+        _image = renderOver;
+        _document = _image.GetElementById("svg")!;
+    }
+
+    private void CreateTree(int width, int height)
+    {
+        XmlDeclaration xmlDeclaration = _image.CreateXmlDeclaration( "1.0", "UTF-8", null );
+        _image.InsertBefore(xmlDeclaration, _image.DocumentElement);
+        XmlElement pElement = _image.CreateElement("svg");
+        XmlAttribute xmlns = _image.CreateAttribute("xmlns");
+        xmlns.Value = "http://www.w3.org/2000/svg";
+        pElement.Attributes.Append(xmlns);
+        XmlAttribute aWidth = _image.CreateAttribute("width");
+        aWidth.Value = width.ToString();
+        pElement.Attributes.Append(aWidth);
+        XmlAttribute aHeight = _image.CreateAttribute("height");
+        aHeight.Value = height.ToString();
+        pElement.Attributes.Append(aHeight);
+        _image.AppendChild(pElement);
+        _document = pElement;
+    }
+
+    public override void DrawLine(float x1, float y1, float x2, float y2, int width, Color color)
+    {
+        XmlElement newLine = _image.CreateElement("line");
+        XmlAttribute aX1 = _image.CreateAttribute("x1");
+        aX1.Value = Math.Floor(x1).ToString("0");
+        newLine.Attributes.Append(aX1);
+        XmlAttribute aY1 = _image.CreateAttribute("y1");
+        aY1.Value = Math.Floor(y1).ToString("0");
+        newLine.Attributes.Append(aY1);
+        XmlAttribute aX2 = _image.CreateAttribute("x2");
+        aX2.Value = Math.Floor(x2).ToString("0");
+        newLine.Attributes.Append(aX2);
+        XmlAttribute aY2 = _image.CreateAttribute("y2");
+        aY2.Value = Math.Floor(y2).ToString("0");
+        newLine.Attributes.Append(aY2);
+        XmlAttribute stroke = _image.CreateAttribute("stroke-width");
+        stroke.Value = width.ToString();
+        newLine.Attributes.Append(stroke);
+        XmlAttribute aColor = _image.CreateAttribute("stroke");
+        aColor.Value = HexFromColor(color);
+        newLine.Attributes.Append(aColor);
+        _document.AppendChild(newLine);
+    }
+
+    public override void DrawDot(float x, float y, int radius, Color color)
+    {
+        XmlElement newCircle = _image.CreateElement("circle");
+        XmlAttribute aX = _image.CreateAttribute("cx");
+        aX.Value = Math.Floor(x).ToString("0");
+        newCircle.Attributes.Append(aX);
+        XmlAttribute aY = _image.CreateAttribute("cy");
+        aY.Value = Math.Floor(y).ToString("0");
+        newCircle.Attributes.Append(aY);
+        XmlAttribute aR = _image.CreateAttribute("r");
+        aR.Value = radius.ToString();
+        newCircle.Attributes.Append(aR);
+        XmlAttribute fill = _image.CreateAttribute("fill");
+        fill.Value = HexFromColor(color);
+        newCircle.Attributes.Append(fill);
+        _document.AppendChild(newCircle);
+    }
+
+    public override void Save(string path)
+    {
+        _image.Save($"{path}.svg");
+    }
+
+    private static string HexFromColor(Color color)
+    {
+        return $"#{color.R:X2}{color.G:X2}{color.B:X2}";
+    }
+}

Server/ConsoleWriter.cs

@@ -1,4 +1,3 @@
-using System.Globalization;
 using System.Text;
 
 namespace Server;

Server/Server.cs

@@ -1,15 +1,19 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Drawing;
 using System.Drawing.Imaging;
+using System.Text.Json;
 using OSMDatastructure;
 using OSMDatastructure.Graph;
 using Pathfinding;
 using RenderPath;
+using Region = OSMDatastructure.Region;
 
 namespace Server;
 
 public class Server
 {
     
+    [SuppressMessage("Interoperability", "CA1416:Validate platform compatibility")]
     public static void Main(string[] args)
     {
         ConsoleWriter newConsole = new();
@@ -17,25 +21,163 @@ public class Server
         Console.SetError(newConsole);
         
         string workingDir = "D:/stuttgart-regbez-latest";
-       
+
         //RegionConverter.ConvertXMLToRegions("D:/stuttgart-regbez-latest.osm", "D:/stuttgart-regbez-latest");
         //RegionConverter.ConvertXMLToRegions("D:/map.osm", "D:/map");
         //RegionConverter.ConvertXMLToRegions("D:/germany-latest.osm", "D:/germany-latest");
         
         Coordinates start = new (48.7933798f, 9.8275859f);
         Coordinates finish = new (48.795918f, 9.021618f);
-        Pathfinder result = new Pathfinder(workingDir).AStar(start,
+
-            finish, Tag.SpeedType.car, 0.01, 0.0001,
+        Pathfinder result = new Pathfinder(workingDir, 2, 30).AStar(start, finish, Tag.SpeedType.car, 1);
-            0);
+        Renderer image = Renderer.DrawPathfinder(result, Renderer.RenderType.png);
+        image.Save("D:/stuttgart-regbez-latest");
         
+        /*
+        if(File.Exists(@"D:\bounds"))
+            File.Delete(@"D:\bounds");
+        RegionManager rm = LoadRegions(workingDir, start, finish);
+        Renderer areaRender = Renderer.DrawArea(rm, Renderer.RenderType.PNG);
+        FileStream s = new(@"D:\bounds", FileMode.OpenOrCreate);
+        JsonSerializer.Serialize(s, areaRender.bounds, JsonSerializerOptions.Default);
+        areaRender.Save(@"D:\Base");
+        s.Dispose();
+        */
+        
+
+
+        //TestVariables(workingDir, start, finish, 12);
+        //GetShortestRoute("D:");
+
+/*
         string parentFolder = new DirectoryInfo(workingDir).Parent!.FullName;
-        string resultFileName = $"{new DirectoryInfo(workingDir).Name}-{DateTime.Now.ToFileTime()}.result";
+        Renderer.Bounds bounds = JsonSerializer.Deserialize<Renderer.Bounds>(new FileStream(@"D:\bounds", FileMode.Open));
+        Image baseImage = Image.FromFile(@"D:\Base.png");
+        
+        Pathfinder result = new Pathfinder(workingDir, 2, 30).AStar(start,
+            finish, Tag.SpeedType.car, 4);
+
+        Console.WriteLine($"Calc-time {result.pathResult!.calcTime} Path-length: {result.pathResult.pathNodes.Count} Visited-nodes: {result.gScore!.Count}");
+
+        string fileName = DateTime.Now.ToFileTime().ToString();
+        
+        string resultFileName = $"{new DirectoryInfo(workingDir).Name}-{fileName}.result";
         result.SaveResult(Path.Join(parentFolder, resultFileName));
 
-        string renderFileName = $"{new DirectoryInfo(workingDir).Name}-{DateTime.Now.ToFileTime()}.render.png";
+        string renderFileName = $"{new DirectoryInfo(workingDir).Name}-{fileName}.render.png";
-        Image render = Renderer.DrawPathfinder(result);
+
-#pragma warning disable CA1416
+        Image renderWeights = Renderer.DrawGScores(result.gScore, baseImage, bounds).Item1;
+        Image render = Renderer.DrawPath(result.pathResult, renderWeights, bounds).Item1;
         render.Save(Path.Join(parentFolder, renderFileName), ImageFormat.Png);
-#pragma warning restore CA1416
+*/
+        Console.Beep(400, 50);
+        Console.Beep(600, 50);
+        Console.Beep(400, 50);
+        Console.Beep(600, 50);
+    }
+
+    private static void GetShortestRoute(string directory)
+    {
+        DateTime start = DateTime.Now;
+        HashSet<string> allFiles = Directory.GetFiles(directory).Where(file => file.EndsWith(".result")).ToHashSet();
+        Dictionary<PathResult, string> results = new();
+        int loaded = 0;
+        foreach (string filePath in allFiles)
+        {
+            PathResult result = PathResult.PathresultFromFile(filePath);
+            results.Add(result, filePath);
+            Console.WriteLine($"{loaded++}/{allFiles.Count()} {filePath}  " +
+                              $"Time elapsed: {DateTime.Now - start} " +
+                              $"Remaining {((DateTime.Now - start)/loaded)*(allFiles.Count-loaded)}");
+        }
+
+        KeyValuePair<PathResult, string> shortest = results.MinBy(result => result.Key.distance);
+        KeyValuePair<PathResult, string> fastest = results.MinBy(result => result.Key.weight);
+        KeyValuePair<PathResult, string> calcTime = results.MinBy(result => result.Key.calcTime);
+        Console.WriteLine($"\nShortest:\t{shortest.Key.distance:0.0} {shortest.Key.weight:0.00} {shortest.Key.calcTime} {shortest.Value}\n" +
+                          $"Fastest:\t{fastest.Key.distance:0.0} {fastest.Key.weight:0.00} {fastest.Key.calcTime} {fastest.Value}\n" +
+                          $"CalcTime:\t{calcTime.Key.distance:0.0} {calcTime.Key.weight:0.00} {calcTime.Key.calcTime} {calcTime.Value}");
+    }
+
+    private static RegionManager LoadRegions(string workingDir, Coordinates c1, Coordinates c2)
+    {
+        float minLat = c1.latitude < c2.latitude ? c1.latitude : c2.latitude;
+        float minLon = c1.longitude < c2.longitude ? c1.longitude : c2.longitude;
+        float maxLat = c1.latitude > c2.latitude ? c1.latitude : c2.latitude;
+        float maxLon = c1.longitude > c2.longitude ? c1.longitude : c2.longitude;
+
+        RegionManager allRegions = new(workingDir);
+        for (float lat = minLat - Region.RegionSize * 3; lat < maxLat + Region.RegionSize * 3; lat += Region.RegionSize / 2)
+        {
+            for (float lon = minLon - Region.RegionSize; lon < maxLon + Region.RegionSize; lon += Region.RegionSize / 2)
+            {
+                allRegions.GetRegion(new Coordinates(lat, lon));
+            }
+        }
+        Console.WriteLine("Loaded needed Regions");
+        return allRegions;
+    }
+
+    [SuppressMessage("Interoperability", "CA1416:Validate platform compatibility")]
+    private static void TestVariables(string workingDir, Coordinates start, Coordinates finish, int threads)
+    {
+        string parentFolder = new DirectoryInfo(workingDir).Parent!.FullName;
+
+        RegionManager rm = LoadRegions(workingDir, start, finish);
+        
+        Queue<Thread> calcThreads = new();
+        
+        Bounds bounds = JsonSerializer.Deserialize<Bounds>(new FileStream(@"D:\bounds", FileMode.Open))!;
+
+        
+        for (double extraTime = 1.5; extraTime >= 1; extraTime -= 0.25)
+        {
+            for (double roadFactor = 0.05; roadFactor < 5; roadFactor += 0.05)
+            {
+                double road = roadFactor;
+                double time = extraTime;
+                calcThreads.Enqueue(new Thread(() =>
+                {
+                    Pathfinder testresult = new Pathfinder(workingDir, road, 30).AStar(start,
+                        finish, Tag.SpeedType.car, time);
+                    Image baseImage = Image.FromStream(new FileStream(@"D:\Base.png", FileMode.Open, FileAccess.Read, FileShare.Read,
+                        (int)new FileInfo(@"D:\Base.png").Length, FileOptions.Asynchronous));
+                    Renderer renderer = new PNGRenderer(baseImage);
+                    renderer.bounds = bounds;
+                    Renderer renderWeights = Renderer.DrawGScores(testresult.gScore!, Renderer.RenderType.png, renderer);
+                    Renderer render = Renderer.DrawPath(testresult.pathResult!, Renderer.RenderType.png, renderWeights);
+                    string fileName = $"road{road:0.00}_time{time:0.00}";
+                    string resultFileName = Path.Combine("D:", $"{fileName}.result");
+                    testresult.SaveResult(resultFileName);
+                    string imageFileName = Path.Combine("D:", fileName);
+                    render.Save(imageFileName);
+                    Console.WriteLine($"Saved {fileName}");
+                }));
+            }
+        }
+
+        int totalTasks = calcThreads.Count;
+        int completedTasks = 0;
+        DateTime startTime = DateTime.Now;
+
+        HashSet<Thread> runningThreads = new();
+        Console.WriteLine($"Running {threads} Threads on {totalTasks} Tasks.");
+        while (calcThreads.Count > 0 || runningThreads.Count > 0)
+        {
+            while (runningThreads.Count < threads && calcThreads.Count > 0)
+            {
+                Thread t = calcThreads.Dequeue();
+                runningThreads.Add(t);
+                t.Start();
+            }
+
+            int newCompletedTasks = runningThreads.RemoveWhere(thread => !thread.IsAlive);
+            completedTasks += newCompletedTasks;
+            if (newCompletedTasks > 0)
+            {
+                TimeSpan elapsedTime = DateTime.Now - startTime;
+                Console.WriteLine($"To calculate: {calcThreads.Count}(+{runningThreads.Count} running)/{totalTasks} Time Average: {(elapsedTime/completedTasks)} Elapsed: {elapsedTime} Remaining: {(elapsedTime/completedTasks*calcThreads.Count)}");
+            }
+        }
     }
 }