Rapport de Soutenance - Freeoscarocr.free.fr/docs/rapport-OSCAR-01.pdf– De plus pour la première soutenance nous avons déja prévu de faire le site. Pour ce projet nous avons décidé

Rapport de Soutenanceprojet : OsCaR

SAHIR Sofiane RAFIDISON Tanjona SUTTER MichaëlMAAREK Nicolas

Mars 2007

1

OsCaR Team OsCaR OCR Rapport de Soutenance 1

Table des matières1 Introduction 3

2 Interface Graphique : GTK 42.1 Introduction à GTK . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.1.1 D’où vient GTK? . . . . . . . . . . . . . . . . . . . . . . 42.1.2 Notions de bases . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 GTK : C ou Caml ? Il faut choisir. . . . . . . . . . . . . . . . . . . 52.3 Exemple commenté . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.3.1 Premiers pas... . . . . . . . . . . . . . . . . . . . . . . . . 62.3.2 Notions de Widget . . . . . . . . . . . . . . . . . . . . . . 62.3.3 L’application minimale . . . . . . . . . . . . . . . . . . . . 6

3 Communication entre C et Objective CAML 93.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.2 Comment ça marche ? . . . . . . . . . . . . . . . . . . . . . . . . 9

3.2.1 Déclérations externes . . . . . . . . . . . . . . . . . . . . . 103.2.2 Déclarations des fonctions C . . . . . . . . . . . . . . . . 103.2.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.2.4 Entrées/Sorties des deux mondes . . . . . . . . . . . . . . 12

4 Gestion de fichier 144.1 Chargement de l’image . . . . . . . . . . . . . . . . . . . . . . . . 144.2 Sauvergarde de l’image . . . . . . . . . . . . . . . . . . . . . . . . 15

5 Pré-traitement 165.1 Transformation en noir et blanc . . . . . . . . . . . . . . . . . . . 165.2 Elimination du bruit . . . . . . . . . . . . . . . . . . . . . . . . . 16

5.2.1 Le filtre gaussien . . . . . . . . . . . . . . . . . . . . . . . 165.2.2 Le filtre median . . . . . . . . . . . . . . . . . . . . . . . . 175.2.3 Le filtre selectif . . . . . . . . . . . . . . . . . . . . . . . . 17

5.3 Rotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195.3.1 Detection de l’angle . . . . . . . . . . . . . . . . . . . . . 195.3.2 rotation de l’image . . . . . . . . . . . . . . . . . . . . . . 19

6 Site WEB 216.1 Languages utilisés . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.1.1 HTML et PHP . . . . . . . . . . . . . . . . . . . . . . . . 216.1.2 CSS, JAVA et FLASH . . . . . . . . . . . . . . . . . . . . 21

6.2 Contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226.3 Graphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

7 Conclusion 23

EPITA 2 InfoSpé A2


1 IntroductionCe projet a pour but la réalisation d’un O.C.R (programme de reconnais-

sance de caractère). Le projet est divisé en trois soutenances distinctes. Le projetest réalisé pour NetBSD. Voici les membres qui compose ce projet :

– RAFIDISON Tanjona (tanjojo) - Chef de projet - Gestion de fichier etrotation

– SAHIR Sofiane (fiensop) - Interface GTK– SUTTER Michaël (mikmik) - Webmaster - Réduction du bruit– MAAREK Nicolas (orochimachu1992)

Ce premier rapport de soutenance a pour but de présenter les différentes partiesdu prétraitement ainsi que l’interface du menu. Pour la première soutenance lesobjectifs sont :

– Ebauche de l’interface graphique.– Première version du pré-traitement de l’image.– Détection de l’angle de rotation d’une image pour la redresser, une pre-

mière application de gommage de bruits de fond.– Les différentes méthodes de rotation de l’image et de gommage de bruits

de fond.– De plus pour la première soutenance nous avons déja prévu de faire le site.

Pour ce projet nous avons décidé de nous mettre ensemble car nous avons déjàpas mal travaillé ensemble les différents projets depuis le debut de l’année. Legroupe de projet est constitué de Tanjona, chef de projet, Michaël, Sofiane, etenfin Nicolas. Nous sommes dans la même classe, ce qui facilitera les réunionsde travail. Nous avons par ailleurs décidé de nommer le projet OSCAR.

EPITA 3 InfoSpé A2


2 Interface Graphique : GTK

2.1 Introduction à GTK2.1.1 D’où vient GTK?

GTK+ (The GIMP Tool Kit) est une librairie permettant de créer des in-terfaces graphiques conçut à l’origine pour le projet GIMP (The GNU ImageManipulation Program) et aujourd’hui étendu à tout type d’application et no-tament celui du projet GNU : GNOME Desktop que l’on connaît tous sous lenom "d’interface graphique" des systèmes Unix en général.

L’avantage de cette librairie est d’une part sa gratuité (diffusée en opensource sous licence LGPL), et d’autre part son utilisation multi langage (C,C++, Perl, Python, Caml etc.) et multi plateforme (Windows, Linux, BSD,Beos, etc.). Pour plus d’informations, le site officiel est disponible à l’adresse :http ://www.gtk.org

2.1.2 Notions de bases

