QGIS Documentation - en to fr translation catalogue (75 entries)

en: Configuring external applications
fr: Configuration des applications tierces

en: The processign framework can be extended using additional applications. Currently, SAGA, GRASS, OTB(Orfeo Toolbox) and R are supported, along with some other command-line applications that provide spatial data analysis functionalities. Algorithms relying on an external application are managed by their own algorithm provider.
fr: Le module de Traitements peut être étendu par des applications tierces. Pour l'instant, les logiciels SAGA, GRASS, OTB (Orfeo Toolbox) et R sont supportés, ainsi que des applications en ligne de commande qui proposent des fonctionnalités d'analyses spatiales. Les algorithmes reposant sur des applications tierces sont gérées par leur propres fournisseurs d'algorithme.

en: This chapter will show you how to configure the processing framework to include these additional applications, and will explain some particular features of the algorithm based on them. Once you have correctly configured the system, you will be able to execute external algorithms from any component like the toolbox or the graphical modeler, just like you do with any other geoalgorithm.
fr: Ce chapitre vous montrera comment configurer le module de Traitements pour inclure ces applications additionnelles et vous expliquera quelques fonctionnalités particulières basées sur ces applications. Une fois le système configuré, vous pourrez exécuter les algorithmes externes depuis tous les composants du module tel que la boîte à outils ou le modeleur graphique, comme vous pourriez le faire avec n'importe quel géoalgorithme.

en: A note for Windows users
fr: Note pour les utilisateurs de Windows

en: A note on file formats
fr: A propos des formats de fichiers

en: A note on vector layer selections
fr: A propos de la sélection des couches vectorielles

en: In this case there is no need to configure that, and you will not see those folders. Instead, you must make sure that SAGA is properly installed and its folder is added to the PATH environment variable. Just open a console and type ``saga_cmd`` to check that the system can find where SAGA binaries are located.
fr: Dans ce cas, il n'est pas nécessaire de configurer tout ceci et vous ne verrez pas ces répertoires. Vérifiez que SAGA est correctement installé et que le chemin d'installation figure dans la variable d'environnement PATH. Pour vérifier que les fichiers binaires de SAGA sont accessibles, ouvrez une console et tapez ``saga_cmd``.

en: About SAGA grid system limitations
fr: A propos des limitations du système de grille de SAGA

en: The definition of that common grid system is controlled by the user, and you will find several parameters in the SAGA group of the setting window to do so. There are two ways of setting the target grid system:
fr: La définition d'une grille commune est contrôlée par l'utilisateur et peut se faire selon plusieurs paramètres, présents dans le groupe SAGA de la fenêtre de configuration. Deux façons de procéder existent:

en: Setting it manually. You define the extent setting the values of the following parameters:
fr: La configuration manuelle. Vous définissez les valeurs de l'emprise:

en: :guilabel:`Resampling min X`
fr: :guilabel:`Rééchantillonner la valeur minimum de X`

en: :guilabel:`Resampling max X`
fr: :guilabel:`Rééchantillonner la valeur maximum de X`

en: :guilabel:`Resampling min Y`
fr: :guilabel:`Rééchantillonner la valeur minimum de Y`

en: :guilabel:`Resampling max Y`
fr: :guilabel:`Rééchantillonner la valeur maximum de Y`

en: :guilabel:`Resampling cellsize`
fr: :guilabel:`Rééchantillonner la taille de la cellule`

en: Setting it automatically from input layers. To select this option, just check the :guilabel:`Use min covering grid system for resampling` option. All the other settings will be ignored and the minimum extent that covers all the input layers will be used. The cellsize of the target layer is the maximum of all cellsizes of the input layers.
fr: La configuration automatique à partir des couches en entrée. Pour choisir cette option, activez l'option :guilabel:`Utiliser la grille minimal pour le rééchantillonnage`. Toutes les autres options seront ignorées et l'emprise minimum pour couvrir les couhces sera utilisée. La taille de la cellule de la couche cible sera la plus grande des tailles de cellules des couches en entrée.

en: For algorithms that do not use multiple raster layers, or for those that do not need a unique input grid system, no resampling is performed before calling SAGA, and those parameters are not used.
fr: Pour les algorithmes qui n'utilisent pas plusieurs couches raster, ou pour ceux qui n'ont pas besoin d'une grille unique, le rééchantillonnage n'est pas nécessaire et ces paramètres ne seront pas utilisés.

en: Limitations for multi-band layers
fr: Limitations pour les couches multi-bandes

en: Limitations in cellsize
fr: Limitations dans la résolution

en: SAGA assumes that raster layers have the same cellsize in the X and Y axis. If you are working with a layer with different values for its horizontal and vertical cellsizes, you might get unexcepted results. In this case, a warning will be added to the processing log, indicating that an input layer might not be suitable to be processed by SAGA.
fr: SAGA suppose que la couche raster possède la même résolution en X et en Y. Si vous travaillez sur une couche avec des résolutions différentes entre les deux axes, les résultats peuvent être incohérents. Dans ce cas, un message d'avertissement est ajouté au journal, indiquant que la couche n'est pas adaptée au traitement par SAGA.

en: Logging
fr: Suivi du journal

en: Most other providers that use an external application and call it through the command-line have similar options, so you will find them as well in other places in the processing settings list.
fr: La plupart des autres fournisseurs tiers qui sont appelés par la ligne de commandes ont des options similaires, que vous trouverez dans la rubrique configuration du module.

en: R. Creating R scripts
fr: R. Créer des scripts R

en: Once again, this is different in Linux, and you just have to make sure that the R folder is included in the PATH environment variable. If you can start R just typing ``R`` in a console, then you are ready to go.
fr: Une fois encore, pour Linux, cela est légèrement différent : vous n'avez qu'à vérifier que le répertoire R est inclus dans la variable d'environnement PATH. Si vous pouvez lancer R en tapant ``R`` dans un terminal, alors vous êtes prêt pour la suite.

en: Script files have the extension :file:`.rsx` and creating them is pretty easy if you just have a basic knowledge of R syntax and R scripting. They should be stored in the R-scripts folder. You can set this folder in the :guilabel:`R` settings group (available from the processing settings dialog), just like you do with the folder for regular processing scripts.
fr: Les fichiers de scripts ont une extension de fichier :file:`.rsx` et leur création est relativement simple si vous connaissez la syntaxe et le langage de script de R. Ils seront sauvegardés dans le répertoire de scripts de R. Vous pouvez configurer ce répertoire dans le groupe de configuration de :guilabel:`R`, dans la fenêtre de configuration du Module de traitements, comme vous le feriez pour un script ordinaire.

en: Tables are opened using the ``read.csv()`` command. If a table entered by the user is not in CSV format, it will be converted prior to importing it in R.
fr: Les tables sont chargées par la commande ``read.csv()``. Si la table à charger n'est pas au format CSV, il faudra la convertir avant de l'importer dans R.

en: Additionally, raster files can be read using the ``readGDAL()`` command instead of ``brick()``, by using the ``##usereadgdal``.
fr: De plus, les couches raster peuvent être lues avec la commande ``readGDAL()`` au lieu de ``brick()``, en utilisant ``##usereadgdal``.

en: The variable ``polygon`` already contains a ``SpatialPolygonsDataFrame`` object, so it can be used to call the ``spsample`` method, just like the ``numpoints`` one, which indicates the number of points to add to the created sample grid.
fr: La variable ``polygon`` contient déjà un objet ``SpatialPolygonsDataFrame``, l'appel de la méthode ``spsample`` est donc simple. Il en est de même pour la méthode ``numpoints`` qui renvoit le nombre de points à ajouter pour créer la grille.

en: Since we have declared an output of type vector named ``out``, we have to create a variable named ``out`` and store a ``Spatial*DataFrame`` object in it (in this case, a ``SpatialPointsDataFrame``). You can use any name for your intermediate variables. Just make sure that the variable storing your final result has the same name that you used to declare it, and contains a suitable value.
fr: Comme nous avons déclaré une sortie de type ``vecteur`` nommée ``out``, nous devons créer cette variable ``out`` et lui affecter un objet ``Spatial*DataFrame`` (dans notre cas, un ``SpatialPointsDataFrame``). Vous pouvez utiliser n'importe quel nom pour les variables intermédiaires. Assurez-vous simplement que la variable qui stocke la valeur finale correspond à la variable de sortie définie au début.

