Seite 1 von 1
GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 18.07.2013 - 12:15
von HerrP
Hallo,
ich habe folgendes Problem, hoffentlich könnt ihr mir helfen.
Ich habe von zwei Punkten (A und B) jeweils longitude latitude und kann mir somit auch die Distanz (z.B.: > 1Km) zwischen den beiden Punkten ausrechnen.
Jetzt will ich einen Punkt X berechnen der exakt auf der Luftlinie zwischen A und B und z.B.: 1Km entfernt von A liegt.
Wie komme ich auf longitude und latitude von X?
vielen Dank im Voraus,
Herr P.
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 18.07.2013 - 12:59
von HackyJ
Den Abstand zwischen zwei Punkten auf der Erde berechnet man mit der HAVERSINUS Formel.
Engl. Havesine
Siehe Wikipedia
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 18.07.2013 - 14:27
von HerrP
Die Abstände hab ich ja eh schon, aber ich will einen auf die Luftlinie zwischen Zwei gegebenen Punkten.
Gegeben:
Punkt A: longitude latitude
Punkt B: longitude latitude
Distanz zwischen Punkt A und B
Distanz zwischen Punkt A und X -> somit auch Distanz zwischen X und B
Gesucht
Punkt X: longitude latitude
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 18.07.2013 - 19:57
von XPosition
Formel:
Bx = cos(φ2).cos(Δλ)
By = cos(φ2).sin(Δλ)
φm = atan2( sin(φ1) + sin(φ2), √((cos(φ1)+Bx)² + By²) )
λm = λ1 + atan2(By, cos(φ1)+Bx)
JavaScript:
var Bx = Math.cos(lat2) * Math.cos(dLon);
var By = Math.cos(lat2) * Math.sin(dLon);
var lat3 = Math.atan2(Math.sin(lat1)+Math.sin(lat2), Math.sqrt( (Math.cos(lat1)+Bx)*(Math.cos(lat1)+Bx) + By*By ) );
var lon3 = lon1 + Math.atan2(By, Math.cos(lat1) + Bx);
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 18.07.2013 - 21:06
von Hagen.Felix
Je nachdem, wie weit A und B voneinander entfernt sind und wie genau die Umrechnung sein soll (bezogen auf die tatsächliche Erdoberfläche), wäre ggfs. eine etwas aufwändigere Umrechnung in ein metrisches System wie UTM bzw. wieder daraus zurück erforderlich:
Code: Alles auswählen
#include "stdafx.h"
#include <math.h>
const double UTMValueA=6378137.0;
const double UTMValueB=6356752.31425;
const double UTMEccentricity2 = 0.00673949674226;
const double UTMScale = 0.9996;
const double fRadiantFactor=0.01745329251994;
inline double UTMGetMeridianLength(double fPhi)
{
const double UTMAlpha = 6367449.1458258;
const double UTMBeta = -0.0025188279155515;
const double UTMGamma = 2.6435410586161e-006;
const double UTMDelta = -3.4526234201967e-009;
const double UTMEpsilon = 4.8918303238935e-012;
return UTMAlpha*(fPhi + UTMBeta * sin(2.0*fPhi)+UTMGamma*sin(4.0*fPhi)
+ UTMDelta*sin(6.0*fPhi) + UTMEpsilon*sin(8.0*fPhi));
}
char GetZoneNumber(double fLat, double fLon)
{
int zone = (int)((fLon+ 180)/6) + 1;
if( fLat >= 56.0 && fLat < 64.0 && fLon >= 3.0 && fLon < 12.0 )
zone = 32;
// Special zones for Svalbard
if( fLat >= 72.0 && fLat < 84.0 )
{
if(fLon >= 0.0 && fLon < 9.0 ) zone = 31;
else if( fLon >= 9.0 && fLon < 21.0 ) zone = 33;
else if( fLon >= 21.0 && fLon < 33.0 ) zone = 35;
else if( fLon >= 33.0 && fLon < 42.0 ) zone = 37;
}
return zone;
}
void WGS84_to_UTM(double fPhi, double fLambda, double *px, double *py, char *zone)
{
double fCosPhi;
double fTanPhi;
double fTanPhi2, fTanPhi4;
double fEta2;
double fDeltaLength;
double fRadiusN;
double fCosL, fCosL2;
double fMeridian;
double l3coef, l4coef, l5coef, l6coef, l7coef, l8coef;
double x, y;
if(*zone == -1)
*zone = GetZoneNumber(fPhi, fLambda);
fPhi*=fRadiantFactor;
fLambda*=fRadiantFactor;
fCosPhi = cos(fPhi);
fTanPhi = tan(fPhi);
fMeridian= ((*zone*6.0)-183.0)*fRadiantFactor;
fDeltaLength = (fLambda - fMeridian);
fCosL2 = fCosPhi * fDeltaLength;
fEta2 = UTMEccentricity2 * fCosPhi * fCosPhi;
fRadiusN = UTMValueA*UTMValueA/(UTMValueB*sqrt(1+fEta2));
fTanPhi2 = fTanPhi*fTanPhi;
fCosL = fCosPhi * fDeltaLength;
fCosL2 = fCosL*fCosL;
fTanPhi2 = fTanPhi * fTanPhi;
fTanPhi4 = fTanPhi2*fTanPhi2;
l3coef = 1.0 - fTanPhi2 + fEta2;
l4coef = 5.0 - fTanPhi2 + 9 * fEta2 + 4.0 * (fEta2 * fEta2);
l5coef = 5.0 - 18.0 * fTanPhi2 + (fTanPhi4) + 14.0 * fEta2 - 58.0 * fTanPhi2 * fEta2;
l6coef = 61.0 - 58.0 * fTanPhi2 + (fTanPhi4) + 270.0 * fEta2 - 330.0 * fTanPhi2 * fEta2;
l7coef = 61.0 - 479.0 * fTanPhi2 + 179.0 * (fTanPhi4) - (fTanPhi4 * fTanPhi2);
l8coef = 1385.0 - 3111.0 * fTanPhi2 + 543.0 * (fTanPhi4) - (fTanPhi4* fTanPhi2);
// Horner-Schema
y = fRadiusN * fCosL *
(1.0 + fCosL2 *
(l3coef/6.0 + fCosL2 *
(l5coef/120.0 + fCosL2 * l7coef/5040.0)));
x = UTMGetMeridianLength(fPhi) +
fTanPhi*fRadiusN * fCosL2 *
(1.0/2.0 + fCosL2 *
(l4coef/24.0 + fCosL2*
(l6coef/720.0 * fCosL2 * l8coef/40320.0)));
*px = x * UTMScale;
*py = 500000.0 + y*UTMScale;
}
inline double UTMFootpointLatitude(double y)
{
const double UTMAlpha_ = 6367449.14582582;
const double UTMBeta_ = 2.51882658382898e-03;
const double UTMGamma_ = 3.70094903394928e-06;
const double UTMDelta_ = 7.44777026493115e-09;
const double UTMEpsilon_ = 1.70359932232102E-11;
double f = y/UTMAlpha_;
return f+(UTMBeta_ * sin(2.0*f) + UTMGamma_*sin(4.0*f) + UTMDelta_*sin(6.0*f) +
UTMEpsilon_*sin(8.0*f));
}
void UTM_WGS84(double x, double y, double *pfPhi, double *pfLambda, int zone)
{
double fLambda0, fPhiF, fCosF, fEtaF2, fNf, fTf, fTf2, fNfpow;
double x2poly, x3poly, x4poly, x5poly, x6poly, x7poly, x8poly;
double x1frac, x2frac, x3frac, x4frac, x5frac, x6frac, x7frac, x8frac;
double y2, y3, y4, y5, y6, y7, y8;
y -= 500000.0;
y /= UTMScale;
x /= UTMScale;
fLambda0 = (-183 + (zone * 6.0)) * fRadiantFactor;
fPhiF = UTMFootpointLatitude(x);
fCosF = cos(fPhiF);
fEtaF2 = fCosF*fCosF*UTMEccentricity2;
fNf = UTMValueA*UTMValueA/(UTMValueB*sqrt(1+fEtaF2));
fTf = tan(fPhiF);
fTf2 = fTf*fTf;
fNfpow = fNf;
x1frac = 1.0 / (fNfpow * fCosF);
fNfpow *= fNf; // ^2
x2frac = fTf/(2.0*fNfpow);
fNfpow *= fNf; // ^3
x3frac = 1.0/(6.0*fNfpow * fCosF);
fNfpow *= fNf; // ^4
x4frac = fTf/(24.0*fNfpow);
fNfpow *= fNf; // ^5
x5frac = 1.0/(120.0*fNfpow * fCosF);
fNfpow *= fNf; // ^6
x6frac = fTf/(720.0*fNfpow);
fNfpow *= fNf; // ^7
x7frac = 1.0/(5040.0*fNfpow * fCosF);
fNfpow *= fNf; // ^8
x8frac = 1.0/(40320.0*fNfpow * fCosF);
x2poly = -1.0 - fEtaF2;
x3poly = -1.0 - 2 * fTf2 - fEtaF2;
x4poly = 5.0 + 3.0 * fTf2 + 6.0 * fEtaF2 - 6.0 * fTf2 * fEtaF2 - 3.0 * (fEtaF2 * fEtaF2) - 9.0 * fTf2 * (fEtaF2 * fEtaF2);
x5poly = 5.0 + 28.0 * fTf2 + 24.0 * fTf2*fTf2 + 6.0 * fEtaF2 + 8.0 * fTf2 * fEtaF2;
x6poly = -61.0 - 90.0 * fTf2 - 45.0 * fTf2*fTf2 - 107.0 * fEtaF2 + 162.0 * fTf2 * fEtaF2;
x7poly = -61.0 - 662.0 * fTf2 - 1320.0 * fTf2*fTf2 - 720.0 * (fTf2*fTf2 * fTf2);
x8poly = 1385.0 + 3633.0 * fTf2 + 4095.0 * fTf2*fTf2 + 1575 * (fTf2*fTf2 * fTf2);
y2 = y*y;
y3 = y2*y;
y4 = y3*y;
y5 = y4*y;
y6 = y5*y;
y7 = y6*y;
y8 = y7*y;
*pfPhi = fPhiF + x2frac * x2poly * y2 + x4frac * x4poly * y4 + x6frac * x6poly * y6 + x8frac * x8poly * y8;
*pfLambda = fLambda0 + x1frac * y + x3frac * x3poly * y3 + x5frac * x5poly * y5 + x7frac * x7poly * y7;
*pfPhi/=fRadiantFactor;
*pfLambda/=fRadiantFactor;
}
Ergänzung: Wenn A und B nicht im selben UTM-Streifen liegen, sollte der dazu besser geeignetere Punkt in die Zone des anderen gezwungen werden, so dass man sich rechnerisch innerhalb der gleichen Zone bewegt.
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 19.07.2013 - 09:04
von HerrP
Vielen Dank Hagen.Felix und XPosition ich werde beide Ansatz gleich mal Testen.
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 19.07.2013 - 10:05
von Roland
Hallo,
da bin ich aber froh.
Ich dachte schon, da bittet jemand um Feuer und bekommt zwei Flammenwerfer hingehalten ...
Mein Tipp wären
Formeln der sphärischen Trigonometrie gewesen, die man mit dem Taschenrechner - aber lassen wir das.
Grüße Roland
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 19.07.2013 - 10:56
von HerrP
Etwas bin ich eh noch überfordert, aber man muss sich ja auch mal echten Herausforderungen stellen
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 19.07.2013 - 11:23
von Taurus
Roland hat geschrieben:Hallo,
da bin ich aber froh.
Ich dachte schon, da bittet jemand um Feuer und bekommt zwei Flammenwerfer hingehalten ...
Mein Tipp wären Formeln der sphärischen Trigonometrie gewesen, die man mit dem Taschenrechner - aber lassen wir das.
Grüße Roland
Jo Roland!!! Das hab ich mir auch gedacht!!!
@HerrP:
Ich hätte noch eine "quick-&-dirty"-Variante für dein Problem... du musst noch nichtmal Rechnen
Allerdings ist die Genauigkeit eher zweitrangig bei meinem Vorschlag, jedoch erhältst du so schonmal eine sehr gute Näherungslösung.
1. Lade dir Google Earth runter (wenn du es nicht schon hast)...
2. Erstelle zwei Punkte mit deinen Koordinaten (A und B)
3. Ziehe zwischen beiden Punkten eine Linie
4. Zeichne einen Kreis um Punkt A mit einem Radius von 1km.
5. Erstelle einen Punkt X an der Stelle wo sich die Linie (von Punkt 3) und der Kreis (von Punkt 4) sich schneiden.
6. Lies die Koordinaten in Google-Earth mit Rechtsklick auf den Punkt aus
Re: GPS Punkt zwischen zwei GPS Punkten berechnen
Verfasst: 19.07.2013 - 17:47
von Deichgraf
... oder auf dem GPS-Gerät mittels Wegpunktprojektion!
> Richtung in Grad eingeben
> Einheit für Distanz auswählen > Kilometer > Meter usw.
> Distanz eingeben in Meter o.ä.