public static void GrayScale(Bitmap bmp) 
{
    for (int y = 0; y < bmp.Height; y++) 
    {
        for (int x = 0; x < bmp.Width; x++) 
        {
               Color c = bmp.GetPixel(x, y); 
               int luma = (int)(c.R * 0.3 + c.G * 0.59 + c.B * 0.11);    
               bmp.SetPixel(x, y, Color.FromArgb(luma, luma, luma)); 
         }
    }
}

Public Shared Sub GrayScale(ByRef bmp As Drawing.Bitmap) 
  For y As Integer = 0 To bmp.Height - 1
      For x As Integer = 0 To bmp.Width - 1 
          Dim c As Drawing.Color = bmp.GetPixel(x, y)
          Dim luma As Integer = CInt(c.R * 0.3 + c.G * 0.59 + c.B * 0.11) 
          bmp.SetPixel(x, y, Drawing.Color.FromArgb(luma, luma, luma))
      Next
  Next
End Sub

public System.Drawing.Image GrayScale(System.Drawing.Image Img)
{
  System.Drawing.Imaging.ImageAttributes GrayAttributes;
  System.Drawing.Imaging.ColorMatrix GrayMatrix = new System.Drawing.Imaging.ColorMatrix();
  GrayMatrix.Matrix00 = 1 / 3.0F;
  GrayMatrix.Matrix01 = 1 / 3.0F;
  GrayMatrix.Matrix02 = 1 / 3.0F;
  GrayMatrix.Matrix10 = 1 / 3.0F;
  GrayMatrix.Matrix11 = 1 / 3.0F;
  GrayMatrix.Matrix12 = 1 / 3.0F;
  GrayMatrix.Matrix20 = 1 / 3.0F;
  GrayMatrix.Matrix21 = 1 / 3.0F;
  GrayMatrix.Matrix22 = 1 / 3.0F;
  GrayAttributes = new System.Drawing.Imaging.ImageAttributes();
  GrayAttributes.SetColorMatrix(GrayMatrix, System.Drawing.Imaging.ColorMatrixFlag.Default, System.Drawing.Imaging.ColorAdjustType.Default);
  System.Drawing.Bitmap FinalImg = new System.Drawing.Bitmap(Img.Width, Img.Height);
  System.Drawing.Graphics Graphics = System.Drawing.Graphics.FromImage(FinalImg);
  Graphics.DrawImage(Img, new Rectangle(0, 0, FinalImg.Width, FinalImg.Height), 0, 0, FinalImg.Width, FinalImg.Height, System.Drawing.GraphicsUnit.Pixel, GrayAttributes);
  return FinalImg;
}

Public Function GrayScale(ByVal Img As System.Drawing.Image) As System.Drawing.Image
  Dim GrayAttributes As System.Drawing.Imaging.ImageAttributes
  Dim GrayMatrix As New System.Drawing.Imaging.ColorMatrix
  GrayMatrix.Matrix00 = 1 / 3.0F
  GrayMatrix.Matrix01 = 1 / 3.0F
  GrayMatrix.Matrix02 = 1 / 3.0F
  GrayMatrix.Matrix10 = 1 / 3.0F
  GrayMatrix.Matrix11 = 1 / 3.0F
  GrayMatrix.Matrix12 = 1 / 3.0F
  GrayMatrix.Matrix20 = 1 / 3.0F
  GrayMatrix.Matrix21 = 1 / 3.0F
  GrayMatrix.Matrix22 = 1 / 3.0F
  GrayAttributes = New System.Drawing.Imaging.ImageAttributes()
  GrayAttributes.SetColorMatrix(GrayMatrix, System.Drawing.Imaging.ColorMatrixFlag.Default, System.Drawing.Imaging.ColorAdjustType.Default)
  Dim FinalImg As New System.Drawing.Bitmap(Img.Width, Img.Height)
  Dim Graphics As System.Drawing.Graphics = System.Drawing.Graphics.FromImage(FinalImg)
  Graphics.DrawImage(Img, New Rectangle(0, 0, FinalImg.Width, FinalImg.Height), 0, 0, FinalImg.Width, FinalImg.Height, System.Drawing.GraphicsUnit.Pixel, GrayAttributes)
  Return FinalImg
End Function

