Discussion :

[ShaiLeTroll]

Je n'ai pas assez fouillé dans les sources pour lire comment était codé TMonochromeEffect cela dit je sais obtenir le Filtre

Cela tombe bien ce n'est pas codé en pascal dans les sources mais via binaire de pseudo-code des API du moteur graphique DirectX HLSL ou OpenGL GLSL et donc via le GPU.

en Théorie (je ne fais pas de FMX mais le code montre qu'un TControl peut gérer une liste de TEffect qui sont ajoutés comme des enfants)
en ajoutant un TMonochromeEffect avec comme parent ton Control devant être grisé soit en fait

Code :

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

  TMonochromeEffect.Create(PaintBox).Parent := PaintBox;

Cela va griser tout le Controle cible, cela se cumule en plus

Tout dépend si finalement tu veux faire que fichier vers fichier ou si tu prévois un affichage

En théorie, ceci doit fonctionner avec Bitmap qui sert d'entrée et sortie à la fois.

Code :

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

1
2
3
4
5
6
with TMonochromeEffect.Create(nil) do
try
  ProcessEffect(nil, Bitmap, 0);
finally
  Free();
end;

[SergioMaster]

En théorie, ceci doit fonctionner avec Bitmap qui sert d'entrée et sortie à la fois.

Théorie totalement correcte pour quelqu'un qui "ne fait pas de FMX"

voici ma petite unité test

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
unit UFilter;
 
interface
 
uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs,
  FMX.Controls.Presentation, FMX.StdCtrls, FMX.Objects;
 
type
  TForm1 = class(TForm)
    Image1: TImage;
    Image2: TImage;
    OpenDialog1: TOpenDialog;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.fmx}
 
uses FMX.Filter.Effects;
 
procedure TForm1.Button1Click(Sender: TObject);
var aBitmap : Tbitmap;
begin
if OpenDialog1.Execute then
 begin
   Image1.Bitmap.LoadFromFile(Opendialog1.FileName);
   ABitmap:=Tbitmap.CreateFromFile(Opendialog1.FileName);
   try
     with TmonochromeEffect.Create(nil) do
     try
      ProcessEffect(nil,aBitmap, 0);
    finally
      Free;
    end;
    image2.Bitmap:=ABitmap;
   finally
    aBitmap.Free;
   end;
 end;
end;
 
end.

et son résultat

[Jipété]

Salut,

on voit bien les différences de rendu de l'orange de la bouée et du bleu de la mer près des palmes.

De mon côté, je peux vous montrer ça, il n'y a pas de dégradés dans l'image d'origine à part le bleu du ciel, ça permet de bien se rendre compte des variations du vert, du jaune (qui est un rouge + vert), et du rouge :


(image réduite de moitié, comme celle d'hier, et convertie en .jpg car l'outil du forum refuse la même image en .png, )

Quant aux filtres, si tu as accès aux pixels, tu as accès à tout et tu peux tout faire ; voilà comment je m'y prends, avec Scanline et FreePascal/Lazarus sous Linux :

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
procedure TForm1.ComputeGray(i: integer);
var
  PixelsS,PixelsD: pRGBQuad;
  hs,ws,hd,wd: integer;
  gray: byte;
  R,G,B{,D}: byte;
begin
  dstbmp.BeginUpdate();
  for hs := 0 to HSIZE-1 do begin // de haut en bas
    hd := hs;
    PixelsS := pRGBQuad(srcbmp.RawImage.GetLineStart(hs));
    PixelsD := pRGBQuad(dstbmp.RawImage.GetLineStart(hd));
    for ws := 0 to WSIZE-1 do begin // de gauche à droite
      wd := ws;
      // prendre le pixel source,
      B := PixelsS[ws].rgbBlue;
      G := PixelsS[ws].rgbGreen;
      R := PixelsS[ws].rgbRed;
      //D := PixelsS[ws].rgbReserved; n.u.
      // le passer en niveaux de gris
      case i of
        1: gray:= round((max(max(R,G),B)+min(min(R,G),B))*0.5);
        2: gray:= round(0.21*R+0.72*G+0.07*B);
        3: gray:= round(0.30*R+0.59*G+0.11*B);
        4: gray:= round(power( ( 0.2126*power(R,2.2)+0.7152*power(G,2.2)+0.0722*power(B,2.2) ),1/2.2) );
        5: gray:= (B+G+R) div 3;
      end;
      // et l'écrire dans la destination
      PixelsD[wd]:= RGBAtoBGRA(gray,gray,gray,255);
    end; // for ws
  end; // for hs
  dstbmp.EndUpdate();
