Optimisation de fonction pour programme qui tourne 1 heure !

**TopCao** · 30/01/2010, 19h13

Bonjour à tous !

Pour rappel je suis débutant en MatLab (depuis 1 semaine)

J'ai donc concu un script qui va chercher des images, les convertit en matrice puis appelle une fonction.
Celle-ci réalise une opération de fitting sur les pixels sélectionnés.

Ca marche à merveille.. SAUF QUE ca me prend presque une heure pour une série de 48 images de 128x128 pixels..... (3200 secondes...)

Alors j'imagine que mon code est hautement optimisable et que je peux gagner des minutes mais je ne vois pas trop ou...

Donc pour être pragmatique :
- est ce que quelqu'un voit une/des ligne(s) que je peux raccourcir d'une façon ou d'une autre ?
- est il judicieux d'aller chercher des fonctions de multi-threading ?
- ai-je un intérêt à "compiler" le prog ou autre ?

MERCI A TOUS !!!

Mon script :

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
%
%  Algorithme d'extraction compartimentale par fitting
%
 
% Vide toute la mémoire pour plus de clareté
clear all;
close all;
clc ;
 
% Initialise le timer
tic;
 
%% Place les images en mémoire
diff01 =  dicomread('diff01.dcm'); diff02 =  dicomread('diff02.dcm'); 
diff03 =  dicomread('diff03.dcm'); diff04 =  dicomread('diff04.dcm');
diff05 =  dicomread('diff05.dcm'); diff06 =  dicomread('diff06.dcm');
diff07 =  dicomread('diff07.dcm'); diff08 =  dicomread('diff08.dcm');
diff09 =  dicomread('diff09.dcm'); diff10 =  dicomread('diff10.dcm');
diff11 =  dicomread('diff11.dcm'); diff12 =  dicomread('diff12.dcm');
diff13 =  dicomread('diff13.dcm'); diff14 =  dicomread('diff14.dcm');
diff15 =  dicomread('diff15.dcm'); diff16 =  dicomread('diff16.dcm');
diff17 =  dicomread('diff17.dcm'); diff18 =  dicomread('diff18.dcm'); 
diff19 =  dicomread('diff19.dcm'); diff20 =  dicomread('diff20.dcm');
diff21 =  dicomread('diff21.dcm'); diff22 =  dicomread('diff22.dcm');
diff23 =  dicomread('diff23.dcm'); diff24 =  dicomread('diff24.dcm');
diff25 =  dicomread('diff25.dcm'); diff26 =  dicomread('diff26.dcm');
diff27 =  dicomread('diff27.dcm'); diff28 =  dicomread('diff28.dcm');
diff29 =  dicomread('diff29.dcm'); diff30 =  dicomread('diff30.dcm');
diff31 =  dicomread('diff31.dcm'); diff32 =  dicomread('diff32.dcm');
diff33 =  dicomread('diff33.dcm'); diff34 =  dicomread('diff34.dcm'); 
diff35 =  dicomread('diff35.dcm'); diff36 =  dicomread('diff36.dcm');
diff37 =  dicomread('diff37.dcm'); diff38 =  dicomread('diff38.dcm');
diff39 =  dicomread('diff39.dcm'); diff40 =  dicomread('diff40.dcm');
diff41 =  dicomread('diff41.dcm'); diff42 =  dicomread('diff42.dcm');
diff43 =  dicomread('diff43.dcm'); diff44 =  dicomread('diff44.dcm');
diff45 =  dicomread('diff45.dcm'); diff46 =  dicomread('diff46.dcm');
diff47 =  dicomread('diff47.dcm'); diff48 =  dicomread('diff48.dcm');
 
% Prépare les 6 images paramétriques
imageA1(128,128) = 0;
imageA2(128,128) = 0;
imageA3(128,128) = 0;
imageB1(128,128) = 0;
imageB2(128,128) = 0;
imageB3(128,128) = 0;
 
