Université Joseph Fourier M1-MAI - Image Année TP 1 - Image bitmap

Transcription

1 Université Joseph Fourier UFR-IM 2 AG M1-MAI - Image Année TP 1 - Image bitmap A faire individuellement ou en binôme. Compte ru à envoyer avec le 25 janvier 2013 sous forme d un document PDF par à l adresse szafran@imag.fr en indiquant dans le sujet le numéro de la séance ainsi que votre ou vos noms. Récupérer les fichiers nécessaires à ce TP à l URL suivante : sous forme d une archive tp1.zip contenant les fichiers : afficher_image.sci ciel.bmp ecrire_imageppm.sci hsvtorgb.sci init_tp1.sce imread.sci lire_imagebmp.sci masque-papillon.bmp masque.bmp papillon.bmp rgbtohsv.sci tp1.sce Les exercices indiqués par EXERCICE-SM font l objet d un rapport à envoyer avant le 25 janvier Le fichier tp1.sce contient les codes SCILAB des différents exemples et fonctions utiles pour les exercices. Dans cette séance, des images doivent être incluses dans le rapport : il suffit de faire des copies d écran. Par exemple avec démarrer GIMP, et dans le menu Fichier, choisir Créer Capture d écran, choisir ensuite Fenêtre seul sans les bordures, valider et cliquer sur une fenêtre pour en faire une copie d écran. Enregistrer les fichiers ou les copier directement depuis GIMP pour les inclure dans le document OpenOffice du rapport. 1.1 Image avec SCILAB Cette section montre les formats d image pris en charge par SCILAB pour l affichage à l écran, et la lecture/écriture sous forme de fichers Mode indexé En mode indexé, une image de dimension L H est définie par une matrice de valeurs de H lignes et L colonnes. Exemple 1 : M = [1 2 3; ]; // drapeau tricolore à laquelle est associée une table de N couleurs, définie par une matrice de N lignes et 3 colonnes, TC = [ ; // bleu ; // blanc ]; // rouge la ligne TC(k,:) définissant les composantes RGB de la k-ème couleur. L affichage d une image en mode indexé à l aide de la fonction afficher image : // afficher l image indexee M avec la table TC et un zoom de 100 afficher_image(m,tc,100); M1-MAI - Image / TP1

2 Remarques : Les valeurs de la matrice peuvent être quelconques : si elles ne sont pas entières, l arrondi le plus proche (round) est utilisé, les valeurs inférieures à 1 sont associées à la couleur 1, et les valeurs supérieures à N sont associées à la couleur N. Exemple 2 : pour une même matrice M, on peut changer de table de couleurs. TC = [ ;... // vert sombre ;... // jaune ]; // rouge afficher_image(m,tc,100); On peut ainsi créer une image dite monochrome avec une table à 2 couleurs : TC=[0 0 0;1 1 1]; M = [ ; ; ; ; ; ; ; ]; afficher_image(m,tc,50); Niveaux de gris... et autres tables de couleurs Le mode indexé permet la manipulation d images en niveaux de gris. Exemple 3 : //// creer une image indexee avec 256 niveaux de gris // bande horizontale du noir (1) au blanc (256) de hauteur 100 M = ones(100,1) * (1:256); // la table de couleurs : 256 couleurs du noir au blanc TC = zeros(256,3); for i=1:256; TC(i,:) = (i-1)/255; ; afficher_image(m,tc,2); Image de fonction z = f(x,y) Une image indexée peut être utilisée pour représenter une fonction z = f(x,y) (exemple des cartes géographiques avec couleur dépant de l altitude). Exemple : //// 1 - définir une fonction z = f(x,y) // fonction test pour creer une image function z=ondes(x,y) r = sqrt(x.^2+y.^2); r1 = sqrt((x-1).^2+(y-1).^2); r2 = sqrt((x-1.5).^2+(y+0.5).^2); z = exp(-r.^2).*cos(r*20)... + exp(-r1.^2).*cos(r1*40)* exp(-r2.^2).*cos(r2*80)*0.25; function M1-MAI - Image / TP1

3 //// 2 - creer une image en mode indexé de taille 300 x 250 correspondant //// à la fonction évaluée sur le rectangle $[-1,2] \times [-1,1.5]$ L = 300; H = 250; // dimensions de l image // la grille [x,y] = meshgrid(linspace(-1,2,l),linspace(-1,1.5,h)); zondes=ondes(x,y); zmin = min(zondes); // valeur min zmax = max(zondes); // valeur max // conversion affine [zmin,zmax] -> [1,256] zondes = (zondes-zmin)/(zmax-zmin)*255+1; zondes = round(zondes); // passage en entier //// 3 - afficher l image avec une table de 256 couleurs // la table de couleurs : 256 couleurs du cyan au rouge TC = zeros(256,3); for i=1:256; TC(i,:) = [(i-1)/255, (256-i)/255, (256-i)/255]; ; // afficher l image afficher_image(zondes,tc); EXERCICE-SM 1 Tester d autres fonctions. Dans le rapport, mettre deux ou trois exemples avec les fonctions utilisées, les bornes utilisées en x et y, et l image obtenue. Créer des images de dimensions inférieures ou égales à Image RGB En mode RGB, une image de dimension L H est définie par une hyper-matrice M de dimensions (H,L,3) de valeurs réelles comprises entre 0 et 1, le pixel en ligne i et colonne j est définie par ses trois composantes RGB : M(i,j,1) (rouge), M(i,j,2) (vert), M(i,j,3) (bleu). Exemple 1 : le drapeau tricolore M=zeros(2,3,3); ////// creer l image par composante M(:,:,1) = [1 1 0 ;1 1 0 ]; // composante R M(:,:,2) = [0 1 0 ;0 1 0 ]; // composante G M(:,:,3) = [ ; ]; // composante B ////// ou bien par pixel M(1,1,:) = [1 0 0 ]; // pixel(1,1) M(1,2,:) = [1 1 1 ]; // pixel(1,2) M(1,3,:) = [ ]; // pixel(1,3) M(1,1,:) = [1 0 0 ]; // pixel(1,1) M(2,2,:) = [1 1 1 ]; // pixel(2,2) M(2,3,:) = [ ]; // pixel(2,3) afficher_image(m,100); Dans le cas du mode RGB, les valeurs peuvent être quelconques, la fonction afficher image se charge de les ramener entre 0 et 1. Exemple 2 : image aléatoire R=rand(20,20,3)*10-5; // valeurs aleatoires entre -5 et 5 afficher_image(r,10); M1-MAI - Image / TP1

4 Exemple 3 : Cet autre exemple montre comment créer une image représentant l ensemble des couleurs RGB correspondant à la composante rouge égale à 1. L=100; H = 100; // dimensions de l image M = zeros(h,l,3); for i=1:h for j=1:l // pixel i,j M(i,j,1) = 1.0; // la composante R est constante et egale a 1 M(i,j,2) = (i-1)/(h-1); // la composante G varie lineairement suivant i M(i,j,3) = (j-1)/(l-1); // la composante B varie lineairement suivant j afficher_image(m,2); Exemple 4 : La lecture d une image se fait à l aide de la fonction imread. L image lue donne une matrice de valeurs entières de type uint8 (valeurs entre 0 et 255). Il est nécessaire de la convertir en valeurs réelles entre 0 et 1 avant d effectuer des opérations mathématiques sur celle-ci. Exemple : // lecture du fichier papillon.bmp M = imread("papillon.bmp"); // conversion uint8 -> reel entre 0 et 1 M = double(m)/255; // afficher l image afficher_image(m); EXERCICE-SM 2 a) En s inspirant de l exemple 3 précédent, créer les images représentant l ensemble des couleurs avec une des trois composantes RGB fixée : l image correspondant aux couleurs RGB avec la composante Red égale à 0, l image correspondant aux couleurs RGB avec la composante Green égale à 0, l image correspondant aux couleurs RGB avec la composante Green égale à 1, l image correspondant aux couleurs RGB avec la composante Blue égale à 0, l image correspondant aux couleurs RGB avec la composante Blue égale à 1. Dans le rapport, mettre les six images obtenues en fixant chaque composante à 0 puis à 1. b) Créer une fonction afficher grisrgb qui pour une image MCouleur = (R,G,B), calcule et affiche l image correspondante MGris = (R, G, B)en niveaux de gris en utilisant la formule R = G = B = Gris = 0,3R+0,58G+0,12B Dans le rapport, mettre le code de la fonction afficher grisrgb et l image en niveaux de gris obtenue à partir du fichier papillon.bmp. M1-MAI - Image / TP1

5 1.2 Opérations sur une image Une image bitmap étant un tableau M de valeurs, on peut alors effectuer des opérations sur ce tableau (M = f(m)) afin d obtenir des informations ou pour transformer l image Opérations pixel par pixel Parmi les opérations de modification, on peut considérer les modifications pixel par pixel : M (i,j) = f(m(i,j)) à l aide d une même fonction. En SCILAB, il suffit de définir une fonction avec les opérations élément par élément puis de faire l opération globale sur l image. Exemple 1 : la fonction négatif : f(t) = 1 t // definition de la fonction "negatif" function y=fnegatif(t) y = 1-t; function // lecture d une image M = imread("papillon.bmp"); M = double(m)/255; afficher_image(m,1); // l operation de modification MT = fnegatif(m); afficher_image(mt,1); Exemple 2 : on peut faire en sorte de ne modifier que une ou deux des trois composantes RGB // "negatif" sur les composantes Vert et Bleu MT(:,:,1) = M(:,:,1); MT(:,:,2) = fnegatif(m(:,:,2)); MT(:,:,3) = fnegatif(m(:,:,3)); afficher_image(mt,1); Conversion RGB - HSV Si les opérations de modifications sont possibles en mode RGB, il est cepant plus commode d utiliser le mode HSV, afin de modifier séparément les trois composantes H, S et V. Comme pour le mode RGB, une image en mode HSV est définie par une hyper-matrice de dimensions H L 3 de valeurs réelles comprises entre 0 et 1, le pixel en ligne i et colonne j est définie par ses trois composantes HSV : M(i,j,1) (Hue - Teinte), M(i,j,2) (Saturation), M(i,j,3) (Value - Intensité lumineuse) Les fonctions rgbtohsv et hsvtorgb permettent la conversion du mode RGB au mode HSV, et inversement. Exemple 1 M = imread("papillon.bmp"); // chargement d une image RGB M = double(m)/255; // passage en valeurs reelles entre 0 et 1 afficher_image(m); // affichage // conversion vers HSV puis RGB et affichage // : pas de modification entre M2 et M MH = rgbtohsv(m); M2 = hsvtorgb(mh); afficher_image(m2); M1-MAI - Image / TP1

6 Pour avoir une idée des composantes HSV, on peut créer trois images à partir de MH : H = size(m,1); L = size(m,2); // affichage de la teinte (fixer S et V = 1) data(:,:,1)=mh(:,:,1); data(:,:,2)=ones(h,l); data(:,:,3)=ones(h,l); afficher_image(hsvtorgb(data)); // affichage de la saturation (fixer H = rouge et V = 1) // une forte saturation apparait en rouge vif et // une faible saturation apparait en blanc data(:,:,1)=zeros(h,l); data(:,:,2)=mh(:,:,2); data(:,:,3)=ones(h,l); afficher_image(hsvtorgb(data)); // affichage de la valeur (fixer S = 0 et H quelconque) // l intensit e (luminosit e) est donn ee par le niveau de gris data(:,:,1)=zeros(h,l); data(:,:,2)=zeros(h,l); data(:,:,3)=mh(:,:,3); afficher_image(hsvtorgb(data)); Exemple 2 : ensemble des couleurs HSV avec la composante V égale à 1 Comme pour le mode RGB, on peut créer une image représentant l ensemble des couleurs HSV en fixant une composante. N=100; // dimension de l image : L=H=N M = zeros(n,n,3); for i=1:n for j=1:n // pixel i,j : M(i,j,1) = (i-1)/(n-1); // la composante H varie lineairement suivant i M(i,j,2) = (j-1)/(n-1); // la composante S varie lineairement suivant j M(i,j,3) = 1.0; // la composante V est constante = 1 afficher_image(hsvtorgb(m),2); EXERCICE-SM 3 En s inspirant de l exemple précédent, créer les images représentant l ensemble des couleurs en fixant une composante : l image correspondant aux couleurs HSV avec V=1/2, l image correspondant aux couleurs HSV avec V=0, l image correspondant aux couleurs HSV avec S=0, l image correspondant aux couleurs HSV avec S=1/2, l image correspondant aux couleurs HSV avec S=1, l image correspondant aux couleurs HSV avec H=0, l image correspondant aux couleurs HSV avec H=1/3, l image correspondant aux couleurs HSV avec H=1/2. Dans le rapport, mettre les images obtenues. M1-MAI - Image / TP1

7 1.2.3 Modification globale d une image par le mode HSV Pour effectuer des modifications globales sur une image en utilisant le mode HSV, le principe général est le suivant : // image initiale RGB definie par une hyper-matrice RGB // de valeurs réelles entre 0 et 1 RGB =...; // passer en mode HSV HSV = rgbtohsv(rgb); H = HSV(:,:,1); S = HSV(:,:,2); V = HSV(:,:,3); // effectuer des transformations sur H et/ou S et/ou V Hm = f1(h); // ou f1(h,s,v) Sm = f2(s); // ou f2(h,s,v) Vm = f3(v); // ou f3(h,s,v) // repasser en mode RGB HSVm(:,:,1) = Hm; HSVm(:,:,2) = Sm; HSVm(:,:,3) = Vm; HSVm = min(max(hsvm,0),1); // remettre les valeurs entre 0 et 1 RGBm = hsvtorgb(hsvm); afficher_image(rgb); // image initiale afficher_image(rgbm); // image modifiee Exemple : RGB = imread("papillon.bmp"); RGB = double(rgb)/255; HSV = rgbtohsv(rgb); H = HSV(:,:,1); S = HSV(:,:,2); V = HSV(:,:,3); // la fonction de modification f(x)=(x+1)/2 deff("y = f(x)","y=(x+1)/2"); // graphique de la fonction f t = 0:0.01:1; scf(); plot(t,f(t),"r-"); // modifier l image en augmentant l intensite Vm = f(v); HSVm(:,:,1)=H; HSVm(:,:,2)=S; HSVm(:,:,3)=Vm; RGBm = hsvtorgb(hsvm); afficher_image(rgb); afficher_image(rgbm); // modifier l image en augmentant la saturation Sm = f(s); HSVm(:,:,1)=H; HSVm(:,:,2)=Sm; HSVm(:,:,3)=V; RGBm = hsvtorgb(hsvm); afficher_image(rgbm); Tester les fonctions f suivantes pour modifier V : f(x)=ones(x), f(x)=x/2, f(x)=(2-x).*x, f(x)=x.*x.*(3-2*x) puis les fonctions f suivantes pour modifier S : f(x)=zeros(x), f(x)=x/2, f(x)=sqrt(x) (les fonctions doivent être définies sur [0,1] et à valeurs dans [0,1]). M1-MAI - Image / TP1

8 1.2.4 Transparence La transparence permet de combiner deux images I1 et I2 à l aide d un masque de transparence α : l image résultante est alors I1 α+i2 (1 α) Exemple 1 : α constant // lecture des images et du masque I1 = imread("papillon.bmp"); // l image I1 I2 = imread("ciel.bmp"); // l image de fond I2 // affichages distincts des deux images I1 = double(i1)/255; I2 = double(i2)/255; afficher_image(i1); afficher_image(i2); // combinaison alpha = 0.5; combinaison = I1.*alpha + I2.*(1-alpha); afficher_image(combinaison); Refaire la même manip. avec d autres valeurs pour α. Exemple 2 : α variable dans cet exemple, α provient d une image NB jouant le rôle de masque. // lecture des images et du masque I1 = imread("papillon.bmp"); // l image I1 I2 = imread("ciel.bmp"); // l image de fond I2 masque = imread("masque.bmp"); // le masque : image en niveaux de gris // affichages distincts des deux images et du masque I1 = double(i1)/255; I2 = double(i2)/255; masque = double(masque)/255; afficher_image(i1); afficher_image(i2); afficher_image(masque); // creation du masque comme image RGB masquergb = zeros(i1); masquergb(:,:,1)=masque; masquergb(:,:,2)=masque; masquergb(:,:,3)=masque; // combinaison composante par composante combinaison(:,:,1) = I1(:,:,1).*masque + I2(:,:,1).*(1-masque); combinaison(:,:,2) = I1(:,:,2).*masque + I2(:,:,2).*(1-masque); combinaison(:,:,3) = I1(:,:,3).*masque + I2(:,:,3).*(1-masque); afficher_image(combinaison); Refaire la même manip. en utilisant l image du fichier masque-papillon.bmp comme masque. M1-MAI - Image / TP1

9 1.3 Primitives graphiques Tracé de segment Le script tp1.sce contient la fonction dessiner segment qui permet de tracer un segment du point (x1,y1) au point (x2,y2) avec la seule configuration x1 x2,y1 y2,dy = y2 y1 dx = x2 x1 en utilisant l algorithme de Bresenham, et la fonction de test test dessiner segment (cette fonction affiche l image initiale sans segment, et l image final après tracé de segment). EXERCICE-SM 4 Compléter la fonction dessiner segment afin de prre en compte tous les configurations possibles. Indication : à partir de la configuration existante, modifier l algo pour prre en compte la configuration x1 x2,y1 y2,dy = y2 y1 dx = x2 x1 puis les configurations correspondantes à et enfin les configurations correspondantes à y1 y2,dy = y2 y1 dx = x2 x1 dy = y2 y1 dx = x2 x1 Compléter la fonction test dessiner segment pour tester les différents cas de figures. Dans le rapport, mettre le code SCILAB de la fonction dessiner segment complétée. EXERCICE-SM 5 Ajouter une fonction dont l en-tête est function IMAGE2 = dessiner_polygone(image,x,y,c) qui trace le contour d un polygone dont les coordonnées des sommets sont données par les deux vecteurs d entiers x et y, avec la couleur c. Cette fonction doit utiliser la fonction dessiner segment Remplissage de triangle EXERCICE-SM 6 Ecrire une fonction dont l en-tête est function IMAGE2 = remplir_triangle(image,x1,y1,x2,y2,x3,y3,c) qui remplit le triangle de sommets S1 = (x1,y1), S2 = (x2,y2), S3 = (x3,y3) avec la couleur c. On pourra dans un premier temps supposer que le triangle n est pas dégénéré et que les sommets sont dans le bon ordre c est à dire que les conditions suivantes sont remplies : x2 x1 x3 x1 y2 y1 y3 y1 = (x2 x1)(y3 y1) (y2 y1)(x3 x1) > 0 (y1 < y2) OU (y1 = y2 ET x1 < x2) y1 < y3 Dans le rapport, mettre le code SCILAB de la fonction remplir triangle. M1-MAI - Image / TP1

10 1.4 Antialiasing La fonction test anti aliasing ci-dessous montre le principe de l antialiasing par sur-échantillonnage. L=...; H=...; // dimensions de l image //// a) l image initiale IMAGE1 IMAGE1 = zeros(h,l,3); // dessin à l échelle 1... afficher_image(image1,1); //// b) l image IMAGE2 correspondant à IMAGE1 sur-échantillonnée 4 fois IMAGE2 = zeros(4*h,4*l,3); // dessin à l échelle 4... afficher_image(image2,1); //// c) passer par moyennage de IMAGE2 à l image IMAGE3 4 fois moins grande IMAGE3 = zeros(h,l,3); for i=1:h for j=1:l // chaque pixel (i,j) d IMAGE3 est la moyenne (composante par composante) // de 16 pixels (k,l) d IMAGE2 IMAGE3(i,j,1) = mean(image2(4*i-3:4*i,4*j-3:4*j,1)); IMAGE3(i,j,2) = mean(image2(4*i-3:4*i,4*j-3:4*j,2)); IMAGE3(i,j,3) = mean(image2(4*i-3:4*i,4*j-3:4*j,3)); afficher_image(image3,1); EXERCICE-SM 7 Modifier la fonction test anti aliasing afin de représenter le dessin suivant : Axe Oy orienté vers le bas (Repère de l image) Axe Oy orienté vers le haut Le dessin à l échelle 1 est construit ainsi : 1. dans un carré blanc de dimension 100 x 100, 2. remplir en rouge le triangle de sommets [10,10],[90,50],[70,90], 3. remplir en vert le triangle de sommets [50,10],[90,90],[10,60], 4. remplir en magenta le triangle de sommets [20, 30],[40, 90],[10, 90], 5. remplir en bleu le triangle de sommets [70,10],[90,10],[20,70], (pour chaque triangle, les sommets sont donnés dans le bon ordre conformément à la partie 1.3.2) Dans le rapport, mettre le code SCILAB de la fonction test anti aliasing modifiée et les images IMAGE1 et IMAGE3 obtenues. M1-MAI - Image / TP1