anaconda: une solution d'analyse de données · de commencer ce rapport de stage pa des eme...

Sylvain BERNARD Licence Professionnelle :

Système informatique et logiciel

Année universitaire 2009-2010

Anaconda, une solution d'analyse de

données

Rapport de stage

Responsable: Cyril Masselot et Jean-Jacques Girardot

Tuteur: Nicolas Janey

Laboratoire ThéMA - Intelligence territoriale

Avant tout développement sur cette expérience professionnelle, il apparaît opportun

de commencer ce rapport de stage par des remerciements, à ceux qui m’ont beaucoup

appris au cours de ce stage, et même à ceux qui ont eu la gentillesse de faire de ce stage un

moment très profitable.

Aussi, je remercie, Jean-Jacques Girardot qui m’a formé et accompagné tout au long

de cette expérience professionnelle avec beaucoup de patience et de pédagogie mais aussi

les différents membres de l’équipe d’intelligence territoriale que j’ai côtoyés: Sylvia Ratsian,

Cyril Masselot, Rémi Thomas, Vincent André. Ainsi que les différents stagiaires travaillant

avec moi : Simon Marthey (étudiant en licence informatique à Besançon) et Amine Khiar

(étudiant en école d’ingénieur au Maroc).

Je remercie également Etienne Sissao, professeur au Burkina-Faso, qui a travaillé avec

nous durant deux mois afin de réutiliser en Afrique les concepts d’intelligence territoriale,

pour sa gentillesse et sa bonne humeur, ainsi que Bénédicte Hermann et Sylvie Damy qui

m’ont fait passer l’entretient préalable et qui m’ont choisi.

1. INTRODUCTION 1

2. PRESENTATION DE L’ENTREPRISE 2

2.1. THEMA (THEORISER ET MODELISER POUR AMENAGER) 2

2.2. L’INTELLIGENCE TERRITORIALE 2

2.2.1. QU'EST CE QUE L'INTELLIGENCE TERRITORIAL 2

2.2.2. L'EQUIPE D'INTELLIGENCE TERRITORIALE 3

3. PRESENTATION DU SUJET 4

3.1. CONTEXTE 4

3.2. CATALYSE 4

3.3. ROLE DE L'APPLICATION 5

4. CAHIER DES CHARGES 6

4.1. DESCRIPTIF FONCTIONNEL 6

4.1.1. DOCUMENTER 6

4.1.2. CORRIGER 6

4.1.3. IMPLEMENTER 6

4.1.3.1. Implémenter des fonctionnalités existantes 6

4.1.3.2. Implémenter des fonctionnalités nouvelles 6

4.2. ANACONDA 7

4.2.1. DIFFERENCES 7

4.2.2. BUGS, PROBLEMES ET FONCTIONNALITES MANQUANTES DANS LA 3.2 9

4.3. CONTRAINTES TECHNIQUES 9

4.4. CONTRAINTES TEMPORELLES 10

5. MISE EN ŒUVRE 11

5.1. CHOIX TECHNIQUES 11

5.1.1. LANGAGE DE PROGRAMMATION 11

5.1.2. FICHIER LANGUE 11

5.1.3. ECLIPSE 11

5.2. APPLICATION 12

5.2.1. REPRISE DE L'EXISTANT 12

5.2.1.1. Analyse 12

5.2.1.2. Documentation 12

5.2.1.3. Correction des bugs et de l'orthographe 12

5.2.1.4. Fenêtre données et résultats 13

5.2.2. REPRISE DES FONCTIONNALITES OUBLIEES 15

5.2.2.1. Paramétrages 15

5.2.2.2. Barre d'état 16

5.2.2.3. Contrôle du fichier booléen 17

5.2.2.4. Inversion des couleurs 19

5.2.3. NOUVELLES FONCTIONNALITES 19

5.2.3.1. Convertisseur de fichier tab en fichier bol 19

5.2.3.2. Création d’un fichier perfiles 20

5.2.3.3. Grossissement des points 21

5.3. PROBLEMES RENCONTRES 21

5.4. DEVELOPPEMENT FUTUR 22

6. PRESENTATION DE L'APPLICATION 23

6.1. GENERATION DES FICHIERS (EN PARTICULIER LE NGE) 23

6.2. GENERATION DU NUAGE, RENDU LOGICIEL 24

6.3. GENERATION DU NUAGE, RENDU OPENGL 24

6.4. MANIPULATION 25

7. BILAN 26

7.1. BILAN POUR L’INTELLIGENCE TERRITORIALE 26

7.2. BILAN HUMAIN 26

7.3. BILAN PEDAGOGIQUE 27

8. CONCLUSION 28

29

30

31

32

35

Anaconda: une solution d'analyse de données 2010

1

1. Introduction

En tant qu'étudiant à la Faculté des Sciences et des Techniques de Besançon et dans le

cadre de ma licence professionnelle, j’ai entrepris un stage en entreprise de 14 semaines. Le

but pédagogique de ce stage est de faciliter, dans une optique professionnelle, l'acquisition

de la pratique et le maniement des concepts enseignés.

Ce sujet de stage a été proposé par M. Girardot, responsable de l’équipe d’intelligence

territoriale du laboratoire ThéMA. L’équipe comprend plusieurs informaticiens, et deux

sujets de stage avaient été proposés au département informatique de l’université de

Franche-Comté. Un sujet concernant le logiciel Pragma et un second sujet concernant le

logiciel Anaconda, c’est ce dernier qui m’a été confié. Le sujet concernant Pragma a été

quant à lui confié à un autre étudiant de licence informatique : Simon Marthey.

Je commencerai par présenter l’entreprise dans laquelle j’ai travaillé. Je ferai ensuite une

analyse du sujet puis un cahier des charges afin de bien cerner et définir le travail que je

devais réaliser. Ensuite, je décrirai comment l’application a été développée, quels choix

techniques ont été effectués, et quels problèmes ont été rencontrés. Pour finir nous verrons

le fonctionnement de l’application, le bilan de ce stage et nous conclurons sur ces 14

semaines passées en entreprise.


2

2. Présentation de l’entreprise

2.1. ThéMA (Théoriser et Modéliser pour Aménager)

ThéMA est une unité mixte de recherche qui associe le CNRS, les universités de Franche-

Comté et de Bourgogne ; elle s’intègre aux Maisons des Sciences de l’Homme de ces deux

universités. Elle fonctionne sur deux sites à Dijon et à Besançon, siège de l’UMR. Unité

pluridisciplinaire, elle est composée de géographes, d’économistes, d’informaticiens et de

civilisationnistes.

Le laboratoire ThéMA fédère 5 équipes de recherche :

4 équipes thématiques

Mobilités, ville et transports;

Paysage et cadre de vie;

Emploi, formation, innovation;

Centre d’étude et de recherche sur le sport et l’observation des territoires.

1 équipe de recherche technologique : intelligence territoriale.

C’est dans cette dernière, l’équipe d’intelligence territoriale, que mon stage a été réalisé.

