ENSEEIHT/TP-vision
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

init

Browse source
This commit is contained in:
Laureηt 2023-06-25 16:42:57 +02:00
commit 4ea5f3f2f9
Signed by: Laurent
SSH key fingerprint: SHA256:kZEpW8cMJ54PDeCvOhzreNr4FSh6R13CMGH/POoO8DI
35 changed files with 1993 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

88
TP_mosaique.m Normal file
View file

@ -0,0 +1,88 @@
clear all;
close all;
% Lecture des images
Im1 = imread('sweet1.pgm');
Im2 = imread('sweet2.pgm');
Im1_coul = imread('sweet_couleur1.jpg');
Im2_coul = imread('sweet_couleur2.jpg');
Im3_coul = imread('sweet_couleur3.jpg');
% Im1_coul = imread('rescaled_local_1.jpg');
% Im2_coul = imread('rescaled_local_2.jpg');
% Im3_coul = imread('rescaled_local_3.jpg');
% Im4_coul = imread('rescaled_local_4.jpg');
% Im5_coul = imread('rescaled_local_5.jpg');
% Im6_coul = imread('rescaled_local_6.jpg');
% Im7_coul = imread('rescaled_local_7.jpg');
% Im8_coul = imread('rescaled_local_8.jpg');
% Im1_coul = imread('im1.jpg');
% Im2_coul = imread('im2.jpg');
% Im3_coul = imread('im3.jpg');
% Im4_coul = imread('im4.jpg');
% Affichage des deux premières images en niveaux de gris
% figure;
% affichage_image(Im1,'Image 1',1,2,1);
% affichage_image(Im2,'Image 2',1,2,2);
% Choix des parametres
TailleFenetre = 17;
NbPoints = 100;
k = 0.05;
seuil = 0.80;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Detection des points d'interet avec Harris %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% [XY_1,Res_1] = harris(Im1,TailleFenetre,NbPoints,k);
% [XY_2,Res_2] = harris(Im2,TailleFenetre,NbPoints,k);
% figure;
% affichage_POI(Im1,XY_1,'POI Image 1',1,2,1);
% affichage_POI(Im2,XY_2,'POI Image 2',1,2,2);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Appariement des points d'interet %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% [XY_C1,XY_C2] = apparier_POI(Im1,XY_1,Im2,XY_2,TailleFenetre,seuil);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Estimation (et verification) de l'homographie %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% H = homographie(XY_C1,XY_C2);
%%%%%%%%%%%%%%%%%%%%%%%%%
% Calcul de la mosaique %
%%%%%%%%%%%%%%%%%%%%%%%%%
% Imos = mosaique(Im1,Im2,H);
% figure;
% affichage_image(uint8(Imos),'Mosaique obtenue a partir des 2 images initiales',1,1,1);
% imwrite(uint8(Imos),'mosaique2.pgm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Version 2 pour la reconstruction %
% A DECOMMENTER QUAND MOSAIQUEBIS AURA ETE ECRITE %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Imosbis = mosaiquebis(Im1,Im2,H);
% figure;
% affichage_image(uint8(Imosbis),'Mosaique obtenue a partir des 2 images initiales (version 2)',1,1,1);
% imwrite(uint8(Imosbis),'mosaique2_bis.pgm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Version 3 pour la reconstruction avec les couleurs R, G et B %
% A DECOMMENTER QUAND MOSAIQUECOUL AURA ETE ECRITE %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Imoscoul = mosaiquecoul(Im1_coul,Im2_coul,H);
% figure;
% affichage_image(uint8(Imoscoul),'Mosaique obtenue a partir des 2 images couleur initiales (version 2)',1,1,1);
% imwrite(uint8(Imoscoul),'mosaique2_coul.pgm');
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Version 4 pour la reconstruction avec 3 images %
% en couleurs et/ou en niveaux de gris %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Imoscoul = mosaiqueN(TailleFenetre, NbPoints, k, seuil, Im1_coul, Im2_coul, Im3_coul);
Imoscoul = mosaiqueNbis(TailleFenetre, NbPoints, k, seuil, 2, Im1_coul, Im2_coul, Im3_coul);
figure;
affichage_image(Imoscoul,'Mosaique obtenue a partir des 3 images couleur initiales (version 2)',1,1,1);
% imwrite(uint8(Imoscoul),'mosaique2_coul.pgm');

17
affichage_POI.m Normal file
View file

@ -0,0 +1,17 @@
% Fonction permettant d'afficher les images avec les points d'interet
% detectes
% ENTREES
% Im : Image
% points : les points a afficher
% message : le titre de la figure
% l, c, numero : le nombre de lignes et colonnes de la figure et le numero
% dans la sous-figure
% SORTIE : la figure
function [] = affichage_POI(Im,points,message,l,c,numero)
% Affichage de l'image
subplot(l,c,numero);
colormap(gray);imshow(Im); hold on;
plot_points(points,length(points),'o');
title(message);
hold off;
end

28
affichage_appariement.m Normal file
View file

@ -0,0 +1,28 @@
% Fonction permettant d'afficher les images
% avec les points d'interet numerotes
% Les points portant le meme numero sont les correspondants
% ENTREES
% Im : Image
% mesurex1,mesurey1 : les points à afficher
% message : le titre de la figure
% l, c, numero : le nombre de lignes et colonnes de la figure et le numero
% dans la sous-figure
% SORTIE : la figure
function [] = affichage_appariement(Im,mesurex1,mesurey1,message,l,c,numero)
% Affichage de l'image
subplot(l,c,numero);
imshow(Im);
% Affichage des points
hold on;
plot(mesurex1,mesurey1,'r.','MarkerSize',15)
% Affichage des numeros
for i=1:size(mesurex1,1)
if (i<10)
text(mesurex1(i)-15,mesurey1(i),num2str(i),'Color','g','FontSize',12)
else
text(mesurex1(i)-30,mesurey1(i),num2str(i),'Color','g','FontSize',12)
end
end
hold off;
end

13
affichage_image.m Normal file
View file

@ -0,0 +1,13 @@
% Fonction permettant d'afficher les images
% ENTREES
% Im : Image
% message : le titre de la figure
% l, c, numero : le nombre de lignes et colonnes de la figure et le numero
% dans la sous-figure
% SORTIE : la figure
function [] = affichage_image(Im,message,l,c,numero)
subplot(l,c,numero);
colormap(gray);
imshow(Im);
title(message);
end

BIN
appa1.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 989 KiB

BIN
appa2.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 995 KiB

47
apparier_POI.m Normal file
View file

@ -0,0 +1,47 @@
function [XY_C1, XY_C2] = apparier_POI(Im1, XY_1, Im2, XY_2, TailleFenetre, seuil)
% apparierPOI apparie les points d'interet stockes dans XY_1 et XY_2 entre
% les images Im1 et Im2 avec une fenetre de correlation de taille
% TailleFenetre
% seuil correspond au seuil utilise pour eliminer les erreurs d'appariement
% XY_C1 et XY_C2 sont les coordonnees des points de l'image 1
% apparies avec les points XY_C2 de l'image 2
% Nombre de points a mettre en correspondance
NbPoints = size(XY_1, 1);
% Calcul de ZNCC
C = apparier_Points(Im1, XY_1, Im2, XY_2, TailleFenetre);
C = abs(C);
% Recherche par methode WTA (Winner Takes All)
% Indices des maxima sur les lignes
[maxI1, ind1_2] = max(C, [], 2);
ind1_2 = ind1_2(:);
% Indices des maxima sur les colonnes
[~, ind2_1] = max(C, [], 1);
ind2_1 = ind2_1(:);
% Verification de la contrainte de symetrie
% + seuillage du score de correlation
% Cette premiere ligne doit etre modifiee pour appliquer les contraintes souhaitees
ind2ind = ind2_1(ind1_2);
ind1 = find(maxI1 > seuil & vecnorm(XY_1(ind2ind, :) - XY_1, 2, 2) <= 0);
% ind1(8) = [];
% Cette deuxieme doit etre gardee telle quelle
ind2 = ind1_2(ind1);
% Affichage des appariements
mesurex1 = XY_1(ind1, 1);
mesurey1 = XY_1(ind1, 2);
mesurex2 = XY_2(ind2, 1);
mesurey2 = XY_2(ind2, 2);
figure;
affichage_appariement(Im1, mesurex1, mesurey1, 'Points d''interet Image 1', 1, 2, 1);
affichage_appariement(Im2, mesurex2, mesurey2, 'Points d''interet correspondants Image 2', 1, 2, 2);
XY_C1 = [mesurex1(:) mesurey1(:)];
XY_C2 = [mesurex2(:) mesurey2(:)];
end

83
apparier_Points.m Normal file
View file

@ -0,0 +1,83 @@
% Fonction calculant pour chaque appariement de points possible
% ZNCC (Zero-mean Normalized Cross Correlation) definie par :
% (P1-/P1).(P2-/P2) Cov(P1,P2)
% ZNCC(P1,P2) = --------------------- = -----------------------
% ||P1 - /P1||||P2-/P2|| sqrt(Var(P1)*Var(P2))
% * P1 = l'ensemble des niveaux de gris du voisinage du point p1=(p1x,p1y)
% sur l'image I1
% * P2 = l'ensemble des niveaux de gris du voisinage du point p2=(p2x,p2y)
% sur l'image I2
% * Cov(P1,P2) = E[(P1-E[P1])*(P2-E[P2])]
% = Sum_{i=-k}^k Sum_{j=-k}^k (I1(p1x+i,p1y+j)-E[P1])
% *(I2(p2x+i,p2y+j)-E[P2])/(2*k+1)^2
% * E[P1] = esperance de P1
% = Sum_{i=-k}^k Sum_{j=-k}^k I1(p1x+i,p1y+j)/(2*k+1)^2,
% * E[P2] = esperance de P2
% = Sum_{i=-k}^k Sum_{j=-k}^k I2(p2x+i,p2y+j)/(2*k+1)^2,
% * Var(P1) = variance de P1
% = Sum_{i=-k}^k Sum_{j=-k}^k (I1(p1x+i,p1y+j)-E[P1])^2/(2*k+1)^2
%
% * Var(P2) = variance de P2
function C = apparier_Points(I1, Ptint1, I2, Ptint2, K)
% I1, I2 : les deux images
% Ptint1, Ptint2 : les coordonnees des points detectes sur l'image 1, resp. 2
% C : matrice contenant, pour chaque paire de points (en ligne : les points
% de l'image 1, en colonne : les points de l'image 2), la valeur de la
% mesure de correlation pour ces paires de points
% K : Taille de la fenetre de correlation utilisee
% Dimensions des images
[htI1 lgI1] = size(I1); [htI2 lgI2] = size(I2);
% Nombres de points d'interet de l'image 1 et de l'image 2
nptI1 = size(Ptint1, 1); nptI2 = size(Ptint2, 1);
% Construction de la matrice des mesures de correlation
% Suppression de tous les points pour lesquels la fenêtre de corrélation
% n'est pas appliquable
C = zeros(nptI1, nptI2);
% Determination des points dont le voisinage est dans l'image
indptI1 = find(Ptint1(:, 1) - K >= 1 & Ptint1(:, 1) + K <= lgI1 ...
& Ptint1(:, 2) - K >= 1 & Ptint1(:, 2) + K <= htI1);
indptI2 = find(Ptint2(:, 1) - K >= 1 & Ptint2(:, 1) + K <= lgI2 ...
& Ptint2(:, 2) - K >= 1 & Ptint2(:, 2) + K <= htI2);
nbptintI1 = size(indptI1, 1);
nbptintI2 = size(indptI2, 1);
% Determination du voisinage : vois1, vois2 matrices composees
% pour chaque ligne des niveaux de gris du voisinage du point
% Appel a la fonction voisinage
vois1 = voisinage(I1, Ptint1(indptI1, :), K);
vois2 = voisinage(I2, Ptint2(indptI2, :), K);
% Nb Pixels par fenetre de correlation
NbPix = K * K;
% Calcul de tous les appariements possibles
[i1, i2] = meshgrid(1:nbptintI1, 1:nbptintI2);
i1 = i1(:); i2 = i2(:);
% Pour les images I1 et I2
% Moyenne des niveaux de gris du voisinage de chaque point
% Utilisation de mean
moy1 = mean(vois1, 2);
moy2 = mean(vois2, 2);
% % Variance des niveaux de gris du voisinage de chaque point
% % Utilisation de var
var1 = var(vois1, 0, 2);
var2 = var(vois2, 0, 2);
% Pour chaque combinaison de paires de points, la covariance
% entre les deux voisinages : le numerateur dans la formule ZNCC
cov = (vois1 - moy1) * (vois2 - moy2)' / NbPix;
% Calcul du score de correlation :
% ajouter le denominateur dans la formule ZNCC
% (le produit des variances)
cor = cov ./ sqrt(var1 * var2');
% cor = 1 ./ pdist2(vois1, vois2);
% Affectation a la matrice C
C(indptI1(i1) + (indptI2(i2) - 1) * nptI1) = cor';
end

30
appliquerHomographie.m Normal file
View file

@ -0,0 +1,30 @@
% Calcul des coordonnees (xy2) des points (xy1)
% apres application d'une homographique H
function [xy2] = appliquerHomographie(H, xy1)
% Entrees :
%
% H : matrice (3x3) de l'homographie
% xy1 : matrice (nbPoints x 2) representant les coordonnees
% (colonne 1 : les x, colonne 2 : les y)
% des nbPoints points auxquels H est appliquee
%
% Sortie :
% xy2 : coordonnees des points apres application de l'homographie
% Nombre de points
N = size(xy1, 1);
% Construction des coordonnees homogenes pour appliquer l'homographie
xy1_tild = [xy1, ones(N, 1)];
% Application de l'homographie
xy1_homo = H * xy1_tild';
% On retourne les coordonnees homogenes (x,y,1)
% Pour cela, il faut diviser par z
% Attention il ne faut garder que les deux premieres coordonnees
xy1_homo = xy1_homo ./ xy1_homo(3, :);
xy2 = xy1_homo(1:2, :)';
end

14
distance_homographie.m Normal file
View file

@ -0,0 +1,14 @@
function d = distance_homographie(XY1, XY2, H)
Hinv = inv(H);
Hinv = Hinv ./ Hinv(3, 3);
XY1_ = appliquerHomographie(H, XY1);
XY2_ = appliquerHomographie(Hinv, XY2);
d1 = sum((XY1_ - XY2).^2, 2);
d2 = sum((XY2_ - XY1).^2, 2);
d = d1 + d2;
end

76
harris.m Normal file
View file

@ -0,0 +1,76 @@
function [XY, R] = harris(Im, TailleFenetre, NbPoints, k)
%[XY,Res]=harris(Im,TailleFenetre,NbPoints,k);
%
% Im -> image
% TailleFenetre -> taille (impaire) de la fenetre du voisinage
% valeurs conseillees : entre 9 et 25
% NbPoints -> nombre de points desires
% k -> poids utilise dans le calcul de la reponse R, k dans [0.04,0.06]
% XY -> Matrice de taille NbPointsx2 contenant
% respectivement les abscisses et les oordonnees des points
% d'interets extraits
% ATTENTION : La fonction de Harris ne doit pas retourner des points sur les bords
% R -> Image des reponses par le detecteur de Harris
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Nota bene : les coordonnees utilisees sont x=j (numero de colonne) et y=i (numero de ligne). %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Verification et correction eventuelle des parametres donnes
if nargin < 4, k = 0.05; end;
if nargin < 3, NbPoints = 50; end;
if nargin < 2, TailleFenetre = 9; end;
% (1.1) Calcul des dérivées images suivant les lignes et les colonnes
% en utilisant la fonction gradient
Im = double(Im);
[Ii, Ij] = gradient(Im);
% (1.2) Calcul du filtre de lissage gaussien
% Calcul de sigma en fonction de la taille de la fenetre
sig = (TailleFenetre - 1) / 4;
L = fspecial('gaussian', TailleFenetre, sig);
% (1.3) Calcul de la reponse R
% Calcul des elements A, B et C puis calcul de la reponse suivant l'equation (1)
% Utiliser conv2 avec l'option 'same' pour appliquer le filtre de lissage L
A = conv2(Ii.^2, L, 'same');
B = conv2(Ij.^2, L, 'same');
C = conv2(Ii .* Ij, L, 'same');
R = A .* B - C.^2 - k * (A + B).^2;
% (2.1) Suppression des non-maxima locaux suivant l'equation (2)
% ATTENTION : il faut gérer le cas particulier des bords
% 1) Il est impossible de calculer le maximum local car une partie du voisinage n'existe pas
% 2) Il faut leur attribuer la valeur minimale afin qu'il ne soit pas selectionne par la suite
n2 = floor(TailleFenetre / 2);
[l, c] = size(Im);
Res = zeros(l, c);
for i = (n2 + 1):(l - n2)
for j = (n2 + 1):(c - n2)
Res(i, j) = max(max(R(i - n2:i + n2, j - n2:j + n2)));
if R(i, j) ~= Res(i, j)
Res(i, j) = 0;
end
end
end
% (2.2) Selection des NbPoints en fonction de "NbPoints" reponses les plus fortes
% Tri des reponses : utiliser sort en LINEARISANT Res au préalable
[~, is] = sort(Res(:), 'descend');
% Selection des indices de NbPoints de plus fortes reponses
is = is(1:NbPoints);
% Calcul des indices dans l'image
% Utiliser ind2sub, attention a l'ordre pour recuperer les coordonnees
[Y, X] = ind2sub([l, c], is);
XY = [X, Y];
end

49
homographie.m Normal file
View file

@ -0,0 +1,49 @@
% Estimation d'une matrice d'homographie H qui permet de passer d'une
% image I1 a une autre image I2 a partir de paires de points (homologues)
%
% H = [ h11 h12 h13 ; h21 h22 h23 ; h31 h32 h33 ]
% H possede 8 parametres independants.
% Chaque correspondance donne 2 equations.
% Ainsi pour estimer H, il faut au moins 4 paires de points.
%
% Il existe differentes manieres d'estimer H.
% Nous choisissons la resolution sous la contrainte ||h33|| = 1,
% au sens des moindres carres.
function [H] = homographie(XY_C1, XY_C2)
% Entrees :
%
% XY_C1 : matrice (NbPointsx2) contenant les coordonnees des Nbpoints dans l'image I1
% XY_C2 : matrice (NbPointsx2) contenant les coordonnees des Nbpoints HOMOLOGUES dans l'image I2
% (colonne 1 : les x, colonne 2 : les y)
%
% Sortie :
% H : la matrice d'homographie estimee
% Les parametres hij de la matrice d'homographie H sont ranges dans
% un vecteur : H = [ h11 ... h33 ]' tel que
% A * H = 0
% avec A qui depend des coordonnees de paires homologues, cf. equation (2)
% A = ( XY_C1(1,1) XY_C1(1,2) 1 0 0 0 -XY_C1(1,1)*XY_C2(1,1) -XY_C1(1,2)*XY_C2(1,1) -XY_C2(1,1)
% 0 0 0 XY_C1(1,1) XY_C1(1,2) 1 -XY_C1(1,1)*XY_C2(1,2) -XY_C1(1,2)*XY_C2(1,2) -XY_C2(1,2)
% ... etc ... )
% Stocker dans une variable le nombre de points apparies
N = size(XY_C1, 1);
% Construction des matrices/vecteurs utiles pour construire la matrice A
A = [
XY_C1(:, 1:2), ones(N, 1), zeros(N, 3), -XY_C2(:, 1) .* XY_C1(:, 1), -XY_C2(:, 1) .* XY_C1(:, 2), -XY_C2(:, 1);
zeros(N, 3), XY_C1(:, 1:2), ones(N, 1), -XY_C2(:, 2) .* XY_C1(:, 1), -XY_C2(:, 2) .* XY_C1(:, 2), -XY_C2(:, 2)
];
% Estimation des parametres de H par decomposition en valeurs singulieres
% Utiliser la fonction matlab svd :
% H est le vecteur propre associee a la plus petite valeur propre de A^TA
[~, ~, V] = svd(A' * A);
H = V(:, end);
% Former la matrice H de taille 3x3
H = reshape(H, 3, 3)';
end

BIN
im1.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 28 KiB

87
im1.pgm Normal file
View file

File diff suppressed because one or more lines are too long

BIN
im2.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 29 KiB

81
im2.pgm Normal file
View file

File diff suppressed because one or more lines are too long

BIN
im3.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 30 KiB

67
im3.pgm Normal file
View file

File diff suppressed because one or more lines are too long

BIN
im4.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 30 KiB

41
im4.pgm Normal file
View file

File diff suppressed because one or more lines are too long

99
mosaique.m Normal file
View file

@ -0,0 +1,99 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaique(I1, I2, H)
% On recupere la taille des deux images.
[nblI1 nbcI1] = size(I1);
[nblI2 nbcI2] = size(I2);
% On calcule l'homographie inverse, normalisee,
% pour nous permettre d'effectuer la transformation de I2 vers I1.
Hinv = inv(H);
Hinv = Hinv ./ Hinv(3, 3);
% Calcul des dimensions de la mosaique.
% Calcul des quatre coins dans l'image 2.
% les coins de l'image 2 sont ranges en ligne selon :
% haut_gauche, haut_droit, bas_droit, bas gauche.
% Lignes et colonnes sont inversees.
xy_coinsI2_R2 = [1 1; nbcI2 1; nbcI2 nblI2; 1 nblI2];
% Application de l'homographie Hinv sur ces coins.
% Calcul des images des coins dans I1.
xy_coinsI2_R1 = appliquerHomographie(Hinv, xy_coinsI2_R2);
% Determination des dimensions de l'image mosaique,
% les xmin ymin xmax ymax, ou :
% - xmin represente la plus petite abscisse parmi les abscisses des images
% des coins de I2 projetes dans I1 et les coins dans I1,
% - etc
% Lignes et colonnes sont inversees.
xmin = min([xy_coinsI2_R1(:, 1)' 1]);
ymin = min([xy_coinsI2_R1(:, 2)' 1]);
xmax = max([xy_coinsI2_R1(:, 1)' nbcI1]);
ymax = max([xy_coinsI2_R1(:, 2)' nblI1]);
% On arrondit de maniere a etre certain d'avoir les coordonnees initiales
% bien comprises dans l'image.
xmin = floor(xmin);
ymin = floor(ymin);
xmax = ceil(xmax);
ymax = ceil(ymax);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% CONTRUCTION DE LA MOSAIQUE %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Calcul de la taille de la mosaique.
% Lignes et colonnes sont inversees.
nblImos = ymax - ymin + 1;
nbcImos = xmax - xmin + 1;
Imos = zeros(nblImos, nbcImos);
% Calcul de l'origine de l'image I1 dans le repere de la mosaique Imos.
O1x_Rmos = 1 - (xmin - 1);
O1y_Rmos = 1 - (ymin - 1);
% Copie de l'image I1.
% Lignes et colonnes sont inversees.
Imos(O1y_Rmos:O1y_Rmos + nblI1 - 1, O1x_Rmos:O1x_Rmos + nbcI1 - 1) = I1;
% Copie de l'image I2 transformee par l'homographie H.
for x = 1:nbcImos,
for y = 1:nblImos,
% Calcul des coordonnees dans I1 connaissant les coordonnees du point origine de I1 dans Imos.
y_R1 = y - O1y_Rmos;
x_R1 = x - O1x_Rmos;
% Dans le repere attache a l'image I1,
% nous estimons les coordonnees du point image de (y_R1,x_R1)
% par l'homographie H : (xy_R2).
xy_R2 = appliquerHomographie(H, [x_R1 y_R1]);
% Il existe plusieurs strategies, mais, ici,
% pour estimer les coordonnees (entieres) ,
% on choisit : sans interpolation, le plus proche voisin.
x_R2 = round(xy_R2(1));
y_R2 = round(xy_R2(2));
% On verifie que xy_R2 appartient bien a l'image I2
% avant d'affecter cette valeur a Imos
% Lignes et colonnes sont inversees.
if (x_R2 >= 1 & x_R2 <= nbcI2 & y_R2 >= 1 & y_R2 <= nblI2)
Imos(y, x) = I2(y_R2, x_R2);
end
end
end
end

57
mosaiqueN.m Normal file
View file

@ -0,0 +1,57 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaiqueN(TailleFenetre, NbPoints, k, seuil, varargin)
Imos = im2double(varargin{1});
for i = 2:nargin - 4
Im1 = Imos;
Im2 = im2double(varargin{i});
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Detection des points d'interet avec Harris %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Im1_gray = rgb2gray(Im1);
Im2_gray = rgb2gray(Im2);
XY_1 = harris(Im1_gray, TailleFenetre, NbPoints, k);
XY_2 = harris(Im2_gray, TailleFenetre, NbPoints, k);
% affichage temporaire
figure;
affichage_POI(Im1,XY_1,'POI Image 1',1,2,1);
affichage_POI(Im2,XY_2,'POI Image 2',1,2,2);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Appariement des points d'interet %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[XY_C1, XY_C2] = apparier_POI(Im1_gray, XY_1, Im2_gray, XY_2, TailleFenetre, seuil);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Estimation (et verification) de l'homographie %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
s = 4;
t = 0.999;
fitFuncHomo = @(XY) homographie(XY(:, 1:2), XY(:, 3:4));
disFuncHomo = @(H, XY) distance_homographie(XY(:, 1:2), XY(:, 3:4), H);
[H, idx] = ransac([XY_C1, XY_C2], fitFuncHomo, disFuncHomo, s, t);
figure('Name', 'Appariement des points d''interet RANSAC');
affichage_appariement(Im1, XY_C1(idx, 1), XY_C1(idx, 2), 'Points d''interet Image 1', 1, 2, 1);
affichage_appariement(Im2, XY_C2(idx, 1), XY_C2(idx, 2), 'Points d''interet correspondants Image 2', 1, 2, 2);
% https://github.com/hero9968/Multiple-View-Geometry-in-Computer-Vision/blob/master/vgg_examples/ransacfithomography_vgg.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Collage des deux images %
%%%%%%%%%%%%%%%%%%%%%%%%%%%
Imos = mosaiquecoul(Im1, Im2, H);
figure;
affichage_image(Imos,'Mosaique obtenue a partir des 2 images initiales',1,1,1);
end
end

71
mosaiqueNbis.m Normal file
View file

@ -0,0 +1,71 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaiqueNbis(TailleFenetre, NbPoints, k, seuil, imref, varargin)
homos = cell(1, length(varargin));
homos(1) = {eye(3)};
for i = 1:length(varargin) - 1
Im1 = im2double(varargin{i});
Im2 = im2double(varargin{i+1});
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Detection des points d'interet avec Harris %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Im1_gray = rgb2gray(Im1);
Im2_gray = rgb2gray(Im2);
XY_1 = harris(Im1_gray, TailleFenetre, NbPoints, k);
XY_2 = harris(Im2_gray, TailleFenetre, NbPoints, k);
% affichage temporaire
figure;
affichage_POI(Im1,XY_1,'POI Image 1',1,2,1);
affichage_POI(Im2,XY_2,'POI Image 2',1,2,2);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Appariement des points d'interet %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
[XY_C1, XY_C2] = apparier_POI(Im1_gray, XY_1, Im2_gray, XY_2, TailleFenetre, seuil);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Estimation (et verification) de l'homographie %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% https://github.com/hero9968/Multiple-View-Geometry-in-Computer-Vision/blob/master/vgg_examples/ransacfithomography_vgg.m
s = 4;
t = 0.999;
fitFuncHomo = @(XY) homographie(XY(:, 1:2), XY(:, 3:4));
disFuncHomo = @(H, XY) distance_homographie(XY(:, 1:2), XY(:, 3:4), H);
[H, idx] = ransac([XY_C1, XY_C2], fitFuncHomo, disFuncHomo, s, t);
% XY = [XY_C1, XY_C2];
% H = homographie(XY(:, 1:2), XY(:, 3:4));
homos(i + 1) = {H};
figure('Name', 'Appariement des points d''interet RANSAC');
affichage_appariement(Im1, XY_C1(idx, 1), XY_C1(idx, 2), 'Points d''interet Image 1', 1, 2, 1);
affichage_appariement(Im2, XY_C2(idx, 1), XY_C2(idx, 2), 'Points d''interet correspondants Image 2', 1, 2, 2);
end
homos_to_ref = cell(1, length(varargin));
homos_to_ref(imref) = {eye(3)};
homos_tmp = eye(3);
for i = imref-1:-1:1
homos_tmp = homos_tmp / homos{i + 1};
homos_to_ref(i) = {homos_tmp};
end
homos_tmp = eye(3);
for i = imref+1:length(varargin)
homos_tmp = homos_tmp * homos{i};
homos_to_ref(i) = {homos_tmp};
end
%%%%%%%%%%%%%%%%%%%%%%
% Collage des images %
%%%%%%%%%%%%%%%%%%%%%%
Imos = mosaiqueter2(homos_to_ref, varargin);
imwrite(Imos, "test.png");

125
mosaiquebis.m Normal file
View file

@ -0,0 +1,125 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaiquebis(I1, I2, H)
% On recupere la taille des deux images.
[nblI1 nbcI1] = size(I1);
[nblI2 nbcI2] = size(I2);
% On calcule l'homographie inverse, normalisee,
% pour nous permettre d'effectuer la transformation de I2 vers I1.
Hinv = inv(H);
Hinv = Hinv ./ Hinv(3, 3);
% Calcul des dimensions de la mosaique.
% Calcul des quatre coins dans l'image 2.
% les coins de l'image 2 sont ranges en ligne selon :
% haut_gauche, haut_droit, bas_droit, bas gauche.
% Lignes et colonnes sont inversees.
xy_coinsI2_R2 = [1 1; nbcI2 1; nbcI2 nblI2; 1 nblI2];
% Application de l'homographie Hinv sur ces coins.
% Calcul des images des coins dans I1.
xy_coinsI2_R1 = appliquerHomographie(Hinv, xy_coinsI2_R2);
% Determination des dimensions de l'image mosaique,
% les xmin ymin xmax ymax, ou :
% - xmin represente la plus petite abscisse parmi les abscisses des images
% des coins de I2 projetes dans I1 et les coins dans I1,
% - etc
% Lignes et colonnes sont inversees.
xmin = min([xy_coinsI2_R1(:, 1)' 1]);
ymin = min([xy_coinsI2_R1(:, 2)' 1]);
xmax = max([xy_coinsI2_R1(:, 1)' nbcI1]);
ymax = max([xy_coinsI2_R1(:, 2)' nblI1]);
% On arrondit de maniere a etre certain d'avoir les coordonnees initiales
% bien comprises dans l'image.
xmin = floor(xmin);
ymin = floor(ymin);
xmax = ceil(xmax);
ymax = ceil(ymax);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% CONTRUCTION DE LA MOSAIQUE %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Calcul de la taille de la mosaique.
% Lignes et colonnes sont inversees.
nblImos = ymax - ymin + 1;
nbcImos = xmax - xmin + 1;
Imos = zeros(nblImos, nbcImos);
% Calcul de l'origine de l'image I1 dans le repere de la mosaique Imos.
O1x_Rmos = 1 - (xmin - 1);
O1y_Rmos = 1 - (ymin - 1);
% Copie de l'image I1.
% Lignes et colonnes sont inversees.
Imos(O1y_Rmos:O1y_Rmos + nblI1 - 1, O1x_Rmos:O1x_Rmos + nbcI1 - 1) = I1;
% Copie de l'image I2 transformee par l'homographie H.
for x = 1:nbcImos
for y = 1:nblImos
% Calcul des coordonnees dans I1 connaissant les coordonnees du point origine de I1 dans Imos.
y_R1 = y - O1y_Rmos;
x_R1 = x - O1x_Rmos;
d1 = min([nbcI1 - x_R1, nblI1 - y_R1, x_R1, y_R1]);
% Dans le repere attache a l'image I1,
% nous estimons les coordonnees du point image de (y_R1,x_R1)
% par l'homographie H : (xy_R2).
xy_R2 = appliquerHomographie(H, [x_R1 y_R1]);
% Il existe plusieurs strategies, mais, ici,
% pour estimer les coordonnees (entieres) ,
% on choisit : sans interpolation, le plus proche voisin.
x_R2 = round(xy_R2(1));
y_R2 = round(xy_R2(2));
d2 = min([nbcI2 - x_R2, nblI2 - y_R2, x_R2, y_R2]);
% calcul des poids de l'interpolation.
if d1 <= 0 || all(I1(y_R1, x_R1) == 0)
d1 = 0;
end
if d2 <= 0 || all(I2(y_R2, x_R2) == 0)
d2 = 0;
end
if d1 == 0 && d2 == 0
p1 = 0;
p2 = 0;
else
p1 = d1 / (d1 + d2);
p2 = d2 / (d1 + d2);
end
% On verifie que xy_R2 appartient bien a l'image I2
% avant d'affecter cette valeur a Imos
% Lignes et colonnes sont inversees.
if p1 ~= 0
t1 = p1 * I1(y_R1, x_R1);
else
t1 = 0;
end
if p2 ~= 0
t2 = p2 * I2(y_R2, x_R2);
else
t2 = 0;
end
Imos(y, x) = t1 + t2;
end
end
end

19
mosaiquecoul.m Normal file
View file

@ -0,0 +1,19 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaiquecoul(I1, I2, H)
c = size(I1, 3);
Imos = [];
for i = 1:c
Imos = cat(3, Imos, mosaiquebis(I1(:,:,i), I2(:,:,i), H));
end
end

138
mosaiqueter.m Normal file
View file

@ -0,0 +1,138 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaiqueter(homos, imgs)
% On recupere la taille des deux images.
Iref = im2double(imgs{1});
[nblIref, nbcIref, nc] = size(Iref);
xmin = Inf;
ymin = Inf;
xmax = -Inf;
ymax = -Inf;
for k=1:length(imgs)
[nblIk, nbcIk, ~] = size(imgs{k});
% On calcule l'homographie inverse, normalisee,
% pour nous permettre d'effectuer la transformation de I2 vers I1.
Hinv = inv(homos{k});
Hinv = Hinv ./ Hinv(3, 3);
% On calcule les coordonnees des 4 coins de I2 dans I1.
xy_coinsIk_Rk = [1 1; nbcIk 1; nbcIk nblIk; 1 nblIk];
% Application de l'homographie Hinv sur ces coins.
% Calcul des images des coins dans I1.
xy_coinsIk_Rref = appliquerHomographie(Hinv, xy_coinsIk_Rk);
% Determination des dimensions de l'image mosaique,
% les xmin ymin xmax ymax, ou :
% - xmin represente la plus petite abscisse parmi les abscisses des images
% des coins de I2 projetes dans I1 et les coins dans I1,
% - etc
% Lignes et colonnes sont inversees.
xmin = min([xy_coinsIk_Rref(:, 1)' xmin]);
ymin = min([xy_coinsIk_Rref(:, 2)' ymin]);
xmax = max([xy_coinsIk_Rref(:, 1)' xmax]);
ymax = max([xy_coinsIk_Rref(:, 2)' ymax]);
end
% On arrondit de maniere a etre certain d'avoir les coordonnees initiales
% bien comprises dans l'image.
xmin = floor(xmin);
ymin = floor(ymin);
xmax = ceil(xmax);
ymax = ceil(ymax);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% CONTRUCTION DE LA MOSAIQUE %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Calcul de la taille de la mosaique.
% Lignes et colonnes sont inversees.
nblImos = ymax - ymin + 1;
nbcImos = xmax - xmin + 1;
Imos = zeros(nblImos, nbcImos, nc);
% Calcul de l'origine de l'image I1 dans le repere de la mosaique Imos.
O1x_Rmos = 1 - (xmin - 1);
O1y_Rmos = 1 - (ymin - 1);
% Copie de l'image I1.
% Lignes et colonnes sont inversees.
Imos(O1y_Rmos:O1y_Rmos + nblIref - 1, O1x_Rmos:O1x_Rmos + nbcIref - 1, :) = Iref;
% Copie de l'image I2 transformee par l'homographie H.
for x = 1:nbcImos
fprintf('%d/%d\r', x, nbcImos);
for y = 1:nblImos
% Calcul des coordonnees dans I1 connaissant les coordonnees du point origine de I1 dans Imos.
y_Rref = y - O1y_Rmos;
x_Rref = x - O1x_Rmos;
distances = zeros(1, length(imgs));
dref = min([nbcIref - x_Rref, nblIref - y_Rref, x_Rref, y_Rref]);
if dref <= 0 || all(Iref(y_Rref, x_Rref, :) == 0)
dref = 0;
end
distances(1) = dref;
% Dans le repere attache a l'image I1,
% nous estimons les coordonnees du point image de (y_R1,x_R1)
% par l'homographie H : (xy_R2).
xy_Rs = zeros(length(imgs), 2);
xy_Rs(1,:) = [x_Rref y_Rref];
for k = 1:length(imgs)
xy_Rk = appliquerHomographie(homos{k}, [x_Rref y_Rref]);
xy_Rs(k,:) = round(xy_Rk);
% Il existe plusieurs strategies, mais, ici,
% pour estimer les coordonnees (entieres) ,
% on choisit : sans interpolation, le plus proche voisin.
x_Rk = round(xy_Rk(1));
y_Rk = round(xy_Rk(2));
[nblIk, nbcIk, ~] = size(imgs{k});
dk = min([nbcIk - x_Rk, nblIk - y_Rk, x_Rk, y_Rk]);
if dk <= 0 || all(imgs{k}(y_Rk, x_Rk, :) == 0)
dk = 0;
end
distances(k) = dk;
end
poids = zeros(1, length(imgs));
if sum(distances) ~= 0
poids = distances / sum(distances);
poids = max(poids, 0);
end
% On verifie que xy_R2 appartient bien a l'image I2
% avant d'affecter cette valeur a Imos
% Lignes et colonnes sont inversees.
ts = zeros(length(imgs), 3);
for k = 1:length(imgs)
if poids(k) ~= 0
ts(k, :) = poids(k) * double(imgs{k}(xy_Rs(k,2), xy_Rs(k,1), :)) / 255;
else
ts(k, :) = [0 0 0];
end
end
Imos(y, x, :) = sum(ts, 1);
end
end
fprintf('\n');
end

123
mosaiqueter2.m Normal file
View file

@ -0,0 +1,123 @@
% Calcul d'une mosaique d'image à partir de 2 images : I1 et I2
% connaissant l'homographie H entre les 2.
% L'image resultat est stockee dans Res.
% On choisit de projeter I2 dans I1 pour construire la mosaique.
% Attention !!!
% On suppose un axe de rotation parallèle aux colonnes.
% C'est la raison pour laquelle on inverse les lignes et les colonnes
% dans la reconstruction de la mosaique.
function [Imos] = mosaiqueter2(homos, imgs)
xmin = Inf;
ymin = Inf;
xmax = -Inf;
ymax = -Inf;
for k=1:length(imgs)
[nblIk, nbcIk, ~] = size(imgs{k});
% On calcule l'homographie inverse, normalisee,
% pour nous permettre d'effectuer la transformation de I2 vers I1.
Hinv = inv(homos{k});
Hinv = Hinv ./ Hinv(3, 3);
% On calcule les coordonnees des 4 coins de I2 dans I1.
xy_coinsIk_Rk = [1 1; nbcIk 1; nbcIk nblIk; 1 nblIk];
% Application de l'homographie Hinv sur ces coins.
% Calcul des images des coins dans I1.
xy_coinsIk_Rref = appliquerHomographie(Hinv, xy_coinsIk_Rk);
% Determination des dimensions de l'image mosaique,
% les xmin ymin xmax ymax, ou :
% - xmin represente la plus petite abscisse parmi les abscisses des images
% des coins de I2 projetes dans I1 et les coins dans I1,
% - etc
% Lignes et colonnes sont inversees.
xmin = min([xy_coinsIk_Rref(:, 1)' xmin]);
ymin = min([xy_coinsIk_Rref(:, 2)' ymin]);
xmax = max([xy_coinsIk_Rref(:, 1)' xmax]);
ymax = max([xy_coinsIk_Rref(:, 2)' ymax]);
end
% On arrondit de maniere a etre certain d'avoir les coordonnees initiales
% bien comprises dans l'image.
xmin = floor(xmin);
ymin = floor(ymin);
xmax = ceil(xmax);
ymax = ceil(ymax);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% CONTRUCTION DE LA MOSAIQUE %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Calcul de la taille de la mosaique.
% Lignes et colonnes sont inversees.
nblImos = ymax - ymin + 1;
nbcImos = xmax - xmin + 1;
% Calcul de l'origine de l'image I1 dans le repere de la mosaique Imos.
O1x_Rmos = 1 - (xmin - 1);
O1y_Rmos = 1 - (ymin - 1);
% Copie de l'image I2 transformee par l'homographie H.
Imos = [];
n_bloc = 4;
bloc_size = floor(nblImos*nbcImos/n_bloc);
for i = 1:n_bloc
fprintf('%d/%d\r', i, n_bloc);
[y, x] = ind2sub([nblImos, nbcImos], i*bloc_size+1:bloc_size*(i+1));
y = y';
x = x';
distances = zeros(bloc_size, length(imgs));
% Calcul des coordonnees dans I1 connaissant les coordonnees du point origine de I1 dans Imos.
y_Rref = y - O1y_Rmos;
x_Rref = x - O1x_Rmos;
% Dans le repere attache a l'image I1,
% nous estimons les coordonnees du point image de (y_R1,x_R1)
% par l'homographie H : (xy_R2).
xy_Rs = zeros(bloc_size, length(imgs), 2);
xy_Rs(:, 1, :) = [x_Rref y_Rref];
for k = 1:length(imgs)
xy_Rk = appliquerHomographie(homos{k}, [x_Rref y_Rref]);
xy_Rs(:,k,:) = round(xy_Rk);
% Il existe plusieurs strategies, mais, ici,
% pour estimer les coordonnees (entieres) ,
% on choisit : sans interpolation, le plus proche voisin.
x_Rk = round(xy_Rk(:,1));
y_Rk = round(xy_Rk(:,2));
[nblIk, nbcIk, ~] = size(imgs{k});
dk = min([nbcIk - x_Rk, nblIk - y_Rk, x_Rk, y_Rk], [], 2);
dk(dk < 0) = 0;
distances(:,k) = dk;
end
poids = distances ./ sum(distances, 2);
poids(isnan(poids)) = 0;
poids(:) = max(poids(:), 0);
% On verifie que xy_R2 appartient bien a l'image I2
% avant d'affecter cette valeur a Imos
% Lignes et colonnes sont inversees.
ts = zeros(bloc_size, length(imgs), 3);
for k = 1:length(imgs)
imgk = im2double(imgs{k});
[nblIk, nbcIk, ~] = size(imgk);
imgk = reshape(imgk, nblIk*nbcIk, 3);
valid_pixels = (xy_Rs(:,k,1) >= 1) & (xy_Rs(:,k,1) <= nbcIk) & (xy_Rs(:,k,2) >= 1) & (xy_Rs(:,k,2) <= nblIk);
ts(valid_pixels, k, :) = poids(valid_pixels,k) .* imgk(sub2ind([nblIk, nbcIk], xy_Rs(valid_pixels,k,2), xy_Rs(valid_pixels,k,1)), :);
end
Imos = cat(1, Imos, sum(ts, 2));
end
Imos = cat(1, Imos, zeros(nblImos*nbcImos - size(Imos, 1), 1, 3));
Imos = reshape(Imos, nblImos, nbcImos, 3);
fprintf('\n');
end

16
plot_points.m Normal file
View file

@ -0,0 +1,16 @@
function plot_points(XY,NbPoints,motif);
% Affichage de points numerotes sur une image.
% Cet affichage est superpose a la fenetre courante.
% I-> vecteur colonne des numeros de lignes des points
% J-> vecteur colonne des numeros de colonnes des points
% NbPoints -> nombre de points a afficher
% si ce parametre est absent, tous les points seront affiches
% motif -> motif utilise pour l'affichage
if nargin < 3, NbPoints=length(I); end;
hold on;
for p=1:NbPoints
plot(XY(p,1),XY(p,2),motif,'MarkerEdgeColor','r','MarkerFaceColor','r','MarkerSize',10);
end
hold off;

494
sweet1.pgm Normal file
View file

File diff suppressed because one or more lines are too long

97
sweet2.pgm Normal file
View file

File diff suppressed because one or more lines are too long

BIN
sweet_couleur1.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2 MiB

BIN
sweet_couleur2.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2 MiB

BIN
sweet_couleur3.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 2 MiB

BIN
test.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 1.2 MiB

33
voisinage.m Normal file
View file

@ -0,0 +1,33 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% fonction renvoyant les niveaux de gris du voisinage de chaque point en ligne
function voisins = voisinage(I, xyPt, TailleFenetre)
% ENTREES
% I : l'image
% xyPt : les coordonnees des points dont nous cherchons le voisinage.
% ATTENTION : on fait l'hypothese qu'il n'y a aucun point sur les bords
% TailleFenetre : La taille de la fenêtre de correlation correspond
% a TailleFenetre x TailleFenetre
% SORTIE
% voisins : une matrice contenant pour chaque ligne (= chaque point),
% le voisinage du point associe
% Nombre de points pour lesquels leur voisinage est cherche
npt = size(xyPt, 1);
% Initialisation
voisins = zeros(npt, TailleFenetre * TailleFenetre);
% Calcul de la demi-fenetre de correlation
K = floor(TailleFenetre / 2);
% Pour chaque point
for i = 1:npt
% On recupere les coordonnees du point
x = xyPt(i, 1);
y = xyPt(i, 2);
% On recupere le voisinage du point
voisins(i, :) = reshape(I(y - K:y + K, x - K:x + K), 1, TailleFenetre * TailleFenetre);
end
end