glax/AStar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed level

Browse Source
This commit is contained in:
C9Glax 2022-05-05 23:47:15 +02:00
parent 702ce6f1fb
commit 7c61d9565b
1 changed files with 138 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
OpenStreetMap Importer/Importer.cs
View File

@ -6,61 +6,50 @@ namespace OpenStreetMap_Importer
{ {
public class Importer public class Importer
{ {
public static Dictionary<UInt64, Node> Import(Logger logger)
{
XmlReader reader = XmlReader.Create(new MemoryStream(OSM_Data.map));
reader.MoveToContent();
Dictionary<UInt64, Node> nodes = new Dictionary<UInt64, Node>();
nodeType currentNodeType = nodeType.NULL; public static Dictionary<ulong, Node> Import(ref Logger logger)
Node nullNode = new Node(); {
Node currentNode = nullNode; List<Way> ways = new List<Way>();
Dictionary<ulong, Node> nodes = new Dictionary<ulong, Node>();
bool wayTag = false;
Way currentWay = new Way(); Way currentWay = new Way();
/*
* First iteration
* Import "ways" with a tag "highway" and add the node-ids to the list of nodes
*/
XmlReaderSettings readerSettings = new XmlReaderSettings()
{
IgnoreWhitespace = true,
IgnoreComments = true
};
XmlReader reader = XmlReader.Create(new MemoryStream(OSM_Data.map), readerSettings);
reader.MoveToContent();
while (reader.Read()) while (reader.Read())
{ {
if (reader.Name == "node" && reader.IsStartElement()) if (reader.Name == "way" && reader.IsStartElement())
{ {
currentNodeType = nodeType.NODE; logger.log(loglevel.VERBOSE, "WAY {0} nodes {1}", currentWay.highway.ToString(), currentWay.nodeIds.Count);
nodes.Add( if (currentWay.highway != Way.highwayType.NONE)
Convert.ToUInt64(reader.GetAttribute("id")), {
new Node( ways.Add(currentWay);
Convert.ToSingle(reader.GetAttribute("lat")), foreach (ulong id in currentWay.nodeIds)
Convert.ToSingle(reader.GetAttribute("lon")) nodes.Add(id, Node.nullnode);
)
);
} }
else if (reader.Name == "way") wayTag = true;
{
if(currentNodeType == nodeType.WAY)
{
ImportWay(currentWay);
logger.log(loglevel.INFO, "Way nodes: {0}", currentWay.nodes.Count);
}
currentNodeType = nodeType.WAY;
currentNode = nullNode;
currentWay = new Way(); currentWay = new Way();
reader.GetAttribute("id");
}else if (reader.Name == "nd" && currentNodeType == nodeType.WAY){
UInt64 id = Convert.ToUInt64(reader.GetAttribute("ref"));
if (!nodes.TryGetValue(id, out currentNode))
{
logger.log(loglevel.DEBUG, "Node with id {0} not imported.", id);
} }
else else if (reader.Name == "tag" && wayTag)
{ {
currentWay.nodes.Add(currentNode); string? value = reader.GetAttribute("v");
} string? key = reader.GetAttribute("k");
}else if (reader.Name == "tag") logger.log(loglevel.VERBOSE, "TAG {0} {1}", key, value);
switch (key)
{ {
if(currentNodeType == nodeType.WAY) case "highway":
{ currentWay.setHighwayType(value);
string ?value = reader.GetAttribute("v"); break;
switch (reader.GetAttribute("k"))
{
/*case "highway":
break;*/
case "oneway": case "oneway":
switch (value) switch (value)
{ {
@ -81,87 +70,112 @@ namespace OpenStreetMap_Importer
break;*/ break;*/
} }
} }
} else if(reader.Name == "node")
}
logger.log(loglevel.INFO, "Loaded. Nodes: {0}", nodes.Count);
return nodes;
}
internal static void ImportWay(Way way)
{ {
wayTag = false;
}
}
logger.log(loglevel.DEBUG, "Ways: {0}", ways.Count);
reader.Close();
reader = XmlReader.Create(new MemoryStream(OSM_Data.map), readerSettings);
reader.MoveToContent();
/*
* Second iteration
* Import nodes that are needed by the "ways"
*/
while (reader.Read())
{
if (reader.Name == "node")
{
ulong id = Convert.ToUInt64(reader.GetAttribute("id"));
if (nodes.ContainsKey(id))
{
Console.Read();
float lat = Convert.ToSingle(reader.GetAttribute("lat").Replace('.', ','));
float lon = Convert.ToSingle(reader.GetAttribute("lon").Replace('.', ','));
nodes[id] = new Node(lat, lon);
logger.log(loglevel.VERBOSE, "NODE {0} {1} {2}", id, lat, lon);
}
}
}
logger.log(loglevel.DEBUG, "Nodes: {0}", nodes.Count);
/*
* Add connections between nodes based on ways and calculate distance
*/
ulong edges = 0;
foreach(Way way in ways)
{
if (way.direction == Way.wayDirection.forward) if (way.direction == Way.wayDirection.forward)
{ {
for(int index = 0; index < way.nodes.Count - 1; index++) for (int index = 0; index < way.nodeIds.Count - 1; index++)
{ {
Node currentNode = way.nodes[index]; Node currentNode = nodes[way.nodeIds[index]];
Node neighborNode = way.nodes[index + 1]; Node neighborNode = nodes[way.nodeIds[index + 1]];
ushort weight = Convert.ToUInt16(DistanceBetweenNodes(currentNode, neighborNode)); ushort weight = Convert.ToUInt16(Utils.DistanceBetweenNodes(currentNode, neighborNode));
currentNode.edges.Add(new Edge(neighborNode, weight)); currentNode.edges.Add(new Edge(neighborNode, weight));
logger.log(loglevel.VERBOSE, "EDGE {0} -- {1} --> {2}", way.nodeIds[index], weight, way.nodeIds[index + 1]);
edges++;
if (!way.oneway) if (!way.oneway)
{
neighborNode.edges.Add(new Edge(currentNode, weight)); neighborNode.edges.Add(new Edge(currentNode, weight));
edges++;
}
} }
} }
else else
{ {
for (int index = way.nodes.Count-1; index > 1; index--) for (int index = way.nodeIds.Count - 1; index > 1; index--)
{ {
Node currentNode = way.nodes[index]; Node currentNode = nodes[way.nodeIds[index]];
Node neighborNode = way.nodes[index - 1]; Node neighborNode = nodes[way.nodeIds[index - 1]];
ushort weight = Convert.ToUInt16(DistanceBetweenNodes(currentNode, neighborNode)); ushort weight = Convert.ToUInt16(Utils.DistanceBetweenNodes(currentNode, neighborNode));
currentNode.edges.Add(new Edge(neighborNode, weight)); currentNode.edges.Add(new Edge(neighborNode, weight));
logger.log(loglevel.VERBOSE, "EDGE {0} -- {1} --> {2}", way.nodeIds[index], weight, way.nodeIds[index - 1]);
edges++;
if (!way.oneway) if (!way.oneway)
{
neighborNode.edges.Add(new Edge(currentNode, weight)); neighborNode.edges.Add(new Edge(currentNode, weight));
edges++;
}
} }
} }
} }
logger.log(loglevel.DEBUG, "Edges: {0}", edges);
internal enum nodeType { NODE, WAY, NULL } return nodes;
}
internal struct Way internal struct Way
{ {
public List<Node> nodes; public List<ulong> nodeIds;
public bool oneway; public bool oneway;
public wayDirection direction; public wayDirection direction;
public highwayType highway;
public enum wayDirection { forward, backward } public enum wayDirection { forward, backward }
public enum highwayType { NONE, motorway, trunk, primary, secondary, tertiary, unclassified, residential, motorway_link, trunk_link, primary_link, secondary_link, tertiary_link, living_street, service, pedestrian, track, bus_guideway, escape, raceway, road, busway, footway, bridleway, steps, corridor, path, cycleway, construction}
public Way() public Way()
{ {
this.nodes = new List<Node>(); this.nodeIds = new List<ulong>();
this.oneway = false; this.oneway = false;
this.direction = wayDirection.forward; this.direction = wayDirection.forward;
} this.highway = highwayType.NONE;
} }
private static double DistanceBetweenNodes(Node n1, Node n2) public void setHighwayType(string waytype)
{ {
return DistanceBetweenCoordinates(n1.lat, n1.lon, n2.lat, n2.lon); try
}
private static double DistanceBetweenCoordinates(float lat1, float lon1, float lat2, float lon2)
{ {
const int earthRadius = 6371; this.highway = (highwayType)Enum.Parse(typeof(highwayType), waytype, true);
double differenceLat = DegreesToRadians(lat2 - lat1); }catch(Exception)
double differenceLon = DegreesToRadians(lon2 - lon1);
double lat1Rads = DegreesToRadians(lat1);
double lat2Rads = DegreesToRadians(lat2);
double a = Math.Sin(differenceLat / 2) * Math.Sin(differenceLat / 2) + Math.Sin(differenceLon / 2) * Math.Sin(differenceLon / 2) * Math.Cos(lat1Rads) * Math.Cos(lat2Rads);
double c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
return earthRadius * c;
}
private static double DegreesToRadians(double deg)
{ {
return deg * Math.PI / 180.0; this.highway = highwayType.NONE;
}
} }
private static double RadiansToDegrees(double rad)
{
return rad * 180.0 / Math.PI;
} }
} }
} }