So berechnen Sie den Abstand von einem Punkt auf eine Strecke, auf einer Kugel?

Hier ist meine eigene Lösung, basierend auf der Idee, in ask Dr. Math. Ich würde mich freuen, zu sehen, dass Ihr feedback.

Disclaimer zuerst. Diese Lösung ist die richtige für Kugeln. Die Erde ist keine Kugel und die Koordinaten-system (WGS-84) nicht davon ausgehen, es ist eine Sphäre. Dies ist also nur eine Annäherung, und ich kann nicht wirklich einschätzen error. Auch bei sehr kleinen Entfernungen ist es wahrscheinlich auch möglich, sich mit guter Näherung durch die Annahme, alles ist nur eine koplanare. Wieder weiß ich nicht, wie "klein" die Abstände zu sein haben.

Nun zum Geschäft. Ich rufe den enden der Linien A,B und der Dritte Punkt C. im Grunde, der Algorithmus ist:

1. konvertieren die ersten Koordinaten zu kartesischen Koordinaten mit dem Ursprung im Mittelpunkt der Erde) - z.B. hier.

2. Berechnen Sie T, der Punkt auf der Linie AB, die am nächsten ist, um C, mit den folgenden 3 Vektor-Produkte:

   G = A x B

   F = C x G

   T = G x F

3. Normalisieren T und multipliziert mit dem radius der Erde.

4. Konvertieren T-back Länge\Breite.
5. Berechnen Sie die Entfernung zwischen T-und C - z.B. hier.

Diese Schritte sind genug, wenn Sie sind auf der Suche für den Abstand zwischen C und der große Kreis, definiert durch A und B. Wenn, wie mir, Sie sind daran interessiert, den Abstand zwischen C und der kürzeren Strecke, die Sie benötigen, um den zusätzlichen Schritt der Feststellung, dass T in der Tat auf dieses segment. Wenn nicht, dann unbedingt der nächste Punkt ist, eines der enden A oder B - der einfachste Weg ist es, zu überprüfen, welche.

Im Allgemeinen, ist die Idee hinter den drei Vektor-Produkte ist die folgende. Der erste (G) gibt uns das Flugzeug des großen Kreises von A und B (also die Ebene mit A,B und den Ursprung). Der zweite (F) gibt uns der große Kreis geht durch C und steht senkrecht auf G. Dann ist T ist der Schnittpunkt der großkreise definiert durch F und G, gebracht, um die richtige Länge durch Normalisierung und Multiplikation von R.

Hier teilweise Java-code, es zu tun.

Finden der nächstgelegenen Punkt des großen Kreises. Die Eingänge und der Ausgang sind Länge-2 arrays. Die intermediate-arrays der Länge 3.

double[] nearestPointGreatCircle(double[] a, double[] b, double c[])
{
    double[] a_ = toCartsian(a);
    double[] b_ = toCartsian(b);
    double[] c_ = toCartsian(c);

    double[] G = vectorProduct(a_, b_);
    double[] F = vectorProduct(c_, G);
    double[] t = vectorProduct(G, F);
    normalize(t);
    multiplyByScalar(t, R_EARTH);
    return fromCartsian(t);
}

Finden der nächstgelegenen Punkt auf dem segment:

double[] nearestPointSegment (double[] a, double[] b, double[] c)
{
   double[] t= nearestPointGreatCircle(a,b,c);
   if (onSegment(a,b,t))
     return t;
   return (distance(a,c) < distance(b,c)) ? a : c;
} 

Dies ist eine einfache Methode der Prüfung, ob der Punkt T, von denen wir wissen, auf demselben großen Kreis als A und B, ist auf das kürzere segment dieses großen Kreis. Allerdings gibt es effizientere Methoden, es zu tun:

   boolean onSegment (double[] a, double[] b, double[] t)
   {
     //should be   return distance(a,t)+distance(b,t)==distance(a,b), 
     //but due to rounding errors, we use: 
     return Math.abs(distance(a,b)-distance(a,t)-distance(b,t)) < PRECISION;
   }    

InformationsquelleAutor daphshez

Dies ist der vollständige code für die akzeptierte Antwort, als ideone Geige (gefunden hier):

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{



    private static final double _eQuatorialEarthRadius = 6378.1370D;
    private static final double _d2r = (Math.PI /180D);
    private static double PRECISION = 0.1;





    //Haversine Algorithm
    //source: http://stackoverflow.com/questions/365826/calculate-distance-between-2-gps-coordinates

    private static double HaversineInM(double lat1, double long1, double lat2, double long2) {
        return  (1000D * HaversineInKM(lat1, long1, lat2, long2));
    }

    private static double HaversineInKM(double lat1, double long1, double lat2, double long2) {
        double dlong = (long2 - long1) * _d2r;
        double dlat = (lat2 - lat1) * _d2r;
        double a = Math.pow(Math.sin(dlat /2D), 2D) + Math.cos(lat1 * _d2r) * Math.cos(lat2 * _d2r)
                * Math.pow(Math.sin(dlong /2D), 2D);
        double c = 2D * Math.atan2(Math.sqrt(a), Math.sqrt(1D - a));
        double d = _eQuatorialEarthRadius * c;
        return d;
    }

    //Distance between a point and a line

    public static void pointLineDistanceTest() {

        //line
        //double [] a = {50.174315,19.054743};
        //double [] b = {50.176019,19.065042};
        double [] a = {52.00118, 17.53933};
        double [] b = {52.00278, 17.54008};

        //point
        //double [] c = {50.184373,19.054657};
        double [] c = {52.008308, 17.542927};
        double[] nearestNode = nearestPointGreatCircle(a, b, c);
        System.out.println("nearest node: " + Double.toString(nearestNode[0]) + "," + Double.toString(nearestNode[1]));
        double result =  HaversineInM(c[0], c[1], nearestNode[0], nearestNode[1]);
        System.out.println("result: " + Double.toString(result));
    }

    //source: http://stackoverflow.com/questions/1299567/how-to-calculate-distance-from-a-point-to-a-line-segment-on-a-sphere
    private static double[] nearestPointGreatCircle(double[] a, double[] b, double c[])
    {
        double[] a_ = toCartsian(a);
        double[] b_ = toCartsian(b);
        double[] c_ = toCartsian(c);

        double[] G = vectorProduct(a_, b_);
        double[] F = vectorProduct(c_, G);
        double[] t = vectorProduct(G, F);

        return fromCartsian(multiplyByScalar(normalize(t), _eQuatorialEarthRadius));
    }

    @SuppressWarnings("unused")
    private static double[] nearestPointSegment (double[] a, double[] b, double[] c)
    {
       double[] t= nearestPointGreatCircle(a,b,c);
       if (onSegment(a,b,t))
         return t;
       return (HaversineInKM(a[0], a[1], c[0], c[1]) < HaversineInKM(b[0], b[1], c[0], c[1])) ? a : b;
    }

     private static boolean onSegment (double[] a, double[] b, double[] t)
       {
         //should be   return distance(a,t)+distance(b,t)==distance(a,b), 
         //but due to rounding errors, we use: 
         return Math.abs(HaversineInKM(a[0], a[1], b[0], b[1])-HaversineInKM(a[0], a[1], t[0], t[1])-HaversineInKM(b[0], b[1], t[0], t[1])) < PRECISION;
       }


    //source: http://stackoverflow.com/questions/1185408/converting-from-longitude-latitude-to-cartesian-coordinates
    private static double[] toCartsian(double[] coord) {
        double[] result = new double[3];
        result[0] = _eQuatorialEarthRadius * Math.cos(Math.toRadians(coord[0])) * Math.cos(Math.toRadians(coord[1]));
        result[1] = _eQuatorialEarthRadius * Math.cos(Math.toRadians(coord[0])) * Math.sin(Math.toRadians(coord[1]));
        result[2] = _eQuatorialEarthRadius * Math.sin(Math.toRadians(coord[0]));
        return result;
    }

    private static double[] fromCartsian(double[] coord){
        double[] result = new double[2];
        result[0] = Math.toDegrees(Math.asin(coord[2] /_eQuatorialEarthRadius));
        result[1] = Math.toDegrees(Math.atan2(coord[1], coord[0]));

        return result;
    }


    //Basic functions
    private static double[] vectorProduct (double[] a, double[] b){
        double[] result = new double[3];
        result[0] = a[1] * b[2] - a[2] * b[1];
        result[1] = a[2] * b[0] - a[0] * b[2];
        result[2] = a[0] * b[1] - a[1] * b[0];

        return result;
    }

    private static double[] normalize(double[] t) {
        double length = Math.sqrt((t[0] * t[0]) + (t[1] * t[1]) + (t[2] * t[2]));
        double[] result = new double[3];
        result[0] = t[0]/length;
        result[1] = t[1]/length;
        result[2] = t[2]/length;
        return result;
    }

    private static double[] multiplyByScalar(double[] normalize, double k) {
        double[] result = new double[3];
        result[0] = normalize[0]*k;
        result[1] = normalize[1]*k;
        result[2] = normalize[2]*k;
        return result;
    }

     public static void main(String []args){
        System.out.println("Hello World");
        Ideone.pointLineDistanceTest();

     }



}

Es funktioniert gut für kommentierte Daten:

//line
double [] a = {50.174315,19.054743};
double [] b = {50.176019,19.065042};
//point
double [] c = {50.184373,19.054657};

Nächste Knoten ist: 50.17493121381319,19.05846668493702

Aber ich habe ein problem mit diesen Daten:

double [] a = {52.00118, 17.53933};
double [] b = {52.00278, 17.54008};
//point
double [] c = {52.008308, 17.542927};

Nächste Knoten ist: 52.00834987257176,17.542691313436357 falsch ist.

Ich denke, dass die Linie durch zwei Punkte ist nicht ein abgeschlossener Bereich.

InformationsquelleAutor loleksy

Für Entfernung bis zu ein paar tausend Meter würde ich vereinfachen das Problem aus der Sphäre in die Ebene.
Dann, die Frage ist ziemlich einfach, wie eine einfache Dreieck-Berechnung verwendet werden können:

Wir haben die Punkte A und B anzusehen und den Abstand X zu der Linie AB. Dann:

Location a;
Location b;
Location x;

double ax = a.distanceTo(x);
double alfa = (Math.abs(a.bearingTo(b) - a.bearingTo(x))) /180
            * Math.PI;
double distance = Math.sin(alfa) * ax;

InformationsquelleAutor Martin Koubek

Ich bin im Grunde auf der Suche für die gleiche Sache, gerade jetzt, außer, dass ich streng genommen kümmern sich nicht darum, dass ein segment des großen Kreises, sondern wollen einfach nur die Entfernung zu einem beliebigen Punkt auf dem Kreis.

Beiden links bin ich derzeit:

Auf dieser Seite erwähnt, "Cross track distance", die im Grunde das zu sein scheint was du suchst.

Auch in dem folgenden thread auf der PostGIS-mailing-Liste, wird der Versuch scheint zu (1) bestimmen Sie den nächstgelegenen Punkt auf dem Großkreis mit der gleichen Formel wie bei der line-Abstand auf eine 2D-Ebene (mit PostGIS' line_locate_point), und dann (2) Berechnung der Entfernung zwischen diesem und der Dritte Punkt auf einem Sphäroid. Ich habe keine Ahnung, ob das mathematisch in Schritt (1) ist richtig, aber ich würde überrascht sein.

http://postgis.refractions.net/pipermail/postgis-users/2009-July/023903.html

Endlich, ich habe gerade gesehen, dass die mit einem Link unter "Verwandte":

Abstand von Punkt Zu Linie große Kreis-Funktion nicht richtig arbeitet.

InformationsquelleAutor