2.2. L’intelligence territoriale

2.2.1. Qu'est ce que l'intelligence territoriale

L’intelligence territoriale est un concept émergeant qui vise à intégrer la dimension

spatiale à l’étude des phénomènes humains saisis à différentes échelles spatio-temporelles

et selon des approches disciplinaires variées.

Elle désigne l’ensemble des connaissances pluridisciplinaires qui améliorent la

compréhension de la structure et de la dynamique des territoires. Elle ambitionne d’être un

instrument au service des communautés pour gouverner le développement équitable et

durable de leurs territoires.

Elle vise à mettre les technologies de l’information territoriale au service des

communautés en respectant des principes de gouvernance qui sont la participation, le

partenariat et l’approche globale.


3

Pour répondre à la question : Quelles connaissances, quelles méthodes, quelles

informations, quels outils, quels processus décisionnels et quelle gouvernance sont utiles

aux communautés territoriales afin de comprendre les dynamiques de leurs territoires et de

gouverner leur développement de façon équitable et durable.

2.2.2. L'équipe d'intelligence territoriale

Dès 1979, le centre MTI®SHS, qui conçoit des outils et procédés basés sur l'évolution

des technologies IT, informatiques et statistiques, a dirigé ses recherches vers l'intelligence

territoriale. Ce pôle intelligence territoriale de ThéMA, dirigé par M. Girardot, développe et

diffuse le concept d’Intelligence Territoriale, ses principes et ses outils. Il propose un

environnement scientifique et technologique aux acteurs du développement durable, dont

le concept d’Intelligence Territoriale renforce la cohérence. Il apporte une méthode originale

d’observation territoriale, Catalyse, dont les outils de diagnostic des besoins et d’évaluation

des actions ont été employés par des partenariats de développement, dans différentes

régions européennes et sur des thématiques diversifiées concernant l’inclusion sociale,

l’intégration socioculturelle et le développement territorial. Il conduit également des

recherches sur les systèmes communautaires d’intelligence territoriale.

Pour résumer, l’équipe d’intelligence territoriale met à disposition des outils qui

permettent par exemple, à partir de données type sondage (appel téléphonique, enquête

dans la rue), de représenter graphiquement ces données dans un nuage de points, et d’en

déduire des informations pertinentes.


4

3. Présentation du sujet

3.1. Contexte

La Licence professionnelle systèmes informatiques et logiciels spécialité conception

et développement orientés objet d'applications multi-tiers à l’Université de Besançon,

s’achève par un stage en entreprise. Le but de ce stage est de mettre en application les

connaissances apprises durant l'année et d’acquérir de l’expérience en milieu professionnel.

C’est dans le cadre de ces stages de fin d’année que l'équipe d'intelligence territoriale a

proposé une offre de stage afin de reprendre le développement d'une de leurs applications

appelée "Anaconda". Anaconda fait partie des outils de la méthode Catalyse.

3.2. Catalyse

La méthode Catalyse propose des outils (figure 1), de diagnostic d’évaluation et

d’observation accessibles aux acteurs locaux du développement territorial durable. Ces

outils sont utiles pour élaborer des projets de développement pertinents, pour gérer

efficacement ces projets, puis pour les évaluer et pour apprécier leur impact. La méthode

Catalyse est développée plus précisément en annexe 1.

Figure 1. Outils de la méthode catalyse


5

3.3. Rôle de l'application

Le sujet proposé consiste à développer une nouvelle version d’un logiciel existant :

Anaconda. Ce logiciel a été développé à de nombreuses reprises depuis plus de vingt ans.

Le logiciel Anaconda a été développé dès 1979 pour favoriser la diffusion de l’Analyse

des Données en simplifiant les manipulations informatiques indispensables à sa mise en

œuvre. En effet ce logiciel se veut une solution accessible et peu chère (en réalité gratuite

actuellement) pour analyser les données. S’il facilite l’usage de l’ordinateur, Anaconda ne

procure pas au départ la compétence méthodologique et la connaissance des données, qui

restent les ingrédients fondamentaux de l’Analyse des données.

Anaconda prend en entrée un fichier standard : un tableau de données. A partir de ce

tableau, des calculs sont réalisés, appelé AFC (Analyse Factorielle des Correspondances) et

classification ascendante hiérarchique. Un graphe résultant de ces calculs est alors généré:

c’est un nuage de points (figure 2).

La dernière version d’Anaconda était la 3.2, mais la version utilisée par ses

utilisateurs est la 2.2. En effet les versions 3.X sont instables : il y a de nombreux bugs, il

manque de nombreuses fonctionnalités présentes dans la 2.2 et le logiciel est mal traduit. Le

développeur de cette version a en réalité préféré travailler sur un nouveau moteur

graphique au lieu de privilégier les fonctionnalités préexistantes. Le temps lui manquant à la

fin, le logiciel est peu utilisable.

Le travail demandé est alors de créer une nouvelle version baptisée Anaconda 3.3,

qui reprend cette version 3.2 mais qui corrige les différents bugs, implémente les différentes

fonctionnalités manquantes et rajoute de nouvelles fonctionnalités.

Figure 2. Exemple d'un nuage de points


6

4. Cahier des charges

4.1. Descriptif fonctionnel

4.1.1. Documenter

Le travail consistant à améliorer une application existante, les sources disponibles

doivent être les plus compréhensibles possibles. Ce n'était pas le cas. En effet le précédent

développeur à laissé un code quasiment vierge de commentaire et de Javadoc. La première

étape du travail est donc de comprendre le code existant (plus de 20 000 lignes) pour

pouvoir différencier les différentes parties et les documenter. Puis ensuite, tout au long du

développement, ne pas faire la même erreur que le précédent développeur, et commenter

le code le plus possible avec des commentaires classiques ou de la Javadoc.

4.1.2. Corriger

Certaines fonctionnalités présentes dans Anaconda 3.2 ne sont pas utilisables car

elles peuvent provoquer de nombreux bugs sous certaines conditions. En effet, si par

exemple le tableau de données en entrée est mal écrit, le logiciel peut planter et provoquer

des erreurs. De plus, de nombreuses fautes d’orthographes sont présentes.

4.1.3. Implémenter

4.1.3.1. Implémenter des fonctionnalités existantes

De nombreuses fonctionnalités existantes dans Anaconda 2.X n’existent plus dans

Anaconda 3.X. Ce sont en général des fonctionnalités très utiles pour l’utilisateur, et elles

doivent être de nouveaux implémentées.

4.1.3.2. Implémenter des fonctionnalités nouvelles

A force d’utilisation du logiciel, les utilisateurs aimeraient bien certaines fonctionnalités

nouvelles qui leurs faciliteraient le travail ou qui perfectionneraient leurs travaux.


7

4.2. Anaconda

4.2.1. Différences

Il existe de nombreuses différences entre la version utilisable d'Anaconda et la

version inachevée. Ce tableau récapitule ces différences.

Anaconda 2.2 Anaconda 3.2

