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

Merci d'utiliser la balise [code].
 
En matlab, ce qui est très coûteux, ce sont les boucles for. Il est nettement préférable de travailler avec des opérateurs manipulant directement des matrices/tableaux.
 
Bon après, c'est sûr qu'en C, ton programme serait nettement plus rapide. Du reste, pourquoi ce choix n'est pas présent dans ton sondage ? Pour le traitement d'image, le C, c'est encore ce qui est le plus efficace (après l'ASM)...

 
Pouvez me donner un exemple dans mon code, de comment remplacer une boule for par des opérations plus rapides.
 
Pour C, le code tourne avec une multitude d'appel de fonctions déjà préétablies, donc sa conversion en C, sera très coûteuse.
 

Désolé, mon niveau en Matlab se résume à qq TP réalisés en école d'Ingé il y plus de 10 ans. Je vais pas pouvoir aider plus. Le coup des boucles coûteuses m'avait juste marqué
 
Mon conseil était donc de regarder dans la doc de Matlab s'il n'y aurait pas des opérations qui soient réalisables par des fonctions travaillant directement sur des matrices/tableaux...