Optimiser un code pour éviter " out of memory"

Version imprimable

Bonjour les gens,
Voila j'ai codé un débruitage d'image à partir de transformée en ondelettes, mais comme j'ai un peu codé comme un bourrin, je ne peux pas dépasser des images 2048*2048, autrement c'est out of memory. Je mets le code, si quelqu'un a une suggestion. Merki

Code:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
function [w]= transfo_des_indiens (X);
X;
[m,n]=size(X);
%décomposition de la matrice image par une transformée discrète en
%ondelettes
%ici la décomposition s'effectue sur 5 niveaux
[A1,H1,V1,D1]=swt2(B,1,'bior3.3');
[A2,H2,V2,D2]=swt2(A1,1,'bior3.3');
[A3,H3,V3,D3]=swt2(A2,1,'bior3.3');
[A4,H4,V4,D4]=swt2(A3,1,'bior3.3');
[A5,H5,V5,D5]=swt2(A4,1,'bior3.3');
%fin de la décompostition
 
%moyennage des composantes détaillées des cinq niveaux(réduction du
%speckle)
%On commence par traiter les composantes du niveau 5
for i=1:m;
    Mh5= mean(H5(i,1:n));
    Mv5= mean(V5(i,1:n));
    Md5= mean(D5(i,1:n));
    for j=1:n;
    if abs(H5(i,j))<abs(Mh5);
        H5(i,j)=H5(i,j);
    else
        H5(i,j)=Mh5;
    end
    if abs(V5(i,j))<abs(Mv5);
        V5(i,j)=V5(i,j);
    else
        V5(i,j)=Mv5;
    end
    if abs(D5(i,j))<abs(Md5);
        D5(i,j)=D5(i,j);
    else
        D5(i,j)=Md5;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 5 au niveau de