Boîte à outils Verticale et indépendante Horizontale et intégré dans la

fenêtre du nuage de points

Console Inexistante En bas

Données et résultats

Ouverture

automatique du

dernier fichier utilisé

Oui Non

Utilisation d’un

fichier .ini qui

sauvegarde les

tailles/emplacements

des fenêtres, la langue

utilisée et les fichiers

récents

Oui Non

Barre d’état avec la

taille du nuage, le

nombre de

caractères/individus

total et sélectionné

Oui Non


8

Paramètre

Inexistant

Aide/aide en ligne Non Oui

Etiquette

Inexistant

Sélection

Inexistant

Limites

Raccourcies clavier

pour utiliser certains

Non Oui


9

menus

Titre de la fenêtre

principale

Nom du fichier + Anaconda 2.2 04/2008 Anaconda 3.2

Moteur de rendu Uniquement logiciel Logiciel ET OpenGL

Langues Anglais, Français, Espagnol, Chinois,

Catalan

Anglais, Français, Espagnol

4.2.2. Bugs, problèmes et fonctionnalités manquantes dans la 3.2

La fenêtre d'ouverture automatique lors du démarrage n'existe pas,

lorsque l’on clique sur un point dans « cloud component », le logiciel peut

planter,

lorsque l’on clique sur « Génération automatique » le logiciel peut planter,

help/online help ne marche pas,

de nombreuses fautes d’orthographes sont présentes,

les limites ne sont pas affichées par défaut,

lorsque l’on clique sur quitter, aucun message de demande de sauvegarde au

format nge n'apparait,

il n'y a pas de barre en bas permettant de saisir la taille du graphique et

d’avoir des informations sur le nombre de caractères et d’individus,

il n'est pas possible de créer un caractère,

il n'est pas possible choisir les points que l’on veut mettre dans le groupe,

il n'y a pas de « contribution data ».

4.3. Contraintes techniques

L’application doit rester totalement portable entre les différents systèmes d’exploitation

en particulier Windows et Mac. Le logiciel étant développé en JAVA, ce langage garantit la

portabilité des applications.


10

4.4. Contraintes temporelles

Le but principal du stage étant de faire devenir fonctionnel une application qui ne l’ai

pas, le logiciel doit absolument être opérationnel à la fin des 14 semaines de stage. Un

diagramme de Gantt a été réalisé afin de gérer au mieux les objectifs initiaux.

Figure 3. Diagramme de Gantt


11

5. Mise en œuvre

5.1. Choix techniques

5.1.1. Langage de programmation

Le langage utilisé depuis des années pour développer Anaconda est le Java. Le stage

consistant à partir du code déjà existant, la nouvelle version d'Anaconda sera elle aussi

développée en Java. La force du langage Java repose sur la puissance de son API standard

disponible. De plus la portabilité de l'application est assurée. Cette portabilité est l'une des

clés du logiciel Anaconda, car le logiciel est destiné en partie à des utilisateurs peu aisés et

qui ne font pas forcément tourner le logiciel sur la dernière version Windows de Microsoft.

En effet ils sont amenés à faire tourner Anaconda sur des systèmes alternatifs gratuit tels

que certaine distribution de Linux.

5.1.2. Fichier langue

Le logiciel Anaconda est utilisé dans de nombreux pays, en particulier en Europe,

mais aussi au niveau international. Anaconda ainsi que les autres logiciels d'intelligence

territoriale, tels que Pragma, doivent donc pouvoir être utilisés dans différents langages (en

particulier l'anglais, le français et l'espagnol). Un seul système de langage a été proposé pour

tous les logiciels développés au sein du laboratoire, il s'agit d'utiliser un fichier texte pour

chaque langage, contenant tout les termes utilisés au sein du logiciel. Le logiciel est alors

chargé de piocher dans ces fichiers textes selon la langue sélectionnée.

5.1.3. Eclipse

Les logiciels tel Anaconda, ont été développés par plusieurs développeurs et seront

dans le futur, développés à nouveau. Afin que tous fonctionnent correctement entre chaque

passage de développeur ainsi que la reprise des sources des logiciels, il a été décidé que les

logiciels développés en Java le soient dorénavant tout le temps dans le même

environnement de développement: Eclipse.

La puissance de cet environnement de développement permet d’économiser un temps

important : auto-complétion, génération automatisée des méthodes...


12

5.2. Application

5.2.1. Reprise de l'existant

5.2.1.1. Analyse

La première étape du stage a été de comprendre ce qui avait été déjà fait. Plusieurs

développeurs se sont succédé à la suite pour développer Anaconda, avec des méthodes de

travail sûrement différentes. La première chose qui sautait aux yeux à la lecture du code,

était le peu, voir la quasi-absence de commentaire. Il a donc fallu analyser les sources, six

grandes parties en sont ressorties, classées au sein d'Eclipse dans des packages distincts:

anacprocedure: différentes procédures au sein d'Anaconda telles que la gestion des

erreurs, des warning, les filtres de sélection de fichier;

engine3D: le moteur qui gère la représentation graphique, permettant de rendre une

apparence 3D au nuage de points;

ihm: l'interface du logiciel;

images: les images utilisés dans Anaconda (image du zoom, rotation etc.);

noyau: le noyau qui gère la procédure AFC, les points, les libellés;

openglEngine: le moteur openGL, pour un autre rendu graphique du nuage de points,

développé par le dernier utilisateur d'Anaconda.

5.2.1.2. Documentation

Une fois ces parties distinguées, le travail a été de corriger l'oubli des précédents

développeurs, c'est à dire mettre des commentaires et du Javadoc afin de faciliter la tâche

des développeurs futurs et ne plus être perdu dans les 20 000 lignes de code. En effet, à

chaque nouveau développeur, plusieurs dizaines d'heures étaient nécessaires afin de

décortiquer le code et le comprendre. Cette étape de « documentation » est donc là pour

réduire cette période, et faciliter toute la phase de développement.

5.2.1.3. Correction des bugs et de l'orthographe

Le bouton aide qui ne marche pas, le logiciel qui plante parfois lorsque l'on clique sur

un point, des fautes d'orthographe disséminées un peu partout dans Anaconda, tels sont les

différents problèmes initiaux rencontrés lors de la prise en main du logiciel. Les petits bugs

comme le bouton aide ont été corrigés de suite, mais d’ autres , plus gênant, ont été réglés

tout au long du développement, nous les verrons donc dans la suite. Quand aux fautes

d'orthographe, elles sont l'un des principaux critères du non-déploiement de la version 3.2

d'Anaconda, l'équipe d'intelligence territoriale a en effet une réputation très sérieuse à


13

conserver auprès de ses partenaires. Les différents problèmes ont été plus ou moins vite

corrigés.

5.2.1.4. Fenêtre données et résultats

La fenêtre données et résultats a subit de nombreuses modifications au cours des

différentes versions d'Anaconda. Cette fenêtre permet de sélectionner un ou plusieurs

