Tutorial - OGRS 2009

Institut Géographique National
Laboratoire COGIT
Lab OGRS 2009
A practical introduction to
Eric Grosso et Bénédicte Bucher
GeOxygene : tutoriel OGRS 2009
p.1/36
IGN / COGIT
Table des matières
INTRODUCTION....................................................................................................................3
PREREQUIS...........................................................................................................................3
RESSOURCES DE LA FORMATION.....................................................................................3
PRESENTATION RAPIDE DE GEOXYGENE........................................................................5
UTILISATION DU PLUGIN GEOXYGENE POUR OPENJUMP.............................................6
EXERCICES...........................................................................................................................7
Exercice 1 : Création d'une structure de données à stocker....................................................7
Correction de l'exercice 1........................................................................................................8
Exercice 2 : Chargement de données sous GeOxygene à partir de fichiers au format
« SIG » : utilisation de la commande « shp2pgsql » de PostgreSQL-PostGIS et de la
console GeOxygene..............................................................................................................13
Correction de l'exercice 2......................................................................................................13
Exercice 3 : Visualisation des données.................................................................................21
Correction de l'exercice 3......................................................................................................21
Exercice 4 : Création des objets « Salle » dans la base de données .....................................23
Correction de l'exercice 4......................................................................................................23
Exercice 5 : Création et manipulation d'une carte topologique............................................25
Correction de l'exercice 5......................................................................................................25
Exercice 6 : Manipulation des outils d'appariement.............................................................27
ANNEXE 1 : Création et restauration d'une base de données spatiales PostGIS..........28
ANNEXE 2 : Visualisation à l'aide d'OpenJump...............................................................30
ANNEXE 3 : Pour aller plus loin – Création et manipulation de données –....................33
GeOxygene : tutoriel OGRS 2009
p.2/36
IGN / COGIT
INTRODUCTION
Ce lab a pour objectif de guider les participants dans la prise en main et l'utilisation
de GeOxygene à travers différents exercices. Ce document est présenté comme
suit :
− Présentation rapide de GeOxygene,
− Utilisation d'outils GeOxygene sous environnement OpenJUMP,
− Exercices pour prendre en main la plate-forme,
− Annexes pour les personnes qui souhaitent aller plus loin.
Le présent document est libre de diffusion.
PREREQUIS
Ce document fait suite au document d'installation de GeOxygene disponible à
l'adresse suivante :
http://oxygene-project.sourceforge.net/geoxygene/docs/geoxygene-installation-1.0.pdf
Il est ainsi supposé qu'une installation complète de la plate-forme ait été réalisée
avant de travailler avec le présent document.
RESSOURCES DE LA FORMATION
Ressources de la formation
Les ressources de la formation sont contenues dans le répertoire
« /home/ogrslabs/22_GeOxygene ». Ce répertoire contient les répertoires suivants :
-
« documentation », contient la documentation relative au projet,
-
« donnees », contient les données utilisées durant les exercices de travaux
pratiques,
-
« ecl_workspace », est le répertoire utilisé comme espace de travail pour
Eclipse dans ce lab,
-
« logiciels », contient les composants logiciels relatif à GeOxygene.
Documentation
Les documents numériques suivants sont fournis :
- geoxygene-appariement-1.0.pdf : documentation des outils d'appariement de
données proposés sous GeOxygene,
-
geoxygene-carte_topo-1.0.pdf : documentation des outils de création et
manipulation de cartes topologiques sous GeOxygene,
-
geoxygene-guide_utilisateur-1.0.pdf : guide utilisateur de GeOxygene,
-
geoxygene-installation-1.0.pdf : documentation relative à l'installation pas à
pas de GeOxygene sous environnement Windows.
GeOxygene : tutoriel OGRS 2009
p.3/36
IGN / COGIT
Données
Quatre jeux de données sont proposés, sous différentes formes.
Deux jeux de données routières, servant à la création et manipulation de cartes
topologiques et aux outils d'appariement :
-
donnees_appariement/BDTOPO/RESEAU_ROUTIER/troncon_route_bdtopo.shp
donnees_appariement/BDCARTO/ RESEAU_ROUTIER/troncon_route_bdcarto.shp
Un jeu de données fourni sous conditions par l'IGN : GEOFLA-dep-L93-SF.ZIP. Pour
plus d'informations sur ces conditions ou l'obtention de ces données, consulter le
point 7 de la documentation « Geoxygene : installation pas à pas ».
Une base de données PostGIS préétablie qui permet d'utiliser facilement (i.e. sans
aucune configuration particulière de GeOxygene) l'outil carte topologique et les outils
d'appariement : geoxygene_backup.backup.
GeOxygene : tutoriel OGRS 2009
p.4/36
IGN / COGIT
PRESENTATION RAPIDE DE GEOXYGENE
Introduction
GeOxygene vise à fournir un cadre ouvert de développement, compatible avec les
spécifications édictées par l'Open Geospatial Consortium (OGC) et l'ISO, pour la
conception et le déploiement d'applications s'appuyant sur des données
géographiques (SIG). GeOxygene est diffusée selon les termes de la licence LGPL
(GNU Lesser General Public License). GeOxygene est basée sur Java et les
technologies open source. Elle met à disposition des utilisateurs un modèle de
données objet et extensible (permettant la modélisation des objets géographiques,
de la géométrie, de la topologie et des métadonnées) compatible avec les
spécifications de l'OGC et les standards de l'ISO concernant l'information
géographique. Les données sont stockées dans un SGBD relationnel pour permettre
un accès rapide et sûr au système. Néanmoins, les utilisateurs n'ont pas à manipuler
les données au travers de SQL : Ils modélisent leurs applications en UML et les
codent en Java. Le "mapping" entre les environnements objet et relationnel est
assuré par un composant open source, OJB. Les fichiers de "mapping" pour le
stockage flexible des objets géographiques dans Oracle et PostGIS sont fournis.
GeOxygene est disponible sur le site : http://oxygene-project.sourceforge.net/
Architecture
GeOxygene : tutoriel OGRS 2009
p.5/36
IGN / COGIT
UTILISATION
OPENJUMP
DU
PLUGIN
GEOXYGENE
POUR
Afin de créer un pont entre les projets GeOxygene et OpenJump et de bénéficier des
développements réalisés dans le cadre du projet OpenJUMP, une bibliothèque sous
forme de plug-in GeOxygene pour OpenJUMP a été créé. Cette bibliothèque permet
notamment l'utilisation de l'environnement OpenJump pour afficher des données
GeOxygene. Ce plug-in est disponible sous licence GPL 2 sur le site du projet
GeOxygene (http;//sourceforge.net/oxygene-project).
Cette partie a pour objectif de montrer les applications GeOxygene portées sur la
plate-forme OpenJUMP.
Lancement d'OpenJUMP
Pour lancer la version d'OpenJump contenant le plug-in GeOxygene, il suffit de
cliquer sur le lanceur « geoxygene_openjump » situé sur le Bureau (Desktop).
Données
Les
données
situées
dans
les
sous-répertoires
du
répertoire
/home/ogrslabs/22_GeOxygene/donnees/donnees_appariement_carte_topo/ seront
ici utilisées.
Manipulation de la carte topologique
Pour utiliser et manipuler la carte topologique (création d'une carte topologique,
cartographie des nœuds topologiques valués, détection des faces circulaires),
procéder comme suit :
− Charger les données routières «troncon_route_bdtopo.shp » contenues dans le
répertoire « BDTOPO/RESEAU_ROUTIER » (File > Open File...),
− Lancer l'un des outils proposés via le menu suivant :
> GeOxygene
> Topological map
> Topology creation
> Circular faces detection
> Mapping of nodes degrees
Mise en œuvre de l'outil d'appariement
Pour utiliser et manipuler l'outil d'appariement, procéder comme suit :
− Charger les données routières « troncon_route_bdtopo.shp » contenues dans
le répertoire « BDTOPO/RESEAU_ROUTIER » (File > Open File...),
− Charger les données routières « troncon_route_bdcarto.shp » contenues dans
le répertoire « BDCARTO/RESEAU_ROUTIER » (File > Open File...),
− Lancer l'outil d'appariement via le menu suivant :
> GeOxygene
> Data matching
> Network data matching
GeOxygene : tutoriel OGRS 2009
p.6/36
IGN / COGIT
EXERCICES
Exercice 1 : Création d'une structure de données à stocker
•
Créer une structure d'accueil GeOxygene permettant de pouvoir manipuler la
classe « Salle » modélisée comme suit :
Cette structure d'accueil doit comprendre la classe « objet » Java (manipulation
Java), la table « salle » (manipulation du SGBD – langage SQL –), et le fichier
correspondant au pont relationnel objet « repository_salle.xml » (manipulation de
OJB – langage XML –).
Tous les composants sont à créer manuellement afin de comprendre les différents
niveaux d'implémentation de GeOxygene, à savoir code Java, table PostgreSQLPostGIS et mapping OJB. Par la suite (voir prochain exercice), la création est
réalisée de manière automatique.
GeOxygene : tutoriel OGRS 2009
p.7/36
IGN / COGIT
Correction de l'exercice 1
Au niveau du langage objet (Java) :
Pour plus de détails, se référer au manuel utilisateur GeOxygene page 6.
La classe Salle hérite de la classe FT_Feature ; de fait, elle hérite d'un identifiant (id
de type « int ») et d'une géométrie (geom de type « GM_Object »). Seuls restent à
créer les trois autres attributs relatifs à la classe « Salle », à savoir « nom »,
« numero » et « superficie ». A partir de la création de ces derniers, on crée soit
manuellement soit dynamiquement (à l'aide d'Eclipse : menu « Source » puis
« Generate Getters and Setters… ») les Getters et Setters correspondants. La classe
« Salle » s'écrit comme suit :
package fr.ign.cogit.geoxygene.tutorial.data;
import fr.ign.cogit.geoxygene.feature.FT_Feature;
/** Modélisation possible d'une salle */
public class Salle extends FT_Feature {
private String nom;
public String getNom() { return this.nom; }
public void setNom(String nom) { this.nom = nom; }
private int numero;
public int getNumero() { return this.numero; }
public void setNumero(int numero) { this.numero = numero; }
private double superficie;
public double getSuperficie() { return this.superficie;}
public void setSuperficie(double superficie) { this.superficie = superficie; }
}
Au niveau du Système de Gestion de Bases de Données (PostgreSQL/PostGIS) :
Créer tout d'abord la table correspondante à la classe « salle » grâce à la syntaxe
SQL suivante :
CREATE TABLE salle (
cogitid INTEGER PRIMARY KEY,
nom VARCHAR(50),
numero INTEGER,
superficie DOUBLE PRECISION
);
Créer ensuite la géométrie associée à cette table via la syntaxe SQL suivante :
SELECT AddGeometrycolumn ('','salle','the_geom','-1','POLYGON',2);
La syntaxe SQL peut s'exécuter depuis pgAdmin (Outils puis Editeurs de requêtes).
Au niveau du pont relationnel-objet :
Pour plus de détails, se référer au manuel utilisateur GeOxygene page 6.
GeOxygene : tutoriel OGRS 2009
p.8/36
IGN / COGIT
Il reste enfin à créer le pont relationnel-objet, i.e. le fichier de mapping OJB. Pour ce
faire, il est nécessaire d'écrire la correspondance entre une classe objet (Java) et
une table du SGBD :
<class-descriptor class="CheminClasseJava" table="NomTable" >
et la correspondance entre chaque attribut de cette classe objet et de cette table en
précisant le type de l'attribut (INTEGER, DOUBLE, VARCHAR, etc.) :
<field-descriptor name="nomAttributClasseJava" column="nomAttributTable" jdbc-type="TYPE" />
Ainsi, dans le présent exemple, créer le fichier de mapping « repository_salle.xml »
comme suit dans le répertoire « mapping/ojb1/tutorial » :
<class-descriptor class="fr.ign.cogit.geoxygene.tutorial.data.Salle" table="salle" >
<field-descriptor
name="id"
column="cogitid"
jdbc-type="INTEGER"
primarykey="true"
autoincrement="true"/>
<field-descriptor name="nom" column="nom" jdbc-type="VARCHAR" />
<field-descriptor name="numero" column="numero" jdbc-type="INTEGER" />
<field-descriptor name="superficie" column="superficie" jdbc-type="DOUBLE" />
<field-descriptor
name="geom"
column="THE_GEOM"
jdbc-type="STRUCT"
conversion="fr.ign.cogit.geoxygene.datatools.ojb.GeomGeOxygene2Dbms" />
</class-descriptor>
Remarque :
Le type « STRUCT » est utilisé dans le cadre d'un attribut dont le type est défini par
l'utilisateur, comme par exemple ici avec la géométrie. Il est de fait nécessaire de
fournir
en
supplément
un
convertisseur,
ici
la
classe « fr.ign.cogit.geoxygene.datatools.ojb.GeomGeOxygene2Dbms ».
Afin que le système prenne en compte le fichier de mapping repository_salle.xml, il
est nécessaire d'ajouter les informations suivantes dans le fichier « repository.xml »
(qui se trouve dans le répertoire « mapping/ojb1/tutorial »), fichier qui centralise les
informations relatives au pont relationnel-objet (voir informations du fichier page
suivante).
GeOxygene : tutoriel OGRS 2009
p.9/36
IGN / COGIT
<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a sample metadata repository for the
Apache ObJectRelationalBridge (OJB) System.
Use this file as a template for building your own mappings.
-->
<!-- doctype definition
By default we are using a local DTD that is expected to reside
in the same directory as this repository.xml file.
If you intend to validate your repository.xml against
the public dtd at the Apache site, please replace the string
"repository.dtd"
by the public adress
"http://db.apache.org/ojb/dtds/1.0/repository.dtd".
In this case validation will only work if the machine you
run your application on can connect to the internet!
-->
<!DOCTYPE descriptor-repository PUBLIC
"-//Apache Software Foundation//DTD OJB Repository//EN"
"repository.dtd"
[
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
]>
database SYSTEM "repository_database.xml">
internal SYSTEM "repository_internal.xml">
tableaux SYSTEM "repository_tableaux.xml">
bdc_tr_route SYSTEM "repository_bdc_tr_route.xml">
bdt_tr_route SYSTEM "repository_bdt_tr_route.xml">
geo SYSTEM "repository_geo.xml">
salle SYSTEM "repository_salle.xml">
<descriptor-repository version="1.0" isolation-level="read-uncommitted"
proxy-prefetching-limit="50">
<!-- fichier de mapping internes a OJB INDISPENSABLE -->
&internal;
<!-- parametres de la connection au SGBD-->
&database;
<!-- exemple classes geographiques
<!-- &geo; -->
-->
<!-- donnees routieres -->
&bdc_tr_route;
&bdt_tr_route;
<!-- salle -->
&salle;
</descriptor-repository>
Enfin, afin de pouvoir charger ces données, il est nécessaire de configurer les
fichiers de mapping (relatif à OJB).
A chaque lancement d’application propre à GeOxygene nécessitant une connexion à
une base de données spatiales (PostGIS, Oracle Spatial), le fichier OJB.properties
est chargé. Ce fichier se trouve à la racine de GeOxygene, dans le répertoire « src ».
GeOxygene : tutoriel OGRS 2009
p.10/36
IGN / COGIT
Configuration du fichier OJB.properties
La variable « repositoryFile », permet de définir le chemin du principal fichier de
mapping, «repository.xml » et de charger ainsi les différents fichiers de mapping vers
lequel il pointe, comme par exemple le fichier « repository_database.xml » qui
permet de configurer la connexion à une base de données.
La variable « repositoryFile » doit donc être modifiée de la manière suivante :
repositoryFile= ./mapping/ojb1/tutorial/repository.xml
Éditer
maintenant
le
fichier
« repository_database.xml »
du
dossier
« mapping/ojb1/tutorial/ » pour que celui-ci corresponde à la base de données
« geoxygene » créée dans PostGIS.
Configurer le en éditant son contenu de la manière suivante :
<!-- DEFINIR ICI LES PARAMETRES DE CONNECTION AU SGBD -->
<jdbc-connection-descriptor
jcd-alias="postgis"
default-connection="true"
platform="PostgreSQL"
jdbc-level="4.0"
driver="org.postgresql.Driver"
protocol="jdbc"
subprotocol="postgresql"
dbalias="//localhost:5432/geoxygene"
username="postgres"
password="postgres"
eager-release="false"
batch-mode="true"
useAutoCommit="2"
ignoreAutoCommitExceptions="false" >
<connection-pool maxActive="21" validationQuery="" />
<sequence-manager
className="org.apache.ojb.broker.util.sequence.SequenceManagerInMemoryImpl
" />
</jdbc-connection-descriptor>
<jdbc-connection-descriptor
jcd-alias="ORACLE_ALIAS"
GeOxygene : tutoriel OGRS 2009
p.11/36
IGN / COGIT
default-connection="false"
platform="Oracle9i"
jdbc-level="2.0"
driver="oracle.jdbc.driver.OracleDriver"
protocol="jdbc"
subprotocol="oracle"
dbalias="thin:@HOSTNAME:1521:SID"
username="USERNAME"
password="PASSWORD"
eager-release="false"
batch-mode="true"
useAutoCommit="2"
ignoreAutoCommitExceptions="false" >
<connection-pool maxActive="21" validationQuery="" />
<sequence-manager
className="org.apache.ojb.broker.util.sequence.SequenceManagerInMemoryImpl
" />
</jdbc-connection-descriptor>
GeOxygene est maintenant configuré.
GeOxygene : tutoriel OGRS 2009
p.12/36
IGN / COGIT
Exercice 2 : Chargement de données sous GeOxygene à partir de
fichiers au format « SIG » : utilisation de la commande
« shp2pgsql » de PostgreSQL-PostGIS et de la console
GeOxygene
•
Charger au sein du SGBD PostgreSQL-PostGIS des données géographiques
(comportant une géométrie) contenues dans un fichier au format ESRI
Shapefile, à l'aide de la commande « shp2pgsql » (pour plus de détails, se
référer au document « GeOxygene : installation pas à pas »).
Information : Le fichier de données géographiques a utilisé est le fichier
dep_france_dom.shp
contenu
dans
le
répertoire
« /home/ogrslabs/22_GeOxygene/donnees/GEOFLA-dep-L93-SF». Le nom
utilisé pour la table sera « departements ».
•
Utiliser ensuite la console GeOxygene afin de générer automatiquement les
fichiers de mapping et java correspondants.
Cet exercice est utile pour la compréhension du chargement de données au format
ESRI Shapefile et pour la compréhension du maniement de la console GeOxygene.
Correction de l'exercice 2
Chargement des données au sein de PostgreSQL-PostGIS :
Prérequis : On suppose que la base nommée « geoxygene » a été créée dans le
SGBD PostgreSQL-PostGIS et que les fonctions liées à PostGIS ont été activées
pour cette dernière. Si ce n'est pas le cas, se référer à la partie « Chargement de
données au format shape sous PostgreSQL-PostGIS » du document « GeOxygene :
installation pas à pas ».
Le chargement de données s'effectue comme suit :
- lancer un terminal et taper ensuite la commande suivante dans la console ainsi
ouverte :
shp2pgsql -D -I /home/ogrslabs/22_GeOxygene/donnees/GEOFLA-dep-L93SF/dep_france_dom.shp departements | psql geoxygene postgres
Rappel de la commande générique utilisée :
shp2pgsql
-D
nom_utilisateur
-I
shapefile
GeOxygene : tutoriel OGRS 2009
nom_table
p.13/36
|
psql nom_base_donnees
IGN / COGIT
Pour plus d'informations sur les différentes options de la commande « shp2pgsql »,
taper simplement « shp2pgsql » dans une console :
La table « departements » est créée et le rapport suivant apparaît :
GeOxygene : tutoriel OGRS 2009
p.14/36
IGN / COGIT
Utilisation de la console GeOxygene - génération automatique des fichiers de
mapping et java correspondants :
Le lancement de la console GeOxygene s'effectue depuis la classe Java relative à la
console située dans le package fr.ign.cogit.geoxygene.appli. Pour lancer la Console
depuis Eclipse, cliquer sur le bouton droit de la souris lorsque le curseur est sur la
classe Console.java puis choisir « Run As – Java Application ».
GeOxygene : tutoriel OGRS 2009
p.15/36
IGN / COGIT
La console apparaît. Cliquer ensuite sur « SQL to Java » :
Sélectionner la table
« departements » :
que
GeOxygene : tutoriel OGRS 2009
vous
voulez
p.16/36
charger
sous
GeOxygene,
IGN / COGIT
ici
Cliquer sur OK puis remplir de la manière suivante :
Cliquer sur OK. La console retourne ce message :
Constater ce qui a été généré par la console :
- Un fichier de mapping (mapping.ojb1.tutorial.repository_departements.xml) :
Information : pour que ce fichier apparaisse, effectuer un rafraichissement du dossier
(clic droit sur le dossier puis « Refresh » ou F5 sur le dossier)
GeOxygene : tutoriel OGRS 2009
p.17/36
IGN / COGIT
- Une classe Java (fr.ign.cogit.geoxygene.tutorial.data.Departements ) :
Information : pour que ce fichier apparaisse, effectuer un rafraichissement du dossier
(clic droit sur le dossier puis « Refresh » ou F5 sur le dossier)
GeOxygene : tutoriel OGRS 2009
p.18/36
IGN / COGIT
Il faut maintenant faire pointer le fichier central des fichiers de mapping
(repository.xml)
vers
le
fichier
de
mapping
généré,
à
savoir
« repository_departements.xml » :
<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a sample metadata repository for the
Apache ObJectRelationalBridge (OJB) System.
Use this file as a template for building your own mappings.
-->
<!-- doctype definition
By default we are using a local DTD that is expected to reside
in the same directory as this repository.xml file.
If you intend to validate your repository.xml against
the public dtd at the Apache site, please replace the string
"repository.dtd"
by the public adress
"http://db.apache.org/ojb/dtds/1.0/repository.dtd".
In this case validation will only work if the machine you
run your application on can connect to the internet!
-->
<!DOCTYPE descriptor-repository PUBLIC
"-//Apache Software Foundation//DTD OJB Repository//EN"
"repository.dtd"
[
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
<!ENTITY
]>
database SYSTEM "repository_database.xml">
internal SYSTEM "repository_internal.xml">
tableaux SYSTEM "repository_tableaux.xml">
bdc_tr_route SYSTEM "repository_bdc_tr_route.xml">
bdt_tr_route SYSTEM "repository_bdt_tr_route.xml">
geo SYSTEM "repository_geo.xml">
salle SYSTEM "repository_salle.xml">
departements SYSTEM "repository_departements.xml">
<descriptor-repository version="1.0" isolation-level="read-uncommitted"
proxy-prefetching-limit="50">
<!-- fichier de mapping internes a OJB INDISPENSABLE -->
&internal;
<!-- parametres de la connection au SGBD-->
&database;
<!-- exemple classes geographiques
<!-- &geo; -->
-->
<!-- donnees routieres -->
&bdc_tr_route;
&bdt_tr_route;
<!-- salle -->
&salle;
<!-- departements -->
&departements;
</descriptor-repository>
GeOxygene : tutoriel OGRS 2009
p.19/36
IGN / COGIT
Générer ensuite les identifiants COGIT (COGITID) à partir de la console (Manage
Data) en choisissant la table que vous voulez traiter, ici « departements »:
Le chargement des données est maintenant terminé.
GeOxygene : tutoriel OGRS 2009
p.20/36
IGN / COGIT
Exercice 3 : Visualisation des données
•
Charger les données de l'exercice précédent (sous forme d'objets java) et les
visualiser.
Correction de l'exercice 3
Visualisation à l'aide du visualisateur GeOxygene :
Créer
la
classe
Java
« VisuGeOxygene »
fr.ign.cogit.geoxygene.tutorial.visu :
dans
le
package
package fr.ign.cogit.geoxygene.tutorial.visu;
import fr.ign.cogit..geoxygene.tutorial.data.Departements;
import fr.ign.cogit.geoxygene.datatools.Geodatabase;
import fr.ign.cogit.geoxygene.datatools.ojb.GeodatabaseOjbFactory;
import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
import fr.ign.cogit.geoxygene.util.viewer.ObjectViewer;
/**Classe qui permet la visualisation de la carte des départements français */
public class VisuGeOxygene {
/**Méthode qui lance l'application*/
public static void main(String[] args) {
//Création d'une nouvelle connexion
Geodatabase geoDB = GeodatabaseOjbFactory.newInstance();
//Chargement des données de la classe Departements
FT_FeatureCollection<Departements> ftfc =
geoDB.loadAllFeatures(Departements.class);
//Affichage des données dans le visualisateur GeOxygene
ObjectViewer viewer = new ObjectViewer();
viewer.addFeatureCollection(ftfc, "departements francais");
}
}
Lancer ensuite l'application depuis Eclipse issue de la classe créée (cliquer sur le
bouton droit de la souris lorsque le curseur est sur la classe java puis choisir « Run
As – Java Application »). S'affiche alors :
GeOxygene : tutoriel OGRS 2009
p.21/36
IGN / COGIT
GeOxygene : tutoriel OGRS 2009
p.22/36
IGN / COGIT
Exercice 4 : Création des objets « Salle » dans la base de données
•
Pour éviter toute frustration inutile à la suite de l'exercice 1, créer les salles
modélisées avec une géométrie de telle manière qu'il est possible de les
visualiser  Ces salles doivent être stockées dans la base de données.
Correction de l'exercice 4
Dans
le
package
ConstructeurSalle.
fr.ign.cogit.geoxygene.tutorial.salle,
créer
la
classe
package fr.ign.cogit.geoxygene.tutorial.salle;
import org.apache.log4j.Logger;
import fr.ign.cogit.geoxygene.tutorial.data.Salle;
import fr.ign.cogit.geoxygene.datatools.Geodatabase;
import fr.ign.cogit.geoxygene.datatools.ojb.GeodatabaseOjbFactory;
import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPosition;
import fr.ign.cogit.geoxygene.spatial.coordgeom.DirectPositionList;
import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_LineString;
import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_Polygon;
/** Méthodes possibles de construction de salles */
public class ConstructeurSalle {
static Logger logger = Logger.getLogger(ConstructeurSalle.class);
public static void main(String[] args) {
CreationSalles(10, "Réunion");
}
/** Construction de salles
*
* @param nbSalles
* @param nomGenerique
*/
public static void CreationSalles(int nbSalles, String nomGenerique) {
//Création d'une connexion à la base
logger.info("Création de la connexion");
Geodatabase geodb = GeodatabaseOjbFactory.newInstance();
logger.info("OK...");
//Ouverture d'une transaction pour la base définie
logger.info("Ouverture de la transaction");
geodb.begin();
logger.info("OK...");
//Création de 10 salles avec une géométrie (polygone carré)
for (int i = 1; i <= nbSalles ; i++) {
//Création d'un nouvel objet "salle"
logger.info("Création d'une nouvelle salle");
Salle salle = new Salle();
salle.setNumero(i); //affectation du numéro
salle.setNom(nomGenerique + " " + i); //affectation du nom
salle.setGeom(creationGeometrie(i)); //affectation de la géométrie
GeOxygene : tutoriel OGRS 2009
p.23/36
IGN / COGIT
salle.getGeom().setCRS(-1); //affectation du système de projection
salle.setSuperficie(salle.getGeom().area()); //affectation (par calcul) de
la superficie
//L'objet "salle" est rendu persistant dans la base
geodb.makePersistent(salle);
}
//Commit de la transaction (sauvegarde les objets créés et ferme la connexion)
logger.info("Commit");
geodb.commit();
logger.info("OK...");
}
/** Création de la géométrie d'une salle en fonction de son numéro
* @param numeroSalle
* @return un polygone
*/
public static GM_Polygon creationGeometrie(int numeroSalle) {
//Création des points de la salle
DirectPosition dp1 = new DirectPosition(((numeroSalle-1) * 10), 0);
DirectPosition dp2 = new DirectPosition((numeroSalle * 10), 0);
DirectPosition dp3 = new DirectPosition((numeroSalle * 10), 10);
DirectPosition dp4 = new DirectPosition(((numeroSalle-1) * 10), 10);
//Ajout des points de manière ordonnée dans une liste de points
DirectPositionList dpl = new DirectPositionList();
dpl.add(dp1);
dpl.add(dp2);
dpl.add(dp3);
dpl.add(dp4);
dpl.add(dp1);
//Construction d'une ligne fermée (premier point = dernier) à partir d'une liste de
points
GM_LineString lineString = new GM_LineString(dpl);
//Retourne un polygone construit à partir de la ligne fermée
return new GM_Polygon(lineString);
}
}
Lancer ensuite le “main”.
Créer une classe permettant la visualisation de ces données, à l'iamge de la classe
VisuGeOxygene qui a permis d'afficher les départements;
GeOxygene : tutoriel OGRS 2009
p.24/36
IGN / COGIT
Exercice 5 : Création et manipulation d'une carte topologique
Regarder
les
exemples
situés
fr.ign.cogit.geoxygene.tutorial.exemple.cartetopo.
dans
le
package
Dans ce package, lancer les mains des classes suivantes pour démonstration :
− TestCarteTopoFaceCirculaire
− TestCarteTopoNoeudValue
•
Créer une nouvelle carteTopologique qui va affecter aux arcs un poids (ici la
vitesse) en fonction de la catégorie du tronçon de route considéré :
• 130 km/h si de catégorie « Autoroute »,
• 90 km/h si de catégorie « Nationale »,
• 80 km/h si de catégorie « Départementale »,
• 50 km/h si de catégorie « Route nommée »,
• 30 km/h si de catégorie « Autre route ».
Pour ce faire, utiliserUtiliser les tronçons de route BDTOPO présents dans la
base (bdt_tr_route), correspondant à la classe fr.ign.cogit.geoxygene.tutorial.
Correction de l'exercice 5
Dans le package fr.ign.cogit.geoxygene.tutorial.cartetopo,
CarteTopoFactoryArcPondere.
créer
la
classe
package fr.ign.cogit.geoxygene.tutorial.cartetopo;
import java.util.Iterator;
import org.apache.log4j.Logger;
import fr.ign.cogit.geoxygene.tutorial.data.BdTopoTrRoute;
import fr.ign.cogit.geoxygene.contrib.cartetopo.Arc;
import fr.ign.cogit.geoxygene.contrib.cartetopo.CarteTopo;
import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
import fr.ign.cogit.geoxygene.feature.Population;
import fr.ign.cogit.geoxygene.spatial.coordgeom.GM_LineString;
public class CarteTopoFactoryArcPondere {
static Logger logger = Logger.getLogger(CarteTopoFactoryArcPondere.class);
/**Création d'une carte topologique à partir d'une FT_FeatureCollection
* avec affectation des poids des arcs en fonction de la catégorie de la route
*
* @param collection
* @return une carte topologique
*/
public static CarteTopo creeCarteTopo(
FT_FeatureCollection<BdTopoTrRoute> collection) {
//Initialisation d'une nouvelle CarteTopo
CarteTopo carteTopo = new CarteTopo("Graphe");
GeOxygene : tutoriel OGRS 2009
p.25/36
IGN / COGIT
//Récupération des arcs de la carteTopo
Population<Arc> arcs = carteTopo.getPopArcs();
Iterator<BdTopoTrRoute> it = (Iterator<BdTopoTrRoute>)
collection.getElements().iterator();
BdTopoTrRoute feature;
Arc arc;
//Import des arcs de la collection dans la carteTopo et valuation de ceux-ci
//en fonction de la nature des tronçons
while (it.hasNext()) {
feature = it.next();
//Création d'un nouvel élément
arc = arcs.nouvelElement();
//affectation de la géométrie de l'objet issu de la collection
//à l'arc de la carteTopo
arc.setGeometrie((GM_LineString) feature.getGeom());
//Instanciation de la relation entre l'arc créé et l'objet
//issu de la collection
arc.addCorrespondant(feature);
//Pondération des arcs
String categorie = feature.getCategorie();
if (categorie.equalsIgnoreCase("Autoroute")) arc.setPoids(130);
else if (categorie.equalsIgnoreCase("Nationale")) arc.setPoids(90);
else if (categorie.equalsIgnoreCase("Départementale")) arc.setPoids(80);
else if (categorie.equalsIgnoreCase("Route nommée")) arc.setPoids(50);
else if (categorie.equalsIgnoreCase("Autre route")) arc.setPoids(30);
}
logger.info("Nombre d'arcs créés : " + carteTopo.getPopArcs().size());
//Création des noeuds manquants
logger.info("Création des noeuds manquants");
carteTopo.creeNoeudsManquants(2);
//Création de la topologie Arcs Noeuds
logger.info("Création de la topologie Arcs Noeuds");
carteTopo.creeTopologieArcsNoeuds(2);
return carteTopo;
}
}
Créer un plug-in OpenJump pour visualiser le résultat.
Ajouter la ligne correspondante à ce plugin dans le fichier « workbenchproperties.xml ».
GeOxygene : tutoriel OGRS 2009
p.26/36
IGN / COGIT
Exercice 6 : Manipulation des outils d'appariement
Regarder
les
exemples
situés
fr.ign.cogit.geoxygene.exemple.appariement.
dans
le
package
Changer les paramètres afin de modifier le comportement du processus et tester le
processus en lançant le main de la classe TestAppariementRoutier.
GeOxygene : tutoriel OGRS 2009
p.27/36
IGN / COGIT
ANNEXE 1 : Création et restauration d'une base de données
spatiales PostGIS
Créer une base PostGIS appelée « geoxygene ». Pour ce faire, se référer au manuel
« GeOxygene : Installation pas à pas », à la rubrique Création d'une base de
données spatiales – point 3.l, page 19, et suivre les instructions.
Charger maintenant la base de données PostGIS préétablie, évoquée dans le
paragraphe « Données », à savoir geoxygene_backup.backup.
Pour ce faire, lancer l'outil de gestion pgAdmin III dont un lanceur se trouve sur le
bureau (Desktop).
Cliquer (clic droit) sur la base « geoxygene » et choisir la fonction « Restaurer », tel
qu'illustré ci-dessous.
L'interface suivante apparaît :
GeOxygene : tutoriel OGRS 2009
p.28/36
IGN / COGIT
Choisir le nom de fichier suivant :
/home/ogrslabs/22_GeOxygene/donnees/geoxygene_backup.backup
Cliquer ensuite sur OK.
Rafraîchir la base de données geoxygene (touche F5) et constater que les tables
« bdc_tr_route » et « bdt_tr_route » ont été créées. Ces tables sont relatives aux
données routières précédemment décrites.
GeOxygene : tutoriel OGRS 2009
p.29/36
IGN / COGIT
ANNEXE 2 : Visualisation à l'aide d'OpenJump
Si le plug-in GeOxygene pour OpenJUMP (ou ses sources) et les bibliothèques
OpenJUMP sont ajouté au projet GeOxygene sous Eclipse, il est possible de
visualiser des données GeOxygene à l'aide d'OpenJUMP de la manière suivante.
L'exemple présenté vise à afficher les départements, de manière similaire à
l'exercice 2.
Créer
la
classe
Java
« VisuOpenJump »
fr.ign.cogit.geoxygene.tutorial.visu :
dans
le
package
package fr.ign.cogit.geoxygene.tutorial.visu;
import java.awt.Color;
import com.vividsolutions.jump.workbench.plugin.PlugInContext;
import com.vividsolutions.jump.workbench.ui.plugin.FeatureInfoPlugIn;
import fr.ign.cogit.appli.commun.interfaceJump.UtilJump;
import fr.ign.cogit.geoxygene.tutorial.data.Departements;
import fr.ign.cogit.geoxygene.datatools.Geodatabase;
import fr.ign.cogit.geoxygene.datatools.ojb.GeodatabaseOjbFactory;
import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
/**Classe qui permet la visualisation de la carte des départements français
* sous OpenJump */
public class VisuOpenJump extends FeatureInfoPlugIn {
/**initialisation de l'interface dans un menu OpenJump : ajout d'un menu
* GeOxygene/Departements/Affichage*/
@Override
public void initialize (PlugInContext context) throws Exception {
context.getFeatureInstaller().addMainMenuItem(this,new String[]{
"GeOxygene",
"Departements"},
"Affichage", false, null, null);
}
/**partie du code relative à l'exécution*/
@Override
public boolean execute(PlugInContext context) throws Exception {
//Création d'une nouvelle connexion
Geodatabase geoDB = GeodatabaseOjbFactory.newInstance();
//Chargement des données de la classe Departements
FT_FeatureCollection<Departements> ftfc =
geoDB.loadAllFeatures(Departements.class);
//Affichage des données en rose sous OpenJump
UtilJump.afficheCollection(context, ftfc, "France","Départements",Color.pink);
return true;
}
}
GeOxygene : tutoriel OGRS 2009
p.30/36
IGN / COGIT
Remarquer que ce fichier se compose de deux parties. La première (« initialize ») est
relative à l'initialisation d'un menu dans OpenJump (GeOxygene – Departements –
Affichage), la seconde au programme qui sera lancé à l'aide du menu créé.
Afin que cette classe soit prise en compte au lancement d'OpenJump, il est
nécessaire d'ajouter la ligne suivante dans le fichier « workbench-properties.xml »
relatif à OpenJump (répertoire mapping/ojb1/formation/) :
<plug-in>fr.ign.cogit.geoxygene.tutorial.visu.VisuOpenJump</plug-in>
Lancer ensuite OpenJump. Pour ce faire :
Lancer l'application associée à la classe Java « JUMPWorkbench.java »
(« com.vividsolutions.jump.workbench.JUMPWorkbench.java »). Pour ce faire,
parcourir la librairie « openjump-workbench-1.3.jar », qui se trouve dans
« Referenced Libraries » sous Eclipse, jusqu'à trouver la classe concernée puis
cliquer à l'aide du bouton droit sur cette dernière. Choisir « Run As » puis « Run
configurations… »
Apparaît alors l'interface suivante :
Cliquer sur New : une nouvelle application nommée « JUMPWorkbench » apparaît
alors. Cliquer sur l'onglet « (x) = Arguments ».
Ecrire les paramètres suivants dans « Program arguments » :
-properties "./mapping/ojb1/tutorial/workbench-properties.xml"
GeOxygene : tutoriel OGRS 2009
p.31/36
IGN / COGIT
Il est également possible d'ajouter des arguments pour la machine virtuelle Java
dans « VM arguments » tel que:
-Xms256M -Xmx1024M
Cliquer sur Apply puis Run.
OpenJumpP se lance.
Cliquer sur le menu « GeOxygene – Departements – Affichage ».
GeOxygene : tutoriel OGRS 2009
p.32/36
IGN / COGIT
ANNEXE 3 : Pour aller plus loin – Création et manipulation de
données –
•
Créer un attribut supplémentaire nommé « superficie » pour les départements,
le calculer et le rendre persistant dans la table « departements » de votre
base de données.
Correction
Au niveau du Système de Gestion de Bases de Données :
Créer tout d'abord la colonne « superficie »
« departements » grâce à la syntaxe SQL suivante :
correspondant
à
la
table
ALTER TABLE departements add superficie DOUBLE PRECISION ;
La syntaxe SQL peut s'exécuter depuis pgAdmin (Outils puis Editeurs de requêtes).
Il est également possible de créer cette même colonne à l'aide des outils interactifs
proposés par pgAdmin. Pour ce faire, procéder comme suit :
- clic droit sur la table « departements » puis « Ajouter un objet – Ajouter une
colonne » :
GeOxygene : tutoriel OGRS 2009
p.33/36
IGN / COGIT
- l'interface suivante apparaît. Remplir comme ci-dessous puis cliquer sur « OK » :
Remarque :
Les attributs sont à écrire de préférence en caractère alpha et en minuscules.
Au niveau du langage objet (Java) :
Il est maintenant nécessaire d'ajouter l'attribut « superficie » au niveau objet. Pour ce
faire,
ajouter
les
lignes
de
code
suivantes
dans
la
classe
« fr.ign.cogit.geoxygene.tutorial.data.Departements ».
private double superficie;
public double getSuperficie() { return this.superficie; }
public void setSuperficie(double superficie) { this.superficie = superficie; }
Au niveau du pont relationnel-objet :
Il reste enfin à ajouter la correspondance dans le fichier de mapping OJB
« repository_departements.xml ». Pour ce faire, ajouter la ligne suivante :
<field-descriptor name="superficie" column="superficie" jdbc-type="DOUBLE" />
Dans le cas présent, il est inutile d'ajouter quoique ce soit dans le fichier de mapping
« repository.xml » puisque « repository_departements.xml » est déjà pris en compte.
GeOxygene : tutoriel OGRS 2009
p.34/36
IGN / COGIT
Remarque importante :
Lors de la création de la table « departements », une contrainte sur la géométrie des
objets est créée :
CONSTRAINT
enforce_geotype_the_geom
'MULTIPOLYGON'::text OR the_geom IS NULL)
CHECK
(geometrytype(the_geom)
=
Cette contrainte oblige les objets de la table « departements » à avoir une géométrie
de type « MULTIPOLYGON » ou une géométrie nulle. Or certains objets créés sont
de type « POLYGON » et ne vérifient donc pas la contrainte. Il s'agit d'un bug dans la
commande « shp2pgsql ». Ce dernier a été identifié et est en passe d'être résolu
dans les prochaines versions.
Dès lors que la table doit être modifiée, il devient obligatoire soit de supprimer cette
contrainte, soit de la rendre plus « souple », en donnant la possibilité aux objets
d'être soit de type géométrique « MULTIPOLYGON » soit de type « POLYGON ».
Faire ici le choix de la seconde solution et de fait, exécuter la requête suivante
suivante :
ALTER TABLE departements DROP CONSTRAINT enforce_geotype_the_geom;
ALTER TABLE departements
ADD CONSTRAINT enforce_geotype_the_geom CHECK
(geometrytype(the_geom)
=
'POLYGON'::text
OR
geometrytype(the_geom)
=
'MULTIPOLYGON'::text OR the_geom IS NULL);
Créer
maintenant
la
classe
fr.ign.cogit.geoxygene.tutorial.departement.DepartementAlgorithmie permettant de
calculer la superficie des départements et de remplir la colonne « superficie » de la
table « departements » :
package fr.ign.cogit.geoxygene.tutorial.departement;
import java.util.Iterator;
import fr.ign.cogit.geoxygene.tutorial.data.Departements;
import fr.ign.cogit.geoxygene.datatools.Geodatabase;
import fr.ign.cogit.geoxygene.datatools.ojb.GeodatabaseOjbFactory;
import fr.ign.cogit.geoxygene.feature.FT_FeatureCollection;
public class DepartementAlgorithmie {
public static void main(String[] args) {
calculSuperficieDepartements();
}
/** Calcul la superficie des départements contenus dans la base
* et affecte cette valeur dans la table "departements"
*/
public static void calculSuperficieDepartements() {
//Création d'une nouvelle connexion
Geodatabase geoDB = GeodatabaseOjbFactory.newInstance();
//Ouverture d'une transaction relative à la connexion
geoDB.begin();
//Chargement des données de la classe Departements
GeOxygene : tutoriel OGRS 2009
p.35/36
IGN / COGIT
FT_FeatureCollection<Departements> ftfc =
geoDB.loadAllFeatures(Departements.class);
//Calcul et instanciation de l'attribut superficie
Iterator<Departements> it = ftfc.getElements().iterator();
while(it.hasNext()){
Departements departement = it.next();
departement.setSuperficie(departement.getGeom().area());
}
//Commit et ferme la transaction
geoDB.commit();
}
}
Lancer l'application et constater le résultat en visualisant la table « departements » :
GeOxygene : tutoriel OGRS 2009
p.36/36
IGN / COGIT