Schnelleres laden von PNGs

[Breager]

Immer dieses Rätselraten
Je genauer Du beschreibst, was Du eigentlich vorhast, desto wahrscheinlicher ist, dass Dir jemand helfen kann. Oder ist das ein Geheimnis?

Je nach der Größe einzelner Bilder ist es sinnvoll, diese zu einem großen Bild (Tilemap) zusammenzufassen, das große Bild zu laden und anschließend den entsprechenden Bildausschnitt zu kopieren. Wie werden die einzelnen Bilder angezeigt? In verschiedenen Image-Komponenten oder in einer? Werden die Bilder zufällig ausgewählt, oder ist es absehbar, welche Bilder verwendet werden?

[pustekuchen]

Vielen Dank für die Zahlreichen antworten =)

Zitat von Klaus01:

.. wenn ein bestimmtes Bild geladen/angefordert wurde ist es Dir dann möglich
vorrauszusehen welche(s) Bild/Bilder als nächstes angefragt werden könnten.

Ja wäre es.

Zitat von Klaus01:

@pustekuchen: Wieso Arbeitest du nicht durchgehend mit PNG's? Haben ja mit der Semitransparenz einen großen Vorteil gegenübr PNG's.

Gut das du mich darauf nochmal aufmerksam machst. Wenn ich mich recht entsinne habe ich es so gemacht, weil ich die PNG nach BMP umwandle, diese einzelteile dann auf eine große Bitmap kopiere und dann einen Teilbereich auf eine Paintbox zeichne. Da gab nachher das Problem, das die Bilder unterschiedliche Farben hatten und das Endergebniss dann ein zusammenengewürfeltes Kunderbunt war. Wenn ich natürlich nun richtig die PNG auf die große Bitmap gezeichnet bekommen, wäre das schonmal ein großer Performance schub.

EDIT: Habs nun nochmal umgeschrieben.

Delphi-Quellcode:

if not Assigned(FPicArray[i - xMin][k - yMin].PngImage) then
          begin
            FPicArray[i - xMin][k - yMin].PngImage := TPNGImage.Create;
            FPicArray[i - xMin][k - yMin].PngImage.Transparent := false;
          end;
          FPicArray[i - xMin][k - yMin].PngImage.LoadFromFile(Path);

Dannach wird das ganze folgendermaßen Kopiert.

Delphi-Quellcode:

BitBlt(Map.Canvas.Handle, xCount, yCount, SIZE_TILE, SIZE_TILE,
            FPicArray[i][k].PngImage.Canvas.Handle, 0, 0, SRCCOPY);

Nun kommen wieder die Kunterbunten Bilder, die dann etwa so aussehen:
Klick

EDIT2: Selbe Problem

Zitat von Iwo Asnet:

Verwende einen Cache, genauer gesagt, einen MRU-Cache. "Most Recently Used". Klingt toll, ist banal:
Du baust Dir eine Liste (verkettet z.B.) mit maximal N Elementen, oder sovielen Elementen, das maximal X Bytes Speicher verbraucht werden.
Die ist zunächst leer.

bevor Du eine PNG in eine Bitmap konvertieren willst, schaust Du im Cache nach, ob die da drin ist. Wenn ja, kommt sie an den ANFANG der Liste. Wenn nicht, wird sie erzeugt und auch an den ANFANG gepackt. Dadurch wächst die Liste. Wenn sie zu groß ist (mehr als N Elemente oder mehr als X Bytes Speicher) wird der LETZTE Eintrag der Liste verworfen.

3-2-1- Perfekt, skalierbar, schnell.

Das tolle ist ja, das die tendentiell oft benötigten Objekte vorne sind, und die selten benötigten eben tendentiell hinten. Also wird ein Cache-Miss relativ selten sein.

Das ist natürlich auch eine sehr gute Idee und würde im meinem Fall wahrscheinlich auch ein wenig helfen und dies werde ich dann auch noch implementieren.
Jedoch ist es ehr so das beim Laden der Bilder am meisten performance verloren geht und dies zuerst optimiert werden sollte.

Zitat von Breager:

Immer dieses Rätselraten
Je genauer Du beschreibst, was Du eigentlich vorhast, desto wahrscheinlicher ist, dass Dir jemand helfen kann. Oder ist das ein Geheimnis?

Je nach der Größe einzelner Bilder ist es sinnvoll, diese zu einem großen Bild (Tilemap) zusammenzufassen, das große Bild zu laden und anschließend den entsprechenden Bildausschnitt zu kopieren. Wie werden die einzelnen Bilder angezeigt? In verschiedenen Image-Komponenten oder in einer? Werden die Bilder zufällig ausgewählt, oder ist es absehbar, welche Bilder verwendet werden?

Ja hast schon recht =) Es stelle mit meiner Anwendung eine Karte dar, die aus Tiles besteht. Das zusammenkopieren auf eine Karte und dann einen Bildauschnitt rauszukopieren passiert bereits.

Edit: Das Kopieren geschieht mit BitBlt

[Uwe Raabe]

Mangels realen Daten kann ich es nicht ausprobieren, aber ich würde versuchen, die PNGs direkt zu speichern und mit TPngImage.Draw an die passende Stelle zu zeichnen.

