RETOUCHE D'IMAGES (FLOUS, SEUIL, HISTOGRAMMES, OPÉRATIONS ARITHMÉTIQUES)

Commentaire de pseudo3 le 22/04/2011 13:45:15

Bonjour,

Voiçi une variante plus rapide utilisant les Scanlines et un tri-par-comptage-d'occurences appliqués au filtre Médian de Cedricbi :

type
  TRGBArray = ARRAY[0..0] OF TRGBTriple;   // élément de bitmap (API windows)
  pRGBArray = ^TRGBArray;                  // type pointeur vers tableau 3 octets 24 bits

var ScanLinesS : array[Word] of pRGBArray; // BmpSource
    ScanLinesD : array[Word] of PRGBArray; // BmpDestination

//        Filtre Médian anti poivre et sel -------------------------------------

function  FiltreMedian2(const BmpSrc : TBitMap; TailleFiltre : Integer) : tBitMap;
type      tAOB = array of byte;
var       X,  Y : Integer;
          X2, Y2 : Integer;
          Rouge,Vert,Bleu : tAOB;
          NombrePixels : Integer;
          NumPixel  : Integer;
          NumPixel2 : Integer;

          procedure TriParOcc( var T : tAOB; sens2tri : boolean);
          //        Tri du tableau T par comptage d'occurences
          //        Si sens2tri=True alors tri en ordre croissant
          var       nbOcc  : array [0..255] of integer; va,i,j,k : integer;
          begin     FillChar(nbOcc,SizeOf(nbOcc),0);  // r.à.z du tableau des occurrences
                    for i := Low(T) to High(T) // recherche des nombres d'occurrences dans le tableau des valeurs :
                    do nbOcc[ T[i] ] := nbOcc[ T[i] ] + 1;

                    k := Low(T);
                    if sens2tri = true  then // restitution en ordre croissant
                    begin for va:=0 to 255
                          do if nbOcc[va] <> 0
                             then for j:=1 to nbOcc[va] do begin T[k]:=va; inc(k); end;
                    end else // restitution en ordre décroissant
                    begin for va := 255 downto 0
                          do if nbOcc[va] <> 0
                             then for j:=1 to nbOcc[va] do begin T[k]:=va; inc(k); end;
                    end;
          end;

begin     Result:=tBitMap.create;
          with Result do begin
               width:=BmpSrc.width; height:=BmpSrc.height; PixelFormat:=pf24bit;
          end;
          for y := 0 to BmpSrc.height-1 do begin
              ScanLinesS[y] := BmpSrc.scanline[y]; // Source
              ScanLinesD[y] := Result.scanline[y]; // Destination
          end;

          TailleFiltre := TailleFiltre div 2;

          SetLength(Rouge, (TailleFiltre * 2 + 1) * (TailleFiltre * 2 + 1));
          SetLength(Vert,  (TailleFiltre * 2 + 1) * (TailleFiltre * 2 + 1));
          SetLength(Bleu,  (TailleFiltre * 2 + 1) * (TailleFiltre * 2 + 1));

          for X := 0 to BmpSrc.Width- 1 do  // Parcourir tous les pixels
          begin //frmFiltres.labX.caption:=intToStr(X); frmFiltres.labX.update;
            for Y := 0 to BmpSrc.Height - 1 do  // de l'image
            begin
              NombrePixels := 0;

              for X2 := -TailleFiltre to TailleFiltre do
                if (X + X2 >= 0) and (X + X2 < BmpSrc.Width) then  // Teste si la colonne X + X2 est sur l'image
                  for Y2 := -TailleFiltre to TailleFiltre do
                    if (Y + Y2 >= 0) and (Y + Y2 < BmpSrc.Height) then  // Teste si la ligne Y + Y2 est sur l'image
                    begin
                      Rouge[NombrePixels]:= ScanLinesS[Y + Y2, X + X2].rgbtRed;   // Mémorisation des valeurs
                      Vert[NombrePixels] := ScanLinesS[Y + Y2, X + X2].rgbtGreen; // des pixels
                      Bleu[NombrePixels] := ScanLinesS[Y + Y2, X + X2].rgbtBlue;  // dans les tableaux

                      Inc(NombrePixels);  // Augmente de 1 le nombre de pixels additionnés
                    end;

              TriParOcc(Rouge, true); // Trier les couleurs par ordre croissant
              TriParOcc(Vert,  true);
              TriParOcc(Bleu,  true);

              if Odd(NombrePixels) then
              begin
                ScanLinesD[Y, X].rgbtRed   := Rouge[NombrePixels div 2]; // Calculer la
                ScanLinesD[Y, X].rgbtGreen := Vert[NombrePixels div 2];  // couleur
                ScanLinesD[Y, X].rgbtBlue  := Bleu[NombrePixels div 2];  // du pixel
              end
              else
              begin
                ScanLinesD[Y, X].rgbtRed  := trunc((Rouge[NombrePixels div 2] + Rouge[NombrePixels div 2 + 1]) / 2); // Calculer la
                ScanLinesD[Y, X].rgbtGreen:= trunc((Vert[NombrePixels div 2]  + Vert[NombrePixels div 2 + 1]) / 2);  // couleur
                ScanLinesD[Y, X].rgbtBlue := trunc((Bleu[NombrePixels div 2]  + Bleu[NombrePixels div 2 + 1]) / 2);  // du pixel
              end;
            end;
          end;
end; // FiltreMedian2

Resultats des tests de vitesses comparatifs pour une image-bitMap de 500x347 pixels et une Taille de filtre égale à 10 :
- avec le code de Cedricbi : Mis 63250 millisecondes (hors durée de la prévisualisation)
- avec le code ci-dessus   : Mis 2687 millisecondes soit 23,5 fois plus rapide.

A+.