Embed Size (px)
DESCRIPTION
Citation preview
Università degli Studi di Trieste
Facoltà di Ingegneria
Tesi di Laurea Triennale in Ingegneria Informatica
PROGETTO E SVILUPPO DI UN APPLICATIVO BASATO SU GOOGLE EARTH PER LA VISUALIZZAZIONE DI DATI DI EMISSIONI INQUINANTI
Relatore: Laureando:
Ill.mo Prof. Maurizio FERMEGLIA Raffaele BERNARDI
Anno accademico 2009 – 2010
1
Indice
1. Introduzione ................................................................................................................... 3
1.1 Obiettivo della tesi .................................................................................................. 3
1.2 Stato dell’arte .......................................................................................................... 3
1.3 Risultato della tesi ................................................................................................... 4
1.4 Motivazioni ............................................................................................................. 4
1.5 Vincoli di progetto .................................................................................................. 5
2. Analisi ............................................................................................................................ 6
2.1 Google Earth ........................................................................................................... 6
2.2 Google Earth Plugin ................................................................................................ 6
2.3 Google Earth API: Javascript vs COM ................................................................... 7
2.4 Il progetto PRTR ..................................................................................................... 8
2.5 Il database PRTR .................................................................................................... 9
2.5.1 Legge dei coseni sferici ................................................................................. 10
3. Progettazione ................................................................................................................ 11
3.1 Use case diagram .................................................................................................. 11
3.2 Activity diagram ................................................................................................... 12
3.3 Class diagram ........................................................................................................ 14
4. Interfaccia ..................................................................................................................... 21
4.1 Form principale ..................................................................................................... 21
4.1.1 Barra dei menu .............................................................................................. 22
4.1.2 Barra di stato .................................................................................................. 23
4.1.3 Dialog box per la ricerca tramite indirizzo .................................................... 23
4.1.4 Dialog box per la ricerca tramite coordinate geografiche ............................. 24
4.1.5 Google Earth Plugin integrato ....................................................................... 24
4.2 Form informazioni ................................................................................................ 25
4.3 Form emissioni ..................................................................................................... 26
4.3.1 Scheda Regional emissions ........................................................................... 27
4.3.2 Scheda Chemical info .................................................................................... 28
4.3.3 Scheda Facility info ....................................................................................... 28
4.4 Esempio d’utilizzo ................................................................................................ 29
4.5 PRTR Google Earth Interface: requisiti per l’installazione .................................. 30
2
5. Implementazione .......................................................................................................... 31
5.1 Tecnologie software utilizzate .............................................................................. 31
5.2 Codice ................................................................................................................... 31
5.2.1 Caricamento di Google Earth Plugin ............................................................. 31
5.2.2 Integrazione di Google Earth Plugin ............................................................. 33
5.2.3 Chiamata ad un metodo esterno .................................................................... 34
5.2.4 Conversione di coordinate e aggiornamento della posizione del puntatore .. 35
5.2.5 Connessione al database ed esecuzione di una query .................................... 38
5.2.6 Esecuzione di una stored procedure .............................................................. 39
6. Conclusioni .................................................................................................................. 42
6.1 Risultati ottenuti .................................................................................................... 42
6.2 Lavoro svolto ........................................................................................................ 42
6.3 Sviluppi futuri ....................................................................................................... 43
7. Bibliografia .................................................................................................................. 45
1. Introduzione
3
1. Introduzione
1.1 Obiettivo della tesi
L’obiettivo che ci si è posti con questa tesi è la progettazione e lo sviluppo di un
applicativo stand-alone che presenti un’interfaccia user friendly per l’interrogazione del
database PRTR e la conseguente visualizzazione dei dati relativi alle emissioni inquinanti.
Più precisamente, si vuole che l’utente possa scegliere un arco temporale ed una regione
geografica per ottenere i relativi valori delle emissioni. La selezione avviene per porzioni
circolari di territorio, all’inserimento delle coordinate geografiche del punto desiderato
segue la determinazione di un raggio d’interesse. Questi costituiscono rispettivamente
centro e raggio dell’ideale circonferenza all’interno della quale si desidera estrarre le
informazioni dal database.
1.2 Stato dell’arte
Al momento esiste ed è operativa un’applicazione1 web simile per funzionalità ma diversa
per struttura.
Figura 1 - L'applicazione web
1 http://prtr.units.it/
1. Introduzione
4
L’inserimento delle coordinate geografiche è manuale, di conseguenza all’utente viene
implicitamente richiesta la conoscenza delle coordinate del punto d’interesse.
1.3 Risultato della tesi
Il software creato, PRTR Google Earth Interface, rispetta i vincoli di progetto ed è
utilizzabile dopo una semplice installazione. Per i requisiti, si rimanda al capitolo 4.5.
Figura 2 - L'applicazione PRTR Google Earth Interface
1.4 Motivazioni
L’applicazione web esistente prevede l’inserimento manuale delle coordinate geografiche
del punto d’interesse. L’operazione richiede quindi uno sforzo preventivo all’utente che di
questo non conosca già le coordinate, una ricerca tramite altri strumenti, esterni
all’applicazione, che gli permetta di scoprire i relativi valori di latitudine e longitudine. Di
1. Introduzione
5
conseguenza il sistema in uso introduce una probabilità d’errore nel momento in cui egli
riporta i dati nell’applicativo. L’utilizzo di una mappa che l’utente possa esplorare sino al
raggiungimento del punto d’interesse ovvia ad entrambi i problemi. All’utente non viene
richiesta la conoscenza preventiva delle coordinate geografiche, tantomeno lo costringe
all’inserimento manuale di tali valori e ciò comporta una sensibile riduzione della
probabilità d’errore.
1.5 Vincoli di progetto
Sono stati imposti i seguenti vincoli di progetto:
• Al fine di integrare una vista del globo nell’applicativo, si utilizzano le API di
Google Earth;
• L’applicativo è stand-alone;
• Il software usa il database PRTR già esistente ed operativo al quale si connette
direttamente ed in locale per l’estrazione dei dati richiesti dall’utente;
• La query avviene per porzioni circolari di territorio, il cui centro è scelto dall’utente
con un click del mouse sulla mappa.
2. Analisi
6
2. Analisi
Partendo dal presupposto di dover presentare all’interno del proprio applicativo
un’interfaccia di semplice utilizzo, ci si è concentrati sul vincolo relativo allo sfruttamento
delle API di Google Earth. In seguito, per l’interrogazione del database PRTR, sulle stored
procedure offerte dallo stesso e già utilizzate dall’applicazione web esistente.
2.1 Google Earth
L’applicazione, creata con il nome di Keyhole dall’omonima società, divenne Google
Earth quando nel 2004 Google acquisì la Keyhole, Inc. Giunto alla versione 6, il software
consente all’utente l’esplorazione ‘in volo’ del globo terrestre, mediante foto satellitari ed
aeree è possibile infatti visualizzare ogni zona del pianeta a diversi livelli di zoom, il cui
livello massimo, conservando una risoluzione accettabile, varia a seconda del luogo. La
navigazione può avvenire semplicemente con l’ausilio del mouse o in alternativa, se si è
alla ricerca di un preciso punto, tramite inserimento delle sue coordinate geografiche o
dell’indirizzo (grazie all’integrazione con Google Maps).
Per rappresentare la superficie del pianeta, Google Earth utilizza la proiezione cilindrica
equirettangolare, in cui meridiani e paralleli sono linee rette equidistanti che si intersecano
ad angolo retto, con datum WGS84, elissoide geocentrico concepito per coprire l’intero
globo terrestre2.
2.2 Google Earth Plugin
Accanto all’applicativo stand-alone, Google nel 2008 rilasciò il plugin del suddetto
software, consentendo in tal modo all’utente l’esplorazione del globo direttamente
all’interno del proprio browser web.
2 http://earth.google.com/intl/it/userguide/v4/ug_importdata.html
2. Analisi
7
2.3 Google Earth API: Javascript vs COM
In concomitanza al rilascio del plugin, Google mise a disposizione le API (Application
Programming Interface) Javascript necessarie agli sviluppatori che avessero voluto creare
applicazioni web proprie sfruttando le potenzialità di Google Earth. Queste andarono ad
affiancarsi alle API COM, fino a quel momento l’unico mezzo per chi avesse voluto
sviluppare codice su questo software, esistenti ancor prima che Keyhole divenisse Google
Earth. Sebbene quest’ultime fossero state mantenute anche dopo tale passaggio, non
godettero mai dello stesso supporto e documentazione che invece vantano le prime. La
difficoltà nel reperire informazioni e lo scarso supporto sono stati confermati dalla stessa
azienda statunitense, la quale nell’agosto 2010 ha annunciato che la versione 5.2 sarebbe
stata l’ultima a supportare le API COM:
“From the earliest days of Google Earth, (and even back when it was still called Keyhole,)
developers have wanted control over the globe to create their own 3D Earth applications.
In response to this need, the Keyhole team added a COM API to the Keyhole app, to allow
further customization of users’ Google Earth experience. When Keyhole became Google
Earth in 2005, this API was carried over. Though we never provided much support,
developers discovered the COM bindings and a few intrepid developers sorted through the
vagaries of COM programming. Eventually we had a small but committed development
community demanding documentation, which we released in 2007. We saw some
interesting uses for the COM API, particularly by Enterprise users and broadcasters.
Mostly, though, people wanted to put Earth in their web applications. In 2008, we released
the Google Earth API and browser plug-in. This robust JavaScript API is more powerful
than the COM API, and can be used on a variety of platforms to deliver compelling 3D
applications over the web based on the Google Earth technology. At the same time, we
stopped development on the COM API and began encouraging developers to migrate to
the Earth API instead. Today, more and more apps are being written in JavaScript, and
COM itself is no longer a widely used technology, so the time has come to retire the
Google Earth COM API. Today we’re announcing that the Google Earth 5.2 client will be
the last version that supports the COM API. […] We believe that the JavaScript API
provides the best mechanism for reaching the most developers. […] ” (Mano Marks, Geo
APIs Team).
Ai fini dell’applicativo quindi si è scelto di operare con le Javascript API. La
documentazione online è affiancata da numerosi esempi più o meno complessi, divisi per
2. Analisi
8
categorie, e forum di supporto. Risalta l’assenza di indicazioni per lo sviluppatore che si
ponesse l’obiettivo di costruire applicazioni stand-alone anziché web.
2.4 Il progetto PRTR
Il PRTR (Pollutant Release and Transfer Register) è un database contenente dati di
emissioni inquinanti. L’organizzazione responsabile del progetto è l’ICS (International
Centre for Science and High Technology) che agisce nell’ambito dell’UNIDO (United
Nations Industrial Development Organization). L’obiettivo dell’ente è sostenere le
comunità scientifiche nei Paesi in via di sviluppo e nei Paesi ad economia di transizione
attraverso attività di ricerca e formazione avanzata per la crescita industriale sostenibile. Le
competenze sviluppate al suo interno forniscono una serie di strumenti che trovano
applicazione in molteplici settori, quali: chimica pura ed applicata, scienze della terra
dell’ambiente e del mare, alta tecnologia e nuovi materiali.
Uno dei principali progetti dell’area ambientale dell’ICS/UNIDO è la distribuzione delle
conoscenze sui sistemi per il supporto decisionale. Lo scopo è la creazione di un centro di
raccolta di conoscenze atto a formare personale competente negli ambiti della simulazione
dei processi e nei sistemi di informazione geografici. In tal modo si sviluppa un
programma che possa favorire il monitoraggio dei sistemi, l’analisi e l’accertamento del
rischio, l’applicazione effettiva della tecnologia in risposta a problemi ambientali causati
da attività industriali. Rientra in questo ambito il progetto riguardante lo sviluppo di un
sistema pubblico per la raccolta e la divulgazione dei dati sugli inquinanti, il PRTR.
Progettato come un database ambientale, il Pollutant Release and Transfer Register
rappresenta un inventario di emissioni potenzialmente dannose riguardanti terra,
sottosuolo, acqua e aria, inoltre tiene conto del trasporto degli inquinanti in luoghi di
trattamento e discarica. Il PRTR si inserisce molto bene nella struttura organizzativa per lo
sviluppo industriale sostenibile, la conoscenza delle quantità delle sostanze emesse
consente di stimare l’equilibrio tra il materiale utilizzato per il processo e l’energia
impiegata per lo stesso, ottimo indicatore della sostenibilità di un processo industriale.
Inoltre i report registrando l’evoluzione delle emissioni nel tempo possono incoraggiare
l’introduzione di tecnologie più pulite al fine di ridurre il livello di inquinamento
ambientale.
2. Analisi
9
I dati presenti nel Pollutant Release and Transfer Register presentano queste caratteristiche
principali:
• Riportati per ogni prodotto chimico;
• Riportati per ogni installazione industriale;
• Riportati per ogni emissione e trasferimento;
• Riportati per ogni elemento dell’ambiente (aria, acqua, terra);
• Periodici;
• Costantemente strutturati;
• Presenti su un database;
• Divulgati e costantemente disponibili al pubblico;
• Permettono il mantenimento dei segreti industriali.
Il progetto diffusosi su scala europea con il nome E-PRTR (European Pollutant Release
and Transfer Register) si identifica nel nostro Paese nell’INES (Inventario Nazionale delle
Emissioni e loro Sorgenti).
2.5 Il database PRTR
Dal punto di vista tecnico, il DBMS utilizzato per il database PRTR contenente le
informazioni relative alle emissioni inquinanti è SQL Server 2005. Da precisare che il
laureando non ha partecipato alla stesura del relativo codice né a parte di esso, per quanto
riguarda il database ci si è soffermati sullo studio delle stored procedure, peraltro già
utilizzate dall’applicazione web esistente.
In particolare le seguenti:
• Statistics_GetByRegion: restituisce le emissioni chimiche in una determinata zona
circolare del globo definita dalle coordinate geografiche del centro, dal raggio e dal
periodo d’interesse;
• Statistics_GetByFacilityChemical: restituisce le emissioni di un determinato
prodotto chimico di un determinato complesso in un determinato periodo;
• Statistics_GetByPeriod: analoga alla precedente, ma è possibile avere i dati relativi
a tutti i complessi o a tutti i periodi inserendo NULL nei rispettivi parametri della
procedura.
2. Analisi
10
2.5.1 Legge dei coseni sferici
Interessante inoltre la funzione GetDistance, utilizzata dalla prima delle procedure citate,
che torna la distanza d fra due punti sulla superficie terrestre definiti dalle rispettive
coordinate geografiche latitudine e longitudine mediante la legge dei coseni sferici3.
∆ = ( + ∆ ) = ∆
con
: latitudine del punto 1
: latitudine del punto 2 ∆ : differenza delle longitudini ∆ : angolo centrale (il cui vertice è il centro della sfera e i cui lati intersecano la superficie
nei punti 1 e 2)
: raggio della sfera
3 Per ulteriori informazioni: (1) http://en.wikipedia.org/wiki/Great-circle_distance (2) http://en.wikipedia.org/wiki/Spherical_law_of_cosines
3. Progettazione
11
3. Progettazione
In questo capitolo si procede alla progettazione dell’applicativo mediante gli strumenti
forniti dal linguaggio UML. Creato con l’intento di unificare in un unico standard le
metodologie per il disegno nell’ambito della progettazione di sistemi software, l’UML
(Unified Modeling Language) stabilisce un insieme di notazioni e simboli, una collezione
di diagrammi composti da elementi grafici e testuali che consentono di descrivere il
sistema a più livelli d’astrazione.
3.1 Use case diagram
Lo Use case diagram è lo strumento utilizzato per la descrizione delle funzionalità offerte
dal software dal punto di vista degli attori che interagiscono con il sistema stesso.
Figura 3 - Use case diagram
Nel caso dell’applicativo in questione, si vuole che l’utente possa esplorare il globo alla
ricerca del punto d’interesse. Sono permesse diverse modalità di navigazione e ad egli
spetta la scelta di visualizzare o meno una serie di strumenti di supporto e di informazioni
aggiuntive. Una volta determinato il punto, procede alla selezione del periodo e del raggio
3. Progettazione
12
della circonferenza ideale di cui esso è il centro. Infine visualizza i dati relativi alle
emissioni inquinanti inerenti alla regione geografica prescelta.
3.2 Activity diagram
L’Activity diagram descrive i processi alla base di una data funzionalità del software.
L’algoritmo pone in primo piano le singole attività evidenziando i sistemi responsabili che
intervengono nel corso dell’elaborazione.
Figura 4 - Activity diagram riferito ai sistemi PRTR Google Earth Interface e Google Earth Server
Allo scopo di rendere il diagramma più comprensibile si è scelto di scinderlo nelle due
parti che caratterizzano l’algoritmo dell’applicativo. La prima di queste riguarda
l’interazione con il plugin di Google Earth (Figura 4), l’altra la connessione con il
database PRTR (Figura 5).
Nel dettaglio, la prima parte comprende le attività:
i. Ricerca per indirizzo/coordinate: l’utente inserisce nell’apposito campo l’indirizzo
o, in alternativa, la coppia di coordinate geografiche della locazione desiderata;
3. Progettazione
13
ii. Verifica che indirizzo/coordinate e altezza della camera view4 siano ben formati:
controllo sui dati immessi dall’utente. Nota: nel caso l’utente scelga di raggiungere
il punto d’interesse mediante navigazione con il mouse, l’activity diagram non
presenta tale attività;
iii. Rilocazione della camera view: vengono visualizzate le fotografie aeree o le
immagini satellitari, a seconda del livello dello zoom, della località scelta
dall’utente;
iv. Scelta del punto d'interesse: l’utente seleziona sulla mappa il punto d’interesse.
Figura 5 - Activity diagram riferito ai sistemi PRTR Google Earth Interface e Prtr database
4 Camera view : punto di vista dell’osservatore ideale.
3. Progettazione
14
La figura soprastante raffigura l’insieme delle attività riguardanti l’interazione con il
database PRTR, unita al primo diagramma rappresenta l’algoritmo completo alla base
dell’applicativo.
Tale parte si compone delle attività:
i. Apertura form emissioni inquinanti: una volta scelto il punto, si apre il form
relativo alle emissioni inquinanti;
ii. Query: lista i periodi: per aiutare l’utente nella scelta si esegue una query sul
database per visualizzare l’elenco dei periodi disponibili;
iii. Inserimento del raggio e selezione del periodo: egli procede all’inserimento del
raggio ed alla scelta del periodo tra quelli presenti;
iv. Query: estrai prodotti chimici relativi a periodo e regione scelti: query per
estrarre dal database i prodotti chimici relativi alla regione ed al periodo
selezionati;
v. Scelta del prodotto chimico: l’utente seleziona tra i risultati della query
precedente il prodotto chimico di cui desidera avere informazioni aggiuntive;
vi. Query: estrai lo storico del prodotto chimico scelto: in riferimento all’elemento
chimico appena selezionato, tale query estrae i dati in relazione a tutti i periodi
presenti nel database;
vii. Query: estrai lo storico dei relativi report: query per estrarre dal database
l’elenco dei report, coppie impianto – periodo, dato il prodotto chimico;
viii. Scelta del report (coppia impianto - periodo): l’utente sceglie tra i risultati della
query precedente il report d’interesse;
ix. Query: estrai i dati relativi a periodo, impianto e prodotto chimico scelti: dati il
prodotto chimico ed il report, la query estrae dal database le informazioni
riguardanti l’impianto, il report e ed il prodotto chimico dichiarato in esso.
3.3 Class diagram
Utilizzando le strutture tipiche della programmazione ad oggetti, classi metodi ed attributi,
il Class diagram ritrae il sistema sotto l’aspetto delle entità che ne fanno parte.
3. Progettazione
15
Figura 6 - Class diagram
Al fine di non appesantire eccessivamente il diagramma, per ognuna delle classi sono stati
omessi gli attributi, per la cui lettura si rimanda al codice sorgente, ed i metodi, che si
analizzano qui di seguito.
Il progetto si compone di 5 classi:
• Program: entry point dell’applicativo.
• MainForm: form principale dell’applicazione, in esso l’utente può esplorare la
mappa grazie al plugin di Google Earth integrato, scegliere se visualizzare o meno
strumenti d’ausilio alla navigazione e informazioni aggiuntive in merito alla
località inquadrata dalla camera view, e infine selezionare il punto. Sono presenti i
controlli necessari a navigare sino al punto d’interesse tramite il suo indirizzo e
strutture analoghe per farlo tramite coordinate geografiche. Dal form principale si
può accedere agli altri.
• InfoForm: semplice form per la visualizzazione della versione di Google Earth
Plugin installata sulla macchina e del programma.
• PointForm: classe del form relativo alle emissioni, da qui l’utente una volta
selezionato il punto procede alla scelta del periodo e del raggio della regione
circolare d’interesse. Quindi visualizza i risultati delle query mediante tabelle e
grafici.
• DecimalToSexagesimal: converte le coordinate geografiche dalla forma decimale
alla notazione sessagesimale e fornisce i metodi per la lettura dei nuovi valori. La
conversione è necessaria dal momento che le API di Google Earth forniscono
metodi i cui parametri e valori di ritorno sono decimali mentre sul database PRTR
le coordinate dei punti sono memorizzate in forma sessagesimale. Quest’ultimo
3. Progettazione
16
formato è stato scelto per quanto riguarda la visualizzazione delle coordinate
geografiche sull’interfaccia dell’applicativo, per favorire una lettura ed un
inserimento dei valori più semplice per l’utente.
La classe Program presenta il metodo:
• Main() : void
Apre il form principale.
La classe MainForm presenta i metodi:
• InternetConnection() : bool
Verifica lo stato della connessione internet.
• exitToolStripMenuItem_Click(object sender, EventArgs e) : void
Exit point dell’applicazione.
• MainForm_Load(object sender, EventArgs e) : void
Carica il form principale.
• jsInitSuccess(object instance) : void
L’istanza di Google Earth Plugin è stata creata correttamente, inizializza il plugin.
• jsInitFailure(String error) : void
L’istanza di Google Earth Plugin non è stata creata, stampa un messaggio d’errore.
• bGo_Click(object sender, EventArgs e) : void
Ricerca la locazione desiderata per indirizzo.
• eventLatLngAlt(float lat, float lng, float alt) : void
Aggiorna sulla barra di stato le coordinate del cursore sulla mappa.
• validateCoord(TextBox i, int low, int up, String coord, String unit) : int
Verifica che le coordinate immesse dall’utente siano ben formate.
• bGoCoord_Click(object sender, EventArgs e) : void
Ricerca la locazione desiderata per coordinate.
• tAltAdd_TextChanged(object sender, EventArgs e) : void
Verifica il valore dell’altezza della camera view (dialog box di ricerca per
indirizzo).
• tAltCoord_TextChanged(object sender, EventArgs e) : void
Verifica il valore dell’altezza della camera view (dialog box di ricerca per
coordinate).
• tLatDeg_TextChanged(object sender, EventArgs e) : void
3. Progettazione
17
Verifica il valore dei gradi di latitudine.
• tLatMin_TextChanged(object sender, EventArgs e) : void
Verifica il valore dei minuti di latitudine.
• tLatSec_TextChanged(object sender, EventArgs e) : void
Verifica il valore dei secondi di latitudine.
• tLngDeg_TextChanged(object sender, EventArgs e) : void
Verifica il valore dei gradi di longitudine.
• tLngMin_TextChanged(object sender, EventArgs e) : void
Verifica il valore dei minuti di longitudine.
• tLngSec_TextChanged(object sender, EventArgs e) : void
Verifica il valore dei secondi di longitudine.
• menuRoads_CheckedChanged(object sender, EventArgs e) : void
Visualizza/nasconde il layer relativo alla rete stradale.
• menuBorders_CheckedChanged(object sender, EventArgs e) : void
Visualizza/nasconde il layer relativo ai confini internazionali.
• menuTerrain_CheckedChanged(object sender, EventArgs e) : void
Visualizza il terreno in 2D/3D.
• menuNavControl_CheckedChanged(object sender, EventArgs e) : void
Visualizza/nasconde il navigation control.
• menuStatusBar_CheckedChanged(object sender, EventArgs e) : void
Visualizza/nasconde la status bar.
• menuGrid_CheckedChanged(object sender, EventArgs e) : void
Visualizza/nasconde una griglia rappresentante meridiani e paralleli.
• gotoProgressBar(float progress) : void
Aggiorna la barra di progresso.
• tAdd_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tAltAdd_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tLatDeg_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tLatMin_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tLatSec_KeyPress(object sender, KeyPressEventArgs e) : void
3. Progettazione
18
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tLngDeg_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tLngMin_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tLngSec_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• tAltCoord_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• menuInfo_Click(object sender, EventArgs e) : void
Apre il form informazioni.
• eventLatLng(float lat, float lng) : void
Apre il form emissioni.
• cbEnablePoint_CheckedChanged(object sender, EventArgs e) : void
Abilita/disabilita la navigazione sulla mappa.
La classe InfoForm presenta il metodo:
• bOkInfo_Click(object sender, EventArgs e) : void
Chiude il form.
La classe PointForm presenta i metodi:
• loadEmissionPeriods() : void
Carica la combobox con l’elenco dei periodi.
• bOkPoint_Click(object sender, EventArgs e) : void
Chiude il form.
• bSubmitQuery_Click(object sender, EventArgs e) : void
Carica la tabella relativa alle emissioni.
• dgvRegionalEmissionDesign() : void
Disegna la tabella relativa alle emissioni.
• dgvRegionalEmission_CellMouseClick(object sender,
DataGridViewCellMouseEventArgs e) : void
Disegna i grafici e carica la seconda scheda del form.
• loadDataGridViewdgvPeriod() : void
Carica la tabella relativa ai periodi.
3. Progettazione
19
• dgvPeriodDesign() : void
Disegna la tabella relativa ai periodi.
• loadDataGridViewdgvPeriodFacility() : void
Carica la tabella relativa ai report.
• dgvPeriodFacilityDesign() : void
Disegna la tabella relativa ai report.
• dgvPeriodFacility_CellMouseClick(object sender,
DataGridViewCellMouseEventArgs e) : void
Carica la terza scheda del form.
• tRange_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
• cbPeriod_KeyPress(object sender, KeyPressEventArgs e) : void
Sposta il cursore nel controllo successivo alla pressione del tasto Invio.
La classe DecimalToSexagesimal presenta i metodi:
• getLatDeg() : int
Restituisce il valore dei gradi di latitudine.
• getLatMin() : int
Restituisce il valore dei minuti di latitudine.
• getLatSec() : int
Restituisce il valore dei secondi di latitudine.
• getLngDeg() : int
Restituisce il valore dei gradi di longitudine.
• getLngMin() : int
Restituisce il valore dei minuti di longitudine.
• getLngSec() : int
Restituisce il valore dei secondi di longitudine.
Infine, per quanto riguarda il form principale, questo contiene una pagina html con uno
script per il caricamento e la gestione di Google Earth Plugin.
Sono presenti le funzioni:
• init()
Crea un’istanza di Google Earth Plugin.
3. Progettazione
20
• success(instance)
L’istanza di Google Earth Plugin è stata creata correttamente, inizializza il plugin.
• failure(errorCode)
L’istanza di Google Earth Plugin non è stata creata, restisuisce una stringa che
descrive l’errore.
• goToAddress(address, altitude)
Ricerca la locazione desiderata per indirizzo.
• goToCoordinates(latitude, longitude, altitude)
Ricerca la locazione desiderata per coordinate.
• geEventListener(kmlEvent)
Restituisce le coordinate del cursore sulla mappa, funzione legata all’evento
mousemove.
• timerStreamingPercent()
Restituisce la percentuale di caricamento dell’immagine attualmente inquadrata
dalla camera view.
• geEventPoint (kmlEvent)
Restituisce le coordinate del cursore sulla mappa, funzione legata all’evento
mouseup.
4. Interfaccia
21
4. Interfaccia
Nel presente capitolo si descrive l’interfaccia dell’applicativo, partendo dall’analisi dei
form che lo compongono, quindi dei rispettivi singoli componenti ed infine nel suo
complesso, mediante un esempio d’utilizzo.
4.1 Form principale
Il form principale contiene gli strumenti per consentire all’utente di selezionare il punto di
suo interesse.
Figura 7 - Form principale dell'applicativo
4. Interfaccia
22
La struttura prevede:
• Barra dei menu
• Barra di stato
• Dialog box per la ricerca tramite indirizzo
• Dialog box per la ricerca tramite coordinate geografiche
• Google Earth Plugin integrato
4.1.1 Barra dei menu
La barra dei menu è divisa in tre categorie File, View, ?. La prima rappresenta le funzioni
necessarie al caricamento ed alla chiusura dell’applicazione; la seconda fornisce un elenco
di strumenti d’ausilio alla navigazione; la terza riguarda le informazioni sull’applicativo.
• File
o New: riavvia l’applicazione ricaricando il plugin ed i valori di default;
o Exit: esce dall’applicazione;
• View
o Navigation Control: visualizza/nasconde il controllo mediante il quale è
possibile variare i parametri di zoom, tilt5 e azimut6;
o Status Bar: visualizza/nasconde il controllo che fornisce dati relativi alle
coordinate geografiche e all’altitudine del punto in corrispondenza del
puntatore sulla mappa e all’altezza della camera view;
o Grid: visualizza/nasconde una griglia rappresentante meridiani e paralleli la
cui definizione varia a seconda dello zoom;
o Roads: visualizza/nasconde il layer relativo alla rete stradale, maggiore è lo
zoom e migliore è il livello di dettaglio;
o Borders: visualizza/nasconde il layer relativo ai confini internazionali;
o Terrain: visualizza il territorio in 2D/3D;
• ?
o Info: apre il form contenente informazioni sulla versione dell’applicativo e
di Google Earth Plugin. 5 Tilt : distanza angolare compresa tra la verticale di un punto e la direzione della camera view. 6 Azimut : distanza angolare compresa tra la direzione del Nord e la direzione in cui cade la perpendicolare di un punto all’orizzonte, calcolata muovendosi in senso orario (cit. Wikipedia). Nello specifico, la distanza angolare tra la direzione del Nord e la direzione della camera view.
4. Interfaccia
23
Figura 8 - Barra dei menu
4.1.2 Barra di stato
La barra di stato mostra la latitudine, la longitudine e l’altitudine del punto sulla mappa in
corrispondenza del puntatore del mouse.
Inoltre contiene una barra di caricamento visibile in fase di download delle immagini.
Figura 9 - Barra di stato
4.1.3 Dialog box per la ricerca tramite indirizzo
Una delle possibilità che l’utente può sfruttare per la localizzazione di un punto è la ricerca
per indirizzo. Sono presenti controlli per prevedere input errati nel textbox relativo
all’altezza da terra della camera view, ovverosia maggiori di 10.000 km e negativi. Per
semplificare e velocizzare la ricerca, è possibile passare da un controllo al successivo
mediante la pressione del tasto Invio.
Figura 10 - Ricerca tramite indirizzo
4. Interfaccia
24
4.1.4 Dialog box per la ricerca tramite coordinate geografiche
In alternativa al primo metodo, l’utente può rilocare la camera view mediante l’inserimento
delle coordinate del punto d’interesse. Anche in questo caso sono presenti controlli che
verificano la validità dei valori inseriti dall’utente. Come nel caso precedente, l’altezza da
terra della camera view deve essere compresa tra 0 e 10.000 km, i campi relativi ai minuti
ed ai secondi possono contenere interi da 0 a 59, quello della latitudine da -90 a 90, della
longitudine da -180 a 180. Inoltre vengono sottoposte a verifica anche le coordinate nel
loro complesso, per evitare che l’utente inserisca, ad esempio, una latitudine 90° 24’55”:
sebbene siano validi i singoli valori, questa è maggiore di 90°. Analogamente a quanto
accade nel primo dialog box, l’utente può spostarsi di controllo in controllo premendo
Invio.
Figura 11 - Ricerca tramite coordinate geografiche
4.1.5 Google Earth Plugin integrato
Il componente principale del form è il plugin di Google Earth, su di esso l’utente ha la
facoltà di navigare e modificare parametri quali lo zoom e il tilt nello stesso modo in cui
può farlo nell’applicazione Google Earth. Una volta scelto il punto, per procedere alla
selezione di questo deve mettere la spunta sul checkbox a lato e quindi cliccare sulla
mappa.
4. Interfaccia
25
Figura 12 - Google Earth Plugin e il checkbox per procedere con la selezione del punto
4.2 Form informazioni
Nel form informazioni è possibile visualizzare la versione del programma, delle Javascript
API e del plugin di Google Earth attualmente installato sul pc.
Figura 13 - Form informazioni
4. Interfaccia
26
4.3 Form emissioni
Il form emissioni presenta i dati relativi alle emissioni inquinanti, ovvero i risultati delle
query sul database PRTR.
Figura 14 - Form emissioni
La struttura prevede una navigazione per schede:
• Regional emissions: contiene il dettaglio delle emissioni nella regione circolare
scelta dall’utente;
• Chemical info: presenta lo storico del prodotto chimico selezionato nella prima
scheda ed i report in cui è presente;
• Facility info: elenca le informazioni relative al report selezionato nella scheda
precedente.
4. Interfaccia
27
4.3.1 Scheda Regional emissions
Nella scheda Regional emissions è presente un dialog box in cui l’utente deve selezionare
da una combobox il periodo d’interesse ed inserire il raggio in chilometri della
circonferenza il cui centro è il punto scelto precedentemente sulla mappa. Il risultato della
query viene evidenziato in una tabella che elenca i prodotti chimici dichiarati nei report dei
complessi la cui locazione è all’interno dell’ideale circonferenza.
Per ogni prodotto si indica la quantità di emissioni (in kg) in:
• Aria
• Sottosuolo
• Acqua
• Terra
• Totale
In fondo alla scheda è visualizzato il grafico relativo al prodotto chimico del record
selezionato.
Figura 15 - Form emissioni, scheda Regional emissions
4. Interfaccia
28
4.3.2 Scheda Chemical info
Nella scheda Chemical info l’utente può avere informazioni aggiuntive sul prodotto
chimico selezionato tramite una tabella che ne rappresenta lo storico. Sono infatti elencati i
valori delle emissioni divisi per i periodi dei report in cui il prodotto compare. Il risultato
di tale query è rappresentato anche da un diagramma a colonne, al di sotto del quale
un’altra tabella elenca i report, visualizzandoli mediante il nome del complesso che lo ha
stilato ed il periodo a cui il contenuto fa riferimento.
Figura 16 - Form emissioni, scheda Chemical info
4.3.3 Scheda Facility info
La terza scheda, Facility info, evidenzia informazioni riguardanti il report selezionato
precedentemente, quindi sul complesso che lo ha stilato e sui valori delle emissioni del
prodotto chimico scelto dall’utente nella prima scheda.
Del complesso si forniscono:
4. Interfaccia
29
• Indirizzo
• Città
• Telefono
• Sito internet
• Nome della compagnia
Per quanto riguarda il prodotto chimico, il tipo di informazioni visualizzate ricalca quanto
visto finora, ovverosia i valori in kg delle emissioni nell’aria, nel sottosuolo, nell’acqua,
sulla terra e in totale.
Figura 17 - Form emissioni, scheda Facility info
4.4 Esempio d’utilizzo
L’utente vuole avere informazioni riguardo alle emissioni inquinanti nel raggio di 100 km
dall’edificio centrale dell’Università di Trieste, dati riferiti all’anno 2000.
4. Interfaccia
30
• Eseguito l’applicativo e caricatosi il plugin di Google Earth, nel primo dialog box
inserisce l’indirizzo, “P.le Europa, Trieste, Italia”, e l’altezza della camera view,
400 metri. Quindi preme il bottone Fly to!;
• Una volta caricata la mappa, mette la spunta sul checkbox e procede alla selezione
del punto con un click in corrispondenza dell’edificio centrale;
• Nella prima scheda del form che in seguito compare, seleziona “Year 2000” nella
combobox relativa al periodo, inserisce “100” nella textbox riferita al raggio e
preme Submit Query;
• La tabella sottostante elenca i dati riguardanti le emissioni, selezionando uno dei
record può accedere alle informazioni della seconda e terza scheda del form.
4.5 PRTR Google Earth Interface: requisiti per
l’installazione
L’applicativo presenta i seguenti requisiti per l’installazione:
• Risoluzione dello schermo minima: 1024 x 768;
• Google Earth Plugin7 versione 6 preinstallato, nel caso fosse installato anche
Google Earth8 assicurarsi che sia aggiornato alla stessa versione.
Per i requisiti di tali applicazioni si rimanda ai rispettivi siti;
• Microsoft Chart Controls for Microsoft .NET Framework 3.59;
• Microsoft .NET Framework.
7 Per il download: http://www.google.com/intl/it/earth/explore/products/plugin.html 8 Per il download: http://www.google.com/earth/index.html 9 Per il download: http://www.microsoft.com/downloads/en/details.aspx?FamilyId=130F7986-BF49-4FE5-9CA8-910AE6EA442C
5. Implementazione
31
5. Implementazione
In questo capitolo viene descritta l’implementazione dell’applicativo, il cui codice è stato
scritto per intero dal laureando eccezion fatta per le righe generate automaticamente
dall’IDE utilizzato. Qui di seguito vengono presentate nel dettaglio le parti salienti
dell’applicativo, si tralasciano quelle riguardanti l’aspetto grafico o la gestione delle
eccezioni mediante blocchi try-catch-finally o funzioni di minor interesse, per la lettura
delle quali si rimanda al listato sorgente.
5.1 Tecnologie software utilizzate
Dall’analisi dei vincoli di progetto si apprende che l’applicativo deve essere stand-alone ed
integrare le funzionalità di Google Earth, le cui API però nascono con l’obiettivo di
consentire agli sviluppatori di scrivere applicazioni web. Ne consegue la necessità di
scrivere due parti di codice distinte e quindi di integrarle mediante gli strumenti opportuni.
A tale scopo, si è scelto di utilizzare Javascript per quanto riguarda il plugin e C# per
l’applicativo stand-alone all’interno del quale il primo deve essere integrato. Quali
strumenti di supporto allo sviluppo sono stati utilizzati Notepad++ versione 5 e Visual
Studio 2008.
5.2 Codice
5.2.1 Caricamento di Google Earth Plugin
Il seguente codice è tratto dal file GEPlugin.html, include le istruzioni di caricamento del
plugin, le funzioni di inizializzazione e di gestione della camera view.
1. <html>
2. <head>
3. <title>Google Earth Plugin</title>
4. <script src="https://www.google.com/jsapi?key=ABCDEF"></script>
5. <script type="text/javascript">
5. Implementazione
32
6. var ge;
7. google.load("earth", "1");
8. google.load("maps", "2");
9.
10. function init() {
11. google.earth.createInstance('mapContainer', success,
failure);
12. }
13.
14. function success(instance) {
15. ge = instance;
16. [...]
17. window.external.jsInitSuccess(instance);
18. }
19.
20. function goToAddress(address, altitude) {
21. var geocoder = new google.maps.ClientGeocoder();
22. geocoder.getLatLng(address, function(point) {
23. if (point) {
24. var lookAt = ge.createLookAt('');
25. lookAt.set(point.y, point.x, altitude,
ge.ALTITUDE_RELATIVE_TO_GROUND, 0, 0, 0);
26. ge.getView().setAbstractView(lookAt);
27. }
28. });
29. }
30.
31. function goToCoordinates(latitude, longitude, altitude) {
32. var lookAt = ge.createLookAt('');
33. lookAt.set(latitude, longitude, altitude,
ge.ALTITUDE_RELATIVE_TO_GROUND, 0, 0, 0);
34. ge.getView().setAbstractView(lookAt);
35. }
36.
37. [...]
38.
39. </script>
40. </head>
41. <body onload="init()">
42. <div id="mapContainer" style="width: 100%; height: 100%;"></div>
43. </body>
44. </html>
5. Implementazione
33
Per poter caricare il plugin è necessario completare l’url con la propria Maps API Key
ottenibile gratuitamente sul sito, in questo caso è stata utilizzata una chiave d’esempio
“ABCDEF” (riga 4). Quindi vengono caricate le API di Google Earth (7) e di Google
Maps (8). Il metodo che consente di creare una nuova istanza del plugin (11) prevede tra i
suoi parametri il nome delle procedure da invocare nel caso l’operazione dovesse fallire o
avere successo (14). In quest’ultimo caso l’istanza viene passata al metodo esterno,
definito nell’applicativo, per permettere l’utilizzo dei metodi forniti dalle API anche in tale
sede. Le funzioni goToAddress (20) e goToCoordinates (31) vengono invocate
dall’esterno, si sottolinea l’utilizzo da parte della prima delle Google Maps API versione 2
per la creazione di un’istanza ClientGeocoder (21) e l’invocazione su questa del metodo
getLatLng (22).
5.2.2 Integrazione di Google Earth Plugin
Il codice che segue è presente nella classe MainForm dell’applicativo, si evidenziano le
parti relative all’integrazione del plugin all’interno del form principale.
1. String pluginUrl =
Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetModules()[0].Full
yQualifiedName) + "\\GEPlugin.html";
2. private IGEPlugin ge = null;
3.
4. private void MainForm_Load(object sender, EventArgs e)
5. {
6. [...]
7. wbGE.Navigate(pluginUrl);
8. wbGE.ObjectForScripting = this;
9. [...]
10. }
11.
12. public void jsInitSuccess(object instance)
13. {
14. [...]
15. ge = (IGEPlugin)instance;
16. [...]
17. }
5. Implementazione
34
Il controllo WebBrowser consente di inserire una pagina web in un form, quindi si presta
ottimamente per l’applicativo in questione. Il metodo Navigate carica il documento
indicato come parametro (riga 7), il cui percorso viene composto runtime tramite reflection
(1). L’operazione successiva è impostare l’oggetto accessibile dal codice contenuto nella
pagina web caricata nel WebBrowser, in questo caso il form stesso, tramite la proprietà
ObjectForScripting10 (8). Il metodo jsInitSuccess (12) è invocato dalla pagina una volta
creata una nuova istanza del plugin.
5.2.3 Chiamata ad un metodo esterno
Il seguente metodo, tratto anch’esso dalla classe MainForm, è legato all’evento pressione
del tasto Fly to! relativo al dialog box di ricerca per coordinate.
1. private void bGoCoord_Click(object sender, EventArgs e)
2. {
3. [...]
4. // validazione dei valori delle coordinate immessi dall’utente
5. // conversione dalle coordinate sessagesimali alle decimali
6. [...]
7. wbGE.Document.InvokeScript("goToCoordinates", new object[] { lat,
lng, alt });
8. }
10 Proprietà WebBrowser.ObjectForScripting : Utilizzare questa proprietà per abilitare la comunicazione tra
una pagina Web inserita nel controllo WebBrowser e l'applicazione che contiene il controllo WebBrowser.
La proprietà consente di integrare codice HTML dinamico (DHTML) con il codice dell'applicazione client.
L'oggetto specificato per questa proprietà è disponibile per lo script della pagina Web come oggetto
window.external, che è un oggetto DOM incorporato fornito per l'accesso all'host. È possibile impostare
questa proprietà su qualsiasi oggetto visibile a COM le cui proprietà e i cui metodi pubblici devono essere
resi disponibili al codice di script (cit. http://msdn.microsoft.com/it-it/library).
COM (Component Object Model) : interfaccia per componenti software, permette la comunicazione tra
processi e creazione dinamica di oggetti con qualsiasi linguaggio di programmazione che supporta questa
tecnologia.
5. Implementazione
35
Si tralasciano le righe di codice riguardanti il controllo di validità dei valori immessi
dall’utente e la conversione dalla notazione sessagesimale, presente nell’interfaccia, a
quella decimale, richiesta dalle API di Google, nel codice rappresentata dalle variabili lat
lng. Si sottolinea il metodo InvokeScript (riga 7) il cui compito è l’esecuzione di una
funzione definita in una pagina web, in questo caso nel documento integrato nel form
tramite il controllo WebBrowser. I parametri del metodo sono rispettivamente il nome della
funzione esterna ed un array di object rappresentante i parametri di quest’ultima.
5.2.4 Conversione di coordinate e aggiornamento della
posizione del puntatore
Nella barra di stato del form principale sono visualizzati i valori di latitudine, longitudine e
altitudine relativi alla posizione del puntatore sulla mappa. Sfruttando le Google Earth API
è possibile risalire alle coordinate del punto in formato decimale, per la loro
visualizzazione sull’interfaccia si richiede una conversione. Di seguito vengono presentate
e descritte le classi e le funzioni che entrano in gioco in questo contesto.
1. public class DecimalToSexagesimal
2. {
3. private int latDeg, latMin, latSec, lngDeg, lngMin, lngSec;
4.
5. public DecimalToSexagesimal(float lat, float lng)
6. {
7. latDeg = (int)Math.Truncate(lat);
8. latMin = (int)Math.Abs(Math.Truncate((lat - latDeg) * 60));
9. latSec = (int)Math.Truncate((Math.Abs((lat - latDeg) * 60) -
latMin) * 60);
10. lngDeg = (int)Math.Truncate(lng);
11. lngMin = (int)Math.Abs(Math.Truncate((lng - lngDeg) * 60));
12. lngSec = (int)Math.Truncate((Math.Abs((lng - lngDeg) * 60) -
lngMin) * 60);
13. }
14.
15. public int getLatDeg()
16. {
17. return latDeg;
18. }
19.
5. Implementazione
36
20. public int getLatMin()
21. {
22. return latMin;
23. }
24.
25. public int getLatSec()
26. {
27. return latSec;
28. }
29.
30. public int getLngDeg()
31. {
32. return lngDeg;
33. }
34.
35. public int getLngMin()
36. {
37. return lngMin;
38. }
39.
40. public int getLngSec()
41. {
42. return lngSec;
43. }
44. }
La classe DecimalToSexagesimal è di supporto all’applicativo, dal quale viene utilizzata
nel momento in cui è necessaria una conversione di rappresentazione di coordinate. I
parametri del costruttore sono i valori decimali della latitudine e della longitudine, per
quanto riguarda i metodi forniti dalla classe sono semplici get sui singoli componenti delle
coordinate in formato sessagesimale. Si nota che l’applicativo tratta i secondi come numeri
interi, tale semplificazione non rappresenta un’approssimazione rilevante per i successivi
calcoli delle distanze, data la formula utilizzata dal database per il calcolo. Questa infatti
basandosi sulla legge dei coseni sferici introduce errori di approssimazione considerando la
Terra come una sfera.
1. public void eventLatLngAlt(float lat, float lng, float alt)
2. {
3. DecimalToSexagesimal dts = new DecimalToSexagesimal(lat, lng);
5. Implementazione
37
4. [...]
5. ssLat.Text = ssLat.Text + dts.getLatDeg() + "° " + dts.getLatMin() +
"' " + dts.getLatSec() + "\"";
6. ssLng.Text = ssLng.Text + dts.getLngDeg() + "° " + dts.getLngMin() +
"' " + dts.getLngSec() + "\"";
7. ssAlt.Text = Math.Round(alt, 2).ToString() + " meters";
8. }
Il metodo eventLatLngAlt fa parte della classe MainForm, esso crea un oggetto di tipo
DecimalToSexagesimal ed un riferimento ad esso (riga 3), trasforma le coordinate ricevute
dall’esterno in formato decimale quindi le visualizza nelle label della barra di stato in
formato sessagesimale.
1. function success(instance) {
2. ge = instance;
3. [...]
4. google.earth.addEventListener(ge.getWindow(), "mousemove",
geEventListener);
5. [...]
6. }
7.
8. function geEventListener(kmlEvent) {
9. var latitude = kmlEvent.getLatitude();
10. var longitude = kmlEvent.getLongitude();
11. var altitude = kmlEvent.getAltitude();
12. window.external.eventLatLngAlt(latitude, longitude, altitude);
13. }
Il codice è tratto dal file GEPlugin.html, la pagina web caricata nel form. La funzione
geEventListener è chiamata dall’evento mousemove sulla mappa (riga 4) e a sua volta
chiama il metodo eventLatLngAlt della classe MainForm (12), oggetto reso disponibile
precedentemente tramite la proprietà ObjectForScripting e raggiungibile ora come oggetto
window.external.
5. Implementazione
38
5.2.5 Connessione al database ed esecuzione di una query
Il seguente metodo è tratto dalla classe PointForm e provvede al popolamento della
combobox con l’elenco dei periodi presenti sul database PRTR.
1. private void loadEmissionPeriods()
2. {
3. SqlConnection connection = new SqlConnection();
4. connection.ConnectionString =
ConfigurationSettings.AppSettings["connectionString"];
5. connection.Open();
6. String query = "SELECT * FROM ReportPeriod ORDER BY EndDate DESC";
7. SqlCommand command = new SqlCommand(query, connection);
8. SqlDataAdapter dataAdapter = new SqlDataAdapter(command);
9. DataTable tablePeriod = new DataTable();
10. dataAdapter.Fill(tablePeriod);
11. for (int i = 0; i < tablePeriod.Rows.Count; i++)
12. {
13. String period = tablePeriod.Rows[i]["Title"].ToString();
14. cbPeriod.Items.Add(period);
15. }
16. cbPeriod.SelectedIndex = 0;
17. [...]
18. connection.Close();
19. }
Per la connessione ad un database è necessaria una connection string che raccolga le
informazioni per la connessione, la cui formattazione dipende dal DBMS in cui risiede il
database, nel caso in questione SQL Server 2005. La stringa di connessione di
conseguenza prevede:
• Data Source
• Network Library
• Initial Catalog
• User Id
• Password
5. Implementazione
39
Si tratta rispettivamente di: indirizzo del server e porta sulla quale è in ascolto, protocollo
utilizzato per la connessione, nome del database e credenziali dell’utente. Per far sì che
queste informazioni possano venire modificate senza la necessità di ricompilare il progetto,
sono state inserite in un file di configurazione a cui il programma accede nel momento in
cui deve impostare la proprietà ConnectionString ad un riferimento di tipo SqlConnection
(riga 4). DataTable rappresenta una tabella di dati in memoria, e grazie al metodo fill
invocato su un oggetto di tipo SqlDataAdapter, il tramite fra Sql Server e la tabella locale, i
dati locali vengono modificati per farli corrispondere a quelli originali, ovverosia la tabella
viene riempita (10).
Qui di seguito il contenuto del file di configurazione.
1. <?xml version="1.0" encoding="utf-8" ?>
2. <configuration>
3. <appSettings>
4. <add key="connectionString" value="Data
Source=140.105.127.92,1433; Network Library=DBMSSOCN; Initial
Catalog=PRTR; User Id=********; Password=********;"/>
5. </appSettings>
6. </configuration>
5.2.6 Esecuzione di una stored procedure
Il seguente codice rappresenta il metodo lanciato alla pressione del tasto Submit Query sul
form emissioni. Compito del metodo è stabilire una connessione con il database ed
eseguire la stored procedure Statistics_GetByRegion.
1. private void bSubmitQuery_Click(object sender, EventArgs e)
2. {
3. SqlConnection connection = new SqlConnection();
4. connection.ConnectionString =
ConfigurationSettings.AppSettings["connectionString"];
5. connection.Open();
6. SqlCommand command = new SqlCommand("Statistics_GetByRegion",
connection);
5. Implementazione
40
7. command.CommandType = CommandType.StoredProcedure;
8. command.Parameters.Add("@LongitudeDeg", SqlDbType.Int).Value =
lngDeg;
9. command.Parameters.Add("@LongitudeMin", SqlDbType.Int).Value =
lngMin;
10. command.Parameters.Add("@LongitudeSec", SqlDbType.Int).Value =
lngSec;
11. command.Parameters.Add("@LatitudeDeg", SqlDbType.Int).Value =
latDeg;
12. command.Parameters.Add("@LatitudeMin", SqlDbType.Int).Value =
latMin;
13. command.Parameters.Add("@LatitudeSec", SqlDbType.Int).Value =
latSec;
14. command.Parameters.Add("@Range", SqlDbType.Float).Value =
Int32.Parse(tRange.Text);
15. command.Parameters.Add("@CultureCode", SqlDbType.NVarChar).Value =
"en-US";
16. command.Parameters.Add("@IDPeriod", SqlDbType.Int).Value =
tablePeriod.Rows[cbPeriod.SelectedIndex].ItemArray[0];
17. SqlDataAdapter dataAdapter = new SqlDataAdapter(command);
18. DataTable table = new DataTable();
19. dataAdapter.Fill(table);
20. [...]
21. connection.Close();
22. }
Invocato il costruttore di SqlCommand con il nome della stored procedure ed il riferimento
alla connessione (riga 6) ed impostata la proprietà CommandType su StoredProcedure (7),
si impostano i parametri richiesti. Nel caso specifico si utilizza la stored procedure
Statistics_GetByRegion, che richiede:
• Gradi di longitudine
• Minuti di longitudine
• Secondi di longitudine
• Gradi di latitudine
• Minuti di latitudine
• Secondi di latitudine
• Raggio della circonferenza d’interesse
• Codice della lingua utilizzata
5. Implementazione
41
• Periodo selezionato nella combobox
Per ulteriori informazioni sul database PRTR si rimanda alla documentazione tecnica dello
stesso.
6. Conclusioni
42
6. Conclusioni
6.1 Risultati ottenuti
I risultati ottenuti rispettano i vincoli di progetto discussi in fase di analisi. L’applicativo
stand-alone creato integra Google Earth Plugin e per la visualizzazione dei dati di
emissioni inquinanti si connette direttamente al database PRTR. La query sul database è
riferita ad una regione circolare di territorio per la selezione della quale all’utente è
richiesto un click sulla mappa per la determinazione del centro e l’inserimento manuale del
valore del raggio.
Tuttavia l’applicativo soffre di un bug presente nella struttura del database in questione. La
tabella Facility, contenente informazioni riguardo ai complessi, memorizza la dislocazione
sul territorio di tali infrastrutture con coordinate geografiche in formato sessagesimale,
dedicando tre campi distinti a gradi, minuti e secondi. Ciò introduce un errore nel momento
in cui si aggiunge un complesso le cui coordinate, longitudine o latitudine, sono incluse
nell’intervallo tra -0° 0’ 1” e -0° 59’ 59”. Nel campo riferito ai gradi infatti non viene
riconosciuto il segno dello zero il che comporta un’ambiguità nell’intervallo tra -0° 59’ 59”
e 0° 59’ 59”. La stored procedure Statistics_GetByRegion sfruttata dall’applicativo
presenta la stessa struttura e di conseguenza lo stesso bug.
6.2 Lavoro svolto
Qui di seguito sono riportati alcuni indici atti a quantificare il lavoro svolto:
Codice C#:
• Classi: 5
• Metodi: 62
• Righe di codice: 3261
Codice HTML / Javascript:
• Funzioni: 8
• Righe di codice: 85
6. Conclusioni
43
6.3 Sviluppi futuri
L’applicativo è stato progettato per consentire all’utente di selezionare sulla mappa il punto
e quindi di inserire manualmente il valore del raggio dell’ideale circonferenza d’interesse.
Un possibile sviluppo potrebbe essere la selezione della circonferenza direttamente sulla
mappa similmente a quanto accade nei programmi di editing di immagini, mediante
trascinamento e modifica delle dimensioni della figura con il solo utilizzo del mouse.
Tale sviluppo potrebbe essere integrato dalla possibilità di selezionare aree poligonali di
territorio in cui l’utente dovrebbe scegliere cliccando sulla mappa i punti che andrebbero a
costituire i vertici. Si rivelerebbero necessari algoritmi per verificare che egli abbia
disegnato una spezzata chiusa e che il poligono non sia intrecciato. Imporre la convessità
costituirebbe un vincolo troppo limitativo, basti pensare ad esempio ad un utente che si
ponesse l’obiettivo di visualizzare le emissioni sul territorio italiano, per la cui selezione
dovrebbe avere la possibilità di tracciare un poligono concavo.
Per quanto riguarda le Google Earth API, queste forniscono gli strumenti per sviluppare
ulteriormente l’applicativo dal punto di vista del disegno del poligono e della
visualizzazione dei risultati.
Una possibile linea di sviluppo potrebbe riguardare il database PRTR, nell’applicativo
potrebbero essere integrate ulteriori query al fine di consentire all’utente un’analisi delle
emissioni una volta scelto il periodo o la compagnia. Per quanto riguarda la funzione
GetDistance, utilizzata dalla già citata stored procedure Statistics_GetByRegion e
responsabile del calcolo delle distanza tra due punti, potrebbe essere migliorata al fine di
fornire una precisione maggiore. Al momento è implementato l’algoritmo della legge dei
coseni sferici, sostituire questo con la formula di Haversine11 o la formula di Vincenty12
migliorerebbe la precisione del calcolo, a discapito però di una maggiore complessità
matematica.
Sotto l’aspetto della connessione al database PRTR, in fase di stesura dei requisiti si è
stabilito che questa dovesse essere diretta e locale ovverosia, nel caso in questione, che
l’applicativo si dovesse connettere direttamente al database dall’interno della rete d’ateneo.
Un possibile sviluppo dell’applicativo potrebbe estendere l’utilizzo dello stesso anche
all’esterno della rete universitaria. In questo caso si rivelerebbe necessaria l’introduzione di
11 http://en.wikipedia.org/wiki/Haversine_formula 12 http://en.wikipedia.org/wiki/Vincenty%27s_formulae
6. Conclusioni
44
un web service che faccia da tramite fra l’applicativo ed il database allo scopo di aggirare il
problema del firewall, il quale blocca il traffico sulla porta utilizzata dal primo per
procedere alla connessione.
7. Bibliografia
45
7. Bibliografia
• Nagel C. Evjen B. Glynn J. Skinner M. Watson K. Jones A., C# 2005 - Guida per
lo Sviluppatore, Editore Ulrico Hoepli Milano, 2006
• PRTR technical documentation
• http://msdn.microsoft.com/it-it/library
• http://javascript.html.it/guide/leggi/25/guida-javascript-di-base/
• http://code.google.com/intl/it-IT/apis/earth/documentation/
• http://code.google.com/apis/ajax/playground/
• http://programmazione.html.it/guide/leggi/41/guida-uml/
