A practical introduction to

Transcription

1 Institut Géographique National Laboratoire COGIT Lab OGRS 2009 A practical introduction to Eric Grosso et Bénédicte Bucher p.1/36

2 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 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 Exercice 3 : Visualisation des données...21 Correction de l'exercice Exercice 4 : Création des objets «Salle» dans la base de données...23 Correction de l'exercice Exercice 5 : Création et manipulation d'une carte topologique...25 Correction de l'exercice 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 p.2/36

3 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 : 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. p.3/36

4 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. p.4/36

5 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 : Architecture p.5/36

6 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 p.6/36

7 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. p.7/36

8 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. p.8/36

9 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). p.9/36

10 <?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 " 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». p.10/36

11 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" p.11/36

12 default-connection="false" platform="oracle9i" jdbc-level="2.0" driver="oracle.jdbc.driver.oracledriver" protocol="jdbc" subprotocol="oracle" 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é. p.12/36

13 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 nom_table p.13/36 psql nom_base_donnees

14 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 : p.14/36

15 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». p.15/36

16 La console apparaît. Cliquer ensuite sur «SQL to Java» : Sélectionner la table «departements» : que vous voulez p.16/36 charger sous GeOxygene, ici

17 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) p.17/36

18 - 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) p.18/36

19 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 " 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> p.19/36

20 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é. p.20/36

21 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 : p.21/36

22 p.22/36

23 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 * nbsalles 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 p.23/36

24 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 numerosalle 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; p.24/36

25 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 * collection une carte topologique */ public static CarteTopo creecartetopo( FT_FeatureCollection<BdTopoTrRoute> collection) { //Initialisation d'une nouvelle CarteTopo CarteTopo cartetopo = new CarteTopo("Graphe"); p.25/36

26 //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». p.26/36

27 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. p.27/36

28 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 : p.28/36

29 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. p.29/36

30 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 * public void initialize (PlugInContext context) throws Exception { context.getfeatureinstaller().addmainmenuitem(this,new String[]{ "GeOxygene", "Departements"}, "Affichage", false, null, null); } /**partie du code relative à 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; } } p.30/36

31 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" p.31/36

32 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». p.32/36

33 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» : p.33/36

34 - 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. p.34/36

35 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 p.35/36

36 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» : p.36/36