en: If you algorithm does not generate any layer, but a text result in the console instead, you have to indicate that you want the console to be shown once the execution is finished. To do so, just start the command lines that produce the results you want to print with the ``>`` ('greater') sign. The output of all other lines will not be shown. For instance, here is the description file of an algorithm that performs a normality test on a given field (column) of the attributes of a vector layer:
fr: Si votre algorithme ne renvoie pas de couche, mais un résultat texte dans la console, vous devez précise que la console doit s'afficher à la fin de son exécution. Pour cela commencez les lignes qui doivent renvoyer les résultats par le signe ``>``. Les sorties des autres lignes seront masquées. Par exemple, voici la description d'un algorithme qui réalise un test de normalisation sur un champ donné (ou une colonne) de la table d'attributs d'une couche vectorielle :

en: If your algorithm creates any kind of graphics (using the ``plot()`` method), add the following line:
fr: Si votre algorithme crée des graphiques (par la méthode ``plot()``), ajoutez la ligne suivante:

en: Both graphics and console results will be shown in the processing results manager.
fr: Les graphiques et les résultats dans la console seront affichés dans le gestionnaire de résultats.

en: For more information, please check the script files provided with SEXTANTE. Most of them are rather simple and will greatly help you understand how to create your own ones.
fr: Pour plus d'information, veuillez vous référer aux scripts fournis avec SEXTANTE. Tous sont relativement simples et pourront vous aider à construire vos propres scripts.

en: Configuring GRASS is not much different from configuring SAGA. First, the path to the GRASS folder has to be defined, but only if you are running Windows. Additionaly, a shell interpreter (usually :file:`msys.exe`, which can be found in most GRASS for Windows distributions) has to be defined and its path set up as well.
fr: Configurer GRASS est similaire à celle de SAGA. Tout d'abord,pour Windows, indiquez le répertoire d'installation de GRASS, ainsi que l'emplacement de l'interpréteur de shell (habituellement le fichier :file:`msys.exe` fourni avec GRASS).

en: If you are running Linux, you just have to make sure that GRASS is correctly installed, and that it can be run without problem from a console.
fr: Sous Linux, assurez-vous simplement que GRASS est correctement installé et qu'il peut être lancé depuis un terminal.

en: GRASS algorithms use a region for calculations. This region can be defined manually using values similar to the ones found in the SAGA configuration, or automatically, taking the minimum extent that covers all the input layers used to execute the algorithm each time. If this is the behaviour you prefer, just check the :guilabel:`Use min covering region` option in the GRASS configuration parameters.
fr: Les algorithmes GRASS nécessitent la définition d'une région. Cette région peut être définie manuellement, en fournissant les valeurs, comme pour la configuration de SAGA, ou de manière automatique, correspondant à l'emprise minimale des données d'entrée à l'exécution de l'algorithme. Si vous préférez ce dernier réglage, cochez l'option :guilabel:`Utiliser l'emprise minimale` dans les paramètres de configuration de GRASS.

en: The last parameter that has to be configured is related to the mapset. A mapset is needed to run GRASS, and the  processing frmaework creates a temporary one for each execution. You have to specify if the data you are working with uses geographical (lat/lon) coordinates or projected ones.
fr: Le dernier paramètre à configurer est le jeu de données. Un jeu de dnnées est nécessaire pour exécuter GRASS et le module de traitement crée un jeu temporaire à chaque exécution. Vous devez indiquer si le système de coordonnées est géographique (lat/lon) ou projeté.

en: Orfeo ToolBox
fr: La boîte à outils Orfeo (OTB)

en: Then configure the path to the folder where OTB command--line tools and libraries are installed:
fr: Ensuite configurez l'emplacement des exécutables et des librairies OTB :

en: |nix| usually :guilabel:`OTB applications folder` point to ``/usr/lib/otb/applications`` and :guilabel:`OTB command line tools folder` is ``/usr/bin``
fr: |nix| habituellement, le répertoire :guilabel:`Applications OTB` pointe vers ``/usr/lib/otb/applications`` et celui des :guilabel:`Outils en ligne OTB` est ``/usr/bin``

