Optimiser un code pour éviter " out of memory"

**risack** · 15/03/2007, 15h39

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 :

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
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;

**tug83** · 15/03/2007, 15h50

As tu regardé :
http://www.mathworks.com/support/tec...00/1106.html#1

**Jerome Briot** · 15/03/2007, 16h02

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 :

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

1
2
3
4
5
if a<=1
   a=a;
else
   a=0;
end

peut simplement s'écrire :

Code :

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

1
2
3
if a>1
   a=0;
end

Peux-tu poster ton code simplifié ?

**risack** · 16/03/2007, 09h40

Voilà le code avec simlification des "if"

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
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;

**Jerome Briot** · 16/03/2007, 10h09

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 :

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
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

**risack** · 16/03/2007, 11h22

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

**Jerome Briot** · 16/03/2007, 11h29

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.

**risack** · 16/03/2007, 11h41

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 :

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
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;

**Jerome Briot** · 16/03/2007, 12h05

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

Code :

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

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 :

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

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

**risack** · 16/03/2007, 12h58

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

nouvelle version

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
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;

**risack** · 16/03/2007, 13h10

Je viens de tester, ça passe maintenant à 2176*2176. Cool!!

**Jerome Briot** · 16/03/2007, 14h27

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 !

**risack** · 16/03/2007, 16h14

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 :

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

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.

**risack** · 16/03/2007, 16h18

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

Code :

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

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

lire

Code :

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

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

**risack** · 16/03/2007, 16h33

En fait voici mon code complet modifié

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
 
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

**Jerome Briot** · 16/03/2007, 16h33

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

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
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.

**risack** · 19/03/2007, 09h36

ok merci beaucoup du coup de main.

Optimiser un code pour éviter " out of memory"

MATLAB

Discussions similaires

Partager

Partager