AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Programmierung allgemein Multimedia Bitmap zeichen (gehts noch schneller?)
Thema durchsuchen
Ansicht
Themen-Optionen

Bitmap zeichen (gehts noch schneller?)

Ein Thema von Amateurprofi · begonnen am 28. Feb 2016 · letzter Beitrag vom 1. Mär 2016
Antwort Antwort
Benutzerbild von Memnarch
Memnarch

Registriert seit: 24. Sep 2010
737 Beiträge
 
#1

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 28. Feb 2016, 20:01
BitBlt, StretchBlt und andere Funktionen der GDI-Lib sind Hardwarebeschleunigt(XP, Vista Nicht, ab W7 wieder). GDI+ ist es nicht.
GDIP hat außerdem bessere interpolationen, die brauchen aber auch mehr cpu.

Wobei zugegeben 136 mal langsamer schon komisch aussieht.

Konnte nur noch diesen Artikel wiederfinden. Den wo GDI+ als nicht HW-beschleunigt genannt wird, nicht
https://msdn.microsoft.com/en-us/lib...=vs.85%29.aspx

PS: Wäre natürlich gut zu wissen unter welchem OS du bist. Ab W8 wurde dass ja schonwieder geändert.
Da man Trunc nicht auf einen Integer anwenden kann, muss dieser zuerst in eine Float kopiert werden

Geändert von Memnarch (28. Feb 2016 um 20:03 Uhr)
  Mit Zitat antworten Zitat
Amateurprofi

Registriert seit: 17. Nov 2005
Ort: Hamburg
1.041 Beiträge
 
Delphi XE2 Professional
 
#2

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 28. Feb 2016, 23:36
BitBlt, StretchBlt und andere Funktionen der GDI-Lib sind Hardwarebeschleunigt(XP, Vista Nicht, ab W7 wieder). GDI+ ist es nicht.
GDIP hat außerdem bessere interpolationen, die brauchen aber auch mehr cpu.

Wobei zugegeben 136 mal langsamer schon komisch aussieht.

Konnte nur noch diesen Artikel wiederfinden. Den wo GDI+ als nicht HW-beschleunigt genannt wird, nicht
https://msdn.microsoft.com/en-us/lib...=vs.85%29.aspx

PS: Wäre natürlich gut zu wissen unter welchem OS du bist. Ab W8 wurde dass ja schonwieder geändert.
Danke Memnarch,
Das wusste ich bisher nicht.
Aber einen offensichtlichen Fehler in meinem Code, der das langsame Zeichnen verursacht siehst du auch nicht, oder?
Siehst du denn eine Möglichkeit aus einer TGPBitmap SCHNELL eine TBitmap zu machen?
Wie ich das bisher mache siehst du in der Prozedur DrawBitmap.

Mein OS ist übrigens Win 7 Prof.
Gruß, Klaus
Die Titanic wurde von Profis gebaut,
die Arche Noah von einem Amateur.
... Und dieser Beitrag vom Amateurprofi....
  Mit Zitat antworten Zitat
Benutzerbild von Memnarch
Memnarch

Registriert seit: 24. Sep 2010
737 Beiträge
 
#3

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 29. Feb 2016, 08:20
Um überhaupt vergleichen zu können, würde ich erstmal die interpolationen in TGPGraphic abstellen. Dann die Frage warum überhaupt GDI+? Wenn du ein so hochauflösendes Bild hast, kannst du nicht auch SetStretchBLTMode HalfTone zum runterskalieren nehmen?

Benutz ich z.B. in meinem AsciiImage:
TGDIRenderContext.EndScene(Zeile 135)

Und so schauts aus:
AsciiImage for Delphi: GDI-Downsampling, FireMonkey and more!

EDIT: Vergiss nicht, dass du da bei GDI+ mitunter unsäglich viel konvertierst(Kann dir auch bei GDI passieren). Wenn die Pixel-Formate zwischen Source und Target nicht gleich sind, wird die source immer konvertiert beim Zeichnen! IIRC solltest du am besten mit 32bit Grafiken arbeiten.
Da man Trunc nicht auf einen Integer anwenden kann, muss dieser zuerst in eine Float kopiert werden

