Discussion :

[sakona]

Bonjour à toutes et à tous

Dans le cadre d'un traitement d'images, je cherche à réduire le temps de traitement que met le programme.

Je partage avec vous le programme pour m'aider si vous voyez des améliorations à apporter afin d'éliminer les calculs inutiles ou de remplacer les instructions qui ajoutent une charge en terme de temps.

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
 
        Ddynamic = zeros(size(leftI), 'single');
        finf = 1e3; 
        disparityCost = finf*ones(size(leftI,2), 2*disparityRange + 1, 'single');
        disparityPenalty = 0.5;
        hWaitBar = waitbar(0,'Utilisation de la programmation dynamique pour le lissage...');
        for m=1:nRowsLeft
            disparityCost(:) = finf;
            minr = max(1,m-halfBlockSize);
            maxr = min(nRowsLeft,m+halfBlockSize);
 
            for n=1:size(leftI,2)
                minc = max(1,n-halfBlockSize);
                maxc = min(size(leftI,2),n+halfBlockSize);
                mind = max( -disparityRange, 1-minc );
                maxd = min( disparityRange, size(leftI,2)-maxc );
                for d=mind:maxd
                    disparityCost(n, d + disparityRange + 1) = ...
                        sum(sum(abs(leftI(minr:maxr,(minc:maxc)+d) ...
                        - rightI(minr:maxr,minc:maxc))));
                end
            end
 
            optimalIndices = zeros(size(disparityCost), 'single');
            cp = disparityCost(end,:);
            for j=size(disparityCost,1)-1:-1:1
                cfinf = (size(disparityCost,1) - j + 1)*finf;
                [v,ix] = min([cfinf cfinf cp(1:end-4)+3*disparityPenalty;
                              cfinf cp(1:end-3)+2*disparityPenalty;
                              cp(1:end-2)+disparityPenalty;
                              cp(2:end-1);
                              cp(3:end)+disparityPenalty;
                              cp(4:end)+2*disparityPenalty cfinf;
                              cp(5:end)+3*disparityPenalty cfinf cfinf],[],1);
                cp = [cfinf disparityCost(j,2:end-1)+v cfinf];
                optimalIndices(j,2:end-1) = (2:size(disparityCost,2)-1) + (ix - 4);
            end
            [~,ix] = min(cp);
            Ddynamic(m,1) = ix;
            for k=1:size(Ddynamic,2)-1
                Ddynamic(m,k+1) = optimalIndices(k, ...
                    max(1, min(size(optimalIndices,2), round(Ddynamic(m,k)) ) ) );
            end
            waitbar(m/nRowsLeft, hWaitBar);
        end
        close(hWaitBar);
        Ddynamic = Ddynamic - disparityRange - 1;

Merci

[Jerome Briot]

Pour commencer, n'utilise pas waitbar. Cette outil est très gourmand en temps.

Ensuite, encadre ton code avec ces instructions :

Code :

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

1
2
3
4
5
profile on
 
% ton code ici
 
profile viewer

Tu pourras ensuite analyser le rapport du profiler de MATLAB

[sakona]

Bonjour,

Merci Dut, l'élimination de Waitbar m'a permis de réduire le temps de traitement par 27 s.

D'après le rapport du profiler de MATLAB, je remarque que la fonction repmat, prend 44s du temps total.

Code :

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

1
2
disparityMin = repmat(-smallRange, size(pyramids{end}.L));
        disparityMax = repmat( smallRange, size(pyramids{end}.L));

Comment contourner ce problème? Y a-t-il une alternative moins coûteuse que cette fonction ?

[Jerome Briot]

Montre nous le code complet où sont situées ces deux lignes.

[sakona]

Bonjour Dut,

Voici mon code:

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
for n=1:size(leftI,2)
                minc = max(1,n-halfBlockSize);
                maxc = min(size(leftI,2),n+halfBlockSize);
                mind = max( -disparityRange, 1-minc );
                maxd = min( disparityRange, size(leftI,2)-maxc );
                for d=mind:maxd
                    disparityCost(n, d + disparityRange + 1) = sum(sum(abs(leftI(minr:maxr,(minc:maxc)+d) - rightI(minr:maxr,minc:maxc))));
                end
            end

            optimalIndices = zeros(size(disparityCost), 'single');
            cp = disparityCost(end,:);
            for j=size(disparityCost,1)-1:-1:1
                cfinf = (size(disparityCost,1) - j + 1)*finf;
                [v,ix] = min([cfinf cfinf cp(1:end-4)+3*disparityPenalty;
                              cfinf cp(1:end-3)+2*disparityPenalty;
                              cp(1:end-2)+disparityPenalty;
                              cp(2:end-1);
                              cp(3:end)+disparityPenalty;
                              cp(4:end)+2*disparityPenalty cfinf;
                              cp(5:end)+3*disparityPenalty cfinf cfinf],[],1);
                cp = [cfinf disparityCost(j,2:end-1)+v cfinf];
                optimalIndices(j,2:end-1) = (2:size(disparityCost,2)-1) + (ix - 4);
            end
            [~,ix] = min(cp);
            Ddynamic(m,1) = ix;
            for k=1:size(Ddynamic,2)-1
                Ddynamic(m,k+1) = optimalIndices(k, max(1, min(size(optimalIndices,2), round(Ddynamic(m,k)) ) ) );
            end
        end
                Ddynamic = Ddynamic - disparityRange - 1;


        pyramids = cell(1,4);
        pyramids{1}.L = leftI;
        pyramids{1}.R = rightI;
        for i=2:length(pyramids)
            hPyr = vision.Pyramid('PyramidLevel',1);
            pyramids{i}.L = single(step(hPyr,pyramids{i-1}.L));
            pyramids{i}.R = single(step(hPyr,pyramids{i-1}.R));
        end
        smallRange = single(3);
        disparityMin = repmat(-smallRange, size(pyramids{end}.L));
        disparityMax = repmat( smallRange, size(pyramids{end}.L));

[Jerome Briot]

Tu ne nous montre pas assez de code pour pouvoir t'aider efficacement…

[sakona]

Bonjour,

je vous ai montré presque la majorité du programme, j'ai pas mis seulement la lecture des images, le prétraitement et la conversion en niveau de gris pour gagner en temps de calcul.

Le rapport du profiler de MATLAB a confirmé que les boules for, repmat, vipstereo_blockmatch_combined et vipstereo_blockmatch sont des fonctions gourmandes en temps. Donc, s'il y a des rectifications , ça sera à ce niveau.