% Déclare les valeurs de b
XVAL = 0 : 100: 4700  ;
XVAL = XVAL(:);
 
% Compteur
i=0;x0=24;xinc=2;xmax=104;y0=10;yinc=2;ymax=119;
ndata=((xmax-x0)/xinc)*((ymax-y0)/yinc)/100;
 
 
% Pour Chaque pixel 
for x= [x0:xinc:xmax]                                                            %;for x=[27:103];
    for y= [y0:yinc:ymax]                                                        %for y=[12:120]
i = i + 1;
% Crée un tableau contenant les différentes valeur du signal en (x,y)
experimentalValue = [diff01(x,y) diff02(x,y) diff03(x,y)  diff04(x,y)...
    diff05(x,y) diff06(x,y) diff07(x,y) diff08(x,y) diff09(x,y)...
    diff10(x,y) diff11(x,y) diff12(x,y) diff13(x,y) diff14(x,y)...
    diff15(x,y) diff16(x,y) diff17(x,y) diff18(x,y) diff19(x,y)...
    diff20(x,y) diff21(x,y) diff22(x,y) diff23(x,y) diff24(x,y)...
    diff25(x,y) diff26(x,y) diff27(x,y) diff28(x,y) diff29(x,y)...
    diff30(x,y) diff31(x,y) diff32(x,y) diff33(x,y) diff34(x,y)...
    diff35(x,y) diff36(x,y) diff37(x,y) diff38(x,y) diff39(x,y)...
    diff40(x,y) diff41(x,y) diff42(x,y) diff43(x,y) diff44(x,y)...
    diff45(x,y) diff46(x,y) diff47(x,y) diff48(x,y) ];
 
% Convertit ce tableau en doulbe
YVAL = double(experimentalValue) ;
 
% Fit les données contenues dans le tableau experimentalValue
paramValue = createFit(XVAL,YVAL);
 
% Insère les valeurs des paramètres retournés dans les matrices image
imageA1(x,y) = paramValue(1);
imageA2(x,y) = paramValue(2);
imageA3(x,y) = paramValue(3);
imageB1(x,y) = paramValue(4);
imageB2(x,y) = paramValue(5);
imageB3(x,y) = paramValue(6);
 
 
 
clc;
i/ndata
    end
end
 
imageA1 = uint16(imageA1);
imageA2 = uint16(imageA2);
imageA3 = uint16(imageA3);
 
% Créé 6 fichiers DICOM paramétriques
dicomwrite(imageA1, '#imageA1.dcm');
dicomwrite(imageA2, '#imageA2.dcm');
dicomwrite(imageA3, '#imageA3.dcm');
dicomwrite(imageB1, '#imageB1.dcm');
dicomwrite(imageB2, '#imageB2.dcm');
dicomwrite(imageB3, '#imageB3.dcm');
 
 
 
% retourne le timer
toc

Ma fonction de fitting

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
 
function [paramVAL] = createFit(XVAL,YVAL)
 
% Ligne -> colonne
 
YVAL = YVAL(:);                                                             
 
% CONDITIONS POUR GAGNER PLEIN DE TEMPS
if YVAL(1) < 50; % Le bruit retourne du bruit
    paramVAL = [0 0 0 0 0 0 0];
 