[pustekuchen]

Die Draw Methode ist aber leider nicht so performant wie BitBlt und in diesem Fall, bei dem oft gezeichnet wird, ist es nicht ausreichend.

[Furtbichler]

Ermittle die Anzahl der CPUs und erstelle entsprechende Threads, die das Einladen erledigen.

[Bummi]

Zitat:

Die Draw Methode ist aber leider nicht so performant wie BitBlt und in diesem Fall, bei dem oft gezeichnet wird, ist es nicht ausreichend.

Ich würde ohnehin nicht in ein Zielbitmap malen sondern im (On)Paint eines GraphicControls (oder auch einer Paintbox) mit den GDI+ Routinen arbeiten, diese unterstützen nativ 32-Bit und Transparenzen.
http://www.progdigy.com/?page_id=7

2 Units einbinden, nichts installieren ...

[lbccaleb]

Vllt. hilft dir auch diese Komponente weiter.

Edit:
An deiner Stelle würde ich die Images gar nicht umwandeln, sondern so mit den PNG´s weiter arbeiten....

[Thom]

Zitat von pustekuchen:

Ingesamt sind es etwa 200.000 Bilder.

Zitat von pustekuchen:

Ja hast schon recht =) Es stelle mit meiner Anwendung eine Karte dar, die aus Tiles besteht. Das zusammenkopieren auf eine Karte und dann einen Bildauschnitt rauszukopieren passiert bereits.

Ich gehe mal davon aus, daß die Kartenteile auf legalem Weg erstanden wurden und will an dieser Stelle nicht den moralischen Zeigefinger erheben.

Dann bietet sich aber auf jeden Fall die Verwendung eines JavaScript-Viewers in Verbindung mit dem WebBrowser an (Google Maps, OpenLayers, ...). Alle diese Lösungen unterstützen auch die Anzeige beliebiger, anwenderdefinierter Bilder. Sie sind zugegebenermaßen nicht die schnellsten (meine reine Delphi-Lösung ist locker um den Faktor 10 schneller), sind aber auch mit relativ geringem Aufwand nutzbar. Willst Du ein ausgereiftes Programm in reinem Delphi - zum Beispiel mit kontinuierlichem Zoom, animierter Verschiebung der Karte per Maus, Overlays (unter transparente PNG's muß auch etwas darunter) und Steuerelemente -, kannst Du einen Entwicklungsaufwand von etlichen Monaten einplanen. Daraus ergeben sich schnell Kosten im 5-stelligen Bereich, wenn's nicht nur aus Spaß an der Freude geschehen soll.

Wenn Geld eine untergeordnete Rolle spielt, könntest Du eventuell die Komponente TGAgisSmartMap verwenden. Die ist in der Lage - soweit man das der compilierten Demo entnehmen kann - Tiles von der Festplatte anzuzeigen. Der Anbieter läßt sich das aber recht gut bezahlen: Für das Basic Package werden 499 und für das Standard Package 699 US-Dollar + MwSt. fällig - und das ohne Quelltext! Die werden schon wissen, weshalb...

Dann ist natürlich noch ausschlaggebend, ob deine Lösung plattformübergreifend - also zum Beispiel auch mit FireMonkey - funktionieren soll. Ansonsten würde ich auch die Verwendung von Graphics32 in Verbindung mit Threads als optimale Lösung empfehlen.

Wenn Du das allerdings schon so weit hast, würde ich mich sehr für Deine Lösung interessieren...

[Bummi]

@Thom
mit WorldTranslation/Transformation ist das ganze doch zu 80% abgefackelt bei quasi keinem Aufwand.

[Thom]

@Bummi

Leider nicht wirklich. Jede Zoomstufe erfordert neue Kacheln, da ja sonst auch alle grafischen Details (Schrift, Straßen usw.) vergrößert bzw. verkleinert werden. Hast Du ganz weit herausgezoomt, bräuchtest Du zum Lesen ein Mikroskop - ansonsten hast Du Text für (fast) Blinde...
Dann geht es weiter mit der Verwaltung der Kacheln. Normalerweise kannst Du die Karte horizontal beliebig verschieben (also Dich quasi 199 mal um den Globus drehen) - vertikal ist aber bei rund 80° Schluß. Wurde jetzt eine Karte mit niedriger Zoomstufe x mal um 360° verschoben und anschließend kräftig hineingezoomt, entstehen leicht Zahlen, die schon an die Grenzen von Int64 gehen. Also muß bei der gesamten Koordinatentransformation extrem aufgepaßt werden, damit es zu keinen Überläufen kommt. Bei Zoomstufe 22 handelt es sich um Terrapixelbilder - nur eben in kleine Teile zerlegt.
Will man sogar eine animierte Verschiebung der Karte (wie das Wischen auf einem Touchscreen) kommt man schnell in die Verlegenheit, auch noch mit Gleitkommazahlen rechnen zu müssen. Das überfordert dann alle Standardtypen und man muß eigene Typen und Berechnungen dazu entwerfen.
Die Kacheln müssen asynchron geladen und angezeigt werden. Das bedeutet Threads in Verbindung mit GDI...
Das geht alles, ist auch machbar - aber leider nicht "eben mal so nebenbei".