points (individus ou caractère) ainsi qu'une ou plusieurs classes ou groupes. Ces points sont

alors grossis et colorisés dans le nuage de points (en bleu pour les individus, en rouge pour

les caractères et en vert pour les groupes et les classes). C'est à partir de cette fenêtre que

l'on peut dessiner des limites.

Au départ, uniquement la fenêtre "Données" existait. Dans cette fenêtre "Données",

lorsque l'on clique sur un point, il est grossi et colorisé. Dans la fenêtre "Résultats",

implémenté à partir d'Anaconda 3.X, lorsque l'on sélectionne un individu, tous les caractères

(=question) correspondant à cet individu sont sélectionnés, grossis et colorisés. Et vice-versa,

lorsqu'on sélectionne un caractère, tous les individus correspondant à ce caractère sont

sélectionnés, grossis et colorisés.

Si un individu a répondu oui à plusieurs réponses, cela correspond à "1" dans le

tableau booléen. L'individu possède alors ces caractères. Voir le diagramme ci-dessous pour

mieux comprendre.

caractère

individu

Résultats Données

Un caractère est possédé par un ou

plusieurs individus

Un individu possède un ou plusieurs

caractères


14

Pour la nouvelle version d'Anaconda développée, il était demandé de séparer en

deux fenêtres "Données" et "Résultat", pour bien différencier les deux (Cf. figure 4).

Dans l'exemple précédent, l'individu "CHP000000500" a été sélectionné dans la

fenêtre résultat. On peut alors voir dans la fenêtre données que les codes caractères RmCh,

EnOr, GeFe, CoEu, WiCo et MaMa (en autre) corresponde à cet individu. Le nuage de points

correspondant donne ceci:

Figure 4. Fenêtre Données et résultats

Figure 5. Nuage de points avec colorisation


15

5.2.2. Reprise des fonctionnalités oubliées

5.2.2.1. Paramétrages

Les anciennes versions d'Anaconda utilisaient un système de paramètre afin de

conserver les spécifications utilisées par l'utilisateur au cours de sa manipulation. La

première étape dans la phase de réhabilitation des anciennes fonctionnalités oubliées a

donc été de remettre en place ce système de paramètre.

Ce système utilise un fichier Anaconda.ini (Cf. figure 6), crée dans la racine du logiciel. Ce

fichier conserve plusieurs données:

La langue utilisée,

les derniers fichiers utilisés: permet de rouvrir automatiquement le dernier fichier

utilisé lors de l'ouverture du logiciel, et de pouvoir, à l'aide du menu, rouvrir

aisément un des derniers fichiers utilisés,

la taille du nuage,

la taille des points (nouveauté),

les tailles des fenêtres,

les dimensions des fenêtres.

Figure 6. Fichier de paramètre


16

Ce fichier est sauvegardé lorsque l'utilisateur quitte le logiciel avec la croix ou en passant par

le menu Fichier/Quitter. Lors du démarrage d'Anaconda, le logiciel teste si le fichier

Anaconda.ini est présent. S'il ne l'est pas, les paramètres par défaut sont alors utilisé (figure

7).

5.2.2.2. Barre d'état

Une autre fonction oubliée d'Anaconda 2.2 est la barre d'état (Cf. figure 8). Cette barre

contient plusieurs informations:

La taille du nuage de points,

le total de caractères et d'individus pour le nuage de points,

le nombre de caractères et d'individus sélectionnés,

la taille des points (nouveauté).

Cette barre possède aussi deux fonctionnalités:

Modifier la taille du nuage de points,

Figure 7. Paramètre par défaut


17

modifier la taille des points (fonctionnalité nouvelle demandée au cours du stage).

5.2.2.3. Contrôle du fichier booléen

L'une des grosses différences entre la version 3.2 d'Anaconda et la version 2.2, est le

manque de contrôle du fichier booléen lors de la génération du fichier nge. En effet, pour

des raisons inconnues, le développeur de la 3.2 n'a pas conservé cette étape de contrôle, qui

garantie pourtant le bon fonctionnement des calculs, et qui est donc absolument nécessaire

pour une version stable d'Anaconda. Une refonte de cette étape a donc été réalisée.

Le fichier booléen résulte du logiciel Pragma. Ce logiciel est développé au sein du

laboratoire et subit lui aussi une refonte par un stagiaire: Simon Marthey. Pragma permet

de créer des questionnaires, et produit à partir des réponses à ces questions, un fichier de

sortie: le fichier booléen. Ce fichier booléen contient les réponses aux questions (les

caractères) posées aux personnes sondées (les individus).

La première ligne du fichier contient les codes des caractères, séparés par des

tabulations. De plus cette première ligne doit commencer par une tabulation. Les codes des

caractères doivent être composés de quatre caractères alphanumériques. Le premier

Figure 8. Barre d'état (en bas)


18

caractère peut être en minuscule ou en majuscule: minuscule indique que le caractère est

passif, majuscule indique qu'il est actif. Le deuxième caractère doit être une minuscule, le

troisième une majuscule et le quatrième une minuscule ; si ce n'est pas le cas, la phase de

contrôle est chargée de renommer les codes avec les bonnes minuscules et majuscules, un

message type "warning" est alors généré. Les noms des codes caractères doivent être tous

différents.

Toutes les autres lignes contiennent le code des individus dans la première colonne,

suivies par les réponses aux caractères séparées par des tabulations: 0 pour non, 1 pour oui,

ou alors un numérique (peu courant). Le nombre de ces valeurs doit être égal au nombre de

code caractère. Le premier caractère du code individu doit être une lettre (minuscule =

passif, majuscule = actif), les autres doivent être alphanumériques. Les noms des codes

individus doivent être tous différents.

Si il y a une erreur, l'utilisateur doit quitter mais il peut décider de continuer quand

même l'exécution du programme, la bonne génération du nuage de points n'est alors plus

garantie (figure 9).

Figure 9. Exemple d'une erreur type


19

5.2.2.4. Inversion des couleurs

Dans Anaconda 2.2, une fonction bien pratique était en place. Cette fonction

permettait d’inverser les couleurs, les points blancs devenant noir et le fond noir devenant

blanc ( Cf. Figure 10). Cette fonction a pour but principal une meilleure lisibilité du nuage

dans des documents tel que les rapports. Cette fonction a donc été ré-implémenté dans

Anaconda 3.3.

Figure 10. Nuage de points avec couleurs inversées

5.2.3. Nouvelles fonctionnalités

5.2.3.1. Convertisseur de fichier tab en fichier bol

Anaconda étant utilisé depuis de nombreuses années, le système de fichier n'a pas

toujours été le même. Certains fichiers en .tab ont donc besoin d'être reconvertis pour

pouvoir être utilisés au sein d'Anaconda 3.3. L'implémentation d'une telle fonction a donc

été demandée.


20

Les fichiers en "nomFichier.tab" ne sont pas écrits de la même façon qu'un fichier

booléen, les données sont espacées par des lignes au lieu des traditionnelles tabulations. De

plus certaines données ne sont pas nécessaires à l'écriture du fichier nge.

Le convertisseur se charge donc de conserver les données essentielles et de les

réécrire correctement tabulées comme elles se doivent. Le convertisseur crée en sortie le

fichier "nomFichier-bol.xls" correspondant.

5.2.3.2. Création d’un fichier perfiles

Une des demandes additionnelles ajoutée en cours de stage a été l'implémentation

d'une étape de création d'un fichier après la génération du fichier nge et avant la génération

du nuage de points. Ce fichier se compose de nombreuses informations piochées dans les

différents fichiers relatifs au booléen:

Le numéro d'ordre du tableau nge (ordre dans lequel les individus apparaissent);

Le libellé long si le fichier -cod est présent, sinon rien;

Le libellé court (vide);

La définition (vide);

La fréquence Frq, présent dans le fichier -cod;

Ctr= Ctr1+Ctr2+Ctr3/3;

Ctr1, 2 et 3 présents dans le fichier -nge;

Cl# présent dans le fichier -spi;

Cl1 à Cln, le nombre d'individus qui possèdent le caractère: Cpl/FrqCl;

Cl1 à Cln, le pourcentage par rapport à la fréquence du caractère: FrqCl/Frq;

Cl1 à Cln, le pourcentage par rapport au nombre d'individus dans la classe.

Le fichier ainsi créée est appelé nomFichier-perfiles.xls


21

5.2.3.3. Grossissement des points

Lorsque le nuage de points est affiché avec un projecteur, les points sont difficilement

visibles (sur un mur, un tableau…). Au cours de ces semaines, une proposition a été faite afin

de pouvoir changer la taille des points et ainsi pouvoir représenter clairement le nuage de

points obtenu lorsque la résolution est élevée (exemple avec la figure 11 et 12).

5.3. Problèmes rencontrés

Le principal problème rencontré a été le temps d’exécution du contrôle du fichier

booléen, de l’AFC (Analyse Factorielle des Correspondances) et de la génération du nuage de

points. Lorsque le fichier booléen possède un grand nombre d’individu (80 000 par exemple),

le temps d’exécution devient très long, même sur une machine récente. En effet ces

différentes étapes comportent de nombreuses boucles qui parcourent tous les individus. La

majorité des fichiers booléens ne possède pas autant d’individus et ne pose donc pas de

problème. D’ailleurs les anciennes versions d’Anaconda possédaient une limite pour le

nombre d’individus (5000 pour la version 2.0). Ce problème algorithmique n’a pas encore

été réglé à l’heure de la rédaction de ce rapport.

L’autre gros problème a été, comme spécifié précédemment, la compréhension des

sources initiales. En effet le code était très peu commenté, et lourd (20 000 lignes). Plusieurs

semaines de prise en main, et de compréhension ont été nécessaires. Avant de comprendre

Anaconda précisément, il a aussi fallu comprendre l’ensemble du concept Catalyse (Cf. 3.2).

Figure 12. Nuage de points taille 3 Figure 11. Nuage de points taille 1


22

5.4. Développement futur

Un des aspects que je n'ai pas traité est le rendu graphique avec OpenGL au lieu de

logiciel. En effet, la représentation du nuage de points peut être générée en OpenGL, avec

des boules à la place des cubes pour un rendu plus précis. Ce rendu a été réalisé par le

développeur de la version 3.2 d'Anaconda. A l'époque il avait privilégié développer ce

moteur plutôt que de ce concentré à ré-implémenter les fonctionnalités présentes dans les

versions antérieures.

Pour ma part, contrairement à l'ancien développeur, j'ai privilégié une version

d'Anaconda fonctionnelle, c'est pour cela que je n'ai presque pas touché la partie OpenGL.

La taille du point et du nuage ne sont donc par exemple pas gérés avec ce rendu. De plus, ce

rendu graphique n'est pas réellement de la 3D, il aurait fallu pour cela utiliser Java 3D. Java

3D aurait pu par exemple réduire le temps de génération du nuage de points, car la

génération actuelle est lourde de ressource, elle simule la 3D avec du 2D.

Le principal problème que le prochain développeur potentiel aura à gérer est le

temps d'exécution du programme, en effet comme décrit précédemment, lorsqu'il y

énormément d'individus le programme est très long.


23

6. Présentation de l'application

Au lancement du logiciel, le programme regarde si un fichier paramètre préexistant

se trouve à la racine de l'application. S'il existe, il charge le dernier fichier nge utilisé avec les

derniers paramètres enregistrés. Sinon la fenêtre s'ouvre, et l'utilisateur doit sélectionner un

fichier booléen ("nomFichier-bol.xls" ou "nomFichier.txt"). Un contrôle est alors effectué sur

ce fichier booléen pour vérifier son écriture (Cf. 5.2.2.3).

6.1. Génération des fichiers (en particulier le nge)

Une fois le fichier booléen importé, et les contrôles adéquates réalisés, les calculs

générant le fichier nge s'exécutent (Analyse Factorielle des Correspondances et classification

ascendante hiérarchique. Ces calculs ont été programmés dès la première version

d'Anaconda en 1981! Ensuite, le fichier "nomFichier-perfiles.xls" est généré. 8 fichiers sont

ainsi générés plus le fichier booléen (Cf. Figure 13):

-bol.xls

-Cpl.xls

-Ctg.xls

-Nge.xls

-perfiles.xls

-Rad.txt

-Spi.txt

-Tkg.txt

-Vec.txt

Ces différents fichiers sont utiles à l'analyste, qui peut dès à présent vérifier certain calcul

pour vérifier la pertinence de son enquête.

Figure 13. Exemple avec le projet PDI94


24

6.2. Génération du nuage, rendu logiciel

A partir du fichier nge généré, le logiciel est alors capable de générer le nuage de

points. Par défaut les points sont affichés en blanc et le fond en noir (figure 14).

6.3. Génération du nuage, rendu OpenGL

Un autre rendu est aussi possible en OpenGL, les points du nuage sont alors des

boules à la place des traditionnels cubes (figure 15).

Figure 14. Nuage de points du projet PDI94

Figure 15. Nuage de points du projet PDI94 avec rendu OpenGL


25

6.4. Manipulation

Une fois le nuage généré, les manipulations qu'un analyste souhaiterait faire sont

alors possibles. Libre à lui de sélectionner les points adéquats, tracer des limites, afficher les

libellés (Cf. Figure 16). Une barre d’outils est présente pour manipuler différents éléments

du nuage:

Afficher ou non les axes;

Créer une limite manuellement;

Sélectionner les points à l'aide d'un rectangle;

Sélectionner les points à l'aide d'un cercle;

Afficher la vue axe XY, XZ ou YZ;

Afficher tous les points, que les points sélectionnés, aucun point;

Faire des rotations suivant l'un des trois axes

Zoomer, dé-zoomer.

Figure 16. Anaconda vue globale


26

7. Bilan Nous pouvons tirer un bilan de cette expérience, en termes d’apports pour l’intelligence

territoriale et sur le plan pédagogique.

7.1. Bilan pour l’intelligence territoriale

Maintenant que le projet arrive à sa fin, avec ses spécifications respectées, la version

3.3 d’Anaconda est sur le point de pouvoir être utilisée pour des représentations

graphiques, et ainsi pouvoir analyser des données sans rencontrer les problèmes liés à la

version 3.2. En effet, la plupart des fonctionnalités disparues d’Anaconda 2.2 ont été

réintégrées, les bugs ont été corrigés, et de nouvelles fonctionnalités sont apparues

telles le grossissement des points ou le convertisseur de fichier tab.

Le programme est maintenant suffisamment commenté pour pouvoir être repris par

un futur développeur afin de développer et améliorer une éventuelle future version.

7.2. Bilan humain

Travailler au sein de l’équipe d’intelligence territoriale, dans un réel laboratoire à

compétence pluridisciplinaire, a été une expérience très enrichissante. J’ai vraiment

apprécié d’être supervisé par M. Girardot, qui a passé du temps à répondre à mes

questions avec cordialité. Mais ce stage a été avant tout un travail d’équipe. De

nombreuses réunions pour faire le point de l’avancement et des idées pouvant être

intégrées au projet ont été réalisées tout au long de ces 14 semaines de stage (tout les

10 jours en moyenne) avec la plupart des intervenants aux outils Catalyses.

De plus, le travail a été réalisé en étroite collaboration avec les deux autres stagiaires

informaticiens présents : Amine et Simon. Ils travaillaient pour leur part sur l’outil

d’analyse économique précédent Anaconda dans l’étape de traitement des données :

Pragma.

Ce n’était que la deuxième fois que j’utilisais mes compétences informatiques dans

un contexte autre que l’école, mais une première fois dans une entreprise française

après le stage passé à Portsmouth en Angleterre l’année dernière. J’ai ainsi pu corriger

certaines lacunes que je m’étais découvertes il y a un an, et améliorer mes points forts.

De ce point de vue je peux dire que l’expérience a été très satisfaisante. De plus

développer un logiciel qui sera ensuite utilisé par des dizaines d’utilisateurs est plus


27

motivant que de développer un logiciel qui sera utilisé seulement quelque fois par un

seul utilisateur.

7.3. Bilan pédagogique

Ce stage m’a offert la possibilité de mettre en application les connaissances et

méthodes apprises durant le cursus, et de les confronter à un projet important en terme

de volume et de responsabilité.

Avec Anaconda, j’ai pu perfectionner un langage que je commençais à bien maitriser:

le Java. Dans le cadre de la licence, le java a été utilisé à mainte reprise à la fois en cours

lors des TP mais aussi lors de mon projet tutoré. C’est aussi dans ce langage que j’ai

développé mon projet tutoré lors de mon DUT informatique l’année dernière. Ces 14

semaines de stage ont donc été l’occasion de mettre en pratique dans un cadre

professionnel toute la connaissance acquise auparavant.

Ce stage m’a aussi permis de planifier tout mon travail, avec un diagramme de Gantt

et des réunions presque hebdomadaires. Tout était planifié pour être le plus organisé

possible. Ces derniers points sont la grande différence entre le travail que j’effectuais

dans le cadre de ma licence et mon travail au sein du laboratoire.

Ce projet a donc été très enrichissant d’un point de vue pédagogique puisque mes

connaissances ont pu être mises en application dans un autre contexte que celui du

développement de programmes simples, mais également parce que j’ai eu l’occasion de

les approfondir.


28

8. Conclusion

Ce stage au sein de l’équipe d’intelligence territoriale a été pour moi la seconde

expérience professionnelle dans le domaine de l’informatique après le stage réalisé à

Portsmouth aux Royaume-Uni dans le cadre de la fin de mon DUT informatique. A ce titre,

cette expérience a été très enrichissante d’un point de vue humain et pédagogique.

La conduite d’un projet peut être compliquée, l’organisation du travail devant être

clairement définie afin que tout se passe pour le mieux. De plus il faut toujours garder à

l’esprit que l’application s’inscrit dans un contexte précis, afin de répondre du mieux

possible aux exigences des responsables.

Reprendre une application développée dans le passé par plusieurs développeurs

successifs était une première pour moi. S’approprier un sujet que l’on n’a pas débuté n’est

pas chose facile, en effet l’application faisait plus de 20 000 lignes de code et n’était que très

peu commentée. Cela m’a permis de réfléchir sur mon travail, en me mettant à la place de

celui qui prendrait la suite du développement et donc de penser en terme durable.

Pour conclure, ce stage a été l’occasion de prouver mes capacités d’informaticien. J’ai

senti que j’étais plus à l’aise et organisé que lors de mon précédent stage et je peux

maintenant envisager plus sereinement mon avenir en entreprise.


29

ThéMA (Théoriser et Modéliser pour Aménager) : unité mixte de recherche qui associe le

CNRS, les universités de Franche-Comté et de Bourgogne ; elle s’intègre aux Maisons des

Sciences de l’Homme de ces deux universités. Elle fonctionne sur deux sites à Dijon et à

Besançon, siège de l’UMR. Unité pluridisciplinaire, elle est composée de géographes,

d’économistes, d’informaticiens et de civilisationnistes.

API (Application Programming Interface) : Une interface de programmation est un

ensemble de fonctions, procédures ou classes mises à dispositions des programmes

informatiques par une bibliothèque logicielle, un système d'exploitation ou un service. la

connaissance des API est indispensable à l'interopérabilité entre les composants logiciels.

Catalyse : Méthode proposant des outils de diagnostic, d’évaluation et d’observation

accessibles aux acteurs locaux du développement territorial durable. Ces outils sont

utiles pour élaborer des projets de développement pertinents, pour gérer efficacement

ces projets, puis pour les évaluer et pour apprécier leur impact.

OpenGL (Open Graphics Library) : Spécification qui définit une API multiplateforme pour

la conception d'applications générant des images 3D.

Diagramme de Gantt : Outil utilisé en ordonnancement et gestion de projet et

permettant de visualiser dans le temps les diverses tâches liées composant un projet. Il

permet de représenter graphiquement l'avancement du projet.

JAVA : Le langage Java est un langage de programmation informatique orienté objet. Il a

la particularité principale que les logiciels écrits avec ce dernier sont très facilement

portables sur plusieurs systèmes d'exploitations.


30

Figure 1. Outils de la méthode catalyse ..................................................................................... 4

Figure 2. Exemple d'un nuage de points..................................................................................... 5

Figure 3. Diagramme de Gantt ................................................................................................. 10

Figure 4. Fenêtre Données et résultats..................................................................................... 14

Figure 5. Nuage de points avec colorisation ............................................................................ 14

Figure 6. Fichier de paramètre ................................................................................................. 15

Figure 7. Paramètre par défaut ................................................................................................ 16

