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.

Point 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 :

Partie Théorique, située à l’ouverture de chaque chapitre, contenant les concepts présentés et des exemples de code exécutables ;
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.py`

La bibliothèque morph.py (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, scikit-image, scikit-learn, NumPy ou Matplotlib, 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.

Chaque fois que possible, la bibliothèque offre deux versions pour un même algorithme : une implémentation didactique, écrite pas à pas pour refléter directement les définitions mathématiques présentées dans le livre, et une autre implémentation optimisée, basée sur des bibliothèques spécialisées pour les applications pratiques.

Héritage Technique

La structure de 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.dil : implémentation optimisée, indiquée pour les applications pratiques ;
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.

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 :

from morph import mm

img = mm.gray(mm.read("lena.jpg"))  # lecture et conversion en niveaux de gris
grad = mm.gradm(img)                # gradient morphologique
mm.show(grad)                       # affichage

Au long du livre, de nouvelles méthodes sont introduites dans la bibliothèque pour simplifier la réalisation des Exercices de Programmation (EPs). Parmi elles figurent mm.readTrain() et mm.readTest(), qui automatisent la lecture des bases d’entraînement et de test utilisées dans les chapitres dédiés à la reconnaissance de formes.

De plus, tous les projets du Gemini Notebook incluent le fichier morph.py, 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 l’algorithme mm.knn0 du morph.py a été implémenté, en montrant le code et en commentant chaque étape de manière didactique. De plus, expliquez les différences entre mm.knn0() et mm.knn().

Implé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.knn0(), mm.dil0() et mm.dil1()) sont des implémentations didactiques, développées pour faciliter la compréhension des algorithmes. Quant aux fonctions sans suffixe (comme mm.knn() et mm.dil()), elles utilisent des implémentations optimisées, souvent basées sur des bibliothèques spécialisées, telles que OpenCV, scikit-image et scikit-learn, étant plus adaptées aux applications pratiques.

Dans les activités évaluées par le VPL de Moodle, des bibliothèques comme scikit-learn et, dans certains cas, scikit-image, peuvent ne pas être utilisées en raison des limitations de mémoire de l’environnement d’exécution. Pour cette raison, les Exercices de Programmation (EPs) emploient préférentiellement les implémentations didactiques de morph.py, qui produisent les mêmes résultats, bien qu’avec une performance computationnelle moindre. Cette restriction n’existe pas lorsque les programmes sont exécutés localement, par exemple dans VS Code, Jupyter Notebook ou Google Colab.

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

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

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.

Note 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 :

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
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/.

Autres 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.

Ré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 ≥, ×). 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

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

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

Copiez le code source complet de la page (Ctrl+U → Ctrl+A → Ctrl+C).
Sur Moodle, créez l’activité VPL, accédez à l’éditeur HTML, collez le contenu (Ctrl+V) et enregistrez.
Importez les fichiers .cases du dossier all/capXX/casos/ dans les paramètres de test du VPL.

Ré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.