Wie bekomme ich die Breitengrad und Längengrad von x, y auf einer Mercator-Karte (JPEG)?

Hier ist ein code für Sie... Lassen Sie mich wissen, wenn Sie mehr Erklärung.

    ///<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;
    }

Erich Mirabal Antwort war völlig korrekt (wenn auch nicht ganz vollständig).

Ich habe es gerade getestet mit einem 'theoretischen 256x256 Mercator-Kachel' (Google einzelne Kachel-version der Weltkarte).

Hier ein wenig mehr code (JavaScript, aber einfach zu Folgen) zu verdeutlichen.

Ich Lebe in Australien, bei einer Breite von etwa -33°.

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

152.88327883810192

Wenn Sie damit rechnen, 152 Pixel nach unten von der Spitze der Fliesen, die Sie finden Australien. Ich habe auch verifiziert, dass diese Antwort richtig ist, indem Sie vergleichen Sie das Ergebnis mit dem bekannt guten Funktionen.

Sicher zu sein, können wir Umgekehrt, dass die Berechnung:

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

Und wir sind zurückgekehrt -32.99613291758226.

Der schwierige Teil ist nicht in der Gudermannian Funktion, aber in der Umrechnung zwischen zwei Skalen.

Glücklicherweise als ziemlich faul und hassen diese Art der Skalierung Probleme, ich hatte auch schon eine kleine Funktion zu tun, die chaotisch Umstellung für mich.

    /**
     * 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];
    }

... Und die JavaScript-Versionen der ursprünglichen Funktionen sind natürlich:

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
    );
}

Einen wichtigen Hinweis bei der Durchführung einer inversen ist, dass es keine solche Sache wie "die mercator-Karte", wie es der Fall mit den meisten anderen Kartenprojektionen. Jeder mercator-Karte in Existenz ist unterschiedlich, je nach dem Eingang phi-Wert. Laut wikipedia nutzt google 85.051129, und anderen Karten-Anbietern verwenden 85.05113. Daher ist die Eingabe von Werten zu Gudermannian muss angepasst werden auf z.B. GudermannianInv(85.05113).