Public Declare Function GetPixel Lib "gdi32" ( _
   ByVal hDC As Long, _
   ByVal X As Long, _
   ByVal Y As Long) As Long
Public Declare Function SetPixel Lib "gdi32" ( _
   ByVal hDC As Long, _
   ByVal X As Long, _
   ByVal Y As Long, _
   ByVal crColor As Long) As Long
Public Sub GrayScale(ByRef picSRC As PictureBox, ByRef picDST As PictureBox)
   Dim Y As Integer, X As Integer
   Dim c As Long, R As Long, v As Long, G As Long, B As Long
   picDST.Width = picSRC.Width
   picDST.Height = picSRC.Height
   picDST.AutoRedraw = False
   Dim luma As Long
   For Y = 0 To picSRC.ScaleHeight
       For X = 0 To picSRC.ScaleWidth
           c = GetPixel(picSRC.hDC, X, Y)
           Call GetRGB(c, R, G, B)
           luma = CInt(R * 0.3 + G * 0.59 + B * 0.11)
           Call SetPixel(picDST.hDC, X, Y, RGB(luma, luma, luma))
       Next X
   Next Y
End Sub 

'Get R G B values / récupère les couleurs R V B
Public Sub GetRGB(ByVal Color As Long, ByRef R As Long, ByRef G As Long, ByRef B As Long)
   B = ((((Color \ 65536) And 255) * 50) + (((Color \ 65536) And 255) * 50)) \ 100
   G = ((((Color \ 256) And 255) * 50) + (((Color \ 256) And 255) * 50)) \ 100
   R = (((Color And 255) * 50) + ((Color And 255) * 50)) \ 100
End Sub 

Const BI_RGB = 0&
Const DIB_RGB_COLORS = 0

Private Type BITMAPINFOHEADER '40 bytes
        biSize As Long
        biWidth As Long
        biHeight As Long
        biPlanes As Integer
        biBitCount As Integer
        biCompression As Long
        biSizeImage As Long
        biXPelsPerMeter As Long
        biYPelsPerMeter As Long
        biClrUsed As Long
        biClrImportant As Long
End Type

Private Type RGBQUAD
        rgbBlue As Byte
        rgbGreen As Byte
        rgbRed As Byte
        rgbReserved As Byte
End Type

Private Type BITMAPINFO
        bmiHeader As BITMAPINFOHEADER
        bmiColors As RGBQUAD
End Type

Private Declare Function GetDIBColorTable Lib "gdi32" (ByVal hdc As Long, ByVal un1 As Long, ByVal un2 As Long, pRGBQuad As RGBQUAD) As Long
Private Declare Function GetDIBits Lib "gdi32" (ByVal aHDC As Long, ByVal hBitmap As Long, ByVal nStartScan As Long, ByVal nNumScans As Long, lpBits As Any, lpBI As BITMAPINFO, ByVal wUsage As Long) As Long
Private Declare Function SetDIBits Lib "gdi32" (ByVal hdc As Long, ByVal hBitmap As Long, ByVal nStartScan As Long, ByVal nNumScans As Long, lpBits As Any, lpBI As BITMAPINFO, ByVal wUsage As Long) As Long

Private Sub GrayScale(PicSRC As PictureBox)
    Const pixR = 1
    Const pixG = 2
    Const pixB = 3
    Dim bitmap_info      As BITMAPINFO
    Dim pixels()            As Byte
    Dim bytes_per_scanLine As Integer
    Dim x                     As Integer
    Dim y                     As Integer
    Dim ave_color         As Byte
    Dim bw                   As Long
    Dim bh                   As Long
    bw = PicSRC.ScaleWidth
    bh = PicSRC.ScaleHeight
    
    bytes_per_scanLine = ((((bw * 32) + 31) \ 32) * 4)
  
  ' Prepare la bitmap description.
    With bitmap_info.bmiHeader
        .biSize = 40
        .biWidth = bw
        .biHeight = -bh
        .biPlanes = 1
        .biBitCount = 32
        .biCompression = BI_RGB
        .biSizeImage = bytes_per_scanLine * bh
         End With
  ' Transforme en bitmap's data.
    ReDim pixels(1 To 4, 1 To bw, 1 To bh)
    GetDIBits PicSRC.hdc, PicSRC.Image, 0, bh, pixels(1, 1, 1), bitmap_info, DIB_RGB_COLORS
  ' Modifie les pixels.
    For y = 1 To bh
        For x = 1 To bw
            ave_color = CByte((CInt(pixels(pixR, x, y)) + pixels(pixG, x, y) + pixels(pixB, x, y)) \ 3)
         '  une autre possibilité:
         '  ave_color = CByte((CInt(pixels(pixR, x, y)) * 0.299 + pixels(pixG, x, y) * 0.587 + pixels(pixB, x, y) * 0.114))
            pixels(pixR, x, y) = ave_color
            pixels(pixG, x, y) = ave_color
            pixels(pixB, x, y) = ave_color
            Next x
        Next y
  ' Affiche le resultat.
    SetDIBits PicSRC.hdc, PicSRC.Image, 0, bh, pixels(1, 1, 1), bitmap_info, DIB_RGB_COLORS
    PicSRC.Picture = PicSRC.Image
    