Geändert von Memnarch (29. Feb 2016 um 08:23 Uhr)
  Mit Zitat antworten Zitat
Amateurprofi

Registriert seit: 17. Nov 2005
Ort: Hamburg
1.041 Beiträge
 
Delphi XE2 Professional
 
#4

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 29. Feb 2016, 13:17
Um überhaupt vergleichen zu können, würde ich erstmal die interpolationen in TGPGraphic abstellen. Dann die Frage warum überhaupt GDI+? Wenn du ein so hochauflösendes Bild hast, kannst du nicht auch SetStretchBLTMode HalfTone zum runterskalieren nehmen?

Benutz ich z.B. in meinem AsciiImage:
TGDIRenderContext.EndScene(Zeile 135)

Und so schauts aus:
AsciiImage for Delphi: GDI-Downsampling, FireMonkey and more!

EDIT: Vergiss nicht, dass du da bei GDI+ mitunter unsäglich viel konvertierst(Kann dir auch bei GDI passieren). Wenn die Pixel-Formate zwischen Source und Target nicht gleich sind, wird die source immer konvertiert beim Zeichnen! IIRC solltest du am besten mit 32bit Grafiken arbeiten.
zu: "würde ich erstmal die interpolationen in TGPGraphic abstellen"
ich hab alle Modi probiert:
InterpolationModeInvalid 270 ms
InterpolationModeDefault 270 ms
InterpolationModeLowQuality 270 ms
InterpolationModeHighQuality 325 ms
InterpolationModeBilinear 270 ms
InterpolationModeBicubic 620 ms
InterpolationModeNearestNeighbor 180 ms
InterpolationModeHighQualityBilinear 370 ms
InterpolationModeHighQualityBicubic 320 MS
Alle Zeiten für einmal zeichnen.
Dagegen StretchBlt 2 ms
Bringt also die benötigte Zeit nicht einmal ansatzweise in die Zeit für StretchBlt.

Und warum bin ich so spitz auf TGPBitmap bin, statt TBitmap?
Das Bild liegt idR als .jpg vor, kann aber auch als .png oder .tif oder .bmp sein.

Bisher habe ich z.B. .jpg entsprechend der untenstehenden "LoadBmpViaJPEG" geladen.
Zur Zeit benutze ich die untenstehende "LoadBmpViaGPBitmap"
Und dann hab ich die untenstehende "LoadGPBitmap" getestet.
Die jeweils benötigten Zeiten:
"LoadBmpViaJPEG" : 970 ms
"LoadBmpViaGPBitmap" 270 ms
"LoadGPBitmap" 319 µs

Da ich das Bild nur ausgeben kann, wenn ich es vorher lade, drängt sich das laden in eine TGPBitmap förmlich auf.
Deshalb möchte auch bei allem was folgt am liebsten mit TGPBitmap weitermachen.



Delphi-Quellcode:
FUNCTION LoadBmpViaJPEG(const Dsn:String):Int64;
var Jpg:TJpegImage; Bmp:TBitmap;
begin
   Result:=TimeStamp;
   Jpg:=TJPEGImage.Create;
   Bmp:=TBitmap.Create;
   Jpg.LoadFromFile(Dsn);
   Bmp.Assign(Jpg);
   Jpg.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
