BitMap zeichnen per API

[Aphton]

Du hast 3 Farbkanäle, die jeweils 1 Byte belegen, sprich 1 Farbpunkt belegt 3*1 = 3 Bytes.. Für jeden Farbpunkt pro Scanline musst du 3 Bytes kopieren. Dh. Breite * 3 kommt da rein.

Weiters ist mir persönlich aufgefallen, dass, wenn du die Scanlines ein einziges mal beim setzen der Dimensionen holst bzw zwischenpufferst, das ganze viel schneller läuft, als wenn du es jedes mal per Bitmap.Scanline[i] ne abfragst. Ich glaub der holt sich dann den jeweiligen Pointer per API Befehle, was unnötig ist!

[sintronic86]

@Aphton:
Ok, Breite mal 3: macht Sinn. Aber das würde doch an dem Problem nichts ändern, das ich nicht einfach sagen kann:

TmpALine := OLEVARIANT[I]

da ich damit ja die erste Spalte, statt Zeile anspreche.
Aber davon abgesehen, bekomme ich bei diesem Zugriff auch eine Fehlermeldung:

---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt XXXXXXX.exe ist eine Exception der Klasse EVariantBadIndexError mit der Meldung 'Variante oder sicheres Array-Index außerhalb des gültigen Bereichs' aufgetreten.
---------------------------
Anhalten Fortsetzen Hilfe
---------------------------


Diese kann ich mir aber nicht erklären, da der Zugriff im selben Moment auf OLEVARIANT[I,0] einen
gültigen Wert herausgiebt!

Ich bin echt am verzweifeln. Habe jetzt ein wenig mit BitBlt herumgespielt, und bekomme es hin,
von einem Image in eine Paintbox zu kopieren. Allerdings wüsste ich nicht, wie ich dort mein OleVariant unterbringen kann.

[Blup]

Irgendwie ist der Code seltsam, warum läuft deine I-Schleife gegen Null?
Im Array ist zu jedem Pixel nur ein Byte aufgezeichnet (Graustufen vermutlich).
Du baust daraus ein TmpRGB, verwendest danach aber nur das unteren Byte von TmpRGB.
Dieses wird für jeden Farbkanal einzeln geschrieben (BGR, Pixelformat pf24Bit).

Das geht auch einfacher:

Delphi-Quellcode:

var
  TmpLine: PByte;
  TmpByte: Byte;

for I := 0 to BILDHÖHE - 1 do
begin
  TmpLine := BITMAP.ScanLine[I];

  for J := 0 to BILDBREITE - 1 do
  begin
    TmpByte := OLEVARIANT[I, J]; // Grau
    TmpLine^ := TmpByte; // Blau
    Inc(TmpLine);
    TmpLine^ := TmpByte; // Gruen
    Inc(TmpLine);
    TmpLine^ := TmpByte; // Rot
    Inc(TmpLine);
  end;
end;

Ist das noch nicht schnell genug, wirds komplizierter:
- Pixelformat der Bitmap auf 256Farben mit Palette umgestellt
- Palette mit 256 Graustufen erstellen und für die Bitmap auswählen
- mit SafeArrayLock() und SafeArrayAccessData() einen Pointer auf die Daten des Variant besorgen
- die Daten direkt in die Bitmap kopieren
- mit SafeArrayUnaccessData() und SafeArrayUnlock() den Variant wieder entsperren

[nuclearping]

Zitat von Blup:

Irgendwie ist der Code seltsam, warum läuft deine I-Schleife gegen Null?

Werden BMPs nicht kopfüber gespeichert?

[Medium]

Fast immer. Fast! Windows bot da irgend einen Weg heruaszufinden, wie es denn nun wirklich hinterlegt ist (ich weiss leider echt nicht mehr was das genau war, aber es stand im MSDN (nicht in den Kommentaren)), aber es gibt wohl ganz selten mal den Fall, dass dem nicht so ist. Ob und wann genau das eintritt stand dort leider nicht, und mir sind bisher auch noch keine "richtig-falsch-herumen" Bitmaps begegnet. Das aber nur am Rande

[Blup]

In welcher Reihenfolge die Bildzeilen im Speicher liegen, wird nicht dadurch beeinflusst, in welcher Reihenfolge ich diese kopiere.
Sowohl auf das Variantarray als auch auf ScanLine wird mit dem Index "I" zugegriffen.
Um das Bild vertikal zu spiegeln müsste genau einer der Zugriffe auf "BILDHÖHE - 1 - I" umgestellt werden.

ScanLine berücksichtigt bereits die Ausrichtung der Bilddaten im Speicher.
Scanline[0] ist immer die oberste Zeile, auch wenn diese im Speicher an letzter Stelle liegt.
Die Ole-Schnittstelle legt die Daten vermutlich in der richtigen Reihenfolge im Array ablegt.

[turboPASCAL]

Eine Möglichkeit könnte ich mir so vorstellen:

Delphi-Quellcode:

var
  theBitmapBitArray: array of dword;  // das array vom OleVariant

procedure TForm ...;
var
  theBitmap: HBITMAP;
  pBmpBits: Pointer;
  bi: BITMAPINFO;

  bmpWidth: integer;
  bmpHeight: integer;

begin
  bmpWidth  := 320;
  bmpHeight := 240;

  setlength(theBitmapBitArray, bmpWidth * bmpHeight);

  // ----------------------------------------------------------- //

  ZeroMemory(@bi, sizeof(BITMAPINFO));
  with bi.bmiHeader do
  begin
    biSize := sizeof(BITMAPINFOHEADER);
    biWidth := bmpWidth;
    biHeight := -bmpHeight;
    biCompression := BI_RGB;
    biBitCount := 32;
    biPlanes := 1;
    biXPelsPerMeter := 0;
    biYPelsPerMeter := 0;
    biClrUsed := 0;
    biClrImportant := 0;
  end;

  theBitmap := CreateDIBSection(0, bi, DIB_RGB_COLORS, pBmpBits, 0, 0);

  pBmpBits := @theBitmapBitArray[0];

  SetDIBits(0, theBitmap, 0, bi.bmiHeader.biHeight * -1, pBmpBits, bi, DIB_RGB_COLORS);

  image1.Picture.Bitmap.Handle := theBitmap;
  image1.Refresh;
end;

[sintronic86]

Vielen Dank für die vielen Antworten.

Da ich aber auf dem "Zu-Fuss"-Weg nicht wirklich weitergekommen bin, habe ich mich einmal mit der Funktion StretchDIBits() genauer auseinander gesetzt.
Und siehe da: Es funktioniert.

Code:

  if FCanDraw then 
  begin
    TmpBitMap        := TBitmap.Create;
    TmpBitMap.Width  := FWidth_Cam;
    TmpBitMap.Height := FHeight_Cam;


    test2 := AOleVariant; 

    SetStretchBltMode(TmpBitMap.Canvas.Handle, COLORONCOLOR);
    StretchDIBits(TmpBitMap.Canvas.Handle,
                  0,
                  0,
                  FWidth_Cam,
                  FHeight_Cam,
                  0,
                  0,
                  FWidth_Cam,
                  FHeight_Cam,
                  test2,
                  TmpBI,
                  DIB_RGB_COLORS,
                  SRCCOPY);



    AImage.Picture.Assign(TmpBitMap); 
    TmpBitMap.Free; 
  end
  else
  begin
    AImage.Picture.Assign(NIL);
  end;