Préface

Ce livre constitue une œuvre en permanente actualisation dans les domaines du Traitement Numérique d’Images (TNI) et de la Vision par Ordinateur (VO), conçue comme matériel didactique interactif pour les cours de premier et de deuxième cycle en Informatique, Ingénierie et domaines connexes.

ImportantPoint important

L’ouvrage repose sur la méthodologie décrite dans Zampirolli et al. (2025) — extension de Zampirolli et al. (2024), travail primé dans la filière Ressources et Environnements Éducatifs de l’EduComp 2024. Le contenu intègre la bibliothèque morph.py, développée par l’auteur.

Ce n’est pas un livre statique. Son contenu évolue continuellement au fur et à mesure que les exemples sont améliorés, que de nouvelles sections sont incorporées et que les approches pédagogiques sont affinées en fonction de l’expérience d’utilisation et des retours des étudiants et des enseignants. De cette manière, l’ouvrage est traité comme un projet en constante évolution, cherchant à accompagner à la fois les avancées technologiques et les meilleures pratiques d’enseignement en TNI et VO.

Contexte de la première édition

Le contenu de cette édition a été élaboré entre mai et août 2026, lors de la première offre du cours de Traitement Numérique d’Images basé sur ce matériel didactique. Le cours a été dispensé dans deux groupes de premier cycle — majoritairement composés d’étudiants en Informatique, en période matinale — et dans un groupe de deuxième cycle en Informatique, tous à l’UFABC. Cette première édition représente le résultat de cette offre initiale, consolidant le contenu développé, testé et continuellement perfectionné tout au long de la période académique.

La méthodologie d’enseignement adoptée a suivi une séquence structurée à chaque cours. Initialement, une courte vidéo était diffusée, d’une durée moyenne de 7 minutes, générée dans Gemini Notebook, alternant entre la présentation de la partie conceptuelle du chapitre et la résolution des Exercices de Programmation (EPs). Dans ce second cas, presque tous les EPs étaient résolus pendant le cours lui-même. Ensuite, un ensemble d’environ 12 diapositives, également générées dans Gemini Notebook, était présenté, ayant comme sources le PDF complet du livre et le fichier morph.py. Ces diapositives étaient produites à partir d’un prompt spécifique pour la génération du contenu théorique et pratique de chaque chapitre.

Après cette étape initiale, il restait environ 100 minutes de cours pour l’exploration des deux notebooks Colab du chapitre, l’un théorique et l’autre pratique, avec un accent sur les simulateurs interactifs et l’exécution des blocs de code, permettant aux étudiants de modifier les paramètres et d’observer leurs effets. Dans les cours réalisés en laboratoire, les étudiants transféraient les réponses des EPs développées dans Colab directement vers les activités VPL de Moodle, où elles étaient soumises à l’évaluation automatique. Ce processus de publication et d’utilisation des EPs est présenté à la fin de cette préface.

L’évaluation continue a inclus des simulations bimensuelles, appliquées avec le SEB (Safe Exam Browser) sur Moodle, contenant des EPs similaires à ceux des listes d’exercices. Chaque simulation accordait un bonus de 5 % sur la note finale. Les deux examens du cours utilisaient également le SEB, mais étaient composés de questions paramétrées générées dans MCTest, dont la description combine LaTeX et des paramètres au format [[code:variable]], définis dans des extraits de Python délimités par [[def: ... ]] dans la question elle-même. Ce processus a permis de générer 110 variations d’examen, tirées individuellement parmi les étudiants.

L’Annexe A détaille la création de ces questions dans MCTest et leur exportation vers Moodle ; l’Annexe B décrit la configuration des activités VPL, y compris le processus de publication des EPs ; l’Annexe C présente la configuration du SEB pour les simulations et les examens ; l’Annexe D décrit la génération des vidéos et diapositives utilisées dans les cours avec Gemini Notebook ; et l’Annexe E détaille l’utilisation de l’Intelligence Artificielle (IA) dans la génération de feedback socratique pour les activités formatives et évaluatives, complétant la correction automatique réalisée par le VPL.