La création d’interface graphique sous GTK+ consiste à créer et manipu-ler des objets graphiques de GTK+. Ces objets sont appelés « Widgets ». UnWidget est une structure proposant des fonctions et propriétés permettant lamanipulation de ces objets.

Bien que nous sommes dans un langage procédural, le terme « objet » està prendre au sens littéral car GTK+ introduit la notion d’héritage. Les objetsgraphiques héritent des membres d’un widget de base : GtkWidget.

La gestion des événements est effectuée dans une boucle événementielle parl’interception de « signaux ». Un click sur un bouton par exemple, déclencheraun signal intercepté par la boucle événementielle qui exécutera la fonction cor-respondante. On appelle « fonction callback » une fonction associée à un signal.

EPITA 4 InfoSpé A2


2.2 GTK : C ou Caml ? Il faut choisir. . .Le projet OsCaR OCR est un projet dans lequel la manipulation d’images

occupe une place très importante. Il est, pour ainsi dire, hors de question derester sous le Terminal pour gérer le programme.

La partie programmation étant imposée pour une grande partie en Caml,nous nous sommes confrontés au choix inévitable du langage avec lequel nousdevions réaliser notre interface graphique. . .

D’une part, l’utilisation d’un langage familier comme le langage C est trèsattractive. Cependant la peur d’avoir un travail trop important à réaliser concer-nant l’interactivité entre les langages C et Caml pour le reste du développementd’OsCar nous a un peu plus influencé dans notre choix. . .

Après avoir peser le pour et le contre et étudier les avantages et les inconve-niants que les deux langages pouvaient offrir, notre choix fût celui conseillé engrande partie par le corps professoral de l’école, à savoir M. Burelle.

La raison qui nous a poussé à choisir le Caml pour GTK est principalementdûe au fait que de façon globale, le projet est codé à 75% en Caml. . .Nous avions ainsi préféré être prévoyant et non fénéant car coder en C nousaurait beaucoup plus facilité la tache : nous n’aurions pas été confrontés au pro-blème du réapprentissage et de l’utilisation d’O-Caml dans un premier temps.

La bibliothèque GTK pour O-Caml est LablGtk. Il en existe deux versions.Celle qui est utilisée pour OsCaR est bien entendu la dernière version.

Caml n’étant pas un langage qui soit utilisé de façon massive par les déve-loppeurs du monde entier, nous avons dû prendre sur nous même pour pouvoirtrouver des exemples concrets sur l’utilisation de GTK en Caml.

Ainsi, le seul tutorial sur lequel nous sommes tombés fût celui nous permet-tant de créer un semblant de Menu et un bouton nous permettant d’écrire surle Terminal. . .

Cependant, ce simple tutorial nous a permis de comprendre l’essentiel dansun premier temps. C’est pour celà que nous avons jugé important de le retrans-crire dans la partie suivante de ce rapport.

EPITA 5 InfoSpé A2


2.3 Exemple commenté2.3.1 Premiers pas...

La documentation se faisant très rare sur LablGTK, et ce notement en cequi concerne les tutoriaux, nous avons dû faire preuve de perséverence dans nosrecherches. . .

En effet, le plus difficile n’était pas de s’accoutumer avec la synthaxe d’unlangage pratiquement oublié pour coder une interface graphique mais au contraire,il fallait surtout comprendre comment GTK fonctionne de manière générale.

Pour ce fait, nos premières études ce sont plus axées sur le principe de GTK.Tous les langage de programmtion avec lesquels nous pouvions comprendre unpeu plus nous intéressaient. Le C étant le "porte-parole" officiel de GTK, nousavons donc dû nous plonger dans du GTK en C pour mieux approcher le GTKavec Objective CAML.

2.3.2 Notions de Widget

Avant de commencer l’étude de la création d’interface graphique grâce àGtk+, il faut savoir que les objets graphiques de Gtk+ sont appelés des widgets(Window Gadget). Un widget est en fait une structure définissant les propriétésd’un objet associé à une large panoplie de fonctions permettant de manipulerces objets.

Ici, le terme "objet" est à prendre au sens littéral, mais aussi au sens Pro-grammation Orientée Objet (POO). En effet, bien que GTK+ soit écrit en C, ilintroduit la notion d’héritage et les widgets de Gtk+ suivent une hiérarchie biendéfinie. Ainsi tous les objets graphiques héritent des propriétés et des fonctionsd’un widget de base qui s’appelle GtkWidget.

Ainsi le widget permettant d’afficher une fenêtre (GtkWindow) a bien sûrses propres fonctions, mais grâce à l’héritage il bénéficie aussi des fonctions desautres widgets dont il dérive.

2.3.3 L’application minimale

Voici la petite application donnée en exemple sur le site des tutoriaux deCaml :

http://www.ocaml-tutorial.org/introduction_to_gtk

Nous avions trouver intéressant de présenter cet exemple du fait de sa simplicitéà comprendre les bases de Gtk en Objective CAML.

Afin de ne pas polluer le bout de code, nous commenterons cette partie etles différentes fonctions utilisées.

open GMainopen GdkKeysyms

let main () =let window = GWindow.window ~width:320 ~height:240

~title:"Ma première application" () in

EPITA 6 InfoSpé A2