End Sub

'   pour l'utilisation il faut une PictureBox
    Picture1.Picture = LoadPicture("Lechemincomplet\votreimage")
    GrayScale Picture1

import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.FilteredImageSource;
import java.awt.image.RGBImageFilter;

public class GrayFilter extends RGBImageFilter {
    public GrayFilter() {
        //initialisation de la variable canFilterIndexColorModel herite de RGBImageFilter
        //ainsi la transformation des couleurs ne depend pas des coordonnees des points de l'image 
        canFilterIndexColorModel = true;
    }
    public static Image setFilter(Image source) {
        return Toolkit.getDefaultToolkit().createImage(
                new FilteredImageSource(source.getSource(),
                        new GrayFilter()));
    }
    public int filterRGB(int x, int y, int rgb) {
        int alpha = (rgb & 0xFF000000);
        int r = (rgb & 0xff0000) >> 16;
        int g = (rgb & 0xff00) >> 8;
        int b = (rgb & 0xff);
        int moy = ((r + g + b) / 3);
        return alpha + (moy << 16) + (moy << 8) + (moy);
    }
    
    public static void main(String [] args){
        Image gray = GrayFilter.setFilter(
                Toolkit.getDefaultToolkit().createImage("image.png"));
    }
}

;// compilation :
 ;// "as toto.s -o toto.o
 ;// "ld toto.o -o toto
 ;// The _fill function is juste to have predictive result when debugging with gdb in Eclipse
 ;// And so to be able to verify operations and pixel results in memory 
 
 .section .data
 .align 16 ; // to ensure 16bytes alignement
 image:        .space    256*256*4; // 256*256*(4 bytes/pixel) format : RGBARGBARGBA....
 imagelen:    .long    256*256*4;   // take care to have size multiple of 4pixels
               // take care to have @image 128bits aligned, if not change all "movdqa" with "movdqu"
               // "movdqa = move doublequad aligned", "movdqu = move doublequad unaligned" 
 
 charmaskinlong:    .long    0x000000FF;
 // we compute all coefficients as 65536th
 coefR:            .long    77;        // 0.3  *256
 coefG:            .long    151;    // 0.59 *256
 coefB:            .long    28;        // 0.11 *256
                 // 77+151+28 = 256 ok, we shouldn't overflow 255
 
 .section .text
 .global _start
 
 _start:
 
     call    _fill;
 
     movd    charmaskinlong,%xmm7; // load charmask in XMM7=[000000000000000000000000000000FF]
     pshufd    $0,%xmm7,%xmm7;      // copy charmask on each packeted 32bits
                                                           // XMM7==[000000FF000000FF000000FF000000FF]
 
     movd    coefR,%xmm6;                // load coefR in XMM6=[000000000000000000000000000000cR]
     pshufd    $0,%xmm6,%xmm6;      // XMM6.D=[cR cR cR cR] , XMM7.W=[0 cR 0 cR 0 cR 0 cR]
 
     movd    coefG,%xmm5;              // load coefG in XMM5=[000000000000000000000000000000cG]
     pshufd    $0,%xmm5,%xmm5;    // XMM5.D=[cG cG cG cG] , XMM5.W=[0 cG 0 cG 0 cG 0 cG]
     pslld    $16,%xmm5;                    // XMM5.W=[cG 0 cG 0 cG 0 cG 0]
     por        %xmm5,%xmm6;          // XMM6.W=[cG cR cG cR cG cR cG cR]
 
     movd    coefB,%xmm4;                // load coefB in XMM7=[000000000000000000000000000000cB]
     pshufd    $0,%xmm4,%xmm4;     // XMM4.D=[cB cB cB cB] , XMM4.W=[0 cB 0 cB 0 cB 0 cB]
     movdqa    %xmm7,%xmm5;        // XMM5.D=[255 255 255 255]
     pslld    $16,%xmm4;                    // XMM4.W=[cB 0 cB 0 cB 0 cB 0]
     por        %xmm4,%xmm5;          // XMM5.W=[cB 255 cB 255 cB 255 cB 255]
 
     movl    $image,%eax;                 // put ptr image in EAX 
     movl    imagelen,%ecx;              // put size in ECX
     
     sar        $4,%ecx;                    // divide size by 16 (4 pixels / pass)
 
 _loop4:
     // the goal is (R*cR+G*cG+B*cB)/256  (cR,cG,cB are *256)
     // we will do  ( [(R*cR + G*cG)/256]*255 + B*cB)/256 -> 2 Packed MultiplyAdd operation
     
     movdqa    (%eax),%xmm0;             // load 4pixels in XMM0 (4 * 32bits = 128bits)
     pshufd    $0xE4,%xmm7,%xmm1;  // copy XMM7 to XMM1 (using shifting SSE unit not load unit)
     pand    %xmm0,%xmm1;                // XMM1.B=[00 00 00 RR 00 00 00 RR 00 00 00 RR 00 00 00 RR]
     pshufd    $0xE4,%xmm7,%xmm2;  // copy XMM7 to XMM2 (using shifting SSE unit not load unit)
     pslld    $8,%xmm2;                          // XMM2.B=[00 00 FF 00 00 00 FF 00 00 00 FF 00 00 00 FF 00]
     pand    %xmm0,%xmm2;                 // XMM1.B=[00 00 GG 00 00 00 GG 00 00 00 GG 00 00 00 GG 00]
     pslld    $8,%xmm2;                          // XMM1.B=[00 GG 00 00 00 GG 00 00 00 GG 00 00 00 GG 00 00]
     por        %xmm2,%xmm1;              // XMM1.W=[G R G R G R G R]
     pmaddwd    %xmm6,%xmm1;         // XMM1.D=[g*cG+R*cR g*cG+R*cR g*cG+R*cR g*cG+R*cR]
     psrad    $8,%xmm1;                        // XMM1.W=[0 (g*cG+R*cR)/256 4x]
     movdqa    %xmm7,%xmm2;           // Copy XMM7 to XMM2 using load SSE unit
     pslld    $16,%xmm2;                       // XMM2.B=[00 FF 00 00 00 FF 00 00 00 FF 00 00 00 FF 00 00]
     pand    %xmm0,%xmm2;                // XMM2.B=[00 BB 00 00 00 BB 00 00 00 BB 00 00 00 BB 00 00]
     por        %xmm2,%xmm1;              // XMM1.W=[BB (g*cG+R*cR)/256 BB 4x]
     pmaddwd    %xmm5,%xmm1;        // XMM1.D=[((g*cG+R*cR)/256)*255+B*cB 4x]
                                                            // XMM1.D~=[(g*cG+R*cR+B*cB) 4x]
     psrad    $8,%xmm1;                      // XMM1.D~=[(g*cG+R*cR+B*cB)/256 4x]
     movdqa    %xmm7,%xmm2;         // Copy XMM7 to XMM2 using load SSE unit
     pslld    $24,%xmm2;                     // XMM2.B=[FF 00 00 00 FF 00 00 00 FF 00 00 00 FF 00 00 00]
     pand    %xmm0,%xmm2;             // XMM2.B=[AA 00 00 00 AA 00 00 00 AA 00 00 00 AA 00 00 00]
     por        %xmm1,%xmm2;           // XMM2.B=[AA 00 00 Gr AA 00 00 Gr AA 00 00 Gr AA 00 00 Gr]
     movdqa    %xmm1,%xmm3;        // XMM3.D~=[Grey Grey Grey Grey]
     pslld    $8,%xmm3;                      // XMM3.B=[00 00 Gr 00 00 00 Gr 00 00 00 Gr 00 00 00 Gr 00]
     por        %xmm3,%xmm2;          // XMM2.B=[AA 00 Gr Gr AA 00 Gr Gr AA 00 Gr Gr AA 00 Gr Gr]
     pslld    $8,%xmm3;                    // XMM3.B=[00 Gr 00 00 00 Gr 00 00 00 Gr 00 00 00 Gr 00 00]
     por        %xmm3,%xmm2;         // XMM2.B=[AA Gr Gr Gr AA Gr Gr Gr AA Gr Gr Gr AA Gr Gr Gr]
     movdqa    %xmm2,(%eax);        // store 4pixels packed Grey converted
     add        $16,%eax;                    // next frame is 4*4bytes=16bytes further
     dec        %ecx;                        // decrement 4pixels packed count
     jnz        _loop4;                        // continue works :)
 _end:
     mov        $1,%eax;                    // 1 => exit
     mov        $0,%ebx;                    // 0 return code
     int        $0x80;                        // bye bye :)
 
 ;// Addon function to fill the picture
 _fill:
     movl    $image,%eax;                 // put ptr image in EAX
     xor        %ebx,%ebx;                    // clear EBX 
     movl    imagelen,%ecx;                // put size in ECX
 _loop2:
     movb    %bl,(%eax);                    // put counter in pixel component
     inc        %bl;                        // increment counter
     inc        %eax;                        // increment pixel component pointer
     dec        %ecx;                        // decrement byte count
     jnz        _loop2;                        // continue if not finished
     ret;                                // come back to the main code
 

