Ejemplo n.º 1
0
        /// <summary><para>Die Funktion verschiebt das Datum von <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam</see> (nur Deutschland) nach <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84</see> (international).
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende  mathematische 
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen: 
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        /// 
        /// <param name="geo">Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam-Datum</see></param>
        /// <returns>Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see>.</returns>
        internal Geographic PODWGS(Geographic geo)
        {

            double laengePotsdam = geo.Longitude;
            double breitePotsdam = geo.Latitude;

            // Breite und Länge (Rad)
            double breiteRad = breitePotsdam * (Math.PI / 180);
            double laengeRad = laengePotsdam * (Math.PI / 180);

            // Querkrümmung
            double qkhm = HALBACHSE / Math.Sqrt(1 - EXZENT * Math.Sin(breiteRad) * Math.Sin(breiteRad));

            // Kartesische Koordinaten Potsdam
            double xPotsdam = qkhm * Math.Cos(breiteRad) * Math.Cos(laengeRad);
            double yPotsdam = qkhm * Math.Cos(breiteRad) * Math.Sin(laengeRad);
            double zPotsdam = (1 - EXZENT) * qkhm * Math.Sin(breiteRad);

            // Kartesische Koordinaten WGS84
            double x = xPotsdam + POTSDAM_DATUM_SHIFT_X;
            double y = yPotsdam + POTSDAM_DATUM_SHIFT_Y;
            double z = zPotsdam + POTSDAM_DATUM_SHIFT_Z;

            // Breite und Länge im WGS84 Datum
            double b = Math.Sqrt(x * x + y * y);
            double breite = (180 / Math.PI) * Math.Atan((z / b) / (1 - WGS84_EXZENT));

            double laenge = 0;
            if (x > 0) laenge = (180 / Math.PI) * Math.Atan(y / x);
            if (x < 0 && y > 0) laenge = (180 / Math.PI) * Math.Atan(y / x) + 180;
            if (x < 0 && y < 0) laenge = (180 / Math.PI) * Math.Atan(y / x) - 180;

            return new Geographic(laenge, breite, GeoDatum.WGS84);
        }
Ejemplo n.º 2
0
        public string GetMGRS()
        {
            Geographic geo = new Geographic(Lng, Lat);

            MGRS mgrs = (MGRS)geo;

            return(mgrs.ToString());
        }
Ejemplo n.º 3
0
        private void ConnectionViewModel_Received(object sender, NmeaParser.NmeaMessageReceivedEventArgs e)
        {
            switch (e.Message)
            {
            case Gprmc rmc:
                GpsData.FixInfo = FixString = rmc.Active ? "Fix" : "No Fix";
                if (rmc.Active)
                {
                    GpsData.Lat = rmc.Latitude;
                    LatStr      = $"{rmc.Latitude:0.0000}";

                    GpsData.Lon = rmc.Longitude;
                    LonStr      = $"{rmc.Longitude:0.0000}";

                    var dto = new DateTime(rmc.FixTime.Ticks, DateTimeKind.Utc);

                    GpsData.Time = dto.ToLocalTime();
                    DateStr      = $"{GpsData.Time:dd.MM.yyyy HH:mm:ss}";

                    GpsData.Speed = rmc.Speed * 1.852;

                    SpeedString = $"{GpsData.Speed:0.0} km/h";

                    var latlon = new Geographic(rmc.Longitude, rmc.Latitude);

                    GpsData.UtmRef = UtmrefString = ((MGRS)latlon).ToString();



                    if (TrackMeOnMap)
                    {
                        MapLocation = new MapPointLatLon(rmc.Latitude, rmc.Longitude);
                    }

                    if (SaveTrack)
                    {
                        try
                        {
                            using (var fs = File.AppendText("track.csv"))
                                using (var csv = new CsvWriter(fs, new Configuration()
                                {
                                    Delimiter = ";"
                                }))
                                {
                                    csv.WriteRecord(GpsData);
                                    csv.NextRecord();
                                }
                        }
                        catch (Exception exception)
                        {
                            SaveTrack = false;
                            ConnectionViewModel.StatusText = $"Failed to write track. {exception.Message}";
                        }
                    }
                }
                break;
            }
        }
Ejemplo n.º 4
0
        private void btnLonLatToXY_Click(object sender, EventArgs e)
        {
            // Works
            double lon  = Convert.ToDouble(txtX4.Text);
            double lat  = Convert.ToDouble(txtY4.Text);
            int    zoom = Convert.ToInt32(txtZ4.Text);

            listBox1.Items.Add(Geographic.GetTileNumber(lat, lon, zoom) + ", Geographic.GetTileNumber");
        }
Ejemplo n.º 5
0
        /// <summary><para>Die Funktion wandelt geographische Koordinaten (Länge/Breite) eines <see cref="GeoSystem.Geographic"/>-Objektes
        /// in ein <see cref="GeoUtility.GeoSystem.GaussKrueger">GaussKrueger</see>-Objekt um.
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende mathematische
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen:
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        ///
        /// <param name="geo"><see cref="GeoSystem.Geographic"/>-Objekt (<see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam-Datum</see>)</param>
        /// <returns>Ein <see cref="GeoUtility.GeoSystem.GaussKrueger "/>-Objekt.</returns>
        public static GaussKrueger WGSGK(Geographic geo)
        {
            double laenge = geo.Longitude;
            double breite = geo.Latitude;

            if (breite < MIN_NORD || breite > MAX_NORD || laenge < MIN_OST || laenge > MAX_OST)
            {
                throw new ArgumentException("ERROR_GK_OUT_OF_RANGE");
            }

            // Datum muss eventuell erst nach Potsdam transformiert werden.
            if (geo.Datum == GeoDatum.WGS84)
            {
                geo.SetDatum(GeoDatum.Potsdam);
            }

            // Koeffizienten für Länge Meridianbogen
            double koeff0 = POL * (Math.PI / 180) * (1 - 3 * EXZENT2 / 4 + 45 * EXZENT4 / 64 - 175 * EXZENT6 / 256 + 11025 * EXZENT8 / 16384);
            double koeff2 = POL * (-3 * EXZENT2 / 8 + 15 * EXZENT4 / 32 - 525 * EXZENT6 / 1024 + 2205 * EXZENT8 / 4096);
            double koeff4 = POL * (15 * EXZENT4 / 256 - 105 * EXZENT6 / 1024 + 2205 * EXZENT8 / 16384);
            double koeff6 = POL * (-35 * EXZENT6 / 3072 + 315 * EXZENT8 / 12288);

            // Breite (Rad)
            double breiteRad = breite * Math.PI / 180;

            double tangens1 = Math.Tan(breiteRad);
            double tangens2 = Math.Pow(tangens1, 2);
            double tangens4 = Math.Pow(tangens1, 4);
            double cosinus1 = Math.Cos(breiteRad);
            double cosinus2 = Math.Pow(cosinus1, 2);
            double cosinus3 = Math.Pow(cosinus1, 3);
            double cosinus4 = Math.Pow(cosinus1, 4);
            double cosinus5 = Math.Pow(cosinus1, 5);

            double eta = EXZENT2 * cosinus2;

            // Querkrümmung
            double qkhm = POL / Math.Sqrt(1 + eta);

            // Länge des Meridianbogens
            double lmbog = koeff0 * breite + koeff2 * Math.Sin(2 * breiteRad) + koeff4 * Math.Sin(4 * breiteRad) + koeff6 * Math.Sin(6 * breiteRad);

            // Differenz zum Bezugsmeridian
            int    kfakt    = (int)((laenge + 1.5) / 3);
            int    merid    = kfakt * 3;
            double dlaenge1 = (laenge - merid) * Math.PI / 180;
            double dlaenge2 = Math.Pow(dlaenge1, 2);
            double dlaenge3 = Math.Pow(dlaenge1, 3);
            double dlaenge4 = Math.Pow(dlaenge1, 4);
            double dlaenge5 = Math.Pow(dlaenge1, 5);

            // Hochwert, Rechtswert
            double hoch   = (lmbog + qkhm * cosinus2 * tangens1 * dlaenge2 / 2 + qkhm * cosinus4 * tangens1 * (5 - tangens2 + 9 * eta) * dlaenge4 / 24);
            double rechts = (qkhm * cosinus1 * dlaenge1 + qkhm * cosinus3 * (1 - tangens2 + eta) * dlaenge3 / 6 + qkhm * cosinus5 * (5 - 18 * tangens2 + tangens4) * dlaenge5 / 120 + kfakt * 1e6 + 500000);

            return(new GaussKrueger(rechts, hoch));;
        }
