UTM-Koord. zu GEOGR. Koord. zu GK-Koord. in VB (Geodäsie/Vermessung)

Thomas @, Mainz, Dienstag, 21.12.2010, 14:12 (vor 2736 Tagen)

Hallo alle zusammen,

ich arbeite in einem Vermessungsbüro in Mainz und seitdem wir vom Katasteramt nur noch XML-Dateien mit UTM-Koordinaten erhalten, haben wir ein ziemliches Problem. Normalerweise bereiten wir kleinere Absteckungen in AutoCAD vor. Dadurch, dass die UTM-Strecken alle einen Maßstab haben und AutoCAD diesen nicht beherrscht wird eine leider ziemlich teure Spezialsoftware fällig (GEOgraf + Kivid, etc.). Also habe ich mich daran gemacht ein Tool zu programmieren, welches die XML-Datei in eine einlesbare ASCII-Datei und eine SCRIPT-Datei mit den ganzen Linienverbindungen konvertiert. Soweit klappt auch alles.

Das Problem ist, dass ich die UTM-Koordinaten noch ins GK-System konvertieren muss. Zunächst konvertiere ich die UTM-Koordinaten zu geographischen Koordinaten und diese dann ins Gauß-Krüger-System. Bei letzterer Transformation hapert es noch und ich finde meinen Fehler einfach nicht. Habe ein Beispiel aus meinem Studium genommen. Die Werte für Breitengrad (BB) und Längengrad (LL) gebe ich zum Testen am Anfang der Funktion vor. Hier die Funktion welche ich in VisualBasic 2010 programmiert habe:


 
Public Function GEO2GK(ByVal Geo_Koord As String) As String
        BB = 50.23366911
        LL = 8.458270889
        '-----------------------------------------------------------------------
        'für Bessel-Ellipsoid
        a = 6377397.155
        b = 6356078.963
        'f = 0.0033427731799399793710112964908005
        '-----------------------------------------------------------------------

        g = 111120.619608 * BB - 15988.6383 * Math.Sin(2 * BB / Ro) + 16.73 * Math.Sin(4 * BB / Ro) - 0.0218 * Math.Sin(6 * BB / Ro)
        L0 = CInt((LL + 1.5) / 3)
        l_klein = LL - L0
        lb = l_klein * Math.PI / 180
        t = Math.Tan(BB)
        n2 = 0.0067192188 * Math.Cos(BB) ^ 2
        N = a ^ 2 / (b * (1 + n2) ^ 0.5)
        c = Math.Sin(BB) * l_klein * (1 + Math.Cos(BB) ^ 2 * l_klein ^ 2 / 3 * Ro ^ 2 * (1 + 3 * n2))
        u = Math.Cos(BB) * l_klein / Ro
 
        x = g + (N * Math.Tan(BB) * Math.Cos(BB) ^ 2 * l_klein ^ 2) / 2 * Ro ^ 2 * (1 * (Math.Cos(BB) * l_klein / Ro) ^ 2 * (5 - Math.Tan(BB) ^ 2 + 9 * n2) / 12)
        'x = g + t / 2 * N * Math.Cos(BB) ^ 2 * lb ^ 2 + t / 24 * N * Math.Cos(BB) ^ 4 * (5 - t ^ 2 + 9 * n2 + 4 * n2 ^ 2) * lb ^ 4 + t / 720 * N * Math.Cos(BB) ^ 6 * (61 - 58 * t ^ 2 + t ^ 4 + 270 * n2 - 330 * t ^ 2 * n2) * lb ^ 6 + t / 40320 * N * Math.Cos(BB) ^ 8 * (61 - 479 * t ^ 2 + 179 * t ^ 4 - t ^ 6)

        y = c * u / (1 + n2) ^ 0.5 * (1 + u ^ 2 * ((1 - Math.Tan(BB) ^ 2 + n2) / 6 + u ^ 2 * (5 + Math.Tan(BB) ^ 2 * (Math.Tan(BB) ^ 2 - 18)) / 120))
        'y = N * Math.Cos(BB) * lb + lb ^ 3 / 6 * N * Math.Cos(BB) ^ 3 * (1 - t ^ 2 + n2) + lb ^ 5 / 120 * N * Math.Cos(BB) ^ 5 * (5 - 18 * t ^ 2 + t ^ 4 + 14 * n2 - 58 * t ^ 2 * n2) + lb ^ 7 / 5040 * N * Math.Cos(BB) ^ 7 * (61 - 479 * t ^ 2 + 179 * t ^ 4 - t ^ 6)
        'y = N / Ro * Math.Cos(BB) * l_klein * (1 + Math.Cos(BB) ^ 2 * l_klein ^ 2 / 6 * Ro ^ 2 * (1 - Math.Tan(BB) ^ 2 + n2) + (Math.Cos(BB) * l_klein / Ro) ^ 4 * 5 - 18 * Math.Tan(BB) ^ 2 + Math.Tan(BB) ^ 4 / 120)

        y = L0 * 10 ^ 6 + 500000 + y
 
        GK_Koord = CStr(y) + "/" + CStr(x)
 
        Return GK_Koord
 
    End Function
 