let vbox = GPack.vbox ~packing:window#add () inwindow#connect#destroy ~callback:Main.quit;

(* Menu bar *)let menubar = GMenu.menu_bar ~packing:vbox#pack () inlet factory = new GMenu.factory menubar inlet accel_group = factory#accel_group inlet file_menu = factory#add_submenu "File" in

(* File menu *)let factory = new GMenu.factory file_menu ~accel_group infactory#add_item "Quit" ~key:_Q ~callback: Main.quit;

(* Button. *)let button = GButton.button ~label:"Push me!"

~packing:vbox#add () inbutton#connect#clicked ~callback: (fun () -> prerr_endline "Ouch!");

(* Display the windows and enter Gtk+ main loop *)window#add_accel_group accel_group;window#show ();Main.main ()

;;

main ()-----------------------------------------------------------------------

Analysons ce programme lignes par lignes.

open GMainopen GdkKeysyms

GMain est le module qui fournit beaucoup de fonctions utiles comme lafonction Gtk main loop. GdkKeysyms fournit quant à lui les définitions d’entréesclavier comme par exemple la combinaison Ctrl + Q.

let main () =let window = GWindow.window ~width:320 ~height:240

~title:"Ma première application" () inlet vbox = GPack.vbox ~packing:window#add () inwindow#connect#destroy ~callback:Main.quit;

Tout d’abord, nous devons créer la première fenêtre qui va accueillir tousles composants de l’interface. Tous les programmes Gtk sont basés sur cettepremière fenêtre que l’on appelle "toplevel window". Nous nous devons de re-marquer trois choses :

1. GWindow.window est une fonction déjà toute implémentée qui nous créaitnotre fenêtre.

EPITA 7 InfoSpé A2


2. La bibliothèque Lablgtk utilise de façon intensive les label (ce sont desarguments optionels et nominatifs).

3. Les parenthèses qui semblent être inutiles () (unit) passées à la fonctionGWindow.window. En réalité, elle ne sont pas inutiles, c’est la seul fa-çon d’indiquer à Objective CAML qu’une fonction contient le bon nombred’arguments du fait que certains sont optionels.

Une vbox un Widget non visible dans l’application et permettant d’accueillird’autres Widegets. Le "v" permet de nous indiquer qu’il s’agit d’une "couche"verticale. L’argument packing nous indique que la vbox sera inserée dans lafenêtre initiale créée précédement.

window#connect#destroy ~callback:Main.quit;

est un exemple d’application d’un signal à une fonction. Dans notre cas, il s’agitdu signal destroy qui est émis par notre fenêtre window lorsqu’on essaye de lafermer en cliquant sur la petite croix en hait à droie. Ce signal appele la fonctionMain.quit ().

Après avoir crée notre fenêtre de base, intéressons-nous au Menus. Pour cela,nous créeons un objet GMenu.menu_bar que nous intégrons à notre vbox grâceau label

~packing:vbox#pack :

(* Menu bar *)let menubar = GMenu.menu_bar ~packing:vbox#pack () inlet factory = new GMenu.factory menubar inlet accel_group = factory#accel_group inlet file_menu = factory#add_submenu "Fichier" in

(* File menu *)let factory = new GMenu.factory file_menu ~accel_group infactory#add_item "Quitter" ~key:_Q ~callback: Main.quit;

Notre menu maintenant crée, il serait assez intéressant de faire une applica-tion avec un bouton. . .Comme pour la barre de menu, on intègre le bouton dansla vbox.

On remarque aussi le signal clicked relié par le label callback à une ofnctionanonyme. Ici, la fonction écrit tout simplement la chaine de caractère "Ouch !"sur la sortie standard.

(* Button. *)let button = GButton.button ~label:"Push me!"

~packing:vbox#add () inbutton#connect#clicked ~callback: (fun () -> prerr_endline "Ouch!");window#add_accel_group accel_group;

Et enfin, pour finir, les deux appels à des fonctions plus qu’importantes.Chaque Widget Gtk doit être affiché en appelant la methode show. De toute

EPITA 8 InfoSpé A2


façon, Lablgtk affiche automatiquement tous les Widgets à l’excéption des to-plevel windows. Par précaution et par besoin, on a besoin d’appeler explici-tement windowshow ().

Main.main () est ce qu’on pourrait appeler la boucle principale de Gtk,celle qui lance et qui intercèpte les évenement.

window#show ();Main.main ()

3 Communication entre C et Objective CAML

3.1 IntroductionComme dit précédement, une partie d’OsCaR est à coder en C, à savoir

la rotation de l’image, le bruit de l’image ou encore le chargement de l’imageetc. . .Cepandant, l’interface graphique étant faite en Caml et ces différentesfonctions faites en C vont devoir communiquer entre elles. La question qui restaità se poser était de savoir si c’était les parties en C qui devaient appeler lesfonctions en Caml ou l’inverse. Étant donné le nombre de fonctions en C et lenombre de fonctions en Caml, nous avons opté pour la version : Caml appelantles fonctions C.

Il reste maintenant à savoir comment procéder. . .

3.2 Comment ça marche ?La communication entre parties, d’un même programme, écrites en C et en

