Trasformazione manuale lat / lon ruotata in lat / lon normale?

Per prima cosa dovrei chiarire che non ho precedenti esperienze nel settore, quindi non conosco la terminologia tecnica. La mia domanda è la seguente:

Ho due set di dati meteorologici:

• Il primo ha il sistema di coordinate regolare (non so se abbia un nome specifico), che va da -90 a 90 e da -180 a 180, ei poli sono a latitudini -90 e 90.

• Nel secondo, anche se dovrebbe corrispondere alla stessa regione, ho notato qualcosa di diverso: latitudine e longitudine non erano le stesse, in quanto hanno un altro punto di riferimento (nella descrizione si chiama griglia ruotata ). Insieme alle coppie lat / lon, arrivano le seguenti informazioni: lat polo sud: -35,00, lon polo sud: -15,00, angolo: 0,0.

Ho bisogno di trasformare la seconda coppia di lon / lat nella prima. Potrebbe essere semplice come aggiungere 35 alle latitudini e 15 alle longitudini, poiché l'angolo è 0 e sembra un semplice spostamento, ma non sono sicuro.

Modifica: le informazioni che ho sulle coordinate sono le seguenti

http://rda.ucar.edu/docs/formats/grib/gribdoc/llgrid.html

Apparentemente, il secondo sistema di coordinate è definito da una rotazione generale della sfera

"Una scelta per questi parametri è:

• La latitudine geografica in gradi del polo sud del sistema di coordinate, ad esempio la mappa;

• La longitudine geografica in gradi del polo sud del sistema di coordinate, ad esempio lambdap;

• L'angolo di rotazione in gradi attorno al nuovo asse polare (misurato in senso orario guardando dal polo sud a quello nord) del sistema di coordinate, assumendo che il nuovo asse sia stato ottenuto ruotando prima la sfera attraverso gradi lambdap attorno all'asse polare geografico e quindi ruotando di (90 + thetap) gradi in modo che il polo sud si spostasse lungo il meridiano (precedentemente ruotato) di Greenwich. "

ma ancora non so come convertirlo nel primo.

L'inversione manuale della rotazione dovrebbe fare il trucco; dovrebbe esserci una formula per ruotare i sistemi di coordinate sferiche da qualche parte, ma poiché non riesco a trovarlo, ecco la derivazione ( ' segna il sistema di coordinate ruotato; le normali coordinate geografiche usano simboli semplici):

Per prima cosa converti i dati nel secondo set di dati da sferici (lon ', lat') a (x ', y', z ') usando:

x' = cos(lon')*cos(lat')
y' = sin(lon')*cos(lat')
z' = sin(lat')

Quindi utilizzare due matrici di rotazione per ruotare il secondo sistema di coordinate in modo che coincida con il primo "normale". Ruoteremo gli assi delle coordinate, quindi possiamo usare le matrici di rotazione degli assi . Dobbiamo invertire il segno nella matrice to in modo che corrisponda al senso di rotazione utilizzato nella definizione ECMWF, che sembra essere diverso dalla direzione positiva standard.

Poiché stiamo annullando la rotazione descritta nella definizione del sistema di coordinate, ruotiamo prima di ϑ = - (90 + lat0) = -55 gradi attorno all'asse y (lungo il meridiano di Greenwich ruotato) e quindi di φ = - lon0 = +15 gradi attorno all'asse z):

