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

Naming Changes

Browse Source
This commit is contained in:
C9Glax 2023-02-02 22:30:43 +01:00
parent f7edc288c1
commit 58aac549c7
17 changed files with 366 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Importer/Connection.cs
View File

@ -1,42 +0,0 @@
namespace OSMServer;
public class Connection
{
public Coordinates end { get; }
private Dictionary<string, string> tags;
public Connection(Coordinates end)
{
this.end = end;
this.tags = new Dictionary<string, string>();
}
public Connection(Coordinates end, Dictionary<string, string> tags)
{
this.end = end;
this.tags = tags;
}
public bool AddTag(string key, string value)
{
return this.tags.TryAdd(key, value);
}
public string? TryGetTagValue(string key)
{
return this.tags.ContainsKey(key) ? this.tags[key] : null;
}
public bool ContainsTag(string key)
{
return this.tags.ContainsKey(key);
}
public void UpdateTag(string key, string value)
{
if(!this.AddTag(key, value))
this.tags[key] = value;
}
}

27
Importer/Coordinates.cs
View File

@ -1,27 +0,0 @@
using System.Diagnostics;
namespace OSMServer;
public class Coordinates
{
public float lat { get; }
public float lon { get; }
public Coordinates(float lat, float lon)
{
this.lat = lat;
this.lon = lon;
}
public uint GetHash()
{
return Convert.ToUInt32((this.lat * 10000f + this.lon) * 10000f);
}
public uint GetRegionHash()
{
float latRegion = this.lat % Importer.regionSize;
float lonRegion = this.lon % Importer.regionSize;
return new Coordinates(latRegion, lonRegion).GetHash();
}
}

138
Importer/Importer.cs
View File

@ -1,138 +0,0 @@
using System.Xml;
using Newtonsoft.Json;
namespace OSMServer;
public class Importer
{
public const float regionSize = 0.01f;
public static void Split(string xmlFilePath, string outputFolderPath)
{
if (!File.Exists(xmlFilePath))
throw new FileNotFoundException();
FileStream xmlFileStream = File.OpenRead(xmlFilePath);
HashSet<ulong> nodesToImport = ReturnGraphNodes(XmlReader.Create(xmlFileStream));
xmlFileStream.Position = 0;
XmlReader xmlReader = XmlReader.Create(xmlFileStream);
Dictionary<ulong, Node> nodes = new Dictionary<ulong, Node>();
RegionManager regionManager = new RegionManager();
while (xmlReader.ReadToFollowing("node"))
{
ulong id = Convert.ToUInt64(xmlReader.GetAttribute("id"));
if (nodesToImport.Contains(id))
{
float lat = Convert.ToSingle(xmlReader.GetAttribute("lat")!.Replace('.', ','));
float lon = Convert.ToSingle(xmlReader.GetAttribute("lon")!.Replace('.', ','));
Node newNode = new Node(lat, lon);
nodes.Add(id, newNode);
regionManager.GetRegion(newNode).AddNode(id, newNode);
}
}
xmlReader.Close();
xmlFileStream.Position = 0;
xmlReader = XmlReader.Create(xmlFileStream);
while (xmlReader.ReadToFollowing("way"))
{
XmlReader wayReader = xmlReader.ReadSubtree();
HashSet<ulong> nodesInWay = new HashSet<ulong>();
Dictionary<string, string> tags = new Dictionary<string, string>();
while (wayReader.Read())
{
if (wayReader.IsStartElement() && wayReader.Name.Equals("nd"))
{
nodesInWay.Add(Convert.ToUInt64(wayReader.GetAttribute("ref")));
}
else if (wayReader.IsStartElement() && wayReader.Name.Equals("tag"))
{
tags.Add(wayReader.GetAttribute("k")!, wayReader.GetAttribute("v")!);
}
}
if (tags.ContainsKey("highway"))
{
AddConnections(nodes, nodesInWay.ToArray(), tags);
}
}
foreach(Region region in regionManager.GetAllRegions())
WriteRegion(region, outputFolderPath);
}
private static HashSet<ulong> ReturnGraphNodes(XmlReader xmlReader)
{
HashSet<ulong> retSet = new HashSet<ulong>();
while (xmlReader.ReadToFollowing("way"))
{
XmlReader wayReader = xmlReader.ReadSubtree();
HashSet<ulong> tmpList = new HashSet<ulong>();
bool addNodes = false;
while (wayReader.Read())
{
if (wayReader.IsStartElement())
{
if (wayReader.Name.Equals("nd"))
{
tmpList.Add(Convert.ToUInt64(wayReader.GetAttribute("ref")));
}
else if (wayReader.Name.Equals("tag"))
{
if (wayReader.GetAttribute("v")!.Equals("highway"))
addNodes = true;
}
}
}
if(addNodes)
retSet.UnionWith(tmpList);
}
return retSet;
}
private static void AddConnections(Dictionary<ulong, Node> nodes, ulong[] nodeIds,
Dictionary<string, string> tags)
{
string oneWayString = tags.ContainsKey("oneway") ? tags["oneway"] : "no";
bool oneWay = false;
bool forward = true;
switch (oneWayString)
{
case "yes":
oneWay = true;
break;
case "-1":
forward = false;
break;
}
for (int i = 0; i < nodeIds.Length - 1; i++)
{
if (oneWay)
{
nodes[nodeIds[i]].AddConnection(new Connection(nodes[nodeIds[i + 1]], tags));
nodes[nodeIds[i + 1]].AddConnection(new Connection(nodes[nodeIds[i]], tags));
}
else if (forward)
{
nodes[nodeIds[i]].AddConnection(new Connection(nodes[nodeIds[i + 1]], tags));
}
else
{
nodes[nodeIds[i + 1]].AddConnection(new Connection(nodes[nodeIds[i]], tags));
}
}
}
private static void WriteRegion(Region region, string outputFolderPath)
{
if (!Directory.Exists(outputFolderPath))
Directory.CreateDirectory(outputFolderPath);
string jsonString = JsonConvert.SerializeObject(region);
string fileName = region.regionHash.ToString();
File.WriteAllText(Path.Combine(outputFolderPath, fileName), jsonString);
}
}