Ejemplo n.º 6
0
        static void Main()
        {
            var input = new Geographic(53.160753042, 4.824761912, 42.8614); // Texel

            Console.WriteLine("Input: " + input);
            var output = Transformer.Etrs2Rdnap(input);

            Console.WriteLine("Output: " + output);
            Console.ReadKey();
        }
Ejemplo n.º 7
0
        /// <summary><para>Die Funktion wandelt geographische Koordinaten (Länge/Breite) eines <see cref="GeoSystem.Geographic"/>-Objektes 
        /// in ein <see cref="GeoUtility.GeoSystem.GaussKrueger">GaussKrueger</see>-Objekt um.
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende mathematische 
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen: 
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        /// 
        /// <param name="geo"><see cref="GeoSystem.Geographic"/>-Objekt (<see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam-Datum</see>)</param>
        /// <returns>Ein <see cref="GeoUtility.GeoSystem.GaussKrueger "/>-Objekt.</returns>
        internal GaussKrueger WGSGK(Geographic geo)
        {

            double laenge = geo.Longitude;
            double breite = geo.Latitude;

            if (breite < MIN_NORD || breite > MAX_NORD || laenge < MIN_OST || laenge > MAX_OST)
            {
                throw new ErrorProvider.GeoException(new ErrorProvider.ErrorMessage("ERROR_GK_OUT_OF_RANGE"));
            }

            // Datum muss eventuell erst nach Potsdam transformiert werden.
            if (geo.Datum == GeoDatum.WGS84) geo.SetDatum(GeoDatum.Potsdam);

            // Koeffizienten für Länge Meridianbogen
            double koeff0 = POL * (Math.PI / 180) * (1 - 3 * EXZENT2 / 4 + 45 * EXZENT4 / 64 - 175 * EXZENT6 / 256 + 11025 * EXZENT8 / 16384);
            double koeff2 = POL * (-3 * EXZENT2 / 8 + 15 * EXZENT4 / 32 - 525 * EXZENT6 / 1024 + 2205 * EXZENT8 / 4096);
            double koeff4 = POL * (15 * EXZENT4 / 256 - 105 * EXZENT6 / 1024 + 2205 * EXZENT8 / 16384);
            double koeff6 = POL * (-35 * EXZENT6 / 3072 + 315 * EXZENT8 / 12288);

            // Breite (Rad)
            double breiteRad = breite * Math.PI / 180;

            double tangens1 = Math.Tan(breiteRad);
            double tangens2 = Math.Pow(tangens1, 2);
            double tangens4 = Math.Pow(tangens1, 4);
            double cosinus1 = Math.Cos(breiteRad);
            double cosinus2 = Math.Pow(cosinus1, 2);
            double cosinus3 = Math.Pow(cosinus1, 3);
            double cosinus4 = Math.Pow(cosinus1, 4);
            double cosinus5 = Math.Pow(cosinus1, 5);

            double eta = EXZENT2 * cosinus2;

            // Querkrümmung
            double qkhm = POL / Math.Sqrt(1 + eta);

            // Länge des Meridianbogens
            double lmbog = koeff0 * breite + koeff2 * Math.Sin(2 * breiteRad) + koeff4 * Math.Sin(4 * breiteRad) + koeff6 * Math.Sin(6 * breiteRad);

            // Differenz zum Bezugsmeridian
            int kfakt = (int)((laenge + 1.5) / 3);
            int merid = kfakt * 3;
            double dlaenge1 = (laenge - merid) * Math.PI / 180;
            double dlaenge2 = Math.Pow(dlaenge1, 2);
            double dlaenge3 = Math.Pow(dlaenge1, 3);
            double dlaenge4 = Math.Pow(dlaenge1, 4);
            double dlaenge5 = Math.Pow(dlaenge1, 5);

            // Hochwert, Rechtswert
            double hoch = (lmbog + qkhm * cosinus2 * tangens1 * dlaenge2 / 2 + qkhm * cosinus4 * tangens1 * (5 - tangens2 + 9 * eta) * dlaenge4 / 24);
            double rechts = (qkhm * cosinus1 * dlaenge1 + qkhm * cosinus3 * (1 - tangens2 + eta) * dlaenge3 / 6 + qkhm * cosinus5 * (5 - 18 * tangens2 + tangens4) * dlaenge5 / 120 + kfakt * 1e6 + 500000);

            return new GaussKrueger(rechts, hoch); ;
        }
Ejemplo n.º 8
0
        /// <summary><para>Die Funktion berechnet den internen Schlüssel für ein Luftbild, welches zu den Geodaten gehört.</para></summary>
        /// <remarks><para>Um nicht für die verschiedenen MapService-Dienste jeweils eigene Funktionen anbieten zu müssen,
        /// werden alle Berechnungen intern mit einem generischen Schlüssel durchgeführt und später gegebenenfalls
        /// in den gewählten MapService-Dienst übersetzt.
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para>
        /// </para></remarks>
        ///
        /// <param name="geo"><see cref="Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see></param>
        /// <param name="zoom">Zoomlevel 1-21</param>
        /// <returns>Interner Schlüssel als <see cref="MapService.Info.MapServiceInternalMapTile"/>-Objekt.</returns>
        internal MapService.Info.MapServiceInternalMapTile WGSIMAP(Geographic geo, int zoom)
        {
            double laenge = geo.Longitude;
            double breite = geo.Latitude;

            if (laenge > 180)
            {
                laenge -= 360;
            }
            laenge /= 180;

            // Breitengrad in den Bereich -1 bis +1 bringen
            breite = Math.Log(Math.Tan((Math.PI / 4) + ((0.5 * Math.PI * breite) / 180))) / Math.PI;

            double        tBreite      = -1;
            double        tLaenge      = -1;
            double        laengeWidth  = 2;
            double        breiteHeight = 2;
            StringBuilder key          = new StringBuilder("t");

            // Interner Schlüssel berechnen
            for (int i = 0; i < zoom; i++)
            {
                laengeWidth  /= 2;
                breiteHeight /= 2;
                if ((tBreite + breiteHeight) > breite)
                {
                    if ((tLaenge + laengeWidth) > laenge)
                    {
                        key.Append('t');
                    }
                    else
                    {
                        tLaenge += laengeWidth;
                        key.Append('s');
                    }
                }
                else
                {
                    tBreite += breiteHeight;
                    if ((tLaenge + laengeWidth) > laenge)
                    {
                        key.Append('q');
                    }
                    else
                    {
                        tLaenge += laengeWidth;
                        key.Append('r');
                    }
                }
            }

            return(new MapService.Info.MapServiceInternalMapTile(key.ToString()));
        }