elseif YVAL(1) > 200 ;
    fo_ = fitoptions('method','NonlinearLeastSquares',...
        'MaxFunEvals',600,'MaxIter',400,...
        'Lower',[  8   8 128 0.0001 0.0001 0.0001 10],...                                       
        'Upper',[inf inf inf   0.01   0.01   0.01 14]);
 
    ok_ = isfinite(XVAL) & isfinite(YVAL);
    if ~all( ok_ )
        warning( 'GenerateMFile:IgnoringNansAndInfs', ...
            'Ignoring NaNs and Infs in data' );
    end
    st_ = [8 8 300 0.0001 0.0002 0.003 12];                                       
    set(fo_,'Startpoint',st_);
    ft_ = fittype('a1*exp(-b1*x)+a2*exp(-b2*x)+a3*exp(-b3*x)+noise',...
        'dependent',{'y'},'independent',{'x'},...
        'coefficients',{'a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'noise'});
 
    % Fit this model using new data
    cf_ = fit(XVAL(ok_),YVAL(ok_),ft_,fo_);                                 
 
    % Or use coefficients from the original fit:
    if 0
       cv_ = {9,9,300,0.0001,0.0001,0.003,12};
       cf_ = cfit(ft_,cv_{:});
    end
    paramVAL = coeffvalues (cf_);
 
else   
    A1 = 0.6 * YVAL(1);
    A2 = 0.3 * YVAL(1);
    A3 = 0.05 * YVAL(1);
    B1 = 1 * log(YVAL(1)/YVAL(48))/4700;
    B2 = 2 * log(YVAL(1)/YVAL(48))/4700;
    B3 = 3 * log(YVAL(1)/YVAL(48))/4700;
    NOISE =  0.05 * YVAL(1);
    MIN = 0.1 * YVAL(1);
    MAX = YVAL(1);
 
    fo_ = fitoptions('method','NonlinearLeastSquares',...
        'DiffMinChange',1.0e-08,...
        'DiffMaxChange',0.1,...
        'MaxFunEvals',600,'MaxIter',400,...
        'TolFun',1.0e-06,'TolX',1.0e-06,...
        'Lower',[MIN MIN MIN 0.0001 0.0001 0.0001 10],...                                       
        'Upper',[MAX MAX MAX   0.01   0.01   0.01 14]);                         % Valeur min des paramètres
 
    ok_ = isfinite(XVAL) & isfinite(YVAL);
    if ~all( ok_ )
        warning( 'GenerateMFile:IgnoringNansAndInfs', ...
            'Ignoring NaNs and Infs in data' );
    end
    st_ = [A1 A2 A3 B1 B2 B3 NOISE];                                     % Valeur d'initialisation des paramètres
    set(fo_,'Startpoint',st_);
    ft_ = fittype('a1*exp(-b1*x)+a2*exp(-b2*x)+a3*exp(-b3*x)+noise',...
        'dependent',{'y'},'independent',{'x'},...
        'coefficients',{'a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'noise'});
 
    % Fit this model using new data
    cf_ = fit(XVAL(ok_),YVAL(ok_),ft_,fo_);                                     % opération de fitting
 
    % Or use coefficients from the original fit:
  %  if 0
   %    cv_ = {110,35,6,0.001,0.002,0.003,10};
   %    cf_ = cfit(ft_,cv_{:});
   % end
 
    paramVAL = coeffvalues (cf_);
 
 
 
end

**kmaniche** · 30/01/2010, 21h19

J'ai regardé ton code, et là je peux te dire qu'il ya du travail. Par exemple :

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
 
%% Place les images en mémoire
diff01 =  dicomread('diff01.dcm'); diff02 =  dicomread('diff02.dcm'); 
diff03 =  dicomread('diff03.dcm'); diff04 =  dicomread('diff04.dcm');
diff05 =  dicomread('diff05.dcm'); diff06 =  dicomread('diff06.dcm');
diff07 =  dicomread('diff07.dcm'); diff08 =  dicomread('diff08.dcm');
diff09 =  dicomread('diff09.dcm'); diff10 =  dicomread('diff10.dcm');
diff11 =  dicomread('diff11.dcm'); diff12 =  dicomread('diff12.dcm');
diff13 =  dicomread('diff13.dcm'); diff14 =  dicomread('diff14.dcm');
diff15 =  dicomread('diff15.dcm'); diff16 =  dicomread('diff16.dcm');
diff17 =  dicomread('diff17.dcm'); diff18 =  dicomread('diff18.dcm'); 
diff19 =  dicomread('diff19.dcm'); diff20 =  dicomread('diff20.dcm');
diff21 =  dicomread('diff21.dcm'); diff22 =  dicomread('diff22.dcm');
diff23 =  dicomread('diff23.dcm'); diff24 =  dicomread('diff24.dcm');
diff25 =  dicomread('diff25.dcm'); diff26 =  dicomread('diff26.dcm');
diff27 =  dicomread('diff27.dcm'); diff28 =  dicomread('diff28.dcm');
diff29 =  dicomread('diff29.dcm'); diff30 =  dicomread('diff30.dcm');
diff31 =  dicomread('diff31.dcm'); diff32 =  dicomread('diff32.dcm');
diff33 =  dicomread('diff33.dcm'); diff34 =  dicomread('diff34.dcm'); 
diff35 =  dicomread('diff35.dcm'); diff36 =  dicomread('diff36.dcm');
diff37 =  dicomread('diff37.dcm'); diff38 =  dicomread('diff38.dcm');
diff39 =  dicomread('diff39.dcm'); diff40 =  dicomread('diff40.dcm');
diff41 =  dicomread('diff41.dcm'); diff42 =  dicomread('diff42.dcm');
diff43 =  dicomread('diff43.dcm'); diff44 =  dicomread('diff44.dcm');
diff45 =  dicomread('diff45.dcm'); diff46 =  dicomread('diff46.dcm');
diff47 =  dicomread('diff47.dcm'); diff48 =  dicomread('diff48.dcm');

Peut être remplacé par :

Code :

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

1
2
3
4
5
6
 
 
diff = zeros(128,128,48) ;
for i =1:48,
 diff(:,:,i) = dicomread(['diff' num2str(48) '.dcm');
end

Code :

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

1
2
3
4
5
6
7
8
 
% Prépare les 6 images paramétriques
imageA1(128,128) = 0;
imageA2(128,128) = 0;
imageA3(128,128) = 0;
imageB1(128,128) = 0;
imageB2(128,128) = 0;
imageB3(128,128) = 0;

Par :

Code :

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

1
2
3
4
5
6
7
8
 
% Prépare les 6 images paramétriques
imageA1 = zeros(128,128) ;
imageA2 = zeros(128,128) ;
imageA3 = zeros(128,128) ;
imageB1 = zeros(128,128) ;
imageB2 = zeros(128,128) ;
imageB3 = zeros(128,128) ;

**Caro-Line** · 30/01/2010, 22h36

Quelques remarques.

Sur ce qu'a dit kmaniche :

Code :

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

1
2
3
4
diff = zeros(128,128,48) ;
for i =1:48,
 diff(:,:,i) = dicomread(['diff' num2str(48) '.dcm');
end

Pour avoir l'écriture 01, 02 ... c'est plutôt (voir faq) :

Code :

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

1
2
3
4
diff = zeros(128,128,48) ;
for i =1:48,
 diffIm(:,:,i) = dicomread(sprintf('diff%02d.dcm',i));
end

(J'ai changé aussi le nom de la variable car DIFF est une fonction de MATLAB)
Il s'agit ici d'optimisation en nombre de lignes, il n'y aura pas je pense de gain de temps.
Par contre le fait d'avoir une seule variable au lieu de plusieurs peut jouer.
Il faut aussi être sur (je ne connais pas le format DICOM) que ce qui est retourné est un tableau n*m

Pareil il faudrait vérifier qu'il y a vraiment un gain de temps entre :

Code :

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

imageA1(128,128) = 0;

et

Code :

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

imageA1 = zeros(128,128) ;

qui fait la même chose.
Et de même tu peux créer une seule variable plutôt que 6 :

Code :

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

res_image=zeros(128,128,6);

Ce qui est intéressant c'est que du coup la suite s'écrit ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
% Pour Chaque pixel 
for x= x0:xinc:xmax  %;for x=27:103;
    for y= y0:yinc:ymax    %for y=12:120
        i = i + 1;
        % Crée un tableau contenant les différentes valeur du signal en (x,y)
        YVAL = double(diffIm(x,y,:));
 
        % Fit les données contenues dans le tableau experimentalValue
        paramValue = createFit(XVAL,YVAL);
 
        % Insère les valeurs des paramètres retournés dans les matrices image
        for k=1:6
           res_image(x,y,k) = paramValue(k);
        end

Je ne comprends pas l'utilité de ces 2 lignes (ni de la variable i au passage) :

Code :

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

1
2
clc;
i/ndata

C'est pour vérification ?

Quelques conseils pour nous aider à t'aider :

indente proprement ton code : sous l'éditeur de MATLAB il suffit de faire CTRL+A puis CTRL+I et le tour est joué
met une seule instruction par ligne

**TopCao** · 31/01/2010, 16h08

Salut,

Merci pour vos conseils.
Ca marche bien d'autant que j'ai simplifié l'algorithme de fitting et que je teste un peu sur le tas le nombre d'itérations nécessaires à la résolution de mon problème.

Pour répondre aux questions :
- Je n'ai pas de gain de temps entre

Code :

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

imageA1(128,128) = 0;

et

Code :

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

imageA1 = zeros(128,128) ;

- Avec le code suivant j'affiche le pourcentage d'éxécution de ma boucle et je rafraichi l'écran à chaque affichage. Ca me permet de savoir si j'ai le temps d'aller me chercher un coca, faire la sieste ou aller me ballader...

Code :

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

1
2
clc;
i/ndata

Je n'ai pas trouvé mieux (pas beaucoup cherché en fait)
D'ailleurs si vous avez une méthode plus simple je suis preneur.

Sinon j'ai éclairci et indenté le code grace au super ctrl + i de Caro-Line !

Je cherche encore comment optimiser, mais je pense que ca passe par la modification de la fonction "fit" en elle même

Voici le code tel que je le fais tourner actuellement :

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
%
%  Algorithme d'extraction compartimentale par fitting
%
 
% Vide toute la mémoire pour plus de clareté
clear all; close all; clc ;
 
% Initialise le timer
tic;
 
%% Place les images en mémoire dans une matrice image
diffIm = zeros(128,128,48) ;
for i =1:48,
    diffIm(:,:,i) = dicomread(sprintf('diff%02d.dcm',i));
end
 
% Prépare les 6 images paramétriques
res_image=zeros(128,128,6);
 
% Déclare les valeurs de b
XVAL = 0 : 100: 4700  ;
XVAL = XVAL(:);
 
% Compteur d'itérations
i=0;x0=24;xinc=1;xmax=104;y0=10;yinc=1;ymax=119;
ndata=((xmax-x0)/xinc)*((ymax-y0)/yinc)/100;
 
 
% Pour Chaque pixel
for x= x0:xinc:xmax
    for y= y0:yinc:ymax
        i = i + 1;
        % Crée un tableau contenant les différentes valeur du signal en (x,y)
        YVAL = double(diffIm(x,y,:));
 
        % Fit les données contenues dans le tableau experimentalValue
        paramValue = createFit(XVAL,YVAL);
 
        % Insère les valeurs des paramètres retournés dans une matrice
        for k=1:6
            res_image(x,y,k) = paramValue(k);
        end
 
        % Affiche le % d'itérations de la double boucle déja effectué
        clc;
        i/ndata
    end
end
 
 
% Ecrit les images dans divers formats
dicomwrite(uint16(res_image(:,:,1)), '#imageA1-u16.dcm');
dicomwrite(uint16(res_image(:,:,2)), '#imageA2-u16.dcm');
dicomwrite(uint16(res_image(:,:,3)), '#imageA3-u16.dcm');
 
dicomwrite(uint8(res_image(:,:,1)),  '#imageA1-u8.dcm');
dicomwrite(uint8(res_image(:,:,2)),  '#imageA2-u8.dcm');
dicomwrite(uint8(res_image(:,:,3)),  '#imageA3-u8.dcm');
 
dicomwrite(res_image(:,:,1),  '#imageA1-db.dcm');
dicomwrite(res_image(:,:,2),  '#imageA2-db.dcm');
dicomwrite(res_image(:,:,3),  '#imageA3-db.dcm');
 
dicomwrite(uint16(res_image(:,:,4)), '#imageB1-u16.dcm');
dicomwrite(uint16(res_image(:,:,5)), '#imageB2-u16.dcm');
dicomwrite(uint16(res_image(:,:,6)), '#imageB3-u16.dcm');
 
dicomwrite(uint8(res_image(:,:,4)), '#imageB1-u16.dcm');
dicomwrite(uint8(res_image(:,:,5)), '#imageB2-u16.dcm');
dicomwrite(uint8(res_image(:,:,6)), '#imageB3-u16.dcm');
 
dicomwrite(res_image(:,:,4),  '#imageB1-db.dcm');
dicomwrite(res_image(:,:,5),  '#imageB2-db.dcm');
dicomwrite(res_image(:,:,6),  '#imageB3-db.dcm');
 
% retourne le timer
toc

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
function [paramVAL] = createFit(XVAL,YVAL)
 
% Ligne -> colonne
YVAL = YVAL(:);
 
% CONDITIONS POUR GAGNER PLEIN DE TEMPS
if YVAL(1) < 50; % BRUIT
    paramVAL = [0 0 0 0 0 0 0];
 
elseif YVAL(1) > 200 ; % CSF
    paramVAL = [9 9 256 0.001 0.001 0.003 12];
 
else   % PARENCHYME
    A1 = 0.6 * YVAL(1);
    A2 = 0.3 * YVAL(1);
    A3 = 0.05 * YVAL(1);
    B1 = 1 * log(YVAL(1)/YVAL(10))/4700;
    B2 = 2 * log(YVAL(1)/YVAL(10))/4700;
    B3 = 3 * log(YVAL(1)/YVAL(10))/4700;
    fo_ = fitoptions('method','NonlinearLeastSquares',...
        'Algorithm', 'levenberg-marquardt',...
        'DiffMinChange',1.0e-08,...
        'DiffMaxChange',0.1,...
        'MaxFunEvals',20,'MaxIter',20,...                                     ù'MaxFunEvals',600,'MaxIter',400,...
        'TolFun',1.0e-06,'TolX',1.0e-06,...
        'Lower',[  0   0   0 0 0 0 10],...
        'Upper',[inf inf inf 1 1 1 14]);                         % Valeur min des paramètres
 
    ok_ = isfinite(XVAL) & isfinite(YVAL);
    if ~all( ok_ )
        warning( 'GenerateMFile:IgnoringNansAndInfs', ...
            'Ignoring NaNs and Infs in data' );
    end
    st_ = [A1 A2 A3 B1 B2 B3 12];                                     % Valeur d'initialisation des paramètres
    set(fo_,'Startpoint',st_);
    ft_ = fittype('a1*exp(-b1*x)+a2*exp(-b2*x)+a3*exp(-b3*x)+noise',...
        'dependent',{'y'},'independent',{'x'},...
        'coefficients',{'a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'noise'});
 
    % Fit this model using new data
    cf_ = fit(XVAL(ok_),YVAL(ok_),ft_,fo_);                                     % opération de fitting
 
 
    % Or use coefficients from the original fit:
    %  if 0
    %    cv_ = {110,35,6,0.001,0.002,0.003,10};
    %    cf_ = cfit(ft_,cv_{:});
    % end
 
    paramVAL = coeffvalues (cf_);
end

Je suis toujours preneur d'astuces

Merci pour les conseils déja prodigués !

**Caro-Line** · 31/01/2010, 16h39

Plus grand chose à dire sur la 1ère fonction à part que tu pourrais aussi faire des boucles pour les DICOMWRITE (gain d'écriture mais pas de temps).

Pour la 2ème une toute petite optimisation :

Code :

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

1
2
3
4
5
6
7
8
else   % PARENCHYME
    st_(1) = 0.6 * YVAL(1);
    st_(2) = 0.3 * YVAL(1);
    st_(3) = 0.05 * YVAL(1);    
    st_(4) = 1 * log(YVAL(1)/YVAL(10))/4700;
    st_(5) = 2 * st_(4);
    st_(6) = 3 * st_(4);
    st_(7) = 12;

Ensuite il te reste à utiliser le PROFILER, plus efficace que le TIC/TOC pour savoir quelles sont les lignes les plus gourmandes.

**kmaniche** · 31/01/2010, 20h12

Avec le code suivant j'affiche le pourcentage d'éxécution de ma boucle et je rafraichi l'écran à chaque affichage. Ca me permet de savoir si j'ai le temps d'aller me chercher un coca, faire la sieste ou aller me ballader...
Code :

clc;
i/ndata

Je n'ai pas trouvé mieux (pas beaucoup cherché en fait)
D'ailleurs si vous avez une méthode plus simple je suis preneur.

Allez, je donne un truc très utile :

Code :

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

1
2
 
>> doc waitbar

Je te laisse découvrir ...

**kmaniche** · 31/01/2010, 20h19

Sinon, pour un affichage plus optimal des chiffres, textes et plus :

Code :

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

1
2
 
>> doc sprintf

**Jerome Briot** · 31/01/2010, 20h59

Envoyé par kmaniche

Allez, je donne un truc très utile :

Code :

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

1
2
 
>> doc waitbar

Je déconseille fortement l'utilisation de la fonction WAITBAR qui est généralement très gourmande en temps...

Faire une petite recherche sur le FEX pour des contributions plus légères...

**TopCao** · 31/01/2010, 21h03

Envoyé par kmaniche

Allez, je donne un truc très utile :

Code :

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

1
2
 
>> doc waitbar

Je te laisse découvrir ...

Ouh mais c'est fameux ça !!!!

Bon alors maintenant je galère pour autre chose

Vous aurez peut-être une idée :

Donc le prog retourne la matrice res_image qui contient la valeur des paramètres dans chaque pixel.

Comme vous avez vu j'écris le résultat dans un fichier dicom. Mais pour optimiser l'image, je souhaiterai modifier les valeurs de la matrice pour que 95% des valeurs soient comprises entre 0 et 255 selon une règle de 3 toute bête.

J'ai procédé de plusieurs manière en faisant

Code :

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

imageB1 = 255 * res_image(:,:,4) / max(max(res_image(:,:,4)));

Cela décale mon histogramme vers le blanc.
Je voudrais faire la même transformation vers le noir sauf que min(min()) va forcément me retourner 0 puisque le bruit est converti en 0 dans mon algo. Il faudrait donc que j'accède à la valeur juste au dessus de 0 dans la matrice. Je n'ai pas trouvé.
Du coup je me suis penché sur le traitement d'image direct. J'ai trouvé une fonction d'égalisation d'histogramme 'histeq' qui ne fonction que sur une matrice uint8 mais même après conversion les résultats ne sont pas probants....
Si vous avez une idée... comme d'habitude je suis preneur !

**kmaniche** · 31/01/2010, 21h11

Il y a un truc qui peut t'aider, regarde la FAQ il y a un exemple

**Caro-Line** · 31/01/2010, 21h28

Je ne suis pas sure du tout de comprendre ce que tu veux faire, mais pour trouver le min(min) en ignorant les zéros :

Code :

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

min(min(res_image(:,:,4)~=0))

**TopCao** · 31/01/2010, 21h29

Envoyé par kmaniche

Il y a un truc qui peut t'aider, regarde la FAQ il y a un exemple

Bah c'est exactement ce que j'avais fait... sauf que ma matrice est déja pleine de 0 comme je disais. Donc Min() retourne toujours 0 ! Je voudrais accéder à la valeur au dessus de 0...

**TopCao** · 31/01/2010, 21h30

Envoyé par Caro-Line

Je ne suis pas sure du tout de comprendre ce que tu veux faire, mais pour trouver le min(min) en ignorant les zéros :

Code :

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

min(min(res_image(:,:,4)~=0))

C'est exactement ça !
Redistribuer mes valeurs sur un intervalle [0;255] en excluant ce qui est déja à 0. C'est en gros une égalisation d'histogramme...

Merci !!

**TopCao** · 01/02/2010, 00h19

En fait ca ne marche pas... :

Code :

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

1
2
3
4
5
6
 
EDU>> min(min(res_image(:,:,4)~=0))
 
ans =
 
     0

**Jerome Briot** · 01/02/2010, 08h40

Envoyé par TopCao

Je voudrais faire la même transformation vers le noir sauf que min(min()) va forcément me retourner 0 puisque le bruit est converti en 0 dans mon algo. Il faudrait donc que j'accède à la valeur juste au dessus de 0 dans la matrice. Je n'ai pas trouvé.

Dans ce cas, met ces valeurs à NaN plutôt qu'à 0. Elles ne seront plus prises en compte par la suite :

Code :

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

1
2
3
4
5
>> min([nan nan 2 7 4 nan 6 1 nan])
 
ans =
 
     1

Envoyé par TopCao

Code :

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

1
2
3
4
5
 
        % Insère les valeurs des paramètres retournés dans une matrice
        for k=1:6
            res_image(x,y,k) = paramValue(k);
        end

Cette boucle est inutile :

Code :

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

res_image(x,y,:) = paramValue;

Et comme l'a déjà dit caroline, pense à utiliser le profiler de MATLAB.

Je ne serais pas étonné que ce soit les fonction de lecture/écriture des fichier DICOM qui ralentissent le code

**Caro-Line** · 01/02/2010, 08h41

Oups....(je n'ai pas MATLAB pour tester, il m'arrive de cafouiller

)

On va être obligé de passer par une variable intermédiaire ici

Code :

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

1
2
maMat = res_image(:,:,4);
min(maMat(maMat~=0))

1 seul MIN est nécessaires, car (à vérifier) maMat~=0 doit donner un vecteur d'indices logiques.

**TopCao** · 01/02/2010, 10h25

Envoyé par Dut

Cette boucle est inutile :

Code :

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

res_image(x,y,:) = paramValue;

Pourquoi cette boucle est elle inutile ?
Il faut bien que j'écrive les résultats quelque part non ?

**Jerome Briot** · 01/02/2010, 10h26

Envoyé par TopCao

Pourquoi cette boucle est elle inutile ?
Il faut bien que j'écrive les résultats quelque part non ?

Je voulais dire qu'il suffisait de remplacer la boucle par la ligne que j'ai donnée dessous

**TopCao** · 01/02/2010, 10h42

Voilà ce que me retourne le profiler :

En gros c'est ma boucle de fit qui me prend tout le temps si je comprends bien

Envoyé par Dut

Je voulais dire qu'il suffisait de remplacer la boucle par la ligne que j'ai donnée dessous

Ah pardon je n'avais pas compris

**Jerome Briot** · 01/02/2010, 10h59

Envoyé par TopCao

En gros c'est ma boucle de fit qui me prend tout le temps si je comprends bien

Oui... et ça va être difficilement compressible

On peut déjà gagner du temps en sortant la construction des variables fo_ et ft_ de la fonction CREATEFIT et les placer avant les 2 boucles FOR-END du programme principale et les passer en arguments de la fonction CREATEFIT

Sinon, il faudrait penser à recoder tout à la main sans utiliser FIT (si c'est envisageable !)

Optimisation de fonction pour programme qui tourne 1 heure ! [Débutant]

MATLAB

Discussions similaires

Partager

Partager