end;

Bon, c'est juste une maquette pour voir les changements de rendu, donc je me suis arrangé pour partir d'images carrées de 310x310, si on sort de ce schéma c'est la cata assurée,

[Charly910]

Bonjour,

voici mon application fourre-tout, faite de bric et de broc, mais qui réunit tous les filtres et traitements d'images que j'ai glanés sur le net :

FiltreImage.zip

J'y ai ajouté les différents filtres gris cités plus haut.

Travail d'amateur en version D7, mais quelques morceaux peuvent peut-être servir quitte à être améliorés !

A+
Charly

[SergioMaster]

Bonjour,
difficile de faire un choix. Du coup j'ai fait un contrôle temps



Dans mon projet, où la qualité prime moins que la vitesse, la méthode sur la moyenne remporte la palme
quoique, l'effet, totalement OS indépendant (faut-il le souligner ?), et dès un second appel gagne la partie (passe à 8 pour un nouveau chargement de l'image)

[Jipété]

Yep !

difficile de faire un choix.

Normal, ton image en (peu de) couleurs se prête mal à des comparaisons. Regarde avec des ballons :

[Andnotor]

cela étant, je me fais incendier par un internaute qui m'écrit qu'il ne faut pas utiliser HSL

Et je serais assez de son avis.

Pourquoi convertir en HSL puisque le gris peut se calculer sur la base des trois composantes ?
Pourquoi travailler en 24 bits puisque tu veux une sortie en niveau de gris 8 bits ? Crée un bitmap 8 bits simplement.


Après si c'est vraiment de la vitesse que tu cherches, il ne faut faire appel qu'une seule fois à Scanline (très gourmand en temps de traitement) et ensuite uniquement indexer le pointeur.

En VCL ça donne :

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
function BmpToGrayscale(aBmp :TBitmap) :TBitmap;
var
  GrayPal :TMaxLogPalette;
begin
  aBmp.PixelFormat := pf24bit;
 
  GrayPal.palVersion    := $0300;
  GrayPal.palNumEntries := 256;
 
  for var i := 0 to 255 do
    with GrayPal.palPalEntry[i] do
    begin
      peRed   := i;
      peGreen := i;
      peBlue  := i;
      peFlags := 0;
    end;
 
  Result             := TBitmap.Create;
  Result.PixelFormat := pf8Bit;
  Result.Palette     := CreatePalette(@GrayPal);
  Result.SetSize(aBmp.Width, aBmp.Height);
 
  var Source :PRGBTriple := aBmp.ScanLine[aBmp.Height -1];
  var Dest   :PByte      := Result.ScanLine[Result.Height -1];
 
  var AlignSource := BytesPerScanline(aBmp.Width, 24, 32) -(aBmp.Width *3);
  var AlignDest   := BytesPerScanline(Result.Width, 8, 32) -Result.Width;
 
  for var y := 0 to aBmp.Height -1 do
  begin
    for var x := 0 to aBmp.Width -1 do
    begin
      Dest^ := Round(0.299 *Source.rgbtRed +0.587 *Source.rgbtGreen +0.114 *Source.rgbtBlue);
      inc(Source);
      inc(Dest);
    end;
 
    inc(PByte(Source), AlignSource);
    inc(Dest, AlignDest);
  end;
end;