Objective CAML s’effectue en créant un exécutable (ou une nouvelle boucled’interaction) contenant ces deux parties. Celles-ci ont pu être compilées sépa-rément. Ce sera donc à l’édition de liens d’établir le lien entre les noms ObjectiveCAML et les noms C, puis de créer l’exécutable. Pour cela le programme Objec-tive CAML contiendra des déclarations externes assurant cette correspondance.

---------------------------------------------------------------/* PARTIE C */

---------------------------------------------------------------value f_c(value x,

value y,value z)

{return (Val_long(Long_val(x) + Long_val(y) + Long_val(z)));

}---------------------------------------------------------------

/* PARTIE OBJECTIVE CAML */---------------------------------------------------------------external f : int -> int -> int -> int = "f_c" (* appel *)

let r = f 2 3 4;; (* retour *)

EPITA 9 InfoSpé A2


On peut voir chaque partie comme contenant du code et des instructionscorrespondant aux définitions de fonctions et de calcul d’expressions pour Ob-jective CAML. L’appel de la fonction f sur trois entiers d’Objective CAMLentraîne le calcul de la fonction f_c de C. Le corps de la fonction convertit lestrois entiers Objective CAML en entiers C, calcule leur somme et retourne lerésultat converti en entier Objective CAML.

Nous présentons ci-dessous les premiers éléments d’interfaçage entre Objec-tive CAML et C : les déclarations externes, les contraintes sur les définitions defonctions C appelables à partir d’Objective CAML ainsi que les options d’éditionde liens. Puis nous donnons un exemple d’utilisation des entrées-sorties.

3.2.1 Déclérations externes

La déclaration externe de fonctions en Objective CAML a pour but d’effec-tuer la correspondance entre une déclaration de fonction C et un nom ObjectiveCAML, tout en indiquant le type de celle-ci. La syntaxe est la suivante :

external nom_caml : type = "nom_C"

Cette déclaration indique que l’appel en Objective CAML de la fonctionnom_caml déclenchera l’appel à la fonction C nom_C avec ses arguments.L’exemple précédent déclare ainsi la fonction f dont l’appel correspondra à l’exé-cution de la fonction f_c.

Il est possible de déclarer une fonction externe dans une interface (i.e. dansun fichier .mli), soit en la déclarant explicitement externe, soit comme une va-leur usuelle :

external nom_caml : type = "nom_C"

val nom_caml : type

Dans le second cas, l’appel à la fonction C passe au préalable par le méca-nisme général des fonctions Objective CAML. C’est un peu moins efficace maiscache la nature de l’implantation de la fonction.

3.2.2 Déclarations des fonctions C

Les fonctions C appelables à partir d’Objective CAML doivent posséder lenombre d’arguments décrit dans la déclaration externe. Ces arguments sont detype value qui est, en C, le type des valeurs d’Objective CAML. Comme celles-ci ont une représentation uniforme, un seul type C permet de coder toutes lesvaleurs Objective CAML.

Le tout premier exemple, donné plus haut, est conforme à ces contraintes.La fonction f_c, liée à la fonction Objective CAML de type int -> int -> int-> int est bien une fonction à trois paramètres de type value qui retourne unrésultat de type value.

EPITA 10 InfoSpé A2


Le mécanisme d’évaluation de l’interprète de code-octet d’Objective CAMLdiffère selon le nombre d’arguments. Si le nombre d’arguments est inférieur ouégal à cinq, les arguments sont empilés dans la pile d’exécution de la machine. Sile nombre d’arguments est supérieur à cinq, c’est un tableau contenant tous lesarguments qui est empilé ainsi que la taille de ce tableau. Comme les fonctionsC peuvent être appelées à partir de la machine abstraite, il est nécessaire dedistinguer ces deux cas. Par contre l’appel de fonction à partir du compilateurnatif empile bien tous ses arguments. Ceux-ci pourront donc être passés direc-tement à la fonction C.

Même si la norme Epita nous l’interdit, n’oublions pas que le langage C offrela possibilité de fournir à nos fonctions plus de 5 arguments. Il convient dans cecas d’écrire deux fonctions C : l’une pour le code-octet et l’autre pour le codenatif. La syntaxe des déclarations externes est donc étendue pour permettre uneseule déclaration de fonction Objective CAML pour deux fonctions C :

external nom_caml : type = "nom_C_byte_code" "nom_C_natif "

La fonction nom_C_byte_code prend deux arguments : un tableau de va-leurs de type value (i.e. un pointeur de type *value) et un entier indiquant lataille de ce tableau.

3.2.3 Exemple

Rien de mieux qu’un exemple explicite avec quelques commentaires pourmieux comprendre à quoi nous venons juste de faire allusions dans les para-graphes plus hauts.

Le programme C suivant définit deux fonctions différentes pour l’addition desix entiers : plus_native et plus_bytecode qui seront utilisées respectivement parle compilateur natif et le compilateur de code-octet. Il est nécessaire d’inclurele fichier mlvalues.h contenant les définitions des types C des valeurs ObjectiveCAML et les macros de conversion.

#include <stdio.h>#include <caml/mlvalues.h>

value plus_native(value x1, value x2,value x3, value x4,value x5, value x6)

