Entwickler-Ecke

Multimedia / Grafik - Flackernde Images, DoubleBuffered := True nützt nichts


galagher - Mi 05.10.05 17:51
Titel: Flackernde Images, DoubleBuffered := True nützt nichts
Hallo Leute!

Ich habe mehrere Image-Komponenten, in die ich Bildateien lade (.bmp, .gif, .jpg, .dib) und die, wenn sie neugezeichnet werden, unschön und deutlich sichtbar neu "aufgebaut" werden, obwohl ich DoubleBuffered := True verwende. Dies tritt jedoch nicht bei Bitmap-Dateien auf, bei anderen schon.

Für Bitmaps verwende ich PixelFormat := pfDevice, damit kriege ich eine schöne, glatte Anzeige hin. Bloss, was kann ich bei anderen Dateiformaten machen, um das Flackern wegzubringen?

Danke schon mal!


GTA-Place - Mi 05.10.05 18:52

Du könntest mal versuchen das Bild in eine Variable vom Typ TPicture zu laden
und erst dann anzeigen zu lassen. Also etwa so:


Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
var
  TempPic: TPicture;

// ...

procedure LoadPic(Pfad: String);
begin
  TempPic := TPicture.Create;
  TempPic.LoadFromFile(Pfad);

  Image1.Picture := TempPic;

  TempPic.Free;


So würde Delphi das Bild im Hintergrund laden und erst dann anzeigen.


galagher - Mi 05.10.05 19:38

user profile iconGTA-Place hat folgendes geschrieben:
Du könntest mal versuchen das Bild in eine Variable vom Typ TPicture zu laden
und erst dann anzeigen zu lassen.


Es flackert ja nicht beim Laden, sondern wenn es bereits geladen ist und zB. ein Fenster einer anderen Anwendung über meinem Programm ist und dieses Fenster über die Images bewegt wird, oder, wenn die ScrollBox, auf der die Images liegen, gescrollt wird. Dann schmieren die Images richtig und es dauert, bis sie wieder normal dargestellt werden. Windows zeichnet ja alles dabei neu, aber wie gesagt, bei .bmp-Files kommt das nicht vor.

Also nicht das Laden der Bilddateien, sondern das Neuzeichnen flackert, schmiert und ist elendig langsam. Klar, bei Bildern mit sagen wir 100x100 Pixel klappt es ja, aber bei 1024x768 ist's ein echter Graus. :(


GTA-Place - Mi 05.10.05 19:43

Und wenn du es doch so machst wie ich und in OnPaint dann Image1.Picture := TempPic; schreibst?
Vielleicht geht das schneller, als wenn er es nochmal malen muss.


EDIT: Gibt kein OnPaint... :lol:


galagher - Mi 05.10.05 20:05

user profile iconGTA-Place hat folgendes geschrieben:
Und wenn du es doch so machst wie ich und in OnPaint dann Image1.Picture := TempPic; schreibst?

Nützt nichts, wenn ich zB. die Grösse von Form1 ändere, sodass das Image nicht mehr voll sichtbar ist, schmiert es beim Vergrössern des Formulars wieder. Auch das Darüberschieben anderer Fenster erzeugt einen Schmiereffekt. Ausserdem habe ich 150 Images - da müsste ich also 150 temporäre Pictures verwenden... Aber es nützt sowieso nichts.

Ich habe auch versucht, mit JPEG-Pixelformat zu arbeiten - nützt ebenfalls nichts:

Delphi-Quelltext
1:
2:
3:
4:
5:
with TJPEGImage(ImagePlus1.Picture.Graphic) do
    begin
      PixelFormat := TJPEGPixelFormat(jf24Bit);  //oder jf8Bit
      //...
    end;

Man müsste herausfinden, warum ein Bitmap weder schmiert noch flackert, aber ein .jpg-File zB. das hingegen schon macht.


Lannes - Mi 05.10.05 21:30

Hallo,

probier mal folgendes:

Delphi-Quelltext
1:
2:
3:
image1.ControlStyle:=image1.ControlStyle+[csOpaque]; 
//oder 
image1.parent.ControlStyle:=image1.parent.ControlStyle+[csOpaque];


Lossy eX - Do 06.10.05 08:42

