Trasformazione Coordinate Su Google Maps

TRASFORMAZIONE

COORDINATE SU

GOOGLE MAPS

18/10/2007 Da WGS84 a

Il programma è in grado di eseguire trasformazioni di coordinate dal sistema

WGS84 (coordinate geodetiche) a

La trasformazione avviene per punti

cui viene posizionato il cursore in Google Maps.

L O R E N Z O D A L C O L

TRASFORMAZIONE

COORDINATE SU

GOOGLE MAPS

Da WGS84 a UTM


WGS84 (coordinate geodetiche) a UTM (coordinate cartesiane).

La trasformazione avviene per punti fissati oppure dinamicamente per il punto in

cui viene posizionato il cursore in Google Maps.

L O R E N Z O D A L C O L [email protected]

TRASFORMAZIONE

COORDINATE SU

GOOGLE MAPS


(coordinate cartesiane).

fissati oppure dinamicamente per il punto in

INTRODUZIONE L’obiettivo di questo programma è quello di costruire un sistema di trasformazione delle

che funzioni su un qualsiasi browser di qualsiasi sistema operativo.

La parte innovativa e interessante è l’integrazione con le Google Maps, uno dei sistemi interattivi per

la navigazione nelle mappe del mondo più in voga in questi tempi. Il van

Google Maps sta nell’avere a disposizione un sistema già pronto per la visualizzazione delle mappe

con le seguenti caratteristiche:

• visualizzazione delle mappe stradali, satellitari e ibride