Soll Ergebnisse sind:

G = 5566267,912 (das habe ich auch raus)
x = 5566408,348
y = -38646,286
H = 5566408,348
R = 3461353,714

Hoffe mir kann jemand sagen was ich falsch mache. Im Voraus vielen Dank für Eure Mühen!

Gruß
Tomas

Avatar

GEOGR. Koord. zu GK-Koord. in Java

MichaeL ⌂, Bad Vilbel, Dienstag, 21.12.2010, 15:55 (vor 2736 Tagen) @ Thomas

Hallo Thomas,

Zunächst konvertiere ich die UTM-Koordinaten zu geographischen Koordinaten und diese dann ins Gauß-Krüger-System.

Wie realisierst Du den Ellipoidübergang?

Ich habe mit Deinen Werten mal schnell die Umrechnung in GeoTra durchgeführt. Ich komme hier zumindest auf Deine Soll-Werte. Die Methode zum Umformen sieht so aus:

 
 private Point2D BL2XY(double phi, double dLambda) {
  double a  = this.ellipsoid.getMajorAxis();
  double b  = this.ellipsoid.getMinorAxis();
  double e2 = this.ellipsoid.getE2Square();
 
  // Meridianbogelnlaenge
  double Bphi = this.ellipsoid.getMeridianArcLengthFromLatitude(phi);
 
  double eta2 = e2*Math.cos(phi)*Math.cos(phi);
  double t    = Math.tan(phi);
  double t2   = t*t;
 
  // Normalkruemmungsradius fuer phi
  double N = a*a/(b*Math.sqrt(1.0+eta2));
 
  double x = Bphi + t/2.0*N*Math.pow(Math.cos(phi),2)*Math.pow(dLambda,2) +
             t/   24.0*N*Math.pow(Math.cos(phi),4)*(   5.0 -        t2 + 9.0*eta2+4.0*eta2*eta2)*Math.pow(dLambda,4) +
             t/  720.0*N*Math.pow(Math.cos(phi),6)*(  61.0 -   58.0*t2 + t2*t2 + 270.0*eta2 - 330*t2*eta2)*Math.pow(dLambda,6) +
             t/40320.0*N*Math.pow(Math.cos(phi),8)*(1385.0 - 3111.0*t2 + 543.0*t2*t2 - Math.pow(t,6))*Math.pow(dLambda,8);
 
  double y = N*Math.cos(phi)*dLambda +
             1.0/   6.0*N*Math.pow(Math.cos(phi),3)*( 1.0 -       t2 + eta2)*Math.pow(dLambda,3) +
             1.0/ 120.0*N*Math.pow(Math.cos(phi),5)*( 5.0 -  18.0*t2 + t2*t2 + 14.0*eta2 - 58.0*t2*eta2)*Math.pow(dLambda,5) +
             1.0/5040.0*N*Math.pow(Math.cos(phi),7)*(61.0 - 479.0*t2 + 179.0*t2*t2 - Math.pow(t,6))*Math.pow(dLambda,7);
 
  return new Point2D("BL2XY", x, y);
 }

Kennziffer und die 500.000 sind noch zu berücksichtigen. Die Formeln stammen aus Bernhard Hofmann-Wellenhof, Gerhard Kienast, Herbert Lichtenegger: GPS in der Praxis. Ein Buch, das ich hiermit gleich mal mit empfehlen möchte.

Schöne Grüße
Micha

--
applied-geodesy.org - OpenSource Least-Squares Adjustment Software for Geodetic Sciences

Tags:
Gauß-Krüger, UTM, Java, GeoTra, Koordinaten, Bessel

