großes Bitmap aus Speicher in TImage zeigen

[br_klaus]

Hallo,

ich glaube, dieses Thema wurde schon einmal angesprochen. Ich habe eine große Bitmap (bmp, 24 oder 8 bpp, also schon pixelweise abgespeichert) im Speicher liegen und möchte die (bzw Ausschnitte daraus) auf einer TImage darstellen.
Kann ich da mit Stretchdraw arbeiten? Aber dazu bräuchte ich eine TGraphic, und die habe ich nicht.
Ich mache es jetzt mit der Opensource-Unit FreeImage.

Und dann die (skalierte) Bitmap im Speicher (mit derselben Größe wie die TImage) Zeile für Zeile via TLazIntfImage in die TImage kopieren.
Es funktioniert, dauert aber recht lange. Weiß jemand eine schnellere Lösung?

Ginge das ganze es auch mit OpenGl (und wäre das dann schneller?), und wie müßte man dann da vorgehen?

Herzlichen Dank!

P. Nikolaus

[theo]

Kann ich da mit Stretchdraw arbeiten? Aber dazu bräuchte ich eine TGraphic, und die habe ich nicht.

Ein TBitmap ist eine TGraphic, wie man u.a. aus der Dokumentation ersehen kann.
http://lazarus-ccr.sourceforge.net/docs ... itmap.html" onclick="window.open(this.href);return false;

Also StretchDraw oder CopyRect verwenden.

[br_klaus]

Lieber Theo.

Ich habe leider kein TBitmap (als Klasse), sondern nur die Bitmap des Bildes als solche (d.h. die einzelnen Pixel) und den dazugehörigen BitmapInfoHeader.
FreeImage liefert als Ergebnis einen Pointer, ein PFIBITMAP auf eine interne Datenstruktur, die die Bitmap und alle zugehörigen Parameter enthält, aber keine TBitmap.
Bei 24 bpp wird mit 32 bit Boundary abgespeichert (d.h. width mod 4 FüllBytes).

Wenn ich zB habe

Code: Alles auswählen

Procedure TForm1.Dib_to_Image(dib:PFIBITMAP);
var data:Pbyte;
  bmi:PBITMAPINFOHEADER;
  bmp: TBitmap  // oder TGraphic?
  w,h,bpp:integer;
  r:TRect;
begin
   data:= FreeImage_GetBits(dib); bmi:=FreeImage_GetInfo(dib);
   w:=FreeImage_Getwidth(dib); h:=FreeImage_GetHeight(dib); bpp:=FreeImage_GetBpp(dib);
   bmp := TBitmap.create; // oder TGraphic.create?
   r:=image1.BoundsRect;
....
  end;

Wie kann ich da jetzt die TBitmap bzw TGraphic mit den entsprechenden Daten beschicken, sodaß ich dann aufrufen kann

Code: Alles auswählen

Image1.Canvas.Draw(0,0,bmp)

bzw.

Code: Alles auswählen

image1.canvas.stretchdraw(r,bmp)

Und bei StretchDraw, gibt es da keine Probleme mit der Art der Abspeicherung in FreeImage (32 bit Boundary)?

Herzlichen Dank
P. Nikolaus

[theo]

Wozu benutzt du FreeImage?

[Socke]

Wozu benutzt du FreeImage?

Das schein irgendeine uns unbekannt Bibliothek zu sein, deren Ursprung wir nicht kennen.

Ich habe leider kein TBitmap (als Klasse), sondern nur die Bitmap des Bildes als solche (d.h. die einzelnen Pixel) und den dazugehörigen BitmapInfoHeader.
FreeImage liefert als Ergebnis einen Pointer, ein PFIBITMAP auf eine interne Datenstruktur, die die Bitmap und alle zugehörigen Parameter enthält, aber keine TBitmap.
Bei 24 bpp wird mit 32 bit Boundary abgespeichert (d.h. width mod 4 FüllBytes).

Schau dir mal http://de.wikipedia.org/wiki/Windows_Bitmap" onclick="window.open(this.href);return false; an; Vielleicht kannst du dein Bitmap selbst (oder über deine Bibliothek) in einen TMemoryStream speichern und von dort wieder mit TBitmap lesen.

[br_klaus]

FreeImage ist OpenSource (http://freeimage.sourceforge.net/download.html" onclick="window.open(this.href);return false;). Ich benütze es v.a., um jedes beliebige Bildformat laden zu können. FreeImage unterstützt fast alle existierenden Formate.
Und es ist sehr schnell.

Eine Möglichkeit, die ich gefunden habe, ist, die Daten auf der Disk zwischenzuspeichern und dann mit LoadFromFile in die Image zu laden.
Gibt es denn keine Möglichkeit, anstatt auf Disk, in den Zwischenspeicher (Clipboard) zu kopieren und dann vom Clipboard aus zu laden?

[theo]

In meinem OpBitmap gibt es in der Unit imagelibs/lazbridge32.pas im Bereich {$ifdef LCLWin32} bei OpBitmapPaint32 Code um DIB auf den Canvas zu bringen (unter Windows mit Pixelformat 32bit).
Vielleicht kannst du dich daran orientieren.

http://www.theo.ch/lazarus/opbitmap64.zip" onclick="window.open(this.href);return false;

[Socke]

Eine Möglichkeit, die ich gefunden habe, ist, die Daten auf der Disk zwischenzuspeichern und dann mit LoadFromFile in die Image zu laden.
Gibt es denn keine Möglichkeit, anstatt auf Disk, in den Zwischenspeicher (Clipboard) zu kopieren und dann vom Clipboard aus zu laden?

Es kommt darauf an, wie du die Daten abspeicherst. Clipboard ist in der Regel zu kompliziert; viel einfacher ist ein TMemoryStream (siehe meinen Beitrag oben).

[br_klaus]

Mit Streams kenne ich mich leider gar nicht aus. Da gibt es so viele verschiedene Arten.
Welchen soll man hier verwenden?
Und wie müßte ich da vorgehen, um
a) die Daten in den Stream zu laden
b) sie zum Image zu schicken?

Herzlicen Dank
P. Nikolaus

[Socke]

TStream ist eine allgemeine Klasse um Daten zu streamen, was soviel bedeutet, dass die Daten einfach irgendwohin gesendet oder von irgendwo gelesen werden. Je nach Quelle oder Ziel gibt es verschiedene, von TStream abgeleitete Klassen -- z.B. TFileStream für Dateien von der Festplatte, TMemoryStream für den Arbeitsspeicher (automatische Verwaltung des Speichers), bei Netzwerk-Komponenten usw.

a) die Daten in den Stream zu laden

Das kann ich dir nicht wirklich sagen, da das auch zu einem großen Teil von der Bibliothek (FreeImage) abhängt, die du verwendest. Allgemein gesehen, geht das so:

Code: Alles auswählen

var
  s: TMemoryStream;
begin
  s := TMemoryStream.Create;
  s.Write(Buffer, Count); // Count Bytes aus Buffer in den Stream schreiben
end;

b) sie zum Image zu schicken?

Dazu nimmst du den Stream von oben:

Code: Alles auswählen

var
  s: TMemoryStream;
begin
  s.Position := 0; // die Position auf den Anfang setzen, damit alle Daten gelesen werden.
  Image1.LoadFromStream(s); // hier werden die Daten gelesen
  s.Free; // nicht vergessen, alles wieder freizugeben
end;

[br_klaus]

Die Daten aus der Bitmap, die da gelesen werden, sind das nur die Daten der Pixel oder auch der zugehörige Rumpf (BitmapInfoHeader, evtl. auch die Paletten)?
Und werden die Pixel in der Bitmap ohne FüllBytes gespeichert oder mit (wenn 32 Bit Boundary, wie in FreeImage)? Denn dann könnte ich ganz leicht zuerst einen BimapinfoHeader mit den entsprechenden Werten vom Stream lesen lassen und dann die Pixel, und dies dann in die Image vom Stream laden.

Wozu braucht man eigentlich überhaupt einen Stream? Man könnte doch genausogut direkt von einem Speicherort zum anderen Kopieren mit Move(src,dst,size) bzw CopyMem(dst,src,size) oder via Assembler (Intel: Rep Mov)? Was ist da der Unterschied zum Streamen?

[Socke]

Die Daten aus der Bitmap, die da gelesen werden, sind das nur die Daten der Pixel oder auch der zugehörige Rumpf (BitmapInfoHeader, evtl. auch die Paletten)?
Und werden die Pixel in der Bitmap ohne FüllBytes gespeichert oder mit (wenn 32 Bit Boundary, wie in FreeImage)? Denn dann könnte ich ganz leicht zuerst einen BimapinfoHeader mit den entsprechenden Werten vom Stream lesen lassen und dann die Pixel, und dies dann in die Image vom Stream laden.

Die Frage ist nicht, was gespeichert wird, sondern was TBitmap lesen kann? Das musst du ausprobieren, oder im Quelltext nachlesen oder jemanden hier fragen, der sich mehr mit Grafiken beschäftigt als ich. In jedem Fall musst du aber das gesamte Bitmap im Stream ablegen (inkl. header, Paletten wenn vorhanden und natürlich die Bilddaten selbst).

Wozu braucht man eigentlich überhaupt einen Stream? Man könnte doch genausogut direkt von einem Speicherort zum anderen Kopieren mit Move(src,dst,size) bzw CopyMem(dst,src,size) oder via Assembler (Intel: Rep Mov)? Was ist da der Unterschied zum Streamen?

Damit es einfacher geht. Wenn du nur im Arbeitsspeicher arbeitest, kannst du die von dir genannten Funktionen selbstverständlich verwenden, aber dann musst du dich auch um den Speicher kümmern. TMemoryStream kann dir das abnehmen. Außerdem kannst du mit TStream als Basisklasse mit einheitlichen Methoden Daten von verschiedenen Quellen lesen (siehe bspw. TBitmap.LoadFromStream und TBitmap.LoadFromFile).