{printf("<< PLUS NATIF >>\n");fflush(stdout);

return Val_long (Long_val(x1) + Long_val(x2) + Long_val(x3)+ Long_val(x4) + Long_val(x5) + Long_val(x6));

}

value plus_bytecode(value *tab_val,int nb_val)



{int i;long res;

printf("<< PLUS BYTECODE >> : ");fflush(stdout);for (i = 0, res = 0; i < nb_val; i++)

res += Long_val(tab_val[i]);

return (Val_long(res));}

Le programme O-CAML suivant utilise ces fonctions C.

external plus : int -> int -> int -> int -> int -> int -> int= "plus_bytecode" "plus_native";;

print_int (plus 1 2 3 4 5 6);;print_newline ();;

Cependant, pour ne pas à avoir à coder sans cesse deux fonctions en C, nousavons trouvé une remarque assez intéressante.

La façon la plus simple pour ne pas avoir à écrire deux fois une même fonctionest d’utiliser la primitive native dans le code de la primitive pour le code-octetsuivant le schéma :

value prim_nat(value x1, ..., value xn){ ... }

value prim_bc(value *tab,int n)

{return prim_nat(tab[0], tab[1], ..., tab[n-1]);

}

3.2.4 Entrées/Sorties des deux mondes

Les fonctions C et Objective CAML ne partagent pas leurs buffers de fichiers.Intéressons nous à l’exemple suivant pour mieux comprendre de quoi il s’agit.

#include <stdio.h>#include <caml/mlvalues.h>

value hello_world(value v){

printf("Hello World !!");fflush(stdout);return (v);

}

On note que les écritures sur la sortie standard doivent être forcées (fflush)si l’on souhaite qu’elles apparaissent dans le bon ordre.



# external caml_hello_world : unit -> unit = "hello_world";;external caml_hello_world : unit -> unit = "hello_world"

# print_string "<< ";caml_hello_world ();print_string " >>\n";flush stdout;;

Hello World !!<< >> - : unit = ()

Cet affichage n’est pas satisfaisant. Il faut réécrire le programme ObjectiveCAML de la manière suivante :

# print_string "<< ";flush stdout;caml_hello_world ();print_string " >>\n";flush stdout;;

<< Hello World !! >> - : unit = ()

Le vidage des tampons qui suit systématiquement un ordre d’écriture permetde conserver l’ordre d’affichage entre les deux mondes.



4 Gestion de fichier

4.1 Chargement de l’imageNous traitons que le format BMP. C’est un format un assez lourd mais il est

simple d’utilisation et on trouve de nombreux site qui explique le contenu desfichiers BMP.le format BMP est constitué de la maniére suivante :

– La signature (sur 2 octets), indiquant qu’il s’agit d’un fichier BMP à l’aidedes deux caractères

– La taille totale du fichier en octets (codée sur 4 octets)– Un champ réservé (sur 4 octets)– L’offset de l’image (sur 4 octets), en français décalage, c’est-à-dire l’adresse

relative du début des informations concernant l’image par rapport au dé-but du fichier

– La taille de l’entête de l’image en octets (codée sur 4 octets). Les valeurshexadécimales suivantes sont possibles suivant le type de format BMP.

– La largeur de l’image (sur 4 octets), c’est-à-dire le nombre de pixels hori-zontalement (en anglais width)

– La hauteur de l’image (sur 4 octets), c’est-à-dire le nombre de pixels ver-ticalement (en anglais height)

– Le nombre de plans (sur 2 octets). Cette valeur vaut toujours 1– La profondeur de codage de la couleur(sur 2 octets), c’est-à-dire le nombre

de bits utilisés pour coder la couleur. Cette valeur peut-être égale à 1, 4,8, 16, 24 ou 32

– La méthode de compression (sur 4 octets). Cette valeur vaut 0 lorsquel’image n’est pas compressée, ou bien 1, 2 ou 3 suivant le type de com-pression utilisé

– La taille totale de l’image en octets (sur 4 octets).– La résolution horizontale (sur 4 octets), c’est-à-dire le nombre de pixels

par mètre horizontalement– La résolution verticale (sur 4 octets), c’est-à-dire le nombre de pixels par

mètre verticalement– Le nombre de couleurs de la palette (sur 4 octets)– Le nombre de couleurs importantes de la palette (sur 4 octets). Ce champ

peut être égal à 0 lorsque chaque couleur a son importance.

Pour gérer ces informations on utilise une structure adéquate avec les champsmise à la bonne taille(en octets) afin que les octets lus correspondent au mieux.Tous les champs de la structure sont en non signés afin que les valeurs ne soitpas lus comme des valeurs négatifs.La première lecture de l’image consiste à récupérer les informations primordialespour construire la matrice de pixel tel que l’offset et les dimensions du tableaude pixel. Pour traiter l’image il faut dans un premier temps charger les pixelsde l’image dans une matrice. Un pixel ne comporte que 3 octets d’information,l’intensité rouge, bleu et vert. La lecture des pixels s’effectue par ligne à l’aidede fread. Pour le format BMP on doit compléter les lignes de pixels par des zéroafin que le nombre de pixel par ligne soit modulo 4 ainsi la boucle de lecture ducorps de l’image utilise un fseek du nombre de pixel sauter si la largeur n’estpas modulo 4.