GEOGR. Koord. zu GK-Koord. in Java

Thomas @, Mainz, Mittwoch, 22.12.2010, 07:41 (vor 2735 Tagen) @ MichaeL

Hallo Michael,
danke für die schnelle Antwort. Also zunächst einmal habe ich die Umrechnung von UTM zu Geographischen Koordinaten nach meinen Formeln aus der Studienzeit berechnet (Schödlbauer).

Hier sind mal 3 Formelblätter:

Geographische Koord. zu Gauss-Krüger
Geographische Koord. zu Gauss-Krüger Alternative
UTM-Koord. zu Geographischen Koordinaten

Da ich mit keiner dieser Formeln 100%ig zufrieden war, habe ich es dann später mit folgendem (an VB angepassten) Quellcode probiert, den ich hier gefunden habe:

 
Public Function UTM2GEO(ByVal UTM_N As Double, ByVal UTM_E As Double, ByVal Zone As Integer) As String
        'für GRS80-Ellipsoid
        a = 6378137
        'b = 6356752.3141
        f = 0.0033528106811935602
        '-----------------------------------------------------------------------
        'für Hayford-Ellipsoid
        'a = 6378388
        'b = 6356911.946
        'f = 0.0033670033670033669
        '-----------------------------------------------------------------------
        'für Bessel-Ellipsoid
        'a = 6377397.155
        'b = 6356078.963
        'f = 0.0033427731799399793710112964908005
        '-----------------------------------------------------------------------
        'für WGS84
        'a = 6378137.
        'f = 0.00335281068
        '-----------------------------------------------------------------------

 
        '  PoUTM_Eümmungshalbmesser c
        c = a / (1 - f)
 
        '  Quadrat der zweiten numerischen Exzentrizität
        ex2 = (2 * f - f * f) / ((1 - f) * (1 - f))
        ex4 = ex2 * ex2
        ex6 = ex4 * ex2
        ex8 = ex4 * ex4
 
        '  Koeffizienten zur Berechnung der geographischen Breite aus gegebener
        '  Meridianbogenlänge
        e0 = c * (Math.PI / 180) * (1 - 3 * ex2 / 4 + 45 * ex4 / 64 - 175 * ex6 / 256 + 11025 * ex8 / 16384)
        f2 = (180 / Math.PI) * (3 * ex2 / 8 - 3 * ex4 / 16 + 213 * ex6 / 2048 - 255 * ex8 / 4096)
        f4 = (180 / Math.PI) * (21 * ex4 / 256 - 21 * ex6 / 256 + 533 * ex8 / 8192)
        f6 = (180 / Math.PI) * (151 * ex6 / 6144 - 453 * ex8 / 12288)
 
 
        '  Geographische Breite bf zur Meridianbogenlänge gf = UTM_N
        Sigma = (UTM_N / 0.9996) / e0
        sigmr = Sigma * Math.PI / 180
        Bf = Sigma + f2 * Math.Sin(2 * sigmr) + f4 * Math.Sin(4 * sigmr) + f6 * Math.Sin(6 * sigmr)
 
        '  Breite bf in Radianten
        br = Bf * Math.PI / 180
        tan1 = Math.Tan(br)
        tan2 = tan1 * tan1
        tan4 = tan2 * tan2
 
        cos1 = Math.Cos(br)
        cos2 = cos1 * cos1
 
        etasq = ex2 * cos2
 
        '  Querkrümmungshalbmesser nd
        nd = c / (1 + etasq) ^ 0.5
        nd2 = nd * nd
        nd4 = nd2 * nd2
        nd6 = nd4 * nd2
        nd3 = nd2 * nd
        nd5 = nd4 * nd
 
        '  Längendifferenz dl zum Bezugsmeridian lh
        Lh = (Val(Mid(Zone, 1, 2)) - 30) * 6 - 3
        dx = (UTM_E - 500000) / 0.9996
        dx2 = dx * dx
        dx4 = dx2 * dx2
        dx3 = dx2 * dx
        dx5 = dx4 * dx
        dx6 = dx3 * dx3
 
        B2 = -tan1 * (1 + etasq) / (2 * nd2)
        B4 = tan1 * (5 + 3 * tan2 + 6 * etasq * (1 - tan2)) / (24 * nd4)
        B6 = -tan1 * (61 + 90 * tan2 + 45 * tan4) / (720 * nd6)
 
        L1 = 1 / (nd * cos1)
        L3 = -(1 + 2 * tan2 + etasq) / (6 * nd3 * cos1)
        L5 = (5 + 28 * tan2 + 24 * tan4) / (120 * nd5 * cos1)
 
        '  Geographischer Breite bb und Länge l als Funktion von Ostwert x und Nordwert y
        BB = Bf + (180 / Math.PI) * (B2 * dx2 + B4 * dx4 + B6 * dx6)
        LL = Lh + (180 / Math.PI) * (L1 * dx + L3 * dx3 + L5 * dx5)
 
        Geo_Koord = CStr(BB) + "/" + CStr(LL)
 
        Return Geo_Koord
 
    End Function
 