en: |win| if you use OSGeo4W installer, than install ``otb-bin`` package and enter ``C:\OSGeo4W\apps\orfeotoolbox\applications`` as :guilabel:`OTB applications folder` and ``C:\OSGeo4W\bin`` as :guilabel:`OTB command line tools folder`. This values should be configured by default, but if you have a different OTB installation, configure them to the correspondig values in your system.
fr: |win| si vous avez utilisé l'installateur OSGeo4W pour installer le paquet ``otb-bin``, entrez respectivement ``C:\OSGeo4W\apps\orfeotoolbox\applications`` et ``C:\OSGeo4W\bin`` pour les répertoires  :guilabel:`OTB applications` et :guilabel:`OTB command line tools folder`. Ces valeurs sont les configurations par défaut mais si vous avez une installation différente d'OTB, modifiez les en conséquence.

en: To use this provider you need to install TauDEM command line tools.
fr: Pour utiliser ce fournisseur, vous devez installer les outils TauDEM en lignes de commandes.

en: Please visit `TauDEM homepage <http://hydrology.usu.edu/taudem/taudem5.0/downloads.html>`_ for installation instructions and precompiled binaries for 32bit and 64bit systems. **IMPORTANT**: you need TauDEM 5.0.6 executables, version 5.2 is currently not supported.
fr: Veuillez vous reporter au `site de TauDEM <http://hydrology.usu.edu/taudem/taudem5.0/downloads.html>`_ pour les instructions d'installation et fichiers exécutables pour les systèmes 32bits et 64bits.**IMPORTANT** : installez la version TauDEM 5.0.6, la version 5.2 n'étant pas pour l'instant supportée.

en: There are no packages for most Linux distribution, so you should compile TauDEM by yourself. As TauDEM uses MPICH2, first install it using your favorite package manager. Also TauDEM works fine with OpenMPI, so you can use it instead of MPICH2.
fr: La plupart des distributions Linux n'ont pas de paquets précompilés. Il vous faudra donc compiler vous-même TauDEM. TauDEM utilise MPICH2, qu'il faudra donc installer avec votre gestionnaire de paquets. TauDEM fonctionne également avec OpenMPI, que vous pouvez installer à la place de MPICH2.

en: Download TauDEM 5.0.6 `source code <http://hydrology.usu.edu/taudem/taudem5.0/TauDEM5PCsrc_506.zip>`_ and extract files in some folder.
fr: Téléchargez le code source de TauDEM 5.0.6 à l'adresse suivante `<http://hydrology.usu.edu/taudem/taudem5.0/TauDEM5PCsrc_506.zip>`_ et décompressez les fichiers dans un répertoire.

en: Open :file:`linearpart.h` file and add after line
fr: Ouvrez le fichier :file:`lienarpart.h` et après la ligne

en: add new line with
fr: ajoutez la ligne suivante

en: so you'll get
fr: afin d'obtenir ceci

en: Save changes and close file. Now open :file:`tiffIO.h`, find line ``#include "stdint.h"`` and replace quotes (``""``) with ``<>``, so you'll get
fr: Sauvegardez les modifications et fermez le fichier. À présent, ouvrez le fichier :file:`tiffIO.h`, trouvez la ligne ``#include "stdint.h"`` dans laquelle vous remplacerez les quotes (``""``) par des  ``<>``, pour obtenir ceci

en: Save changes and close file. Create build directory and cd into it
fr: Sauvegardez et fermez le fichier. Créez un répertoire de compilation et déplacez-vous dedans

en: Configure your build with command
fr: Configurez votre compliation avec la commande

en: and then compile
fr: ensuite compilez

en: Finaly, to install TauDEM into ``/usr/local/bin``, run
fr: Enfin, pour installer TauDEM dans ``/usr/local/bin``, exécutez

en: By default, all algorithms that rely on an external appplication not shipped with |qg| are not enabled. You can enable them in the configuration dialog. Make sure that the corresponding application is already installed in your system. Enabling an algorithm provider without installing the application it needs will cause the algorithms to appear in the toolbox, but an error will be thrown when you try to execute them.
fr: Par défaut, tous les algorithmes qui reposent sur une application tierce non fournie avec |qg| sont désactivés. Vous pouvez les activer dans la fenêtre de configuration. Vérifiez que l'application correspondante est préalablement installée sur votre ordinateur. Activer un fournisseur d'algorithmes non installé résultera en une erreur à l'exécution, bien que les algorithmes soient présent dans la boîte à outils.

en: This is because the algorithm descriptions (needed to create the parameters dialog and provide the information needed about the algorithm) are not included with each application, but with |qg| instead. That is,they are part of |qg|, so you have them in your installation even if you have not installed any other software. Running the algorithm, however, needs the application binaries to be installed in your system.
fr: La raison est que les descriptions des algorithmes (nécessaires pour créer la fenêtre de paramètres et donner les informations sur l'algorithme) ne sont pas fournies avec les applications mais sont inclues dans |qg|. C'est à dire que |qg| les inclut d'office, même si vous ne les avez pas installé. Exécuter un algorithme nécessite évidemment que l'application tierce soit installée au préalable.

en: If you are not an advanced user and you are running |qg| on windows, you might not be interested in reading the rest of this chapter. Make sure you install |qg| in your system using the OSGeo4W application. That will automatically install SAGA, GRASS and OTB in your system, and configure them so they can be run from |qg|. All the algorithms in the simplified view of the toolbox will be ready to be run, without needing any further configuration.
fr: Si vous n'êtes pas un utilisateur avancé et utilisez |qg| sur Windows, vous pourriez ne pas vous intéresser au reste de ce chapitre. Assurez-vous d'avoir installé |qg| sur votre système avec l'application OSGeo4W. Ceci installera automatiquement SAGA, GRASS et OTB sur votre système et les configurera de manière à ce qu'ils soient accessibles depuis |qg|. Tous les algorithmes de la vue simplifiée de la barre d'outils sont prêts à être utilisés, sans aucune configuration supplémentaire.

en: When using an external software, opening a file in |qg| does not mean that it can be opened and processed as well on that other software. In most cases, it can read what you have opened in |qg|, but in some cases, that might not be the case. When using databases or uncommon file formats, whether for raster of vector layers, problems might arise. If that happens, try to use well known file formats that you are sure that are understood by both programs, and check to console output (in the history and log dialog) for knowing more about what is going wrong.
fr: Le fait d'ouvrir un fichier dans |qg| ne garantit pas que ce fichier pourra être ouvert et traité par l'application tierce. Dans la plupart des cas, celui-ci pourra lire ce que vous avez ouvert dans |qg|, mais parfois, cela ne sera pas le cas. C'est particulièrement le cas des connections aux bases de données et les fichiers peu communs, aussi bien raster que vectoriels, qui pourront présenter des problèmes. Si cela arrivait, essayez de convertir vos données dans un format usuel reconnu par l'application tierce et vérifiez dans la console (historique et messages) le résultat du traitement pour analyser l'origine des erreurs.

en: You should, however, find no problems at all with vector layers, since |qg| automatically converts from the original file format to one accepted by the external application before passing the layer to it. This adds an extra processing time, which might be significant if the layer has a large size, so do not be surprised if it takes more to process a layer from a DB connection that one of a similar size stored in a shapefile.
fr: Pour les couches vectorielles, vous ne devriez pas rencontrer de problème : |qg| les convertit automatiquement dans un format reconnu par l'application tierce avant de lui transmettre. Cela aboutit à un temps de traitement plus long, particulièrement si la couche comprend beaucoup d'objets. Ne vous étonnez donc pas si le traitement d'un couche prévenant d'un base de données est plus long que celui d'un shapefile de taille équivalente.

en: Providers not using external applications can process any layer that you can open in |qg|, since they open it for analysis through |qg|.
fr: Les algorithmes n'utilisant pas d'application tierce peuvent traiter toutes les couches qui peuvent s'ouvrir dans|qg| puisque qu'ils sont lancés depuis QGIS.

en: Regarding output formats, all formats supported by |qg| as output can be used, both for raster and vector layers. Some provider do not support certain formats, but all can export to common formats raster layers that can be later transformed by |qg| automatically. As in the case of input layers, if this conversion is needed, that might increase the processing time.
fr: Concernant les formats de sortie, tous les formats gérés par |qg| peuvent être utilisés en sortie, à la fois pour les couches raster et vecteur. Certains formats ne sont pas gérés par certaines applications tierces mais celles-ci permettent toutes d'exporter dans des formats raster courants qui peuvent ensuite être convertis automatiquement par |qg|. Comme pour les couches d'entrée, si une conversion est opérée, le temps de traitement peut être allongé.

en: Most of SAGA algorithms that require several input raster layers, require them to have the same grid system. That is, to cover the same geographic area and have the same cellsize, so their corresponding grids match. When calling SAGA algorithms from |qg|, you can use any layer, regardless of its cellsize and extent. When multiple raster layers are used as input for a SAGA algorithm, |qg| resamples them to a common grid system and then passes them to SAGA (unless the SAGA algorithm can operate with layers from different grid systems).
fr: La plupart des algorithmes SAGA nécessitent habituellement des couches Raster en entrée sur la même emprise et la même grille, couvrant la même emprise et ayant la même résolution. A l'appel d'un algorithme SAGA depuis |qg|, vous pouvez cependant utiliser n'importe quelle couche, quelles que soient leur emprise et leur résolution. Quand plusieurs couches raster son indiquées en entré d'un algorithme SAGA, |qg| les rééchantillonne sur une grille commune avant de les transmettre à SAGA (à moins que l'algorithme SAGA manipule directement des couches dans des grilles différentes).

en: Notice that |qg| will resample input layers to that extent, even if they do not overlap with it.
fr: Veuillez noter que |qg| rééchantillonnera les couches en entrées sur cette emprise, même si elles ne la recoupent pas.

en: When |qg| calls SAGA, it does it using its command-line interface, thus passing a set of commands to perform all the required operation. SAGA show its progress by writing information to the console, which includes the percentage of processing already done, along with additional content. This output is filtered and used to update the progress bar while the algorithm is running.
fr: Lorsque |qg| appelle SAGA, il le fait par son interface en lignes de commandes pour effectuer l'opération demandée. SAGA transmet son état d'avancement dans la console ainsi que d'autres informations. Ces messages sont filtrés et utilisés pour afficher la barre d'avancement pendant l'exécution de l'algorithme.

en: R integration in |qg| is different from that of SAGA in that there is not a predefined set of algorithms you can run (except for a few examples). Instead, you should write your scripts and call R commands, much like you would do from R, and in a very similar manner to what we saw in the chapter dedicated to processing scripts. This chapter shows you the syntax to use to call those R commands from |qg| and how to use |qg| objects (layers, tables) in them.
fr: L'intégration de R est légèrement différente de celle de SAGA, dans la mesure où il n'y a pas d'ensemble prédéfini d'algorithmes à exécuter, hormis quelques exemples. Au lieu de cela, c'est à vous d'écrire les scripts à transmettre à R, comme vous le feriez depuis R. Un peu comme dans le chapitre sur les scripts. Ce chapitre va vous montrer comment appeler les commandes R à partir de |qg| et comment leur transmettre les objets |qg| (couches et tables).

en: The first thing you have to do, as we saw in the case of SAGA, is to tell |qg| where you R binaries are located. You can do so using the :guilabel:`R folder` entry in the processing configuration dialog. Once you have set that parameter, you can start creating your own R scripts and executing them.
fr: La première chose à faire, comme nous l'avons vu pour SAGA, est de dire à |qg| où se situent les fichiers exécutables de R. Paramétrez l'entrée :guilabel:`Répertoire R` dans la fenêtre de configuration du module de traitements. Une fois cela fait, vous pouvez commencer à créer vos scripts R et à les exécuter.

en: To add a new algorithm that calls an R function (or a more complex R script that you have developed and you would like to have available from |qg|), you have to create a script file that tells the processing framework how to perform that operation and the corresponding R commands to do so.
fr: Pour ajouter un nouvel algorithme qui appelle une fonction R (ou un script R plus complexe que vous auriez développé et que vous souhaiteriez utiliser dans |qg|), vous devez créer un fichier de script qui va indiquer au module de traitements comment effectuer l'opération et les commandes R correspondantes.

en: Let’s have a look at a very simple file script file, which calls the R method ``spsample`` to create a random grid within the boundary of the polygons in a given polygon layer. This method belong to the ``maptools`` package. Since almost all the algorithms that you might like to incorporate into |qg| will use or generate spatial data, knowledge of spatial packages like ``maptools`` and, specially, ``sp``, is mandatory.
fr: Voyons un simple script, qui appelle la méthode ``spsample`` de R, pour créer une grille aléatoire à l'intérieur de l'emprise d'un ensemble de polygones d'une couche donnée. Cette fonction appartient au paquet ``maptools``. Comme la plupart des algorithmes que vous aurez à intégrer dans |qg| utilisent ou génèrent des données spatiales, la connaissance des paquets spatiaux comme ``maptools`` et surtout ``sp`` est un prérequis.

en: When you declare an input parameter, |qg| uses that information for two things: creating the user interface to ask the user for the value of that parameter and creating a corresponding R variable that can be later used as input for R commands.
fr: Quand vous déclarez un paramètre d'entrée, |qg| utilise cette information pour deux choses : créer le formulaire pour demander à l'utilisateur la valeur de ce paramètre et créer la variable R correspondante qui sera ensuite utilisée dans les commandes R.

en: In the above example, we are declaring an input of type ``vector`` named ``polyg``. When executing the algorithm, |qg| will open in R the layer selected by the user and store it in a variable also named ``polyg``. So the name of a parameter is also the name of the variable that we can use in R for accesing the value of that parameter (thus, you should avoid using reserved R words as parameter names).
fr: Dans l'exemple ci-dessus, nous avons déclaré une entrée de type ``vecteur`` appelée ``polyg``. A l'exécution de l'algorithme, |qg| ouvrira la couche sélectionnée par l'utilisateur dans R et la stockera dans une variable nommée ``polyg``. Ainsi le nom du paramètre est également le nom de la variable à utiliser dans R pour accéder à son contenu (par conséquent, évitez d'utiliser des mots réservés R comme noms de paramètre).

en: In this case, the result obtained from the ``spsample`` method has to be converted explicitly into a ``SpatialPointsDataFrame`` object, since it is itself an object of class ``ppp``, which is not a suitable class to be returned to |qg|.
fr: Dans notre exemple, le résultat de la méthode ``spsample`` doit être converti explicitement en objet ``SpatialPointsDataFrame``, dans la mesure où c'est un objet de la classe ``ppp`` qui ne peut être retransmis à |qg|.

en: The output ot the last line is printed, but the output of the first is not (and neither are the outputs from other command lines added automatically by |qg|).
fr: La sortie de la dernière ligne est affichée, mais la sortie de la première ne l'est pas (ni celles des commandes ajoutées automatiquement par |qg|).

en: This will cause |qg| to redirect all R graphical outputs to a temporary file, which will be later opened once R execution has finished.
fr: Ceci va indiquer à |qg| de rediriger toutes les sorties graphiques de R vers un fichier temporaire qui sera chargé une fois l'exécution de R terminée.

en: No additional configuration is needed to run GDAL algorithms, since it is already incorporated to |qg| and algorithms can infere its configuration from it.
fr: Les algorithmes GDAL ne nécessitent pas de configuration particulière, dans la mesure où ils sont déjà intégrés dans |qg| et ils y récupèrent donc leurs configurations.

en: Orfeo ToolBox (OTB) algorithms can be run from |qg| if you have OTB installed in your system and you have configured |qg| properly, so it can find all necessary files (command-line tools and libraries).
fr: Les algorithmes de la boîte à outils Orfeo (OTB) peuvent être exécutés depuis |qg| si OTB est installé sur votre ordinateur et que |qg| est configuré correctement pour trouver les fichiers nécessaires (outils en ligne de commande et librairies).

en: Once OTB is installed, start |qg|, open the processing configuration dialog and configure the OTB algorithm provider. In the :guilabel:`Orfeo Toolbox (image analysis)` block you will find all settings related to OTB. First ensure that algorithms are enabled.
fr: Une fois OTB installé, démarrez |qg|, ouvrez la fenêtre de configuration du module de Traitements et configurez le fournisseur OTB. Dans le groupe :guilabel:`Orfeo Toolbox (image analysis)`, vous retrouverez tous les réglages relatifs à OTB. Vérifiez que les algorithmes sont activés.
