Discussion :

[hanane78]

dans le forum de traitement d'image psedocode m'explique comment je peux trouve l'interpolation bilineaire d'une image

Ca sert a estimer la valeur d'un pixel "imaginaire" P(u,v) entre 4 pixels connus g0,g1,g2,g3. C'est une moyenne pondérée des 4 pixels connus. Les poids sont egaux à "1 - coordonnée barycentrique".

g2 +---------------+ g3
| |
| * (u,v) |
| |
g0 +---------------+ g1

En fait, on regarde la partie décimale de (u,v) qu'on note ( dpu, dpv )

Si cette partie décimale est proche de (0,0) alors le pixel est proche de g0.
Si cette partie décimale est proche de (1,1) alors le pixel est proche de g3.
et ainsi de suite...

on arrive donc a la formule:

P(u,v) = (1-dpu)*(1-dpv)*g0 + (dpu)*(1-dpv)*g1 + (1-dpu)*(dpv)*g2 + (dpu)*(dpv)*g3

On peut bien sur l'adapter aux images couleur, en appliquant cette formule pour chaque composante couleur:

P(u,v)_red = (1-dpu)*(1-dpv)*g0_red + (dpu)*(1-dpv)*g1_red + (1-dpu)*(dpv)*g2_red + (dpu)*(dpv)*g3_red
P(u,v)_green = (1-dpu)*(1-dpv)*g0_green + (dpu)*(1-dpv)*g1_green + (1-dpu)*(dpv)*g2_green + (dpu)*(dpv)*g3_green
P(u,v)_blue = (1-dpu)*(1-dpv)*g0_blue + (dpu)*(1-dpv)*g1_blue + (1-dpu)*(dpv)*g2_blue + (dpu)*(dpv)*g3_blue

maintenant je peut utiliser cette algorithme pour implementer une fonction sous matlab

Merci bien

[paradize3]

maintenant je peut utiliser cette algorithme pour implementer une fonction sous matlab

Oui tu peux.

[hanane78]

oui, je sais que ce matlab je peux implementer cette fonction mais mon probleme c'est que j'arrive pas a le faire moi seule

j'ai besoin de quelque indication sous matlab

Merci bien

[hanane78]

voila ce code mais il me donne rien

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
Isrc = imread('cameraman.tif');
Idest = zeros(size(Isrc));
Mparams = [1 0 0; 0 1 0;141.5 105.5 1]';
 width   = size(Isrc,2); 
height  = size(Isrc,1);
 
widthR  = size(Idest,2);
heightR = size(Idest,1);
 
 
Iresult = zeros(size(Idest));
% Obtain all the coordinates in Idest.
 
[y, x] = find(Idest>=0);
 
u = zeros(length(y),1);   
v = zeros(length(y),1);   
h = zeros(length(y),1);  
 
g0     = zeros(widthR*heightR,1);
g1     = zeros(widthR*heightR,1);
g2     = zeros(widthR*heightR,1);
g3     = zeros(widthR*heightR,1);
for i =1:length(y)
  kk   = Mparams*[x(i); y(i); 1.0];  
  u(i) = kk(1);
  v(i) = kk(2);
  h(i) = kk(3);
 
floorU = floor(u);
 
floorV = floor(v);
 
 
 
% la partie entier de u et v
dpu = (u - floorU);
dpv = (v - floorV);
 
 
 P(u,v) = (1-dpu).*(1-dpv).*g0 + (dpu).*(1-dpv).*g1 + (1-dpu).*(dpv).*g2 + (dpu).*(dpv).*g3;
end

je sais pas où je trouve l'erreur
Merci

[larimoise]

Ce n'est pas dans le domaine de Fourier que tu devrais travailler par hasard?

[hanane78]

Ce n'est pas dans le domaine de Fourier que tu devrais travailler par hasard?

j'ai pas compris le domaine de fourier ?

mais mon problem entre dans comment je peux faire l'interpolation d'une image j'ai trouve dans un document

L’interpolation bilinéaire est une application successive de plusieurs interpolations linéaires sur
deux variables. Dans notre cas, on cherche le niveau de gris F(G) d’un point G(x, y) inclue dans
un carré formé par quatre pixels A, B, C, D. En effectuant un changement de repère pour simplifier
les calculs, on se ramène à considérer les points A(0, 0), B(1, 0), C(1, 1), D(0, 1) et G(dx, dy) avec
dx = x − Entier(x) et dy = y − Entier(y).

Soient les points M1(dx, 0) et M2(dx, 1). Deux interpolations linéaires sur l’axe des abscisses donnent :
F(M1) = (1 − dx) · F(A) + dx · F(B)
F(M2) = (1 − dx) · F(D) + dx · F(C)

On en déduit F(G) via une interpolation linéaire sur l’axe des ordonnées :
F(G) = (1 − dy) · F(M1) + dy · F(M2)
= F(A) · (1 − dx) · (1 − dy) + F(B) · dx · (1 − dy) + F(C) · dx · dy +
F(D) · (1dx) · dy

c'est la meme principe qu'il me donnais pseudocode de la forum de traitement d'image

maintenant j'ai pas compris comment je peux commencer pour faire cette interpolation sous matlab
Merci d'avence

[larimoise]

Je ne connais pas particulièrement cette méthode, si j'ai parlé du domaine de Fourier (c'est à dire passer par la transformée de Fourier), c'est en voyant tes notations:

g2 +---------------+ g3
| |
| * (u,v) |
| |
g0 +---------------+ g1

En général on utilise la notation g(u,v) quand on travaille avec la transformée de Fourier de l'image.
Quand tu dit que:

dx = x − Entier(x) et dy = y − Entier(y).

que représentent x et y par rapport au pixel?

[hanane78]

P(x,y) c'etait la position de P selon les x et y

je pense pas ici que je dois travailler avec fourier!!

[Jerome Briot]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
g0     = zeros(widthR*heightR,1);
g1     = zeros(widthR*heightR,1);
g2     = zeros(widthR*heightR,1);
g3     = zeros(widthR*heightR,1);
 
for i =1:length(y)
 P(u,v) = (1-dpu).*(1-dpv).*g0 + (dpu).*(1-dpv).*g1 + (1-dpu).*(dpv).*g2 + (dpu).*(dpv).*g3;
end

je sais pas où je trouve l'erreur

Il n'y a rien qui te choque dans le code que tu as posté ci-dessus ?

Laisse moi deviner, la matrice P est remplie de 0

[hanane78]

on cherche le niveau de gris F(G) d’un point G(x, y) inclue dans
un carré formé par quatre pixels A, B, C, D. En effectuant un changement de repère pour simplifier
les calculs, on se ramène à considérer les points A(0, 0), B(1, 0), C(1, 1), D(0, 1) et G(dx, dy) avec
dx = x − Entier(x) et dy = y − Entier(y).

comment je peux cherche les 4 point voisins A B C et D dans l'image
puisque je dois trouver la nouvelle valeur de chaque pixel dans l'image
G(x, y) ==>P(u,v) pour chaque pixel

[larimoise]

Si x et y représentent une position (coordonnées) alors:

dx = x − Entier(x) vaut 0 non ? , puisque x est une valeur entière.

[hanane78]

non
dx et dy doit etre different de zero

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
% la partie entier de x et y
floorX = floor(x);
floorY = floor(y);
dx = (x - floorX);
dy = (y - floorY);

[Jerome Briot]

Ceci s'écrit plus simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
dx=rem(x,1);
dy=rem(y,1);

[paradize3]

Si tu veux une fonction clef en main, utilise interp2 avec l'option 'linear' (cf doc).

salutations,

Gregoire

[hanane78]

bonjour
j'ai utilisé la fonction interp2 avec ce petit programme mais il est bloqué

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
I = imread('cameraman.tif');
[m,n]= size(I);
for  XI = 1:m ;
   for YI= 1:n ;
        ZI = interp2(I,XI,YI,'linear');
   end
end
 
  figure,imshow(ZI);

normalement je dois utiliser un image couleur ?

[paradize3]

Si on prend la peine d'ouvrir et de lire rapidement la doc on voit:

ZI = interp2(Z,XI,YI) assumes that X = 1:n and Y = 1:m, where [m,n] = size(Z).

Sinon il faut que tu appliques a chaque composante de ton image couleur séparemment puisqu'il s'agit d'une interpolation 2D.

Salutations,

Greg

[hanane78]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
close all;clear all; clc;
I = imread('cameraman.tif');
figure,
imshow(I);
Isrc = double(I);
Idest =  zeros(size(Isrc))  ;
Mparams =  [1 0 145.5;0  1 151.50 ; 0 0  1];
 
width   = size(Isrc,2); 
height  = size(Isrc,1);
 
widthR  = size(Idest,2);
heightR = size(Idest,1);
 
Iresult = zeros(size(Idest));
% Obtain all the coordinates in Idest.
[y, x] = find(Idest>=0);
u = zeros(length(y),1);   
v = zeros(length(y),1);   
h = zeros(length(y),1);   
for i =1:length(y)
  kk   = Mparams*[x(i); y(i); 1.0];  
  u(i) = kk(1);
  v(i) = kk(2);
  h(i) = kk(3);
end
 
floorU = floor(u);
ceilU  = ceil(u);
floorV = floor(v);
ceilV  = ceil(v);   
 
g0     = zeros(widthR*heightR,1);
g1     = zeros(widthR*heightR,1);
g2     = zeros(widthR*heightR,1);
g3     = zeros(widthR*heightR,1);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%j'ai pas bien compris ces instruction
l      = find((floorV >= 1) & (floorV < height) & (floorU >= 1) & (floorU < width));
g0(l)  = double(Isrc(floorV(l) + height.*(floorU(l)-1)));
g1(l)  = double(Isrc(floorV(l) + height.*(ceilU(l)-1)));
g2(l)  = double(Isrc(ceilV(l)  + height.*(floorU(l)-1)));
g3(l)  = double(Isrc(ceilV(l)  + height.*(ceilU(l)-1)));
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
dx=rem(u,1);
dy=rem(v,1);
 
g01    = g0 + (g1 - g0).*dx;
g23    = g2 + (g3 - g2).*dx;
Iresult(y + heightR.*(x-1)) = (g01 + (g23 - g01).*dy);
 
Iresult = uint8(Iresult);
figure,  imshow(Iresult);

j'ai ce test sur cette image est ce que ça est l'interpolation bilenaire

la partie qui entre les commentaire est incomprehensible pour moi
est ce que si possible d'ajouter des commentaire la dedans

Merci bien

[hanane78]

je trouve aucun commentaire sur ma question
es ce que quelqu'un a une aidee sur ma question

Merci bien