Ejemplo n.º 9
0
        public async override Task <ElevationData> GetDemXYZ(int x, int y, int z)
        {
            lock (_object) // thread safe bitmap lookup contention. Todo use thread safe readonly list
            {
                y = MapUtil.FlipY(y, z);
                // Get the lat lon boundary from xyz tile
                var rect = Geographic.TileXYToRectangleLL(x, y, z);

                // Make the DEM that will be used to make a quantized mesh
                return(MakeTileDEM(rect));
            }
        }
Ejemplo n.º 10
0
        public void ImportGeographic()
        {
            var geo      = new Geographic();
            var response = GetUuids(geo.Data.Count);

            for (var i = 0; i < geo.Data.Count; i++)
            {
                var request = new RestRequest($"authority/{response.uuids[i]}", Method.PUT, DataFormat.Json);
                request.AddJsonBody(new { authoritativeLabel = geo.Data[i][0], archivesspaceUri = geo.Data[i][1] });
                var test = _client.Execute(request).Content;
            }
        }
Ejemplo n.º 11
0
        private void btnConvertToMgrs_Click(object sender, EventArgs e)
        {
            // Geographic geo = new Geographic(8.12345, 50.56789);
            Geographic geo   = new Geographic(9.692965, 8.447336);
            UTM        utm   = (UTM)geo;
            double     east  = utm.East;
            double     north = utm.North;
            int        zone  = utm.Zone;
            string     band  = utm.Band;

            lblLonMgrs.Text = "longitude = " + Convert.ToString(east);
            lblLatMgrs.Text = "lattitude = " + Convert.ToString(north) + " ZONE: " + Convert.ToString(zone) + "BAND : " + band;
        }
Ejemplo n.º 12
0
        /// <summary><para>Die Funktion berechnet den internen Schlüssel für ein Luftbild, welches zu den Geodaten gehört.</para></summary>
        /// <remarks><para>Um nicht für die verschiedenen MapService-Dienste jeweils eigene Funktionen anbieten zu müssen, 
        /// werden alle Berechnungen intern mit einem generischen Schlüssel durchgeführt und später gegebenenfalls 
        /// in den gewählten MapService-Dienst übersetzt. 
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para>
        /// </para></remarks>
        /// 
        /// <param name="geo"><see cref="Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see></param>
        /// <param name="zoom">Zoomlevel 1-21</param>
        /// <returns>Interner Schlüssel als <see cref="MapService.Info.MapServiceInternalMapTile"/>-Objekt.</returns>
        internal MapService.Info.MapServiceInternalMapTile WGSIMAP(Geographic geo, int zoom)
        {
            double laenge = geo.Longitude;
            double breite = geo.Latitude;

            if (laenge > 180) laenge -= 360;
            laenge /= 180;

            // Breitengrad in den Bereich -1 bis +1 bringen
            breite = Math.Log(Math.Tan((Math.PI / 4) + ((0.5 * Math.PI * breite) / 180))) / Math.PI;

            double tBreite = -1;
            double tLaenge = -1;
            double laengeWidth = 2;
            double breiteHeight = 2;
            StringBuilder key = new StringBuilder("t");

            // Interner Schlüssel berechnen 
            for (int i = 0; i < zoom; i++)
            {
                laengeWidth /= 2;
                breiteHeight /= 2;
                if ((tBreite + breiteHeight) > breite)
                {
                    if ((tLaenge + laengeWidth) > laenge)
                    {
                        key.Append('t');
                    }
                    else
                    {
                        tLaenge += laengeWidth;
                        key.Append('s');
                    }
                }
                else
                {
                    tBreite += breiteHeight;
                    if ((tLaenge + laengeWidth) > laenge)
                    {
                        key.Append('q');
                    }
                    else
                    {
                        tLaenge += laengeWidth;
                        key.Append('r');
                    }
                }
            }

            return new MapService.Info.MapServiceInternalMapTile(key.ToString());
        }
Ejemplo n.º 13
0
        /// <summary><para>Ein Konstruktor mit den Parametern für Zone, East und Nordwert, sowie Hemisphäre.</para></summary>
        /// <param name="zone">Zone</param>
        /// <param name="east">East</param>
        /// <param name="north">North</param>
        /// <param name="hem">Hemisphäre: Nord, Süd</param>
        protected Geocentric(int zone, double east, double north, Hemisphere hem)
        {
            string band = "N";                                                      // Transformationsroutine auf Nordhalbkugel setzen 
            if (hem == Hemisphere.South) band = "A";                                // Transformationsroutine auf Südhalbkugel setzen 
            Geographic geo = Transform.UTMWGS(new UTM(zone, band, east, north));
            geo.Longitude = Math.Round(geo.Longitude, 4);                           // Ohne Rundung könnte Bandberechnung fehlerbehaftet sein
            geo.Latitude = Math.Round(geo.Latitude, 4);                             // Ohne Rundung könnte Bandberechnung fehlerbehaftet sein
            UTM utm = Transform.WGSUTM(geo);                                       // Doppelte Transformation um Band zu berechnen

            this.East = east;
            this.North = north;
            this.Zone = zone;
            this.Band = utm.Band;

        }