Delphi-Quellcode:
FUNCTION LoadBmpViaGPBitmap(const Dsn:String):Int64;
var W,H:Integer; Image:TGPBitmap; Graphics:TGPGraphics; Bmp:TBitmap;
begin
   Result:=TimeStamp;
   Bmp:=TBitmap.Create;
   Image:=TGPBitmap.Create(Dsn);
   W:=Image.GetWidth;
   H:=Image.GetHeight;
   Bmp.SetSize(W,H);
   Graphics:=TGPGraphics.Create(Bmp.Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
   Graphics.DrawImage(Image,MakeRect(0,0,W,H));
   Graphics.Free;
   Image.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
Delphi-Quellcode:
FUNCTION LoadGPBitmap(const Dsn:String):Int64;
var I:Integer; Image:TGPBitmap;
begin
   Result:=TimeStamp;
   Image:=TGPBitmap.Create(Dsn);
   Result:=TimeStamp-Result;
   Image.Free;
end;
Zur Vollständigkeit:
Delphi-Quellcode:
FUNCTION TimeStamp:Int64;
asm
   rdtsc
   {$IFDEF CPUX64}
   shl rdx,32
   or rax,rdx
   {$ENDIF}
end;
Gruß, Klaus
Die Titanic wurde von Profis gebaut,
die Arche Noah von einem Amateur.
... Und dieser Beitrag vom Amateurprofi....
  Mit Zitat antworten Zitat
TiGü

Registriert seit: 6. Apr 2011
Ort: Berlin
3.062 Beiträge
 
Delphi 10.4 Sydney
 
#5

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 29. Feb 2016, 13:32
Da ich das Bild nur ausgeben kann, wenn ich es vorher lade, drängt sich das laden in eine TGPBitmap förmlich auf.
Wenn es dir einzig und allein darum geht, verschiedene Grafik-Formate zu laden und du sonst nichts mit der GDI+-Biblothek machst, kannst du auch Vcl.Graphics.TWicImage nehmen.

Siehe hier:
http://www.tek-tips.com/faqs.cfm?fid=7568
  Mit Zitat antworten Zitat
Benutzerbild von Memnarch
Memnarch

Registriert seit: 24. Sep 2010
737 Beiträge
 
#6

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 29. Feb 2016, 13:50
TPicture.LoadFromFile wäre auch noch da
Da man Trunc nicht auf einen Integer anwenden kann, muss dieser zuerst in eine Float kopiert werden
  Mit Zitat antworten Zitat
Amateurprofi

Registriert seit: 17. Nov 2005
Ort: Hamburg
1.041 Beiträge
 
Delphi XE2 Professional
 
#7

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 29. Feb 2016, 22:57
TPicture.LoadFromFile wäre auch noch da
Hallo Memnarch,

TPicture.LoadFromFile arbeitet zwar recht flott, aber Canvas.StretchDraw(ClientRect,Picture.Graphic) ist dafür umso langsamer.

Ich hab mal alle Varianten durchprobiert.
Die beste Alternative scheint zu sein:
1) GPImage oder GPBitmap laden
2) In TBitmap kopieren
3) TBitmap mit StretchBlt ausgeben.

Letztendlich reduziert sich alles auf die Ausgangsfrage: Weiß jemand, wie man eine GPBitmap schnell ausgibt?

Und so sind die Zeiten, die ich ermittelt habe.
Bei mehreren Testen hintereinander weichen die Zeiten zwar ab, aber die Relation der Zeiten für die verschiedenen Abläufe ändert sich nicht wesentlich.

Parameter : .jpg Datei, 4000x3000 Pixel,
Größe des Canvas : 1920 x 1000 Pixel

LoadGPImage 0.731 ms
LoadGPBitmap 0.558 ms
LoadWicImage 141.564 ms
LoadPicture 2.989 ms

LoadBmpViaJPEG 966.952 ms
LoadBmpViaGPImage 243.285 ms
LoadBmpViaGPBitmap 243.314 ms
LoadBmpViaWicImage 387.731 ms
LoadBmpViaPicture 984.076 ms

DrawBitmap 2.729 ms
DrawGPImage 174.647 ms
DrawGPBitmap 174.511 ms
DrawWicImage 262.219 ms
DrawPicture 990.640 MS

Zur Vollständigkeit die komplette (aktualisierte) Test Prozedur.
Vielleicht macht Ihre Euch die Mühe und schaut die einmal kritisch durch, denn seine eigenend kleinen Flüchtigkeitsfehler übersieht man ja oft.

Delphi-Quellcode:
PROCEDURE TMain.Test;
//------------------------------------------------------------------------------
FUNCTION TimeStamp:Int64;
asm
   rdtsc
   {$IFDEF CPUX64}
   shl rdx,32
   or rax,rdx
   {$ENDIF}