Figure 8. Barre d'état (en bas) .................................................................................................. 17

Figure 9. Exemple d'une erreur type......................................................................................... 18

Figure 10. Nuage de points avec couleurs inversées ................................................................ 19

Figure 11. Nuage de points taille 1 ........................................................................................... 21

Figure 12. Nuage de points taille 3 ........................................................................................... 21

Figure 13. Exemple avec le projet PDI94 .................................................................................. 23

Figure 14. Nuage de points du projet PDI94 ............................................................................ 24

Figure 15. Nuage de points du projet PDI94 avec rendu OpenGL ............................................ 24

Figure 16. Anaconda vue globale ............................................................................................. 25


31

Site internet:

1 http://www.siteduzero.com/ De nombreux tutoriaux en JAVA

2 http://java.developpez.com/ Importante communauté francophone dédiée

au développement informatique, en

particulier le Java.

3 http://java.sun.com/j2se/1.5.0/docs/api/ L’API (interface de programmation) de

JAVA


32

La méthode Catalyse propose des outils de diagnostic, d’évaluation et d’observation

accessibles aux acteurs locaux du développement territorial durable. Ces outils sont utiles

pour élaborer des projets de développement pertinents, pour gérer efficacement ces

projets, puis pour les évaluer et pour apprécier leur impact.

Destinés aux acteurs du développement durable, ces outils respectent et favorisent

les principes de participation, d’approche globale et de partenariat. Ils facilitent la

mobilisation de partenariats de développement constitués de professionnels travaillant dans

des services publics, des organismes privés et de bénévoles actifs dans des associations. Ils

garantissent une animation participative du partenariat.

Pour réaliser des outils accessibles et utiles aux acteurs, Catalyse adapte des

méthodes fondamentales et des instruments génériques de large applicabilité. Ce sont des

méthodes d’analyse statistique et spatiale des données, des protocoles de gestion de projet

et d’évaluation, des bases de connaissances, des systèmes d’édition scientifique et

technique, des systèmes d’information géographiques, qui utilisent les technologies de

l’information et de la communication.

Catalyse utilise notamment les logiciels conviviaux conçus pour les chercheurs en

sciences humaines et sociales qui ont été réalisés par l’équipe de recherche en intelligence

territoriale de ThéMA :

Le logiciel Pragma de dépouillement quantitatif d’enquêtes ;

Les logiciels Anaconda et Nuage d’analyse qualitative des données, qui combinent

analyse factorielle des correspondances et classification ascendante hiérarchique ;

Le système d’information territorial Sitra, conçu en partenariat avec le Laboratoire

d’Informatique de l’université de Franche-Comté. La méthode CATALYSE confronte

trois types d’informations et utilise à cette fin trois séries d’outils, selon le schéma

suivant :


33

1. Les outils de diagnostic et d’évaluation mutualisent et traitent les informations

individuelles multisectorielles pour définir des profils de besoins et pour en mesurer

l’importance, afin de proposer les services adaptés à ces besoins. Les mêmes outils servent

ensuite pour évaluer les actions qui délivrent des services aux personnes. Ces outils sont les

suivants :

Le guide de diagnostic et d’évaluation recueille les informations individuelles selon

une approche multisectorielle. Ce guide est divisé en thèmes comportant plusieurs

questions. Pour faciliter l’exploitation du guide, chaque question est rédigée sous

forme fermée, elle propose le choix entre plusieurs modalités de réponse.

Une version spécifique du logiciel PRAGMA calcule des tableaux de bord quantitatifs.

Les logiciels d’analyse qualitative multicritère ANACONDA et NUAGE établissent une

typologie des personnes en fonction de leurs profils de besoins.

2. Le répertoire de services est une base de données actualisable et consultable en ligne. Il

inventorie les services aux personnes accessibles aux habitants du territoire. Chaque service


34

est décrit grâce à un formulaire dont les contenus sont structurés, comme pour le guide, en

thèmes, descripteurs et modalités. La correspondance entre les questions du guide et les

descripteurs du répertoire permet la comparaison entre les besoins diagnostiqués et les

services inventoriés. Cette confrontation entre demande et offre permet d’évaluer la

pertinence des services existants et d’identifier les services manquants, de façon à adapter

l’offre de services aux besoins exprimés.

3. Le système d’indicateurs territoriaux intègre une sélection d’informations à caractère

socio-économique décrivant le territoire et la communauté territoriale. Ces données sont

constituées et fournies par les services statistiques d’institutions spécialisées. Certains

indicateurs sont accessibles en ligne. Le système d’indicateurs territoriaux édite des cartes

de besoins, de services et d’indicateurs territoriaux. Elles permettent de comparer la

répartition territoriale des besoins avec celle des services et, éventuellement, avec les

indicateurs territoriaux, pour optimiser la localisation des services.

Les logiciels PRAGMA et ANACONDA peuvent également être utilisés pour analyser les

services et les indicateurs contextuels, quantitativement et qualitativement.


35

Préalable

Afin de pouvoir utiliser Anaconda sur votre ordinateur, vous devez avoir une version

à jour de Java.

Installation

Pour installer le logiciel Anaconda, vous devez tout d'abord le télécharger sur le site

Internet de la Communauté Catalyse, sur la page des téléchargements:

http://www.territorial-intelligence.eu/catalyse/?page_id=6&lang=fr

Au moment de la rédaction de ce manuel utilisateur, Anaconda 3.3 n'est pas encore

disponible au téléchargement.

Après le téléchargement, un fichier nommé "Anaconda 3.3.jar" apparaît sur votre bureau.

Vous n'avez alors plus qu'à l'ouvrir en cliquant dessus.

Le logiciel démarre alors : au lancement, un explorateur de fichier s'ouvre pour vous

demander de choisir le fichier "source" à utiliser. Un tel fichier doit avoir l'une des

extensions suivantes : .nge, .txt, -nge.xls ou -bol.xls.

Quand vous avez choisi le fichier qui vous intéresse, le nuage se crée.

Présentation des menus d'Anaconda 3.3

a) Fichier

Créer un projet : nouveau projet, on part du fichier booléen et on lance une

génération du fichier -nge;

Ouvrir un projet: projet déjà existant, on ouvre un fichier -nge;

Fichier récent: possibilité d'ouvrir un des derniers fichiers utilisés;

Enregistrer: efface la version précédente du nuage;

Enregistrer sous: permet d'enregistrer sous un nouveau nom en conservant la version

précédente;

Exporter l'image: permet d'exporter la représentation graphique du nuage, en format

bmp, jpeg ou png;


36

Quitter: pour quitter le programme, un message de confirmation s'ouvre afin de

pouvoir sauvegarder le projet.

b) Edition

Langues: choix de la langue du logiciel à utiliser entre le Français, l'Espagnol et

l'Anglais;

Effacer la sélection: efface le tracé, le sélectionné dans le nuage de points;

Conversion tab - bol: pour convertir un fichier .tab en -bol.xls;

Inverser couleurs: inverse les couleurs du nuage de points, à utiliser pour des images