Ejemplo n.º 14
0
        /// <summary><para>Die Funktion verschiebt das Datum von <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84</see> (international) nach <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam</see> (nur Deutschland).
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende  mathematische
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen:
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        ///
        /// <param name="geo">Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see>.</param>
        /// <returns>Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam-Datum</see>.</returns>
        internal Geographic WGSPOD(Geographic geo)
        {
            double laengeWGS84 = geo.Longitude;
            double breiteWGS84 = geo.Latitude;

            // Breite und Länge (Rad)
            double breiteRad = breiteWGS84 * (Math.PI / 180);
            double laengeRad = laengeWGS84 * (Math.PI / 180);

            // Querkrümmung
            double qkhm = WGS84_HALBACHSE / Math.Sqrt(1 - WGS84_EXZENT * Math.Sin(breiteRad) * Math.Sin(breiteRad));

            // Kartesische Koordinaten WGS84
            double xWGS84 = qkhm * Math.Cos(breiteRad) * Math.Cos(laengeRad);
            double yWGS84 = qkhm * Math.Cos(breiteRad) * Math.Sin(laengeRad);
            double zWGS84 = (1 - WGS84_EXZENT) * qkhm * Math.Sin(breiteRad);

            // Kartesische Koordinaten Potsdam
            double x = xWGS84 - POTSDAM_DATUM_SHIFT_X;
            double y = yWGS84 - POTSDAM_DATUM_SHIFT_Y;
            double z = zWGS84 - POTSDAM_DATUM_SHIFT_Z;

            // Breite und Länge im Potsdam Datum
            double b      = Math.Sqrt(x * x + y * y);
            double breite = (180 / Math.PI) * Math.Atan((z / b) / (1 - EXZENT));

            double laenge = 0;

            if (x > 0)
            {
                laenge = (180 / Math.PI) * Math.Atan(y / x);
            }
            if (x < 0 && y > 0)
            {
                laenge = (180 / Math.PI) * Math.Atan(y / x) + 180;
            }
            if (x < 0 && y < 0)
            {
                laenge = (180 / Math.PI) * Math.Atan(y / x) - 180;
            }

            if (laenge < MIN_OST || laenge > MAX_OST || breite < MIN_NORD || breite > MAX_NORD)
            {
                throw new ErrorProvider.GeoException(new ErrorProvider.ErrorMessage("ERROR_GK_OUT_OF_RANGE"));
            }

            return(new Geographic(laenge, breite, GeoDatum.Potsdam));
        }
Ejemplo n.º 15
0
        private void btnXYZ_Click(object sender, EventArgs e)
        {
            int lon  = Convert.ToInt32(txtX5.Text);
            int lat  = Convert.ToInt32(txtY5.Text);
            int zoom = Convert.ToInt32(txtZ5.Text);
            var bb   = Geographic.TileXYToRectangleLL(lon, lat, zoom);

            ToDisplay(bb.ToDisplay());

            var midPt = bb.GetCenter();

            ToDisplay($"Mo=idPoint XY ({midPt.Longitude} , {midPt.Latitude})");
            var pt = Coord.geo_to_ecef(new Vector3(MapUtil.Deg2Rad(midPt.Longitude), MapUtil.Deg2Rad(midPt.Latitude), 1)); // zero elevation for now

            //var pt = MapUtil.LatLonToEcef(midPt.Latitude, midPt.Longitude, 0); // zero elevation for now

            ToDisplay($"CenterXYZ {pt.X}, {pt.Y}, {pt.Z}");
        }
Ejemplo n.º 16
0
        /// <summary><para>Die Funktion verschiebt das Datum von <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam</see> (nur Deutschland) nach <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84</see> (international).
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende  mathematische
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen:
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        ///
        /// <param name="geo">Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam-Datum</see></param>
        /// <returns>Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see>.</returns>
        internal Geographic PODWGS(Geographic geo)
        {
            double laengePotsdam = geo.Longitude;
            double breitePotsdam = geo.Latitude;

            // Breite und Länge (Rad)
            double breiteRad = breitePotsdam * (Math.PI / 180);
            double laengeRad = laengePotsdam * (Math.PI / 180);

            // Querkrümmung
            double qkhm = HALBACHSE / Math.Sqrt(1 - EXZENT * Math.Sin(breiteRad) * Math.Sin(breiteRad));

            // Kartesische Koordinaten Potsdam
            double xPotsdam = qkhm * Math.Cos(breiteRad) * Math.Cos(laengeRad);
            double yPotsdam = qkhm * Math.Cos(breiteRad) * Math.Sin(laengeRad);
            double zPotsdam = (1 - EXZENT) * qkhm * Math.Sin(breiteRad);

            // Kartesische Koordinaten WGS84
            double x = xPotsdam + POTSDAM_DATUM_SHIFT_X;
            double y = yPotsdam + POTSDAM_DATUM_SHIFT_Y;
            double z = zPotsdam + POTSDAM_DATUM_SHIFT_Z;

            // Breite und Länge im WGS84 Datum
            double b      = Math.Sqrt(x * x + y * y);
            double breite = (180 / Math.PI) * Math.Atan((z / b) / (1 - WGS84_EXZENT));

            double laenge = 0;

            if (x > 0)
            {
                laenge = (180 / Math.PI) * Math.Atan(y / x);
            }
            if (x < 0 && y > 0)
            {
                laenge = (180 / Math.PI) * Math.Atan(y / x) + 180;
            }
            if (x < 0 && y < 0)
            {
                laenge = (180 / Math.PI) * Math.Atan(y / x) - 180;
            }

            return(new Geographic(laenge, breite, GeoDatum.WGS84));
        }
Ejemplo n.º 17
0
        /// <summary><para>Die Funktion verschiebt das Datum von <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84</see> (international) nach <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam</see> (nur Deutschland).
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende  mathematische 
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen: 
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        ///         
        /// <param name="geo">Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see>.</param>
        /// <returns>Ein <see cref="GeoUtility.GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.Potsdam">Potsdam-Datum</see>.</returns>
        internal Geographic WGSPOD(Geographic geo)
        {

            double laengeWGS84 = geo.Longitude;
            double breiteWGS84 = geo.Latitude;

            // Breite und Länge (Rad)
            double breiteRad = breiteWGS84 * (Math.PI / 180);
            double laengeRad = laengeWGS84 * (Math.PI / 180);

            // Querkrümmung
            double qkhm = WGS84_HALBACHSE / Math.Sqrt(1 - WGS84_EXZENT * Math.Sin(breiteRad) * Math.Sin(breiteRad));

            // Kartesische Koordinaten WGS84
            double xWGS84 = qkhm * Math.Cos(breiteRad) * Math.Cos(laengeRad);
            double yWGS84 = qkhm * Math.Cos(breiteRad) * Math.Sin(laengeRad);
            double zWGS84 = (1 - WGS84_EXZENT) * qkhm * Math.Sin(breiteRad);

            // Kartesische Koordinaten Potsdam
            double x = xWGS84 - POTSDAM_DATUM_SHIFT_X;
            double y = yWGS84 - POTSDAM_DATUM_SHIFT_Y;
            double z = zWGS84 - POTSDAM_DATUM_SHIFT_Z;

            // Breite und Länge im Potsdam Datum
            double b = Math.Sqrt(x * x + y * y);
            double breite = (180 / Math.PI) * Math.Atan((z / b) / (1 - EXZENT));

            double laenge = 0;
            if (x > 0) laenge = (180 / Math.PI) * Math.Atan(y / x);
            if (x < 0 && y > 0) laenge = (180 / Math.PI) * Math.Atan(y / x) + 180;
            if (x < 0 && y < 0) laenge = (180 / Math.PI) * Math.Atan(y / x) - 180;

            if (laenge < MIN_OST || laenge > MAX_OST || breite < MIN_NORD || breite > MAX_NORD)
            {
                throw new ErrorProvider.GeoException(new ErrorProvider.ErrorMessage("ERROR_GK_OUT_OF_RANGE"));
            }

            return new Geographic(laenge, breite, GeoDatum.Potsdam);
        }
Ejemplo n.º 18
0
        public string GetMGRS()
        {
            Geographic geo = new Geographic(Lng, Lat);

            MGRS mgrs = (MGRS)geo;

            return mgrs.ToString();
        }