Allerdings scheint es hier auch Probleme bei der Berechnung des Längengrades zu geben.

Ich werde später mal versuchen, ob ich mit deinen Formeln zu Potte komme, muss jetzt allerdings in den Außendienst. Vielen Dank für deine Mühe.

Gruss
Thomas

Avatar

GEOGR. Koord. zu GK-Koord. in Java

MichaeL ⌂, Bad Vilbel, Mittwoch, 22.12.2010, 09:25 (vor 2735 Tagen) @ Thomas

Hallo Thomas,

Also zunächst einmal habe ich die Umrechnung von UTM zu Geographischen Koordinaten nach meinen Formeln aus der Studienzeit berechnet (Schödlbauer).

Okay, das wird sicher passen, denke ich. Die Formeln beschreiben aber noch nicht den Übergang von GRS80 nach Bessel.

Quellcode probiert, den ich hier gefunden habe:

Von Michael Brandt vermute ich. Habe ich bisher nicht weiter validiert. Aber das machst Du ja gerade für mich ;-) Mich würde also schon interessieren, welche Probleme DU letztlich hattest und wie die Lösung am Ende aussieht.

Ich habe Dir mal noch VB als Code hinzugefügt. Wenn Du statt [CODE] nun [CODE=vb] nimmst, werden Schlüsselwörter gleich hervorgehoben.

Gruß Micha

--
applied-geodesy.org - OpenSource Least-Squares Adjustment Software for Geodetic Sciences

GEOGR. Koord. zu GK-Koord. in Java

Thomas @, Mainz, Mittwoch, 22.12.2010, 20:00 (vor 2735 Tagen) @ MichaeL

Hallo Michael,

Die Formeln beschreiben aber noch nicht den Übergang von GRS80 nach Bessel.

Damit hast du wohl recht. Allerdings haben wir während des Studiums immer nur mit diesen Formeln gerechnet, weswegen ich dieses Problem gar nicht wahrgenommen habe.

Mich würde also schon interessieren, welche Probleme DU letztlich hattest und wie die Lösung am Ende aussieht.

Dadurch dass du "GeoTra" erwähnt hast, habe ich bei näherem Hinsehen erst realisiert, dass es sich dabei um ein Zusatzmodul für JAG3D handelt, welches ich bereits kannte (nicht jedoch die Möglichkeit damit auch Koordinatenumformungen zu rechnen). Damit ist mein größtes Problem erst mal beseitigt, da ich die von meinem Programm aus der XML-Datei erzeugte UTM-Koordinatendatei jetzt schön mit GeoTra umrechnen kann.

Allerdings will ich diese Funktion dennoch meinem Programm hinzufügen, um nicht immer den Umweg über JAG3D zu gehen.

Mein Problem ist nun anscheinend, dass ich keine passenden Formeln habe, um die Ellipsoidübergänge GRS80 --> WGS84 --> Bessel zu rechnen. Extra wieder teure Fachliteratur werde ich mir wohl nicht anschaffen, es sei denn, der Chef bezahlt. ;-)
Diese Jahr werde ich wohl nicht mehr an meinem Programm weiter arbeiten weil es jetzt zur Familie in den Hunsrück geht und dann erst mal in Urlaub.

Vielen Dank für deine schnelle und kompetente Hilfe. Frohes Fest und guten Rutsch!

Gruss
Thomas

GEOGR. Koord. zu GK-Koord. in Java

Christian @, Mittwoch, 29.12.2010, 22:15 (vor 2728 Tagen) @ Thomas

Mein Problem ist nun anscheinend, dass ich keine passenden Formeln habe, um die Ellipsoidübergänge GRS80 --> WGS84 --> Bessel zu rechnen. Extra wieder teure Fachliteratur werde ich mir wohl nicht anschaffen, es sei denn, der Chef bezahlt. ;-)

Hi Thomas,

vielleicht hilft dir ja das weiter, was ich gefunden hatte.

einen guten Rutsch wünscht Christian

Avatar

GEOGR. Koord. zu GK-Koord. in Java

Tino ⌂, Montag, 03.01.2011, 18:22 (vor 2723 Tagen) @ Christian

Hallo,

was man über Weihnachten nicht so alles macht ;-). Wie es aussieht wurde das Problem bereits gelöst. Ich schaue öfter mal im Geo-Forum vorbei und staune über die langen mathematischen Formeln, die hier und da mühsam hergeleitet werden. Allerdings frage ich mich, warum bei Umrechnungen zwischen Projektionen das Rad ständig neu erfunden wird... denn dafür gibt es schon sehr lange bewährte Bibliotheken, wie z.B. PROJ.4 oder Geotools. Für PROJ.4 gibt es auch einen VB-Wrapper.

Viele Grüße

Tino

Avatar

GEOGR. Koord. zu GK-Koord. in Java

MichaeL ⌂, Bad Vilbel, Freitag, 07.01.2011, 16:45 (vor 2719 Tagen) @ Tino

Hallo Tino,

Ich schaue öfter mal im Geo-Forum vorbei und staune über die langen mathematischen Formeln, die hier und da mühsam hergeleitet werden.

Warum? Das ist doch eine der Daseinsberechtigungen dieses Forums - das Posten von Links zu (fertigen) Lösungen gehört sicher auch dazu.

Allerdings frage ich mich, warum bei Umrechnungen zwischen Projektionen das Rad ständig neu erfunden wird...

Du weiß, dass dies kein Argument sein darf, denn es würde jeglichen Fortschritt engegenstehen. Im JGeodesy ist kürzlich erst wieder ein Artikel über transform geocentric into geodetic coordinates erschienen, auch wenn man sicher bereits im Großmann 1963 hierzu eine entsprechende Lösung findet.

Schöne Grüße
Micha

--
applied-geodesy.org - OpenSource Least-Squares Adjustment Software for Geodetic Sciences

Avatar

GEOGR. Koord. zu GK-Koord. in Java

Tino ⌂, Samstag, 08.01.2011, 16:37 (vor 2718 Tagen) @ MichaeL

Hallo,

Warum? Das ist doch eine der Daseinsberechtigungen dieses Forums - das Posten von Links zu (fertigen) Lösungen gehört sicher auch dazu.

Natürlich. Das habe ich damit auch weder bestritten noch kritisiert. Es sollte nur als eine Art Einleitung dienen und es gibt schließlich auch andere Berechnungen neben dem Umrechenen von Koordinaten.

Du weiß, dass dies kein Argument sein darf, denn es würde jeglichen Fortschritt engegenstehen.

Fortschritt kann doch nur dann entstehen, wenn man auf vorhandene Erfahrungen und vorhandenem Wissen aufbaut. Die Formeln für das Umrechnungen zwischen den verschiedensten Koordinatenreferenzsystemen wurden alle schon tausendfach hergeleitet und in Bibliotheken implementiert. Diese Formeln ändern sich vermutlich sehr selten, wenn z.B. jemand einen besseren Algorithmus gefunden hat. Dann sei Dir aber sicher, dass die implementierenden Bibliotheken diesen aufgreifen werden... und wenn nicht kannst Du ihn z.B. selbst der Bibliothek bereitstellen.
Wenn es die Funktionalität des Umrechnens schon gibt, warum sollte man dann komplett von vorne (Urschleim) anfangen, vor allem wenn man eine schnelle, praktikable Lösung braucht wie z.B. Thomas? Weiterhin haben Bibliotheken wie Proj4 den Vorteil, dass sie in unzähligen Projekten verwendet und dadurch auch getesteten werden und somit fehlerärmer als neu geschriebener Code sind.

Mein Erguss sollte auch eher ein Tipp, als Kritik sein, der vielleicht beim nächsten Umrechnungsproblem schnell Abhilfe schafft.

Viele Grüße

Tino

UTM-Koord. zu GEOGR. Koord. zu GK-Koord. in VB

mad66 @, Dienstag, 25.01.2011, 23:49 (vor 2701 Tagen) @ Thomas

