OSMServer/OSMSplitter/Importer.cs

using System.Globalization;
using System.Text;
using System.Xml;
using OSMDatastructure;

namespace OSMImporter
{
    public static class Importer
    {
    
        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;
            RegionStruct regionStruct = new RegionStruct();

            Console.WriteLine("Reading nodes...");
            LoadNodesIntoDictionary(ref nodes, XmlReader.Create(xmlFileStream, readerSettings), ref regionStruct);
        
            xmlFileStream.Position = 0;
        
            Console.WriteLine("Reading ways twice...");
            CreateConnections(XmlReader.Create(xmlFileStream, readerSettings), ref nodes);

            Console.WriteLine("Writing...");
        
            foreach(Region region in regionStruct.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 RegionStruct regionStruct)
        {
            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;
                    regionStruct.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], nodes[nodeIds[i + 1]]!, tags));
                    if(nodes.ContainsKey(nodeIds[i + 1]))
                        nodes[nodeIds[i + 1]]!.AddConnection(new Connection(nodeIds[i], nodes[nodeIds[i]]!, tags));
                }
                else if (forward)
                {
                    if(nodes.ContainsKey(nodeIds[i]))
                        nodes[nodeIds[i]]!.AddConnection(new Connection(nodeIds[i + 1], nodes[nodeIds[i + 1]]!, tags));
                }
                else
                {
                    if(nodes.ContainsKey(nodeIds[i + 1]))
                        nodes[nodeIds[i + 1]]!.AddConnection(new Connection(nodeIds[i], nodes[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);
            fileStream.Write(ByteConverter.GetBytes(region));
            fileStream.Close();
        }
    }
    
    internal class RegionStruct
    {
        private readonly Dictionary<ulong, Region> _regions = new();

        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();
        }
    }
}