pauline ferrouillat hind zineddine · macaulay drive craigiebuckler aberdeen ab15 8qh uk rapport...

Institut Supérieur d’Informatique deModélisation et de leurs Applications

Campus des CézeauxBP 10 12563 173 AUBIERE cedexFRANCE

The Macaulay LandUse Institute Research

Macaulay DriveCraigiebucklerAberdeenAB15 8QHUK

Rapport d'ingénieurprojet de deuxième année

Filière Calcul et Modélisation Scientifiques

Intégration du calcul de voisinage dans un outil de distribution d’espèces

Présenté par : Pauline FERROUILLATHind ZINEDDINE

Date de la soutenance : 24 mars 2011Responsable ISIMA : Vincent BARRAResponsable laboratoire : Alessandro GIMONA

Remerciements

Nous souhaitons remercier M. Alessandro GIMONA pour sa disponibilité et sa patience tout au long du projet. Bien que nous ayons rencontré des difficultés à communiquer avec M. GIMONA, il a toujours pris le temps de nous répondre et de nous expliquer à nouveau jusqu'à ce que nous nous comprenions.

Nous tenons aussi à remercier Benoît PIC, étudiant à l’I.S.I.M.A. qui a également effectué son stage de 2ème année sur l’outil de distributions d’espèces. Il a pris le temps de nous expliquer ce qu’il se rappelait et en particulier, les différents dossiers et leurs contenus.

Nos remerciements sont également destinés à M. Vincent BARRA, notre responsable I.S.I.M.A., à M. Christophe GOUINAUD pour l’installation des bibliothèques nécessaires à notre projet ainsi qu’à toutes les personnes qui nous ont aidées dans l’avancement de notre projet.

Table des figuresFigure 1 : Emplacement du Macaulay Institute Écosse................................................2Figure 2 : Contenu du dossier RIPS_v2........................................................................5Figure 3 : Contenu du dossier “ComputeNeighbors”....................................................6Figure 4 : Logo de GTK.................................................................................................7Figure 5 : Squelette de la fonction GTK+ "g_signal_connect"......................................7Figure 6 : Logo du langage R........................................................................................7Figure 7 : Logo d’Unfuddle............................................................................................8Figure 8 : Logo de Subversion......................................................................................8Figure 9 : Nos dossiers sur Unfuddle............................................................................8Figure 10 : Notre espace de travail sur Google Documents.........................................9Figure 11 : Logo de Google Documents.......................................................................9Figure 12 : Rédaction du rapport sur Google Documents..........................................10Figure 13 : Lancement du calcul des voisins avant nos modifications.......................10Figure 14 : Lancement du calcul des voisins..............................................................11Figure 15 : Algorithmes de principe sur une partie de “readFileofPoint” ...................11Figure 16 : Aperçu du fichier “neighbours.res”............................................................12Figure 17 : Aperçu du fichier “coordinatesfile.temp”...................................................12Figure 18 : Algorithme de principe pour représenter graphiquement les voisins.......12Figure 19 : Aperçu du fichier "full.csv".........................................................................13Figure 20 : Représentation graphique du fichier des voisins......................................13Figure 21 : Lancement du logiciel RIPS......................................................................14Figure 22 : Page 1 de l’interface graphique de RIPS..................................................15Figure 23 : Page 2 de l’interface graphique de RIPS..................................................16Figure 24: Page 3 de l’interface graphique de RIPS...................................................17

Résumé

Lors de notre projet de 2ème année à l'I.S.I.M.A., nous avons collaboré avec le Macaulay Land Use Research Institute (M.L.U.R.I.). Le M.L.U.R.I. est un institut de recherche en écologie et en environnement.

M. Alessandro GIMONA, chercheur au M.L.U.R.I., travaille sur l'influence des facteurs climatiques et terrestres sur la répartition géographique des espèces animales. C'est sur le logiciel de calcul de ces influences nommé RIPS que nous avons effectué notre projet.

Durant notre projet, nous avons continué de développer le logiciel RIPS codé par Gilles ROLHION et Benoît PIC. Nous avons intégré le calcul des voisins dans l'interface graphique du logiciel RIPS.

A l'aide du langage C, nous avons d'abord enlevé les paramètres, que l'utilisateur devait calculer, du programme de calcul des voisins. Ensuite, nous avons copié, avec le langage système, le fichier répertoriant les voisins dans les dossiers de l'interface graphique pour que l'utilisateur ne le fasse pas à la main. En outre au moyen du langage R, nous avons montré graphiquement à l'utilisateur les données des espèces sur lesquels il travaille et les voisins de chaque donnée. Puis avec la bibliothèque GTK+, nous avons demandé à l'utilisateur de saisir ses paramètres dans l'interface graphique nécessaire à l'exécution du calcul des voisins. Enfin, il reste à coder l'exécution ce calcul.

Mots clés : RIPS, calcul des voisins et interface graphique

AbstractDuring our project of 2nd year at the I.SI.M.A., we collaborated with the Macaulay

Land Use Research Institute (M.L.U.R.I.). The M.L.U.R.I is an research institute in ecology and environment.

M. Alessandro GIMONA, M.LU.R.I researcher, works on the influence of climatic and land factors on the geographic distribution of the species. It is on the software calculation of those influences called RIPS that we made our project.

At the time our project, we continued develop the program RIPS encoded by Gilles ROLHION and Benoît PIC. We integrated the neighbours calculation in the GUI of the program RIPS.

Using the language C, we first removed the parameters that the user should calculate, from the neighbours calculation program. Secondly, we copied, with the system language, the file listing neighbours in the GUI program in order to that the user does not do. Thirdly by using the language R, we showed graphically for the user the data species on which he worked and the neighbours of each data. Fourthly with the GTK+ library, we asked the user to capture his parameters in the GUI for the execution of neighbours calculation. Finally, it remains to encode the execution of this calculation.

Keywords : RIPS, neighbours calculation and GUI

Table des matières

Remerciements

Résumé

Abstract

Glossaire

Introduction.....................................................................................................................1

