[[Delphius]]

Como el procesamiento se realiza sobre un mapa de bits, al intentar guardarlo como jpg fallará. Para hacer esto deberás convertir tu mapa de bits a jpg empleando la clase TJPEGImage:

Código Delphi [-]
               procedure TForm1.Button1Click(Sender: TObject);
               var 
                 MyJPEG : TJPEGImage;
                 MyBMP  : TBitmap;
               begin 
                 MyBMP := TBitmap.Create;
                 with MyBMP do 
                   try
                     {Cargamos el BMP}
                     {Load the BMP} 
                     LoadFromFile('YourBmpHere.BMP');
                     MyJPEG := TJPEGImage.Create;
                     with MyJPEG do begin 
                       Assign(MyBMP);
                       {Grabamos el JPG}
                       {Save the JPG}
                       SaveToFile('YourJpegHere.JPEG');
                       Free;
                     end; 
                   finally
                     Free;
                   end; 
               end;

Este código lo saqué de trucomania (Truco n° 147).

He visto que empleas la orden Pixels[] para que de acuerdo a una coordenada puedas conocer el valor. La misma ayuda de Delphi aclara que emplear este método es lento. Que es recomendable usar ScanLine().

Lo malo de emplear scanline es que es un poquito más complicado. Ya que hay que ir corriendo el puntero...

Las coordenadas la obtienes como dice seoane:

Código Delphi [-]
function RatonAImagenX(Imagen: TImage; x: integer): integer;
begin
  Result:= (x * Imagen.Picture.Width) div Imagen.Width;
end;

function RatonAImagenY(Imagen: TImage; y: integer): integer;
begin
  Result:= (y * Imagen.Picture.Height) div Imagen.Height;
end;

Ahora para acceder al pixel debemos hacer esto:

1. Tener un puntero de tipo array para acceder a los canales RGB de dicho pixel:

Código Delphi [-]
type
TRGB = array[1..3] of byte;
PRGB = ^TGRB;

2. Accedemos la la posición de memoria en la coordenada Y:

Código Delphi [-]
var RGB = PRGB;
....
RGB := Picture.Bitmap.ScanLine[Y];

3. Una vez ubicados en la posición Y, nos movemos sobre el eje horizontal X veces:

Código Delphi [-]
for pos := 0 to X do
     inc(RGB);

4. Ahora, en RGB quedó registrado el valor de cada canal (Azul = 1, Verde = 2, Rojo = 3). Como sabrás, dicho valor está comprendido en el rango: [0,255]

Código Delphi [-]
Rojo := RGB[3];
Verde := RGB[2];
Azul := RGB[1];

Tiene un poco más de código, pero el acceso mediante scanline es más rápido que el por Pixels. Sobre todo si es que la imagen es grande.

Yo hice una pruebas (del tipo filtrado) "Pixels vs Scanline" y la verdad es que puede llegar a ser perceptible la lentitud.

Espero que te sirva.
Saludos,