Comment puis-je obtenir la latitude, la longitude à partir de x, y sur une carte de Mercator (JPEG)?

Voici un code pour vous... Laissez-moi savoir si vous avez besoin de plus d'explication.

    ///<summary>
    ///Calculates the Y-value (inverse Gudermannian function) for a latitude. 
    ///<para><see cref="http://en.wikipedia.org/wiki/Gudermannian_function"/></para>
    ///</summary>
    ///<param name="latitude">The latitude in degrees to use for calculating the Y-value.</param>
    ///<returns>The Y-value for the given latitude.</returns>
    public static double GudermannianInv(double latitude)
    {
        double sign = Math.Sign(latitude);
        double sin = Math.Sin(latitude * RADIANS_PER_DEGREE * sign);
        return sign * (Math.Log((1.0 + sin) /(1.0 - sin)) /2.0);
    }

    ///<summary>
    ///Returns the Latitude in degrees for a given Y.
    ///</summary>
    ///<param name="y">Y is in the range of +PI to -PI.</param>
    ///<returns>Latitude in degrees.</returns>
    public static double Gudermannian(double y)
    {
        return Math.Atan(Math.Sinh(y)) * DEGREES_PER_RADIAN;
    }

OriginalL'auteur Erich Mirabal

Erich Mirabal réponse était tout à fait correct (si pas complètement terminée).

Je viens de tester à l'aide d'un "théorique 256x256 Mercator tuile' (Google tuile unique version de la carte du monde).

Voici un peu plus de code (JavaScript, mais facile à suivre) afin d'élucider.

J'habite en Australie, à une latitude d'environ -33°.

convertRange(
    GudermannianInv(-33), 
    [Math.PI, - Math.PI], 
    [0, 256]
);

152.88327883810192

Si vous comptez 152 pixels vers le bas à partir du haut de la tuile, vous trouverez l'Australie. J'ai aussi vérifié cette réponse est correcte en comparant le résultat de bonnes fonctions.

Pour être sûr, on peut inverser le calcul:

Gudermannian(
    convertRange(
        152.88, 
        [0, 256], 
        [Math.PI, - Math.PI]
));

Et nous sommes retournés -32.99613291758226.

La partie la plus délicate n'est pas dans la Gudermannian fonction, mais dans la conversion entre les deux échelles.

Heureusement, étant plutôt paresseux, et détestant ce genre de mise à l'échelle des problèmes, j'ai déjà eu un peu de fonction pour le faire désordre de conversion pour moi.

    /**
     * convert number from _n_ of r1[0] .. r1[1] to _n_ of r2[0] .. r2[1]
     * @example `convertRange( 5, [0, 10], [0, 100] ) === 50`
     *
     * @param {number} value
     * @param {array<number>} r1 old range
     * @param {array<number>} r2 new range
     * @returns {number} value adjusted for new range
     */
    function convertRange( value, r1, r2 ) {
        return ( value - r1[0] )
             * ( r2[1] - r2[0] )
             /( r1[1] - r1[0] )
             +   r2[0];
    }

Et le JavaScript les versions de l'origine des fonctions sont naturellement:

function Gudermannian(y) {
    return Math.atan(Math.sinh(y)) * (180 /Math.PI)
}

function GudermannianInv(latitude)
{
    var sign = Math.sign(latitude);
    var sin  = Math.sin(
                          latitude 
                        * (Math.PI /180) 
                        * sign
    );
    return sign * (
        Math.log(
            (1 + sin) /(1 - sin)
        ) /2
    );
}

OriginalL'auteur Orwellophile

Une remarque importante lors de l'exécution d'un inverse est qu'il n'y a pas une telle chose comme "la cartographique mercator" comme c'est le cas avec la plupart des autres projections cartographiques. Chaque cartographique mercator dans l'existence est différente en fonction de l'entrée phi valeur. Selon wikipédia google utilise 85.051129, et d'autres carte des prestataires de 85.05113. Par conséquent, les valeurs d'entrée pour Gudermannian doit être adaptée en fonction sur, par exemple, GudermannianInv(85.05113).

OriginalL'auteur J Tileson