1. Introduction de l’étude...............................................................................................2 1.1. Présentation du Macaulay Land Use Research Institute......................................2 1.2. Présentation du projet RIPS..................................................................................3 1.3. Présentation de notre projet .................................................................................3

2. Matériels et méthodes utilisés..................................................................................5 2.1. Architecture du logiciel existant.............................................................................5 2.2. Matériels utilisés par le logiciel et pour notre travail sur le projet.........................7 2.3. Changements réalisés sur RIPS.........................................................................10

3. Résultats obtenus.....................................................................................................18 3.1. Effet des modifications sur le calcul des voisins.................................................18 3.2. Effet sur les modifications de l’interface graphique.............................................20 3.3. Améliorations possibles.......................................................................................21

Conclusion....................................................................................................................22

Références bibliographiques

Glossaire

GTK+ : C'est un ensemble de bibliothèques logicielles écrites en langage C, c'est-à-dire un ensemble de fonctions informatiques, permettant de réaliser des interfaces graphiques dans de nombreux langages de programmation (C, C++, Pascal, PHP, Java et ainsi de suite), cette bibliothèque a été développée originellement pour les besoins du logiciel de traitement d'images GIMP.

Fichier exécutable : C'est un fichier contenant un programme et identifié en tant qu'exécutable par le système d'exploitation ; le chargement d'un tel fichier entraîne la création d'un processus dans le système et l'exécution de son programme.

Langage R : C'est un langage de programmation et un environnement mathématique utilisés pour le traitement de données et l'analyse statistique.

Langage système : C'est un langage qui permet la codification des fonctions basiques d'un système d'exploitation.

Linux : C'est un système d'exploitation.

RIPS : C'est un logiciel, développé au sein du Macaulay Land Use Research Institute, pour estimer l'influence des facteurs climatiques et terrestres sur la répartition géographique d'espèces animales ; il a été développé durant les stages de Gilles ROLHION et Benoît PIC sous la direction d'Alessandro GIMONA.

SFTP (Secure File Transfer Protocol) : C'est un protocole de communication sécurisé destiné à l'échange de fichiers sur un réseau TCP/IP, c'est-à-dire qu'il permet, depuis un ordinateur, de copier des fichiers vers un autre ordinateur du réseau, d'alimenter un site web, ou encore de supprimer ou de modifier des fichiers sur cet autre ordinateur.

UNIX : C'est le nom d'un système d'exploitation multitâche et multi-utilisateur créé en 1969, il a donné naissance à une famille de systèmes d'exploitation dont Linux.

Voisin : Dans notre projet, nous avons des données sur des espèces animales ; ces données contiennent des coordonnées géographiques, alors pour chacune de ces coordonnées, nous cherchons les quatre autres coordonnées les plus proches géographiquement et nous appelons ces coordonnées les voisins.

Introduction

Dans le cadre de notre deuxième année à l'I.S.I.M.A., nous avons choisi un projet en collaboration avec le Macaulay Land Use Research Institute (M.L.U.R.I.), institut de recherche en écologie et en environnement, situé à Aberdeen en Écosse. C'est pourquoi notre tuteur M. Alessandro GIMONA, chercheur au M.LU.R.I, géographe aussi bien dans les systèmes aquatiques que terrestres, nous a demandé de poursuivre le développement d'un logiciel estimant l’influence de facteurs climatiques et terrestres sur la répartition géographique des espèces.

Jusqu'à présent, ce logiciel nommé RIPS a été développé durant les stages de deux élèves de l'I.S.I.M.A., Gilles ROLHION et Benoît PIC. Gilles ROLHION a conçu le logiciel RIPS. Il a développé une version du logiciel fonctionnant sur Linux et une autre sur UNIX. Mais pour les deux versions, le corps des programmes est identique. La version sous UNIX fonctionne également avec le logiciel Condor, qui permet de lancer différents processus sur les différentes machines connectées au réseau du M.L.U.R.I. Benoît PIC a ajouté au logiciel l'estimation de l’influence des facteurs climatiques et terrestres en fonction des zones géographiques. Il a travaillé sur la version Linux.

Le but de notre projet était d'intégrer le calcul des voisins effectué pour chaque coordonnée géographique dans l'interface graphique du logiciel RIPS. Nous avons aussi travaillé sur la version Linux de RIPS. Ainsi, il est plus facile pour l'utilisateur d’exécuter le calcul des voisins. Maintenant, il peut lancer le calcul des voisins à partir de l'interface graphique de RIPS. Nous avons aussi aidé l'utilisateur a visualisé ses données à l'aide d'un graphique.

Dans un premier temps, nous vous présenterons le M.L.U.R.I, le logiciel RIPS et notre projet (rédigé par Hind). Dans un second temps, nous introduirons le matériel que nous avions à disposition et les méthodes mises en place (rédigé par Pauline). Dans un troisième temps, nous analyserons les résultats obtenus (rédigé par Pauline).

Pauline FERROUILLAT & Hind ZINEDDINE 1

1. Introduction de l’étude

1.1. Présentation du Macaulay Land Use Research Institute

Fondé en 1930, le Macaulay Land Use Research Institute est un centre international œuvrant pour la recherche sur l’environnement et les conséquences sociales de l’utilisation des terres rurales. Il joue également le rôle de consultant à la demande d’entreprises ou d’administrations. Son siège social, situé à Aberdeen, en Écosse, a été ouvert en 1993 (voir Figure 1). Trois dépendances, , y sont rattachées, Glasaugh, Hartwood et Sourhope. Le but de la recherche interdisciplinaire concernant l’environnement et les sciences sociales est d’encourager la protection des ressources naturelles et le développement durable des communautés rurales ; tout en essayant de faire évoluer les règles internationales de développement en territoire rural dans le bon sens.

Avec un revenu annuel provenant de ses activités de recherche et de consultant dépassant les 11 millions de

livres sterling, le Macaulay Land Use Research Institute est la plus importante organisation de recherche interdisciplinaire de ce type en Europe.