21
Importer/Node.cs
View File

@ -1,21 +0,0 @@
namespace OSMServer;
public class Node : Coordinates
{
private HashSet<Connection> connections = new HashSet<Connection>();
public Node(float lat, float lon) : base(lat, lon)
{
}
public void AddConnection(Connection connection)
{
this.connections.Add(connection);
}
public Connection[] GetConnections()
{
return this.connections.ToArray();
}
}

33
Importer/Region.cs
View File

@ -1,33 +0,0 @@
namespace OSMServer;
public class Region
{
private Dictionary<ulong, Node> nodesInRegion = new Dictionary<ulong, Node>();
public uint regionHash;
public Region(uint regionHash)
{
this.regionHash = this.regionHash;
}
public Region(Coordinates regionCoordinates)
{
this.regionHash = regionCoordinates.GetRegionHash();
}
public Region(ulong nodeId, Node firstNode)
{
this.regionHash = firstNode.GetRegionHash();
this.nodesInRegion.Add(nodeId, firstNode);
}
public void AddNode(ulong nodeId, Node node)
{
this.nodesInRegion.Add(nodeId, node);
}
public Node[] GetNodes()
{
return this.nodesInRegion.Values.ToArray();
}
}

28
Importer/RegionManager.cs
View File

@ -1,28 +0,0 @@
namespace OSMServer;
public class RegionManager
{
private Dictionary<uint, Region> regions;
public RegionManager()
{
this.regions = new Dictionary<uint, Region>();
}
public Region GetRegion(Coordinates coordinates)
{
if(this.regions.ContainsKey(coordinates.GetRegionHash()))
return this.regions[coordinates.GetRegionHash()];
else
{
Region newRegion = new Region(coordinates.GetRegionHash());
this.regions.Add(newRegion.regionHash, newRegion);
return newRegion;
}
}
public Region[] GetAllRegions()
{
return this.regions.Values.ToArray();
}
}

50
OSMImporter/Coordinates.cs Normal file
View File