Ejemplo n.º 19
0
        /// <summary><para>Die Funktion wandelt die geographischen Koordinaten eines <see cref="GeoSystem.Geographic"/>-Objekts
        /// in die Koordinaten eines <see cref="GeoSystem.UTM"/>-Objekts um.
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende  mathematische
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen:
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        ///
        /// <param name="geo"><see cref="GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see>.</param>
        /// <returns>Ein <see cref="GeoSystem.UTM"/>-Objekt.</returns>
        internal UTM WGSUTM(Geographic geo)
        {
            // falls geo Objekt nicht im WGS84-Datum
            if (geo.Datum != GeoDatum.WGS84)
            {
                geo = this.PODWGS(geo);
            }

            double laenge = geo.Longitude;
            double breite = geo.Latitude;

            if (laenge <= MIN_LAENGE || laenge > MAX_LAENGE || breite < MIN_BREITE || breite > MAX_BREITE)
            {
                throw new ErrorProvider.GeoException(new ErrorProvider.ErrorMessage("ERROR_GEO2UTM"));
            }

            // Koeffizienten für Länge Meridianbogen
            double koeff0 = WGS84_POL * (Math.PI / 180) * (1 - 3 * WGS84_EXZENT2 / 4 + 45 * WGS84_EXZENT4 / 64 - 175 * WGS84_EXZENT6 / 256 + 11025 * WGS84_EXZENT8 / 16384);
            double koeff2 = WGS84_POL * (-3 * WGS84_EXZENT2 / 8 + 15 * WGS84_EXZENT4 / 32 - 525 * WGS84_EXZENT6 / 1024 + 2205 * WGS84_EXZENT8 / 4096);
            double koeff4 = WGS84_POL * (15 * WGS84_EXZENT4 / 256 - 105 * WGS84_EXZENT6 / 1024 + 2205 * WGS84_EXZENT8 / 16384);
            double koeff6 = WGS84_POL * (-35 * WGS84_EXZENT6 / 3072 + 315 * WGS84_EXZENT8 / 12288);

            // Berechnung Zone, Band
            int zone = (int)((laenge + 180) / 6) + 1;

            // Handling UTM exception
            if ((breite >= 56d) && (breite < 64d) && (laenge >= 3d) && (laenge < 12d))
            {
                // South-Norway 31V-32V (32V extends to the west from 3 to 12 degrees, with degree 9 as meridian)
                zone = 32;
            }
            else if (breite >= 72d)
            {
                // Arctic region exceptions
                if ((laenge >= 0d) && (laenge < 9d))
                {
                    zone = 31;
                }
                else if ((laenge >= 9d) && (laenge < 21d))
                {
                    zone = 33;
                }
                else if ((laenge >= 21d) && (laenge < 33d))
                {
                    zone = 35;
                }
                else if ((laenge >= 33d) && (laenge < 42d))
                {
                    zone = 37;
                }
            }

            string sZone     = string.Format("00", zone);
            int    bandIndex = (int)(1 + (breite + 80) / 8);
            string band      = UTM_BAND.Substring(bandIndex - 1, 1);

            // Geographische Breite (Rad)
            double breiteRad = breite * Math.PI / 180;

            double tangens1 = Math.Tan(breiteRad);
            double tangens2 = Math.Pow(tangens1, 2);
            double tangens4 = Math.Pow(tangens1, 4);
            double cosinus1 = Math.Cos(breiteRad);
            double cosinus2 = Math.Pow(cosinus1, 2);
            double cosinus3 = Math.Pow(cosinus1, 3);
            double cosinus4 = Math.Pow(cosinus1, 4);
            double cosinus5 = Math.Pow(cosinus1, 5);

            double eta = WGS84_EXZENT2 * cosinus2;

            // Querkrümmung
            double qkhm = WGS84_POL / Math.Sqrt(1 + eta);

            // Länge des Meridianbogens
            double lmbog = (koeff0 * breite) + (koeff2 * Math.Sin(2 * breiteRad)) + (koeff4 * Math.Sin(4 * breiteRad)) + (koeff6 * Math.Sin(6 * breiteRad));

            // Differenz zum Bezugsmeridian
            int merid = (zone - 30) * 6 - 3;

            double dlaenge1 = (laenge - merid) * Math.PI / 180;
            double dlaenge2 = Math.Pow(dlaenge1, 2);
            double dlaenge3 = Math.Pow(dlaenge1, 3);
            double dlaenge4 = Math.Pow(dlaenge1, 4);
            double dlaenge5 = Math.Pow(dlaenge1, 5);

            // Berechnung East, North
            double east, north;

            if (breite < 0)
            {
                north = 10E+06 + UTM_FAKTOR * (lmbog + qkhm * cosinus2 * tangens1 * dlaenge2 / 2 + qkhm * cosinus4 * tangens1 * (5 - tangens2 + 9 * eta) * dlaenge4 / 24);
            }
            else
            {
                north = UTM_FAKTOR * (lmbog + qkhm * cosinus2 * tangens1 * dlaenge2 / 2 + qkhm * cosinus4 * tangens1 * (5 - tangens2 + 9 * eta) * dlaenge4 / 24);
            }
            east = UTM_FAKTOR * (qkhm * cosinus1 * dlaenge1 + qkhm * cosinus3 * (1 - tangens2 + eta) * dlaenge3 / 6 + qkhm * cosinus5 * (5 - 18 * tangens2 + tangens4) * dlaenge5 / 120) + UTM_FALSE_EASTING;

            north = Math.Round(north, 3);
            east  = Math.Round(east, 3);

            return(new UTM(zone, band, east, north));
        }
Ejemplo n.º 20
0
 public UTM ConvertToUtm()
 {
     var geo = new Geographic(Longitude, Latitude, GeoDatum.WGS84);
     return (UTM)geo;
 }
Ejemplo n.º 21
0
 public MGRS ConvertToMgrs()
 {
     var geo = new Geographic(Longitude, Latitude, GeoDatum.WGS84);
     return (MGRS)geo;
 }