Le Macaulay Land Use Research Institute est l’un des principaux sous-traitant dans le domaine de la recherche environnementale du gouvernement écossais. Environ 75% du revenu du centre provient de ces programmes de recherches ; qui sont principalement axées sur l’utilisation du territoire et l’intendance rurale. L’institut possède environ 300 employés et étudiants (250 employés pour 50 étudiants) de plus de 25 pays différents. Il possède également un large panel d’organisations partenaires.

L’institut est divisé en cinq grands groupes : - Gestion des bassins versants : Compréhension des différents processus

relationnels entre les écosystèmes (plaines, montagnes et côtes) ;- Écologie : recherche sur la protection, la valorisation et la gestion de la

biodiversité pour le bien de la société ;


Figure 1 : Emplacement du Macaulay Institute

Écosse

- Système intégré de l’utilisation des sols : Compréhension des processus sociaux, économiques et biophysiques qui influent sur l’écosystème dans le but d’élaborer une politique de gestion durable des terres ;

- Recherche socio-économique : Recherche sur l’économie, la gouvernance et les attitudes rurales et en particulier sur le développement durable ;

- Sols : Recherche transversale sur la nature des sols ; cette recherche aborde les domaines de la microbiologie, de la biologie moléculaire, de la minéralogie ou encore de la physique des plantes.

1.2. P résentation du projet RIPS