du nuage dans des rapports, documents, projection etc.

c) Etiquette

Afficher les libellés des individus;

Afficher les libellés des caractères;

Afficher les libellés des groupes.

d) Limites

Dessin automatique: trace la limite des points sélectionnés;

Afficher toutes les limites: toute les limites créées par l'utilisateur sont affichées;

Afficher les limites sélectionnées: uniquement la limite sélectionné est affiché;

Masquer les limites: aucune limite n'est affichée.

e) Fenêtre

Affiche, ou cache la fenêtre correspondante.

Nuage: la fenêtre du nuage de points (à gauche par défaut);

Données: la fenêtre des données du nuage de points (au milieu par défaut);

Résultat: la fenêtre des résultats du nuage de points (à droite par défaut);

Code des données (inactif pour l'instant);

Console: la console qui affiche les informations concernant les calculs (en bas par

défaut).

f) Aide

Liens vers la documentation (wiki de la méthode Catalyse)


37

Représentation graphique

Pour obtenir la représentation graphique de vos résultats, vous devez ouvrir le fichier

que Pragma a produit suite à la saisie des réponses au questionnaire qui vous intéresse. Pour

cela, au lancement du logiciel Anaconda, vous devez trouver le fichier qui vous intéresse

dans la fenêtre d'exploration qui s'ouvre alors.

Espace supérieur

Dans la partie supérieure de l'écran, vous pouvez voir la barre de menu (présenter

précédemment), ainsi qu'un espace, découpé en trois parties, présentant diverses

informations concernant la représentation graphique.

1. Espace "Points" :

Code : indique le code sélectionné (on ne peut pas le modifier)

Libellé court : s'il y en a un ; sinon possibilité de compléter ce champ.

Libellé long : s'il y en a un ; sinon possibilité de compléter ce champ.

Couleur : couleur des points sélectionnés.

2. Espace "Descripteurs“ :

génération auto : permet de générer de manière automatique les descripteurs (pour

son utilisation voir la chapitre "Création automatique des descripteur".


38

génération manuelle : permet de générer manuellement des descripteurs (pour son

utilisation voir le chapitre "Création manuelle d'un descripteur".

3. Espace "Limites" :

Il indique l'épaisseur du trait, le type de trait, ainsi que la couleur de la limite définie.

Fenêtres

Vous avez également à l'écran quatre fenêtres : une fenêtre "Cloud" qui présente le

nuage ainsi que la boîte à outils permettant de modifier la représentation graphique ; une

fenêtre "Données" qui présente les individus et caractères en "données" ; une fenêtre

"Résultat" qui présente les groupes (descripteurs) ainsi que les points (individus et

caractères en "résultat") ; et enfin une fenêtre de commentaires, intitulé "Console", si elle

est activée (propose les commentaires de toutes les actions réalisées : sélection de points,

création de descripteur, etc.).

La fenêtre "Nuage" (présenté dans la partie gauche de l'écran) présente le nuage de points,

ainsi que les trois axes (axe 1 en rouge, axe 2 en vert et axe 3 en bleu). On trouve également

dans cette fenêtre les outils permettant de modifier l'aspect de la représentation graphique :

Voici, dans l'ordre, la signification des différents boutons de cette barre de menu :

Permet de revenir à la position de départ

Permet d'afficher ou non les axes

Permet de sélectionner une zone du nuage de manière libre

Permet de sélectionner une zone du nuage sous une forme rectangulaire

Permet de sélectionner une zone du nuage sous une forme circulaire

Présente le nuage selon les axes 1 et 2



Tous les points sont représentés, les points sélectionnés sont de couleur différente

Seul, les points sélectionnés sont représentés

Aucun élément n'est représenté

Rotation selon axe 1



Rotation selon axe 1 (sens horaire)



Avancée du zoom

Recul du zoom

http://www.territorial-intelligence.eu/catalyse/doc/index.php?title=Image:BarreOutils2.jpg

http://www.territorial-intelligence.eu/catalyse/doc/index.php?title=Image:BarreOutils.jpg


39

Création manuelle d'un descripteur

Avec cette version, vous pouvez créer un descripteur à partir de descripteurs déjà

existants. Pour cela, dans la partie "Groupes" de la fenêtre "Résultat", vous sélectionnez

dans la colonne de gauche les descripteurs que vous souhaitez regrouper (dans le cas des

descripteurs relatifs à une même question, leur code commence par les deux mêmes lettres)

en cliquant dessus et en maintenant la touche majuscule de votre clavier enfoncée.

Puis vous cliquer sur le bouton "génération manuelle", qui se trouve dans la partie

supérieure de votre écran (au centre).

Une fenêtre s'ouvre pour vous demander le nom du descripteur. Une fois le nom complété,

vous validez en cliquant sur OK. Le nouveau descripteur apparaît alors dans la colonne de

droite de la partie "Groupes" dans la fenêtre "Résultat".

Si vous souhaitez modifier un descripteur, vous pouvez le faire directement dans la partie

supérieure de votre écran, dans la partie "Points" :

Vous cliquez dans la cellule "Libellé court" et vous pouvez changer le code du descripteur

créer. Pour valider votre changement, appuyer sur la touche "Entrée" de votre clavier.

Vous pouvez également compléter un libellé long dans la cellule correspondante.

Génération automatique des descripteurs

Vous avez la possibilité de regrouper de manière automatique les caractères de

chaque question en un unique descripteur. Pour cela, vous cliquez sur le bouton "génération

automatique" qui se trouve dans la partie supérieure de votre écran. En quelques secondes,

les regroupements se feront et les descripteurs seront créés dans la colonne de droite de la

partie "Groupes" dans la fenêtre "Résultat" : les descripteurs créés ont alors pour code les

deux premières lettres (communes) des caractères initiaux.

Dans le cadre de la Licence Professionnelle Système Informatique et Logiciel, j'ai

effectué un stage dans l'équipe d'intelligence territoriale du laboratoire ThéMA.

Le travail effectué consistait à reprendre le développement d'un logiciel d'analyse de

données économique et accessible à tous appelé Anaconda. Ce logiciel utilise des données

fournies par le logiciel Pragma pour en faire une représentation 3D. Les analystes peuvent

alors tirer des conclusions des résultats affichés.

Ce rapport présente les différents aspects du projet.

Mots clés :

Anaconda, Données, résultats, représentation 3D, nuage de points, individus, caractères,

groupes, classes

As part of the professional degree of Computer Science, I did an internship in the

territorial intelligence team inside the ThéMA laboratory.

This project consisted in taking over software of data analysis cheap and accessible

called Anaconda. This software uses the date provided by the Pragma software to make a 3D

representation. Then, Analysts can draw conclusions from the display results.

This report presents the different aspects of the project.

Key words:

Anaconda, Data, results, 3D representation, point cloud, individuals, characters, groups,

classes

anaconda: une solution d'analyse de données · de commencer ce rapport de stage pa des eme...

Documents