• 20 livelli di zoom (accessibili anche

• vasta disponibilità di API (funzioni di libreria) con cui poter interagire

• possibilità di fissare marcatori e layer aggiuntivi sulla mappa

• costante aggiornamento delle funzionalità da parte di Google

• portabilità: funziona in tutti i sistemi operativi con quasi tutti i browser moderni

• efficienza: il sistema di visualizzazione è veloce e le mappe vengono scaricate solo per le zone

effettivamente visualizzate

Le funzionalità che si vogliono implementare sono due:

1. Conversione delle coordinate di punti prefissati (latitudine, longitudine, altitudine) con

visualizzazione delle coordinate tramite un marcatore nelle Google Maps.

2. Possibilità di poter spostare il marcatore trascinandolo con il mouse con rilevamente delle

coordinate e conversione delle stesse in automatico.

Come eseguire il programma

Per provare le funzionalità del programma di conversione coordinate sulle Google Maps è sufficiente

collegarsi con un browser (vedi prossimo capitolo) all’indirizzo:

� http://www.lordalcol.com/g

Trasformazione coordinate su Google Maps

L’obiettivo di questo programma è quello di costruire un sistema di trasformazione delle

che funzioni su un qualsiasi browser di qualsiasi sistema operativo.


la navigazione nelle mappe del mondo più in voga in questi tempi. Il vantaggio nell’utilizzo delle


visualizzazione delle mappe stradali, satellitari e ibride

20 livelli di zoom (accessibili anche tramite la rotella del mouse)

vasta disponibilità di API (funzioni di libreria) con cui poter interagire

possibilità di fissare marcatori e layer aggiuntivi sulla mappa

costante aggiornamento delle funzionalità da parte di Google

utti i sistemi operativi con quasi tutti i browser moderni

efficienza: il sistema di visualizzazione è veloce e le mappe vengono scaricate solo per le zone

Le funzionalità che si vogliono implementare sono due:

coordinate di punti prefissati (latitudine, longitudine, altitudine) con

visualizzazione delle coordinate tramite un marcatore nelle Google Maps.

Possibilità di poter spostare il marcatore trascinandolo con il mouse con rilevamente delle

ersione delle stesse in automatico.

Come eseguire il programma


collegarsi con un browser (vedi prossimo capitolo) all’indirizzo:

http://www.lordalcol.com/gis

one coordinate su Google Maps

Pagina 1

L’obiettivo di questo programma è quello di costruire un sistema di trasformazione delle coordinate


taggio nell’utilizzo delle


utti i sistemi operativi con quasi tutti i browser moderni

efficienza: il sistema di visualizzazione è veloce e le mappe vengono scaricate solo per le zone

coordinate di punti prefissati (latitudine, longitudine, altitudine) con

Possibilità di poter spostare il marcatore trascinandolo con il mouse con rilevamente delle


Esempio: il marcatore rosso viene trascinato dal mouse, al momento del rilascio vengono visualizzate

le coordinate WGS84 e UTM appena calcolate

La conversione è dalle coordinate geodetiche WGS84 alle coordinate cartesiane

attraverso le coordinate ellissoidiche ED50

di Gauss.

CARATTERISTICHE TECNIl programma è realizzato in Javascript, pertanto gira all’interno di una pagina web visualizzata in un

browser. Javascript è un linguaggio di scripting interpretato molto potente e standard, supportato da

diverse compagnie nel mondo e certificato dalle ECMA.

Browser supportati:

• Microsoft Internet Explorer 6, 7

• Mozilla Firefox 1.5, 2.0

• Safari

Dispositivi hardware supportato:

• Personal Computer con qualsiasi sistema operativo

• PDA, cellulare e altri dispositivi provvisti delle funzionalità per navigare in internet avanzate

Bisogna inoltre ricordare che le nuove tecnologie hanno portato questi browser all’interno di

numerosi dispositivi portatili (PDA, cellulari, ecc), pertanto la maggior parte di questi dispositivi che

sono in grado di navigare in internet dovrebbero essere in grado di eseguire il programma della

conversione.

Javascript è un linguaggio interpretato, pertanto

ottimali della macchina, tuttavia la velocità di esecuzione in questo caso è completamente

soddisfacente, e permette un utilizzo completo in real



le coordinate WGS84 e UTM appena calcolate

La conversione è dalle coordinate geodetiche WGS84 alle coordinate cartesiane UTM passando

le coordinate ellissoidiche ED50; viene effettuata utilizzando le formule di Molodenski

CARATTERISTICHE TECNICHE DEL PROGRAMMAIl programma è realizzato in Javascript, pertanto gira all’interno di una pagina web visualizzata in un

ascript è un linguaggio di scripting interpretato molto potente e standard, supportato da

diverse compagnie nel mondo e certificato dalle ECMA.

Microsoft Internet Explorer 6, 7

Personal Computer con qualsiasi sistema operativo

PDA, cellulare e altri dispositivi provvisti delle funzionalità per navigare in internet avanzate


dispositivi portatili (PDA, cellulari, ecc), pertanto la maggior parte di questi dispositivi che


Javascript è un linguaggio interpretato, pertanto non permette il raggiungimento delle prestazioni


un utilizzo completo in real-time.

one coordinate su Google Maps

Pagina 2


UTM passando

; viene effettuata utilizzando le formule di Molodenskij e

ICHE DEL PROGRAMMA Il programma è realizzato in Javascript, pertanto gira all’interno di una pagina web visualizzata in un

ascript è un linguaggio di scripting interpretato molto potente e standard, supportato da

PDA, cellulare e altri dispositivi provvisti delle funzionalità per navigare in internet avanzate


dispositivi portatili (PDA, cellulari, ecc), pertanto la maggior parte di questi dispositivi che


non permette il raggiungimento delle prestazioni



Pagina 3

I SISTEMI DI COORDINATE

WGS84

World Geodetic System 1984: è il sistema di riferimento utilizzato nel posizionamento con la

tecnologia GPS. E’ espresso tramite le coordinate geodetiche X,Y,Z, riferite all’ellissoide di rotazione

geocentrico.

• l’asse Z è diretto verso la posizione del polo medio definito nel 1984

• l’asse X è definito dall’intersezione del piano equatoriale medio nel 1984 con il meridiano di

Greenwich

• l’asse Y è definito in modo tale da completare la terna destrorsa

UTM

Universal Transverse Mercator: è la cartografia più diffusa al mondo, nota anche come Gauss-Boaga.

Questa proiezione è approssimata notevolmente dalla cilindrica trasversa inversa. Questo tipo di

cartografia è conforme. Le trasformate del meridiano centrale (di tangenza) e dell’Equatore sono

rette e rappresentano gli assi del sistema di riferimento (N e E).

Poiché più ci si allontana dal meridiano centrale più il modulo di deformazione lineare sale, nel

sistema UTM l’ampiezza di un fuso è di 6°, il sistema risulta essere quindi policilindrico. Ogni fuso ha

un sistema N,E indipendente. Viene inoltre applicato alle coordinate un coefficiente di contrazione di

0,9996 per ridurre le deformazioni. Infine all’origine delle ascisse viene applicata una falsa origine di

500000 m, per evitare valori negativi di E. Il riferimento geodetico è basato sull’ellissoide

internazionale con orientamento europeo (ED50), cioè orientato a Postdam.

LE FORMULE DI TRASFORMAZIONE La trasformazione delle coordinate avviene in due passi, utilizzando due funzioni diverse. La prima

converte le coordinate ellissoidiche WGS84 in coordinate ellissoidiche ED50 usando le formule di

Molodenskij; la seconda converte le coordinate ellissoidiche ED50 in coordinate piane UTM usando le

formule di Gauss adatte a questo scopo.

Le formule di Molodenskij

Le formule di Molodenskij complete sono le seguenti:


Pagina 4

dove:

a Semiasse equatoriale dell’ellissoide WGS84

e2 Eccentricità dell’ellissoide WGS84

ρ Raggio di curvatura del meridiano

NG Gran normale

x0, y0, z0 Traslazioni fra i centri del sistema WGS84 e ED50

Ex, Ey, Ez Rotazioni attorno agli assi dell’ellissoide ED50

K Fattore di scala

da Differenza tra semiasse maggiore WGS84 e ED50

dα Differenza tra schiacciamento WGS84 e ED50

φ, λ, h Coordinate ellissoidiche WGS84

Siccome non ci sono rotazioni tra l’ellissoide WGS84 e l’ellissoide ED50 e non ci sono variazioni del

fattore di scala, allora le componenti di rotazione Ex, Ey, Ez e il fattore di scala K sono pari a zero.

Questo ridurrebbe le formule di Molodenskij a:

Nel programma sono state codificate le formule complete, non quelle semplificate, pertanto esso si

presterebbe anche ad effettuare conversioni tra altri ellissoidi oltre a quelli utilizzati in questo caso.

In specifico si potrebbe utilizzare il programma anche per la conversione a ITA40, che effettua pure

rotazioni e riscalamento.

Le formule di Gauss

La seconda funzione calcola le coordinate piane a partire da quelle ellissoidiche utilizzando le

seguenti formule di Gauss:


Pagina 5

dove:

a Semiasse equatoriale dell’ellissoide ED50

e2 Eccentricità dell’ellissoide ED50

φ, λ Coordinate ellissoidiche ED50

LE CLASSI Il software è basato sulla programmazione ad oggetti (OOP) e presenta le seguenti classi:

• DegreesConverter

Serve a convertire da gradi decimali a radianti e viceversa, e da gradi sessagesimali a gradi

decimali, e viceversa.

• MapPoint

Oggetto che rappresenta un punto descritto tramite coordinate ellissoidiche. Il punto può

essere definito usando i gradi sessagesimali, decimali o radianti. Dopo la definizione in

automatico vengono calcolate le coordinate negli altri sistemi di misura.

• RotationElipsoid

Oggetto che rappresenta un ellissoide di rotazione orientato nello spazio. L’inizializzazione

avviente passando i valori del semiasse maggiore e l’inverso dello schiacciamento. Tutte le

altre caratteristiche dell’ellissoide vengono calcolate automaticamente. Fornisce i metodi per

calcolare il rapporto di curvatura e la gran normale, dato un punto. Viene inoltre passato

come parametro l’orientamento dell’ellissoide.

• Integral

Questa classe statica riceve in ingresso il delegato della funzione da integrare e il suo

contesto (scope), gli estremi dell’intervallo di integrazione e il numero di passi in cui fare il

calcolo dell’integrale (da poche decine a diversi milioni, a seconda della precisione voluta). Il

metodo di integrazione numerica è quello dei trapezi.

• MolodenskijConverter

Si occupa della trasformazione delle coordinate ellissoidiche da WGS84 a UTM. Viene

inizializzata passando come parametri i due oggetti che rappresentano gli ellissoidi di

rotazione di partenza e di arrivo.

• GaussConverter

Si occupa della trasformazione delle coordinate ellissoidiche ED50 in coordinate cartesiane

UTM. Viene inizializzata passando l’ellissoide e le coordinate del punto. Questa classe

effettua il calcolo integrale.

Altre classi di supporto completano il programma, fornendo utilità di I/O, controllo errori,

compatibilità con le Google Maps, ecc.


Pagina 6

Definizione delle coordinate nel programma

Ecco un esempio di come viene in modo molto intuitivo inizializzato un punto (sia con i gradi, sia con i

radianti):

// esempio con coordinate in gradi

var lanaro = {

degrees: { latitude: {degrees: 45, minutes: 44, seconds: 49.67811},

longitude: {degrees: 13, minutes: 46, seconds: 55.62078}

},

altitude: 589.377

};

var point = new MapPoint(lanaro);

// esempio con coordinate in radianti

var radiansCoords = {

radians: { latitude: 0.77468329623124645462133015424366,

longitude: 0.21958987974778470489567723141063

},

altitude: 0

};

var point = new MapPoint(radiansCoords);

Inoltre all’inizio del programma vengono anche definiti gli ellissoidi che poi

vengono utilizzati per la trasformazione:

var WGS84_Hayford = new RotationElipsoid(6378137.0, 298.257222101, new

Orientation(0,0,0));

var ED50 = new RotationElipsoid(6378388,297, new Orientation(-87,-98,-121));

IL FLUSSO DEL PROGRAMMA Ecco in breve il processo di conversione delle coordinate:

• definizione del punto

Inizialmente viene definito un oggetto MapPoint, cioè un punto generico, inizializzato tramite

le coordinate di latitudine, longitudine e altitudine (in gradi oppure radianti).

• conversione gradi-radianti

Subito vengono converite le coordinate da gradi sessagesimali a gradi decimali e poi in

radianti, o viceversa, in modo da avere tutti i formati disponibili.

• definizione degli ellissoidi

Vengono definiti gli ellissoidi utilizzati dalle formule (WGS84, ED50).

• trasformazione di Molodenskij

Le coordinate del punto vengono trasformate in coordinate riferite al nuovo ellissoide

(ED50), restituendo il risultato in radianti.

• trasformazione di Gauss

Le coordinate del nuovo punto vengono trasformate in coordinate piane UTM in metri,

calcolando anche un integrale per la coordinata N. Vengono restituite le coordinate UTM.

Per quanto riguarda l’iterazione con le Google Maps si procede in questo modo:

• si ricevono le coordinate WGS84 della posizione del marcatore sulla mappa

• si effettua la conversione

• si scrivono le coordinate originali e quelle convertite nel messaggio vicino al marcatore


Pagina 7

ESEMPI DI TRASFORMAZIONI EFFETTUATI Ecco riportati alcuni esempi di trasformazioni di coordinate effettuati per punti noti:

latitudine - N longitudine – E altitudine

lanaro 45° 44’ 49. 27350” 13° 46’ 55.62078” 589.377

UTM (forniti) 5066854.358 405339.313 547.103

UTM (calcolati) 5066854.356 405339.328 547.097

3cam 45 ° 38’ 5.30010” 13° 48’ 59.79464” 317.163

UTM (forniti) 5054346.905 407838.028 274.727

UTM (calcolati) 5054346.903 407838.041 274.721

franco 45° 40’ 55.34769” 13° 50’ 10.56380” 452.412

UTM (forniti) 5059572.341 409446.428 410.075

UTM (calcolati) 5059572.339 409446.441 410.069

berciz 45° 44’ 51.20396” 13° 39’ 53.19392” 244.504

UTM (forniti) 5067059.624 396213.021 202.124

UTM (calcolati) 5067059.622 396213.039 202.118

cares 45° 35’ 35.21889” 13° 49’ 45.06422” 205.139

UTM (forniti) 5049700.854 408750.471 162.642

UTM (calcolati) 5049700.852 408750.484 162.636

ermada 45° 47’ 40.96079” 13° 37’ 34.64112” 367.605

UTM (forniti) 5072349.315 393309.393 325.271

UTM (calcolati) 5072349.313 393309.412 325.265

sleon 45° 45’ 53.51495” 13° 43’ 20.49039” 446.276

UTM (forniti) 5068909.479 400722.712 403.978

UTM (calcolati) 5068909.477 400722.728 403.972

duino 45° 47’ 14. 67811” 13° 35’ 32.46407” 61.580

UTM (forniti) 5071584.090 390657.508 19.203

UTM (calcolati) 5071584.088 390657.529 19.196

Sono riportati in tabella i dati delle coordinate WGS84 espresse in gradi, primi, secondi, i dati UTM in

metri forniti come riferimento e i dati UTM espressi in metri calcolati dal programma.

OSSERVAZIONI SULLA PRECISIONE In tutti i calcoli sono state mantenute tutte le cifre significative gestite dal linguaggio di

programmazione.

Il calcolo più dispendioso in termini di tempo è l’integrale (per via numerica) della funzione non

lineare (contenente radice quadrata, funzioni trigonometriche, potenze, ecc). Di seguito vengono

riportate delle misure empiriche dei tempi impiegati per il calcolo dell’integrale a seconda del

numero di passi:


Pagina 8

• 1000 passi: meno di 1/10 di secondo

• 10 000 passi: meno di 1 secondo

• 100 000 passi: qualche secondo

• 1 000 000 passi: alcune decine di secondi

• 10 000 000 passi: più di un minuto

Facendo diversi test con più funzioni di diversi tipi (compresa quella di Gauss usata in questo

programma) si è scoperto per via empirica che sono sufficienti 10 000 passi per il calcolo

dell’integrale. Aumentare ulteriormente il numero di passi allunga notevolmente l’attesa e non

migliora il risultato, almeno per le prime 9 cifre significative.

Dato che il tempo di esecuzione di tutta la trasformazione (compreso l’integrale) rimane inferiore al

secondo questo sistema può essere utilizzato per applicazioni in tempo reale.

Un confronto con i valori calcolati dal software e i valori forniti precedentemente ha riportato:

• Coordinata NORD: differenza di 3 mm sistematica per tutti i valori

• Coordinata EST: differenza di circa 17 cm sistematica

• altitudine: differenza di 4-5 mm sistematica

Tutte le trasformazioni hanno quindi una precisione matematica ben inferiore al metro.

CODICI SORGENTI

DegreesConverter function DegreesConverter() {

this.className = "DegreesConverter";

this.pi = Math.PI;

this.degreesToRadians = function(degree) {

return this.de_ra(this.de60_de10(degree));

}

this.radiansToDegrees = function(radians) {

return this.de10_de60(this.ra_de(radians));

}

this.de60_de10 = function(degree60) {

return degree60.degrees + degree60.minutes / 60 + degree60.seconds / 3600;

}

this.de10_de60 = function(degree10) {

var myDegrees = Math.floor(degree10);

var myMinutes = (degree10 - myDegrees) * 60;

var mySeconds = (myMinutes - Math.floor(myMinutes)) * 60;

return {degrees: myDegrees, minutes: Math.floor(myMinutes), seconds: mySeconds };

}

this.ra_de = function(radian) {

return radian*(180/this.pi);

}

this.de_ra = function(degree10) {

return degree10*(this.pi/180);

}

}

MapPoint function MapPoint(myPoint) {


Pagina 9

this.className = "MapPoint";

this.degrees = {};

this.decimals = {};

this.radians = {};

var c = new DegreesConverter();

if (myPoint.degrees) {

this.degrees = myPoint.degrees;

this.radians.latitude = c.degreesToRadians(this.degrees.latitude);

this.radians.longitude = c.degreesToRadians(this.degrees.longitude);

this.decimals.latitude = c.de60_de10(this.degrees.latitude);

this.decimals.longitude = c.de60_de10(this.degrees.longitude);

} else if (myPoint.radians) {

this.radians = myPoint.radians;

this.degrees.latitude = c.radiansToDegrees(this.radians.latitude);

this.degrees.longitude = c.radiansToDegrees(this.radians.longitude);

this.decimals.latitude = c.ra_de(this.degrees.latitude);

this.decimals.longitude = c.ra_de(this.degrees.longitude);

} else if (myPoint.decimals) {

this.decimals = myPoint.decimals;

this.radians.latitude = c.de_ra(this.decimals.latitude);

this.radians.longitude = c.de_ra(this.decimals.longitude);

this.degrees.latitude = c.radiansToDegrees(this.radians.latitude);

this.degrees.longitude = c.radiansToDegrees(this.radians.longitude);

} else {

alert("Eccezione: non sono state impostate le coordinate geodetiche " +

this.className);

return false;

}

this.altitude = myPoint.altitude;

}

RotationElipsoid function RotationElipsoid(semimajor, invertF, orientation) {

this.className = "RotationElipsoid";

this.orientation = orientation;

this.semimajor = semimajor;

this.flattening = 1/invertF;

this.semiminor = this.semimajor - this.semimajor * this.flattening;

this.e2 = (Math.pow(this.semimajor,2) - Math.pow(this.semiminor,2)) /

Math.pow(this.semimajor,2);

//this.semiminor = Math.sqrt(Math.pow(this.semimajor,2) - e2 * Math.pow(this.semimajor,2));

//this.flattening = (this.semimajor - this.semiminor) / this.semimajor;

this.CurvationRatio = function(myPoint) {

var e2 = this.e2;

return this.semimajor * (1 - e2) / Math.sqrt(Math.pow(1 - e2 *

Math.pow(Math.sin(myPoint.radians.latitude),2),3));

}

this.GrandNormal = function(myPoint) {

var e2 = this.e2;

return this.semimajor / Math.sqrt(1 - e2 *

Math.pow(Math.sin(myPoint.radians.latitude),2));

}

}

function Orientation(translation_yz, translation_xz, translation_xy, refactor, rotation_x, rotation_y,

rotation_z) {

this.translation_xy = translation_xy;

this.translation_yz = translation_yz;

this.translation_xz = translation_xz;

if (!refactor) { this.refactor = 0; } else { this.refactor = refactor; }

if (!rotation_x) { this.rotation_x = 0; } else { this.rotation_x = rotation_x; }


Pagina 10

if (!rotation_y) { this.rotation_y = 0; } else { this.rotation_y = rotation_y; }

if (!rotation_z) { this.rotation_z = 0; } else { this.rotation_z = rotation_z; }

}

Integral function Integral(myFunction, scope, begin, end, parts) {

this.className = "Integral";

if (!begin) { begin = 0; }

if (!end) { end = 1; }

if (!parts) { parts = 1; }

var step = (end - begin) / parts;

var result;

var temp = 0;

temp = myFunction(begin, scope) / 2;

begin += step;

for (var c = 0; c < parts - 1; c++) {

temp += myFunction(begin, scope);

begin += step;

}

temp += myFunction(begin, scope) / 2;

result = temp*step;

return result;

}

MolodenskijConverter function MolodenskijConverter(fromSurface, toSurface) {

this.className = "MolodenskijConverter";

fromOrientation = fromSurface.orientation;

toOrientation = toSurface.orientation;

this.deltaSemiMajor = fromSurface.semimajor - toSurface.semimajor;

this.deltaFlattening = fromSurface.flattening - toSurface.flattening;

this.rotation_x = toOrientation.rotation_x - fromOrientation.rotation_x;

this.rotation_y = toOrientation.rotation_y - fromOrientation.rotation_y;

this.rotation_z = toOrientation.rotation_z - fromOrientation.rotation_z;

this.translation_x = toOrientation.translation_yz - fromOrientation.translation_yz;

this.translation_y = toOrientation.translation_xz - fromOrientation.translation_xz;

this.translation_z = toOrientation.translation_xy - fromOrientation.translation_xy;

this.scaleFactor = toOrientation.refactor - toOrientation.refactor;

//save Elipsoid for calculations...

this.fromElipsoid = fromSurface;

this.destElipsoid = toSurface;

this.convert = function(myPoint) {

var curvationRatio = this.fromElipsoid.CurvationRatio(myPoint);

var grandNormal = this.fromElipsoid.GrandNormal(myPoint);

var sinLongitude = Math.sin(myPoint.radians.longitude);

var cosLongitude = Math.cos(myPoint.radians.longitude);

var sinLatitude = Math.sin(myPoint.radians.latitude);

var cosLatitude = Math.cos(myPoint.radians.latitude);

var tanLatitude = Math.tan(myPoint.radians.latitude);

var altitude = myPoint.altitude;

var flattening = this.fromElipsoid.flattening;

var translation_x = this.translation_x;

var translation_y = this.translation_y;

var translation_z = this.translation_z;

var rotation_x = this.rotation_x;

var rotation_y = this.rotation_y;

var rotation_z = this.rotation_z;

var scaleFactor = this.scaleFactor;

var deltaSemiMajor = this.deltaSemiMajor;


Pagina 11

var from_semiMajor = this.fromElipsoid.semimajor;

var deltaFlattening = this.deltaFlattening;

var tempVar = curvationRatio + altitude;

var tempVar2 = Math.pow(from_semiMajor,2) / grandNormal + altitude;

var tempVar6 = Math.pow(1 - flattening,2);

var tempVar5 = (1 - tempVar6) * grandNormal;

var tempVar3 = ( grandNormal + altitude ) * cosLatitude;

var tempVar4 = (tempVar6 * grandNormal + altitude) / (grandNormal + altitude);

var o1 = (sinLatitude * cosLongitude / tempVar) * translation_x;

var o2 = (sinLatitude * sinLongitude / tempVar) * translation_y;

var o3 = (cosLatitude / tempVar) * translation_z;

var o4 = (tempVar2 / tempVar) * sinLongitude * rotation_x;

var o5 = (tempVar2 / tempVar) * cosLongitude * rotation_y;

var o6 = (tempVar5 / tempVar) * cosLatitude * sinLatitude * ( scaleFactor +

deltaSemiMajor / from_semiMajor);

var o7 = ((curvationRatio + tempVar6 * grandNormal) / tempVar) * cosLatitude *

sinLatitude * ( deltaFlattening / (1 - flattening));

var dLatitude = o1+o2-o3+o4-o5-o6-o7;

var dLongitude = sinLongitude / tempVar3 * translation_x -

cosLongitude / tempVar3 *

translation_y -

tempVar4 * tanLatitude * cosLongitude

* rotation_x -

tempVar4 * tanLatitude * sinLongitude

* rotation_y +

rotation_z;

var dAltitude = - cosLatitude * cosLongitude * translation_x -

cosLatitude * sinLongitude *

translation_y -

sinLatitude * translation_z +

tempVar5 * sinLatitude * cosLatitude *

sinLongitude * rotation_x -

tempVar5 * sinLatitude * cosLatitude *

cosLongitude * rotation_y -

tempVar2 * scaleFactor +

from_semiMajor / grandNormal *

deltaSemiMajor -

tempVar6 * grandNormal *

Math.pow(sinLatitude, 2) * (deltaFlattening / (1 - flattening));

var toLatitude = myPoint.radians.latitude + dLatitude;

var toLongitude = myPoint.radians.longitude + dLongitude;

var toAltitude = myPoint.altitude + dAltitude;

//Angle longitude = new Angle(toLongitude);

//Angle latitude = new Angle(toLatitude);

//GeographicCoords newPoint = new

GeographicCoords(destElipsoid,longitude,latitude,toAltitude);

return new MapPoint({ radians: { latitude: toLatitude, longitude: toLongitude},

altitude: toAltitude });

}

}

GaussConverter function GaussConverter(surface) {

this.className = "GaussConverter";

this.defaultIntegralStep = 10000;


Pagina 12

this.a = surface.semimajor;

this.e2 = surface.e2;

this.Integral_Function = function(val, scope) {

var a = scope.a;

var e2 = scope.e2;

var tempVal = (a * (1 - e2));

return tempVal/Math.sqrt(Math.pow(1 - e2 * Math.pow(Math.sin(val),2),3));

}

this.convert = function(myPoint, precision) {

if (!precision) { precision = this.defaultIntegralStep; }

var a = this.a;

var e2 = this.e2;

var fuse_length = 6 * Math.PI / 180;

//TODO: calcolare il fuso meglio

var fuse;

if (myPoint.radians.longitude > Math.PI)

fuse = Math.floor((myPoint.radians.longitude - Math.PI) / fuse_length);

else

fuse = Math.floor((myPoint.radians.longitude + Math.PI) / fuse_length);

var deltalength = (fuse - 30) * fuse_length + fuse_length / 2;

var latitude = myPoint.radians.latitude;

var longitude = myPoint.radians.longitude - deltalength;

var sinLatitude = Math.sin(latitude);

var cosLatitude = Math.cos(latitude);

var tanLatitude = Math.tan(latitude);

var tempVar1 = Math.sqrt(1 - e2 * Math.pow(sinLatitude, 2));

var tempVar2 = Math.pow(e2/Math.sqrt(1 - e2), 2);

var valoreIntegrale = Integral(this.Integral_Function, this, 0, latitude, precision);

var x = valoreIntegrale +

(1/2 * a*sinLatitude*cosLatitude / tempVar1) *

Math.pow(longitude,2) +

(1/24 * a*sinLatitude*Math.pow(cosLatitude, 3)) / tempVar1 * (

5 - Math.pow(tanLatitude,2) +

9*tempVar2*Math.pow(cosLatitude,2) +

4 * Math.pow(tempVar2, 2)*

Math.pow(cosLatitude,4)

) * Math.pow(longitude,4) +

1/720 * a*sinLatitude*Math.pow(cosLatitude, 5)/ tempVar1 * (

61 - 58*Math.pow(tanLatitude,2) +

Math.pow(tanLatitude, 4) + 270 * tempVar2 * Math.pow(cosLatitude, 2) -

330 * tempVar2 * Math.pow(cosLatitude, 2) *

Math.pow(tanLatitude,2)

) * Math.pow(longitude, 6);

var y = (a * cosLatitude / tempVar1) * longitude +

(1/6) * a * Math.pow(cosLatitude, 3) / tempVar1 * (

1 - Math.pow(tanLatitude,2) + tempVar2 *

Math.pow(cosLatitude, 2)

) * Math.pow(longitude, 3) +

(1/120) * a*Math.pow(cosLatitude, 5) / tempVar1 * (

5 - 18 * Math.pow(tanLatitude, 2) +

Math.pow(tanLatitude, 4) + 14 * tempVar2 * Math.pow(cosLatitude, 2) -

58 * tempVar2 * Math.pow(cosLatitude, 2) *

Math.pow(tanLatitude, 2)

) * Math.pow(longitude, 5);

return [x,y,myPoint.altitude];

}


Pagina 13

}

Documents

Trasformazione Coordinate Su Google Maps