Le projet RIPS (ce n'est pas notre projet le logiciel RIPS) concerne le pôle Écologie qui s’emploie au soutien et à la promotion de la biodiversité. Ses deux grandes lignes directrices sont :

- l’étude de l’impact des interactions entre les producteurs et les consommateurs influant sur la dynamique des espèces animales et végétales ;

- l’étude de l’impact du changement climatique, de la pollution, de la gestion des terres, et des politiques gouvernementales sur la biodiversité.

C’est ici que se situe le cadre du projet RIPS. En effet, le but consiste en la création d’un logiciel permettant l’estimation, à partir de données, de l’influence de paramètres climatiques et terrestres sur des espèces d’oiseau.

Par exemple, la compréhension de l’absence d’une espèce d’oiseau dans un espace géographique donné est intéressante sur le plan scientifique. L’analyse des données permet d’en déterminer les causes. La finalité du logiciel est donc, à partir d’un fichier de données, de mettre en évidence les éléments les plus influents sur cet évènement, tout en gardant à l’esprit que les paramètres sont différents suivant les espèces.

1.3. Présentation d e notre projet

Nous avons téléchargé sur le serveur du M.LU.R.I trois programmes existants : deux programmes utilitaires (je ne pense pas que le mot « utilitaire » est approprié mais je ne sais pas quoi proposé à la place) et un programme principal nommé RIPS :

- le programme utilitaire de génération de données artificielles- le programme utilitaire de génération des voisins qui doit être lancé avant RIPS- le programme principal RIPS


La tâche principale consistait à changer l’interface utilisateur de RIPS pour faire en sorte que le programme de génération des voisins puisse être appelé à partir de l’interface. Il a donc fallu ajouter un onglet permettant de faire cela.

Nous devions également effectuer des changements dans le programme utilitaire de génération des voisins de la façon suivante :

- modifier et supprimer des paramètres nécessaires à l'exécution du programme de génération des voisins car les paramètres supprimés peuvent être calculés et ceux modifiés étaient difficiles à calculer par l'utilisateur ;

- écrire le fichier créé par le programme de génération des voisins dans le dossier du programme principal et si ce dossier n'est pas trouvé, afficher un message d'erreur à l'écran et arrêter l'exécution du programme ;

- représenter graphiquement le fichier créé par le programme de génération des voisins.


2. Matériels et méthodes utilisés

2.1. A rchitecture du logiciel existant

Tout d’abord, nous avons travaillé pour notre projet sur un logiciel existant, RIPS. La première étape fût donc de récupérer ce qu’il existait déjà de ce logiciel.

Pour le récupérer, M. GIMONA nous a demandées de télécharger FileZilla, logiciel que nous devions utiliser en tant que client SFTP afin de récupérer sur le serveur du Macaulay Land Use Research Institute les dossiers utiles à notre projet.

Lors des configurations de ce logiciel, nous nous sommes aperçues que nous n’avions pas le mot de passe pour se connecter au serveur. Nous avons alors demandé ce mot de passe à M. GIMONA par mail. Il nous l’a envoyé et nous a signalé que ce mot de passe était changé tous les mois. Vu que nous étions en fin de mois, nous devions alors récupérer rapidement RIPS sur le serveur du Macaulay.

Cependant, nous ne sommes pas arrivées à configurer FileZilla pour récupérer le logiciel RIPS, nous avons alors utilisé un autre client SFTP nommé WinSCP. Avec ce client SFTP, nous avons réussi à obtenir les dossiers pour notre projet.

Nous avons alors récupéré 4 dossiers : “archived programs”, “RIPSv2”, “GenerateData” et “ComputeNeighbors”. Premièrement, “archived programs” contient des versions compressées des 3 autres dossiers. Nous pouvons noter que nous ne nous sommes pas servies des versions contenues dans ces dossiers.

Deuxièmement, le dossier “RIPSv2” (voir Figure 2) contient le logiciel RIPS. Il est constitué de 3 dossiers importants “ihm_source”, “rips_source” et “simport_source”.

Le dossier “ihm_source” contient le code pour l’interface graphique du logiciel RIPS dans le fichier “ihm.c”


Figure 2 : Contenu du dossier RIPS_v2

Le dossier “rips_source” contient le code pour les calculs et l’exécution. Le dossier “simport_source” contient le code pour importer les fichiers nécessaires pour l’exécution. Les autres dossiers commençant par “res” comportent les résultats pour les espèces sélectionnées dans le logiciel RIPS. Par exemple, le dossier “res_5_sp23” contient les résultats de l’espèce nommée 23, qui est la 5ème espèce étudiée dans le logiciel. Enfin, ce dossier “RIPSv2” contient aussi des fichiers. Les fichiers importants de ce dossier sont “full.csv”, “log_import.txt”, “neighbours.res” et “rips”.

Le fichier “full.csv” contient les données sur les différentes espèces qui vont être étudiées ; nous le nommerons dans la suite fichier de données. Ce fichier contient des données réelles sur des oiseaux d'Afrique du Sud. Le fichier “neighbours.res” contient les quatre voisins les plus proches de chaque espèce ; nous le nommerons fichier des voisins dans la suite. Le fichier “log_import.txt” contient les valeurs importantes pour l'exécution du logiciel. Enfin, le fichier “rips” est le fichier exécutable du logiciel.

Troisièmement, le dossier “GenerateData” contient le code permettant de générer des données pour tester le logiciel RIPS.

Dernièrement, le dossier “ComputeNeighbors” (voir Figure 3) contient le code permettant de calculer les quatre voisins les plus proches de chaque espèce.

Il contient un dossier, “Package R” qui contient toutes les bibliothèques utiles pour l’utilisation du langage R. “ComputeNeighbors” contient aussi des fichiers :

“full.csv”, fichier d’entrée contenant les données sur les espèces, nommé fichier de données ; “main.c”, le code pour calculer les voisins ; “neighbors”, exécutable pour le calcul des voisins ; “neighbours.res”, fichier de sortie contenant les quatre voisins de chaque espèce, fichier de voisins ;


Figure 3 : Contenu du dossier “ComputeNeighbors”

“neighbours-plot.png”, image représentant les voisins ; “plotknearneigh.R”, code en R pour calculer les voisins.

Finalement, les dossiers que nous avons les plus utilisés sont “ComputeNeighbors” et “ihm_source” contenu dans “RIPSv2”. Les fichiers les plus utilisés dans ces dossiers sont “main.c” pour “ComputeNeighbors” et “ihm.c” pour “ihm_source”.

2.2. M atériels utilisés par le logiciel et pour notre travail sur le projet

D'abord, ce logiciel ne marche que sous Linux et nécessite plusieurs bibliothèques annexes. Alors, nous avons mis nos ordinateurs personnels sous Linux et installé ses bibliothèques. De même, nous avons demandé à M. Gouinaud d'installer ses bibliothèques sur le serveur de l'I.S.I.M.A. nommé “etud”.

Comme dit précédemment, nous avons modifié surtout deux fichiers.Le premier fichier que nous avons modifié est “ihm.c”.

Ce fichier utilise GTK+ (voir Figure 4), un ensemble de bibliothèques écrit en langage C permettant de réaliser des interfaces graphiques. Le GTK+ n’est pas étudié à l’I.S.I.M.A. Nous avons donc dû comprendre les fonctions de GTK+ utilisées dans “ihm.c”. Ce travail de compréhension a été réalisé à l'aide d' un tutoriel de GTK+ [1]. Il a été long car premièrement le fichier “ihm.c” comporte 2717 lignes ce qui représente beaucoup de fonctions, deuxièmement les

fonctions GTK sont différentes des fonctions que nous avons l’habitude d’utiliser. En particulier, nous avons eu des difficultés pour comprendre le fonctionnement de la fonction représentée sur la figure 5. Car, cette fonction appelle une autre fonction avec le paramètre “GCallback func”. Or, nous ne connaissions pas avant des fonctions ayant un paramètre qui appelle une autre fonction Donc, la

compréhension du GTK+ à l'aide d'un tutoriel [1] nous a pris du temps et a été compliqué.

Le deuxième fichier que nous avons modifié est “main.c” du dossier “ComputeNeighbors”. Ce fichier est rédigé en langage C. Mais, il contient une fonction qui écrit un fichier codé en R, “plotknearneigh.R”. Alors,


Figure 4 : Logo de GTK

Figure 5 : Squelette de la fonction GTK+ "g_signal_connect"

Figure 6 : Logo du langage R

nous avons dû comprendre le langage R (voir Figure 6), un langage de programmation et un environnement mathématique utilisés pour le traitement de données et l'analyse statistique. La compréhension du langage R a été effectué de nouveau avec un tutoriel [2]. Elle a été moins compliqué que la compréhension du GTK+.

Nous venons de vous montrer nos outils de compréhensions des langages utilisés par le logiciel. Maintenant, nous allons voir les outils que nous nous sommes servies pour travailler ensemble.

Pour travailler ensemble, nous avons utilisé deux outils : un pour le projet et un pour le rapport.

En premier lieu, l’outil utilisé pour le projet est Subversion (svn en abrégé), un système de gestion de versions (voir Figure 8). En d'autres termes, il permet de garder toutes les modifications faites sur les fichiers. En plus de Subversion, nous avons utilisé Unfuddle (voir Figure 7) [3], un serveur sécurisé et hébergeur de projets. Alors, nous avons appris à utiliser ses outils.

Sur Unfuddle, nous avons créé notre propre serveur nommé “rips”. Ainsi, nous avons pu accéder à notre projet à partir de n’importe quel ordinateur car nous avons stocké dans ce serveur “rips” tous les fichiers de notre projet (voir Figure 9). Il nous a permis aussi de communiquer à partir de “Messages” ou “Tickets” et de noter des rendez-vous avec “Milestones”.


Figure 7 : Logo d’Unfuddle

Figure 8 : Logo de Subversion

Figure 9 : Nos dossiers sur Unfuddle

A l'aide de Subversion, nous avons pu ajouter, modifier et supprimer des documents étant sur le serveur d’Unfuddle. Pour effectuer ces actions, nous avons appris à utiliser Subversion à l'aide d'un tutoriel [4]. Parce que Subversion fonctionne à partir de commandes tapées dans un terminal (commandes répertoriées dans le tutoriel [4]).

Finalement, Subversion et Unfuddle nous ont permis de travailler chacune de notre côté quand nous le voulions et à partir de n’importe quel ordinateur comportant une connexion internet.

Deuxièmement, pour rédiger le rapport et la présentation de la soutenance, nous avons utilisé Google Documents, un logiciel de traitement de texte permettant un travail collaboratif en ligne (voir Figure 10 et 11). Google Documents peut prendre la forme d’un traitement de texte (voir Figure 12) ou d’une présentation. Donc, cet outil nous a permis de rédiger en même temps et surtout de pouvoir voir les modifications faites sur notre rapport.

Finalement, ce projet nous a permis de tester des outils pour le travail en groupe, Subversion, Unfuddle et Google Documents mais aussi d’apprendre des nouveaux langages, le GTK+ et le langage R.

Nous allons maintenant vous présenter les changements que nous avons fait sur le logiciel RIPS grâce à ses outils.


Figure 11 : Logo de Google Documents

Figure 10 : Notre espace de travail sur Google Documents

2.3. C hangements réalisés sur RIPS

Le but de notre projet était d’effectuer des changements sur le logiciel RIPS et en particulier, d’intégrer le calcul des voisins dans le logiciel. Alors, nous avons effectué 4 changements : enlever des paramètres dans le calcul des voisins, enregistrer le fichier des voisins dans le dossier “RIPSv2”, représenter graphiquement ce dernier fichier et pouvoir calculer les voisins à partir de l’interface graphique de RIPS. Nous n'avons pas eu le temps d'exécuter le calcul des voisins dans l'interface graphique de RIPS.

Premièrement, nous avons modifié les paramètres nécessaires à l’exécution du calcul des voisins. Avant nos modifications pour exécuter le calcul de voisinage, il fallait aller dans le dossier “ComputeNeighbors” et lancer dans un terminal le fichier exécutable “neighbors” comme montré dans la figure 13 ; après nos modifications, les démarches sont les mêmes que précédemment sauf que les paramètres sont différents, voir Figure 14. Les paramètres qui ne sont pas modifiés sont “FILE_NAME_IN” qui correspond au fichier de données, “FILE_NAME_OUT” pour le fichier des voisins et “HEADLINE” pour la définir la longueur de l'entête du fichier de données, c'est-à-dire le nombre de lignes qui n'ont pas de valeurs.

./neighbors NB_PTS FILE_NAME_IN FILE_NAME_OUT [BURN_X BURN_Y [HEAD_LINE]]

Figure 13 : Lancement du calcul des voisins avant nos modifications


Figure 12 : Rédaction du rapport sur Google Documents

./neighbors FILE_NAME_IN FILE_NAME_OUT [COLUMN_OF_X_COORD COLUMN_OF_Y_COORD [HEAD_LINE]]

Figure 14 : Lancement du calcul des voisins

Le premier paramètre que nous avons enlevé est “NB_PTS”. Ce paramètre correspond au nombre de points présents dans le fichier de données, c’est-à-dire le nombre de lignes de ce fichier. Donc, ce paramètre peut être calculé. Pour le calculer, nous avons modifié une fonction déjà existante, “readFileofPoint”. Cette fonction parcourait le fichier de données pour mettre les coordonnées X et Y de chaque point dans un autre fichier. Les coordonnées X et Y sont une colonne dans le fichier de données et correspondent à l'emplacement géographique de chaque point. Dans la fonction “readFileofPoint”, nous avons alors ajouté un incrément, initialisé à 0 et incrémenté de 1 à chaque fois que nous changeons de ligne dans le fichier de données. A la fin de la fonction, nous affichons à l’écran le nombre de lignes du fichier.

Ensuite, nous avons modifié deux autres paramètres, “BURN_X” et “BURN_Y”. “BURN_X” est un entier qui correspond à l'écart entre le numéro de la première colonne et celui de la colonne de la coordonnée X. “BURN_Y” indique l'écart entre le numéro de la colonne de la coordonnée X et celui de la colonne de la coordonnée Y. Ces deux paramètres ont été remplacé par “COLUMN_OF_X_COORD” et “COLUMN_OF_Y_COORD”, qui correspondent au numéro de la colonne X ou Y. Alors, “COLUMN_OF_X_COORD” correspond à l’ancien paramètre “BURN_X” et “COLUMN_OF_Y_COORD” à l’addition des paramètres “BURN_X” et “BURN_Y”. Ces deux derniers paramètres étaient seulement utilisés dans la fonction précédente “readFileofPoint”. Ils permettaient de savoir le nombre de colonnes à parcourir à partir de la première colonne pour trouver la colonne de la coordonnée X puis de trouver la colonne de la coordonnée Y à partir de la colonne X. Les modifications de ces paramètres ont entraîné une modification de la fonction “readFileofPoint” et en particulier, de deux boucles “pour” (voir Figure 15).

Avant nos modifications : Pour colonne de 0 à BURN_X-1

Instruction 1;Fin PourPour colonne de 0 à BURN_Y-1

Instruction 3;Fin Pour

Après nos modifications : Pour colonne de 0 à COLUMN_OF_X_COORD-1

Instruction 1;Fin PourPour colonne de COLUMN_OF_X_COORD à COLUMN_OF_Y_COORD-1

Instruction 3;Fin Pour

Figure 15 : Algorithmes de principe sur une partie de “readFileofPoint”


Deuxièmement, nous avons représenté graphiquement le fichier des voisins “neighbours.res” (voir Figure 16), fichier créé et rempli lors de l’exécution du calcul des voisins. Ce fichier contient, par exemple, sur la ligne 1 les numéros “2 6 5 7”. La ligne correspond au point pour lequel nous cherchons ces voisins. Les coordonnées géographiques de ce point se trouvent alors à la ligne 1 du fichier “coordinatesfile.temp” (voir Figure 17) ou dans les colonnes des coordonnées X et Y du fichier de données “full.csv” (voir Figure 19) et sont donc (29.125,-22.125). Les nombres “2 6 5 7” correspondent aux numéros des lignes de ces voisins les plus proches, ici les points de coordonnées géographiques (29.375,-22.125), (29.125,-22.375), (28,875,-22.375) et (29.375,-22.375).

Pour représenter les points voisins à un point, nous utilisons une fonction codé en R détaillée dans la figure 18.

Lecture du fichier “coordinatesfile.temp”Récupération des coordonnées de X et YCalcul de 4 voisins pour chaque coordonnée (x,y)Sauvegarde des résultats dans le fichier “neighbours.res”Tracer de chaque coordonnée (x,y) et de leurs 4 voisins

Figure 18 : Algorithme de principe pour représenter graphiquement les

voisins

Le résultat de cette fonction est visible sur la figure 20. Sur ce graphe, chaque point est représenté par un cercle et les voisins par des traits reliant les centres de deux cercles donc reliant deux points.


Figure 17 : Aperçu du fichier

“coordinatesfile.temp”

Figure 16 : Aperçu du fichier

“neighbours.res”


Légende :

Point

2 voisins reliés

Point relié à ses

4 voisins

Figure 20 : Représentation

graphique du fichier des voisins

Figure 19 : Aperçu du fichier "full.csv"

Troisièmement, nous avons écrit le fichier des voisins dans le dossier “RIPSv2” et si ce dossier ne peut être trouvé, nous avons imprimé une erreur à l’écran.

En premier lieu, nous allons voir l’écriture du fichier des voisins. Avant que nous modifions le code, le fichier des voisins, généralement appelé “neighbours.res”, était écrit seulement dans le dossier “ComputeNeighbors” (voir arborescence sur la Figure 3). Nous l'avons alors écrit aussi dans le dossier “RIPSv2”. Ainsi, nous avons utilisé une commande du langage système qui copie un fichier d’un répertoire dans un autre. Mais ensuite, nous ne savions pas comment rédiger cette commande système dans notre code en C. Il suffit en fait de stocker la commande que l’on veut utiliser dans une chaîne de caractères et d'appeler cette chaîne de caractères avec la fonction “system”.

En second lieu, une erreur est imprimé à l'écran lorsque le dossier “RIPSv2” n'est pas trouvé. Cette erreur est en fait le retour de la fonction “system” précédente, c’est-à-dire que lorsque la copie de notre fichier des voisins dans le dossier “RIPSv2” est possible, la fonction “system” retourne 0 sinon elle retourne un autre entier. Finalement, pour imprimer à l’écran une erreur, nous stockons le retour de la fonction “system” dans un variable nommée “error” et par cette même fonction “system”, nous imprimons à l’écran le contenu de “error”.

Quatrièmement, nous avons ajouté dans l’interface graphique de RIPS une page permettant à l’utilisateur de saisir les paramètres nécessaires à l’exécution du calcul des voisins (voir Figure 23). Pour lancer cette interface graphique du logiciel RIPS, il faut aller dans le dossier “RIPSv2” et lancer dans un terminal le fichier exécutable “rips” comme montré dans la figure 21.

./rips

Figure 21 : Lancement du logiciel RIPS

Pour insérer cette page entre la page une et la page deux du logiciel existant (voir Figure 22 et 24), nous avons repris l’algorithme de la première page du logiciel (voir Figure 22) en ajoutant quelques modifications. Parce qu'il y a aussi besoin d’un menu “file”, de deux noms de fichiers, de trois entiers que l’utilisateur peut modifier, de boutons suivant et précédent et d'un pour quitter. Cependant, il y a des différences au niveau du codage de la nouvelle page par rapport à la page une.

Par la suite, nous appellerons page une l'ancienne page une et page deux la page rajoutée.

Tout d’abord dans le menu 'file' de la page deux, l'utilisateur ne doit pas pouvoir cliquer sur 'Load'. Car lors d'un clic sur 'Load', le fichier "file of log" peut être modifié. Or, nous voulons que ce fichier soit modifié seulement sur la première page. Alors dans la page une, lorsqu’un clic sur le bouton ‘Suivant’ est effectué, nous désactivons la possibilité


de cliquer sur 'Load' et nous passons à la page deux. Nous avons réalisé la désactivation de ce bouton avec une fonction de la librairie GTK+ qui active ou désactive la possibilité de cliquer sur un bouton. De plus lorsque un clic est effectué sur le bouton ‘Précédent’ dans la deuxième page, il faut réactiver la possibilité de cliquer sur 'Load'. Ceci est réalisé avec la même fonction de GTK+ que dans le cas précédent.

Ensuite pour aucun fichier, nous avons besoin de chercher un fichier dans notre arborescence. Donc, le code utilisé dans la page une du bouton ‘ouvrir’ pour le fichier de données a été supprimé pour la deuxième page. Mais pour les deux fichiers, nous avons redéfini le nom du fichier par défaut. Pour le fichier des voisins, ceci a été simple car c’est un nom choisi par défaut, "neighbours.res". En revanche pour le fichier de données, ceci a


Figure 22 : Page 1 de l’interface graphique de RIPS

été plus compliqué car nous avons récupéré le nom du fichier de données saisi dans la page une. Nous l'avons récupéré grâce à une fonction de la librairie GTK+ qui permet de récupérer le texte contenu dans des variables. En plus pour le fichier de données "file of data" dans la page deux, nous ne voulons pas qu’il soit modifié parce que c’est le même fichier de données que celui de la page une. Mais, nous l’affichons car il fait parti des paramètres lors de l’exécution du calcul des voisins. Alors pour empêcher l’utilisateur de modifier le fichier de données, dans le code, nous utilisons de nouveau la fonction GTK+,qui peut activer ou désactiver la possibilité de cliquer.

Figure 23 : Page 2 de l’interface graphique de RIPS

Puis pour les valeurs que l’utilisateur peut modifier, nous avons dû redéfinir les valeurs par défauts et les valeurs maximales. Les valeurs par défauts ont été redéfini en changeant simplement les valeurs, que nous avions pour la page une, par 1 pour “column of X coord.” et “headline” et par 2 pour “column of Y coord.”. En revanche, les modifications des valeurs maximales, que l'utilisateur peut saisir, ont été plus difficiles car ces valeurs dépendent des paramètres du fichier et en particulier du nombre de lignes et de colonnes. Nous avons alors cherché les variables qui contiennent les nombres de lignes et de colonnes. Puis, nous avons converti ces variables à l’aide de la fonction GTK+


déjà utilisée pour récupérer le nom du fichier de données. Les valeurs maximales sont alors le nombre de colonnes moins deux pour “column of X coord.”, moins un pour “column of Y coord.” et le nombre de lignes moins un pour “headline”

Enfin, nous avons configuré la possibilité de passer à la page précédente. Ceci a été réalisé à l’aide du code du bouton 'Précédent' des pages suivantes. Donc, nous avons codé ce bouton avec quelques modifications sur les codes précédents.

Finalement, nous avons modifié plusieurs codes existants du logiciel RIPS en utilisant différents langages. Les modifications ont été réalisées sur deux fichiers : celui du calcul des voisins et celui de l’interface graphique. Sur celui du calcul des voisins, nous avons modifié les paramètres lors de l’exécution (modification faite en C), copié le fichier des voisins dans le dossier “RIPSv2” (modification faite en langage système) et représenté graphiquement les voisins (modification faite en langage R). Sur le fichier de l’interface graphique, nous avons offert la possibilité à l’utilisateur de saisir les paramètres pour l’exécution du calcul des voisins (modification faite en GTK+).


Figure 24: Page 3 de l’interface graphique de RIPS

3. Résultats obtenus

3.1. E ffet des modifications sur le calcul des voisins

Pour le calcul des voisins, des modifications ont été faites sur le fichier "main.c". Ces modifications sont la suppression et la modification de paramètres de l’exécutable du calcul des voisins, la copie du fichier des voisins dans le dossier "RIPSv2" et la représentation graphique des voisins.

Tout d’abord, parlons des conséquences de la suppression et de la modification de certains paramètres nécessaires pour exécuter le calcul des voisins.

Comme montré sur la figure 14, pour exécuter le calcul des voisins, il faut maintenant taper un paramètre en moins. Ce paramètre en moins est "NB_PTS". Il permet de savoir le nombre de points contenu dans le fichier de données, c’est-à-dire le nombre de lignes de ce fichier. Avant la suppression du paramètre "NB_PTS", lorsque l’utilisateur exécutait le calcul des voisins, il devait renseigner ce paramètre, c’est-à-dire que l’utilisateur devait connaître le nombre de lignes de son fichier de données. La suppression de ce paramètre permet ainsi d’éviter à l’utilisateur de chercher dans son fichier de données le nombre de lignes alors qu'il peut être calculé. Pour tester le fonctionnement du programme sans ce paramètre, nous avons exécuté le calcul des voisins et nous avons vérifié que le fichier des voisins possède le même nombre de ligne que le fichier de données.

En comparant les figures 13 et 14, nous voyons aussi que nous avons modifié les paramètres "BURN_X" et "BURN_Y" en "COLUMN_OF_X_COORD" et "COLUMN_OF_Y_COORD". Le paramètre "BURN_X" donnait l'écart entre le numéro de la première colonne du fichier de données et le numéro de la colonne de la coordonnée de X et "BURN_Y" l'écart entre le numéro de la colonne de la coordonnée X et celui de la colonne de la coordonnée de Y. Tandis que les paramètres "COLUMN_OF_X_COORD" et "COLUMN_OF_Y_COORD" donnent respectivement le numéro de la colonne X et celui de la colonne Y. Avant cette modification, pour connaître les paramètres "BURN_X" et "BURN_Y", l’utilisateur devait connaître le numéro de la colonne de la coordonnée X et le nombre de colonnes entre les coordonnées X et Y. Pour l’utilisateur, "BURN_X" est facile à déterminer mais "BURN_Y" est plus difficile à déterminer s’il y a beaucoup de colonnes entre les coordonnées X et Y. Donc, la modification de ces paramètres permet à l’utilisateur de connaître seulement les colonnes des coordonnées de X et Y. Cette modification a été


vérifié grâce à la représentation graphique du fichier des voisins (voir Figure 20). Parce que si la modification effectuée n'était pas correcte alors le graphe ne représenterait pas l’Afrique du Sud.

Finalement, la modification des paramètres lors de l’exécution du calcul des voisins (comparer les figures 13 et 1A) facilite la saisie des paramètres par l’utilisateur.

Ensuite, regardons la copie du fichier d’entrée dans le dossier “RIPSv2”.Lors de l’exécution du calcul de voisins (voir Figure 14), un des paramètres est

"FILE_NAME_OUT" qui correspond au nom du fichier des voisins. Ce fichier est créé dans le répertoire courant, c’est-à-dire le répertoire “ComputeNeighbors”. Or, il est nécessaire lors de l’exécution du logiciel RIPS. C’est pourquoi nous avons copié ce fichier dans le dossier “RIPSv2”.

Cette copie de fichier permet donc d’avoir tous les fichiers nécessaires au logiciel RIPS dans le dossier “RIPSv2”. Avant que cette copie existe, l’utilisateur copiait à la main ce fichier. Maintenant, il est automatiquement créé dans le dossier “RIPSv2” lors de l’exécution du calcul des voisins.

Enfin, nous allons voir la portée de la représentation graphique des voisins (voir Figure 20). La représentation graphique permet en premier lieu de représenter le fichier des voisins, en deuxième lieu de vérifier notre programme de calcul des voisins et en troisième lieu de vérifier que nos données sont correctes.

Premièrement, le graphe représente le fichier des voisins créé à l’exécution du calcul de voisinage. Ce fichier contient pour chaque point le numéro des lignes de ses quatre voisins. Comme dit dans le 2.3), chaque point de coordonnées (X,Y) est représenté par un cercle et lorsque deux points sont voisins, les centres de leur cercle sont reliés. Nous avons donc représenté notre fichier des voisins.