for (i = height - 1; i >= 0; i--){

fread(tab[i], sizeof (s_pixel), width, file);if (dec)

fseek(file, dec, SEEK_CUR);}

Cette méthode nous permet d’économiser de nombreux appel de la fonctionfread ainsi rendre la lecture d’une image plus rapide. Tous les autres formatsd’image peuvent être utiliser car si le format BMP n’est pas détecté on utilise lafonction convert de la librairie Imagemagick à l’aide d’un execvp (utiliser dansun processus cloné auparavant). Cette fonction nous permet de convertir la pluspart des formats d’image vers le format BMP.

4.2 Sauvergarde de l’imageAfin de pouvoir présenter l’image suite aux différents traitements nous avons

besoin de sauver l’image. On recopie la même en-tête récupérer lors de la lectureensuite il reste plus qu’a copier le corps de l’image. Pour cela il suffit de procéderde même façon que pour la lecture sauf que si la largeur du tableau de pixeln’est pas modulo 4, on écrit le nombre de zéro nécessaire. L’écriture se fait parligne suivie du complément de zéro si besoin est.La boucle d’écriture :

for (i = header->height; i > 0; i--){

fwrite(tab[i - 1], sizeof (s_pixel), (header->width), file);if (dec)

fwrite(temp, sizeof (char), dec, file);}



5 Pré-traitementDans cette partie, L’image subit plusieurs transformation. La première trans-

formation est la saturation des couleurs, de manière à avoir uniquement du noiret du blanc. Le second traitement est l’élimination du bruit, grâce à un filtre. Cesdeux premiers traitements ont été réalisés par Michaël. Le dernier traitementconcerne la rotation de l’image, en cas de léger décalage lors de la numérisation.La rotation a été attribué à Tanjona.

5.1 Transformation en noir et blancAvant tous traitement, il faut transformer l’image en noir et blanc. Cela

signifie qu’il n’y aura que du blanc ou du noir sur l’image, ce qui nous permettrade récupérer plus facilement les caractères.Le principe est le suivant :On prend une valeur de seuil, et on sature le résultat en fonction de l’intensité,calculée grâce à la formule suivante :luminosité = 0.299 * rouge + 0.587 * vert + 0.114 * bleuSi la luminosité est supérieur, alors on met chacune des composantes du pixelà 255, sinon on met ces dernières à 0. On parcourt l’image et on applique cetteméthode sur chaque pixel de l’image. La difficulté a été de choisir une valeur deseuil, car sur les images en 75dpi, si le seuil est trop bas, on perd beaucoup tropde données. Les OCR ne sont donc pas optimisés pour les image de 75dpi, et sontplutot utilisé avec des images de 300dpi. J’ai donc choisit comme valeur de seuilla valeur 140, car elle offrait un bon compromis, et offrait une fonctionnementoptimal pour les images en 300dpi.

5.2 Elimination du bruitLa première chose dont je me suis occupé a été de me renseigner sur le sujet.

J’ai d’abord lu des documents parlant du bruit dans les images, des différentesméthode utilisés, ainsi que leurs différents usages et efficacités. Après quelquesdocumentation, j’avais trouvé trois méthodes différentes pour éliminer le bruit,les filtres gaussien, médian et séléctif. Ces différents filtres ont pour but d’éli-miner les pixels isolés détériorant l’image.Afin de trouver le filtre le mieux adapter à notre projet, j’ai implementer cha-cun de ces modèles, et les ai tester. Après différents tests, j’ai décidé d’utiliser lefiltre gaussien. En effet ce type de filtre me paraissait avoir de meilleurs rendussur les pages testées.

5.2.1 Le filtre gaussien

La première méthode, consiste à appliquer une matrice de convolution 3 *3, 5 * 5 (ou plus mais impaire) sur chaque pixel de l’image. Ayant choisis cetype de filtre, j’ai choisis une matrice 3 * 3, qui permet de rendre le filtre plusperformant. En effet plus la matrice est grande, plus les pertes d’informationssont importantes. Chaque composante de couleur du pixel est modifié en fonctiondu filtre utilisé et des pixels envirronants. Cette méthode se base sur le fait queles pixels d’une image sont en interraction les uns avec les autres. On appliquedonc la matrice sur le pixel, en sommant les produits des composantes colorées



des pixels voisins avec la valeur de la matrice correspondante. On divise ensuitele résultat par la somme des valeurs de la matrice.Voici la matrice de convolution généralement utilisé pour ce filtre :

1 2 12 4 21 2 1

La somme des valeurs de la matrice est ici égale à seize, donc on divisera parseize.Le principe de ce modèle est le suivant :On parcours l’image pixel par pixel, en appliquant le masque sur chaque pixelset sur ses voisins. On garde le résultat dans une variable pour chacune des com-posantes du pixel (rouge, vert, bleu). Une fois le masque parcouru, on divise lasomme des resultat obtenue sur chaque pixel voisins par la somme des valeursdu masque, c’est-à-dire seize pour la matrice utilisé. On remplace ensuite lescomposantes du pixel par celles obtenues lors du parcours.

5.2.2 Le filtre median

Cette méthode consiste à appliquer une matrice de convolution 3 * 3, surchaque pixel de l’image, comme le précédent.A la différence qu’on utilise lamatrice suivante :

