OSMServer/RenderPath/Renderer.cs

194 lines
7.8 KiB
C#
Raw Permalink Normal View History

2023-04-13 00:24:33 +02:00
using System.Drawing;
using OSMDatastructure;
2023-04-13 00:24:33 +02:00
using OSMDatastructure.Graph;
using Pathfinding;
2023-04-13 00:24:33 +02:00
namespace RenderPath;
public abstract class Renderer
2023-04-13 00:24:33 +02:00
{
private const int ImageMaxSize = 20000;
private const int PenThickness = 2;
private static readonly Color RouteColor = Color.Red;
2023-04-23 13:06:47 +02:00
private static readonly Color WeightStartColor = Color.FromArgb(127, 0, 100, 255);
private static readonly Color WeightEndColor = Color.FromArgb(255, 0, 255, 0);
2023-04-23 13:06:47 +02:00
private static readonly Color RoadPrioStart = Color.FromArgb(200, 100, 100, 100);
private static readonly Color RoadPrioEnd = Color.FromArgb(255, 255, 180, 0);
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)
2023-04-13 00:24:33 +02:00
{
2023-04-21 00:41:18 +02:00
HashSet<OsmNode> nodes = new();
foreach (OSMDatastructure.Region r in rm.GetAllRegions())
nodes = nodes.Concat(r.nodes).ToHashSet();
float minLat = nodes.Min(node => node.coordinates.latitude);
float minLon = nodes.Min(node => node.coordinates.longitude);
float maxLat = nodes.Max(node => node.coordinates.latitude);
float maxLon = nodes.Max(node => node.coordinates.longitude);
2023-04-13 00:24:33 +02:00
float latDiff = maxLat - minLat;
float lonDiff = maxLon - minLon;
float scaleFactor = latDiff > lonDiff ? ImageMaxSize / latDiff : ImageMaxSize / lonDiff;
int pixelsX = (int)(lonDiff * scaleFactor);
int pixelsY = (int)(latDiff * scaleFactor);
Renderer renderer;
switch (renderType)
{
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)
{
2023-04-24 19:39:04 +02:00
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;
float x1 = (c1.longitude - minLon) * scaleFactor;
float y1 = (maxLat - c1.latitude) * scaleFactor;
float x2 = (c2.longitude - minLon) * scaleFactor;
float y2 = (maxLat - c2.latitude) * scaleFactor;
renderer.DrawLine(x1, y1, x2, y2, PenThickness, ColorInterp(RoadPrioStart, RoadPrioEnd, priority));
}
}
renderer.bounds = new Bounds(minLat,minLon,maxLat,maxLon);
return renderer;
}
public static Renderer DrawPath(PathResult pathResult, RenderType renderType, Renderer? drawOver)
{
List<Coordinates> coordinates = new();
foreach(PathNode node in pathResult.pathNodes)
coordinates.Add(node.coordinates);
float minLat = drawOver?.bounds!.minLat ?? coordinates.Min(coords => coords.latitude);
float minLon = drawOver?.bounds!.minLon ?? coordinates.Min(coords => coords.longitude);
float maxLat = drawOver?.bounds!.maxLat ?? coordinates.Max(coords => coords.latitude);
float maxLon = drawOver?.bounds!.maxLon ?? coordinates.Max(coords => coords.longitude);
2023-04-13 00:24:33 +02:00
float latDiff = maxLat - minLat;
float lonDiff = maxLon - minLon;
float scaleFactor = latDiff > lonDiff ? ImageMaxSize / latDiff : ImageMaxSize / lonDiff;
2023-04-13 00:24:33 +02:00
int pixelsX = (int)(lonDiff * scaleFactor);
int pixelsY = (int)(latDiff * scaleFactor);
Renderer renderer;
if(drawOver is null)
switch (renderType)
{
case RenderType.svg:
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];
float x1 = (c1.longitude - minLon) * scaleFactor;
float y1 = (maxLat - c1.latitude) * scaleFactor;
float x2 = (c2.longitude - minLon) * scaleFactor;
float y2 = (maxLat - c2.latitude) * scaleFactor;
renderer.DrawLine(x1, y1, x2, y2, PenThickness, RouteColor);
}
2023-04-13 00:24:33 +02:00
renderer.bounds = new Bounds(minLat, minLon, maxLat, maxLon);
return renderer;
}
public static Renderer DrawGScores(Dictionary<OsmNode, double> gScore, RenderType renderType, Renderer? drawOver)
{
2023-04-23 13:06:29 +02:00
float minLat = drawOver?.bounds!.minLat ?? gScore.Min(kv => kv.Key.coordinates.latitude);
float minLon = drawOver?.bounds!.minLon ?? gScore.Min(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);
2023-04-23 13:06:29 +02:00
double minWeight = gScore.Min(kv => kv.Value);
double maxWeight = gScore.Max(kv => kv.Value);
float latDiff = maxLat - minLat;
float lonDiff = maxLon - minLon;
float scaleFactor = latDiff > lonDiff ? ImageMaxSize / latDiff : ImageMaxSize / lonDiff;
int pixelsX = (int)(lonDiff * scaleFactor);
int pixelsY = (int)(latDiff * scaleFactor);
Renderer renderer;
if(drawOver is null)
switch (renderType)
{
case RenderType.svg:
renderer = new SVGRenderer(pixelsX, pixelsY);
break;
default:
renderer = new PNGRenderer(pixelsX, pixelsY);
break;
}
else
renderer = drawOver;
2023-04-23 13:06:29 +02:00
foreach (KeyValuePair<OsmNode, double> kv in gScore)
2023-04-13 00:24:33 +02:00
{
2023-04-13 01:12:29 +02:00
double percentage = (kv.Value - minWeight) / (maxWeight - minWeight);
float x = (kv.Key.coordinates.longitude - minLon) * scaleFactor;
float y = (maxLat - kv.Key.coordinates.latitude) * scaleFactor;
renderer.DrawDot(x, y, PenThickness, ColorInterp(WeightStartColor, WeightEndColor, percentage));
}
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
*/
private static int LinearInterp(int start, int end, double percentage) => start + (int)Math.Round(percentage * (end - start));
private static Color ColorInterp(Color start, Color end, double percentage) =>
Color.FromArgb(LinearInterp(start.A, end.A, percentage),
LinearInterp(start.R, end.R, percentage),
LinearInterp(start.G, end.G, percentage),
LinearInterp(start.B, end.B, percentage));
2023-04-13 00:24:33 +02:00
}