Deuxièmement en observant le graphe, nous pouvons voir que tous les points ont effectivement quatre voisins, c’est-à-dire qu’ils sont reliés à quatre autres points. Pour ceux du bord, il est difficile de distinguer ces 4 voisins mais en zoomant, les 4 voisins sont visibles. Donc, notre programme de calcul de 4 voisins pour chaque point fonctionne.

Dernièrement, nos données proviennent d’Afrique du Sud. Ceci se vérifie aisément sur le graphe. En noir, l’Afrique du Sud se distingue. Même le Lesotho, petit pays enclavé dans l’Afrique, est visible en blanc au milieu du noir dans le coin inférieur droit (cercle manquant). Nous affirmons donc qu’effectivement nos données proviennent de l’Afrique du Sud.

Finalement, la représentation graphique de notre fichier des voisins permet de voir sur quelles données nous travaillons, ici l’Afrique du Sud, et de constater que le programme de calcul des voisins fonctionne.


Pour conclure, les modifications sur le programme de calcul des voisins facilitent l’utilisation du logiciel RIPS et représentent nos coordonnées et les voisins correspondant à ces coordonnées.

3.2. Effet sur les m odifications de l’interface graphique

Sur l’interface graphique du logiciel RIPS, c’est-à-dire dans le fichier “ihm.c”, nous avons offert la possibilité à l’utilisateur de saisir les paramètres nécessaires pour le calcul des voisins de chaque point.

