Changeset 494 for GraphicTest/Packages/bgrabitmap/blurnormal.inc

Timestamp:

Dec 22, 2016, 8:49:19 PM (8 years ago)

Author:

chronos

Message:

• Modified: Updated BGRABitmap package.

File:

• GraphicTest/Packages/bgrabitmap/blurnormal.inc (modified) (11 diffs)

GraphicTest/Packages/bgrabitmap/blurnormal.inc

@@ +1 @@
+type
+  PWeightedPixel = ^TWeightedPixel;
+  TWeightedPixel = packed record
+    Coord: TPoint;
+    Weight: NativeInt;
+    PtrOfs: NativeInt;
+  end;
+
 var
   maskWidth,maskHeight: integer;
-  blurOfs:      TPoint;
-  PixelWeight:  array of integer;
-  PixelOfs:     array of TPoint;
+  blurOfs: TPoint;
+  ppixel: PWeightedPixel;
+  Pixel: array of TWeightedPixel;
   PixelArrayLineStart: array of integer;
-  DiffPixelWeight:  array of integer;
-  DiffPixelOfs:     array of TPoint;
+  DiffPixel: array of TWeightedPixel;
   DiffPixelArrayLineStart: array of integer;
 
-  procedure LoadMask;
-  var x,y,n: integer;
-      tempWeight: integer;
-      diffMask: array of array of integer;
+  bmpWidth,bmpHeight,lineDelta: NativeInt;
+
+  procedure LoadMask(out ABlurOfs: TPoint);
+  var x,y,n,i: NativeInt;
+      tempWeight: NativeInt;
+      diffMask: array of packed array of NativeInt;
+      p: PBGRAPixel;
   begin
-    blurOfs := point(blurMask.Width shr 1, blurMask.Height shr 1);
+    ABlurOfs := point(blurMask.Width shr 1, blurMask.Height shr 1);
 
     //count number of non empty pixels
@@ -20 +30 @@
     maskHeight := blurMask.Height;
     n := 0;
-    for y := 0 to maskHeight - 1 do
-      for x := 0 to maskWidth - 1 do
-        if blurMask.GetPixel(x, y).red <> 0 then Inc(n);
+    p := blurMask.Data;
+    for i := blurMask.NbPixels-1 downto 0 do
+    begin
+      if p^.red <> 0 then inc(n);
+      inc(p);
+    end;
 
     //initialize arrays
     setlength(diffMask, maskHeight, maskWidth+1);
     for y := 0 to maskHeight - 1 do
-      for x := 0 to maskWidth do
-        diffMask[y,x] := 0;
-
-    setlength(PixelWeight, n);
-    setlength(PixelOfs, n);
+      fillchar(diffMask[y,0], (maskWidth+1)*sizeof(NativeInt), 0);
+
+    setlength(Pixel, n);
     setlength(PixelArrayLineStart, maskHeight+1);  //stores the first pixel of each line
     n := 0;
@@ -38 +49 @@
     begin
       PixelArrayLineStart[y] := n;
+      p := blurMask.ScanLine[y];
       for x := 0 to maskWidth - 1 do
       begin
-        tempWeight := blurMask.GetPixel(x, y).red;
+        tempWeight := p^.red;
+        inc(p);
         diffMask[y,x] -= tempWeight;
         diffMask[y,x+1] += tempWeight;
@@ -46 +59 @@
         if tempWeight <> 0 then
         begin
-          PixelWeight[n] := tempWeight;
-          PixelOfs[n] := Point(x,y);
+          Pixel[n].Weight := tempWeight;
+          Pixel[n].Coord := Point(x,y);
+          Pixel[n].PtrOfs := (y-ABlurOfs.Y)*lineDelta + (x-ABlurOfs.X)*sizeof(TBGRAPixel);
           Inc(n);
         end;
@@ -61 +75 @@
 
     //initialize arrays