end;
//------------------------------------------------------------------------------
FUNCTION FixCPU(var PaMask:NativeUInt):Boolean;
var SaMask,TaMask:NativeUInt;
begin
   GetProcessAffinityMask(GetCurrentProcess,PaMask,SaMask);
   if PaMask<>0 then begin
      TaMask:=1;
      while (TaMask<>0) and ((TaMask and PaMask)=0) do TaMask:=TaMask shl 1;
      if TaMask<>0 then SetThreadAffinityMask(GetCurrentThread,TaMask);
      Result:=TaMask<>0;
   end else begin
      Result:=False;
   end;
end;
//------------------------------------------------------------------------------
FUNCTION GetTimeStampFrequency:Int64;
var OldPriority:Word; Q0,Q1,Qf,Ts0,Ts1:Int64; Seconds:Extended;
    PaMask:NativeUInt; Fixed:Boolean;
begin
   // Thread nur auf einer CPU ausführen
   Fixed:=FixCPU(PaMask);
   // Priorität des Threads hochsetzen
   OldPriority:=GetThreadPriority(GetCurrentThread);
   SetThreadPriority(GetCurrentThread,THREAD_PRIORITY_TIME_CRITICAL);
   // QPC- und TimeStamp-Ticks für 10 ms holen
   QueryPerformanceCounter(Q0);
   Ts0:=TimeStamp;
   Sleep(10);
   Ts1:=TimeStamp;
   QueryPerformanceCounter(Q1);
   // Anhand QPF die TimeStamp-Frequenz ermitteln
   QueryPerformanceFrequency(Qf);
   Seconds:=(Q1-Q0)/Qf;
   Result:=Trunc((Ts1-Ts0)/Seconds+0.5); // Ticks/s
   // Priorität des Threads auf alten Wert stellen und Thread für alle
   // CPUs freigeben
   SetThreadPriority(GetCurrentThread,OldPriority);
   if Fixed and (PaMask<>0) then SetThreadAffinityMask(GetCurrentThread,PaMask);
end;
//------------------------------------------------------------------------------
FUNCTION LoadGPImage(const Dsn:String):Int64;
var I:Integer; Image:TGPImage;
begin
   Result:=TimeStamp;
   Image:=TGPImage.Create(Dsn);
   Result:=TimeStamp-Result;
   Image.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadGPBitmap(const Dsn:String):Int64;
var Image:TGPBitmap;
begin
   Result:=TimeStamp;
   Image:=TGPBitmap.Create(Dsn);
   Result:=TimeStamp-Result;
   Image.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadWicImage(const Dsn:String):Int64;
var WicImage:TWicImage;
begin
   WicImage:=TWicImage.Create;
   Result:=TimeStamp;
   WicImage.LoadFromFile(Dsn);
   Result:=TimeStamp-Result;
   WicImage.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadBmpViaJPEG(const Dsn:String):Int64;
var Jpg:TJpegImage; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Result:=TimeStamp;
   Jpg:=TJPEGImage.Create;
   Jpg.LoadFromFile(Dsn);
   Bmp.Assign(Jpg);
   Jpg.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadBmpViaGPImage(const Dsn:String):Int64;