L'’interface qui permet de saisir les paramètres pour calculer les voisins est visible sur la figure 23. Sur cette page, les paramètres que l’utilisateur peut saisir sont le nom du fichier des voisins, les numéro des colonnes des coordonnées X et Y et le nombre de lignes de l’entête du fichier.

La figure 23 permet de voir que l’utilisateur ne peut pas modifier le fichier de données. Parce que il a saisi le nom de ce fichier sur la première page du logiciel (voir Figure 22). L’utilisateur peut alors saisir ses paramètres s’ils sont différents des paramètres par défaut. Donc, si ses paramètres sont les paramètres par défaut, il gagne du temps dans l'exécution du logiciel.

Finalement, cette interface permet à l’utilisateur de saisir rapidement ses paramètres pour l’exécution du calcul des voisins et à la personne qui programme, d’exécuter ce calcul dans l’interface graphique, exécution que nous n'avons pas eu le temps de réaliser.


3.3. A méliorations possibles

Comme dit précédemment, nous n'avons pas eu le temps d’exécuter, dans l’interface graphique, le calcul des voisins à partir des paramètres saisis par l'utilisateur dans la page 2. L'exécution de ce calcul aurait crée alors le fichier des voisins dans le dossier “RIPSv2” nécessaire pour la suite du logiciel RIPS.