Wieso willst du überhaupt Transformieren? Nur wegen dem Maßstabsfaktor? Wenn sowohl Autocad davon ausgeht, dass der Maßstab 1 ist als auch das Tachymeter dann sind nur die Fehlervektoren vielleicht was größer.
Wie sieht es mit Open Surce Software aus? http://derletztekick.com/software/koordinatenumformung
Hab ich aber auch noch nicht getestet! Falls du positive Erfahrungen sammeln solltest kannst du ja nochmal bescheid sagen.

Gruß Markus

GK-Koordinaten in Länge und Breite umrechnen in C#

Daniel_1983, Samstag, 12.03.2011, 22:31 (vor 2655 Tagen) @ Thomas

Hallo zusammen
ich bin neu und entschuld mich wenn ich noch Fragen stelle die für viele selbstverständlich sind.

Ich benötige ein kleines Programm das mir GK-Koordinaten in Länge und Breite umrechnet.
habe in meinen alten Unterlagen noch ein paar Formeln gefunden und diese auch umgesetzt jedoch komme ich nicht auf die richtige Ergebnisse. Vielleicht kann mir jemand da weiter helfen. Ich bin auch für andere Lösungen offen. es ist schon ein bisschen her als ich damit aktiv zu tun hatte.

Mein Code bis jetzt

