Si vous avez des enseignants dans votre entourage, vous serez peut-être sollicités (si ce n’est déjà fait) pour créer des questionnaires à choix multiples (QCM). Les QCM constituent un outil commode pour évaluer des élèves ou des étudiants. Ils se présentent sous la forme de questions auxquelles plusieurs réponses possibles sont proposées. En général, une seule de ces réponses est correcte; les autres, appelées distracteurs, visent à éprouver la maîtrise du sujet par les candidats. À ce titre, elles se doivent d’être plausibles.

En règle générale, l’évaluateur souhaite produire deux versions de son questionnaire : une version vierge destinée aux candidats, et une version corrigée, souvent destinée à l’impression sur transparent, pour l’aider dans la correction des copies. Nous allons voir qu’il est possible de satisfaire à toutes ces exigences en utilisant LaTeX sans aucune extension dédiée !

Des paquets

Comme toujours, on commence un document LaTeX par l’écriture de son préambule. Dans le cas qui nous intéresse, nous allons rédiger un questionnaire en français à l’aide de la classe article. Nous avons donc besoin du code suivant :

\documentclass[11pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[french]{babel}
\usepackage[T1]{fontenc}
\usepackage{lmodern}

Les cases à cocher seront représentées par des symboles mathématiques, de sorte que nous devons aussi charger les paquets fournis par la société mathématique américaine :

\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}

Nous souhaitons en outre utiliser tout l’espace disponible afin de réduire la longueur de l’énoncé. Nous souhaitons donc écrire nos questions sur plusieurs colonnes (paquet multicol). Nous aurons aussi besoin de personnaliser l’en-tête et le pied de page (paquet fancyhdr)… et vous verrez plus tard que les macros que nous allons écrire nécessitent le paquet ifthen :

\usepackage{ifthen}
\usepackage{multicol}
\usepackage{fancyhdr} 

Des macros

Afin de pouvoir passer facilement du mode « énoncé » au mode « corrigé », nous allons définir une variable booléenne correction et l’initialiser à faux (false) :

\newboolean{correction}
\setboolean{correction}{false}

Nous allons aussi définir un compteur pour les numéros des questions :

\newcounter{QNumber}

Définir une question

Nous allons ensuite écrire une macro \Question qui permet de définir une nouvelle question. Cette macro reçoit deux arguments : le premier, facultatif, indique quel est le caractère à placer en fin de question (le plus souvent ‘:’, mais on peut aussi trouver un point d’interrogation), et le second n’est autre que la question elle-même. Nous écrivons donc :

\newcommand{\Question}[2][:]{
  \stepcounter{QNumber}
  \noindent\textbf{Question \theQNumber} -- #2~#1
}

Ajouter une liste de choix

Nous allons aussi définir un environnement Reponse pour permettre d’entrer les différents choix proposés à la sagacité des candidats :

\newenvironment{Reponse}{
  \begin{list}{$\square$}{\leftmargin=5em}
}{
  \end{list}\vspace{1em}
}

Proposition correcte et distracteurs

Il ne nous reste plus qu’à définir la macro \Vrai (resp. \Faux) pour ajouter une proposition vraie (resp. fausse) :

\newcommand{\Vrai}{
  \item[\ifthenelse{\boolean{correction}}{$\blacksquare$}{$\square$}]}
\newcommand{\Faux}{\item[$\square$]}

Vous remarquerez que le symbole utilisé par la macro \Vrai dépend de l’état de la variable booléenne correction. De cette façon, si correction est égal à true, les réponses justes seront marquées par un carré plein, ce qui révèle la correction du questionnaire.

En-tête et pied de page

On souhaite ajouter en en-tête de la première page des champs permettant au condidat d’indiquer son nom et son prénom :

\chead{\ifthenelse{\thepage=1}{
  \textbf{Nom :}
  \makebox[12em]{\dotfill}
  \hspace{2em}
  \textbf{Prénom :}
  \makebox[12em]{\dotfill}}{}} 

