Circular spectrum visualizer

[EWeiss]

Zitat:

ganz einfach zugreifen?

Nun wenn man nicht davor sitzt ist es einfach ja da gebe ich dir recht.

Um die Effekte korrekt darzustellen benötige ich die X, Y Position eines jeden Pixel.
Die habe ich aber in der Funktion BitmapData nicht zur Verfügung.

So die originale Funktion der GDIP in der GDIObject.pas holt sich die Daten mit

Delphi-Quellcode:

  function TGPBitmap.GetPixel(x, y: Integer; out color: TGPColor): TStatus;
   begin
     result := SetStatus(GdipBitmapGetPixel(GpBitmap(nativeImage), x, y, color));
   end;

Das ist aber definitiv falsch denn dann macht GDIPBitmapLockBits keinen sinn mehr.
Gerade wegen der NICHT Verwendung von GdipBitmapGetPixel kann man die Schnelligkeit wie die Pixel über BitmapData gelesen werden erst erfassen.

GdipBitmapGetPixel verursacht eine Auslastung der CPU von 30%

Ich habe mir jetzt eine Hilfsfunktion geschrieben die macht folgendes.

Delphi-Quellcode:

function TSpectrum.BitmapLockBits(Img: LONG_PTR): TBitmapData;
var
  X, Y : integer;
  RGBQuad  : PRGBQuad;
  Pixel : TRGBQuad;
  BitmapData : TBitmapData;

function Scanline(BitmapData : TBitmapData; Stride: integer): PRGBQuad;
begin
    result := BitmapData.Scan0;
    inc(PByte(result), Stride * bitmapData.stride);
end;

begin
  if GDIP_BitmapLockBits(Img, nil, ImageLockModeRead or ImageLockModeWrite,
    PixelFormat32bppARGB, @BitmapData) = OK then
  begin
    for Y := 0 to BitmapData.Height - 1 do
    begin
      RGBQuad := Scanline(BitmapData, Y);
      for X := 0 to BitmapData.Width - 1 do
      begin
        Pixel := RGBQuad^;
        SpectrumData2D[X, Y] := DWord(Pixel);
        inc(RGBQuad);
      end;
    end;
    Result := BitmapData;
  end;
end;

Sie füllt mein leeres Array mit Daten an den benötigten X,Y Positionen.
Jetzt arbeite ich wie bisher mit dem Array und kann mir GdipBitmapGetPixel ersparen.

Die fertige Funktion vom Fire Effekt sieht so aus und ja sie läuft wie sie soll.

Delphi-Quellcode:

    2:
      begin
        d := round(FFade * 64);
        BitmapData := BitmapLockBits(imgSpectrum);

        Buf := SpectrumData2D;

        if FSymmetrical then
        begin
          o := 0;
          s := 239 * 2;
        end else
        begin
          o := 0.5;
          s := 239;
        end;

        for Row := 0 to BitmapData.Height - 1 do
        begin
          RGBQuad := Scanline(BitmapData, Row);

          for Col := 0 to BitmapData.Width - 1 do
          begin
            Pixel := RGBQuad^;

            cx := Col / s - o;
            cy := Row / (BitmapData.Height - 1) - 0.5;

            radius := round(Sqrt(cx * cx + cy * cy));

            dx := round((cx + o + 0.01 * cx * ((radius - 1) / 0.5)) * s);
            dy := round((cy + 0.5 + 0.01 * cy * ((radius - 1) / 0.5)) * (BitmapData.Height - 1));

            alpha := Buf[dx, dy] shr 24;

            if alpha >= d then
              Pixel.rgbReserved := alpha - d
            else
            Pixel.rgbReserved := 0;

            Color := Buf[dx, dy] and $00FFFFFF;
            SKAERO_SplitColorARGB((Pixel.rgbReserved shl 24) or Color, _a, _r, _g, _b);

            Pixel.rgbBlue := _b;
            Pixel.rgbGreen := _g;
            Pixel.rgbRed := _r;
            Pixel.rgbReserved := _a;

            RGBQuad^ := Pixel;
            inc(RGBQuad);

          end;
          GDIP_BitmapUnlockBits(imgSpectrum, @BitmapData);
        end;
      end;

gruss