// Fonction pour convertir un BMP en niveaux de gris
Function GrayScale(srcBmp, DstBmp : TBitmap): Boolean;
Type
  TRGBArray = Array[0..0] Of TRGBTriple;
  PRGBArray = ^TRGBArray;
Var
  GrayScale         : PRGBArray;
  BH, BW, Gray       : integer;
Begin
  Result := False;
  If (SrcBmp = Nil) or (DstBmp = Nil) or SrcBmp.Empty Then Exit;
  With DstBmp Do
  Begin
    PixelFormat := Pf24Bit;
    Width  := SrcBmp.Width;
    Height := SrcBmp.Height;
// pour ne pas modifier l'image originale on fait une copie dans DstBmp
// 
    BitBlt(Canvas.Handle, 0, 0, Width, Height,
      SrcBmp.Canvas.Handle, 0, 0, srcCopy);
    For BH := 0 To Height - 1 Do
      Begin
        GrayScale := Scanline[BH];
        For BW := 0 To Width - 1 Do
          With GrayScale[BW] Do
            Begin
              Gray := Round(RGBTRed * 0.3 + RGBTGreen * 0.59 + RGBTBlue * 0.11);
              RGBTRed := Gray;
              RGBTGreen := Gray;
              RGBTBlue := Gray;
            End;
      End;
  End;
End;
// Utilisation :
// Bmp est l'image d'origine
// Tmp l'image en niveaux de gris
// Image1 pour visionner le résultat
procedure TfrmMain.Button1Click(Sender: TObject);
Var Tmp : TBitmap;
begin
  Tmp := TBitmap.Create;
  GrayScale(Bmp, Tmp);
  Image1.Picture.Assign(Tmp);
  Tmp.Free;
end;

// Classes nécessaires
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.awt.color.ColorSpace;
/**
  * Transformer une image colorée en Niveau de gris.
  */
BufferedImage toGray (BufferedImage bi) {
    ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);    
    ColorConvertOp op = new ColorConvertOp(cs, null);
    
    return op.filter(bi, null);
}
  

//on parcout l'image pixel par pixel et on calcule a chaque fois le niveau de gris correspondant
maclasse::ToGrayScale(Bitmap* planche)
{
    for(UINT y = 0; y < planche->GetHeight(); y++)
        {
            for(UINT x = 0;x < planche->GetWidth(); x++)
            {
            Color c;
            planche->GetPixel(x, y,&c);
            int luma = (int)((c.GetRed() * 0.3) + (c.GetGreen() * 0.59)+ (c.GetBlue() * 0.11));
            ARGB argb = Color::MakeARGB(c.GetAlpha(), luma, luma, luma);
            Color argbColor(argb);
            planche->SetPixel(x, y, argbColor);
            } 
        }
}

type
  pByteQuad = ^ByteQuad;
  ByteQuad  = array[0..3] of byte;

procedure GrayByMinMax(src, dest : TBitmap);
var X : integer;
    pPix : pByteQuad;
    Bo,Bm,Bx : byte;
begin
  if Src.PixelFormat <> pf32bit then
  begin
    Src.PixelFormat  := pf32Bit;
    Dest.PixelFormat := pf32Bit;
  end;
  Dest.Assign(Src);
  pPix := Dest.ScanLine[Dest.Height-1];
  for X := 0 to (Dest.Width*Dest.Height)-1 do
  begin
    if pPix^[0] > pPix^[2] then
    begin
      Bx := pPix^[0];
      Bm := pPix^[2];
    end
    else
    begin
      Bx := pPix^[2];
      Bm := pPix^[0];
    end;
    if pPix^[1] > Bx then
      Bx := pPix^[1]
    else
    if pPix^[1] < Bm then
      Bm := pPix^[1];

    Bo := (Bx + Bm) shr 1;
    pPix^[0] := Bo; // B
    pPix^[1] := Bo; // G
    pPix^[2] := Bo; // R
    inc(pPix);
  end;
end;
{ ------- }
procedure GrayByRGBAverage(src, dest : TBitmap);
var X   : integer;
    pPix  : pByteQuad;
    Bo    : byte;
begin
  if Src.PixelFormat <> pf32bit then
  begin
    Src.PixelFormat  := pf32Bit;
    Dest.PixelFormat := pf32Bit;
  end;
  Dest.Assign(Src);
  pPix := Dest.ScanLine[Dest.Height-1];
  for X := 0 to (Dest.Width*Dest.Height)-1 do
  begin
    Bo  := (((pPix^[0] + pPix^[1]) shr 1) + pPix^[2]) shr 1;
    pPix^[0] := Bo; // B
    pPix^[1] := Bo; // G
    pPix^[2] := Bo; // R
    inc(pPix);
  end;
end;
{ ------- }
procedure TrueGrayScale(Src : TBitmap; Dest : TBitmap);
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
  if Src.PixelFormat <> pf32bit then
  begin
    Src.PixelFormat  := pf32Bit;
    Dest.PixelFormat := pf32Bit;
  end;
  Dest.Assign(Src);
  { 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;

procedure ColToAverageGrey( const BMP : TBitmap );
           var Grey : Byte;
                 i       : Integer;
                 Pix   : pRGBQuad;
begin
  BMP.PixelFormat := pf32bit;
  Pix := BMP.ScanLine[ BMP.Height-1 ]; // Un seul appel à Scanline.
  for i:=1 to BMP.Width*BMP.Height do begin
    Grey := ( Pix^.rgbBlue + Pix^.rgbGreen + Pix^.rgbRed ) div 3;
    Pix^.rgbBlue   := Grey;
    Pix^.rgbGreen := Grey;
    Pix^.rgbRed    := Grey;
    Inc( Pix );
  end;
end;


procedure ColToSightGrey( const BMP : TBitmap );
           var Grey : Byte;
                 i       : Integer;
                 Pix   : pRGBQuad;
begin
  BMP.PixelFormat := pf32bit;
  Pix := BMP.ScanLine[ BMP.Height-1 ]; // Un seul appel à Scanline.
  for i:=1 to BMP.Width*BMP.Height do begin
    Grey := round( Pix^.rgbBlue*0.0721 + Pix^.rgbGreen*0.7154 + Pix^.rgbRed*0.2125 );
    Pix^.rgbBlue   := Grey;
    Pix^.rgbGreen := Grey;
    Pix^.rgbRed    := Grey;
    Inc( Pix );
  end;
end;


{UTILISATION :}
procedure TForm1.Button1Click( Sender: TObject );
           var BMPtemp1, BMPtemp2 : TBitmap;
begin
  BMPtemp1 := TBitmap.Create;
  BMPtemp2 := TBitmap.Create;
  try
    BMPtemp1.Assign( Image1.picture.bitmap );
    ColToAverageGrey( BMPtemp1 );
    Image2.Picture.Bitmap.Assign( BMPtemp1 );
    BMPtemp2.Assign( Image1.picture.bitmap );
    ColToSightGrey( BMPtemp2 );
    Image3.Picture.Bitmap.Assign( BMPtemp2 );
  finally BMPtemp2.Free;BMPtemp1.Free; end;
end;