Beispiel #1
0
        internal void Export()
        {
            Debug.Log("Beginning export");
            mapping = new RoadMapping(4.5);
            var osm = new OSM();

            osm.version = 0.6M;
            osm.meta    = new osmMeta {
                osm_base = DateTime.Now
            };
            osm.generator = "Cities Skylines Magic Mapper Mod";
            osm.note      = Singleton <SimulationManager> .instance.m_metaData.m_CityName;
            osm.bounds    = new osmBounds {
                minlon = 35.753054M, minlat = 34.360353M, maxlon = 35.949310M, maxlat = 34.522050M
            };
            var nm = Singleton <NetManager> .instance;

            mapping.InitBoundingBox(osm.bounds, 1);

            nodeCount = 128000;
            wayCount  = 128000;

            AddNodesAndWays();
            AddBuildings();
            AddDistricts();
            AddCity();
            AddCountours();
            AddRoutes();

            mapping.printDebug();

            osm.node = FilterUnusedNodes();
            osm.way  = ways.ToArray();

            var serializer = new XmlSerializer(typeof(OSM));
            var ms         = new StreamWriter(Singleton <SimulationManager> .instance.m_metaData.m_CityName + ".osm");

            serializer.Serialize(ms, osm);
            ms.Close();
        }
Beispiel #2
0
        private void Init(OSM osm, double scale)
        {
            mapping.InitBoundingBox(osm.bounds, scale);

            foreach (var node in osm.node)
            {
                if (!nodes.ContainsKey(node.id) && node.lat != 0 && node.lon != 0)
                {
                    Vector2 pos = Vector2.zero;
                    if (mapping.GetPos(node.lon, node.lat, ref pos))
                    {
                        nodes.Add(node.id, pos);
                    }
                }
            }

            foreach (var way in osm.way.OrderBy(c => c.changeset))
            {
                RoadTypes   rt     = RoadTypes.None;
                List <uint> points = null;
                int         layer  = 0;

                if (mapping.Mapped(way, ref points, ref rt, ref layer))
                {
                    Vector2 previousPoint = Vector2.zero;
                    var     currentList   = new List <uint>();
                    for (var i = 0; i < points.Count; i += 1)
                    {
                        var pp = points[i];
                        if (nodes.ContainsKey(pp))
                        {
                            currentList.Add(pp);
                            previousPoint = nodes[pp];
                        }
                        else
                        {
                            if (currentList.Count() > 1 || currentList.Contains(pp))
                            {
                                ways.AddLast(new Way(currentList, rt, layer));
                                currentList = new List <uint>();
                            }
                        }
                    }
                    if (currentList.Count() > 1)
                    {
                        ways.AddLast(new Way(currentList, rt, layer));
                    }
                }
            }

            var intersection = new Dictionary <uint, List <Way> >();

            foreach (var ww in ways)
            {
                foreach (var pp in ww.nodes)
                {
                    if (!intersection.ContainsKey(pp))
                    {
                        intersection.Add(pp, new List <Way>());
                    }
                    intersection[pp].Add(ww);
                }
            }

            var allSplits = new Dictionary <Way, List <int> >();

            foreach (var inter in intersection)
            {
                if (inter.Value.Count > 1)
                {
                    foreach (var way in inter.Value)
                    {
                        if (!allSplits.ContainsKey(way))
                        {
                            allSplits.Add(way, new List <int>());
                        }
                        allSplits[way].Add(way.nodes.IndexOf(inter.Key));
                    }
                }
            }

            foreach (var waySplits in allSplits)
            {
                SplitWay(waySplits.Key, waySplits.Value);
            }

            BreakWaysWhichAreTooLong();
            SimplifyWays();
        }