Ejemplo n.º 22
0
        Operation IParser.Parse(string[] lines)
        {
            Operation         operation = new Operation();
            OperationResource last      = new OperationResource();

            lines = Utilities.Trim(lines);
            CurrentSection   section      = CurrentSection.AHeader;
            bool             keywordsOnly = true;
            NumberFormatInfo nfi          = new NumberFormatInfo {
                NumberDecimalSeparator = "."
            };

            for (int i = 0; i < lines.Length; i++)
            {
                try
                {
                    string line = lines[i];
                    if (line.Length == 0)
                    {
                        continue;
                    }

                    // Try to parse the header and extract date and time if possible
                    operation.Timestamp = ParserUtility.ReadFaxTimestamp(line, operation.Timestamp);



                    if (GetSection(line.Trim(), ref section, ref keywordsOnly))
                    {
                        continue;
                    }

                    string msg    = line;
                    string prefix = "";

                    // Make the keyword check - or not (depends on the section we are in; see above)
                    if (keywordsOnly)
                    {
                        string keyword;
                        if (!ParserUtility.StartsWithKeyword(line, Keywords, out keyword))
                        {
                            continue;
                        }

                        int x = line.IndexOf(':');
                        if (x == -1)
                        {
                            // If there is no colon found (may happen occasionally) then simply remove the length of the keyword from the beginning
                            prefix = keyword;
                            msg    = line.Remove(0, prefix.Length).Trim();
                        }
                        else
                        {
                            prefix = line.Substring(0, x);
                            msg    = line.Substring(x + 1).Trim();
                        }

                        prefix = prefix.Trim().ToUpperInvariant();
                    }

                    // Parse each section
                    switch (section)
                    {
                    case CurrentSection.AHeader:
                    {
                        switch (prefix)
                        {
                        case "ABSENDER":
                            operation.CustomData["Absender"] = msg;
                            break;

                        case "TERMIN":
                            operation.CustomData["Termin"] = msg;
                            break;

                        case "EINSATZN.":
                            operation.OperationNumber = msg;
                            break;
                        }
                    }
                    break;

                    case CurrentSection.BMitteiler:
                    {
                        // This switch would not be necessary in this section (there is only "Name")...
                        switch (prefix)
                        {
                        case "NAME":
                            operation.Messenger = msg;
                            break;
                        }
                    }
                    break;

                    case CurrentSection.CEinsatzort:
                    {
                        switch (prefix)
                        {
                        case "STRAßE":
                        {
                            operation.Einsatzort.Street = msg;
                        }
                        break;

                        case "HAUS-NR.":
                        {
                            operation.Einsatzort.StreetNumber = msg;
                        }
                        break;

                        case "ABSCHNITT":
                        {
                            operation.Einsatzort.Intersection = msg;
                        }
                        break;

                        case "ORTSTEIL":
                        {
                            operation.CustomData["Einsatzort Ortsteil"] = msg;
                        }
                        break;

                        case "ORT":
                        {
                            operation.Einsatzort.ZipCode = ParserUtility.ReadZipCodeFromCity(msg);
                            if (string.IsNullOrWhiteSpace(operation.Einsatzort.ZipCode))
                            {
                                Logger.Instance.LogFormat(LogType.Warning, this, "Could not find a zip code for city '{0}'. Route planning may fail or yield wrong results!", operation.Einsatzort.City);
                            }

                            operation.Einsatzort.City = msg.Remove(0, operation.Einsatzort.ZipCode.Length).Trim();

                            // The City-text often contains a dash after which the administrative city appears multiple times (like "City A - City A City A").
                            // However we can (at least with google maps) omit this information without problems!
                            int dashIndex = operation.Einsatzort.City.IndexOf(" - ");
                            if (dashIndex != -1)
                            {
                                // Ignore everything after the dash
                                operation.Einsatzort.City = operation.Einsatzort.City.Substring(0, dashIndex).Trim();
                            }
                        }
                        break;

                        case "KOORDINATE":

                            Regex r       = new Regex(@"\d+");
                            var   matches = r.Matches(line);
                            if (matches.Count > 2)
                            {
                                int          rechts = Convert.ToInt32(matches[0].Value);
                                int          hoch   = Convert.ToInt32(matches[1].Value);
                                GaussKrueger gauss  = new GaussKrueger(rechts, hoch);
                                Geographic   geo    = (Geographic)gauss;
                                operation.Einsatzort.GeoLatitude  = geo.Latitude;
                                operation.Einsatzort.GeoLongitude = geo.Longitude;
                            }
                            break;

                        case "OBJEKT":
                            operation.Einsatzort.Property = msg;
                            break;

                        case "EINSATZPLAN":
                            operation.OperationPlan = msg;
                            break;

                        case "STATION":
                            operation.CustomData["Einsatzort Station"] = msg;
                            break;

                        case "SCHLAGWORT":
                            operation.Keywords.Keyword = msg;
                            break;

                        case "STICHWORT B":
                            operation.Keywords.B = msg;
                            break;

                        case "STICHWORT T":
                            operation.Keywords.T = msg;
                            break;

                        case "STICHWORT S":
                            operation.Keywords.S = msg;
                            break;

                        case "STICHWORT I":
                            operation.CustomData["Stichwort I"] = msg;
                            break;

                        case "STICHWORT R":
                            operation.Keywords.R = msg;
                            break;
                        }
                    }
                    break;

                    case CurrentSection.FEinsatzmittel:
                    {
                        switch (prefix)
                        {
                        case "NAME":
                            last.FullName = msg.Trim();
                            break;

                        case "AUSSTATTUNG":
                            // Only add to requested equipment if there is some text,
                            // otherwise the whole vehicle is the requested equipment
                            if (!string.IsNullOrWhiteSpace(msg))
                            {
                                last.RequestedEquipment.Add(msg);
                            }
                            // This line will end the construction of this resource. Add it to the list and go to the next.
                            operation.Resources.Add(last);

                            last = new OperationResource();
                            break;
                        }
                    }
                    break;

                    case CurrentSection.GBemerkung:
                    {
                        // Append with newline at the end in case that the message spans more than one line
                        operation.Comment = operation.Comment.AppendLine(msg);
                    }
                    break;

                    case CurrentSection.HFooter:
                        // The footer can be ignored completely.
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Logger.Instance.LogFormat(LogType.Warning, this, "Error while parsing line '{0}'. The error message was: {1}", i, ex.Message);
                }
            }
            return(operation);
        }
Ejemplo n.º 23
0
        public void Execute(params object[] list)
        {
            string addr = (string)list [0];

            if (addr.Substring(0, 5) == "COORD")
            {
                addr = addr.Substring(addr.IndexOf(":") + 1);
                FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** Converting Gauss-Krüger to Latitude/Longitude: " + addr);
                GaussKrueger gauss = new GaussKrueger(int.Parse(addr.Substring(0, addr.IndexOf(" ")).Trim()), int.Parse(addr.Substring(addr.IndexOf(" ") + 1).Trim()));
                MGRS         mgrs  = (MGRS)gauss;
                Geographic   geo   = (Geographic)mgrs;
                double       lon   = geo.Longitude;
                double       lat   = geo.Latitude;

                string key            = "AsSta3yGavJt7O8i-SokTyANtvF1HfBoPK5GdD_xgl4ul6ZBmBB3Ru7gX7pof0_T";
                Uri    geocodeRequest = new Uri(string.Format("http://dev.virtualearth.net/REST/v1/Locations?q={0}&key={1}", addr, key));
                System.Collections.Generic.Dictionary <string, string> Result;
                Result = new System.Collections.Generic.Dictionary <string, string> ();
                System.Net.WebClient WCC = new WebClient();
                Result.Add("lat", (System.Math.Round(lat, 5)).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
                Result.Add("lng", (System.Math.Round(lon, 5)).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
                try {
                    System.Net.ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => {
                        return(true);
                    };
                    System.Net.WebClient WC = new System.Net.WebClient();
                    FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** downloading map...");
                    WC.DownloadFile("http://dev.virtualearth.net/REST/V1/Imagery/Map/AerialWithLabels/" + (lat).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (lon).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "/16?pp=" + (lat).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (lon).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + ";10;&mapSize=600,700&mapLayer=TrafficFlow&key=AsSta3yGavJt7O8i-SokTyANtvF1HfBoPK5GdD_xgl4ul6ZBmBB3Ru7gX7pof0_T", "/tmp/map.jpg");
                    //WC.DownloadFile("https://maps.googleapis.com/maps/api/staticmap?center="+(lat).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat)+","+(lon ).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat)+"&zoom=13&scale=2&size=400x900&maptype=roadmap&format=png&visual_refresh=true&markers=size:big%7Ccolor:red%7Clabel:Einsatzort%7C"+(lat ).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat)+","+(lon ).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat),"/tmp/map.png");
                    string XFile = System.IO.File.ReadAllText("web/" + ((string)list [1]).Replace(" ", "_") + ".xml");
                    XFile = XFile.Replace("<Property name=\"Tag\">MAP</Property>", "<Property name=\"Tag\">MAP</Property>\r\n      <Property name=\"Image\">\r\n        <Binary>" + System.Convert.ToBase64String(System.IO.File.ReadAllBytes("/tmp/map.jpg")) + "</Binary>\r\n</Property>");
                    FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** put map to panel-xml...");
                    System.IO.File.WriteAllText("web/panel.xml", XFile);
                    System.IO.File.WriteAllText("web/" + ((string)list [1]).Replace(" ", "_") + ".xml", XFile);
                } catch (Exception exx) {
                    FeuerwehrCloud.Helper.Logger.WriteLine(exx.ToString());
                }
                RaiseFinish("text", Result);
            }
            else
            {
                FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** Trying to get coordinates from: " + addr);
                try {
                    System.Collections.Generic.Dictionary <string, string> Result;
                                        #if GOOGLE
                    Geocoding.Address[] addresses = GeC.Geocode((string)list[0]).ToArray();
                    Result = new System.Collections.Generic.Dictionary <string, string> ();
                    Result.Add("lat", (addresses [0].Coordinates.Latitude).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
                    Result.Add("lng", (addresses [0].Coordinates.Longitude).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
                    try {
                        System.Net.ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => { return(true); };
                        System.Net.WebClient WC = new System.Net.WebClient();
                        WC.DownloadFile("https://maps.googleapis.com/maps/api/staticmap?center=" + (addresses [0].Coordinates.Latitude).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (addresses [0].Coordinates.Longitude).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "&zoom=13&scale=2&size=400x900&maptype=roadmap&format=png&visual_refresh=true&markers=size:big%7Ccolor:red%7Clabel:Einsatzort%7C" + (addresses [0].Coordinates.Latitude).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (addresses [0].Coordinates.Longitude).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat), "/tmp/map.png");
                        string XFile = System.IO.File.ReadAllText("/FeuerwehrCloud/DEIVA/panel.xml");
                        XFile = XFile.Replace("<Property name=\"Tag\">MAP</Property>", "<Property name=\"Tag\">MAP</Property>\r\n      <Property name=\"Image\">\r\n        <Binary>" + System.Convert.ToBase64String(System.IO.File.ReadAllBytes("/tmp/map.png")) + "</Binary>\r\n</Property>");
                        System.IO.File.WriteAllText("/FeuerwehrCloud/DEIVA/panel.xml", XFile);
                    } catch (Exception ex) {
                        FeuerwehrCloud.Helper.Logger.WriteLine(ex.ToString());
                    }
                    RaiseFinish("text", Result);
                                        #else
                    // StaticMap with Routes!
                    //http://dev.virtualearth.net/REST/v1/Imagery/Map/Road/Routes?mapSize=800,800&wp.0=Sonnenstr.3,Rosenheim;64;1&wp.1=Hoffeldstr.10,Rosenheim;66;2&key=AsSta3yGavJt7O8i-SokTyANtvF1HfBoPK5GdD_xgl4ul6ZBmBB3Ru7gX7pof0_T

                    string key            = "AsSta3yGavJt7O8i-SokTyANtvF1HfBoPK5GdD_xgl4ul6ZBmBB3Ru7gX7pof0_T";
                    Uri    geocodeRequest = new Uri(string.Format("http://dev.virtualearth.net/REST/v1/Locations?q={0}&key={1}", addr, key));
                    Result = new System.Collections.Generic.Dictionary <string, string> ();
                    System.Net.WebClient WCC = new WebClient();
                    try {
                        string str = WCC.DownloadString(geocodeRequest);
                        if (str.IndexOf("\"Point\",\"coordinates\":") > -1)
                        {
                            FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** Address found!");
                            dynamic jsonDe = JsonConvert.DeserializeObject(str);
                            float   lat    = jsonDe.resourceSets [0].resources [0].point.coordinates [0];
                            float   lon    = jsonDe.resourceSets [0].resources [0].point.coordinates [1];
                            Result.Add("lat", (System.Math.Round(lat, 5)).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
                            Result.Add("lng", (System.Math.Round(lon, 5)).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
                            try {
                                System.Net.ServicePointManager.ServerCertificateValidationCallback = (a, b, c, d) => {
                                    return(true);
                                };
                                System.Net.WebClient WC = new System.Net.WebClient();
                                FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** downloading map...");
                                //WC.DownloadFile ("http://dev.virtualearth.net/REST/V1/Imagery/Map/Road/" + (lat).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (lon).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "/14?pp=" + (lat).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (lon).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + ";47;!&mapSize=400,700&mapLayer=TrafficFlow&key=AsSta3yGavJt7O8i-SokTyANtvF1HfBoPK5GdD_xgl4ul6ZBmBB3Ru7gX7pof0_T", "/tmp/map.jpg");
                                WC.DownloadFile("http://dev.virtualearth.net/REST/V1/Imagery/Map/AerialWithLabels/" + (lat).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (lon).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "/16?pp=" + (lat).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + "," + (lon).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat) + ";10;&mapSize=500,700&mapLayer=TrafficFlow&key=AsSta3yGavJt7O8i-SokTyANtvF1HfBoPK5GdD_xgl4ul6ZBmBB3Ru7gX7pof0_T", "/tmp/map.jpg");
                                //WC.DownloadFile("https://maps.googleapis.com/maps/api/staticmap?center="+(lat).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat)+","+(lon ).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat)+"&zoom=13&scale=2&size=400x900&maptype=roadmap&format=png&visual_refresh=true&markers=size:big%7Ccolor:red%7Clabel:Einsatzort%7C"+(lat ).ToString(System.Globalization.CultureInfo.InvariantCulture.NumberFormat)+","+(lon ).ToString (System.Globalization.CultureInfo.InvariantCulture.NumberFormat),"/tmp/map.png");
                                string XFile = System.IO.File.ReadAllText("web/panel.xml");
                                XFile = XFile.Replace("<Property name=\"Tag\">MAP</Property>", "<Property name=\"Tag\">MAP</Property>\r\n      <Property name=\"Image\">\r\n        <Binary>" + System.Convert.ToBase64String(System.IO.File.ReadAllBytes("/tmp/map.jpg")) + "</Binary>\r\n</Property>");
                                FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** put map to panel-xml...");
                                System.IO.File.WriteAllText("web/panel.xml", XFile);
                            } catch (Exception exx) {
                                FeuerwehrCloud.Helper.Logger.WriteLine(exx.ToString());
                            }
                            FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** done...!");
                            RaiseFinish("text", Result);
                        }
                        else
                        {
                            FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** Address not found ... :/");
                            FeuerwehrCloud.Helper.Logger.WriteLine(str);
                            // Keine Koordinaten gefunden... :/
                        }
                    } catch (Exception ex) {
                        if (ex.GetType().ToString() == "System.Net.WebException")
                        {
                            if (ex.Message == "NameResolutionFailure")
                            {
                                // PANIC! We don't have internet!!!!
                            }
                        }
                        FeuerwehrCloud.Helper.Logger.WriteLine("|  + [GeoCoder] *** Exception... :/");
                        FeuerwehrCloud.Helper.Logger.WriteLine(FeuerwehrCloud.Helper.Helper.GetExceptionDescription(ex));
                    }
                                        #endif
                } catch (Exception ex) {
                    FeuerwehrCloud.Helper.Logger.WriteLine(FeuerwehrCloud.Helper.Helper.GetExceptionDescription(ex));
                }
            }
        }
        /// <summary><para>Die Funktion wandelt die geographischen Koordinaten eines <see cref="GeoSystem.Geographic"/>-Objekts 
        /// in die Koordinaten eines <see cref="GeoSystem.UTM"/>-Objekts um.
        /// <para>Die Funktion ist nur für interne Berechnungen bestimmt.</para></para></summary>
        /// <remarks><para>
        /// Hintergründe zum Problem der Koordinatentransformationen sowie entsprechende  mathematische 
        /// Formeln können den einschlägigen Fachbüchern oder dem Internet entnommen werden.<p />
        /// Quellen: 
        /// Bundesamt für Kartographie und Geodäsie<br />
        /// <a href="http://www.bkg.bund.de" target="_blank">http://www.bkg.bund.de</a><br />
        /// <a href="http://crs.bkg.bund.de" target="_blank">http://crs.bkg.bund.de</a><br />
        /// </para></remarks>
        /// 
        /// <param name="geo"><see cref="GeoSystem.Geographic"/>-Objekt im <see cref="GeoUtility.GeoSystem.Helper.GeoDatum.WGS84">WGS84-Datum</see>.</param>
        /// <returns>Ein <see cref="GeoSystem.UTM"/>-Objekt.</returns>
        internal UTM WGSUTM(Geographic geo)
        {

            // falls geo Objekt nicht im WGS84-Datum
            if (geo.Datum != GeoDatum.WGS84) geo = this.PODWGS(geo);

            double laenge = geo.Longitude;
            double breite = geo.Latitude;

            if (laenge <= MIN_LAENGE || laenge > MAX_LAENGE || breite < MIN_BREITE || breite > MAX_BREITE)
            {
                throw new ErrorProvider.GeoException(new ErrorProvider.ErrorMessage("ERROR_GEO2UTM"));
            }

            // Koeffizienten für Länge Meridianbogen
            double koeff0 = WGS84_POL * (Math.PI / 180) * (1 - 3 * WGS84_EXZENT2 / 4 + 45 * WGS84_EXZENT4 / 64 - 175 * WGS84_EXZENT6 / 256 + 11025 * WGS84_EXZENT8 / 16384);
            double koeff2 = WGS84_POL * (-3 * WGS84_EXZENT2 / 8 + 15 * WGS84_EXZENT4 / 32 - 525 * WGS84_EXZENT6 / 1024 + 2205 * WGS84_EXZENT8 / 4096);
            double koeff4 = WGS84_POL * (15 * WGS84_EXZENT4 / 256 - 105 * WGS84_EXZENT6 / 1024 + 2205 * WGS84_EXZENT8 / 16384);
            double koeff6 = WGS84_POL * (-35 * WGS84_EXZENT6 / 3072 + 315 * WGS84_EXZENT8 / 12288);

            // Berechnung Zone, Band
            int zone = (int)((laenge + 180) / 6) + 1;
            // Handling UTM exception 
            if ((breite >= 56d) && (breite < 64d) && (laenge >= 3d) && (laenge < 12d)) 
            {
                // South-Norway 31V-32V (32V extends to the west from 3 to 12 degrees, with degree 9 as meridian)
                zone = 32;

            }
            else if (breite >= 72d) 
            {
                // Arctic region exceptions
                if ((laenge >= 0d) && (laenge < 9d)) zone = 31;
                else if ((laenge >= 9d) && (laenge < 21d)) zone = 33;
                else if ((laenge >= 21d) && (laenge < 33d)) zone = 35;
                else if ((laenge >= 33d) && (laenge < 42d)) zone = 37;
            }

            string sZone = string.Format("00", zone);
            int bandIndex = (int)(1 + (breite + 80) / 8);
            string band = UTM_BAND.Substring(bandIndex - 1, 1);

            // Geographische Breite (Rad)
            double breiteRad = breite * Math.PI / 180;

            double tangens1 = Math.Tan(breiteRad);
            double tangens2 = Math.Pow(tangens1, 2);
            double tangens4 = Math.Pow(tangens1, 4);
            double cosinus1 = Math.Cos(breiteRad);
            double cosinus2 = Math.Pow(cosinus1, 2);
            double cosinus3 = Math.Pow(cosinus1, 3);
            double cosinus4 = Math.Pow(cosinus1, 4);
            double cosinus5 = Math.Pow(cosinus1, 5);

            double eta = WGS84_EXZENT2 * cosinus2;

            // Querkrümmung
            double qkhm = WGS84_POL / Math.Sqrt(1 + eta);

            // Länge des Meridianbogens
            double lmbog = (koeff0 * breite) + (koeff2 * Math.Sin(2 * breiteRad)) + (koeff4 * Math.Sin(4 * breiteRad)) + (koeff6 * Math.Sin(6 * breiteRad));

            // Differenz zum Bezugsmeridian
            int merid = (zone - 30) * 6 - 3;

            double dlaenge1 = (laenge - merid) * Math.PI / 180;
            double dlaenge2 = Math.Pow(dlaenge1, 2);
            double dlaenge3 = Math.Pow(dlaenge1, 3);
            double dlaenge4 = Math.Pow(dlaenge1, 4);
            double dlaenge5 = Math.Pow(dlaenge1, 5);

            // Berechnung East, North
            double east, north;
            if (breite < 0)
            {
                north = 10E+06 + UTM_FAKTOR * (lmbog + qkhm * cosinus2 * tangens1 * dlaenge2 / 2 + qkhm * cosinus4 * tangens1 * (5 - tangens2 + 9 * eta) * dlaenge4 / 24);
            }
            else
            {
                north = UTM_FAKTOR * (lmbog + qkhm * cosinus2 * tangens1 * dlaenge2 / 2 + qkhm * cosinus4 * tangens1 * (5 - tangens2 + 9 * eta) * dlaenge4 / 24);
            }
            east = UTM_FAKTOR * (qkhm * cosinus1 * dlaenge1 + qkhm * cosinus3 * (1 - tangens2 + eta) * dlaenge3 / 6 + qkhm * cosinus5 * (5 - 18 * tangens2 + tangens4) * dlaenge5 / 120) + UTM_FALSE_EASTING;

            north = Math.Round(north, 3);
            east = Math.Round(east, 3);

            return new UTM(zone, band, east, north);
        }