Hallo,

ich mache mir schon seit einigen Tagen Gedanken über Tile-Mapping - weiss aber immer noch nicht, was so der beste Weg dafür ist.

Problemfall: Ich habe ein wirklich grosses Image (eine Europa-Karte - sehr detailiert) und möchte diese auf meinem Endgerät darstellen. Diese soll natürlich scrollbar und zoombar sein. Als "Königsdisziplin" käme noch eine Rotation dazu (also eine Karte, die nicht genordet ist, sondern sich der aktuellen Bewegungsrichtung anpasst).
Programmiersprache und Endgerät sind erstmal egal - mich interessiert zuerst mal die grundsätzliche Herangehensweise.

Ich habe mir überlegt, ich teile mein Image erstmal in kleine Stücke auf - soweit so gut: Aber wie gross ist ideal? 64x64px? 128x128px? oder grösser oder noch kleiner?
Wenn ich diese nun hab, erstelle ich dann ein - sagen wir mal panel - von der gesamtgrösse und dann lege ich darauf kleine images ab, die ich aber erst dann lade, wenn diese in den Sichtbereich kommen? Oder erstelle ich die Images on-the-fly erst, wenn diese benötigt werden?
Was passiert mit den Images, die aus dem Sichtbereich verschwinden, wenn ich in der Karte gescrollt habe? Lösche ich diese wegen der Ressourcen oder lass ich diese stehen, weil ich die ja bereit mit dem Image geladen habe und dann spare ich mir eine weitere Ladezeit, wenn diese wieder in die Karte zurückgescrollt werden?

Was passiert beim Zoomen? Wenn ich keine festen Zoomstufen habe, sondern ein smoothless Zooming (so wie auf den Smartphones) haben möchte, was lade ich dann z.b. bei der höchsten und was bei der niedrigsten Auflösung? Immer die gleiche Karte oder sollte ich unterschiedliches Kartenmaterial für verschiedene Zoomstufen haben?

Naja und dann natürlich die Krönung: Wie bekomme ich es hin, daß die gesamte Map in Echtzeit gedreht wird? Drehe ich dann einfach das Panel? Wie berechne ich dann den "sichtbaren" Bereich an den Ecken?

Ja, ich weiss - ganz viele Fragen, aber vielleicht hat ja der eine oder andere so was schon mal gemacht und kann mir ein paar Tipps geben.

Sascha

Grundprinzip: Trenne die Daten von der Darstellung.

Daten: Ein riesiges Bild, meinetwegen 50.000 x 50.000 Pixel
Anzeige: Ein kleines Bild, so groß wie das Display, meinetwegen 1.000 x 1.000 Pixel.

Mein Vorgehen wäre: Daten aufteilen in kleine Bitmap-Dateien, da würde ich als Richtwert die Displaygröße nehmen. Beim Bewegen auf der Karte muss dann bestimmt werden, welche Daten benötigt werden (das wären dann max. die Daten aus 4 Bitmap-Dateien). Daraus dann zuerst offscreen ein Bitmap zusammenbasteln (iirc geht das mit draw sehr einfach) und das dann auf die Anzeige-Komponente kopieren (assign).

Beim Drehen auch: Da wird nicht das Anzeigepanel gedreht (wüsste auch nicht, wie das gehen soll), sondern das gedrehte Bild wird erst "intern berechnet". D.h. zunächst ein etwas größeres Bild wie oben erstellen, das dann drehen (Forensuche müsste dazu was hergeben, auf Anhieb habe ich da keine Idee), und dann den entsprechenden Ausschnitt in das TImage kopieren.

Zudem kannst du das gedrehte Zeichnen auch automatisiert erledigen lassen. Stichwort SetWorldTransform usw.

In OpenGL ist das einfach umzusetzen. Sowohl ein stufenloses Zoomen als auch ein stufenloses Rotieren wird von OpenGL direkt unterstützt. Die Qualität ist sehr gut und Du hast keinen großen Aufwand. Wichtig ist, dass Du für die Bewegungen ein Timebased Movement benutzt. Wie groß ist die Karte den maximal?

Viele Grüße