glax/OSMServer
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Compare commits

base: glax:82d2de1537cae7884783eaeddf3d51e245d27ee4
Branches Tags
glax:master
..
compare: glax:2d5ffabb5d05fa3352a0fa64f4eb877e98b9a5a7
Branches Tags
glax:master

No commits in common. "82d2de1537cae7884783eaeddf3d51e245d27ee4" and "2d5ffabb5d05fa3352a0fa64f4eb877e98b9a5a7" have entirely different histories.
82d2de1537 ... 2d5ffabb5d

8 changed files with 87 additions and 108 deletions
Show Stats Expand all files Collapse all files

2
OSMDatastructure/Coordinates.cs
View File

@ -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)}";
}
}

2
OSMDatastructure/OsmEdge.cs
View File

@ -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}";
}
}

38
OSMDatastructure/OsmNode.cs
View File

@ -1,6 +1,3 @@
using System.ComponentModel;
using System.Runtime.Serialization;
namespace OSMDatastructure.Graph;
[Serializable]
@ -15,14 +12,6 @@ public class OsmNode
[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)
{
this.nodeId = nodeId;
@ -39,10 +28,10 @@ public class OsmNode
public OsmEdge? GetEdgeToNode(OsmNode n)
{
HashSet<OsmEdge> e = edges.Where(edge => edge.neighborId == n.nodeId).ToHashSet();
if (e.Count > 0)
return e.First();
else return null;
foreach (OsmEdge e in this.edges)
if (e.neighborId == n.nodeId)
return e;
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)
return $"{nodeId} {coordinates} ec:{edges.Count} d:{directDistanceToGoal} w:{currentPathWeight} l:{currentPathLength} p:{previousPathNode.nodeId}";
return
$"{nodeId} {coordinates} ec:{edges.Count} d:{directDistanceToGoal} w:{currentPathWeight} l:{currentPathLength} null";
if(this.previousPathNode != null)
return string.Format(
"NODE {0} Edges-Count: {1} previousPathNode: {2} currentPathWeight: {3} currentPathLength: {4} directDistanceToGoal: {5}",
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);
}
}

16
OSMDatastructure/Tag.cs
View File

@ -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;

2
OSMDatastructure/TagManager.cs
View File

@ -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)

67
Pathfinding/Pathfinder.cs
View File

@ -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? goalRegion = regionManager.GetRegion(goal);
if (startRegion is null || goalRegion is null)
return new List<OsmNode>();
Region startRegion, goalRegion;
try
{
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)
{
if (node.directDistanceToGoal.Equals(double.MaxValue))
{
node.directDistanceToGoal = Utils.DistanceBetween(node, goalNode);
}
closestNodeToGoal = toVisit.OrderBy(node => node.directDistanceToGoal).First();
foreach (OsmEdge edge in closestNodeToGoal.edges)
if (node.directDistanceToGoal < closestNodeToGoal.directDistanceToGoal)
{
OsmNode? neighbor = regionManager.GetNode(edge.neighborId, edge.neighborRegion);
if (neighbor is not null)
closestNodeToGoal = node;
}
}
foreach (OsmWay edge in closestNodeToGoal.edges)
{
OsmNode? neighbor = regionManager.GetNode(edge.neighborCoordinates);
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;
}
}
}*/
}

47
Pathfinding/RegionManager.cs
View File

@ -13,20 +13,20 @@ 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));
}
public Region? GetRegion(ulong id)
{
if(_regions.TryGetValue(id, out Region? value))
return value;
if(_regions.ContainsKey(Coordinates.GetRegionHashCode(coordinates)))
return _regions[Coordinates.GetRegionHashCode(coordinates)];
else
{
Region? loadedRegion = LoadRegion(id);
if(loadedRegion is not null)
_regions.Add(loadedRegion!.regionHash, value: loadedRegion);
Region loadedRegion = LoadRegion(coordinates);
_regions.Add(loadedRegion.regionHash, value: loadedRegion);
return loadedRegion;
}
}
@ -36,28 +36,21 @@ 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));
}
private Region? LoadRegion(ulong id)
{
return Region.FromId(workingDirectory, id);
throw new NotImplementedException();
}
public OsmNode? GetNode(Coordinates coordinates)
{
Region? regionWithNode = GetRegion(coordinates);
if (regionWithNode is not null)
Region regionWithNode = GetRegion(coordinates);
return regionWithNode.GetNode(coordinates);
else return null;
}
public OsmNode? GetNode(ulong nodeId, ulong regionId)
{
Region? r = GetRegion(regionId);
return r?.GetNode(nodeId);
}
}
}

15
Server/Server.cs
View File

@ -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 finish = new Coordinates(48.7906258f, 9.8355983f);
OsmNode[] path = Pathfinder.CustomAStar("D:/map", start, finish, Tag.SpeedType.pedestrian).ToArray();
/*
Coordinates start = new Coordinates(48.243351f, 11.640417f);
Coordinates finish = new Coordinates(48.25239f, 11.53272f);
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();*/
}
}