Sei sulla pagina 1di 14

TRASFORMAZIONE

COORDINATE SU
GOOGLE MAPS

18/10/2007 Da WGS84 a UTM

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


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.
LORENZO DAL COL lorenzo.dalcol@gmail.com
Trasformazione
one coordinate su Google Maps

INTRODUZIONE
L’obiettivo di questo programma è quello di costruire un sistema di trasformazione delle coordinate
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 vantaggio
vantaggio nell’utilizzo delle
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 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
• portabilità: funziona in tutti
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
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
ersione 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/gis
http://www.lordalcol.com/g

Pagina 1
Trasformazione
one coordinate su Google Maps

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 UTM passando
attraverso le coordinate ellissoidiche ED50;
ED50; viene effettuata utilizzando le formule di Molodenski
Molodenskij e
di Gauss.

CARATTERISTICHE TECNICHE
TECNICHE DEL PROGRAMMA
Il programma è realizzato in Javascript, pertanto gira all’interno di una pagina web visualizzata in un
browser. Javascript
ascript è 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 non permette il raggiungimento delle prestazioni
ottimali della macchina, tuttavia la velocità di esecuzione in questo caso è completamente
soddisfacente, e permette un utilizzo completo in real
real-time.

Pagina 2
Trasformazione coordinate su Google Maps

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 3
Trasformazione coordinate su Google Maps

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 4
Trasformazione coordinate su Google Maps

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 5
Trasformazione coordinate su Google Maps

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 6
Trasformazione coordinate su Google Maps

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 7
Trasformazione coordinate su Google Maps

• 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 8
Trasformazione coordinate su Google Maps

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 9
Trasformazione coordinate su Google Maps

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 10
Trasformazione coordinate su Google Maps

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 11
Trasformazione coordinate su Google Maps

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 12
Trasformazione coordinate su Google Maps

Pagina 13