Added abstract Renderer class that SVGRenderer and PNGRenderer inherit from.

This way standardized rendering methods can be implemented.

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,38 +1,29 @@
-using System.Diagnostics.CodeAnalysis;
 using System.Drawing;
-using System.Drawing.Imaging;
-using System.Text.Json.Serialization;
 using OSMDatastructure;
 using OSMDatastructure.Graph;
 using Pathfinding;
 
 namespace RenderPath;
 
-public static class Renderer
+public abstract class Renderer
 {
     private const int ImageMaxSize = 20000;
-    private const float PenThickness = 2;
+    private const int PenThickness = 2;
     private static readonly Color RouteColor = Color.Red;
     private static readonly Color WeightStartColor = Color.FromArgb(127, 0, 100, 255);
-    private static readonly Color WeightEndColor = Color.FromArgb(255,0, 255, 0);
+    private static readonly Color WeightEndColor = Color.FromArgb(255, 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);
 
-    [SuppressMessage("Interoperability", "CA1416:Plattformkompatibilität überprüfen")]
+    public Bounds? bounds;
-    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;
+    public enum RenderType { png, svg}
-    }
     
-    [SuppressMessage("Interoperability", "CA1416:Plattformkompatibilität überprüfen")]
+    public abstract void DrawLine(float x1, float y1, float x2, float y2, int width, Color color);
-    public static ValueTuple<Image, Bounds> DrawArea(RegionManager rm)
+    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)
     {
         HashSet<OsmNode> nodes = new();
         foreach (OSMDatastructure.Region r in rm.GetAllRegions())
@@ -51,9 +42,16 @@ public static class Renderer
         int pixelsX = (int)(lonDiff * scaleFactor);
         int pixelsY = (int)(latDiff * scaleFactor);
 
-        Image ret = new Bitmap(pixelsX, pixelsY, PixelFormat.Format32bppPArgb);
+        Renderer renderer;
-        Graphics g = Graphics.FromImage(ret);
+        switch (renderType)
-        g.Clear(Color.White);
+        {
+            case RenderType.svg:
+                renderer = new SVGRenderer(pixelsX, pixelsY);
+                break;
+            default:
+                renderer = new PNGRenderer(pixelsX, pixelsY);
+                break;
+        }
 
         foreach (OsmNode node in nodes)
         {
@@ -64,30 +62,29 @@ public static class Renderer
                 OsmNode nNode = rm.GetNode(edge.neighborId, edge.neighborRegion)!;
                 Coordinates c2 = nNode.coordinates;
 
-                Pen p = new(ColorInterp(RoadPrioStart, RoadPrioEnd, priority), 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;
@@ -97,36 +94,43 @@ public static class Renderer
         int pixelsX = (int)(lonDiff * scaleFactor);
         int pixelsY = (int)(latDiff * scaleFactor);
         
-        Image ret = renderOver ?? new Bitmap(pixelsX, pixelsY, PixelFormat.Format32bppPArgb);
+        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> gScore, Image? renderOver = null,
-        Bounds? bounds = null)
     {
         
-        float minLat = bounds?.minLat ?? gScore.Min(kv => kv.Key.coordinates.latitude);
+        float minLat = drawOver?.bounds!.minLat ?? gScore.Min(kv => kv.Key.coordinates.latitude);
-        float minLon = bounds?.minLon ?? gScore.Min(kv => kv.Key.coordinates.longitude);
+        float minLon = drawOver?.bounds!.minLon ?? gScore.Min(kv => kv.Key.coordinates.longitude);
-        float maxLat = bounds?.maxLat ?? gScore.Max(kv => kv.Key.coordinates.latitude);
+        float maxLat = drawOver?.bounds!.maxLat ?? gScore.Max(kv => kv.Key.coordinates.latitude);
-        float maxLon = bounds?.maxLon ?? gScore.Max(kv => kv.Key.coordinates.longitude);
+        float maxLon = drawOver?.bounds!.maxLon ?? gScore.Max(kv => kv.Key.coordinates.longitude);
 
         double minWeight = gScore.Min(kv => kv.Value);
         double maxWeight = gScore.Max(kv => kv.Value);
@@ -139,27 +143,43 @@ public static class Renderer
         int pixelsX = (int)(lonDiff * scaleFactor);
         int pixelsY = (int)(latDiff * scaleFactor);
         
-        Image ret = renderOver ?? new Bitmap(pixelsX, pixelsY, PixelFormat.Format32bppPArgb);
+        Renderer renderer;
-        Graphics g = Graphics.FromImage(ret);
+        if(drawOver is null)
-        if(renderOver is null)
+            switch (renderType)
-            g.Clear(Color.White);
+            {
-
+                case RenderType.svg:
-        float pointSize = PenThickness * 1.5f;
+                    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(ColorInterp(WeightStartColor, WeightEndColor, percentage));
-            
             float x = (kv.Key.coordinates.longitude - minLon) * scaleFactor;
             float y = (maxLat - kv.Key.coordinates.latitude) * scaleFactor;
             
-            x -= pointSize / 2;
+            renderer.DrawDot(x, y, PenThickness, ColorInterp(WeightStartColor, WeightEndColor, percentage));
-            y -= pointSize / 2;
-            g.FillEllipse(b, x, y, pointSize, pointSize);
         }
 
-        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;
     }
     
     /*

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/Server.cs

@@ -1,5 +1,7 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Drawing;
 using System.Drawing.Imaging;
+using System.Text.Json;
 using OSMDatastructure;
 using OSMDatastructure.Graph;
 using Pathfinding;
@@ -11,6 +13,7 @@ namespace Server;
 public class Server
 {
     
+    [SuppressMessage("Interoperability", "CA1416:Validate platform compatibility")]
     public static void Main(string[] args)
     {
         ConsoleWriter newConsole = new();
@@ -26,26 +29,33 @@ public class Server
         Coordinates start = new (48.7933798f, 9.8275859f);
         Coordinates finish = new (48.795918f, 9.021618f);
 
-        TestVariables(workingDir, start, finish, 16);
+        Pathfinder result = new Pathfinder(workingDir, 2, 30).AStar(start, finish, Tag.SpeedType.car, 1);
-        GetShortestRoute("D:");
+        Renderer image = Renderer.DrawPathfinder(result, Renderer.RenderType.png);
+        image.Save("D:/stuttgart-regbez-latest");
         
         /*
-        ValueTuple<Image, Renderer.Bounds> area = Renderer.DrawArea(LoadRegions(workingDir, start, finish));
+        if(File.Exists(@"D:\bounds"))
-        area.Item1.Save(@"D:\Base.png", ImageFormat.Png);
+            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();
+        */
         
-        ValueTuple<Image, Renderer.Bounds> areaDistance = Renderer.DrawPath(
-            PathResult.PathresultFromFile(@"D:\angle0,140_level0,020_same0,160.result"), Image.FromFile(@"D:\Base.png"), area.Item2);
-        areaDistance.Item1.Save(@"D:\Distance.png", ImageFormat.Png);
 
-        ValueTuple<Image, Renderer.Bounds> areaWeight = Renderer.DrawPath(
+
-            PathResult.PathresultFromFile(@"D:\angle0,160_level0,020_same0,020.result"), Image.FromFile(@"D:\Base.png"), area.Item2);
+        //TestVariables(workingDir, start, finish, 12);
-        areaWeight.Item1.Save(@"D:\Weight.png", ImageFormat.Png);
+        //GetShortestRoute("D:");
-*/
+
 /*
         string parentFolder = new DirectoryInfo(workingDir).Parent!.FullName;
+        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, 0.0215, 30).AStar(start,
+        Pathfinder result = new Pathfinder(workingDir, 2, 30).AStar(start,
-            finish, Tag.SpeedType.car, 3);
+            finish, Tag.SpeedType.car, 4);
 
         Console.WriteLine($"Calc-time {result.pathResult!.calcTime} Path-length: {result.pathResult.pathNodes.Count} Visited-nodes: {result.gScore!.Count}");
 
@@ -55,11 +65,15 @@ public class Server
         result.SaveResult(Path.Join(parentFolder, resultFileName));
 
         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, 100);
+        Console.Beep(400, 50);
+        Console.Beep(600, 50);
+        Console.Beep(400, 50);
+        Console.Beep(600, 50);
     }
 
     private static void GetShortestRoute(string directory)
@@ -93,7 +107,7 @@ public class Server
         float maxLon = c1.longitude > c2.longitude ? c1.longitude : c2.longitude;
 
         RegionManager allRegions = new(workingDir);
-        for (float lat = minLat - Region.RegionSize; lat < maxLat + Region.RegionSize; lat += Region.RegionSize / 2)
+        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)
             {
@@ -104,6 +118,7 @@ public class Server
         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;
@@ -112,23 +127,41 @@ public class Server
         
         Queue<Thread> calcThreads = new();
         
-        for (double extraTime = 30; extraTime > 1; extraTime -= 1)
+        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, 0.0215, 30).AStar(start,
+                    Pathfinder testresult = new Pathfinder(workingDir, road, 30).AStar(start,
                         finish, Tag.SpeedType.car, time);
-                string fileName = $"time{time:0}.result";
+                    Image baseImage = Image.FromStream(new FileStream(@"D:\Base.png", FileMode.Open, FileAccess.Read, FileShare.Read,
-                testresult.SaveResult(Path.Join(parentFolder, fileName));
+                        (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)