@ -0,0 +1,50 @@
using System.Globalization;
namespace OSMImporter
{
public class Coordinates
{
public float lat { get; }
public float lon { get; }
public Coordinates(float lat, float lon)
{
this.lat = lat;
this.lon = lon;
}
private const float decimalCoordsSave = 10000;
private const ulong offset = 10000000;
//Latitude maxChars = 7
//Longitude maxChars = 8
public ulong GetHash()
{
ulong latHash = Convert.ToUInt64((this.lat + 90) * decimalCoordsSave);
ulong lonHash = Convert.ToUInt64((this.lon + 180) * decimalCoordsSave);
return latHash * offset + lonHash;
}
public ulong GetRegionHash()
{
float latRegion = this.lat - this.lat % Importer.regionSize;
float lonRegion = this.lon - this.lon % Importer.regionSize;
ulong latHash = Convert.ToUInt64((latRegion + 90) * decimalCoordsSave);
ulong lonHash = Convert.ToUInt64((lonRegion + 180) * decimalCoordsSave);
return latHash * offset + lonHash;
}
public static Coordinates GetFromHash(ulong hash)
{
ulong latHash = (hash / offset) - 90;
ulong lonHash = (hash % offset) - 180;
float lat = Convert.ToSingle(latHash) / decimalCoordsSave;
float lon = Convert.ToSingle(lonHash) / decimalCoordsSave;
return new Coordinates(lat, lon);
}
public override string ToString()
{
return string.Format("{0} {1}", this.lat.ToString(CultureInfo.InvariantCulture), this.lon.ToString(CultureInfo.InvariantCulture));
}
}
}

188
OSMImporter/Importer.cs Normal file
View File

@ -0,0 +1,188 @@
using System.Globalization;
using System.Text;
using System.Xml;
namespace OSMImporter
{
public static class Importer
{
public const float regionSize = 0.01f;
private static readonly XmlReaderSettings readerSettings = new()
{
IgnoreWhitespace = true,
IgnoreComments = true
};
private static readonly NumberFormatInfo coordinateFormat = new NumberFormatInfo()
{
NumberDecimalSeparator = "."
};
public static void Split(string xmlFilePath, string outputFolderPath)
{
if (!File.Exists(xmlFilePath))
throw new FileNotFoundException();
FileStream xmlFileStream = File.OpenRead(xmlFilePath);
Console.WriteLine("Reading ways once...");
Dictionary<ulong, Node?> nodes = ReturnNodeIdDictionary(XmlReader.Create(xmlFileStream, readerSettings));
xmlFileStream.Position = 0;
RegionManager regionManager = new RegionManager();
Console.WriteLine("Reading nodes...");
LoadNodesIntoDictionary(ref nodes, XmlReader.Create(xmlFileStream, readerSettings), ref regionManager);
xmlFileStream.Position = 0;
Console.WriteLine("Reading ways twice...");
CreateConnections(XmlReader.Create(xmlFileStream, readerSettings), ref nodes);
Console.WriteLine("Writing...");
foreach(Region region in regionManager.GetAllRegions())
WriteRegion(region, outputFolderPath);
}
private static Dictionary<ulong, Node?> ReturnNodeIdDictionary(XmlReader xmlReader)
{
Dictionary<ulong, Node?> retSet = new Dictionary<ulong, Node?>();
while (xmlReader.ReadToFollowing("way"))
{
byte[] byteArray = Encoding.ASCII.GetBytes(xmlReader.ReadOuterXml());
MemoryStream wayStream = new MemoryStream(byteArray);
XmlReader wayReader = XmlReader.Create(wayStream);
bool addNodes = false;
while (wayReader.ReadToFollowing("tag") && !addNodes)
{
if (wayReader.GetAttribute("v")!.Equals("highway"))
{
addNodes = true;
break;
}
}
if (addNodes)
{
wayStream.Position = 0;
wayReader = XmlReader.Create(wayStream);
while (wayReader.ReadToFollowing("nd"))
{
retSet.TryAdd(Convert.ToUInt64(wayReader.GetAttribute("ref")!), null);
}
}
}
xmlReader.Close();
return retSet;
}
private static void LoadNodesIntoDictionary(ref Dictionary<ulong, Node?> nodes, XmlReader xmlReader, ref RegionManager regionManager)
{
while (xmlReader.ReadToFollowing("node"))
{
ulong id = Convert.ToUInt64(xmlReader.GetAttribute("id"));
if (nodes.ContainsKey(id))
{
float lat = Convert.ToSingle(xmlReader.GetAttribute("lat")!, coordinateFormat);
float lon = Convert.ToSingle(xmlReader.GetAttribute("lon")!, coordinateFormat);
Node newNode = new Node(lat, lon);
nodes[id] = newNode;
regionManager.GetRegion(newNode).AddNode(id, newNode);
}
}
xmlReader.Close();
}
private static void CreateConnections(XmlReader xmlReader, ref Dictionary<ulong, Node?> nodes)
{
while (xmlReader.ReadToFollowing("way"))
{
byte[] byteArray = Encoding.ASCII.GetBytes(xmlReader.ReadOuterXml());
MemoryStream wayStream = new MemoryStream(byteArray);
XmlReader wayReader = XmlReader.Create(wayStream);
Dictionary<string, string> tags = new Dictionary<string, string>();
bool addNodes = false;
while (wayReader.ReadToFollowing("tag"))
{
if (wayReader.GetAttribute("v")!.Equals("highway"))
{
addNodes = true;
}
tags.Add(wayReader.GetAttribute("k")!, value: wayReader.GetAttribute("v")!);
}
if (addNodes)
{
HashSet<ulong> nodesInWay = new HashSet<ulong>();
wayStream.Position = 0;
wayReader = XmlReader.Create(wayStream);
while (wayReader.ReadToFollowing("nd"))
{
nodesInWay.Add(Convert.ToUInt64(wayReader.GetAttribute("ref")));
}
ConnectNodesOfWay(nodes, nodesInWay.ToArray(), tags);
}
}
xmlReader.Close();
}
private static void ConnectNodesOfWay(Dictionary<ulong, Node?> nodes, ulong[] nodeIds,
Dictionary<string, string> tags)
{
string oneWayString = tags.ContainsKey("oneway") ? tags["oneway"] : "no";
bool oneWay = false;
bool forward = true;
switch (oneWayString)
{
case "yes":
oneWay = true;
break;
case "-1":
forward = false;
break;
}
for (int i = 0; i < nodeIds.Length - 1; i++)
{
if (oneWay)
{
if(nodes.ContainsKey(nodeIds[i]))
nodes[nodeIds[i]]!.AddConnection(new Connection(nodeIds[i + 1], tags));
if(nodes.ContainsKey(nodeIds[i + 1]))
nodes[nodeIds[i + 1]]!.AddConnection(new Connection(nodeIds[i], tags));
}
else if (forward)
{
if(nodes.ContainsKey(nodeIds[i]))
nodes[nodeIds[i]]!.AddConnection(new Connection(nodeIds[i + 1], tags));
}
else
{
if(nodes.ContainsKey(nodeIds[i + 1]))
nodes[nodeIds[i + 1]]!.AddConnection(new Connection(nodeIds[i], tags));
}
}
}
private static void WriteRegion(Region region, string outputFolderPath)
{
if (!Directory.Exists(outputFolderPath))
Directory.CreateDirectory(outputFolderPath);
string fileName = region.regionHash.ToString();
string fullPath = Path.Combine(outputFolderPath, fileName);
if (!File.Exists(fullPath))
File.Create(fullPath).Close();
FileStream fileStream = new FileStream(fullPath, FileMode.Append);
foreach (Node node in region.GetNodes())
{
byte[] nodeByte = node.ToByte();
fileStream.Write(nodeByte, 0, nodeByte.Length );
}
fileStream.Close();
}
}
}

44
OSMImporter/Node.cs Normal file
View File

@ -0,0 +1,44 @@
namespace OSMImporter
{
public class Node : Coordinates
{
private readonly HashSet<Connection> _connections = new HashSet<Connection>();
public Node(float lat, float lon) : base(lat, lon)
{
}
public void AddConnection(Connection connection)
{
this._connections.Add(connection);
}
public Connection[] GetConnections()
{
return this._connections.ToArray();
}
/*
* Returns byte array in order:
* Value 1: Latitude (4bytes)
* Value 2: Longitude (4bytes)
* Value 3: Connections-Count (1 byte)
* Value x: Connection (8bytes) //TODO
*/
public byte[] ToByte()
{
float[] coords = { this.lat, this.lon };
byte[] ret = new byte[sizeof(float) * coords.Length + 1 + _connections.Count * sizeof(ulong)];
Buffer.BlockCopy(coords, 0, ret, 0, sizeof(float) * coords.Length );
byte countConnections = Convert.ToByte(_connections.Count);
Connection[] conns = this._connections.ToArray();
for (int i = 0; i < conns.Length; i++)
{
byte[] connection = conns[i].ToByte();
Buffer.BlockCopy(connection, 0, ret, sizeof(float) * coords.Length + 1 + i * connection.Length, connection.Length);
}
return ret;
}
}
}

4
Importer/Importer.csproj → OSMImporter/OSMImporter.csproj
View File

@ -7,8 +7,4 @@
<RootNamespace>OSMServer</RootNamespace>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
</ItemGroup>
</Project>

29
OSMImporter/Region.cs Normal file
View File

@ -0,0 +1,29 @@
namespace OSMImporter
{
public class Region
{
private readonly Dictionary<ulong, Node> _nodesInRegion = new Dictionary<ulong, Node>();
public ulong regionHash { get; }
public Region(Coordinates regionCoordinates)
{
this.regionHash = regionCoordinates.GetRegionHash();
}
public Region(ulong nodeId, Node firstNode)
{
this.regionHash = firstNode.GetRegionHash();
this._nodesInRegion.Add(nodeId, value: firstNode);
}
public void AddNode(ulong nodeId, Node node)
{
this._nodesInRegion.Add(nodeId, value: node);
}
public Node[] GetNodes()
{
return this._nodesInRegion.Values.ToArray();
}
}
}

29
OSMImporter/RegionManager.cs Normal file
View File

@ -0,0 +1,29 @@
namespace OSMImporter
{
public class RegionManager
{
private readonly Dictionary<ulong, Region> _regions;
public RegionManager()
{
this._regions = new Dictionary<ulong, Region>();
}
public Region GetRegion(Coordinates coordinates)
{
if(this._regions.ContainsKey(coordinates.GetRegionHash()))
return this._regions[coordinates.GetRegionHash()];
else
{
Region newRegion = new Region(coordinates);
this._regions.Add(newRegion.regionHash, value: newRegion);
return newRegion;
}
}
public Region[] GetAllRegions()
{
return this._regions.Values.ToArray();
}
}
}

8
OSMServer.sln
View File

@ -1,6 +1,8 @@

Microsoft Visual Studio Solution File, Format Version 12.00
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OSMServer", "OSMServer\OSMServer.csproj", "{BE5C111D-AD61-433A-AE7E-F02B78551347}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OSMImporter", "OSMImporter\OSMImporter.csproj", "{BE5C111D-AD61-433A-AE7E-F02B78551347}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Server", "Server\Server.csproj", "{7E025EFC-B889-4B57-A03F-EF294CFFBCD6}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@ -12,5 +14,9 @@ Global
{BE5C111D-AD61-433A-AE7E-F02B78551347}.Debug|Any CPU.Build.0 = Debug|Any CPU
{BE5C111D-AD61-433A-AE7E-F02B78551347}.Release|Any CPU.ActiveCfg = Release|Any CPU
{BE5C111D-AD61-433A-AE7E-F02B78551347}.Release|Any CPU.Build.0 = Release|Any CPU
{7E025EFC-B889-4B57-A03F-EF294CFFBCD6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{7E025EFC-B889-4B57-A03F-EF294CFFBCD6}.Debug|Any CPU.Build.0 = Debug|Any CPU
{7E025EFC-B889-4B57-A03F-EF294CFFBCD6}.Release|Any CPU.ActiveCfg = Release|Any CPU
{7E025EFC-B889-4B57-A03F-EF294CFFBCD6}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
EndGlobal

4
OSMServer.sln.DotSettings Normal file
View File

@ -0,0 +1,4 @@
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:Boolean x:Key="/Default/UserDictionary/Words/=busway/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=maxspeed/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=oberbayern/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

5
OSMServer.sln.DotSettings.user
View File

@ -1,2 +1,5 @@
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=_002Fhome_002Fglax_002FRiderProjects_002FGeo_002DGraph_002FGeo_002DGraph_002Fobj_002FDebug_002Fnet6_002E0_002FGeo_002DGraph_002Edll/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
<s:Boolean x:Key="/Default/AddReferences/RecentPaths/=_002Fhome_002Fglax_002FRiderProjects_002FGeo_002DGraph_002FGeo_002DGraph_002Fobj_002FDebug_002Fnet6_002E0_002FGeo_002DGraph_002Edll/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=ferrata/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=glax/@EntryIndexedValue">True</s:Boolean>
<s:Boolean x:Key="/Default/UserDictionary/Words/=guideway/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

10
Server/Server.cs
View File

@ -1,9 +1,13 @@
namespace OSMServer;
using OSMImporter;
namespace Server;
public class Server
{
public Server()
public static void Main(string[] args)
{
Importer.Split("/home/glax/Downloads/bayern-latest.osm.bz2", "/home/glax/Downloads/split");
Importer.Split("/home/glax/Downloads/oberbayern-latest.osm", "/home/glax/Downloads/split");
}
}

4
Server/Server.csproj
View File

@ -7,4 +7,8 @@
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\OSMImporter\OSMImporter.csproj" />
</ItemGroup>
</Project>