h1. %{color:darkred}Présentation générale de la plateforme, grands principes%

|{width:4000px;text-align:left;border-color:transparent}. !/attachments/download/18/en_US.png! [[En_introduction|...english version of this page]] |

Cette section présente la philosophie et les concepts importants de *Computree*.

h1. Philosophie

p<>. Le but de *Computree* est de permettre le traitement de nuages de points 3D, pour en extraire des informations utiles, comme par exemple :
* Des indicateurs
* Des formes géométriques simples (ex. : des cylindres pour des troncs d'arbres détectés dans une scène forestière)
* Des informations de nature géographique (ex. : modèle numérique de terrain sous la forme d'un raster)

p<>. La plateforme se place dans une logique de Recherche et Développement. L'idée est donc de permettre à l'utilisateur de créer de façon intéractive une séquence algorithmique permettant, à partir de données chargées, d'aboutir aux résultats souhaités. Cette séquence - plutôt un arbre hiérarchique en fait, car il est possible de ramifier cette séquence en chaînes algorithmiques parallèles - est décomposée en étapes algorithmiques unitaires, réalisant des traitements spécifiques. 

p<>. Les étapes sont regroupées dans des plugins, ce qui permet d'enrichir facilement la plateforme avec de nouveaux traitements. 

p<>. Après l’exécution de la séquence algorithmique, les résultats intermédiaires de chaque étape unitaire sont disponibles, exportables et visualisables, ce qui permet une analyse poussée de la qualité des traitements effectués.

p<>. La plateforme a été développée avec la philosophie suivante :

* *Modularité* : les algorithmes sont regroupés dans des plugins développés indépendamment.

* *Ouverture* : le cœur du système est sous licence GPL/LGPL(http://www.gnu.org/). La licence de chaque plugin est laissée au libre choix de son développeur. 

* *Portabilité* : par l'utilisation du framework c++/Qt (http://qt-project.org), elle peut être compilée sous Windows (Xp et suivants), Mac OS X (Lion et suivants) et Linux (Ubuntu 12.04 et suivants, voir le site de Qt pour les autres distributions), en architecture 32 ou 64 bits. 

* *Performance* : par l'utilisation du c++, et les possibilités de traitement Multi-Coeurs offertes par Qt, elle vise à optimiser les temps de calcul.

p<>. L'objectif est ainsi de permettre à différentes équipes de collaborer autour du traitement de scène 3D forestières.

p<>. Mais si la plateforme permet une logique collaborative de R&D, elle est également prévue pour permettre un passage facile des méthodes développées dans un environnement de production (en gestion forestière par exemple). En effet, le système rend aisée la création d'interfaces adaptées à des besoins spécifiques, en utilisant le cœur et les plugins de façon transparente.

h1. Architecture générale

!architecture.png!

p<>. La plateforme Computree est composée des éléments suivants :

* *Un coeur*, chargé de la gestion des étapes algorithmiques, et proposant les structures de données et fonctionnalités génériques

* *Une interface graphique standard* (_ComputreeGUI_), plutôt orientée pour des utilisateurs en Recherche ou en R&D, permettant de contruire, d'exécuter et d'analyser les resultats de séquences algorithmiques plus ou moins complexes.

* *Un mode batch*  permettant d'utiliser des interfaces de traitement automatisé et/ou par lots. 

* *De plugins*,  développés par les équipes souhaitant enrichir Computree avec de nouvelles étapes algorithmiques (ou autres fonctionnalités).

h1. Structures de traitement et de gestion des données

p<>. Pour traiter les données, Computree utilise un *arbre d'étapes*,  exportable en tant que *script* (extension .xsct2). La racine de l'arbre est une étape de chargement ou de création de données. Ensuite chaque étape est attachée à une étape mère. L'arbre des étapes peut être intégralement constitué avant d'exécuter les calculs. 

p<>. Les *étapes* sont implémentées dans les *plugins* (indépendants). Chaque étape prend en entrée des résultats issus de l'étape précédente, et produit d'autres résultats en sortie. 

p<>. Les *résultats* contiennent les données en elles-mêmes. Pour permettre l'enchaînement d'étapes développées indépendamment, les résultats stockent les données dans des éléments génériques définies dans le cœur.

p<>. Ces éléments génériques sont de deux natures : 

* Des *groupes* permettent de créer une structure hiérachique dans le résultat
* Les *items* sont les données en elles-mêmes, hébergées dans les groupes des différentes niveaux

!str_resultat.png!

p<>. _Sur ce schéma est représentée une structure de *résultat* permettant d'illuster la structuration par les *groupes*, et le stockage des données dans des *items* contenus dans ces groupes. A noter que pour chaque *niveau de groupe*, l'étape peut produire un nombre indéterminé de réalisations de cette structure. Ainsi si l'algorithme a détécté n arbres, la structure sera créée n fois, contenant à chaque fois des points et des cylindres différents, ainsi qu'un nombre de branches variable d'un arbre à l'autre._ 

p<>. Pour que l' *arbre d'étapes* puisse être constitué intégralement avant execution, il est nécessaire que les étapes puissent communiquer entre-elles, afin de déterminer leur compatibilité.

p<>. Pour ce faire, chaque résultat est doté d'un *modèle de résultat OUT* décrivant sa structure :
* L'agencement hiérachiques des niveaux contitués par les *groupes*
* Le contenu en *items* de chaque niveau de groupe

notice. Ces modèles sont nommés OUT, car il décrivent la structure de résultat produite par l'étape en *sortie*.

p<>. Les étapes quant à elle sont dotées de *modèles de résultats IN*. Ce sont des *cahiers des charges* permettant à l'étape de tester des *modèles de résultats OUT* issus des étapes précédents, et de déterminer si elle peut les utiliser en entrée. 

notice. Ces modèles sont nommés IN, car il décrivent la structure de résultat souhaitée en *entrée* par une étape. 

!arbre_etapes.png!

p<>. _Sur ce schéma, les étapes 1 et 3 proviennent d'un plugin, alors que l'étape 2 provient d'un autre. Les flèches rouges représentent l'enchaînement des étapes. Les flèches bleues, la production de résultats par les étapes. Les flèches noires, les tests de compatibilité réalisés par les étapes sur les modèles de résultats OUT candidats, à l'aide de leurs modèles de résultats IN._

h1. Contenu des plugins

p<>. Les plugins peuvent étendre les fonctionnalités de *Computree* en fournissant des éléments d'une ou plusieurs catégories :
* Des *étapes* : c'est l'élement le plus courant dans les plugins. Une étape prend un ou plusieurs résultats en entrée et produit un ou plusieurs résultats en sortie.
* Des *types d'items* : même si ce n'est pas préconisé (pour conserver la généricité des étapes), un plugin peut définir ses propres types d'items. 
* Des *readers* : ce sont des formats de fichiers utilisables par les étapes de chargement de données.
* Des *exporters* : ce sont des éléments permettant d'exporter certains types d'items dans certains formats de fichiers. Un exporter peut être utilisé directement par l'interface graphique ou au sein d'une étape. 
* Des *actions* : ce sont des méthodes de traitement intéractif des données. Une action peut être utilisée directement par l'interface graphique et / ou au sein d'une étape, qui du coup nécessitera une intervention de l'utilisateur à l'execution. 

notice<>. Le *plugin Base*, fourni en standard avec *Computree*, contient des *étapes* utilitaires, des *readers* et *exporters* pour les formats classiques de nuages de points et de grilles 2D / 3D, ainsi que des *actions*. Se reporter au projet [[plugin-base:Fr_wiki|Plugin Base]] pour plus de détails. 

_____

| [[Fr_overview|Retour au sommaire]]| [[Fr_datatypes|Page suivante (Types d'items)]] |