private MyPunkt2D berechnung(double x, double y)
        {
            string breite= "";
            string länge= "";
            double roh = 180 / Math.PI;
        // Besselellipsoid
            double halbachse = 6377397.155;     // große Halbachse in Meter
            double f = 1/299.152813;            // Abplattung
            double lh = 9;                  // Hauptmeridian
            double mh = 1;
   // start Berechnungen
        // Vorberechnungen
            double g = x / mh;
            double b = halbachse - (f - halbachse);
            double e2 = (Math.Pow  (halbachse,2) - Math.Pow(b,2)) / (Math.Pow(halbachse,2));
            double e_strich = Math.Sqrt((Math.Pow(halbachse,2) - Math.Pow(b,2)) / (Math.Pow(b,2)));
            double c = Math.Pow(halbachse,2) / b;
 
            double e0 = c * (1 - 3 / 4 * Math.Pow(e_strich, 2) + 45 / 64 * Math.Pow(e_strich, 4) - 175 / 256 * Math.Pow(e_strich, 6) + 11025 / 16384 * Math.Pow(e_strich, 8));
            double f2 = 3 / 8 * Math.Pow(e_strich, 2) - 3 / 16 * Math.Pow(e_strich, 4) + 213 / 2048 * Math.Pow(e_strich, 6);
            double f4 = 21 / 256 * Math.Pow(e_strich, 4) - 21 / 256 * Math.Pow(e_strich, 6);
            double f6 = 151 / 6144 * Math.Pow(e_strich, 6);
 
            double a = g / e0;
            double bf = a + f2 * Math.Sin(2 * a) + f4 * Math.Sin(4 * a) + f6 * Math.Sin(6 * a);
            double tf = Math.Tan(bf);
            double nf2 = Math.Pow(e_strich, 2) * Math.Pow(Math.Cos(bf), 2);
            double rnf = a / (Math.Sqrt(1 - e2 * Math.Pow(Math.Sin(bf), 2)));
 
            double b2 = -(tf*(1+nf2))/(2*Math.Pow(mh,2)*Math.Pow(rnf,2));
            double b4 = (tf * (5 + 3 * Math.Pow(tf, 2) + 6 * nf2 * (1 - Math.Pow(tf, 2)))) / (24 * Math.Pow(mh, 4) * Math.Pow(rnf, 4));
            double b6 = -(tf * (61+ 90 * Math.Pow(tf, 2) + 45* Math.Pow(tf, 4))) / (720 * Math.Pow(mh, 6) * Math.Pow(rnf, 6));
 
            double l1 = 1 / (rnf * mh * Math.Cos(bf));
            double l3 = -(1 + 2 * Math.Pow(tf, 2) + nf2) / (6 * Math.Pow(mh, 3) * Math.Pow(rnf, 3) * Math.Cos(bf));
            double l5 = (5 + 28 * Math.Pow(tf, 2) + 24 * Math.Pow(tf, 4)) / (120 * Math.Pow(mh, 5) * Math.Pow(rnf, 5) * Math.Cos(bf));
 
     // Berechnung länge und Breite
            double breite_dezimal = bf + b2 * Math.Pow(y, 2) + b4 * Math.Pow(y, 4) + b6 * Math.Pow(y, 6);
            double länge_dezimal = lh + l1 * Math.Pow(y, 1) + l3 * Math.Pow(y, 3) + l5 * Math.Pow(y, 5);
 
            int breite_grad = Convert.ToInt16(breite_dezimal);
            int breite_minute = Convert.ToInt16(((breite_dezimal-Convert.ToDouble(breite_grad))*100*0.6));
            int breite_sekunde = Convert.ToInt16(((((breite_dezimal-Convert.ToDouble(breite_grad))*100*0.6)-Convert.ToDouble(breite_minute))*100*0.6));
            breite += Convert.ToString(breite_grad) + "°" + Convert.ToString(breite_minute) + "'" + Convert.ToString(breite_sekunde) + "''";
 
            int länge_grad = Convert.ToInt16(länge_dezimal);
            int länge_minute = Convert.ToInt16(((länge_dezimal - Convert.ToDouble(länge_grad)) * 100 * 0.6));
            int länge_sekunde = Convert.ToInt16(((((länge_dezimal - Convert.ToDouble(länge_grad)) * 100 * 0.6) - Convert.ToDouble(länge_minute)) * 100 * 0.6));
            länge += Convert.ToString(länge_grad) + "°" + Convert.ToString(länge_minute) + "'" + Convert.ToString(länge_sekunde) + "''";
 
            MyPunkt2D punkt_LB = new MyPunkt2D (länge,breite);
            return punkt_LB;

vielen Dank schon mal

Avatar

GK-Koordinaten in Länge und Breite umrechnen in C#

MichaeL ⌂, Bad Vilbel, Sonntag, 13.03.2011, 10:14 (vor 2654 Tagen) @ Daniel_1983

Hallo,

Formeln zum Abprogrammieren liefert Bernhard Hofmann-Wellenhof, Gerhard Kienast, Herbert Lichtenegger: GPS in der Praxis. Diese waren auch Grundlage im Programm GeoTra. Wie Tino aber bereits anmerkte, ist es ggf. einfacher, auf Bibliotheken zurückzugreifen.

Gruß Micha

--
applied-geodesy.org - OpenSource Least-Squares Adjustment Software for Geodetic Sciences

GK-Koordinaten in Länge und Breite umrechnen in C#

Daniel_1983, Mittwoch, 16.03.2011, 21:08 (vor 2651 Tagen) @ MichaeL

Hallo Micha

war die letzten Tage unterwegs. Danke schon mal für deine Hilfe. Weißt du auch zufällig wo ich solche Bibliotheken bekomme? Muss ich die kaufen?

Gruß Dany

Avatar

GK-Koordinaten in Länge und Breite umrechnen in C#

MichaeL ⌂, Bad Vilbel, Donnerstag, 17.03.2011, 10:00 (vor 2650 Tagen) @ Daniel_1983

Hallo Dany,

Weißt du auch zufällig wo ich solche Bibliotheken bekomme?

Ich habe GeoTra geschrieben, weil ich Spaß am Programmieren habe - nicht weil ich Bedarf an der Funktionalität hatte. Der Quellcode liegt offen und kann im Rahmen der GPL eingesehen, modifiziert und in eigenen Applikationen verwendet werden.

Muss ich die kaufen?

Nein, nicht zwingend. Tino hatte ja auf Dienste bzw. Bibliotheken hingewiesen, die ebenfalls OpenSource sind. Unter seiner Aufzählung war nun zwar C# nicht dabei aber es lässt doch vermuten, dass es hier ähnlich gelagerte Projekte gibt.

Gruß Micha

--
applied-geodesy.org - OpenSource Least-Squares Adjustment Software for Geodetic Sciences

Tags:
GK-Koordinaten, geographische Koordinaten

GK-Koordinaten in Länge und Breite umrechnen in C#

Stefan Hahne @, Bonn, Freitag, 01.07.2011, 14:55 (vor 2544 Tagen) @ MichaeL

Bei der Bezirksregierung Köln (Abteilung 7), dem ehemaligen Landesvermessungsamt NRW, gibt es eine DLL (Standard), die alle Transformationssachverhalte beherrscht. Somit auch Datumsübergänge.
Gruß Stefan

RSS-Feed dieser Diskussion