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

en: Using processing algorithms from the console
fr: Utiliser les algorithmes du module de traitements depuis la console Python

en: The console allows advanced users to increase their productivity and perform complex operations that cannot be performed using any of the other GUI elements of the processing framework GUI. Models involving several algorithms can be defined using the command-line interface, and additional operations such as loops and conditional sentences can be added to create more flexible and powerful workflows.
fr: La console permet aux utilisateurs confirmés d'accroître leur productivité en réalisant des opérations complexes qui ne pourraient par être réalisées à partir de l'interface graphique du module de Traitements. Les modèles impliquant plusieurs algorithmes peuvent être définis à partir de l'interface en lignes de commandes et des opérations additionnelles comme les boucles ou les branchements conditionnels permettent de créer des flux de traitements plus puissants et plus flexibles.

en: The code that you can execute from the Python console, even if it does not call any specific processing method, can be converted into a new algorithm that you can later call from the toolbox, the graphical modeler or any other component, just like you do with any other algorithm. In fact, some algorithms that you can find in the toolbox are simple scripts.
fr: Le code exécuté à partir de la console Python, même s'il n'utilise pas de méthodes de traitements particulières, peut être converti en un nouveau algorithme pour être réutilisé dans la boîte à outils, le modeleur ou dans un autre flux de traitements, comme tout autre algorithme. Ainsi certains algorithmes que vous pouvez trouver dans la boîte à outils sont en fait de simples scripts.

en: Calling algorithms from the Python console
fr: Appeler de algorithmes depuis la console Python

en: The first thing you have to do is to import the processing functions with the following line:
fr: La première chose à faire est d'importer les fonctions de traitement à l'aide de l'instruction suivante:

en: Now, there is basically just one (interesting) thing you can do with that from the console: to execute an algorithm. That is done using the ``runalg()`` method, which takes the name of the algorithm to execute as its first parameter, and then a variable number of additional parameter depending on the requirements of the algorithm. So the first thing you need to know is the name of the algorithm to execute. That is not the name you see in the toolbox, but rather a unique command–line name. To find the right name for your algorithm, you can use the ``algslist()`` method. Type the following line in you console:
fr: A présent, la seule instruction (intéressante) à faire est d'exécuter un algorithme. Cela est effectué en utilisant la méthode ``runalg()``, qui prend en premier paramètre le nom de l'algorithme à lancer, puis tous les paramètres nécessaires à son exécution. Vous devez donc connaître le nom de commande de l'algorithme, qui peut être différent de celui affiché dans la boîte à outils. Pour le trouver, tapez ``alglist()`` dans la console :

en: You will see something like this.
fr: Vous devriez avoir quelque chose qui ressemble à ceci.

en: That's a list of all the available algorithms, alphabetically ordered, along with their corresponding command-line names.
fr: Il s'agit de la liste des algorithmes disponibles, par ordre alphabétique, accompagnés des noms de commande.

en: You can use a string as a parameter for this method. Instead of returning the full list of algorithm, it will only display those that include that string. If, for instance, you are looking for an algorithm to calculate slope from a DEM, type ``alglist("slope")`` to get the following result:
fr: Vous pouvez également passer une chaine de caractères en paramètre de cette méthode. Au lieu de retourner lal iste complète des algorithmes, elle filtrera les résultats selon la chaîne fournies. Par exemple, si vous recherchez un algorithme premettant de calculer la pente d'un MNT, l'instruction ``alglist("slope")`` donnera le résultat suivant:

en: This result might change depending on the algorithms you have available.
fr: Ce résultat peut différer d'un système à l'autre selon les algorithmes disponibles.

en: It is easier now to find the algorithm you are looking for and its command-line name, in this case ``saga:slopeaspectcurvature``.
fr: Il est ainsi facile de trouver l'algorithme recherché et son nom de commande, ici ``saga:slopeaspectcurvature``.

