Changeset 30 for trunk/Packages/Common/PixelPointer.pas

Timestamp:

Jun 28, 2024, 11:08:43 PM (5 months ago)

Author:

chronos

Message:

• Modified: Updated Common package.

File:

• trunk/Packages/Common/PixelPointer.pas (moved) (moved from trunk/Packages/Common/UPixelPointer.pas ) (18 diffs)

trunk/Packages/Common/PixelPointer.pas

@@ -1 @@
-unit UPixelPointer;
+unit PixelPointer;
 
 interface
 
 uses
-  Classes, SysUtils, Graphics;
+  Math, Classes, SysUtils, Graphics;
 
 type
   TColor32 = type Cardinal;
   TColor32Component = (ccBlue, ccGreen, ccRed, ccAlpha);
+  TColor32Planes = array[0..3] of Byte;
 
   { TPixel32 }
@@ -14 +15 @@
   TPixel32 = packed record
   private
-    procedure SetRGB(AValue: Cardinal);
-    function GetRGB: Cardinal;    
+    procedure SetRGB(AValue: Cardinal); inline;
+    function GetRGB: Cardinal; inline;
   public
+    class function CreateRGB(R, G, B: Byte): TPixel32; static;
+    class function CreateRGBA(R, G, B, A: Byte): TPixel32; static;
     property RGB: Cardinal read GetRGB write SetRGB;
     case Integer of
       0: (B, G, R, A: Byte);
       1: (ARGB: TColor32);
-      2: (Planes: array[0..3] of Byte);
+      2: (Planes: TColor32Planes);
       3: (Components: array[TColor32Component] of Byte);
   end;
@@ -29 +32 @@
 
   TPixelPointer = record
+  private
+    function GetPixelARGB: TColor32; inline;
+    function GetPixelB: Byte; inline;
+    function GetPixelG: Byte; inline;
+    function GetPixelPlane(Index: Byte): Byte; inline;
+    function GetPixelR: Byte; inline;
+    function GetPixelA: Byte; inline;
+    function GetPixelPlanes: TColor32Planes;
+    function GetPixelRGB: Cardinal; inline;
+    procedure SetPixelARGB(Value: TColor32); inline;
+    procedure SetPixelB(Value: Byte); inline;
+    procedure SetPixelG(Value: Byte); inline;
+    procedure SetPixelPlane(Index: Byte; AValue: Byte); inline;
+    procedure SetPixelR(Value: Byte); inline;
+    procedure SetPixelA(Value: Byte); inline;
+    procedure SetPixelRGB(Value: Cardinal); inline;
+  public
     Base: PPixel32;
     Pixel: PPixel32;
@@ -35 +55 @@
     BytesPerPixel: Integer;
     BytesPerLine: Integer;
+    Data: PPixel32;
+    Width: Integer;
+    Height: Integer;
     procedure NextLine; inline; // Move pointer to start of next line
     procedure PreviousLine; inline; // Move pointer to start of previous line
@@ -41 +64 @@
     procedure SetXY(X, Y: Integer); inline; // Set pixel position relative to base
     procedure SetX(X: Integer); inline; // Set horizontal pixel position relative to base
+    procedure CheckRange; inline; // Check if current pixel position is not out of range
+    function PosValid: Boolean;
+    class function Create(Bitmap: TRasterImage; BaseX: Integer = 0; BaseY: Integer = 0): TPixelPointer; static;
+    property PixelARGB: TColor32 read GetPixelARGB write SetPixelARGB;
+    property PixelRGB: Cardinal read GetPixelRGB write SetPixelRGB;
+    property PixelB: Byte read GetPixelB write SetPixelB;
+    property PixelG: Byte read GetPixelG write SetPixelG;
+    property PixelR: Byte read GetPixelR write SetPixelR;
+    property PixelA: Byte read GetPixelA write SetPixelA;
+    property PixelPlane[Index: Byte]: Byte read GetPixelPlane write SetPixelPlane;
   end;
   PPixelPointer = ^TPixelPointer;
 
-  function PixelPointer(Bitmap: TRasterImage; BaseX: Integer = 0; BaseY: Integer = 0): TPixelPointer; inline;
   function SwapRedBlue(Color: TColor32): TColor32;
   procedure BitmapCopyRect(DstBitmap: TRasterImage; DstRect: TRect; SrcBitmap: TRasterImage; SrcPos: TPoint);
@@ -63 +95 @@
 implementation
 
+resourcestring
+  SOutOfRange = 'Pixel pointer out of range [X: %d, Y: %d, Width: %d, Height: %d]';
+  SWrongBitmapSize = 'Wrong bitmap size [width: %d, height: %d]';
+
 { TPixel32 }
 