-    setlength(DiffPixelWeight, n);
-    setlength(DiffPixelOfs, n);
+    setlength(DiffPixel, n);
     setlength(DiffPixelArrayLineStart, maskHeight+1);  //stores the first pixel of each diff line
     n := 0;
@@ -74 +87 @@
         if tempWeight <> 0 then
         begin
-          DiffPixelWeight[n] := tempWeight;
-          DiffPixelOfs[n] := Point(x-1,y);
+          DiffPixel[n].Weight := tempWeight;
+          DiffPixel[n].Coord := Point(x-1,y);
+          DiffPixel[n].PtrOfs := (y-ABlurOfs.Y)*lineDelta + (x-ABlurOfs.X-1)*sizeof(TBGRAPixel);
           Inc(n);
         end;
@@ -83 +97 @@
   end;
 
-var
-  curScans: array of PBGRAPixel;
-  bounds: TRect;
-
-  {procedure ShowCurScans;
-  var str: string;
-    i: Integer;
-  begin
-    str := '';
-    for i := 0 to high(curScans) do
-    begin
-      if i <> 0 then str += ', ';
-      if curScans[i]=nil then str += 'nil' else
-        str += 'bmp['+inttostr(curScans[i]-bmp.Data)+']';
-    end;
-    ShowMessage(str);
-  end;}
-
-  function PrepareScan: boolean;
-  var
-    bmpY: integer;
-    y   : Integer;
+  function PrepareScan(AWantedBounds: TRect; out AClippedBounds: TRect): boolean;
   begin
     //evaluate required bounds taking blur radius into acount
-    bounds := bmp.GetImageBounds;
-    if IsRectEmpty(bounds) then
+    AClippedBounds := bmp.GetImageBounds;
+    if IsRectEmpty(AClippedBounds) then
     begin
       result := false;
       exit;
     end;
-    bounds.Left   := max(0, bounds.Left - blurOfs.X);
-    bounds.Top    := max(0, bounds.Top - blurOfs.Y);
-    bounds.Right  := min(bmp.Width, bounds.Right + maskWidth - 1 - blurOfs.X);
-    bounds.Bottom := min(bmp.Height, bounds.Bottom + maskHeight - 1 - blurOfs.Y);
-    if not IntersectRect(bounds, bounds, ABounds) then
+    AClippedBounds.Left   := max(0, AClippedBounds.Left - blurOfs.X);
+    AClippedBounds.Top    := max(0, AClippedBounds.Top - blurOfs.Y);
+    AClippedBounds.Right  := min(bmpWidth, AClippedBounds.Right + maskWidth - 1 - blurOfs.X);
+    AClippedBounds.Bottom := min(bmpHeight, AClippedBounds.Bottom + maskHeight - 1 - blurOfs.Y);
+    if not IntersectRect(AClippedBounds, AClippedBounds, AWantedBounds) then
     begin
       result := false;
@@ -123 +116 @@
     end;
 
-    //init scanlines
-    setlength(curScans, maskHeight);
-    for y := 0 to maskHeight-1 do
-    begin
-      bmpY := y+bounds.Top-blurOfs.Y;
-      if (bmpY < 0) or (bmpY >= bmp.Height) then
-        curScans[y] := nil else
-          curScans[y] := bmp.ScanLine[bmpY];
-    end;
-    //ShowCurScans;
     result := true;
   end;
 
-  procedure ShiftScan(NewY: integer); inline;
-  var y: integer;
-  begin
-    for y := 0 to maskHeight-2 do
-     curScans[y] := curScans[y+1];
-
-    //get next scanline
-    if newY >= bmp.Height then
-      curScans[maskHeight-1] := nil
-    else
-      curScans[maskHeight-1] := bmp.ScanLine[newY];
-    //ShowCurScans;
-  end;
-
 var