en: Once you know the command-line name of the algorithm, the next thing to do is to know the right syntax to execute it. That means knowing which parameters are needed and the order in which they have to be passed when calling the ``runalg()`` method. There is a method to describe an algorithm in detail, which can be used to get a list of the parameters that an algorithms require and the outputs that it will generate. To do it, you can use the ``alghelp(name_of_the_algorithm)`` method. Use the command-line name of the algorithm, not the full descriptive name.
fr: Une fois trouvé le nom de commande de l'algorithme, il s'agit de connaître la bonne syntaxe pour l'exécuter. Cela comprend la liste et l'ordre des paramètres à fournir à l'appel de la méthode ``runalg()``. Une méthode est destinée à décrire en détail un algorithme et renvoie la liste des paramètres nécessaires et le type de sorties générées : il s'agit de la méthode ``alghelp(nom_de_l_algorithme)``. Veillez à bien utiliser le nom de commande et non le nom descriptif.

en: Calling the method with ``saga:slopeaspectcurvature`` as parameter, you get the following description.
fr: L'appel à la méthode avec le paramètre ``saga:slopeaspectcurvature`` donnera la description suivante.

en: Now you have everything you need to run any algorithm. As we have already mentioned, there is only one single command to execute algorithms: ``runalg()``. Its syntax is as follows:
fr: Vous avez à présent tout ce qu'il faut pour exécute n'importe quel algorithme. Comme indiqué précédemment, l'instruction ``runalg()`` suffit pour exécuter un algorithme. Sa syntaxe est la suivante:

en: The list of parameters and outputs to add depends on the algorithm you want to run, and is exactly the list that the ``alghelp()`` method gives you, in the same order as shown.
fr: La liste des paramètres et des sorties à fournir dépend de l'algorithme à exécuter et correspond au résultat, dans l'ordre donné, de la méthode ``alghelp()``.

en: Depending on the type of parameter, values are introduced differently. The next one is a quick review of how to introduce values for each type of input parameter:
fr: Selon le type de paramètre, les valeurs peuvent être fournies selon plusieurs manières. Une rapide description de ces possibilités est donnée pour chaque type de paramètre d'entrée :

en: Selection. If an algorithm has a selection parameter, the value of that parameter should be entered using an integer value. To know the available options, you can use the ``algoptions()`` command, as shown in the following example:
fr: Sélection. Si un algorithme  possède un paramètre sélection, cette valeur doit être une valeur entière. Pour connaître les options possibles, vous pouvez utilisez la commande ``algoptions()``, comme dans l'exemple suivant :

en: In this case, the algorithm has one of such such parameters, with 7 options. Notice that ordering is zero-based.
fr: Dans l'exemple, l'algorithme présente ces types de paramètres, avec 7 options. Notez que le premier élément a pour numéro 0.

en: Multiple input. The value is a string with input descriptors separated by semicolons (``;``). As in the case of single layers or tables, each input descriptor can be the data object name, or its filepath.
fr: Entrées multiples. La valeur est une chaîne de caractères, avec les entrées séparées par des points-virgules  (``;``). Comme pour les couches simples et les tables, chaque élément d'entrée peut être le nom d'une variable objet ou un nom de fichier.

en: Table Field from XXX. Use a string with the name of the field to use. This parameter is case-sensitive.
fr: Champ de la table XXX. Insérez une chaîne de caractère contenant le nom du champ à utiliser. Ce paramètre est sensible à la casse.

