DataLab - en to fr translation catalogue (63 entries)

en: Tutorial on how to prototype a custom image processing pipeline using DataLab (macro, plugin, external IDE, Jupyter notebook)
fr: Tutoriel: prototyper une chaîne de traitement d'image avec DataLab (macro, plugin, IDE externe, notebook Jupyter)

en: DataLab, custom function, macro-command, plugin, image processing, prototype, Spyder, Jupyter
fr: DataLab, fonction personnalisée, macro-commande, plugin, traitement d'image, prototype, Spyder, Jupyter

en: :octicon:`book;1em;sd-text-info` Prototyping a custom processing pipeline
fr: :octicon:`book;1em;sd-text-info`  Prototypage d'une chaîne de traitement personnalisée

en: This example shows how to prototype a custom image processing pipeline using DataLab:
fr: Cet exemple montre comment prototyper une chaîne de traitement d'image personnalisée en utilisant DataLab :

en: Define a custom processing function
fr: Définir une fonction de traitement personnalisée

en: Create a macro-command to apply the function to an image
fr: Créer une macro-commande pour appliquer la fonction à une image

en: Use the same code from an external IDE (e.g. Spyder) or a Jupyter notebook
fr: Utiliser le même code à partir d'un IDE externe (par exemple Spyder) ou d'un notebook Jupyter

en: Create a plugin to integrate the function in the DataLab GUI
fr: Créer un plugin pour intégrer la fonction dans l'interface graphique de DataLab

en: For illustrating the extensibility of DataLab, we will use a simple image processing function that is not available in the standard DataLab distribution, and that represents a typical use case for prototyping a custom processing pipeline.
fr: Pour illustrer l'extensibilité de DataLab, nous utiliserons une fonction de traitement d'image simple qui n'est pas disponible dans la distribution standard de DataLab, et qui représente un cas d'utilisation typique pour le prototypage d'une chaîne de traitement personnalisée.

en: The function that we will work on is a denoising filter that combines the ideas of averaging and edge detection. This filter will average the pixel values in the neighborhood, but with a twist: it will give less weight to pixels that are significantly different from the central pixel, assuming they might be part of an edge or noise.
fr: La fonction sur laquelle nous allons travailler est un filtre de débruitage qui combine les idées de moyennage et de détection de contours. Ce filtre va moyenner les valeurs de pixels dans le voisinage, mais avec une particularité : il donnera moins de poids aux pixels qui sont significativement différents du pixel central, en supposant qu'ils pourraient faire partie d'un bord ou d'un bruit.

en: Here is the code of the ``weighted_average_denoise`` function::
fr: Voici le code de la fonction ``weighted_average_denoise`` :

en: For testing our processing function, we will use a generated image from a DataLab plugin example (`plugins/examples/cdl_example_imageproc.py`). Before starting, make sure that the plugin is installed in DataLab (see the first steps of the tutorial :ref:`tutorial_blobs`).
fr: Pour tester notre fonction de traitement, nous utiliserons une image générée à partir d'un exemple de plugin DataLab (plugins/examples/cdl_example_imageproc.py). Avant de commencer, assurez-vous que le plugin est installé dans DataLab (voir les premières étapes du tutoriel :ref:`tutorial_blobs`).

en: To begin, we reorganize the window layout of DataLab to have the "Image Panel" on the left and the "Macro Panel" on the right.
fr: Pour commencer, nous réorganisons la disposition de la fenêtre de DataLab pour avoir le "Panneau Image" à gauche et le "Gestionnaire de Macros" à droite.

en: We generate a new image using the "Plugins > Extract blobs (example) > Generate test image" menu.
fr: Nous générons une nouvelle image en utilisant le menu "Plugins > Extract blobs (example) > Generate test image".

en: We select a limited size for the image (e.g. 512x512 pixels) because our algorithm is quite slow, and click on "OK".
fr: Nous sélectionnons une taille limitée pour l'image (par exemple 512x512 pixels) car notre algorithme est assez lent, et cliquons sur "OK".

en: We can now see the generated image in the "Image Panel".
fr: Nous pouvons maintenant voir l'image générée dans le "Panneau Image".