@@ -70 +106 @@
 end;
 
+class function TPixel32.CreateRGB(R, G, B: Byte): TPixel32;
+begin
+  Result.R := R;
+  Result.G := G;
+  Result.B := B;
+  Result.A := 0;
+end;
+
+class function TPixel32.CreateRGBA(R, G, B, A: Byte): TPixel32;
+begin
+  Result.R := R;
+  Result.G := G;
+  Result.B := B;
+  Result.A := A;
+end;
+
 procedure TPixel32.SetRGB(AValue: Cardinal);
 begin
-  R := (AValue shr 16) and $ff;
-  G := (AValue shr 8) and $ff;
-  B := (AValue shr 0) and $ff;
+  ARGB := (ARGB and $ff000000) or (AValue and $ffffff);
 end;
 
@@ -112 +162 @@
 end;
 
+procedure TPixelPointer.CheckRange;
+{$IFOPT R+}
+var
+  X: Integer;
+  Y: Integer;
+{$ENDIF}
+begin
+  {$IFOPT R+}
+  if (PByte(Pixel) < PByte(Data)) or
+    (PByte(Pixel) >= PByte(Data) + Height * BytesPerLine) then begin
+    X := PByte(Pixel) - PByte(Data);
+    Y := Floor(X / BytesPerLine);
+    X := X - Y * BytesPerLine;
+    X := Floor(X / BytesPerPixel);
+    raise Exception.Create(Format(SOutOfRange, [X, Y, Width, Height]));
+  end;
+  {$ENDIF}
+end;
+
+function TPixelPointer.PosValid: Boolean;
+begin
+  Result := not ((PByte(Pixel) < PByte(Data)) or
+    (PByte(Pixel) >= PByte(Data) + Height * BytesPerLine));
+end;
+
+function TPixelPointer.GetPixelPlanes: TColor32Planes;
+begin
+  CheckRange;
+  Result := Pixel^.Planes;
+end;
+
+function TPixelPointer.GetPixelRGB: Cardinal;
+begin
+  CheckRange;
+  Result := Pixel^.RGB;
+end;
+
+procedure TPixelPointer.SetPixelARGB(Value: TColor32);
+begin
+  CheckRange;
+  Pixel^.ARGB := Value;
+end;
+
+procedure TPixelPointer.SetPixelB(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.B := Value;
+end;
+
+procedure TPixelPointer.SetPixelG(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.G := Value;
+end;
+
+procedure TPixelPointer.SetPixelPlane(Index: Byte; AValue: Byte);
+begin
+  CheckRange;
+  Pixel^.Planes[Index] := AValue;
+end;
+
+procedure TPixelPointer.SetPixelR(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.R := Value;
+end;
+
+procedure TPixelPointer.SetPixelA(Value: Byte);
+begin
+  CheckRange;
+  Pixel^.A := Value;
+end;
+
+function TPixelPointer.GetPixelARGB: TColor32;
+begin
+  CheckRange;
+  Result := Pixel^.ARGB;
+end;
+
+function TPixelPointer.GetPixelB: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.B;
+end;
+
+function TPixelPointer.GetPixelG: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.G;
+end;
+
+function TPixelPointer.GetPixelPlane(Index: Byte): Byte;
+begin
+  CheckRange;
+  Result := Pixel^.Planes[Index];
+end;
+
+function TPixelPointer.GetPixelR: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.R;
+end;
+
+function TPixelPointer.GetPixelA: Byte;
+begin
+  CheckRange;
+  Result := Pixel^.A;
+end;
+
+procedure TPixelPointer.SetPixelRGB(Value: Cardinal);
+begin
+  CheckRange;
+  Pixel^.RGB := Value;
+end;
+
 procedure BitmapCopyRect(DstBitmap: TRasterImage; DstRect: TRect;
   SrcBitmap: TRasterImage; SrcPos: TPoint);
@@ -120 +285 @@
   SrcBitmap.BeginUpdate(True);
   DstBitmap.BeginUpdate(True);
-  SrcPtr := PixelPointer(SrcBitmap, SrcPos.X, SrcPos.Y);
-  DstPtr := PixelPointer(DstBitmap, DstRect.Left, DstRect.Top);
+  SrcPtr := TPixelPointer.Create(SrcBitmap, SrcPos.X, SrcPos.Y);
+  DstPtr := TPixelPointer.Create(DstBitmap, DstRect.Left, DstRect.Top);
   for Y := 0 to DstRect.Height - 1 do begin
     for X := 0 to DstRect.Width - 1 do begin
-      DstPtr.Pixel^.ARGB := SrcPtr.Pixel^.ARGB;
+      DstPtr.PixelARGB := SrcPtr.PixelARGB;
       SrcPtr.NextPixel;
       DstPtr.NextPixel;
@@ -150 +315 @@
   SrcBitmap.BeginUpdate(True);
   DstBitmap.BeginUpdate(True);
-  SrcPtr := PixelPointer(SrcBitmap, SrcRect.Left, SrcRect.Top);
-  DstPtr := PixelPointer(DstBitmap, DstRect.Left, DstRect.Top);
+  SrcPtr := TPixelPointer.Create(SrcBitmap, SrcRect.Left, SrcRect.Top);
+  DstPtr := TPixelPointer.Create(DstBitmap, DstRect.Left, DstRect.Top);
   for Y := 0 to DstRect.Height - 1 do begin
     for X := 0 to DstRect.Width - 1 do begin
@@ -160 +325 @@
       DstPtr.SetXY(X, Y);
       SrcPtr.SetXY(R.Left, R.Top);
-      C := SrcPtr.Pixel^.ARGB;
-      DstPtr.Pixel^.ARGB := C;
+      C := SrcPtr.PixelARGB;
+      DstPtr.PixelARGB := C;
       for YY := 0 to R.Height - 1 do begin
         for XX := 0 to R.Width - 1 do begin
-          DstPtr.Pixel^.ARGB := C;
+          DstPtr.PixelARGB := C;
           DstPtr.NextPixel;
         end;
@@ -181 +346 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      Ptr.Pixel^.ARGB := Color;
+      Ptr.PixelARGB := Color;
       Ptr.NextPixel;
     end;
@@ -198 +363 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap, Rect.Left, Rect.Top);
+  Ptr := TPixelPointer.Create(Bitmap, Rect.Left, Rect.Top);
   for Y := 0 to Rect.Height - 1 do begin
     for X := 0 to Rect.Width - 1 do begin
-      Ptr.Pixel^.ARGB := Color;
+      Ptr.PixelARGB := Color;
       Ptr.NextPixel;
     end;
@@ -215 +380 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      Ptr.Pixel^.ARGB := SwapRedBlue(Ptr.Pixel^.ARGB);
+      Ptr.PixelARGB := SwapRedBlue(Ptr.PixelARGB);
       Ptr.NextPixel;
     end;
@@ -232 +397 @@
 begin
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      Ptr.Pixel^.ARGB := Ptr.Pixel^.ARGB xor $ffffff;
+      Ptr.PixelARGB := Ptr.PixelARGB xor $ffffff;
       Ptr.NextPixel;
     end;
@@ -252 +417 @@
   Pixel := Color32ToPixel32(Color);
   Bitmap.BeginUpdate(True);
-  Ptr := PixelPointer(Bitmap);
+  Ptr := TPixelPointer.Create(Bitmap);
   for Y := 0 to Bitmap.Height - 1 do begin
     for X := 0 to Bitmap.Width - 1 do begin
-      A := Ptr.Pixel^.A; //(Ptr.Pixel^.A + Pixel.A) shr 1;
-      R := (Ptr.Pixel^.R + Pixel.R) shr 1;
-      G := (Ptr.Pixel^.G + Pixel.G) shr 1;
-      B := (Ptr.Pixel^.B + Pixel.B) shr 1;
-      Ptr.Pixel^.ARGB := Color32(A, R, G, B);
+      A := Ptr.PixelA; //(Ptr.PixelA + Pixel.A) shr 1;
+      R := (Ptr.PixelR + Pixel.R) shr 1;
+      G := (Ptr.PixelG + Pixel.G) shr 1;
+      B := (Ptr.PixelB + Pixel.B) shr 1;
+      Ptr.PixelARGB := Color32(A, R, G, B);
       Ptr.NextPixel;
     end;
@@ -295 +460 @@
 end;
 
-function PixelPointer(Bitmap: TRasterImage; BaseX: Integer;
+class function TPixelPointer.Create(Bitmap: TRasterImage; BaseX: Integer;
   BaseY: Integer): TPixelPointer;
 begin
+  Result.Width := Bitmap.Width;
+  Result.Height := Bitmap.Height;
+  if (Result.Width < 0) or (Result.Height < 0) then
+    raise Exception.Create(Format(SWrongBitmapSize, [Result.Width, Result.Height]));
   Result.BytesPerLine := Bitmap.RawImage.Description.BytesPerLine;
   Result.BytesPerPixel := Bitmap.RawImage.Description.BitsPerPixel shr 3;
+  Result.Data := PPixel32(Bitmap.RawImage.Data);
   Result.Base := PPixel32(Bitmap.RawImage.Data + BaseX * Result.BytesPerPixel +
     BaseY * Result.BytesPerLine);
@@ -310 +480 @@
 end;
 
-
 end.
-