OSMServer/Server/RegionConverter.cs

using System.Globalization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml;
using OSMDatastructure.Graph;

namespace Server;

public class RegionConverter
{
    private static readonly XmlReaderSettings ReaderSettings = new()
    {
        IgnoreWhitespace = true,
        IgnoreComments = true
    };
    private static readonly NumberFormatInfo decimalInfo = new()
    {
        NumberDecimalSeparator = "."
    };

    public const string NodesFileName = "region.nodes";
    public const string WaysFileName = "region.ways";
    public const string tagsFileName = "region.tags";
    
    public static void ConvertXMLToRegions(string filePath, string outputPath)
    {
        if (!File.Exists(filePath))
            throw new FileNotFoundException();
        if (!Directory.Exists(outputPath))
            Directory.CreateDirectory(outputPath);
        
        Console.WriteLine("Converting Nodes...");
        FileStream xmlFileStream = new FileStream(filePath, FileMode.Open);
        Dictionary<ulong, ulong> nodeIdRegionDict = GetNodesAndRegions(XmlReader.Create(xmlFileStream, ReaderSettings), outputPath);
        xmlFileStream.Position = 0;
        
        Console.WriteLine("Converting Ways...");
        ImportWays(XmlReader.Create(xmlFileStream, ReaderSettings), nodeIdRegionDict, outputPath);
    }

    private static Dictionary<ulong, ulong> GetNodesAndRegions(XmlReader xmlReader, string outputPath)
    {
        BinaryFormatter bFormatter = new BinaryFormatter();
        Dictionary<ulong, ulong> nodeRegions = new();
        Dictionary<ulong, FileStream> regionFileStreams = new();
        Dictionary<ulong, OsmNode> tmpAllNodes = new();
        bool isHighway;
        HashSet<ulong> currentIds = new();
        while (xmlReader.Read())
        {
            if (xmlReader.Name == "node")
            {
                ulong id = Convert.ToUInt64(xmlReader.GetAttribute("id")!);
                float lat = Convert.ToSingle(xmlReader.GetAttribute("lat")!, decimalInfo);
                float lon = Convert.ToSingle(xmlReader.GetAttribute("lon")!, decimalInfo);
                tmpAllNodes.TryAdd(id, new OsmNode(id, lat, lon));
            }
            else if (xmlReader.Name == "way")
            {
                isHighway = false;
                currentIds.Clear();
                XmlReader wayReader = xmlReader.ReadSubtree();
                while (wayReader.Read())
                {
                    if (xmlReader.Name == "tag" && xmlReader.GetAttribute("k")!.Equals("highway"))
                    {
                        isHighway = true;
                    }
                    else if (xmlReader.Name == "nd")
                    {
                        try
                        {
                            ulong id = Convert.ToUInt64(xmlReader.GetAttribute("ref")!);
                            currentIds.Add(id);
                        }
                        catch (FormatException) { };
                    }
                }
                wayReader.Close();

                foreach (ulong nodeId in currentIds.Where(key => tmpAllNodes.ContainsKey(key)))
                {
                    if (isHighway)
                    {
                        ulong regionHash = Coordinates.GetRegionHashCode(tmpAllNodes[nodeId].coordinates);
                        FileStream nodesRegionStream;
                        if(regionFileStreams.ContainsKey(regionHash))
                            nodesRegionStream = regionFileStreams[regionHash];
                        else
                        {
                            string regionPath = Path.Combine(outputPath, regionHash.ToString());
                            Directory.CreateDirectory(regionPath);
                            string nodesRegionPath = Path.Combine(regionPath, NodesFileName);
                            nodesRegionStream = new FileStream(nodesRegionPath, FileMode.Create);
                            regionFileStreams.Add(regionHash, nodesRegionStream);
                        }
                        nodeRegions.Add(nodeId, regionHash);
                        
#pragma warning disable SYSLIB0011 //eheheh
                        bFormatter.Serialize(nodesRegionStream, tmpAllNodes[nodeId]);
#pragma warning restore SYSLIB0011
                    }
                    tmpAllNodes.Remove(nodeId);
                }
            }
            
        }
        xmlReader.Close();
        return nodeRegions;
    }
    
    private static void ImportWays(XmlReader xmlReader, Dictionary<ulong, ulong> nodeRegions, string outputPath)
    {
        BinaryFormatter bFormatter = new BinaryFormatter();
        bool currentWayIsHighway;
        ulong currentWayId = 0;
        List<ulong> currentNodeIds = new();
        Dictionary<Tag.TagType, dynamic> currentTags = new();
        Dictionary<ulong, FileStream> regionWaysFileStreams = new();
        Dictionary<ulong, FileStream> regionTagsFileStreams = new();
        while (xmlReader.ReadToFollowing("way"))
        {
            ulong wayId = Convert.ToUInt64(xmlReader.GetAttribute("id")!);
            currentWayIsHighway = false;
            currentNodeIds.Clear();
            currentTags.Clear();
            XmlReader wayReader = xmlReader.ReadSubtree();
            while (wayReader.Read())
            {
                currentWayId = Convert.ToUInt64(wayReader.GetAttribute("id")!);
                if (wayReader.Name == "tag")
                {
                    Tag wayTag = Tag.ConvertToTag(wayReader.GetAttribute("k")!, wayReader.GetAttribute("v")!);
                    currentTags.TryAdd(wayTag.key, wayTag.value);
                    if(wayTag.key == Tag.TagType.highway)
                        currentWayIsHighway = true;
                }
                else if (wayReader.Name == "nd")
                {
                    try
                    {
                        ulong nodeId = Convert.ToUInt64(wayReader.GetAttribute("ref"));
                        currentNodeIds.Add(nodeId);
                    }
                    catch (FormatException) { };
                }
            }
            wayReader.Close();
            if (currentWayIsHighway)
            {
                for (int i = 0; i < currentNodeIds.Count - 1; i++)
                {
                    ulong node1Id = currentNodeIds[i];
                    ulong node2Id = currentNodeIds[i+1];
                    if (currentTags.ContainsKey(Tag.TagType.oneway) && (bool)currentTags[Tag.TagType.oneway] && nodeRegions.ContainsKey(node1Id) && nodeRegions.ContainsKey(node2Id))
                    {
                        if (currentTags.ContainsKey(Tag.TagType.forward) && !(bool)currentTags[Tag.TagType.forward])
                        {
                            OsmWay n21e = new OsmWay(currentWayId, node2Id, node1Id, nodeRegions[node2Id]);
                            WriteWay(ref regionWaysFileStreams, nodeRegions[node2Id], n21e, outputPath);
                            WriteTag(ref regionTagsFileStreams, nodeRegions[node2Id], currentTags, outputPath);
                        }
                        else
                        {
                            OsmWay n12e = new OsmWay(currentWayId, node1Id, node2Id, nodeRegions[node2Id]);
                            WriteWay(ref regionWaysFileStreams, nodeRegions[node1Id], n12e, outputPath);
                            WriteTag(ref regionTagsFileStreams, nodeRegions[node1Id], currentTags, outputPath);
                        }
                    }
                    else if(nodeRegions.ContainsKey(node1Id) && nodeRegions.ContainsKey(node2Id))
                    {
                        OsmWay n12e = new OsmWay(currentWayId, node1Id, node2Id, nodeRegions[node2Id]);
                        WriteWay(ref regionWaysFileStreams, nodeRegions[node1Id], n12e, outputPath);
                        WriteTag(ref regionTagsFileStreams, nodeRegions[node1Id], currentTags, outputPath);
                        
                        OsmWay n21e = new OsmWay(currentWayId, node2Id, node1Id, nodeRegions[node2Id]);
                        WriteWay(ref regionWaysFileStreams, nodeRegions[node2Id], n21e, outputPath);
                        WriteTag(ref regionTagsFileStreams, nodeRegions[node2Id], currentTags, outputPath);
                    }
                }
            }
        }
        xmlReader.Close();
        foreach (FileStream f in regionWaysFileStreams.Values)
            f.Dispose();
        foreach(FileStream f in regionTagsFileStreams.Values)
            f.Dispose();
    }

    private static void WriteWay(ref Dictionary<ulong, FileStream> regionWaysFileStreams, ulong regionHash, OsmWay way, string outputPath)
    {
        BinaryFormatter bFormatter = new BinaryFormatter();
        if (!regionWaysFileStreams.ContainsKey(regionHash))
        {
            string waysRegionPath = Path.Combine(outputPath, regionHash.ToString(), WaysFileName);
            regionWaysFileStreams.Add(regionHash, new FileStream(waysRegionPath, FileMode.OpenOrCreate));
        }
#pragma warning disable SYSLIB0011
        bFormatter.Serialize(regionWaysFileStreams[regionHash], way);
#pragma warning restore SYSLIB0011
        
    }

    private static void WriteTag(ref Dictionary<ulong, FileStream> regionTagsFileStreams, ulong regionHash, Dictionary<Tag.TagType, dynamic> currentTags, string outputPath)
    {
        BinaryFormatter bFormatter = new BinaryFormatter();
        if (!regionTagsFileStreams.ContainsKey(regionHash))
        {
            string tagsRegionPath = Path.Combine(outputPath, regionHash.ToString(), tagsFileName);
            regionTagsFileStreams.Add(regionHash, new FileStream(tagsRegionPath, FileMode.OpenOrCreate));
        }
#pragma warning disable SYSLIB0011
        bFormatter.Serialize(regionTagsFileStreams[regionHash], currentTags);
#pragma warning restore SYSLIB0011
    }
}