Si les questions continuent au verso, on veut que le recto de la première page se termine par la mention « Tournez la page s’il vous plaît » :

\rfoot{\ifthenelse{\thepage=1}{\textit{(tournez la page s.v.p)}}{}}

Je laisse au lecteur le soin de généraliser ceci à toutes les pages impaires dans le cas d’un questionnaire comportant plus de deux pages pleines.

Compilation du document

Pour compiler votre document et produire un fichier PDF, il vous suffit d’utiliser la commande pdflatex qcm.tex. En changeant la valeur du booléen correction, vous obtenez ainsi un énoncé et un corrigé. Le code source est disponible ici.

Cordialement,
Cacophrène

Après un long moment d’absence, je reviens pour vous parler d’une notion dont l’intérêt m’a été révélé par un article sur le blog de bluestorm. Il s’agit des types fantômes, dont je souhaite vous montrer ici tout le bien. Naturellement, je vais partir d’un cas concret autour de ce que je développe actuellement.

Le contexte

Une application pour microscopistes

Je suis actuellement en train d’écrire les grandes lignes d’un programme destiné à des microscopistes amateurs, dont il existe déjà une version en Visual Basic (à réécrire et faire évoluer). Ce programme doit permettre de mettre en forme des images pour un forum en leur ajoutant un cartouche contenant diverses informations utiles (échelle, type de matériel, coloration éventuelle, etc.). Je vous donne une image ci-dessous pour vous faire une idée. Une caractéristique importante de ce logiciel réside dans sa capacité à dessiner des échelles à partir d’une relation entre un nombre X de pixels et une taille Y en micromètres, déterminée sur une image étalon.

Spores d’helvelle après coloration.
Objectif Zeiss Planapo 100/1.3

Image d’étalon

Une image étalon est une photo dont les éléments ont une taille connue, prise dans les mêmes conditions qu’une image classique. Le plus souvent, il s’agit d’une « règle » dont les graduations sont espacées de 10 µm (la bagatelle de 100 graduations dans un millimètre…). Le programme charge l’image d’étalon, l’analyse à la manière d’un outil de reconnaissance de caractères (en beaucoup plus simple !), et en déduit la taille d’une graduation, exprimée en pixels. De son côté, l’utilisateur indique la taille réelle correspondante, en micromètres cette fois-ci (cf. l’image ci-dessous).

Image d’étalon (1 graduation correspond à 10 µm).
Objectif Zeiss Plan Neofluar 63/1.25

Manipulation d’images

Pour automatiser la reconnaissance des graduations, on souhaite implémenter l’algorithme suivant (plutôt une recette de cuisine) :

• Charger l’image en couleur (24 bits).
• La transformer en niveaux de gris.
• Augmenter la luminosité pour éclaircir le fond.
• Passer en noir et blanc.
• Effacer les poussières pour uniformiser le fond.
• Reboucher les trous dans les traits de graduations.
• Mesurer les traits de graduation et les espaces qu’ils délimitent.
• En déduire la taille d’une graduation (un espace + un trait).

Pour y parvenir, nous allons utiliser LablGTK et CamlImages, deux bibliothèques qui dialoguent plutôt bien. Nous allons nous fixer comme objectif d’écrire un type picture polymorphe. Nous nous en servirons pour distinguer les images en couleur (24 bits), en niveaux de gris et en noir et blanc. Les fonctions telles que get_width ou get_pixbuf s’appliqueront à tout type d’image.

Choix d’une interface

Pour faire court, nous voudrions quelque chose comme ceci :

type 'a picture

type fullcolor
type grayscale
type monochrom

val from_file : string -> fullcolor picture
(** Charge une image en couleurs. *)