Finalement, l’exécution du calcul des voisins dans l’interface permettrait d’éviter à l’utilisateur d’exécuter ce calcul puis de lancer le logiciel RIPS. L’utilisateur aurait juste à lancer l’exécution du logiciel RIPS pour exécuter le calcul des voisins et effectuer ensuite la modélisation de la distribution des espèces.

Nous voulons essayer de programmer ceci avant la soutenance de projet.


Conclusion

Dans le cadre de notre projet de 2ème année à l'I.S.I.M.A., nous avons intégré le calcul de voisinage dans un outil de distribution d'espèce, réalisé en partie par Gilles ROLHION et Benoît PIC.

Pour commencer, nous avons modifié le calcul des voisins pour faciliter l'utilisation du logiciel RIPS. Avant nos modifications, l'utilisateur devait calculer certains paramètres nécessaires à l'exécution du calcul des voisins. Par ailleurs, il devait copier à la main le fichier des voisins dans le dossier où le logiciel RIPS est exécuté, maintenant ce fichier est automatiquement copié dans ce dossier. Ensuite, nous avons représenté le fichier des voisins pour aider l'utilisateur à visualiser ses données.

Puis, nous avons permis à l'utilisateur de saisir les paramètres nécessaires à l'exécution du calcul des voisins, dans l'interface graphique de RIPS. Enfin, si nous avions eu le temps d'exécuter le calcul des voisins dans l'interface graphique, l'utilisateur aurait pu exécuter ce calcul et faire sa modélisation sans avoir besoin d'exécuter le calcul d'une part et de lancer le logiciel RIPS d'autre part.

