pixelweises Zeichnen von PaintBox beschleunigen

[mikro-ViiV]

Hallo alle zusammen,
ich bin neu hier im Forum und habe auch gleich mal eine erste Frage.


Und zwar geht es um folgendes Problem:
Ich habe eine alte Gameboy-Cam an einen Mikrocontroller angeschlossen und kann damit pixelweise ein Bild auslesen. Als Ergebnis erhalte ich 128*128=16384 Pixelwerte, jeweils im Bereich von 0 bis 255.
Diese Werte sende ich dann via RS232 (serielle Schnittstelle) an den Computer und lese es mit Delphi aus. Die Einzelnen Werte der Pixel speichere ich zur Zeit noch provisorisch in einem Memo, damit ich auch immer sehe, was ankommt.
Diese einzelnen Pixelwerte aus der Memo lese ich dann Zeile für Zeile aus, wobei bei mir jeweilt eine Zeile den Wert eines Pixels enthällt. Den jeweils ausgelesenen Wert wandle ich dann in einen Grauwert um und zeichne das jeweilige Pixel mit:
Paintbox.Canvas.Pixels[x,y]:='Grauwert'

Das ganze wiederhole ich für alle 16384 Pixel und zusätzlich habe ich die Größe der PaintBox von 128x128 auf 256x256 vergrößert, sodass ich mit jedem Pixelgrauwert jeweils 4 Pixel der PaintBox beschreibe.

Das ganze funktioniert auch so und ich sehe tatsächlich ein Bild (nach langem Probieren).


Es ist allerdings so, das die jetzige Routine zum Zeichnen des Bildes sehr viel Zeit in Anspruch nimmt, 1s oder so. So das man regelrecht zuschauen kann, wie das Bild aufgebaut wird.


Jetzt meine Frage:
Gibt es eine Möglichkeit das Zeichnen zu beschleunigen?


Eine Idee, die ich hatte war, das ganze mit mehreren Threads zu machen. Allerdings kann ich von einem Thread aus nicht direkt die Pixel der PaintBox setzen, sodass die hinfällig ist.


Ich hoffe, das mir diesbezüglich jemand weiterhelfen kann.
Ich bedanke mich bereits im Voraus für jede Hilfe.

-----
mikro

[Apollonius]

Holst du dir die Werte mit StrToInt wieder aus dem Memo oder hast du ein eigenes Array dafür?

[mikro-ViiV]

Danke für die wirklich schnelle Antwort.

Zitat:

Holst du dir die Werte mit StrToInt wieder aus dem Memo oder hast du ein eigenes Array dafür?

Ich mache das mit StrToInt.
Würde es denn mit einem Array schneller gehen?

[little_budda]

Hallo,

A: du kannst ein virtuelles Canvas Objekt erstellen, dort zeichen und das fertige Canvas deiner Paintbox zuweisen
B: Das Schreiben und lesen aus dem Memo dauert recht lange.
Es wäre besser du schreibst die Werte beispielsweise in ein zweidimensionales Array
(Entspricht dann direkt auch deiner Canvas-Koordinate)

[mikro-ViiV]

Sorry, aber ich bin was Delphi angeht noch kein Profi.

Darum die Vielleicht dumm erscheinende Frage:
Was ist eigentlich ein zweidimensionales Array?

[mikro-ViiV]

Ich hab das gerade mal mit den virtuellen Canvas probiert, aber ich bekomms einfach nicht hin.

Delphi-Quellcode:

var virtcanvas: Tcanvas;

...

virtcanvas.Pixels[x,y]:=Grauwert;

Fehlt da vielleicht noch irgendetwas bei der Erstellung des virtuellen Canvas.
Mus man da vielleicht die Größe oder so noch festlegen, und wenn ja, wie macht man das? Height und Widht gibts da ja nicht.

[OldGrumpy]

Ich tippe mal stark darauf, dass Du an der falschen Baustelle werkelst.

Zitat:

Zitat von mikro-ViiV

Als Ergebnis erhalte ich 128*128=16384 Pixelwerte, jeweils im Bereich von 0 bis 255. Diese Werte sende ich dann via RS232 (serielle Schnittstelle) an den Computer und lese es mit Delphi aus.

Ich könnte wetten, dass die Übertragung via RS232 der eigentliche Bremsklotz ist.

[Arnulf]

Zitat:

Ich könnte wetten, dass die Übertragung via RS232 der eigentliche Bremsklotz ist.

wieviel ist denn eingestellt bei deiner seriellen übertragung?
155200 bps? oder mehr - oder kommst garnicht auf die geschwindigkeit.
wenn du jetzt 16348 pixel hast mit jeweils einem byte kommst du auf:

130784 bit.
dh. es ist nicht verwunderlich wenn du nur ein bild pro sekunde bekommst.

das speicher in ein memo hast du ja eh als temp. bezeichnet also sag ich mal nix dazu.

lg
Arnulf

[turboPASCAL]

Zitat:

Zitat von mikro-ViiV

Ich hab das gerade mal mit den virtuellen Canvas probiert, aber ich bekomms einfach nicht hin.

Delphi-Quellcode:

var virtcanvas: Tcanvas;

...

virtcanvas.Pixels[x,y]:=Grauwert;

Fehlt da vielleicht noch irgendetwas bei der Erstellung des virtuellen Canvas.
Mus man da vielleicht die Größe oder so noch festlegen, und wenn ja, wie macht man das? Height und Widht gibts da ja nicht.

Äh, ja ? :glaskugl: Der Rest zw. "..." und "virtcanvas.Pixels". ;)

Delphi-Quellcode:

var
  virtcanvas: TCanvas;
  x, y: Integer;
begin
  virtcanvas := TCanvas.Create;
  for y := 0 to 127 do
    for x := 0 to 127 do
      virtcanvas.Pixels[x, y] := RGB(Grauwert, Grauwert, Grauwert);

  // ...
end;

Ich emfpele Dir ein Virtuelles Bitmap, damit ist es einfacher zu "Werkeln". Ein Canvas speichert nicht, sondern Zeichnet nur.
Also:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, ...

type
  TForm1 = class(TForm)
    PaintBox1: TPaintBox;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure PaintBox1Paint(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    GBBitmap: TBitmap;
    procedure ReadGBCamPixels;
    procedure ZeichneGBBitmap;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

var
  GBCamPixelGrauW : Array [0..127, 0..127] of Byte;

procedure TForm1.FormCreate(Sender: TObject);
begin
  GBBitmap := TBitmap.Create; // Virt. Bitmap erzeugen
  GBBitmap.Width  := 128;     // Grösse festlegen
  GBBitmap.Height := 128;
  GBBitmap.Pixelformat := pf8bit; // 256 Farben od. Grauwerte
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  GBBitmap.Free;              // Virt. Bitmap freigeben
end;

procedure TForm1.PaintBox1Paint(Sender: TObject);
begin
  // Das Bitmap in der PBox zeichen (lassen beim verschieben des Frensters etc.)

  PaintBox1.Canvas.Draw(0, 0, GBBitmap);
end;

procedure TForm1.ReadGBCamPixels;
var
  x,y : Integer;
begin
  // Einlesen der Cam Werte aus der GBCam.
  // ...
  // ...
  // ...

  // for y := 0 to 128 do
  //   for x := 0 to 128 do
  //    GBCamPixelGrauW[x, y] := ...
end;

procedure TForm1.ZeichneGBBitmap;
var
  x,y : Integer;
begin
  // Hiier das Bitmap miit den Farbpixeln zeichnen

  for y := 0 to 128 do
    for x := 0 to 128 do
      GBBitmap.Canvas.Pixels[x, y] :=
        RGB(GBCamPixelGrauW[x, y], GBCamPixelGrauW[x, y], GBCamPixelGrauW[x, y]);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  // The Action

  ReadGBCamPixels;
  ZeichneGBBitmap;
  PaintBox1.Repaint;
end;

end.

[Cyf]

Vielleicht eine dumme Frage, aber wenn deine Werte zwischen 0 und 255 liegen, dann sind sie nur ein Byte groß, hast du damitnicht schon Grauwerte :?: Oder wie ist das aufgebaut 2 Bit pro Farbe, oder wie?
Mit dem Canvas ist gemeint, das du dir erstmal z.B. ein TBitmap erstells (ohne es anzuzeigen) und dessen Canvas Objekt nimmst, da hast du dann auch die Größeneigenschaften des TBitmaps zu Verfügung.
Mehrdimensionale Arrays siehe :arrow: http://www.delphi-treff.de/sprachen/...xe-datentypen/