%décomposition 4
At4=iswt2(A5,H5,V5,D5,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 4
for i=1:m;
    Mh4= mean(H4(i,1:n));
    Mv4= mean(V4(i,1:n));
    Md4= mean(D4(i,1:n));
    for j=1:n;
    if abs(H4(i,j))<abs(Mh4);
        H4(i,j)=H4(i,j);
    else
        H4(i,j)=Mh4;
    end
    if abs(V4(i,j))<abs(Mv4);
        V4(i,j)=V4(i,j);
    else
        V4(i,j)=Mv4;
    end
    if abs(D4(i,j))<abs(Md4);
        D4(i,j)=D4(i,j);
    else
        D4(i,j)=Md4;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 4 au niveau de
%décomposition 3
At3=iswt2(At4,H4,V4,D4,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 3
for i=1:m;
    Mh3= mean(H3(i,1:n));
    Mv3= mean(V3(i,1:n));
    Md3= mean(D3(i,1:n));
    for j=1:n;
    if abs(H3(i,j))<abs(Mh3);
        H3(i,j)=H3(i,j);
    else
        H3(i,j)=Mh3;
    end
    if abs(V3(i,j))<abs(Mv3);
        V3(i,j)=V3(i,j);
    else
        V3(i,j)=Mv3;
    end
    if abs(D3(i,j))<abs(Md3);
        D3(i,j)=D3(i,j);
    else
        D3(i,j)=Md3;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 3 au niveau de
%décomposition 2
At2=iswt2(At3,H3,V3,D3,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 2
for i=1:m;
    Mh2= mean(H2(i,1:n));
    Mv2= mean(V2(i,1:n));
    Md2= mean(D2(i,1:n));
    for j=1:n;
    if abs(H2(i,j))<abs(Mh2);
        H2(i,j)=H2(i,j);
    else
        H2(i,j)=Mh2;
    end
    if abs(V2(i,j))<abs(Mv2);
        V2(i,j)=V2(i,j);
    else
        V2(i,j)=Mv2;
    end
    if abs(D2(i,j))<abs(Md2);
        D2(i,j)=D2(i,j);
    else
        D2(i,j)=Md2;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 2 au niveau de
%décomposition 1
At1=iswt2(At2,H2,V2,D2,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 1
for i=1:m;
    Mh1= mean(H1(i,1:n));
    Mv1= mean(V1(i,1:n));
    Md1= mean(D1(i,1:n));
    for j=1:n;
    if abs(H1(i,j))<abs(Mh1);
        H1(i,j)=H1(i,j);
    else
        H1(i,j)=Mh1;
    end
    if abs(V1(i,j))<abs(Mv1);
        V1(i,j)=V1(i,j);
    else
        V1(i,j)=Mv1;
    end
    if abs(D1(i,j))<abs(Md1);
        D1(i,j)=D1(i,j);
    else
        D1(i,j)=Md1;
    end
    end
end
 
%Dernière transformation inverse pour avoir l'image débruitée, puis
%affichage du résultat
Xt=iswt2(At1,H1,V1,D1,'bior3.3');
n=256;
map2=gray(n);
subplot(211); image(B);colormap(map2);
subplot(212); image(Xt);colormap(map2);
w=Xt;

15/03/2007, 15h50
tug83

As tu regardé :
http://www.mathworks.com/support/tec...00/1106.html#1
15/03/2007, 16h02
Jerome Briot
Bonjour,

on s'occupera du "Out of memory" plus tard !
Il serait d'abord judicieux d'optimiser les conditions IF-END qui sont très mal employées ici.
Code:

1 2 3 4 5 if a<=1 a=a; else a=0; end
peut simplement s'écrire :
Code:

1 2 3 if a>1 a=0; end
Peux-tu poster ton code simplifié ?

Voilà le code avec simlification des "if"

Code:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
function [w]= transfo_des_indiens (X);
[m,n]=size(X);
%décomposition de la matrice image par une transformée discrète en
%ondelettes
%ici la décomposition s'effectue sur 5 niveaux
[A1,H1,V1,D1]=swt2(X,1,'bior3.3');
[A2,H2,V2,D2]=swt2(A1,1,'bior3.3');
[A3,H3,V3,D3]=swt2(A2,1,'bior3.3');
[A4,H4,V4,D4]=swt2(A3,1,'bior3.3');
[A5,H5,V5,D5]=swt2(A4,1,'bior3.3');
%fin de la décompostition
 
 
%moyennage des composantes détaillées des cinq niveaux(réduction du
%speckle)
%On commence par traiter les composantes du niveau 5
for i=1:n;
    Mh5= mean(H5(i,1:n));
    Mv5= mean(V5(i,1:n));
    Md5= mean(D5(i,1:n));
    for j=1:m;
    if abs(H5(i,j))>abs(Mh5);
        H5(i,j)=Mh5;
    end
    if abs(V5(i,j))>abs(Mv5);
        V5(i,j)=Mv5;
    end
    if abs(D5(i,j))>abs(Md5);
        D5(i,j)=Md5;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 5 au niveau de
%décomposition 4
At4=iswt2(A5,H5,V5,D5,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 4
for i=1:m;
    Mh4= mean(H4(i,1:n));
    Mv4= mean(V4(i,1:n));
    Md4= mean(D4(i,1:n));
    for j=1:n;
    if abs(H4(i,j))>abs(Mh4);
        H4(i,j)=Mh4;
    end
    if abs(V4(i,j))>abs(Mv4);
        V4(i,j)=Mv4;
    end
    if abs(D4(i,j))>abs(Md4);
        D4(i,j)=Md4;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 4 au niveau de
%décomposition 3
At3=iswt2(At4,H4,V4,D4,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 3
for i=1:m;
    Mh3= mean(H3(i,1:n));
    Mv3= mean(V3(i,1:n));
    Md3= mean(D3(i,1:n));
    for j=1:n;
    if abs(H3(i,j))>abs(Mh3);
        H3(i,j)=Mh3;
    end
    if abs(V3(i,j))>abs(Mv3);
        V3(i,j)=Mv3;
    end
    if abs(D3(i,j))>abs(Md3);
        D3(i,j)=Md3;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 3 au niveau de
%décomposition 2
At2=iswt2(At3,H3,V3,D3,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 2
for i=1:m;
    Mh2= mean(H2(i,1:n));
    Mv2= mean(V2(i,1:n));
    Md2= mean(D2(i,1:n));
    for j=1:n;
    if abs(H2(i,j))>abs(Mh2);
        H2(i,j)=Mh2;
    end
    if abs(V2(i,j))>abs(Mv2);
        V2(i,j)=Mv2;
    end
    if abs(D2(i,j))>abs(Md2);
        D2(i,j)=Md2;
    end
    end
end
 
%transformation inverse, passage du niveau de décomposition 2 au niveau de
%décomposition 1
At1=iswt2(At2,H2,V2,D2,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 1
for i=1:m;
    Mh1= mean(H1(i,1:n));
    Mv1= mean(V1(i,1:n));
    Md1= mean(D1(i,1:n));
    for j=1:n;
    if abs(H1(i,j))>abs(Mh1);
        H1(i,j)=Mh1;
    end
    if abs(V1(i,j))>abs(Mv1);
        V1(i,j)=Mv1;
    end
    if abs(D1(i,j))>abs(Md1);
        D1(i,j)=Md1;
    end
    end
end
 
%Dernière transformation inverse pour avoir l'image débruitée, puis
%affichage du résultat
Xt=iswt2(At1,H1,V1,D1,'bior3.3');
n=256;
map2=gray(n);
figure(1); image(X);colormap(map2);
figure(2); image(Xt);colormap(map2);
w=Xt;

Bonjour,

c'est déjà un peu plus clair.

Matlab est un logiciel de calcul matriciel optimisé pour travailler sur des matrices ou des vecteurs. On évite donc au maximum les boucles FOR-END imbriquées qui ne travaillent que sur des scalaires.

Voir la différence entre ces deux codes :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 H=rand(3,5)-rand(3,5); HH=H; % Copie de H for i=1:size(H,1) Mh=mean(H(i,:)) for j=1:size(H,2) if abs(H(i,j))>abs(Mh) H(i,j)=Mh; end end end for i=1:size(HH,1) Mh=mean(HH(i,:)); idx=abs(HH(i,:))>abs(Mh); HH(i,idx)=Mh; end H HH

16/03/2007, 11h22
risack

Merci,
c'est ce qui s'appelle programmer avec élégance.
16/03/2007, 11h29
Jerome Briot

Citation:

Envoyé par risack

c'est ce qui s'appelle programmer avec élégance.

Je dirais plutôt avec efficacité... peut-on voir le code modifié pour passer à la suite... je sais j'insiste mais un code DOIT être efficace ! Surtout si on peut y parvenir simplement.

Ajout des balises CODE

J ai effectué des tests de proche en proche pour arriver à une taille limite de 2144*2144 pixels (je dois avoir des images de dont la longueur et la largeur sont des multiples de 2^5); cette limite dépassée j'ai le message out of memory.
Voici le code modifié.

Code:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
function [w]= transfo_des_indiens (X);
 
%décomposition de la matrice image par une transformée discrète en
%ondelettes
%ici la décomposition s'effectue sur 5 niveaux
[A1,H1,V1,D1]=swt2(X,1,'bior3.3');
[A2,H2,V2,D2]=swt2(A1,1,'bior3.3');
[A3,H3,V3,D3]=swt2(A2,1,'bior3.3');
[A4,H4,V4,D4]=swt2(A3,1,'bior3.3');
[A5,H5,V5,D5]=swt2(A4,1,'bior3.3');
%fin de la décompostition
 
 
%moyennage des composantes détaillées des cinq niveaux(réduction du
%speckle)
%On commence par traiter les composantes du niveau 5
for i=1:size(X,1);
    Mh5= mean(H5(i,:));
    Mv5= mean(V5(i,:));
    Md5= mean(D5(i,:));
    idx=abs(H5(i,:))>Mh5;
    idx2=abs(V5(i,:))>Mv5;
    idx3=abs(D5(i,:))>Md5;
    H5(i,idx)=Mh5;
    V5(i,idx)=Mv5;
    D5(i,idx)=Md5;
end
 
%transformation inverse, passage du niveau de décomposition 5 au niveau de
%décomposition 4
At4=iswt2(A5,H5,V5,D5,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 4
for i=1:size(X,1);
    Mh4= mean(H4(i,:));
    Mv4= mean(V4(i,:));
    Md4= mean(D4(i,:));
    idx=abs(H4(i,:))>Mh4;
    idx2=abs(V4(i,:))>Mv4;
    idx3=abs(D4(i,:))>Md4;
    H4(i,idx)=Mh4;
    V4(i,idx)=Mv4;
    D4(i,idx)=Md4;
end
 
%transformation inverse, passage du niveau de décomposition 4 au niveau de
%décomposition 3
At3=iswt2(At4,H4,V4,D4,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 3
for i=1:size(X,1);
    Mh3= mean(H3(i,:));
    Mv3= mean(V3(i,:));
    Md3= mean(D3(i,:));
    idx=abs(H3(i,:))>Mh3;
    idx2=abs(V3(i,:))>Mv3;
    idx3=abs(D3(i,:))>Md3;
    H3(i,idx)=Mh3;
    V3(i,idx)=Mv3;
    D3(i,idx)=Md3;
end
 
%transformation inverse, passage du niveau de décomposition 3 au niveau de
%décomposition 2
At2=iswt2(At3,H3,V3,D3,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 2
for i=1:size(X,1);
    Mh2= mean(H2(i,:));
    Mv2= mean(V2(i,:));
    Md2= mean(D2(i,:));
    idx=abs(H2(i,:))>Mh2;
    idx2=abs(V2(i,:))>Mv2;
    idx3=abs(D2(i,:))>Md2;
    H2(i,idx)=Mh2;
    V2(i,idx)=Mv2;
    D2(i,idx)=Md2;
end
 
%transformation inverse, passage du niveau de décomposition 2 au niveau de
%décomposition 1
At1=iswt2(At2,H2,V2,D2,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 1
for i=1:size(X,1);
    Mh1= mean(H1(i,:));
    Mv1= mean(V1(i,:));
    Md1= mean(D1(i,:));
    idx=abs(H1(i,:))>Mh1;
    idx2=abs(V1(i,:))>Mv1;
    idx3=abs(D1(i,:))>Md1;
    H1(i,idx)=Mh1;
    V1(i,idx)=Mv1;
    D1(i,idx)=Md1;
end
 
%Dernière transformation inverse pour avoir l'image débruitée, puis
%affichage du résultat
Xt=iswt2(At1,H1,V1,D1,'bior3.3');
Err=X-Xt;
n=256;
map2=bone(n);
figure(1); image(X);colormap(map2);title('Image originale');
figure(2); image(Xt);colormap(map2);title('Image sans speckle');
figure(3); image(Err);colormap(map2);title('Bruit enlevé');
w=Xt;

Maintenant on va optimiser la mémoire.
Il y a trop de variables inutiles dans le programme.

Code:

1
2
3
4
5
6
7
8
9
10
11
for i=1:size(X,1);
    Mh5= mean(H5(i,:));
    Mv5= mean(V5(i,:));
    Md5= mean(D5(i,:));
    idx=abs(H5(i,:))>Mh5;
    idx2=abs(V5(i,:))>Mv5;
    idx3=abs(D5(i,:))>Md5;
    H5(i,idx)=Mh5;
    V5(i,idx)=Mv5;
    D5(i,idx)=Md5;
end

Mh5,Mv5,Md5 et idx,idx2,idx3 sont inutilement redondantes ici, donc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for i=1:size(X,1);
 
    Mhvd= mean(H5(i,:));
    idx=abs(H5(i,:))>Mhvd;
    H5(i,idx)=Mhvd;
 
    Mhvd= mean(V5(i,:));
    idx=abs(V5(i,:))>Mhvd;
    V5(i,idx)=Mhvd;
 
    Mhvd= mean(D5(i,:));
    idx=abs(D5(i,:))>Mhvd;
    D5(i,idx)=Mhvd;
end

Alors nouvelle modif du code selon les instructions. Je vais finir par avoir vraiment honte de mon code de départ ...... :?

nouvelle version

Code:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
function [w]= transfo_des_indiens (X);
 
%décomposition de la matrice image par une transformée discrète en
%ondelettes
%ici la décomposition s'effectue sur 5 niveaux
[A1,H1,V1,D1]=swt2(X,1,'bior3.3');
[A2,H2,V2,D2]=swt2(A1,1,'bior3.3');
[A3,H3,V3,D3]=swt2(A2,1,'bior3.3');
[A4,H4,V4,D4]=swt2(A3,1,'bior3.3');
[A5,H5,V5,D5]=swt2(A4,1,'bior3.3');
%fin de la décompostition
 
 
%moyennage des composantes détaillées des cinq niveaux(réduction du
%speckle)
%On commence par traiter les composantes du niveau 5
for i=1:size(X,1);
    Mhvd= mean(H5(i,:));
    idx=abs(H5(i,:))>Mhvd;
    H5(i,idx)=Mhvd;
 
    Mhvd= mean(V5(i,:));
    idx=abs(V5(i,:))>Mhvd;
    V5(i,idx)=Mhvd;
 
    Mhvd= mean(D5(i,:));
    idx=abs(D5(i,:))>Mhvd;
    D5(i,idx)=Mhvd;
end
 
%transformation inverse, passage du niveau de décomposition 5 au niveau de
%décomposition 4
At4=iswt2(A5,H5,V5,D5,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 4
for i=1:size(X,1);
    Mhvd= mean(H4(i,:));
    idx=abs(H4(i,:))>Mhvd;
    H4(i,idx)=Mhvd;
 
    Mhvd= mean(V4(i,:));
    idx=abs(V4(i,:))>Mhvd;
    V4(i,idx)=Mhvd;
 
    Mhvd= mean(D4(i,:));
    idx=abs(D4(i,:))>Mhvd;
    D4(i,idx)=Mhvd;
 
end
 
%transformation inverse, passage du niveau de décomposition 4 au niveau de
%décomposition 3
At3=iswt2(At4,H4,V4,D4,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 3
for i=1:size(X,1);
    Mhvd= mean(H3(i,:));
    idx=abs(H3(i,:))>Mhvd;
    H3(i,idx)=Mhvd;
 
    Mhvd= mean(V3(i,:));
    idx=abs(V3(i,:))>Mhvd;
    V3(i,idx)=Mhvd;
 
    Mhvd= mean(D3(i,:));
    idx=abs(D3(i,:))>Mhvd;
    D3(i,idx)=Mhvd;
 
end
 
%transformation inverse, passage du niveau de décomposition 3 au niveau de
%décomposition 2
At2=iswt2(At3,H3,V3,D3,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 2
for i=1:size(X,1);
    Mhvd= mean(H2(i,:));
    idx=abs(H2(i,:))>Mhvd;
    H2(i,idx)=Mhvd;
 
    Mhvd= mean(V2(i,:));
    idx=abs(V2(i,:))>Mhvd;
    V2(i,idx)=Mhvd;
 
    Mhvd= mean(D2(i,:));
    idx=abs(D2(i,:))>Mhvd;
    D2(i,idx)=Mhvd;
 
end
 
%transformation inverse, passage du niveau de décomposition 2 au niveau de
%décomposition 1
At1=iswt2(At2,H2,V2,D2,'bior3.3');
 
%réduction du speckle sur les coefficients de la décomposition au niveau 1
for i=1:size(X,1);
    Mhvd= mean(H1(i,:));
    idx=abs(H1(i,:))>Mhvd;
    H1(i,idx)=Mhvd;
 
    Mhvd= mean(V1(i,:));
    idx=abs(V1(i,:))>Mhvd;
    V1(i,idx)=Mhvd;
 
    Mhvd= mean(D1(i,:));
    idx=abs(D1(i,:))>Mhvd;
    D1(i,idx)=Mhvd;
 
end
 
%Dernière transformation inverse pour avoir l'image débruitée, puis
%affichage du résultat
Xt=iswt2(At1,H1,V1,D1,'bior3.3');
Err=X-Xt;
n=256;
map2=bone(n);
figure(1); image(X);colormap(map2);title('Image originale');
figure(2); image(Xt);colormap(map2);title('Image sans speckle');
figure(3); image(Err);colormap(map2);title('Bruit enlevé');
w=Xt;

16/03/2007, 13h10
risack

Je viens de tester, ça passe maintenant à 2176*2176. Cool!!
16/03/2007, 14h27
Jerome Briot

Donc, maintenant dans le même ordre d'idée, est-il nécessaire d'avoir A1...5, H1...5, V1...5, D1...5 en permanence dans le code ?

Il serait judicieux de les enregister, de supprimer ces varaibles et de ne les charger que si besoin

Et surtout, je viens de m'en apercevoir, supprimer la variable inutile "w" et mettre Xt en sortie de la fonction !
16/03/2007, 16h14
risack
Alors je suppose que ce n'est pas une vrai question mais plutot une manière de me dire "essaye de trouver les réponses seul".
J'ai essayé; mais j'en arrive à vouloir programmer une boucle for suivant le schéma
Code:

1 2 3 4 for i=1:5; A=swt2(A,1,'bior3.3'); end
pour ensuite effectuer la reconstruction de l'image. Et je crois pas que ça me fasse gagner en espace mémoire cette affaire.
16/03/2007, 16h18
risack

je me suis planté au niveau de la boucle for.
Au lieu de

Code:

A=swt2(A,1,'bior3.3');

lire

Code:

[A,H,V,D]=swt2(A,1,'bior3.3');

En fait voici mon code complet modifié

Code:

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
 
function [Xt]= transfo_des_indiens (X);
 
A=X;
for i=1:5;
    [A,H,V,D]=swt2(A,1,'bior3.3');
end
 
 
 
for j=1:5;
for i=1:size(X,1);
    Mhvd= mean(H(i,:));
    idx=abs(H(i,:))>Mhvd;
    H(i,idx)=Mhvd;
 
    Mhvd= mean(V(i,:));
    idx=abs(V(i,:))>Mhvd;
    V(i,idx)=Mhvd;
 
    Mhvd= mean(D(i,:));
    idx=abs(D(i,:))>Mhvd;
    D(i,idx)=Mhvd;
end
A=iswt2(A,H,D,V,1,'bior3.3');
end
 
Err=X-A;
n=256;
map2=gray(n);
figure(1); image(X);colormap(map2);title('Image originale');
figure(2); image(A);colormap(map2);title('Image sans speckle');
figure(3); image(Err);colormap(map2);title('Bruit enlevé');

Désolé pas eu le temps de remettre les commentaires

On peut écraser X ici. Il n'est pas nécessaire de le dupliquer.
Pourquoi ne pas faire ceci :

Code:

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
function X= transfo_des_indiens (X);
 
%décomposition de la matrice image par une transformée discrète en
%ondelettes
%ici la décomposition s'effectue sur N niveaux
 
N=5;
 
for n=1:N
 
	[X,H,V,D]=swt2(X,1,'bior3.3');
	fname=sprintf('decomp%d.mat',n);
	save(fname,'H','V','D')
 
end
 
for n=N:-1:1
 
	fname=sprintf('decomp%d.mat',n);
	load(fname)
 
	for i=1:size(X,1);
 
        Mhvd= mean(H(i,:));
        idx=abs(H(i,:))>Mhvd;
        H(i,idx)=Mhvd;
 
        Mhvd= mean(V(i,:));
        idx=abs(V(i,:))>Mhvd;
        V(i,idx)=Mhvd;
 
        Mhvd= mean(D(i,:));
        idx=abs(D(i,:))>Mhvd;
        D(i,idx)=Mhvd;
 
	end
 
	X=iswt2(X,H,V,D,'bior3.3');
 
end

Mettre toute les commandes de vérification et de dessin dans une autre fonction à part.

19/03/2007, 09h36
risack

ok merci beaucoup du coup de main.