Au cours du projet, nous avons rencontré des difficultés techniques et d'organisation. La difficulté technique est la compréhension du code “ihm.c” rédigé en GTK+. Elle a été résolue à force de travailler sur ce code et à l'aide du tutoriel de GTK+ [1]. Quant aux difficultés d'organisation, elles sont dues à la communication. Nous avons eu des difficultés à comprendre ce que M. GIMONA voulait qu'on fasse. Mais à l'aide de multiples mails, nous y sommes arrivées. L'autre difficulté a été la communication entre nous et l'incommodité à travailler ensemble à cause de nos méthodes de travail si différentes.


Références bibliographiques

[1] Cours Gtk+ [Ressource électronique]. [France] : CECCHI Jérôme, 27 février 2006Disponible sur : http :// gtk . developpez . com / cours / gtk 2/

[2] R pour les débutants [Ressource électronique]. [Montpellier, France] : PARADIS Emmanuel, Institut des Sciences de l'Évolution [Université Montpellier II], 12 décembre 2005Disponible sur : http :// cran . r - project . org / doc / contrib / Paradis - rdebuts _ fr . pdf

[3] Notre serveur de RIPS [Serveur], UnfuddleDisponible sur : http :// rips . unfuddle . com /

[4] Tutoriel Subversion [Ressource électronique]. [France] : Club*Nix, MAD[[email protected]]Disponible sur : http :// www . clubnix . fr / tutoriel _ svn

http://www.google.com/url?q=http%3A%2F%2Fgtk.developpez.com%2Fcours%2Fgtk2%2F&sa=D&sntz=1&usg=AFQjCNGpXio8_SFGl5tAlYau2i1dVd484g

http://www.google.com/url?q=http%3A%2F%2Fwww.clubnix.fr%2Ftutoriel_svn&sa=D&sntz=1&usg=AFQjCNGcpNeHrfn4l4-xOATVPpbSIb3_Xw











http://www.google.com/url?q=http%3A%2F%2Frips.unfuddle.com%2F&sa=D&sntz=1&usg=AFQjCNEgtfxBUFHIqAUx90FcNie8sI-rCw








http://www.google.com/url?q=http%3A%2F%2Fcran.r-project.org%2Fdoc%2Fcontrib%2FParadis-rdebuts_fr.pdf&sa=D&sntz=1&usg=AFQjCNHRbmVBPjGyPIv97CLm2a1gRwJb5A






























