Uma questão bastante popular é como obter acesso rápido aos pixels do TBBITMAP ?
É fácil de fazer em Delphi , com a propriedade Scanline [] , devido ao número limitado de formatos de pixel, mas é difícil em Lázaro .
Por exemplo: https://wiki.freepsal.org/fast_direct_pixel_access
Proponho um pequeno arquivo único, módulo "bitmappixels.pas" que simplificam o trabalho para chamar tbitmapdata.map () e tbitmapdata.unmap () .
Você recebe uma matriz de pixels de $ aarrggbb na propriedade de dados , e é um conjunto de pixels de pixels usando setPixel ()/getPixel () .
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec; // for easy access to the channels
begin
// Reading the colors of the image into map "Data", width mode "ReadWrite", in the "False" alpha channel mode.
// The alpha channel will be set to 0 on every element of the array. ($00RRGGBB, $00RRGGBB, ...)
Data.Map(Bitmap, TAccessMode.ReadWrite, False);
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
// Read color at (X, Y) to Pixel record
Pixel := Data.GetPixel(X, Y);
// some changes of Pixel
Pixel.R := (Pixel.R + Pixel.G + Pixel.B) div 3 ;
Pixel.G := Pixel.R;
Pixel.B := Pixel.R;
// ...
// Write Pixel record to (X, Y) in map
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
// Writing the map to the image.
// Since we have abandoned Alpha, the pixel format will be set to pf24bit.
Data.Unmap();
end ;
end ;Principais recursos:

procedure InvertColors ( const Bitmap: TBitmap);
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Data.Map(Bitmap, TAccessMode.ReadWrite, False); // RGB access
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel := Data.GetPixel(X, Y);
Pixel.R := 255 - Pixel.R;
Pixel.G := 255 - Pixel.G;
Pixel.B := 255 - Pixel.B;
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ; 
procedure HalfAlpha ( const Bitmap: TBitmap);
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Data.Map(Bitmap, TAccessMode.ReadWrite, True); // ARGB access
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel := Data.GetPixel(X, Y);
Pixel.A := Pixel.A div 2 ;
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ; 
function MakePlasm (): TBitmap;
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Result := TBitmap.Create();
Result.SetSize( 300 , 300 );
Data.Map(Result, TAccessMode.Write, False);
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel.R := Byte(Trunc(
100 + 100 * (Sin(X * Cos(Y * 0.049 ) * 0.01 ) + Cos(X * 0.0123 - Y * 0.09 ))));
Pixel.G := 0 ;
Pixel.B := Byte(Trunc(
Pixel.R + 100 * (Sin(X * Cos(X * 0.039 ) * 0.022 ) + Sin(X * 0.01 - Y * 0.029 ))));
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ;
function Mix ( const A, B: TBitmap): TBitmap;
function Min (A, B: Integer): Integer;
begin
if A < B then Exit(A) else Exit(B);
end ;
var
DataA, DataB, DataResult: TBitmapData;
X, Y: Integer;
PixelA, PixelB, PixelResult: TPixelRec;
begin
Result := TBitmap.Create();
Result.SetSize(Min(A.Width, B.Width), Min(A.Height, B.Height));
// this needed for correct Unmap() on exception
DataA.Init();
DataB.Init();
DataResult.Init();
try
DataA.Map(A, TAccessMode.Read, False);
DataB.Map(B, TAccessMode.Read, False);
DataResult.Map(Result, TAccessMode.Write, False);
for Y := 0 to DataResult.Height - 1 do
begin
for X := 0 to DataResult.Width - 1 do
begin
PixelA := DataA.Pixels[X, Y];
PixelB := DataB.Pixels[X, Y];
PixelResult.R := (PixelA.R + PixelB.R) div 2 ;
PixelResult.G := (PixelA.G + PixelB.G) div 2 ;
PixelResult.B := (PixelA.B + PixelB.B) div 2 ;
DataResult[X, Y] := PixelResult;
end ;
end ;
finally
DataA.Unmap();
DataB.Unmap();
DataResult.Unmap();
end ;
end ; Есть довольно популярный, в сообществе Lazarus разработчиков, вопрос: Как получить быстрый доступ к пикселам TBitmap ?
Это легко сделать в Delphi благодаря свойству Scanline[] из-за довольно ограниченного количества возможных форматов пикселей, но доéri оно cho сжно Lázaro .
# Nchaм с слноeir, ктторые могт взни deve: https://wiki.freepsal.org/fast_direct_pixel_access.
Я пnchaдлаю нооошшш, и иие ое в в в в в в в в в в вее в е в вее в вле вле влл в furmAppixels.pas " , который Ã Tbitmapdata.unmap () .
Ы п полчаетететааси<и deu в в м в в в в в в dados, dados, a а жж аллч аTrgbB слллллсчч аTrgbB сллллсч аTrggbB Dados, arggbb с сTrgbb. помощщю setPixel ()/getPixel () .
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec; // for easy access to the channels
begin
// Reading the colors of the image into map "Data", width mode "ReadWrite", in the "False" alpha channel mode.
// The alpha channel will be set to 0 on every element of the array. ($00RRGGBB, $00RRGGBB, ...)
Data.Map(Bitmap, TAccessMode.ReadWrite, False);
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
// Read color at (X, Y) to Pixel record
Pixel := Data.GetPixel(X, Y);
// some changes of Pixel
Pixel.R := (Pixel.R + Pixel.G + Pixel.B) div 3 ;
Pixel.G := Pixel.R;
Pixel.B := Pixel.R;
// ...
// Write Pixel record to (X, Y) in map
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
// Writing the map to the image.
// Since we have abandoned Alpha, the pixel format will be set to pf24bit.
Data.Unmap();
end ;
end ;Оно Sou чичи:

procedure InvertColors ( const Bitmap: TBitmap);
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Data.Map(Bitmap, TAccessMode.ReadWrite, False); // RGB access
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel := Data.GetPixel(X, Y);
Pixel.R := 255 - Pixel.R;
Pixel.G := 255 - Pixel.G;
Pixel.B := 255 - Pixel.B;
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ; 
procedure HalfAlpha ( const Bitmap: TBitmap);
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Data.Map(Bitmap, TAccessMode.ReadWrite, True); // ARGB access
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel := Data.GetPixel(X, Y);
Pixel.A := Pixel.A div 2 ;
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ; 
function MakePlasm (): TBitmap;
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Result := TBitmap.Create();
Result.SetSize( 300 , 300 );
Data.Map(Result, TAccessMode.Write, False);
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel.R := Byte(Trunc(
100 + 100 * (Sin(X * Cos(Y * 0.049 ) * 0.01 ) + Cos(X * 0.0123 - Y * 0.09 ))));
Pixel.G := 0 ;
Pixel.B := Byte(Trunc(
Pixel.R + 100 * (Sin(X * Cos(X * 0.039 ) * 0.022 ) + Sin(X * 0.01 - Y * 0.029 ))));
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ;
function Mix ( const A, B: TBitmap): TBitmap;
function Min (A, B: Integer): Integer;
begin
if A < B then Exit(A) else Exit(B);
end ;
var
DataA, DataB, DataResult: TBitmapData;
X, Y: Integer;
PixelA, PixelB, PixelResult: TPixelRec;
begin
Result := TBitmap.Create();
Result.SetSize(Min(A.Width, B.Width), Min(A.Height, B.Height));
// this needed for correct Unmap() on exception
DataA.Init();
DataB.Init();
DataResult.Init();
try
DataA.Map(A, TAccessMode.Read, False);
DataB.Map(B, TAccessMode.Read, False);
DataResult.Map(Result, TAccessMode.Write, False);
for Y := 0 to DataResult.Height - 1 do
begin
for X := 0 to DataResult.Width - 1 do
begin
PixelA := DataA.Pixels[X, Y];
PixelB := DataB.Pixels[X, Y];
PixelResult.R := (PixelA.R + PixelB.R) div 2 ;
PixelResult.G := (PixelA.G + PixelB.G) div 2 ;
PixelResult.B := (PixelA.B + PixelB.B) div 2 ;
DataResult[X, Y] := PixelResult;
end ;
end ;
finally
DataA.Unmap();
DataB.Unmap();
DataResult.Unmap();
end ;
end ; Є досить популярне, у спільноті Lazarus розробників, питання: Як отримати швидкий доступ до пікселів TBitmap?
Л л л л ц ц л л л з з з л л з з з з л з з з з з з з з ззnchi зphяиfia влллиииииияяяfia ззяииfia. Lázaro .
Приоncer с саднощ п, мж мжть иини deve: https://wiki.freepsal.org/fast_direct_pixel_access.
Я пропоную невеликий, у вигляді одного файлу, модуль "BitmapPixels.pas " , який спрощує роботу до простого виклику TBitmapData.Map() і Tbitmapdata.unmap () .
Ви отримуєте масив пікселів у форматі $AARRGGBB у властивості Data , а також можливість встановити та отримати колір пікселів зз допомогою setPixel ()/getPixel () .
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec; // for easy access to the channels
begin
// Reading the colors of the image into map "Data", width mode "ReadWrite", in the "False" alpha channel mode.
// The alpha channel will be set to 0 on every element of the array. ($00RRGGBB, $00RRGGBB, ...)
Data.Map(Bitmap, TAccessMode.ReadWrite, False);
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
// Read color at (X, Y) to Pixel record
Pixel := Data.GetPixel(X, Y);
// some changes of Pixel
Pixel.R := (Pixel.R + Pixel.G + Pixel.B) div 3 ;
Pixel.G := Pixel.R;
Pixel.B := Pixel.R;
// ...
// Write Pixel record to (X, Y) in map
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
// Writing the map to the image.
// Since we have abandoned Alpha, the pixel format will be set to pf24bit.
Data.Unmap();
end ;
end ;Оно sul н:

procedure InvertColors ( const Bitmap: TBitmap);
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Data.Map(Bitmap, TAccessMode.ReadWrite, False); // RGB access
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel := Data.GetPixel(X, Y);
Pixel.R := 255 - Pixel.R;
Pixel.G := 255 - Pixel.G;
Pixel.B := 255 - Pixel.B;
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ; 
procedure HalfAlpha ( const Bitmap: TBitmap);
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Data.Map(Bitmap, TAccessMode.ReadWrite, True); // ARGB access
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel := Data.GetPixel(X, Y);
Pixel.A := Pixel.A div 2 ;
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ; 
function MakePlasm (): TBitmap;
var
Data: TBitmapData;
X, Y: Integer;
Pixel: TPixelRec;
begin
Result := TBitmap.Create();
Result.SetSize( 300 , 300 );
Data.Map(Result, TAccessMode.Write, False);
try
for Y := 0 to Data.Height - 1 do
begin
for X := 0 to Data.Width - 1 do
begin
Pixel.R := Byte(Trunc(
100 + 100 * (Sin(X * Cos(Y * 0.049 ) * 0.01 ) + Cos(X * 0.0123 - Y * 0.09 ))));
Pixel.G := 0 ;
Pixel.B := Byte(Trunc(
Pixel.R + 100 * (Sin(X * Cos(X * 0.039 ) * 0.022 ) + Sin(X * 0.01 - Y * 0.029 ))));
Data.SetPixel(X, Y, Pixel);
end ;
end ;
finally
Data.Unmap();
end ;
end ;
function Mix ( const A, B: TBitmap): TBitmap;
function Min (A, B: Integer): Integer;
begin
if A < B then Exit(A) else Exit(B);
end ;
var
DataA, DataB, DataResult: TBitmapData;
X, Y: Integer;
PixelA, PixelB, PixelResult: TPixelRec;
begin
Result := TBitmap.Create();
Result.SetSize(Min(A.Width, B.Width), Min(A.Height, B.Height));
// this needed for correct Unmap() on exception
DataA.Init();
DataB.Init();
DataResult.Init();
try
DataA.Map(A, TAccessMode.Read, False);
DataB.Map(B, TAccessMode.Read, False);
DataResult.Map(Result, TAccessMode.Write, False);
for Y := 0 to DataResult.Height - 1 do
begin
for X := 0 to DataResult.Width - 1 do
begin
PixelA := DataA.Pixels[X, Y];
PixelB := DataB.Pixels[X, Y];
PixelResult.R := (PixelA.R + PixelB.R) div 2 ;
PixelResult.G := (PixelA.G + PixelB.G) div 2 ;
PixelResult.B := (PixelA.B + PixelB.B) div 2 ;
DataResult[X, Y] := PixelResult;
end ;
end ;
finally
DataA.Unmap();
DataB.Unmap();
DataResult.Unmap();
end ;
end ;