{ 
Originally written by Horst Kniebusch, modified by  alioth to make it(alot) faster.  
http://www.swissdelphicenter.ch/torry/showcode.php?id=1484 
Modifier par  Cirec permettant un résultat jusqu'a 4 fois plus rapide 
que la version  "optimisée" de Alioith (ceci en fonction de l'image bien sur)  
 30/06/2008 : Ajout de la division en début donc un gain de temps  supplémentaire 
 grâce à f0xi ... j'l'avais même pas vu ... pfff ^^  
} 
Procedure  crAntialiasing(aBitmap: TBitmap;Const  Percent: Integer = 5; Const pRect: PRect); 
Type  
  TRGBTripleArray = Array[0..32767] Of TRGBTriple; 
  PRGBTripleArray =  ^TRGBTripleArray; 
Const iCent = 20; 
Var  
  PrevLine, CurrLine, NextLine: PRGBTripleArray; 
  M, L, P :  Integer; 
  aRect, bRect: TRect; 
  nCent: Single; 
Begin 
  If aBitmap.Empty Then 
    Exit; 
  aBitmap.PixelFormat :=  pf24Bit; 
  // evite l'appel de Invalidate si Bitmap  est contenu dans un TImage 
  aBitmap.Canvas.Pixels[1, 1] :=  aBitmap.Canvas.Pixels[1, 1]; 
  bRect := Rect(1, 1, aBitmap.Width-2,  aBitmap.Height-2); 
  If  pRect = Nil  Then 
    aRect :=  bRect 
  Else 
  Begin 
    aRect :=  pRect^; 
    If aRect.Left < bRect.Left  Then 
      aRect.Left := bRect.Left;  
    If aRect.Top < bRect.Top Then 
      aRect.Top := bRect.Top; 
    If aRect.Right > bRect.Right+2 Then  
      aRect.Right := bRect.Right+2;  
    If aRect.Bottom >  bRect.Bottom+2 Then  
      aRect.Bottom := bRect.Bottom+2;  
  End; 
  nCent := iCent / (Percent +  iCent); 
  For L := aRect.Top To aRect.Bottom Do  
    Begin 
        //Over Get previous  ScanLine 
        m := l - 1;  
      PrevLine := aBitmap.ScanLine[m]; 
      //Middle Get current ScanLine 
      CurrLine :=  aBitmap.ScanLine[l]; 
        //Under Get Next  ScanLine 
        m := l + 1;  
      NextLine := aBitmap.ScanLine[m]; 
      For  P := aRect.Left To aRect.Right  Do 
      Begin 
        // Left change previous pixel //maque le moins 1  (-1) 
          m := p - 1;  
        If (CurrLine[p].rgbtRed <>  CurrLine[m].rgbtRed) Or  
           (CurrLine[p].rgbtGreen <> CurrLine[m].rgbtGreen)  Or 
           (CurrLine[p].rgbtBlue  <> CurrLine[m].rgbtBlue)Then 
        Begin  
          CurrLine[m].rgbtRed := Round(CurrLine[p].rgbtRed +  (CurrLine[m].rgbtRed - CurrLine[p].rgbtRed) * nCent);  
          CurrLine[m].rgbtGreen := Round(CurrLine[p].rgbtGreen +  (CurrLine[m].rgbtGreen - CurrLine[p].rgbtGreen) * nCent);  
          CurrLine[m].rgbtBlue := Round(CurrLine[p].rgbtBlue +  (CurrLine[m].rgbtBlue - CurrLine[p].rgbtBlue) * nCent); 
        End; 
        //Right  change next pixel 
          m := p + 1; 
        If  (CurrLine[p].rgbtRed <> CurrLine[m].rgbtRed) Or 
           (CurrLine[p].rgbtGreen <>  CurrLine[m].rgbtGreen) Or  
           (CurrLine[p].rgbtBlue <>  CurrLine[m].rgbtBlue)Then 
        Begin  
          CurrLine[m].rgbtRed := Round(CurrLine[p].rgbtRed +  (CurrLine[m].rgbtRed - CurrLine[p].rgbtRed) * nCent);  
          CurrLine[m].rgbtGreen := Round(CurrLine[p].rgbtGreen +  (CurrLine[m].rgbtGreen - CurrLine[p].rgbtGreen) * nCent);  
          CurrLine[m].rgbtBlue := Round(CurrLine[p].rgbtBlue +  (CurrLine[m].rgbtBlue - CurrLine[p].rgbtBlue) * nCent); 
        End; 
        //Under  Change pixel in previous Line 
        If  (CurrLine[p].rgbtRed <> PrevLine[P].rgbtRed) Or 
           (CurrLine[p].rgbtGreen <>  PrevLine[P].rgbtGreen) Or  
           (CurrLine[p].rgbtBlue <>  PrevLine[P].rgbtBlue)Then 
        Begin  
          PrevLine[P].rgbtRed := Round(CurrLine[p].rgbtRed +  (PrevLine[P].rgbtRed - CurrLine[p].rgbtRed) * nCent);  
          PrevLine[P].rgbtGreen := Round(CurrLine[p].rgbtGreen +  (PrevLine[P].rgbtGreen - CurrLine[p].rgbtGreen) * nCent);  
          PrevLine[P].rgbtBlue := Round(CurrLine[p].rgbtBlue +  (PrevLine[P].rgbtBlue - CurrLine[p].rgbtBlue) * nCent); 
        End; 
        //Over  Change pixel in next Line 
        If  (CurrLine[p].rgbtRed <> NextLine[P].rgbtRed) Or 
           (CurrLine[p].rgbtGreen <>  NextLine[P].rgbtGreen) Or  
           (CurrLine[p].rgbtBlue <> NextLine[P].rgbtBlue)Then 
        Begin  
          NextLine[P].rgbtRed := Round(CurrLine[p].rgbtRed +  (NextLine[P].rgbtRed - CurrLine[p].rgbtRed) * nCent);  
          NextLine[P].rgbtGreen := Round(CurrLine[p].rgbtGreen +  (NextLine[P].rgbtGreen - CurrLine[p].rgbtGreen) * nCent);  
          NextLine[P].rgbtBlue := Round(CurrLine[p].rgbtBlue +  (NextLine[P].rgbtBlue - CurrLine[p].rgbtBlue) * nCent); 
        End; 
      End; 
    End;  
End; 

 type
    TPixel = record
      R,G,B: byte;
    end;
    pPixelArray =  ^TPixelArray;
    TPixelArray = Array[0..32767] Of TPixel;
 
  procedure AAS(aBitmap: TBitmap; const pR: PRect; const Percent: single = 0.1);
  var
    PreLn,
    CurLn,
    NexLn  : PPixelArray;
    M,
    L,
    P      : Integer;
    aRect,
    bRect  : TRect;
    nCent  : single;
  const
    iCent = 0.20;
  begin
    if aBitmap.Empty then
      Exit;
 
    aBitmap.PixelFormat := pf24bit;
 
    bRect.Left   := 1;
    bRect.Top    := 1;
    bRect.Right  := aBitmap.Width-2;
    bRect.Bottom := aBitmap.Height-2;
    aRect        := bRect;
    if pR <> Nil then
    begin
      aRect :=  pR^;
      if aRect.Left < bRect.Left then
        aRect.Left := bRect.Left;
      if aRect.Top < bRect.Top then
        aRect.Top := bRect.Top;
      if aRect.Right > bRect.Right then
        aRect.Right := bRect.Right;
      if aRect.Bottom > bRect.Bottom then
        aRect.Bottom := bRect.Bottom;
    end;
 
    nCent := iCent/(Percent + iCent);
 
    for L := aRect.Top to aRect.Bottom do
    begin
      PreLn := aBitmap.ScanLine[l-1];
      CurLn := aBitmap.ScanLine[l];
      NexLn := aBitmap.ScanLine[l+1];
 
      for P := aRect.Left to aRect.Right do
      begin
        m := p - 1;
        if (CurLn[p].R <> CurLn[m].R) or (CurLn[p].G <> CurLn[m].G) or (CurLn[p].B <> CurLn[m].B) then
        begin
          CurLn[m].R := Round(CurLn[p].R + (CurLn[m].R - CurLn[p].R) * nCent);
          CurLn[m].G := Round(CurLn[p].G + (CurLn[m].G - CurLn[p].G) * nCent);
          CurLn[m].B := Round(CurLn[p].B + (CurLn[m].B - CurLn[p].B) * nCent);
        end;
 
        m := p + 1;
        if (CurLn[p].R <> CurLn[m].R) or (CurLn[p].G <> CurLn[m].G) or (CurLn[p].B <> CurLn[m].B) then
        begin
          CurLn[m].R := Round(CurLn[p].R + (CurLn[m].R - CurLn[p].R) * nCent);
          CurLn[m].G := Round(CurLn[p].G + (CurLn[m].G - CurLn[p].G) * nCent);
          CurLn[m].B := Round(CurLn[p].B + (CurLn[m].B - CurLn[p].B) * nCent);
        end;
 
        if (CurLn[p].R <> PreLn[P].R) or (CurLn[p].G <> PreLn[P].G) or (CurLn[p].B <> PreLn[P].B) then
        begin
          PreLn[P].R := Round(CurLn[p].R + (PreLn[P].R - CurLn[p].R) * nCent);
          PreLn[P].G := Round(CurLn[p].G + (PreLn[P].G - CurLn[p].G) * nCent);
          PreLn[P].B := Round(CurLn[p].B + (PreLn[P].B - CurLn[p].B) * nCent);
        end;
 
        if (CurLn[p].R <> NexLn[P].R) or (CurLn[p].G <> NexLn[P].G) or (CurLn[p].B <> NexLn[P].B) then
        begin
          NexLn[P].R := Round(CurLn[p].R + (NexLn[P].R - CurLn[p].R) * nCent);
          NexLn[P].G := Round(CurLn[p].G + (NexLn[P].G - CurLn[p].G) * nCent);
          NexLn[P].B := Round(CurLn[p].B + (NexLn[P].B - CurLn[p].B) * nCent);
        end;
      end;
    end;
  end;