(** Fonctions usuelles, valables pour tout type d'image. *)
val copy : 'a picture -> 'a picture
val get_width : 'a picture -> int
val get_height : 'a picture -> int
val get_pixbuf : 'a picture -> GdkPixbuf.pixbuf

val grayscale : 
  ?filter:(Color.rgb -> int) -> 
  fullcolor picture -> grayscale picture
(** Conversion en niveaux de gris d'une image couleur (24 bits). *)

val black_and_white :
  ?threshold:int ->
  grayscale picture -> monochrom picture
(** Conversion en noir et blanc d'une image en niveaux de gris. *)

val noise_reduction :
  ?threshold:int ->
  monochrom picture -> monochrom picture
(** Effacement des poussières sur une image en noir et blanc. *)

val fill_gaps :
  ?threshold:int ->
  monochrom picture -> monochrom picture
(** Rebouchage des trous sur une image en noir et blanc. *)

Pour que cet algorithme ne reste pas nébuleux, voici un PDF d’illustration.

Du côté de l’implémentation

Après l’interface, voyons l’implémentation. A priori, cela peut sembler difficile. Pourtant, grâce aux types fantômes, nous n’avons presque rien à faire ! Définissons d’abord le type picture :

type 'a picture = {pict: OImages.rgb24_class}

Ne vous étonnez pas de trouver ici un record alors qu’il paraît inutile. Le vrai type picture, que j’utilise dans mon application, contient d’autres champs (mais aucun n’est de type 'a, c’est très important). Il a été simplifié ici par souci de pédagogie.

Définissons maintenant trois types fantômes :

type fullcolor
type grayscale
type monochrom

Un type fantôme est un type utilisé comme paramètre d’un autre type (à la manière du type int dans int list), mais qui ne sert pas dans la définition de ce type (comme 'a dans 'a picture ci-dessus). Le type fantôme vous permet d’ajouter une information (une contrainte) qui sera propagée correctement par l’algorithme d’inférence de types, sans impact sur l’implémentation. Dans mon cas, il s’agit surtout de s’assurer que l’on passe bien une image en niveaux de gris à la fonction black_and_white, par exemple.

Nous pouvons maintenant écrire la fonction de création :

let from_file str = {pict = OImages.rgb24 (OImages.load path [])}

puis les fonctions utilitaires :

let get_width t = t.pict#width
let get_height t = t.pict#height
let get_pixbuf t = Imagegdk.to_pixbuf t.pict#coerce
let copy t = {t with pict = Oo.copy t.pict}

Nous pouvons maintenant en venir aux fonctions qui agissent directement sur l’image et, comme vous allez le constater, on ne se doute de rien en lisant cette partie du code :

let grayscale ?(filter = Color.brightness) pic =
  let res = copy pic in
  let img = res.pict in
  for x = 0 to img#width - 1 do
    for y = 0 to img#height - 1 do
      let res = filter (img#unsafe_get x y) in
      img#unsafe_set x y {Color.r = res; g = res; b = res}
    done
  done;
  res

let black = {Color.r = 0; g = 0; b = 0}
let white = {Color.r = 255; g = 255; b = 255}

let black_and_white ?(threshold = 0x90) pic =
  let res = copy pic in
  let img = res.pict in
  for x = 0 to img#width - 1 do
    for y = 0 to img#height - 1 do
      let rgb = img#unsafe_get x y in
      img#unsafe_set x y (if rgb.Color.r > threshold then white else black)
    done
  done;
  res

et ainsi de suite (le détail d’implémentation des fonctions   et fill_gaps sort du cadre de ce billet; je peux développer sur demande, mais il ne me semble pas pertinent de le faire ici). Avec un appel à ocamlc -i, toutes ces fonctions accepteraient des images de type 'a picture. La contrainte que nous avons posée dans l’interface est à la fois valide et transparente du côté de l’implémentation.

Il est intéressant de noter que les types fantômes apportent une information supplémentaire sans impact sur l’implémentation. Cela renforce la sûreté du code sans nuire aux performances (imaginez la lourdeur qui consisterait à s’assurer d’abord que tous les pixels sont bien des teintes de gris !).

En guise de conclusion…

Je parlais d’un aller simple vers le monde des fantômes. Vous savez maintenant pourquoi : quand on y a goûté, on ne peut plus s’en passer. Les types fantômes, c’est bien, mangez-en !

À bientôt,
Cacophrène