Comment ce livre est produit

Le contenu de ce livre est développé dans Quarto et stocké dans le dossier all du dépôt github.com/fzampirolli/pdi-vc. À partir d’un code source unique, le livre est automatiquement généré et publié dans différents formats, présentés dans le Table 1.

Bien que l’édition en PDF enregistre l’état de l’œuvre à la fin de la première offre du cours en 2026, le développement du livre se poursuit de manière permanente. À chaque mise à jour du dépôt GitHub, de nouvelles versions des pages HTML, du PDF et des notebooks sont automatiquement générées, mettant immédiatement les améliorations à la disposition des lecteurs.

Table 1: Différents formats de publication générés automatiquement à partir du même code source.
Format Description
HTML Version pour le web, avec simulateurs interactifs et navigation entre les chapitres : fzampirolli.github.io/pdi-vc/
PDF Version adaptée à l’impression ou à la lecture hors ligne : livro.pt.py.pdf
Notebooks (.ipynb) Compatibles avec Jupyter et Google Colab, permettant d’exécuter, de modifier et d’expérimenter les exemples de code et les Exercices de Programmation (EPs). Un filtre personnalisé maintient les références croisées, la numérotation des figures et des tableaux, et formate automatiquement les citations selon la norme ABNT.

L’ouvrage est publié en dix combinaisons — chaque piste de code (Python et C++) dans cinq langues (portugais, anglais, français, espagnol et italien). Avec le cache de traduction déjà rempli, une régénération complète (traduction, réexécution des notebooks, rendu HTML et PDF, et publication) prend environ 72 minutes, avec un parallélisme réel moyen de ~5 processus (pic de 8) ; la première génération d’une nouvelle langue, avec un cache vide, est bien plus lente — environ 80 minutes par combinaison, comme observé lors des premières générations en espagnol et en italien. Le Table 2 résume chaque combinaison (cache déjà rempli) : nombre de pages du PDF et temps de rendu. Ce temps total réel est bien inférieur à la somme des temps de chaque combinaison prise isolément (plus de 5 heures si elles étaient exécutées une par une) : sur un processeur à plusieurs cœurs, plusieurs combinaisons s’exécutent en même temps, donc le temps total n’est pas la simple somme des temps individuels.

Table 2: Nombre de pages du PDF et temps de rendu par combinaison (parallélisme réel moyen de ~5 processus, pic de 8). La combinaison de base Python/Portugais ne fait que rendre les sorties déjà enregistrées dans les notebooks source ; les autres réexécutent tout le code.
Combinaison Piste Langue Pages Temps de rendu
py.pt Python Portugais (base) 654 ~7 min
py.en Python Anglais 644 ~31 min
py.fr Python Français 666 ~31 min
py.es Python Espagnol 666 ~31 min
py.it Python Italien 658 ~31 min
cpp.pt C++ Portugais 434 ~26 min
cpp.en C++ Anglais 426 ~34 min
cpp.fr C++ Français 434 ~38 min
cpp.es C++ Espagnol 430 ~37 min
cpp.it C++ Italien 428 ~35 min

État de validation. Seule la combinaison py.pt (Python, portugais) est la source curée : c’est là que l’auteur écrit, révise et valide tout le contenu. Les neuf autres combinaisons — les pistes C++ et les traductions en anglais, français, espagnol et italien — sont générées automatiquement, par traduction via un modèle de langage et transpilation du code, et nécessitent encore une révision détaillée. Le point le plus sensible est le texte incrusté dans certaines figures : là où la version traduite n’a pas encore été produite, l’image apparaît avec du texte en portugais (chaque figure traduite suit le même suffixe de langue que les autres fichiers générés, par exemple image_en.png).

Les pages HTML, le PDF et les notebooks disponibles dans le projet reflètent toujours l’état le plus récent du développement. Lorsqu’une édition officielle est publiée, elle est identifiée par une balise dans le dépôt GitHub, permettant de reproduire exactement le contenu correspondant à cette édition. Ainsi, le lecteur peut suivre à la fois l’évolution continue du projet et récupérer toute édition officielle précédemment publiée.