en: Create a macro-command
fr: Créer une macro-commande

en: Let's get back to our custom function. We can create a new macro-command that will apply the function to the current image. To do so, we open the "Macro Panel" and click on the "New macro" |libre-gui-add| button.
fr: Revenons à notre fonction personnalisée. Nous pouvons créer une nouvelle macro-commande qui appliquera la fonction à l'image actuelle. Pour ce faire, nous ouvrons le "Gestionnaire de Macros" et cliquons sur le bouton "Nouvelle macro" |libre-gui-add|.

en: DataLab creates a new macro-command which is not empty: it contains a sample code that shows how to create a new image and add it to the "Image Panel". We can remove this code and replace it with our own code::
fr: DataLab crée une nouvelle macro-commande qui n'est pas vide : elle contient un code d'exemple qui montre comment créer une nouvelle image et l'ajouter au "Panneau Image". Nous pouvons supprimer ce code et le remplacer par le nôtre :

en: In DataLab, macro-commands are simply Python scripts:
fr: Dans DataLab, les macro-commandes sont simplement des scripts Python :

en: Macros are part of DataLab's **workspace**, which means that they are saved and restored when exporting and importing to/from an HDF5 file.
fr: Les macros font partie de l'**espace de travail** de DataLab, ce qui signifie qu'elles sont sauvegardées et restaurées lors de l'exportation et de l'importation vers/depuis un fichier HDF5.

en: Macros are executed in a separate process, so we need to import the necessary modules and initialize the proxy to DataLab. The proxy is a special object that allows to communicate with DataLab.
fr: Les macros sont exécutées dans un processus séparé, nous devons donc importer les modules nécessaires et initialiser le proxy vers DataLab. Le proxy est un objet spécial qui permet de communiquer avec DataLab.

en: As a consequence, **when defining a plugin or when controlling DataLab from an external IDE, we can use exactly the same code as in the macro-command**. This is a very important point, because it means that we can prototype our processing pipeline in DataLab, and then use the same code in a plugin or in an external IDE to develop it further.
fr: En conséquence, **lors de la définition d'un plugin ou du contrôle de DataLab à partir d'un IDE externe, nous pouvons utiliser exactement le même code que dans la macro-commande**. C'est un point très important, car cela signifie que nous pouvons prototyper notre chaîne de traitement dans DataLab, puis utiliser le même code dans un plugin ou dans un IDE externe pour le développer davantage.

en: The macro-command is executed in DataLab's Python environment, so we can use the modules that are available in DataLab. However, we can also use our own modules, as long as they are installed in DataLab's Python environment or in a Python distribution that is compatible with DataLab's Python environment.
fr: La macro-commande est exécutée dans l'environnement Python de DataLab, nous pouvons donc utiliser les modules disponibles dans DataLab. Cependant, nous pouvons également utiliser nos propres modules, tant qu'ils sont installés dans l'environnement Python de DataLab ou dans une distribution Python compatible avec l'environnement Python de DataLab.

en: If your custom modules are not installed in DataLab's Python environment, and if they are compatible with DataLab's Python version, you can prepend the ``sys.path`` with the path to the Python distribution that contains your modules::
fr: Si vos modules personnalisés ne sont pas installés dans l'environnement Python de DataLab, et s'ils sont compatibles avec la version Python de DataLab, vous pouvez préfixer ``sys.path`` avec le chemin vers la distribution Python qui contient vos modules :

en: This will allow you to import your modules in the macro-command and mix them with the modules that are available in DataLab.
fr: Cela vous permettra d'importer vos modules dans la macro-commande et de les mélanger avec les modules disponibles dans DataLab.

en: If you use this method, make sure that your modules are compatible with DataLab's Python version. Otherwise, you will get errors when importing them.
fr: Si vous utilisez cette méthode, assurez-vous que vos modules sont compatibles avec la version Python de DataLab. Sinon, vous obtiendrez des erreurs lors de leur importation.

en: Now, let's execute the macro-command by clicking on the "Run macro" |libre-camera-flash-on| button:
fr: Maintenant, exécutons la macro-commande en cliquant sur le bouton "Exécuter la macro" |libre-camera-flash-on| :