Ich denke mal dein Bitmap wird das selbe Problem haben wie die anderen Bilder auch, nur dass es bei ihm nicht auffällt, da es pfDevice als Pixelformat besitzt. pfDevice (oder HandleTyp bmDDB) sagen aus, dass das Bild hardwarebeschleunigt gezeichnet wird. Zu mindest wird es versucht so viel wie möglich aus der Hardware herauszuholen. Fakt dürfte sein, dass die Anzeige des Bitmap schneller ist als die der anderen. Evtl. wird es durch das verwendete Format noch mal beschleunigt.

150 Images? Und dann wunderst du dich warum es flackert und schliert? Das Zeichnen von 150 Komponenten dauert nun mal ne Weile. Das solltest du anders aufziehen. Also ich würde die Bilder entweder in TBitmaps oder bei unterschiedlichen Typen in TPictures laden. Zum Zeichnen würde ich dann eine PaintBox oder ein verändertes Panel benutzen. Zu Begin der Anwendung würde ich ein Bitmap erstellen, welches genau die Größe des Panels besitzt. Im OnPaint würde ich zu erst die Größe updaten. Es passiert nichts, wenn die größe gleich ist. Anschließend würde ich alles so zeichnen wie ich die Bilder gerne haben will. Und wenn alle fertig ist dann kann das Bitmap in die Zeichenfläche gezeichnet werden.

Evtl kannst du aus performance Gründen auch das temporäre Bild auch woanders zusammenbauen auf, dass es im OnPaint lediglich noch gezeichnet werden muss. So brauchst du es dann nur noch updaten, wenn sich auch tatsächlich etwas verändert hat. Dadurch sparst du Leistung ein die du anderweitig benutzen kannst.

Du solltest bei der Zeichenfläche aber noch den ControlStyle (wie bei Lannes) setzen. Es genügt dabei die PaintBox. Der Style sorgt dafür, dass das Fenster von Windows nicht mehr gelöscht wird, wodurch der ursprüngliche Inhalt erhalten bleibt.

Nur zum Verständniss. DoubleBuffering sorgt dafür, dass eine Komponente vor dem auf dem Bildschirm darstellen erst einmal in ein Temporäres Bitmap gezeichnet wird. Es nützt absolut nichts, wenn du ein Image mit DoubleBuffering versiehst, da das Darstellen eines Bildes je Problemlos funktionieren sollte. Ich an deiner Stelle würde die ParentKomponente deines Bitmaps mit DoubleBuffering versehen. Das sollte wesentlich mehr bringen. Aber bei 150 Images würde ich defintiv etwas anderes machen.


Alpha_Wolf - Do 06.10.05 15:29

Wie Lossy ex schon sagte würde ich es ebenfalls anders aufbauen..

Ich hatte mal das Problem als ich einen speziellen Player für Kamerabilder programmiert habe..

Vielleicht hilf dir das in irgendeiner Art und Weise..

Das ganze ins Create der Form schreiben.


Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
...
var
  lCounter: integer
begin
  for lCounter:= 0 to ComponentCount-1 do begin
    if Components[lCounter].InheritsFrom(TWinControl) then begin
      TWinControl(Components[lCounter]).DoubleBuffered:= true;
    end;
  end;
end;


galagher - Do 06.10.05 17:51

user profile iconLossy eX hat folgendes geschrieben:
150 Images? Und dann wunderst du dich warum es flackert und schliert?

Naja, es sind ja 150 Images mit je nur 69x69 Pixel Grösse, das Bild wird mit .Proportional := True geladen und somit verkleinert. Nur das allein hilft nicht. Deine Tips sind zwar einleuchtend und ich würde das wahrscheinlich auch hinbekommen (mit Nachfragen hier im Forum :mrgreen: ), aber ich will nicht das ganze Programm umbauen müssen! Wenn schon, dann lieber gleich neu anfangen.

Aber ich habe eine andere Idee: Mit kleinen Bilddateien (etwa 200x300 Pixel oder mit Bilddateien mit nur 256 Farben) klappt ja alles zufriedenstellend. Sagen wir, ich lade ein Bitmap mit 1024x768 Pixeln in ein zur Laufzeit erstelltes Image. Wie kann ich nun erreichen, dass das Bitmap (JPEG usw.) nicht nur verkleinert dargestellt, sondern in der Image-Komponente tatsächlich verkleinert wird? (Selbst wenn ich Stretch oder Proportional verwende - das Bild bleibt so gross, wie es ist). Kennt jemand eine Funktion oder Prozedur, die das kann?
Das so verkleinerte Bild weise ich dann einer sichtbaren Image-Komponente zu. Das mache ich eben 150 mal.