en: Fixed Table. Type the list of all table values separated by commas (``,``) and enclosed between quotes (``"``). Values start on the upper row and go from left to right. You can also use a 2D array of values representing the table.
fr: Table fixée. Entrez la liste de toutes les valeurs, séparées par des virgules (``,``) et entre guillemets (``"``). Les valeurs commencent par la première ligne et se lisent de gauche à droite. Vous pouvez aussi utiliser un tableau à deux dimensions pour représenter la table.

en: CRS. Enter the EPSG code number of the desired CRS.
fr: SCR. Entrez le code EPSG du système de coordonnées désiré.

en: Extent. You must use a string with ``xmin``, ``xmax``, ``ymin`` and ``ymax`` values separated by commas (``,``).
fr: Étendue. Vous devez fournir une chaîne de caractères avec les valeurs ``xmin``, ``xmax``, ``ymin`` et ``ymax`` séparées par des virgules (``,``).

en: Boolean, file, string and numerical parameters do not need any additional explanations.
fr: Booléen, fichier, chaîne de caractères et valeurs numériques ne nécessitent pas d'explications particulières.

en: Input parameters such as strings booleans or numerical values have default values. To use them, use ``None`` in the corresponding parameter entry.
fr: Pour spécifier les valeurs par défaut des paramètres tels que chaînes de caractères, booléens ou valeurs numériques, entrez ``None`` dans l'entrée correspondante.

en: For output data objects, type the filepath to be used to save it, just as it is done from the toolbox. If you want to save the result to a temporary file, use ``None``. The extension of the file determines the file format. If you enter a file extension not included in the ones supported by the algorithm, the default file format for that output type will be used, and its corresponding extension appended to the given filepath.
fr: Pour les données en sortie, entrez le chemin à utiliser, comme dans la boîte à outils. Si vous préférez sauvegarder le résultat dans un fichier temporaire, indiquez ``None``. L'extension du fichier déterminera le format de fichier utilisé. Si elle n'est pas reconnue par l'algorithme, le format de fichier par défaut sera utilisé et l'extension sera ajouté à la fin du nom de fichier.

en: The ``runalg`` method returns a dictionary with the output names (the ones shown in the algorithm description) as keys and the filepaths of those outputs as values. You can load those layers by passing its filepath to the ``load()`` method.
fr: La méthode ``runalg`` renvoie un dictionnaire Python avec pour clés les noms des sorties (correspondant à la description des éléments de l'algorithme) et pour valeurs les chemins des résultats. Vous pouvez charger ces couches de résultat en passant leur chemin à la méthode ``load()``.

en: Additional functions for handling data
fr: Fonctions supplémentaires pour gérer des données

en: Creating scripts and running them from the toolbox
fr: Créer des scripts et les exécuter depuis la boîte à outils

en: The name of the algorithm (the one you will see in the toolbox) is created from the filename, removing its extension and replacing low hyphens with blank spaces.
fr: Le nom de l'algorithme (celui qui apparaît dans la boîte à outils) est généré à partir du nom de fichier, en enlevant son extension et en remplaçant les underscores ('_') par des espaces.

en: Let's have the following code, which calculates the Topographic Wetness Index (TWI) directly from a DEM
fr: Voici par exemple le code permettante de calculer l'Indice d'Humidité Topographique (Topographic Wetness Index, TWI) directement à partir d'un MNT

en: As you can see, it involves 3 algorithms, all of them coming from SAGA. The last one of them calculates the TWI, but it needs a slope layer and a flow accumulation layer. We do not have these ones, but since we have the DEM, we can calculate them calling the corresponding SAGA algorithms.
fr: Comme vous pouvez le voir, il utilise 3 algorithmes, provenant de SAGA. Le dernier calcule le TWI, mais nécessite de une couche représentant la pente et une autre d'accumulation des flux. Dans la mesure où ces deux couches n'existent pas mais que nous disposons d'un MNT, nous allons les calculer en faisant appel aux algorithmes SAGA adéquats.

en: The part of the code where this processing takes place is not difficult to understand if you have read the previous sections in this chapter. The first lines, however, need some additional explanation. They provide the information that is needed to turn your code into an algorithm that can be run from any of the GUI components, like the toolbox or the graphical modeler.
fr: Le bout de code où le traitement est effectué n'est pas compliqué à comprendre si vous avez lu les sections précédentes. Cependant, les premières lignes nécessitent quelques explications. Elles fournissent les informations nécessaires pour convertir votre code en un algorithme utilisable à partir d'autres contextes, comme la boîte à outils ou le modeleur graphique.

en: These lines start with a double Python comment symbol (``##``) and have the following structure
fr: Ces lignes débutent par deux symboles de commentaire Python (``##``) et présentent la structure suivante :

en: Here is a list of all the parameter types that are supported in processign scripts, their syntax and some examples.
fr: Voici la liste des types de paramètres gérés par les scripts de traitement, leur syntaxe ainsi que quelques exemples.

en: ``raster``. A raster layer
fr: ``raster``. Une couche raster

en: ``vector``. A vector layer
fr: ``vector``. Une couche vectorielle

en: ``table``. A table
fr: ``table``. Une table

en: ``number``. A numerical value. A default value must be provided. For instance, ``depth=number 2.4``
fr: ``number``. Une valeur numérique. Une valeur par défaut doit être définie. Par exemple, ``depth=number 2.4``

en: ``string``. A text string. As in the case of numerical values, a default value must be added. For instance, ``name=string Victor``
fr: ``string``. Une chaîne de caractère. Comme pour les valeurs numériques, une valeur par défaut doit être définie. Par exemple, ``name=string Victor``

en: ``boolean``. A boolean value. Add ``True`` or ``False`` after it to set the default value. For example, ``verbose=boolean True``
fr: ``boolean``. Une valeur booléenne. Ajoutez ``True`` (Vrai) ou ``False`` (Faux) pour définir la valeur par défaut. Par exemple, ``verbose=boolean True`` pour plus un rendu plus parlant

en: ``multiple raster``. A set of input raster layers.
fr: ``multiple raster``. Un ensemble de couches raster en entrée.

en: ``multiple vector``. A set of input vector layers.
fr: ``multiple vector``. Un ensemble de couches vectorielles en entrée.

en: ``field``. A field in the attributes table of a vector layer. The name of the layer has to be added after the ``field`` tag. For instance, if you have declared a vector input with ``mylayer=vector``, you could use ``myfield=field mylayer`` to add a field from that layer as parameter.
fr: ``field``. Un champ dans la table d'attributs d'une couche vectorielle. Le nom de la couche doit être ajoutée après l'étiquette ``field``. Par exemple, si vous déclarez une couche vectorielle ``macouche=vector`` en entrée, vous pouvez utilisez ``monchamp=champ1 macouche`` pour ajouter en paramètre le champ de cette couche.

en: ``folder``. A folder
fr: ``folder``. Un répertoire

en: ``file``. A filename
fr: ``file``. Un nom de fichier

en: The parameter name is the name that will be shown to the user when executing the algorithm, and also the variable name to use in the script code. The value entered by the user for that parameter will be assigned to a variable with that name.
fr: Le nom du paramètre correspond à ce qui sera affiché lorsque l'utilisateur exécutera l'algorithme, ainsi qu'au nom de variable à utiliser dans le script. La valeur saisie par l'utilisateur pour ce paramètre sera assignée à cette variable, portant ce nom.

en: When showing the name of the parameter to the user, the name will be edited it to improve its appearance, replacing low hyphens with spaces. So, for instance, if you want the user to see a parameter named ``A numerical value``, you can use the variable name ``A_numerical_value``.
fr: A l'affichage du nom de paramètre, les underscores ('_') sont convertis en espaces pour améliorer la lisibilité. Ainsi, par exemple, si vous souhaitez que l'utilisateur saisisse une valeur appelée 'Valeur numérique', vous devez utiliser une variable nommée ``Valeur_numérique``.

en: Outputs are defined in a similar manner, using the following tags:
fr: Les sorties sont définies de la même manière, avec les étiquettes suivantes:

en: The value assigned to the output variables is always a string with a filepath. It will correspond to a temporary filepath in case the user has not entered any output filename.
fr: La valeur attribuée à une variable de sortie est toujours une chaîne de caractères contenant le chemin de l'objet. Si le nom est vide, un fichier temporaire sera créé.

en: Do not use the ``load()`` method in your script algorithms, but just when working with the console line. If a layer is created as output of an algorithm, it should be declared as such. Otherwise, you will not be able to properly use the algorithm in the modeler, since its syntax (as defined by the tags explained above) will not match what the algorithm really creates.
fr: N'utilisez donc pas la méthode ``load()`` dans vos scripts, mais uniquement à partir de la console. Si un algorithme définit une couche en sortie, celle-ci doit être déclarée ainsi. Dans le cas contraire, vous ne pourriez pas l'utiliser dans le modeleur parce que sa syntaxe (comme définie par ses étiquettes, exposées précédemment) ne correspond âs à ce que l'algorithme crée effectivement.

en: Hidden outputs (numbers and strings) do not have a value. Instead, it is you who has to assign a value to them. To do so, just set the value of a variable with the name you used to declare that output. For instance, if you have used this declaration,
fr: Les sorties masquées (nombres ou chaînes) n'ont pas de valeur. C'est à vous de leur assigner une valeur. Pour cela, affecter une valeur à la variable pour la déclarer en sortie. Par exemple, vous pourriez utiliser la déclaration suivante,

en: the following line will set the value of the output to 5:
fr: l'instruction suivante fixe la valeur de sortie à 5:

en: In addition to the tags for parameters and outputs, you can also define the group under which the algorithm will be shown, using the ``group`` tag.
fr: En complément des étiquettes définissant les paramètres et les sorties, vous pouvez définir la catégorie dans laquelle l'algorithme apparaîtra, en utilisant l'étiquette ``group``.

en: If you algorithm takes a long time to process, it is a good idea to inform the user. You have a global named ``progress`` available, with two available methods: ``setText(text)`` and ``setPercentage(percent)`` to modify the progress text and the progress bar.
fr: Il est conseillé d'informer l'utilisateur de l'avancée du traitement de l'algorithme. Vous disposez de la variable globale ``progress``, aevc deux méthodes, ``setText(text)`` et ``setPercentage(percent)`` pour modifier le message et la barre de progression.

en: Several examples are provided. Please, check them to see real examples of how to create algorithms using the processing framework classes. You can right-click on any script algorithm and select :guilabel:`Edit script` to edit its code or just to see it.
fr: Plusieurs exemples sont fournis. Veuillez vous y reporter pour servir d'exemples. Cliquez avec le bouton droit sur un script et choisissez ``Éditer le script`` pour voir et éditer le code correspondant.

en: Documenting your scripts
fr: Documenter ses scripts

en: As in the case of models, you can create additional documentation for your script, to explain what they do and how to use them. In the script editing dialog you will find a **[Edit script help]** button. Click on it and it will take you to the help editing dialog. Check the chapter about the graphical modeler to know more about this dialog and how to use it.
fr: Comme pour les modèles, vous pouvez ajouter des commentaires à votre script, pour expliciter le traitement effectué et son utilisation. Dans la fenêtre d'édition du script se situe un bouton **[Editer l'aide]**, qui vous amènera à la fenêtre d'édition de l'aide. Veuillez vous reporter au chapitre Modeleur graphique pour plus d'information sur cette fenêtre.

en: Help files are saved in the same folder as the script itself, adding the :file:`.help` extension to the filename. Notice that you can edit your script's help before saving it for the first time. If you later close the script editing dialog without saving the script (i.e. you discard it), the help content you wrote will be lost. If your script was already saved and is associated to a filename, saving is done automatically.
fr: Les fichiers d'aide sont sauvegardés dans le même répertoire que les scripts, avec l'extention :file:`.help`.Veuillez noter qu'à la première édition de l'aide, la fermeture de la fenêtre ne sauvegarde pas vos modifications. Par contre, si le fichier a déjà été sauvegardé une fois préalablement, les modifications seront conservées.

en: In this chapter we will see how to use processing algorithms from the |qg| Python console, and also how to write your own algorithms using Python.
fr: Dans ces chapitre, nous allons voir comme utiliser des algorithme issus du module de Traitements à partir de la console Python de |qg| et également comment écrire vos propres algorithmes en Python.

en: Raster Layer, Vector Layer or Table. Simply use a string with the name that identifies the data object to use (the name it has in the |qg| Table of Contents) or a filename (if the corresponding layer is not opened, it will be opened, but not added to the map canvas). If you have an instance of a |qg| object representing the layer, you can also pass it as parameter. If the input is optional and you do not want to use any data object, use ``None``.
fr: Les couches raster, vectorielles ou les tables. Indiquez simplement le nom identifiant la donnée (le nom dans la liste de couches de |qg|) ou un nom de fichier (si la couche n'a pas encore été ouverte, elle sera chargée mais pas ajoutée au canevas). Si vous avez une instance d'un objet |qg| représentant une couche, vous pouvez également la transmettre en paramètre. Si l'entrée est optionnelle et que vous ne souhaitez pas fournir de données particulières, utilisez la valeur ``None``.

en: When you declare an output, the algorithm will try to add it to |qg| once it is finished. That is the reason why, although the ``runalg()`` method does not load the layers it produces, the final TWI layer will be loaded, since it is saved to the file entered by the user, which is the value of the corresponding output.
fr: Si un résultat est défini, l'algorithme tentera de l'ajouter à |qg| à l'issue de son exécution. C'est la raison pour laquelle la couche résultat TWI, nommée explicitement par l'utilisateur, sera chargée, même si la méthode ``runalg()`` ne le fait pas.