en: The macro-command is executed in a separate process, so we can continue to work in DataLab while the macro-command is running. And, if the macro-command takes too long to execute, we can stop it by clicking on the "Stop macro" |libre-camera-flash-off| button.
fr: La macro-commande est exécutée dans un processus séparé, nous pouvons donc continuer à travailler dans DataLab pendant que la macro-commande s'exécute. Et, si la macro-commande prend trop de temps à s'exécuter, nous pouvons l'arrêter en cliquant sur le bouton "Arrêter la macro" |libre-camera-flash-off|.

en: During the execution of the macro-command, we can see the progress in the "Macro Panel" window: the process standard output is displayed in the "Console" below the macro editor. We can see the following messages:
fr: Pendant l'exécution de la macro-commande, nous pouvons voir la progression dans la fenêtre "Gestionnaire de Macros" : la sortie standard du processus est affichée dans la "Console" en dessous de l'éditeur de macro. Nous pouvons voir les messages suivants :

en: ``---[...]---[# ==> Running 'Untitled 01' macro...]``: the macro-command starts
fr: ``---[...]---[# ==> Running 'Untitled 01' macro...]`` : la macro-commande démarre

en: ``Connecting to DataLab XML-RPC server...OK [...]``: the proxy is connected to DataLab
fr: ``Connecting to DataLab XML-RPC server...OK [...]`` : le proxy est connecté à DataLab

en: ``---[...]---[# <== 'Untitled 01' macro has finished]``: the macro-command ends
fr: ``---[...]---[# <== 'Untitled 01' macro has finished]`` : la macro-commande se termine

en: When the macro-command has finished, we can see the new image in the "Image Panel". Our filter has been applied to the image, and we can see that the noise has been reduced.
fr: Lorsque la macro-commande est terminée, nous pouvons voir la nouvelle image dans le "Panneau Image". Notre filtre a été appliqué à l'image, et nous pouvons voir que le bruit a été réduit.

en: Prototyping with an external IDE
fr: Prototypage avec un IDE externe

en: Now that we have a working prototype of our processing pipeline, we can use the same code in an external IDE to develop it further.
fr: Maintenant que nous avons un prototype fonctionnel de notre chaîne de traitement, nous pouvons utiliser le même code dans un IDE externe pour le développer davantage.

en: For example, we can use the Spyder IDE to debug our code. To do so, we need to install Spyder but not necessarily in DataLab's Python environment (in the case of the stand-alone version of DataLab, it wouldn't be possible anyway).
fr: Par exemple, nous pouvons utiliser l'IDE Spyder pour déboguer notre code. Pour ce faire, nous devons installer Spyder mais pas nécessairement dans l'environnement Python de DataLab (dans le cas de la version autonome de DataLab, ce ne serait de toute façon pas possible).

en: The only requirement is to install a DataLab client in Spyder's Python environment:
fr: Le seul prérequis est d'installer un client DataLab dans l'environnement Python de Spyder :

en: If you use the stand-alone version of DataLab or if you want or need to keep DataLab and Spyder in separate Python environments, you can install the `DataLab Simple Client <https://pypi.org/project/cdlclient/>`_ (``cdl-client``) using the ``pip`` package manager::
fr: Si vous utilisez la version autonome de DataLab ou si vous voulez ou devez garder DataLab et Spyder dans des environnements Python séparés, vous pouvez installer le `DataLab Simple Client <https://pypi.org/project/cdlclient/>`_ (``cdl-client``) en utilisant le gestionnaire de paquets ``pip`` :

en: Or you may also install the `DataLab Python package <https://pypi.org/project/cdl/>`_ (``cdl``) which includes the client (but also other modules, so we don't recommend this method if you don't need all DataLab's features in this Python environment)::
fr: Ou vous pouvez également installer le `paquet Python DataLab <https://pypi.org/project/cdl/>`_ (``cdl``) qui inclut le client (mais aussi d'autres modules, donc nous ne recommandons pas cette méthode si vous n'avez pas besoin de toutes les fonctionnalités de DataLab dans cet environnement Python) :

en: If you use the DataLab Python package, you may run Spyder in the same Python environment as DataLab, so you don't need to install the client: it is already available in the main DataLab package (the ``cdl`` package).
fr: Si vous utilisez le paquet Python DataLab, vous pouvez exécuter Spyder dans le même environnement Python que DataLab, vous n'avez donc pas besoin d'installer le client : il est déjà disponible dans le paquet principal DataLab (le paquet ``cdl``).

en: Once the client is installed, we can start Spyder and create a new Python script:
fr: Une fois le client installé, nous pouvons démarrer Spyder et créer un nouveau script Python :

en: We go back to DataLab and select the first image in the "Image Panel".
fr: Nous retournons à DataLab et sélectionnons la première image dans le "Panneau Image".

en: Then, we execute the script in Spyder, step-by-step (using the defined cells), and we can see the result in DataLab.
fr: Ensuite, nous exécutons le script dans Spyder, étape par étape (en utilisant les cellules définies), et nous pouvons voir le résultat dans DataLab.

en: We can see in DataLab that a new image has been added to the "Image Panel". This image is the result of the execution of the script in Spyder. Here we have used the script without any modification, but we could have modified it to test new ideas, and then use the modified script in DataLab.
fr: Nous pouvons voir dans DataLab qu'une nouvelle image a été ajoutée au "Panneau Image". Cette image est le résultat de l'exécution du script dans Spyder. Ici, nous avons utilisé le script sans aucune modification, mais nous aurions pu le modifier pour tester de nouvelles idées, puis utiliser le script modifié dans DataLab.

en: Prototyping with a Jupyter notebook
fr: Prototypage avec un notebook Jupyter

en: We can also use a Jupyter notebook to prototype our processing pipeline. To do so, we need to install Jupyter but not necessarily in DataLab's Python environment (in the case of the stand-alone version of DataLab, it wouldn't be possible anyway).
fr: Nous pouvons également utiliser un notebook Jupyter pour prototyper notre chaîne de traitement. Pour ce faire, nous devons installer Jupyter mais pas nécessairement dans l'environnement Python de DataLab (dans le cas de la version autonome de DataLab, ce ne serait de toute façon pas possible).

en: The only requirement is to install a DataLab client in Jupyter's Python environment (see the previous section for more details: that is exactly the same procedure as for Spyder or any other IDE like Visual Studio Code, for example).
fr: Le seul prérequis est d'installer un client DataLab dans l'environnement Python de Jupyter (voir la section précédente pour plus de détails : c'est exactement la même procédure que pour Spyder ou tout autre IDE comme Visual Studio Code, par exemple).

en: Once the client is installed, we can start Jupyter and create a new notebook.
fr: Une fois le client installé, nous pouvons démarrer Jupyter et créer un nouveau notebook.

en: Then, we execute the notebook in Jupyter, step-by-step (using the defined cells), and we can see the result in DataLab. Once again, we can see in DataLab that a new image has been added to the "Image Panel". This image is the result of the execution of the notebook in Jupyter. As for the script in Spyder, we could have modified the notebook to test new ideas, and then use the modified notebook in DataLab.
fr: Ensuite, nous exécutons le notebook dans Jupyter, étape par étape (en utilisant les cellules définies), et nous pouvons voir le résultat dans DataLab. Une fois de plus, nous pouvons voir dans DataLab qu'une nouvelle image a été ajoutée au "Panneau Image". Cette image est le résultat de l'exécution du notebook dans Jupyter. Comme pour le script dans Spyder, nous aurions pu modifier le notebook pour tester de nouvelles idées, puis utiliser le notebook modifié dans DataLab.

en: Creating a plugin
fr: Création d'un plugin

en: Now that we have a working prototype of our processing pipeline, we can create a plugin to integrate it in DataLab's GUI. To do so, we need to create a new Python module that will contain the plugin code. We can use the same code as in the macro-command, but we need to make some changes.
fr: Maintenant que nous avons un prototype fonctionnel de notre chaîne de traitement, nous pouvons créer un plugin pour l'intégrer dans l'interface graphique de DataLab. Pour ce faire, nous devons créer un nouveau module Python qui contiendra le code du plugin. Nous pouvons utiliser le même code que dans la macro-commande, mais nous devons apporter quelques modifications.

en: The plugin system is described in the :ref:`about_plugins` section.
fr: Le système de plugins est décrit dans la section :ref:`about_plugins`.

en: Apart from integrating the feature to DataLab's GUI which is more convenient for the user, the advantage of creating a plugin is that we can take benefit of the DataLab infrastructure, if we encapsulate our processing function in a certain way (see below):
fr: Mis à part l'intégration de la fonctionnalité à l'interface graphique de DataLab qui est plus pratique pour l'utilisateur, l'avantage de créer un plugin est que nous pouvons tirer parti de l'infrastructure de DataLab, si nous encapsulons notre fonction de traitement d'une certaine manière (voir ci-dessous) :

en: Our function will be executed in a separate process, so we can interrupt it if it takes too long to execute.
fr: Notre fonction sera exécutée dans un processus séparé, nous pouvons donc l'interrompre si elle prend trop de temps à s'exécuter.

en: Warnings and errors will be handled by DataLab, so we don't need to handle them ourselves.
fr: Les avertissements et les erreurs seront gérés par DataLab, nous n'avons donc pas besoin de les gérer nous-mêmes.

en: The most significant change is that we need to define a function that will be operating on DataLab's native image objects (:class:`cdl.obj.ImageObj`), instead of operating on NumPy arrays. So we need to find a way to call our custom function ``weighted_average_denoise`` with a :class:`cdl.obj.ImageObj` as input and output. To avoid writing a lot of boilerplate code, we can use the function wrapper provided by DataLab: :class:`cdl.core.computation.image.Wrap11Func`.
fr: Le changement le plus significatif est que nous devons définir une fonction qui fonctionnera sur les objets d'image natifs de DataLab (:class:`cdl.obj.ImageObj`), au lieu de fonctionner sur des tableaux NumPy. Nous devons donc trouver un moyen d'appeler notre fonction personnalisée ``weighted_average_denoise`` avec un :class:`cdl.obj.ImageObj` en entrée et en sortie. Pour éviter d'écrire beaucoup de code de base, nous pouvons utiliser l'enveloppe de fonction fournie par DataLab : :class:`cdl.core.computation.image.Wrap11Func`.

en: Besides we need to define a class that describes our plugin, which must inherit from :class:`cdl.plugins.PluginBase` and name the Python script that contains the plugin code with a name that starts with ``cdl_`` (e.g. ``cdl_custom_func.py``), so that DataLab can discover it at startup.
fr: Par ailleurs, nous devons définir une classe qui décrit notre plugin, qui doit hériter de :class:`cdl.plugins.PluginBase` et nommer le script Python qui contient le code du plugin avec un nom qui commence par ``cdl_`` (par exemple ``cdl_custom_func.py``), afin que DataLab puisse le découvrir au démarrage.

en: Moreover, inside the plugin code, we want to add an entry in the "Plugins" menu, so that the user can access our plugin from the GUI.
fr: De plus, dans le code du plugin, nous voulons ajouter une entrée dans le menu "Plugins", afin que l'utilisateur puisse accéder à notre plugin depuis l'interface graphique.

en: Here is the plugin code:
fr: Voici le code du plugin :

en: To test it, we have to add the plugin script to one of the plugin directories that are discovered by DataLab at startup (see the :ref:`about_plugins` section for more details, or the :ref:`tutorial_blobs` for an example).
fr: Pour le tester, nous devons ajouter le script du plugin à l'un des répertoires de plugins qui sont découverts par DataLab au démarrage (voir la section :ref:`about_plugins` pour plus de détails, ou le :ref:`tutorial_blobs` pour un exemple).

en: We restart DataLab and we can see that the plugin has been loaded.
fr: Nous redémarrons DataLab et nous pouvons voir que le plugin a été chargé.

en: We generate again our test image using (see the first steps of the tutorial), and we process it using the plugin: "Plugins > My custom filters > Weighted average denoise".
fr: Nous générons à nouveau notre image de test en utilisant (voir les premières étapes du tutoriel), et nous la traitons en utilisant le plugin : "Plugins > My custom filters > Weighted average denoise".