1 1 11 1 11 1 1

On remplace ensuite la valeur du pixel par la valeur médiane des pixelsvoisins, après application du masque. Le principe de ce modèle est le suivant :On parcours l’image pixel par pixel, en appliquant le masque sur chaque pixelset sur ses voisins. On applique la formule suivante sur chacun des pixels voisins :luminosité = 0.299 * rouge + 0.587 * vert + 0.114 * bleuOn garde les résultats dans un tableau pour chaque pixel. Une fois le masqueparcouru, on classe les valeurs du tableau, et on prend la valeur médiane. Onremplace ensuite les composantes du pixel par celles du pixels correspondant.Le problème est que ce filtre rend l’image trop flou, est fait disparaitre le texte.

5.2.3 Le filtre selectif

Cette méthode consiste à appliquer une matrice de convolution 3 * 3, surchaque pixel de l’image, comme les précédent.A la différence que la matrice ap-pliquée est calculée pour chacun des pixels. On remplace ensuite les composantesdu pixel par la somme des composantes des pixels voisins, après application dumasque. Le principe de ce modèle est le suivant :On parcours l’image pixel par pixel, en appliquant le masque sur chaque pixelset sur ses voisins. On calcule la différence entre les composantes du pixel courantet de ces voisins. On somme les resultats, et on divise par la somme des valeursdu filtre calculé.Les coefficients sont calculés comme suit :



h(m,n) =

(1

d(i,j,i+m,j+n)∑1

d(i,j,i+m,j+n)

)

Voici la boucle qui garde les nouvelles composantes du pixel courant :

for ( i = 0; i < 3; i++)if ((coord[0] - 1 + i >= 0) && (coord[0] - 1 + i < height)&& (coord[0] - 1 + j >= 0) && (coord[0] - 1 + j < width))

{res[0] += (src[coord[0] - 1 + i][coord[1] - 1 + j].r) * red[j][i];res[1] += (src[coord[0] - 1 + i][coord[1] - 1 + j].g) * green[j][i];res[2] += (src[coord[0] - 1 + i][coord[1] - 1 + j].b) * blue[j][i];

}

En théorie, ce filtre est le meilleur, puisqu’il est censé conserver au mieux lescontours grâce au filtre calculé à chaque fois,mais son problème est qu’il n’estpas fait pour les images avec beaucoup de détérioration du au bruit.



5.3 Rotation5.3.1 Detection de l’angle

Cela represente la partie la plus dure de la rotation. Pour determiner l’anglede rotation, On utilise le procédé de la transformée de Hough. La transforméede Hough est une technique de reconnaissance de formes (inventée en 1962 parPaul Hough) utilisée dans le traitement d’images numériques. Ici, nous utili-serons sont applications la plus simple. Elle permet de reconnaitre les lignesd’une image, mais des modifications peuvent être apportées pour reconnaitren’importe quelle forme.Dans la transformée de Hough, dite aussi transforméestandard de Hough ou SHT, chaque ligne est un vecteur de coordonnées para-métriques :

– rho : la norme du vecteur– theta : l’angle

En transformant toutes lignes possibles qui relient un point à un autre,c’est à dire en calculant la valeur de rho pour chaque theta , on obtient unesinosoïde unique appelée espace de Hough. Si les courbes associées à deux pointsse coupent, l’endroit où elles se coupent dans l’espace de Hough correspond auxparamètres d’une droite qui relie ces deux points. Considérons un pixel P(x,y) denotre matrice de pixel. Ce point P appartient à toutes les droites dont l’équationest, en coordonnées polaires :

ρ = cos(θ)× (x) + sin(θ)× (y)

L’équation dépend du paramètre theta. Il y a donc une infinité de droitespossibles. Soit Q un autre point sélectionné. Grâce à lui, nous obtenons uneseconde relation qui permet de ne trouver qu’un seul couple (rho, theta) pourlesquels P et Q sont sur la droite. ainsi en selectionant tous les pixels noireselon une certaine tolerance apres effacement du bruit, on utilise une matriceavec rho en ordonnée et theta en absice. rho variant de 0 jusqu a la diagonalede la matrice et theta de 0 jusqu à 180. Pour tous les points selectionnés onincremente chaque case qui verifie la formule avec x,y du point et theta quivarie entre 0 et 180. Ainsi on recupére l’angle dans la case qui contient la valeurmaximum car c’est la case auquel correspond le plus d intersection de point.

5.3.2 rotation de l’image

Une fois l’angle obtenu, on applique une matrice de rotation 2D inverse caron cherche le point sur lequelle on se situait avant la rotation, la rotation s’effec-tue par rapport au centre de l’image (le pixel de coordonné width/2, height/2).Etant en 2D, la matrice de rotation est simple à appliquer :

rotinv[0][0] = cos(teta * M_PI / 180);rotinv[1][1] = cos(teta * M_PI / 180);rotinv[0][1] = sin(teta *M_PI / 180);rotinv[0][1] = -sin(teta *M_PI / 180);x = rotinv[0][0] * (i - width/2) + rotinv[0][1] * (j - (width/2));y = rotinv[1][0] * (i - width/2)+ rotinv[1][1] * (j - (width/2));



On obtient les anciennes coordonné, il ne reste que de copier le pixel.

new[j][i].r = tab[y1][x1].r;new[j][i].b = tab[y1][x1].b;new[j][i].g = tab[y1][x1].g;

avec x1 et y1 sont les valeur de x arrondi à l’inferieur. Tous les points sont copiésdans une nouvelle matrice qui est retourné dans un nouveau tableau de pixel



6 Site WEBPour le bon déroulement d’un projet, un site WEB est nécéssaire. Le projet

OSCAR devait donc en avoir un. Michaël s’en est occupé. Il nous fallait unsite WEB sobre qui donnerait une image sérieuse au projet. Pour augmenterla renommée du projet, le site existe en version française ainsi qu’en versionanglaise. L’adresse du site web est la suivante : http ://oscarocr.free.fr/

6.1 Languages utilisésPour réaliser le site WEB, trois principaux language ont été utilisés, ainsi

que d’autres moins important pour le graphisme.

6.1.1 HTML et PHP

Pour le contenu du site, des balises HTML et PHP ont été utilisées. Chaquepages du site a donc pour extension *.php et peut uniquement être éxécutée parle serveur. Pour visualiser le site pendant sa réalisation, il faut donc un logicielpermettant de simuler un serveur, comme le logiciel EasyPHP que j’ai utilisé.La plus grande partie du contenu et en HTML, mais certaines fonction PHPutiles ont été crée, comme le compteur de visiteur ou la présentation du siteWEB incluant le menu ou encore la bannière grâce à "include".

<?phpinclude("header.php");

?>

Le compteur de visite utilise la gestion de cookies. Le principe est le suivant :à chaque connexion, on crée un cookie nommé "counter". Si le cookie n’existepas, cela signifie que l’on vient juste d’arriver sur le site, on incrémente donc lavariable contenu dans le fichier "count.txt". Ensuite, on affiche la variable à lasuite du message de bienvenue.

<?php$file = "count.txt";$fd = fopen($file, "r");$res = fread($fd, filesize($file));fclose($fd);if (!isset($_COOKIE[’counter’])){$fd = fopen($file, "w");$res++;fwrite($fd, $res);fclose($fd);setcookie("counter", "ok");}?>

6.1.2 CSS, JAVA et FLASH

Pour le graphisme du site, le language CSS à été utilisé. Pour le position-nement des données, les couleurs, les polices et tout autre aspect graphique du



site WEB.Les languages JAVA et FLASH ont été utilisés à divers endroit, tel que la ban-nière ou la page de membres.

6.2 ContenuLe menu contient des liens vers les pages de présentation du projet, de télé-

chargements, de présentation des membres ou de liens extèrieures. Les pages deprésentation du projet contiennent une introduction, une chronologie, un his-torique, ansi que les problèmes rencontrés et les solutions. Les liens contenusdans la rubrique "liens" du menu renvoient vers les logiciels utilisés, les biblio-thèques nécéssaires, ansi que d’autres liens comme des liens vers des sites quinous ont été utiles pour le projet. Les pages de téléchargements contiennent lesdocuments relatifs au projet, comme les rapports de soutenances, le sujet, ainsique le projet donné à chaque soutenances.

6.3 GraphismeLes teintes des pages sont assez sobres, afin de donner un coté professionnel

au projet. Le blanc, le gris, le bleu et le noir sont les principales couleurs utilisés.Le menu est un tableau d’image, réalisées grâce a photoshop. Le menu est bleuet gris, avec un effet brossé ainsi qu’un dégradé, pour donner un aspect métaliséau site WEB.La taille du site est en 800 * 600, comme le demande la charte de developpe-ment HTML. Chaque pages possèdent un fond d’écran identique, réalisé avecphotoshop, constitué de caractères entremélés pour être en accord avec l’espritdu projet, la reconnaissance de caractères.La bannière du site WEB à été réalisé en FLASH, et représente le mot OSCARqui se transforme en caractères ASCII. Le logo du site est constitué du motOSCAR, avec les lettres placées de manière pyramidale.La page de présentation des membres contient une fenètre dynamique, réaliséeen JAVA, qui réagit en fonction de la souris. En déplaçant la souris, on se dé-place dans la fenètre, et en cliquant sur les photos des membres, on obtient unedéscription de chacun, inscrit sous les photos.



7 ConclusionPour conclure, nous sommes heureux du travail que nous avons accompli, et

les membres du projet s’entendent bien, ce qui motive chacun d’entre nous. Pourla deuxième soutenance nous avons comme programme et objectifs les pointssuivants :

– Présentation de la description du positionnement des lignes à partir d’unfichier image "parfait".

– Développement des bases du module chargé de la resonnaissance des sym-boles.

– Integration du module de reconnaissance des symboles dans l’application,et gestion des symboles non reconnus.

– Interface graphique complète.

Nous espérons remplir ces points avec succès, et sommes motivés pour continuerà travailler comme maintenant, et plus encore.


Documents

Rapport de Soutenance - Freeoscarocr.free.fr/docs/rapport-OSCAR-01.pdf– De plus pour la première soutenance nous avons déja prévu de faire le site. Pour ce projet nous avons décidé