Y'a pas de quoi pour le double-post ! C'est réglé.

Ta technique "implicite" est excellente mais évidemment, tout le monde n'a pas delphi 2006/7.

Sinon, pour le "packed", c'est pas compressé au sens Win-zip du terme, mais plutôt "compacté".

Cela signifie simplement qu'en mémoire tu as ça : BGRA (une lettre = un octet)

Si tu ne met pas packed, Delphi aligne les débuts des variables selon la directive {$A} qui vaut 8 par défaut, et tu obtiens ça: B000G000R000A000, tout ça pour respecter l'alignement sur DWord.

Mais ici, il ne faut pas, puisque dans le fichier, les octets des composantes sont bien côte à côte.

bien vus.

peut etre limité l'utilisation du packed en redefinissant $A a 1 pour un byte align, pour la declaration de TPixel.

faudrait faire des mesures de perf d'accés.

Salut Deefaze & Florent.

 @Deefaze :

D'accord avec toi pour les bitmaps 32bits, c'est assez inutile si on n'emploie pas la couche alpha. J'ai d'ailleurs toujours utilisé le traitement sur 24 bits. Mais je pensais que le traitement sur les octets pouvait être optimisé en 32 bits, ce qui semble assez logique dans une architecture 32 bits (?).

Pour l'utilisation de "packed" : il faudrait se mettre d'accord, car beaucoup de sources graphiques sérieuses l'utilisent. Delphi lui-même dans windows.pas déclare :

TRGBTriple = PACKED RECORD
  rgbtBlue : BYTE;
  rgbtGreen: BYTE;
  rgbtRed  : BYTE;
END;

Merci pour le code que tu utilises personnellement.

A +

Thierry

En fait tout depend de ce que tu compte faire sur le bitmap.

par exemple, un filtre negatif tu le fait en 32bit avec un integer c'est plus simple.

procedure Negativize(src, dest : TBitmap); // ~0.026 cycles par pixel
var X : integer;
    pPix : ^Integer;
begin
  Dest.Assign(Src);
  Dest.PixelFormat := pf32Bit;

  pPix := Dest.ScanLine[Dest.Height-1];
  for X := 0 to (Dest.Width*Dest.Height)-1 do
  begin
    pPix^ := not pPix^;
    inc(pPix);
  end;
end;

pouf, rapide, efficace.

par contre quand c'est du traitement sur R,G,B, par exemple un GrayScale, la on peu travailler en 24bits ou en 32bits. perso, il est vrai que je travail en 32bits a chaque fois.
surtout quand il sagit de filtre, qui ne necessite pas forcement d'avoir un rendus immediat par rapport a des effets temps réel ou la, il faut chercher le plus performant.

procedure TrueGrayScale(Src,Dest : TBitmap); // ~0.050 cycles par pixel
var
  X  : integer;
  Bo : integer;
  pPix : pByteQuad;
  PCLR : array[0..255] of single;
  PCLG : array[0..255] of single;
  PCLB : array[0..255] of single;
const
  LumRed   = 0.2125; // % of red
  LumGreen = 0.7154; // % of green
  LumBlue  = 0.0721; // % of blue
                     // = 100% (1.0)
begin
  Dest.Assign(Src);
  Dest.PixelFormat := pf32Bit;

  { PreCalculs }
  for X := 0 to 255 do
  begin
    PCLR[X] := X*LumRed;
    PCLG[X] := X*LumGreen;
    PCLB[X] := X*LumBlue;
  end;

  pPix := Dest.ScanLine[Dest.Height-1];
  for X := 0 to (Dest.Width*Dest.Height)-1 do
  begin
    Bo := byte(Round(PCLB[pPix^[0]] + PCLG[pPix^[1]] + PCLR[pPix^[2]]));
    pPix^[0] := Bo;
    pPix^[1] := Bo;
    pPix^[2] := Bo;
    inc(pPix);
  end;
end;
 

perso, j'ai jamais utiliser le TRGBTriple. ou même les fonction GetRedValue etc. je prefere utiliser mes propres methodes.

Salut Deefaze,

Encore merci à toi.

A +

Thierry