-  yb, xb: integer;
-  mindy, maxdy, n: integer;
-  bmpWidth,bmpX: integer;
-  pixMaskAlpha, maskAlpha: integer;
+  bounds: TRect;
+  yb, xb: NativeInt;
+  mindy, maxdy, n, nStart, nCount, nDiffStart, nDiffCount: NativeInt;
+  bmpX,bmpXBase,bmpYBase: NativeInt;
+  pixMaskAlpha, maskAlpha: NativeInt;
   tempPixel: TBGRAPixel;
   pdest : PBGRAPixel;
-  pt: TPoint;
+  psrc : PByte;
 
 begin
-  LoadMask;
-
-  if (ADestination.Width <> bmp.Width) or (ADestination.Height <> bmp.Height) then
+  bmpWidth := bmp.Width;
+  bmpHeight:= bmp.Height;
+  if bmp.LineOrder = riloTopToBottom then
+    lineDelta := bmpWidth*sizeof(TBGRAPixel) else
+    lineDelta := -bmpWidth*sizeof(TBGRAPixel);
+
+  if (ADestination.Width <> bmpWidth) or (ADestination.Height <> bmpHeight) then
     raise exception.Create('Dimension mismatch');
 
-  if not PrepareScan then exit; //nothing to do
-
-  bmpWidth := bmp.Width;
+  LoadMask(blurOfs);
+  if not PrepareScan(ABounds, bounds) then exit; //nothing to do
+
+  bmpYBase := bounds.Top - blurOfs.Y;
+
   //loop through destination
   for yb := bounds.Top to bounds.Bottom - 1 do
   begin
     if (ACheckShouldStop <> nil) and ACheckShouldStop(yb) then break;
+    psrc := PByte(bmp.ScanLine[yb]+bounds.Left);
     pdest := ADestination.ScanLine[yb] + bounds.Left;
     //compute vertical range
     mindy := max(-blurOfs.Y, -yb);
-    maxdy := min(blurMask.Height - 1 - blurOfs.Y, bmp.Height - 1 - yb);
+    maxdy := min(blurMask.Height - 1 - blurOfs.Y, bmpHeight - 1 - yb);
 
     sumR   := 0;
@@ -186 +163 @@
     {$endif}
 
+    bmpXBase := bounds.Left-blurOfs.X;
+    nStart := PixelArrayLineStart[mindy+blurOfs.Y];
+    nCount  := PixelArrayLineStart[maxdy+blurOfs.Y+1]-nStart;
+    ppixel:= @Pixel[nStart];
     //go through pixel list of the current vertical range
-    for n := PixelArrayLineStart[mindy+blurOfs.Y] to PixelArrayLineStart[maxdy+blurOfs.Y+1]-1 do
-    begin
-      pt := PixelOfs[n];
-      bmpX := bounds.Left-blurOfs.X+pt.x;
+    for n := nCount-1 downto 0 do
+    begin
+      bmpX := bmpXBase+ppixel^.Coord.x;
       //check horizontal range
       if (bmpX >= 0) and (bmpX < bmpWidth) then
       begin
-        tempPixel := (curScans[pt.y]+bmpX)^;
-        maskAlpha := PixelWeight[n];
+        tempPixel := PBGRAPixel(psrc + ppixel^.PtrOfs)^;
+        maskAlpha := ppixel^.Weight;
         pixMaskAlpha := maskAlpha * tempPixel.alpha;
         sumA    += pixMaskAlpha;
@@ -209 +189 @@
         {$hints on}
       end;