git clone https://github.com/fzampirolli/pdi-vc.git
cd pdi-vc
git checkout <tag-da-versao>

Chaque chapitre met à disposition deux boutons Exécuter Colab (Figure 1), qui dirigent vers des environnements complémentaires :

  1. Partie Théorique, située à l’ouverture de chaque chapitre, contenant les concepts présentés et des exemples de code exécutables ;
  2. Partie Pratique, dans la section Partie Pratique avec Exercices de Programmation (EPs), dédiée aux exercices et à leurs simulateurs interactifs.

Figure 1: Bouton cliquable Exécuter Colab, disponible au début des parties Théorique et Pratique de chaque chapitre, permettant l’exécution interactive des exemples et des exercices. Dans la version PDF, il existe un lien HTML direct entre l’image du simulateur et sa légende.

La génération des notebooks est entièrement automatisée par le script gerar_notebooks_alunos.py, qui adapte le contenu aux environnements interactifs, permettant son exécution sans nécessité d’installation de Quarto.

Utilisation d’outils d’Intelligence Artificielle

La conception, le projet pédagogique, la structure conceptuelle et le contenu fondamental de ce livre sont de paternité exclusive de l’auteur.

Dans le processus d’édition et de soutien au développement, des outils d’Intelligence Artificielle (IA), tels que ChatGPT, Claude, DeepSeek et Gemini, ont été utilisés dans leurs versions gratuites, employés strictement comme ressources auxiliaires. Leur utilisation s’est limitée au soutien à la révision et à l’amélioration du style textuel, à l’optimisation de la syntaxe des codes et à la génération assistée d’illustrations conceptuelles et d’exemples.

Toutes les réponses et contenus suggérés par ces outils ont été soumis à une analyse critique, une vérification, une validation technique, une adaptation et une intégration par l’auteur, qui assume la responsabilité du texte, des codes et des ressources pédagogiques présentés. Les outils d’IA ne sont pas considérés comme auteurs ou coauteurs de l’œuvre, ni responsables des décisions intellectuelles, techniques ou pédagogiques qui fondent son contenu.

Il convient également de souligner que les simulateurs et ressources interactives présents dans le livre — disponibles dans les versions HTML et Jupyter Notebook (IPYNB) — ont été conçus et implémentés dans le cadre de l’approche pédagogique de l’œuvre, dans le but de permettre une expérimentation directe des concepts présentés et de favoriser l’autonomie d’apprentissage du lecteur.

Distinct de l’utilisation éditoriale décrite ci-dessus, le pipeline de génération multilingue (voir « Comment ce livre est produit ») emploie un modèle de langage comme composant d’ingénierie du système : la traduction automatique du contenu entre le portugais et d’autres langues, avec un cache incrémental qui évite de retraduire les passages inchangés. Cette étape utilise l’API payante de DeepSeek (modèle deepseek-v4-flash) ; le livre complet a déjà été traduit du portugais vers l’anglais, le français, l’espagnol et l’italien, et les chapitres 1 à 5 disposent en outre d’une piste C++ qui compile et s’exécute réellement — le tout pour un coût cumulé de l’ordre de quelques dollars, grâce au cache incrémental.

Certaines images du livre contiennent encore du texte en portugais ; elles seront également traduites à l’avenir dans les autres langues, en suivant le même modèle de suffixe que les autres fichiers générés (par exemple, image_en.png).

La bibliothèque morph.hpp

La bibliothèque morph.hpp (Zampirolli et al., 2025) accompagne toute l’œuvre comme un outil de soutien à l’enseignement. Son objectif n’est pas de remplacer les bibliothèques consolidées, comme OpenCV, ni de rivaliser avec elles en performance ou en couverture. Au lieu de cela, elle cherche à rendre transparents les algorithmes fondamentaux du Traitement Numérique d’Images et de la Vision par Ordinateur (TNI-VO), permettant à l’étudiant de comprendre leur implémentation, de modifier le code et de développer de nouvelles fonctionnalités.