x   ( cos(φ), sin(φ), 0) (  cos(ϑ), 0, sin(ϑ)) (x')
y = (-sin(φ), cos(φ), 0).(  0     , 1, 0     ).(y')
z   ( 0     , 0     , 1) ( -sin(ϑ), 0, cos(ϑ)) (z')

Espanso, questo diventa:

x = cos(ϑ) cos(φ) x' + sin(φ) y' + sin(ϑ) cos(φ) z'
y = -cos(ϑ) sin(φ) x' + cos(φ) y' - sin(ϑ) sin(φ) z'
z = -sin(ϑ) x' + cos(ϑ) z'

Quindi riconvertire in "normale" (lat, lon) utilizzando

lat = arcsin(z)
lon = atan2(y, x)

Se non hai atan2, puoi implementarlo tu stesso usando atan (y / x) ed esaminando i segni di xey

Assicurati di convertire tutti gli angoli in radianti prima di usare le funzioni trigonometriche, altrimenti otterrai strani risultati; converti nuovamente in gradi alla fine se è quello che preferisci ...

Esempio (coordinate della sfera ruotata ==> coordinate geografiche standard):

• il polo sud del CS ruotato è (lat0, lon0)

  (-90 °, *) ==> (-35 °, -15 °)

• meridiano primo del CS ruotato è il meridiano di -15 ° in geografico (ruotato di 55 ° verso nord)

  (0 °, 0 °) ==> (55 °, -15 °)

• la simmetria richiede che entrambi gli equatori si intersecino a 90 ° / -90 ° nella nuova CS, o 75 ° / -105 ° nelle coordinate geografiche

  (0 °, 90 °) ==> (0 °, 75 °)
  (0 °, -90 °) ==> (0 °, -105 °)

EDIT: riscritto la risposta grazie al commento molto costruttivo di whuber: le matrici e l'espansione sono ora sincronizzate, usando segni adeguati per i parametri di rotazione; aggiunto riferimento alla definizione delle matrici; rimosso atan (y / x) dalla risposta; aggiunti esempi di conversione.

EDIT 2: È possibile derivare espressioni per lo stesso risultato senza esplicita trasformazione nello spazio cartesiano. Il x, y, znel risultato può essere sostituito con le loro espressioni corrispondenti, e lo stesso può ripetersi per x', y'e z'. Dopo aver applicato alcune identità trigonometriche, emergono le seguenti espressioni a passaggio singolo:

lat = arcsin(cos(ϑ) sin(lat') - cos(lon') sin(ϑ) cos(lat'))
lon = atan2(sin(lon'), tan(lat') sin(ϑ) + cos(lon') cos(ϑ)) - φ

Nel caso in cui qualcuno fosse interessato, ho condiviso uno script MATLAB sullo scambio di file trasformando il normale lat / lon in lat / lon ruotato e viceversa: Trasformazione della griglia ruotata

function [grid_out] = rotated_grid_transform(grid_in, option, SP_coor)

lon = grid_in(:,1);
lat = grid_in(:,2);

lon = (lon*pi)/180; % Convert degrees to radians
lat = (lat*pi)/180;

SP_lon = SP_coor(1);
SP_lat = SP_coor(2);

theta = 90+SP_lat; % Rotation around y-axis
phi = SP_lon; % Rotation around z-axis

phi = (phi*pi)/180; % Convert degrees to radians
theta = (theta*pi)/180;

x = cos(lon).*cos(lat); % Convert from spherical to cartesian coordinates
y = sin(lon).*cos(lat);
z = sin(lat);

if option == 1 % Regular -> Rotated

    x_new = cos(theta).*cos(phi).*x + cos(theta).*sin(phi).*y + sin(theta).*z;
    y_new = -sin(phi).*x + cos(phi).*y;
    z_new = -sin(theta).*cos(phi).*x - sin(theta).*sin(phi).*y + cos(theta).*z;

elseif option == 2 % Rotated -> Regular

    phi = -phi;
    theta = -theta;

    x_new = cos(theta).*cos(phi).*x + sin(phi).*y + sin(theta).*cos(phi).*z;
    y_new = -cos(theta).*sin(phi).*x + cos(phi).*y - sin(theta).*sin(phi).*z;
    z_new = -sin(theta).*x + cos(theta).*z;

end

lon_new = atan2(y_new,x_new); % Convert cartesian back to spherical coordinates
lat_new = asin(z_new);

lon_new = (lon_new*180)/pi; % Convert radians back to degrees
lat_new = (lat_new*180)/pi;

grid_out = [lon_new lat_new];

Questa trasformazione può anche essere calcolata con il software proj (utilizzando la riga di comando o programmaticamente) impiegando quella che proj chiama una traduzione obliqua ( ob_tran) applicata a una trasformazione latlon. I parametri di proiezione da impostare sono:

• o_lat_p = latitudine del polo nord => 35 ° nell'esempio
• lon_0 = longitudine polo sud => -15 ° nell'esempio
• o_lon_p = 0

Inoltre, -m 57.2957795130823 è necessario (180 / pi) per considerare i valori previsti in gradi.

La replica degli esempi proposti da mkadunc fornisce lo stesso risultato (si noti che qui l'ordine lon latnon è (lat,lon), i coodinati sono digitati nell'input standard, l'output è contrassegnato da =>):

invproj -f "=> %.6f" -m 57.2957795130823 +proj=ob_tran +o_proj=latlon +o_lon_p=0 +o_lat_p=35 +lon_0=-15
0 -90
=> -15.000000   => -35.000000
40 -90
=> -15.000000   => -35.000000
0 0
=> -15.000000   => 55.000000
90 0
=> 75.000000    => -0.000000
-90 0
=> -105.000000  => -0.000000

invprojIl comando è usato per convertire da coordinate "proiettate" (cioè ruotate) a geografiche, mentre projper fare il contrario.

Ho sviluppato una pagina asp.net per convertire le coordinate da ruotate a non ruotate in base ai domini CORDEX.

Si basa sui metodi di cui sopra. Puoi usarlo liberamente in questo link:

Trasformazione manuale lat / lon ruotata in lat / lon normale

https://www.mathworks.com/matlabcentral/fileexchange/43435-rotated-grid-transform

PITONE:

from math import *

def rotated_grid_transform(grid_in, option, SP_coor):
    lon = grid_in[0]
    lat = grid_in[1];

    lon = (lon*pi)/180; # Convert degrees to radians
    lat = (lat*pi)/180;

    SP_lon = SP_coor[0];
    SP_lat = SP_coor[1];

    theta = 90+SP_lat; # Rotation around y-axis
    phi = SP_lon; # Rotation around z-axis

    theta = (theta*pi)/180;
    phi = (phi*pi)/180; # Convert degrees to radians

    x = cos(lon)*cos(lat); # Convert from spherical to cartesian coordinates
    y = sin(lon)*cos(lat);
    z = sin(lat);

    if option == 1: # Regular -> Rotated

        x_new = cos(theta)*cos(phi)*x + cos(theta)*sin(phi)*y + sin(theta)*z;
        y_new = -sin(phi)*x + cos(phi)*y;
        z_new = -sin(theta)*cos(phi)*x - sin(theta)*sin(phi)*y + cos(theta)*z;

    else:  # Rotated -> Regular

        phi = -phi;
        theta = -theta;

        x_new = cos(theta)*cos(phi)*x + sin(phi)*y + sin(theta)*cos(phi)*z;
        y_new = -cos(theta)*sin(phi)*x + cos(phi)*y - sin(theta)*sin(phi)*z;
        z_new = -sin(theta)*x + cos(theta)*z;



    lon_new = atan2(y_new,x_new); # Convert cartesian back to spherical coordinates
    lat_new = asin(z_new);

    lon_new = (lon_new*180)/pi; # Convert radians back to degrees
    lat_new = (lat_new*180)/pi;

    print lon_new,lat_new;

rotated_grid_transform((0,0), 1, (0,30))

Quale software stai usando? Ogni software GIS avrà la possibilità di mostrarti le attuali informazioni di sistema / proiezione coordinate. , che può aiutarti a ottenere il nome del tuo attuale sistema di coordinate.

Inoltre, se si utilizza ArcGIS, è possibile utilizzare lo strumento Progetto per riproiettare il secondo set di dati, importando le impostazioni dal primo.

Il modulo cartopy per Python ha una struttura a palo ruotato. Capisce le trasformazioni che sembra.

https://scitools.org.uk/cartopy/docs/latest/gallery/rotated_pole.html#sphx-glr-gallery-rotated-pole-py

Potrebbe essere utile, immagino.