-    end;
-
-    for xb := bounds.Left to Bounds.Right - 1 do
-    begin
-      if xb > bounds.left then
-      begin
-        for n := DiffPixelArrayLineStart[mindy+blurOfs.Y] to DiffPixelArrayLineStart[maxdy+blurOfs.Y+1]-1 do
-        begin
-          pt := DiffPixelOfs[n];
-          bmpX := xb-blurOfs.X+pt.x;
+      inc(ppixel);
+    end;
+
+    //compute average
+    if (Adiv <= 0) {$ifdef PARAM_MASKSHIFT} or (RGBdiv <= 0) {$endif} then
+      pdest^ := BGRAPixelTransparent
+    else
+      pdest^ := computeAverage;
+
+    nDiffStart := DiffPixelArrayLineStart[mindy+blurOfs.Y];
+    nDiffCount := DiffPixelArrayLineStart[maxdy+blurOfs.Y+1]-nDiffStart;
+
+    if nDiffCount < nCount then
+    begin
+      for xb := bounds.Left+1 to Bounds.Right - 1 do
+      begin
+        Inc(pdest);
+        inc(bmpXBase);
+        inc(psrc,sizeof(TBGRAPixel));
+
+        ppixel:= @DiffPixel[nDiffStart];
+        for n := nDiffCount-1 downto 0 do
+        begin
+          bmpX := bmpXBase+ppixel^.Coord.x;
           if (bmpX >= 0) and (bmpX < bmpWidth) then
           begin
-            tempPixel := (curScans[pt.y]+bmpX)^;
-            maskAlpha := DiffPixelWeight[n];
+            tempPixel := PBGRAPixel(psrc + ppixel^.PtrOfs)^;
+            maskAlpha := ppixel^.Weight;
             pixMaskAlpha := maskAlpha * tempPixel.alpha;
             sumA    += pixMaskAlpha;
@@ -236 +230 @@
             {$hints on}
           end;
-        end;
-      end;
-
-      //compute average
-      if (Adiv <= 0) {$ifdef PARAM_MASKSHIFT} or (RGBdiv <= 0) {$endif} then
-        pdest^ := BGRAPixelTransparent
-      else
-        pdest^ := computeAverage;
-
-      Inc(pdest);
-    end;
-
-    ShiftScan(yb-blurOfs.Y+maskHeight);
+          inc(ppixel);
+        end;
+
+        //compute average
+        if (Adiv <= 0) {$ifdef PARAM_MASKSHIFT} or (RGBdiv <= 0) {$endif} then
+          pdest^ := BGRAPixelTransparent
+        else
+          pdest^ := ComputeAverage;
+      end;
+    end else
+    begin
+      for xb := bounds.Left+1 to Bounds.Right - 1 do
+      begin
+        Inc(pdest);
+        inc(bmpXBase);
+        inc(psrc,sizeof(TBGRAPixel));
+
+        sumR   := 0;
+        sumG   := 0;
+        sumB   := 0;
+        sumA   := 0;
+        Adiv   := 0;
+        {$ifdef PARAM_MASKSHIFT}
+        RGBdiv := 0;
+        {$endif}
+
+        ppixel:= @Pixel[nStart];
+        for n := nCount-1 downto 0 do
+        begin
+          bmpX := bmpXBase+ppixel^.Coord.x;
+          //check horizontal range
+          if (bmpX >= 0) and (bmpX < bmpWidth) then
+          begin
+            tempPixel := PBGRAPixel(psrc + ppixel^.PtrOfs)^;
+            maskAlpha := ppixel^.Weight;
+            pixMaskAlpha := maskAlpha * tempPixel.alpha;
+            sumA    += pixMaskAlpha;
+            Adiv    += maskAlpha;
+            {$ifdef PARAM_MASKSHIFT}
+            pixMaskAlpha := pixMaskAlpha shr maskShift;
+            RGBdiv  += pixMaskAlpha;
+            {$endif}
+            {$hints off}
+            sumR    += tempPixel.red * pixMaskAlpha;
+            sumG    += tempPixel.green * pixMaskAlpha;
+            sumB    += tempPixel.blue * pixMaskAlpha;
+            {$hints on}
+          end;
+          inc(ppixel);
+        end;
+
+        //compute average
+        if (Adiv <= 0) {$ifdef PARAM_MASKSHIFT} or (RGBdiv <= 0) {$endif} then
+          pdest^ := BGRAPixelTransparent
+        else
+          pdest^ := computeAverage;
+      end;
+    end;
+
+    inc(bmpYBase);
   end;
   ADestination.InvalidateBitmap;