Die Bilddatei soll natürlich nicht verändert werden, aber mein Programm soll nun nicht mehr ein grosses Bild, das verkleinert dargestellt wird, handlen, sondern ein grosses Bild, das verkleinert ist, so, als hätte es ein kleines Bild geladen.
Anders gesagt: Wenn ich SaveToFile anwende, wird das Bild mit exakt der Anzahl an Pixeln, die die Image-Komponente hat, gespeichert - 69x69.


Alpha_Wolf - Do 06.10.05 17:56

Hilft dir mein code nicht weiter (2 post vorher)? Wundert mich direkt..

Einfach mal die Hilfe besuchen und du findest einiges..Bild verkleinern... [http://www.delphi-forum.de/viewtopic.php?t=11022&highlight=bild+verkleinern]


Teo - Fr 07.10.05 08:42

Du köntest versuchen ob es besser geht wenn am Anfang der Zeichenroutine LockWindowUpdate(form.handle) steht und am ende LockWindowUpdate(0).

Dass hat aber ein Nachteil: das ganze wird nicht eher gezeignet als am ende der Routine. LockWindowUpdate (wie der Nahme sagt sorgt dafür dass zeichnen nicht ausgeführt wird)


Lossy eX - Fr 07.10.05 09:06

@Alpha_wolf: Bitte nicht so die Bilder verkleiner. StretchDraw macht nichts anderes als Pixel zu wiederholen oder wegzulassen. Das Ergebniss ist zwar ziemlich genau so wie in der Imagekomponente allerdings lässt die Qualität so doch sehr zu wünschen übrig. Und Graphics32 für so etwas simples zu bemühen finde ich auch übertrieben. Vor allem, da er die Bilder wohl bei jedem Durchgang kleiner rechnen wird. Dann doch lieber ein Resample mit Scanlines [http://www.swissdelphicenter.ch/torry/showcode.php?id=2403]. Das ist schnell und sieht gut aus. Den Code habe ich jetzt spontan mit Google gefunden aber er sieht ganz brauchbar aus.

Allen Komponenten das Doublebuffering zu verpassen halte ich auch nicht für sinnvoll. Schließlich muss er bei jedem Zeichnen ein Temporäres Bitmap anlegen und in das hineinzeichen. Bei ImageKomponenten ist das aber recht sinnfrei, da das bereits Bilder sind. Ich denke mal das Problem rührt davon, dass die Komponenten in der Scollbox verschoben werden und vorerst der Hintergrund gelöscht wird.

Das Zeichnen dauert nun mal eine Weile. Beim StrechtDraw wie es in den TImages benutzt wird muss er durch das ganze Bild gehen um heraus zufinden welche Pixel er zeichnen muss und welche nicht. Um so größer die Bilder sind umso mehr zeit braucht er dafür. Auch wenn die Bilder jetzt kleiner wären, das Problem bleibt das Gleiche. Nur ist es in anderen Fällen nicht so offensichtlich, weil er nicht so lange dafür braucht. Was ist aber, wenn dein Rechner gerade beschäftigt ist oder dein Programm auf einem langsameren Rechner ausgeführt wird? Dann wird es genau so sein. Und dann auch mit den kleineren Bildern.

Ich persönlich sehe keine andere Möglichkeit als, dass du es entsprechend anpasst. Wobei ich mal sehr stark bezweifel, dass du deswegen komplett neu anfangen musst. Und auch wenn, dann kannst du ja größere Teile bestimmt so übernehmen oder andere Stellen die dir nicht gefallen ausbessern etc. Aber normal musst du lediglich die Verwaltung von TImages auf TPictures umstellen und beim Zeichnen dann auf die TPictures zugreifen. Den ResampleAlgorithmus solltest du wohl in jedem Fall mit benutzen.

Du kannst ja auch daraus lernen, wie man ein Programm aufbaut, damit man es später erweitern oder umbauen kann. Das wird nicht das letzte mal gewesen sein, dass du in solche eine Situationen gekommen bist. Spreche da ein bisschen aus Erfahrungen. ;-) Ich vertrete da auch die Meinung, dass man etwas lieber umbauen sollte als es auf Teufel komm raus auf etwas anderes umzbiegen. Da kommt meist nichts so tolles bei raus.


galagher - Fr 07.10.05 18:54

user profile iconLossy eX hat folgendes geschrieben:
Dann doch lieber ein Resample mit Scanlines [http://www.swissdelphicenter.ch/torry/showcode.php?id=2403]. Das ist schnell und sieht gut aus.

Ich möchte mehrere Bildformate verkleinern können, nicht nur Bitmaps! Das Bild einfach kleiner machen im Image! Ob es nun ein JPEG ist oder sonstwas.

Aber erstmal danke für eure Anregungen - momentan versuche ich es mit StretchDraw hinzukriegen. Sieht aber nicht sehr erfolgreich aus. Nicht kleiner darstellen, kleiner werden!

Moderiert von user profile iconraziel: Quote-Tag repariert.


Lossy eX - Fr 07.10.05 22:23

Du kannst ja schließlich auch jedes jpeg auf ein tbitmap zeichnen und das dann kleiner rechnen lassen. Schon mal an so etwas gedacht? In welchem Format die kleinen Bilder sinst doch wurscht. Sind doch nur zum anzeigen da, oder etwa nicht?


galagher - Sa 08.10.05 16:46

Ok, StretchDraw klappt jetzt. Aber ich möchte die verkleinerten Bilder auch noch proportional korrekt, also ohne Verzerrung, anzeigen, denn

Delphi-Quelltext
1:
2:
3:
 ImagePlusX.Picture.LoadFromFile(OpenPictureDialog1.Files[B]);
 TImagePlus(FindComponent('ImagePlus'+IntToStr(B))).
  Canvas.StretchDraw(Rect(006969),ImagePlusX.Picture.Graphic);

verzerrt das Bild auf 69x69 Pixel. Wie kann ich statt dem fixen Wert 69 einen variablen Wert errechnen, der die Grafik wie .Proportional := True ins Image einpasst, angenommen, bei einer 1024x768 Pixel grossen Grafik?


galagher - Sa 08.10.05 20:10

Mir würde es auch schon helfen, wenn man von einem Image mit Proportional := True die Höhe und Breite des tatsächlichen Bildes ermitteln kann. .Picture.Height oder .Picture.Width geben immer die Original-Werte zurück, ich brauche aber soetwas wie .Canvas.Width. Diesen Wert verwende ich dann für die Breite in StretchDraw.


Lossy eX - So 09.10.05 09:57

Also mit dem Dreisatz (Prozentrechnung) kommst du spielend die Größe die du brauchst. Das solltest du schon beherschen, weil man das sehr häufig braucht.

Das würde dann so aussehen. Höhe = 1024 / 69 * 768. Du musst natürlich vorher überprüfen ob das Bild hochkant oder Quer ist.


galagher - So 09.10.05 10:42

user profile iconLossy eX hat folgendes geschrieben:
Also mit dem Dreisatz (Prozentrechnung) kommst du spielend die Größe die du brauchst.

Danke, das hab' ich vorhin gerade mit Google eher zufällig gefunden: :mrgreen:
http://www.swissdelphicenter.ch/de/forum/lofiversion/index.php/t9232.html
Proporional verkleinern geht somit im Prinzip so:
Yneu = (Xneu * Yalt) / Xalt
Xneu = (Xalt * Yneu) / Yalt

Allerdings bleiben in die "freien" Bereiche weiss, das müsste ich nun noch wegbekommen, und ausserdem noch das verkleinerte Bild mittig ausrichten...


galagher - So 09.10.05 16:53

user profile icongalagher hat folgendes geschrieben:
Allerdings bleiben in die "freien" Bereiche weiss, das müsste ich nun noch wegbekommen, und ausserdem noch das verkleinerte Bild mittig ausrichten...

Beides gelöst: Vor dem Zeichnen des Bildes verwende ich einfach FloodFill, und das Ausrichten in der Mitte des Ziel-Images kann man berechnen, momentan kriege ich es aber nur dann ohne Verzerrung hin, wenn Breite und Höhe des Ziel-Images ident sind.

Soll aber nicht heisen, dass ihr mir jetzt nie mehr antworten sollt, weil ich die Lösung selbst gefunden habe! :mrgreen:


Lossy eX - So 09.10.05 20:18

Um ein Bild zu löschen benutze ich immer FillRect mit dem Rect. FloodFill geht doch normal her und füllt nur einen gewissen bereich mit einer Farbe. Dabei muss er normal ja jedes Pixel abfragen. In deinem Fall sollte ein einfachen übermalen schneller sein.

Und das mit dem Mittig ausrichten und gleich höhe/breite habe ich nicht gerallt.


galagher - So 09.10.05 21:24

user profile iconLossy eX hat folgendes geschrieben:
Und das mit dem Mittig ausrichten und gleich höhe/breite habe ich nicht gerallt.

Ok, hier der Code:

Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
procedure ProportionalPicture(Image, DestImage: TImage;
 SourceWidth, SourceHeight, DestWidth, DestHeight: Integer; HGColor: TColor);
var
  I, L, T, Xnew, Ynew, H, W: Integer;
begin
 with DestImage do
 begin
  Picture.Graphic := nil;
  Canvas.Brush.Color := HGColor;
  Canvas.FillRect(Rect(00, Width, Height));
 end;

 Xnew := (SourceWidth * DestWidth) div SourceHeight;
 Ynew := (DestHeight * SourceHeight) div SourceWidth;

 L := 0;
 T := 0;
 for I := Xnew to DestWidth do Inc(L);
 for I := Ynew to DestHeight do Inc(T);

 W := DestWidth div 3;
 H := DestHeight div 3;

 if Xnew > Ynew then
  DestImage.
   Canvas.StretchDraw(Rect(L div 2, T div 2, Xnew-W, Ynew+T div 2),Image.Picture.Graphic)
 else if Xnew < Ynew then
  DestImage.
   Canvas.StretchDraw(Rect(L div 2, T div 2, Xnew+L div 2, Ynew-H),Image.Picture.Graphic)
 else if Xnew = Ynew then
  DestImage.Canvas.StretchDraw(Rect(L, T, Xnew, Ynew),Image.Picture.Graphic);
end;


Wenn DestWidth ungleich DestHeight ist, treten Verzerrungen auf. Ansonsten wird das Bild proportional korrekt eingepasst. Das Ganze wird also so aufgerufen:

Delphi-Quelltext
1:
2:
 ImageX.Picture.LoadFromFile(//FileName
 ProportionalPicture(ImageX, Image1, ImageX.Picture.Width, ImageX.Picture.Height, 6969, clBtnFace)


Lossy eX - So 09.10.05 22:20

Wenn du das Bild eh schon kleiner gerechnet hast, dann könntest du auch Draw anstelle von Stretchdraw verwenden. Du musst es ja nicht strechten. Anderenfall schaue ich mir morgen in ruhe noch mal deinen Code an. Habe jetzt keine Zeit und bin nicht mehr so richtig aufnahmefähig.


Lossy eX - Mo 10.10.05 09:05

Okay. Ich sehe gerade anhand von deinem Code, dass du die Bilder nicht runter rechnest sondern lediglich kleiner Zeichnest. Also das mit den variablen T und L? Hast du mal genau überlegt, was du damit veranstaltest? Du setzt sie auf 0 und anschließend erhöhst du sie in einer Schleife. Du könntest auch DestWidth - XNew ausrechnen um das zu bekommen. Aber egal. Das geht alles viel einfacher als du denkst.

Versuch es mal so.

Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
procedure TForm1.Button1Click(Sender: TObject);
var
  NewWidth, NewHeight, OffsetX, OffsetY: Integer;
begin
  with Image1.Picture.Bitmap do begin
    // Größe setzen und Hintergrund löschen
    Width := 200;
    Height := 200;

    Canvas.Brush.Color := clBtnFace;
    Canvas.FillRect(Canvas.ClipRect);

    // neue Bildgröße berechnen
    NewWidth := 200;
    NewHeight := 200;

    if Image2.Picture.Width > Image2.Picture.Height
      then NewHeight := 200 * Image2.Picture.Height div Image2.Picture.Width
      else NewWidth := 200 * Image2.Picture.Width div Image2.Picture.Height;

    // Bild Zentriert darstellen
    OffsetX := (Width - NewWidth) div 2;
    OffsetY := (Height - NewHeight) div 2;

    Canvas.StretchDraw(
      Rect(OffsetX, OffsetY, OffsetX + NewWidth, OffsetY + NewHeight),
      Image2.Picture.Graphic);
  end;
end;


Nicht wundern meine Zielgröße ist 200x200 Pixel. Aber das Prinzip sollte klar sein. (Hoffe ich jedenfalls) Und wie du daran siehst kann man das mit einem ganz simplen Dreisatz lösen. Die Ausrichtung erfolgt mithilfe ganz normaler Subtraktion und einem Div.


galagher - Mo 10.10.05 17:53

user profile iconLossy eX hat folgendes geschrieben:
Okay. Ich sehe gerade anhand von deinem Code, dass du die Bilder nicht runter rechnest sondern lediglich kleiner Zeichnest. Also das mit den variablen T und L? Hast du mal genau überlegt, was du damit veranstaltest? Du setzt sie auf 0 und anschließend erhöhst du sie in einer Schleife.

Ich setzt T und L deshalb zunächst auf 0, da sie als lokale variablen diesen Wert ja nicht automatisch haben. Kleiner zeichnen ist doch das Ziel der ganzen Aktion :| ! Leider funktioniert dein Code nicht, trotzdem danke! Bei

Delphi-Quelltext
1:
 with Image1.Picture.Bitmap do begin                    
erhalte ich "Division durch Null", bei


Delphi-Quelltext
1:
 with Image1.Picture.Graphic do begin                    
erhalte ich a) bei Bitmaps "Division durch Null", b) bei JPEG's "Die Grösse einer JPEG-Grafik kann nicht geändert werden".

L und T dienen nur dazu, Left und Top zu bestimmen, ab hier soll gezeichnet werden. Ich werde mir anschauen, wie man das vereinfachen kann.


Lossy eX - Di 11.10.05 09:32

user profile icongalagher hat folgendes geschrieben:
L und T dienen nur dazu, Left und Top zu bestimmen, ab hier soll gezeichnet werden. Ich werde mir anschauen, wie man das vereinfachen kann.

Das meine ich ja damit. Diese Aktion die du per Schleife durchführst, die kann man auch berechnen. Und das kostet nicht mal einen Bruchteil der Zeit den du mit den Schleifen vergeudest.

Zu dem Code. Ich habe fast befürchtest, dass du den einfach so direkt kopieren wirst. Ich habe gehoft, dass du es nicht tun wirst. Aber du hast es getan. Den Code kannst du natürlich nicht einfach so kopieren! Du müsstest den schon auf deine Bedürftnisse anpassen.

In dem Code greife ich direkt auf meine beiden Images zu. Die aber nur existieren, weil es für mich einfacher ist. Du müsstest die natürlich als Parameter übergeben. Oder die TPictures als Parameter! Was ich persönlich für Sinnvoller halte, da du diese aus Standalone erstellen kannst. Sonst bist du immer an eine Komponente gebunden. Die Größe setze ich bei dem Zielbild. Das ist zu Begin noch leer und wird ja letzten Endes mit dem anderen Bild gefüllt. Was ich nur zum Zeichnen verwende und das geht 100%tig. Ich habe es selber ausprobiert.


PS: Ich kann dir nur dringenst raten dich (noch) mal mit den Grundlagen der Softwareentwicklung zu beschäftigen. Auf mich hat es den nämlich den Anschein als ob du nicht genau weißt was du tust. Sondern es einfach nur so tust. Sonst hättest du wohl den Code von mir verstanden und umsetzen können.


galagher - Di 11.10.05 18:01

user profile iconLossy eX hat folgendes geschrieben:
Zu dem Code. Ich habe fast befürchtest, dass du den einfach so direkt kopieren wirst. Ich habe gehoft, dass du es nicht tun wirst. Aber du hast es getan. Den Code kannst du natürlich nicht einfach so kopieren! Du müsstest den schon auf deine Bedürftnisse anpassen.

Zuerst wollte ich ihn natürlich testen, also mit einem Button1, Image1 und Image2. Habe aber übersehen, dass das Bild in Image2 in Image1 gezeichnet werden soll, nicht umgekehrt, habe deshalb in Image1 eine Grafik geladen und liess Image2 leer. Umgekehrt funktioniert es natürlich und ich setze deinen Code bereits ein!

Er ist aber nur minimal schneller als meiner - bei 89 JPEG's, 1024x768 Pixel, um etwa 5 Sekunden. Eleganter ist er allemal, zugegeben.

Danke für deine Hilfe! :D