var W,H:Integer; Image:TGPImage; Graphics:TGPGraphics; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Result:=TimeStamp;
   Image:=TGPImage.Create(Dsn);
   W:=Image.GetWidth;
   H:=Image.GetHeight;
   Bmp.SetSize(W,H);
   Graphics:=TGPGraphics.Create(Bmp.Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
   Graphics.DrawImage(Image,MakeRect(0,0,W,H));
   Graphics.Free;
   Image.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadBmpViaGPBitmap(const Dsn:String):Int64;
var W,H:Integer; Image:TGPBitmap; Graphics:TGPGraphics; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Result:=TimeStamp;
   Image:=TGPBitmap.Create(Dsn);
   W:=Image.GetWidth;
   H:=Image.GetHeight;
   Bmp.SetSize(W,H);
   Graphics:=TGPGraphics.Create(Bmp.Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
   Graphics.DrawImage(Image,MakeRect(0,0,W,H));
   Graphics.Free;
   Image.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadBmpViaWicImage(const Dsn:String):Int64;
var WicImage:TWicImage; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Result:=TimeStamp;
   WicImage:=TWicImage.Create;
   WicImage.LoadFromFile(Dsn);
   Bmp.Assign(WicImage);
   WicImage.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadPicture(const Dsn:String):Int64;
var Picture:TPicture;
begin
   Picture:=TPicture.Create;
   Result:=TimeStamp;
   Picture.LoadFromFile(Dsn);
   Result:=TimeStamp-Result;
   Picture.Free;
end;
//------------------------------------------------------------------------------
FUNCTION LoadBmpViaPicture(const Dsn:String):Int64;
var Picture:TPicture; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Result:=TimeStamp;
   Picture:=TPicture.Create;
   Picture.LoadFromFile(Dsn);
   Bmp.Assign(Picture.Graphic);
   Picture.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;
//------------------------------------------------------------------------------
FUNCTION DrawBitmap(const Dsn:String):Int64;
var W,H:Integer; Image:TGPImage; Graphics:TGPGraphics; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Image:=TGPImage.Create(Dsn);
   W:=Image.GetWidth;
   H:=Image.GetHeight;
   Bmp.SetSize(W,H);
   Graphics:=TGPGraphics.Create(Bmp.Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
   Graphics.DrawImage(Image,MakeRect(0,0,W,H));
   Graphics.Free;
   Image.Free;
   Result:=TimeStamp;
   SetStretchBltMode(Canvas.Handle,COLORONCOLOR);
   SetBrushOrgEx(Canvas.Handle,0,0,nil);
   StretchBlt(Canvas.Handle,0,0,ClientWidth,ClientHeight,
              Bmp.Canvas.Handle,0,0,Bmp.Width,Bmp.Height,SrcCopy);
   Result:=TimeStamp-Result;
   Bmp.Free
end;
//------------------------------------------------------------------------------
FUNCTION DrawGPImage(const Dsn:String):Int64;
var I:Integer; Image:TGPImage; Graphics:TGPGraphics;
begin
   Image:=TGPImage.Create(Dsn,True);
   Result:=TimeStamp;
   Graphics:=TGPGraphics.Create(Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeNearestNeighbor);
   Graphics.DrawImage(Image,MakeRect(0,0,ClientWidth,ClientHeight));
   Graphics.Free;
   Result:=TimeStamp-Result;
   Image.Free;
end;
//------------------------------------------------------------------------------
FUNCTION DrawGPBitmap(const Dsn:String):Int64;
var I:Integer; Image:TGPBitmap; Graphics:TGPGraphics;
begin
   Image:=TGPBitmap.Create(Dsn,True);
   Result:=TimeStamp;
   Graphics:=TGPGraphics.Create(Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeNearestNeighbor);
   Graphics.DrawImage(Image,MakeRect(0,0,ClientWidth,ClientHeight));
   Graphics.Free;
   Result:=TimeStamp-Result;
   Image.Free;
// InterpolationModeInvalid 270
// InterpolationModeDefault 270
// InterpolationModeLowQuality 270
// InterpolationModeHighQuality 325
// InterpolationModeBilinear 270
// InterpolationModeBicubic 620
// InterpolationModeNearestNeighbor 180
// InterpolationModeHighQualityBilinear 370
// InterpolationModeHighQualityBicubic 320
end;
//------------------------------------------------------------------------------
FUNCTION DrawWicImage(const Dsn:String):Int64;
var WicImage:TWicImage;
begin
   WicImage:=TWicImage.Create;
   WicImage.LoadFromFile(Dsn);
   Result:=TimeStamp;
   Canvas.StretchDraw(ClientRect,WicImage);
   Result:=TimeStamp-Result;
   WicImage.Free;
end;
//------------------------------------------------------------------------------
FUNCTION DrawPicture(const Dsn:String):Int64;
var Picture:TPicture;
begin
   Picture:=TPicture.Create;
   Picture.LoadFromFile(Dsn);
   Result:=TimeStamp;
   Canvas.StretchDraw(ClientRect,Picture.Graphic);
   Result:=TimeStamp-Result;
   Picture.Free;
end;
//------------------------------------------------------------------------------
var Results:String;
PROCEDURE Add(TSC,TSF:Int64; const FuncName:String);
var S:String;
begin
   if Results<>'then Results:=Results+#13#10;
   if TSF=0 then begin
      S:=IntToStr(TSC)+' CPU-Ticks'
   end else begin
      Str(TSC/TSF*1000:0:3,S);
      S:=S+' ms';
   end;
   Results:=Results+FuncName+' '+S
end;
//------------------------------------------------------------------------------
// https://commons.wikimedia.org/w/index.php?curid=6558322
const Dsn='E:\Daten\DownLoads\PfauVonVorne.jpg';
var TSF:Int64; PaMask:NativeUInt; CPUFixed:Boolean;
begin
   TSF:=GetTimeStampFrequency;
   CPUFixed:=FixCPU(PaMask);
   Add(LoadGPImage(Dsn),TSF,'LoadGPImage');
   Add(LoadGPBitmap(Dsn),TSF,'LoadGPBitmap');
   Add(LoadWicImage(Dsn),TSF,'LoadWicImage');
   Add(LoadPicture(Dsn),TSF,'LoadPicture');
   Results:=Results+#13#10;
   Add(LoadBmpViaJPEG(Dsn),TSF,'LoadBmpViaJPEG');
   Add(LoadBmpViaGPImage(Dsn),TSF,'LoadBmpViaGPImage');
   Add(LoadBmpViaGPBitmap(Dsn),TSF,'LoadBmpViaGPBitmap');
   Add(LoadBmpViaWicImage(Dsn),TSF,'LoadBmpViaWicImage');
   Add(LoadBmpViaPicture(Dsn),TSF,'LoadBmpViaPicture');
   Results:=Results+#13#10;
   Add(DrawBitmap(Dsn),TSF,'DrawBitmap');
   Add(DrawGPImage(Dsn),TSF,'DrawGPImage');
   Add(DrawGPBitmap(Dsn),TSF,'DrawGPBitmap');
   Add(DrawWicImage(Dsn),TSF,'DrawWicImage');
   Add(DrawPicture(Dsn),TSF,'DrawPicture');
   if CPUFixed and (PaMask<>0) then SetThreadAffinityMask(GetCurrentThread,PaMask);
   Clipboard.AsText:=Results;
   ShowMessage(Results);
end;
Gruß, Klaus
Die Titanic wurde von Profis gebaut,
die Arche Noah von einem Amateur.
... Und dieser Beitrag vom Amateurprofi....
  Mit Zitat antworten Zitat
Amateurprofi

Registriert seit: 17. Nov 2005
Ort: Hamburg
1.041 Beiträge
 
Delphi XE2 Professional
 
#8

AW: Bitmap zeichen (gehts noch schneller?)

  Alt 29. Feb 2016, 22:25
Da ich das Bild nur ausgeben kann, wenn ich es vorher lade, drängt sich das laden in eine TGPBitmap förmlich auf.
Wenn es dir einzig und allein darum geht, verschiedene Grafik-Formate zu laden und du sonst nichts mit der GDI+-Biblothek machst, kannst du auch Vcl.Graphics.TWicImage nehmen.

Siehe hier:
http://www.tek-tips.com/faqs.cfm?fid=7568
Hallo TiGü:
kannte ich auch noch nicht.
Ist aber keine Alternative, weil recht bummelig.
Im nächsten Beitrag werde ich das mal alles zusammenfassen.
Gruß, Klaus
Die Titanic wurde von Profis gebaut,
die Arche Noah von einem Amateur.
... Und dieser Beitrag vom Amateurprofi....
  Mit Zitat antworten Zitat
Antwort Antwort


Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 13:12 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz