Calculer le relèvement entre deux emplacements (lat, long)

Je suis en train de développer mon propre réalité augmentée moteur.

Des recherches sur internet, j'ai trouvé ce utile tutoriel. Le lisant, je vois que la chose la plus importante est le palier entre l'emplacement de l'utilisateur, l'emplacement du point et du nord.

L'image ci-dessous est à partir de ce tutoriel.

La suite, j'ai écrit un Objective-C méthode pour obtenir bêta:

+ (float) calculateBetaFrom:(CLLocationCoordinate2D)user to:(CLLocationCoordinate2D)destination
{
    double beta = 0;
    double a, b = 0;

    a = destination.latitude - user.latitude;
    b = destination.longitude - user.longitude;

    beta = atan2(a, b) * 180.0 / M_PI;
    if (beta < 0.0)
        beta += 360.0;
    else if (beta > 360.0)
        beta -= 360;

    return beta;
}

Mais, quand je l'ai essayer, ça ne fonctionne pas très bien.

Alors, j'ai vérifié iPhone AR boîte à outils, pour voir comment il fonctionne (j'ai travaillé avec cette boîte à outils, mais il est tellement grand pour moi).

Et, dans ARGeoCoordinate.m il y a une autre mise en œuvre de la façon d'obtenir la bêta:

- (float)angleFromCoordinate:(CLLocationCoordinate2D)first toCoordinate:(CLLocationCoordinate2D)second {

    float longitudinalDifference    = second.longitude - first.longitude;
    float latitudinalDifference     = second.latitude  - first.latitude;
    float possibleAzimuth           = (M_PI * .5f) - atan(latitudinalDifference / longitudinalDifference);

    if (longitudinalDifference > 0) 
        return possibleAzimuth;
    else if (longitudinalDifference < 0) 
        return possibleAzimuth + M_PI;
    else if (latitudinalDifference < 0) 
        return M_PI;

    return 0.0f;
}

Il utilise cette formule:

float possibleAzimuth = (M_PI * .5f) - atan(latitudinalDifference / longitudinalDifference);

Pourquoi (M_PI * .5f) dans cette formule? Je ne comprends pas.

Et continuer à chercher, j'ai trouvé un autre page parler de la façon de calculer la distance et le relèvement de 2 endroits. Dans cette page il y a une autre mise en œuvre:

/**
 * Returns the (initial) bearing from this point to the supplied point, in degrees
 *   see http://williams.best.vwh.net/avform.htm#Crs
 *
 * @param   {LatLon} point: Latitude/longitude of destination point
 * @returns {Number} Initial bearing in degrees from North
 */
LatLon.prototype.bearingTo = function(point) {
  var lat1 = this._lat.toRad(), lat2 = point._lat.toRad();
  var dLon = (point._lon-this._lon).toRad();

  var y = Math.sin(dLon) * Math.cos(lat2);
  var x = Math.cos(lat1)*Math.sin(lat2) -
          Math.sin(lat1)*Math.cos(lat2)*Math.cos(dLon);
  var brng = Math.atan2(y, x);

  return (brng.toDeg()+360) % 360;
}

Lequel est le bon?

source d'informationauteur VansFannel

Calculer portant

//Source
JSONObject source = step.getJSONObject("start_location");
double lat1 = Double.parseDouble(source.getString("lat"));
double lng1 = Double.parseDouble(source.getString("lng"));

//destination
JSONObject destination = step.getJSONObject("end_location");
double lat2 = Double.parseDouble(destination.getString("lat"));
double lng2 = Double.parseDouble(destination.getString("lng"));

double dLon = (lng2-lng1);
double y = Math.sin(dLon) * Math.cos(lat2);
double x = Math.cos(lat1)*Math.sin(lat2) - Math.sin(lat1)*Math.cos(lat2)*Math.cos(dLon);
double brng = Math.toDegrees((Math.atan2(y, x)));
brng = (360 - ((brng + 360) % 360));

Convertir des Degrés en Radians

Radians = Degrees * PI / 180

Convertir des Radians en Degrés

Degrees = Radians * 180 / PI

7

Je sais que cette question est ancienne, mais ici, c'est une solution plus facile:

flotteur de roulement = loc1.bearingTo(loc2);
4

Dans la formule

float possibleAzimuth = (M_PI * .5f) - atan(latitudinalDifference /longitudinalDifference);

le terme (M_PI * .5f) signifie π/2, qui est de 90°. Cela signifie que c'est la même formule que vous avez dit au début, parce que concernant à la figure ci-dessus, il est titulaire d'

β = arctan (a/b) = 90° - arctan(b/a).

De sorte que les deux formules sont similaires si a se réfère à la différence de longitude et b à la différence de latitude. La dernière formule de calcule de nouveau le même à l'aide de la première partie de mon équation.
2

a dans le diagramme est la différence de longitude, b est la différence de latitude, par conséquent, dans la méthode que vous avez écrit, vous avez le mauvais sens.
```
a = destination.latitude - user.latitude; //should be b
b = destination.longitude - user.longitude; //should be a
```
Essayer de changer et de voir ce qui se passe.

Voir Palund de réponse pour les réponses pour le reste de vos questions.

Essayez ceci pour la précision des résultats:

private static double degreeToRadians(double latLong) {
    return (Math.PI * latLong / 180.0);
}

private static double radiansToDegree(double latLong) {
    return (latLong * 180.0 / Math.PI);
}

public static double getBearing() {

//Source
JSONObject source = step.getJSONObject("start_location");
double lat1 = Double.parseDouble(source.getString("lat"));
double lng1 = Double.parseDouble(source.getString("lng"));

//destination
JSONObject destination = step.getJSONObject("end_location");
double lat2 = Double.parseDouble(destination.getString("lat"));
double lng2 = Double.parseDouble(destination.getString("lng"));

    double fLat = degreeToRadians(lat1);
    double fLong = degreeToRadians(lng1);
    double tLat = degreeToRadians(lat2);
    double tLong = degreeToRadians(lng2);

    double dLon = (tLong - fLong);

    double degree = radiansToDegree(Math.atan2(sin(dLon) * cos(tLat),
            cos(fLat) * sin(tLat) - sin(fLat) * cos(tLat) * cos(dLon)));

    if (degree >= 0) {
        return degree;
    } else {
        return 360 + degree;
    }
}

Vous pouvez tester de roulement résultat sur http://www.sunearthtools.com/tools/distance.php .

here is the code for calculating bearing angle between two points(startPoint, endPoint):

public float CalculateBearingAngle(double startLatitude,double startLongitude, double endLatitude, double endLongitude){
    double Phi1 = Math.toRadians(startLatitude);
    double Phi2 = Math.toRadians(endLatitude);
    double DeltaLambda = Math.toRadians(endLongitude - startLongitude);

    double Theta = atan2((sin(DeltaLambda)*cos(Phi2)) , (cos(Phi1)*sin(Phi2) - sin(Phi1)*cos(Phi2)*cos(DeltaLambda)));
    return (float)Math.toDegrees(Theta);
}

call for function:
float angle = CalculateBearingAngle(startLatitude, startLongitude, endLatitude, endLongitude);


import static java.lang.Math.atan2;
import static java.lang.Math.cos;
import static java.lang.Math.sin;

0

Si vous le souhaitez, vous pouvez prendre un coup d'oeil au code utilisé dans mixare réalité augmentée moteur, c'est sur github et il y a une version pour iPhone ainsi: github.com/mixare

Vous devez vous connecter pour publier un commentaire.