C’est l’équivalent en C++ de morph.py : header-only (il suffit d’un #include "morph.hpp"), avec les mêmes noms de fonction dans le namespace mm:: — quiconque connaît déjà mm.dil(), mm.dil0() ou mm.gradm() en Python reconnaît immédiatement mm::dil(), mm::dil0() et mm::gradm() en C++. Une divergence de nom entre les deux versions est considérée comme un défaut de la bibliothèque, non comme un choix de conception.

NoteHéritage Technique

La structure de morph.hpp (comme celle de sa contrepartie morph.py) a pour base des outils de Morphologie Mathématique développés au Brésil, comme MMachLib (Lotufo et al., 1997) et MMach (Barrera et al., 1998), ainsi que la mmorph, utilisée dans l’ouvrage de Dougherty; Lotufo (2003). Ces bibliothèques ont servi de référence pour l’enseignement du domaine pendant des décennies.

Cette philosophie peut être observée, par exemple, dans les opérateurs morphologiques de dilatation :

  • mm::dil0 : implémentation didactique de la dilatation pour les éléments structurants planaires, suivant directement la définition classique de la Morphologie Mathématique ;
  • mm::dil1 : implémentation didactique de la dilatation pour les fonctions structurantes (kernels non planaires), suivant rigoureusement sa formulation mathématique ;
  • mm::dil : par défaut, délègue à mm::dil0() — la version didactique planaire, numériquement équivalente à cv::dilate pour ce type d’élément structurant. L’implémentation optimisée, basée sur OpenCV (cv::dilate), n’entre en jeu que si le programme est compilé avec l’option -DMM_USE_OPENCV.
ImportantUne différence délibérée par rapport à morph.py

En Python, mm.dil() (sans suffixe) est déjà l’implémentation optimisée par défaut. En C++, mm::dil() (même nom, même signature) ne devient la version optimisée que si OpenCV est explicitement lié à la compilation ; sans cela — ce qui est justement le cas par défaut, y compris sur Moodle/VPL — mm::dil() se comporte comme mm::dil0(). Ce choix évite que la piste C++ dépende d’OpenCV juste pour compiler et exécuter un exercice simple : g++ fichier.cpp -o fichier suffit déjà. Pour la version accélérée en local, il suffit de compiler avec g++ -DMM_USE_OPENCV fichier.cpp -o fichier $(pkg-config --cflags --libs opencv4).

La bibliothèque offre également des fonctions pour la lecture, l’affichage, la conversion des couleurs, le filtrage et la morphologie mathématique via une interface simple :

#include "morph.hpp"

int main() {
    mm::Image img = mm::gray(mm::read("lena.jpg"));  // lecture et conversion en niveaux de gris
    mm::Image grad = mm::gradm(img);                 // gradient morphologique
    mm::show(grad, "sortie.png");                    // affichage (écrit dans un fichier)
}

Contrairement à la version Python, mm::show() exige un chemin de sortie explicite : chaque cellule de code C++ du livre s’exécute comme un processus isolé (compilé et exécuté via %%writefile + !g++ ... sur Colab), sans le compteur global de figures qui n’a de sens que dans un seul processus Jupyter.

De plus, tous les projets du Gemini Notebook de la piste C++ incluent le fichier morph.hpp, permettant de consulter et de discuter directement l’implémentation des algorithmes présentés dans le livre. De cette manière, l’étudiant peut utiliser le Gemini Notebook lui-même comme assistant d’étude, en posant des questions telles que :

Expliquez comment la fonction mm::dil0 de morph.hpp a été implémentée, en montrant le code et en commentant chaque étape de manière didactique. Expliquez également la différence entre mm::dil0() et mm::dil() sans l’option -DMM_USE_OPENCV.

ImportantImplémentations didactiques et implémentations optimisées

Dans plusieurs chapitres, un même algorithme est présenté en deux versions. Les fonctions avec suffixe 0, 1, etc. (par exemple, mm::dil0() et mm::dil1()) sont des implémentations didactiques, développées pour faciliter la compréhension des algorithmes et disponibles indépendamment de l’option de compilation. Quant aux fonctions sans suffixe (comme mm::dil()), elles n’utilisent l’implémentation optimisée basée sur OpenCV que lorsqu’elles sont compilées avec -DMM_USE_OPENCV ; sinon, elles se comportent comme la version didactique correspondante.

Dans les activités évaluées par le VPL de Moodle, la compilation suit le mode par défaut sans -DMM_USE_OPENCV — non pas en raison de limitations de mémoire (comme c’est le cas de scikit-learn/scikit-image dans la piste Python), mais pour qu’aucun EP en C++ ne dépende de la présence d’OpenCV dans l’environnement d’exécution. En pratique, cela signifie que, sur le VPL, mm::dil() et mm::dil0() produisent exactement le même résultat. En local — par exemple dans VS Code ou Google Colab — l’étudiant peut choisir de compiler avec -DMM_USE_OPENCV pour comparer avec la version optimisée.

Le code source de la bibliothèque est disponible à :

https://github.com/fzampirolli/pdi-vc/tree/master/morph/cpp

Exercices de Programmation (EPs) et Validation Automatique

Chaque unité du livre inclut des Exercices de Programmation (EPs) pratiques et de complexité croissante, conçus pour consolider les concepts présentés tout au long du chapitre. Chaque EP est accompagné d’un simulateur interactif, disponible dans les versions HTML et IPYNB, qui permet à l’étudiant de manipuler les paramètres, de visualiser le comportement des algorithmes et de développer une compréhension intuitive du problème avant de commencer son implémentation. De cette manière, le processus d’apprentissage combine expérimentation, programmation et validation automatique.

La validation des solutions est effectuée localement par la classe TestSuite (testsuite.py), qui compare la sortie du programme avec les fichiers de cas de test (.cases) :

TestSuite("EP01_01.py").run()

Le système prend en charge plusieurs langages (Python, Java, C++, C, JavaScript et R) et peut être intégré directement à Moodle. Pour les enseignants intéressés par le processus complet pas à pas de publication des EPs comme activités VPL, consultez le Guide de l’Enseignant, à la fin de cette préface, et l’Annexe B.

Code ouvert

Le projet est régi par des principes de code ouvert. Le dépôt public rassemble le texte, les codes, les images et les scripts : github.com/fzampirolli/pdi-vc

Chaque version du livre est archivée en permanence sur Zenodo avec un DOI citable. Pour citer ce matériel dans des travaux académiques :

ZAMPIROLLI, Francisco de Assis. PDI+VC — Traitement Numérique d’Images et Vision par Ordinateur. UFABC, 2026. DOI : 10.5281/zenodo.20784605

Il convient de noter, à propos, que le contenu exposé dans cet ouvrage reflète le regard critique, la proposition pédagogique et l’expérience d’enseignement de son auteur. Ainsi, les analyses, approches et opinions exprimées tout au long de ce livre représentent uniquement la compréhension de son concepteur, ne constituant ni ne reflétant une position officielle ou institutionnelle de l’Université Fédérale de l’ABC (UFABC).

Avant de commencer : Notebooks en Python

Le concept de Literate Programming (Programmation Littéraire), proposé par Donald Knuth (Knuth, 1984), fonde la structure de ce matériel. La logique inverse le paradigme traditionnel : le programme est écrit pour la lecture humaine, ressemblant à un essai, tandis que le code est extrait séparément pour l’exécution computationnelle.

Le contenu est structuré en notebooks — des documents qui entrelacent des cellules de texte (en Markdown) et des cellules de code (en Python).

  • Exécution : les cellules de code sont identifiées par [ ]. L’exécution peut être réalisée avec Shift + Enter ou par le bouton ▶️ de l’interface.
  • Environnements : les notebooks peuvent être exécutés localement, via Jupyter ou Visual Studio Code (VS Code), ainsi que dans des environnements cloud, comme Google Colab.
AstuceNote sur le format

Dans les environnements interactifs, le code peut être modifié et exécuté. Dans les versions statiques (HTML ou PDF), les blocs de code ont une finalité de lecture et de référence, sans préjudice à l’intégrité des explications.

Guide de l’Enseignant : Publication des EPs sur Moodle

Cette section est destinée aux enseignants souhaitant intégrer les Exercices de Programmation (EPs) aux activités VPL (Virtual Programming Lab) de Moodle, en complément de l’Annexe B.

Intégration avec Moodle (VPL)

Les EPs des notebooks peuvent être convertis en activités VPL sur Moodle. Le script ep_tools.py (exécuté via make build) automatise l’exportation des EPs de la fin de chaque chapitre en deux étapes :

  1. Extraction (make eps) : génère un HTML interactif indépendant par EP, avec énoncé, exemples et simulateur, dans gen/book/eps/<versao>/. Voir la liste complète à : https://fzampirolli.github.io/pdi-vc/eps/py.pt/index.html
  2. Conversion (make moodle) : transforme le HTML en fragment autonome, sans dépendance à un CSS externe, prêt à être collé dans l’éditeur de Moodle, dans gen/book/eps/<versao>_moodle/. Voir un exemple à : https://fzampirolli.github.io/pdi-vc/eps/py.pt_moodle/EP01_01.html

De plus, tous les simulateurs interactifs développés tout au long du livre peuvent être consultés directement à https://fzampirolli.github.io/pdi-vc/simuladores/py.pt/.

NoteAutres pistes et langues

Les liens ci-dessus utilisent py.pt comme exemple. Pour accéder aux EPs ou simulateurs d’une autre combinaison langage/langue, il suffit de remplacer ce segment dans l’URL — par exemple, cpp.it pour la piste C++ en italien : https://fzampirolli.github.io/pdi-vc/eps/cpp.it/index.html. La structure est la même pour toutes les combinaisons disponibles, sous /eps/<version>/, /eps/<version>_moodle/ et /simuladores/<version>/.

Lors de la publication avec make publish, ces deux versions de chaque EP sont disponibles aux liens indiqués. L’enseignant peut combiner les deux stratégies : coller la version Moodle dans l’éditeur VPL (avec simulateur fonctionnel) et inclure dans l’énoncé un lien vers la version complète, où les formules sont rendues correctement par MathJax.

AvertissementRévision obligatoire avant de publier sur Moodle

Bien qu’automatisée, la conversion exige une révision de l’enseignant en raison des limitations de l’éditeur TinyMCE/HTML Purifier de Moodle :

  • Formules mathématiques — TinyMCE rejette les barres obliques inverses (\), corrompant les équations LaTeX. Pour cette raison, la version Moodle convertit les formules simples en HTML pur (entités comme &ge;, &times;). Les formules complexes (\begin{cases}, matrices, intégrales) peuvent sortir incomplètes — vérifiez et, si nécessaire, réécrivez-les en texte ou indiquez la version complète via lien.
  • Figures externes — Les images complémentaires doivent être insérées manuellement dans l’activité VPL.
  • Simulateurs — Fonctionnent parfaitement à condition d’utiliser du JavaScript standard avec des styles inline et une manipulation directe du DOM (getElementById). Attention : si vous incluez des formules en LaTeX contenant le caractère \ sur Moodle, les simulateurs peuvent cesser de fonctionner.

Comment publier sur Moodle

  1. Accédez à la version Moodle de l’EP souhaité :

    https://fzampirolli.github.io/pdi-vc/eps/py.pt_moodle/EPXX_YY.html

  2. Copiez le code source complet de la page (Ctrl+U → Ctrl+A → Ctrl+C).

  3. Sur Moodle, créez l’activité VPL, accédez à l’éditeur HTML, collez le contenu (Ctrl+V) et enregistrez.

  4. Importez les fichiers .cases du dossier all/capXX/casos/ dans les paramètres de test du VPL.

AstuceRéutilisation des Cas de Test

Les fichiers .cases sont compatibles avec le VPL, permettant d’utiliser le même ensemble de tests tant dans le développement local que dans la correction automatisée sur Moodle.