Vektor-PMTiles-Viewer: PMTiles-Karten kostenlos online öffnen

Ein Vektor-PMTiles-Viewer, der in Ihrem Browser läuft

PMTiles ist ein Einzeldatei-Format für gekachelte Karten. Ein .pmtiles-Archiv enthält eine ganze Kachelpyramide, von der Weltansicht bei Zoom 0 bis zur Straßenebene, dazu einen Index, der sagt, wo jede Kachel in der Datei liegt. Weil eine Karten-App jede Kachel mit einer einzigen HTTP-Range-Anfrage lesen kann, legen Sie die Datei einfach in einen Cloud-Speicher und nutzen sie ganz ohne Kachelserver als Karte. Deshalb sind PMTiles-Karten heute ein üblicher Weg, OpenStreetMap-Daten zu veröffentlichen: Die Protomaps-Basiskarten und viele Stadt- und Landeskarten aus Planetiler erscheinen als OpenStreetMap-PMTiles-Dateien.

In so eine Datei hineinzusehen ist schwerer. Eine .pmtiles-Datei ist binär, kein normales Programm öffnet sie, und für die Vektorkacheln braucht man meist MapLibre, einen Stil und etwas Code. Dieser PMTiles-Vektor-Viewer online nimmt Ihnen das ab. Legen Sie eine Datei ab oder fügen Sie die URL eines Archivs ein, das schon online ist: Der Viewer liest Header und Verzeichnisse, holt nur die sichtbaren Kacheln, dekodiert sie im Browser und zeichnet jeden Layer in eigener Farbe.

Er ist ebenso ein Prüfwerkzeug wie ein Viewer. Klicken Sie ein Objekt an, um seine Attribute zu lesen, schalten Sie Layer ein und aus, sehen Sie die Kachelgrößen je Zoomstufe und prüfen Sie das Archiv gegen PMTiles v3 und die Vektorkachel-Spezifikation: Header, Kompression, Clustering, Größe des Wurzelverzeichnisses, Metadaten, Ausdehnung, Kachelzahlen und ETag. Danach exportieren Sie die sichtbaren Objekte als GeoJSON, speichern ein PNG oder laden einen technischen Bericht. Mein Rat: Öffnen Sie das Archiv über seine endgültige URL, bevor Sie es ankündigen. Die meisten Fälle von „PMTiles-Karte lädt nicht“ sind CORS- oder Range-Einstellungen am Bucket, und dieser Viewer zeigt sie mit einem Klick.

Was der Vektor-PMTiles-Viewer kann

Hier ist alles, was das Werkzeug tut, in der Reihenfolge, in der Sie es nutzen.

1. Datei oder URL öffnen. Ziehen Sie eine .pmtiles-Datei auf die Karte, klicken Sie „PMTiles öffnen“ oder fügen Sie eine URL ein und drücken Sie Öffnen. Es gibt keine Größengrenze: Der Viewer liest nur Header, Verzeichnisse und die Kacheln, die er braucht, von Ihrer Festplatte oder von einem Server. „Beispiel laden“ öffnet eine kleine OpenStreetMap-PMTiles-Datei der Pariser Innenstadt, der Beispiel-Link ein Archiv von Florenz auf pmtiles.io.
2. Die Karte sofort sehen. Der Viewer liest die Ausdehnung aus dem Header und zoomt zu den Daten. Jeder Layer wird in eigener Farbe auf eine Leinwand gezeichnet: Polygone als helle Flächen, Linien als Striche, Punkte als Punkte mit Beschriftung. Layernamen aus den Schemas von Protomaps, OpenMapTiles und Shortbread, etwa water, landuse, buildings, roads und places, bekommen natürliche Farben.
3. Mit den Layern arbeiten. Der Reiter Layer listet jeden Layer aus den Metadaten und aus den Kacheln auf, mit Geometrietypen, der Zahl der Objekte in einer Stichprobe und allen Feldern samt Beispielwert. Schalten Sie Layer ein und aus, drücken Sie „Nur“, um einen Layer allein zu sehen, oder klicken Sie auf das Farbfeld, um eine eigene Farbe zu wählen.
4. Objekte per Klick prüfen. Klicken Sie in die Karte, und eine Karte zeigt jedes Objekt an dieser Stelle in den sichtbaren Layern: Layer, Geometrietyp, ID und alle Attribute, zum Beispiel kind, name und min_zoom einer OpenStreetMap-Straße. Das Objekt wird hervorgehoben, und Sie können es als GeoJSON kopieren oder die ganze Kachel als .pbf-Datei laden.
5. Die Archiv-Info lesen. Der Reiter Archiv-Info zeigt Header und Metadaten in klaren Worten: Name, Quellenangabe, Kacheltyp, Kompression von Kacheln und Verzeichnissen, Zoombereich, Ausdehnung, Mittelpunkt, das Erstellungswerkzeug (zum Beispiel Planetiler), Archivgröße, die Zahl adressierter und eindeutiger Kacheln und die Größe der Verzeichnisse.
6. Die Kacheln prüfen. Der Viewer liest jeden Verzeichniseintrag und nennt je Zoomstufe die Zahl der Kacheln sowie Gesamt-, Durchschnitts- und Höchstgröße, dazu die zehn größten Kacheln. Mit „Zeigen“ springen Sie zu einer Kachel. Das Kachelraster zeichnet jeden Kachelrand mit z/x/y und gespeicherter Größe.
7. Die Prüfungen ausführen. Der Reiter Prüfungen testet das Archiv: Header-Version, Kacheltyp, Kompression, Clustering, ob das Wurzelverzeichnis in die ersten 16 KB passt, Metadaten und vector_layers, Ausdehnung und Mittelpunkt, Zoombereich und Kachelzahlen gegen die Verzeichnisse, Kacheln über 500 KB, Deduplizierung, Quellenangabe und bei URLs das ETag. Jede Prüfung ist als OK, Warnung oder Fehler markiert und klar erklärt.
8. Einen Link teilen. Wenn Sie ein Archiv über eine URL öffnen, liefert „Link zu diesem Archiv kopieren“ einen Link zu dieser Seite, der dieselbe Datei öffnet. Schicken Sie ihn einer Kollegin oder einem Kollegen, und beide sehen dieselbe Karte und dieselben Prüfungen.
9. Über die Daten hinaus zoomen. Vektorkacheln bleiben scharf, wenn Sie über die letzte Zoomstufe hinaus vergrößern. Der Viewer zeichnet die tiefsten Kacheln dann vergrößert weiter („Overzoom“). Unter der ersten Zoomstufe sagt ein Hinweis, dass Sie hineinzoomen sollen.
10. Exportieren. Laden Sie die sichtbaren Objekte als GeoJSON, die Kartenansicht als PNG, Header und Metadaten als JSON oder einen technischen Bericht mit Prüfungen, Header, Layern, Feldern, Kachelstatistik und Empfehlungen.

Eine lokale Datei wird von JavaScript in Ihrem Browser-Tab stückweise gelesen und nie hochgeladen. Eine URL liest Ihr Browser direkt von deren Server; diese Seite sieht die Daten nicht.

So sehen Sie eine PMTiles-Datei an, Schritt für Schritt

Ein echtes Beispiel mit der OpenStreetMap-PMTiles-Probe der Pariser Innenstadt (Protomaps-Basiskartenschema, Zoom 0 bis 12).

1

Schritt 1: Den Vektor-PMTiles-Viewer öffnen

Das Werkzeug startet mit leerer Karte, einem Ablagebereich und einem URL-Feld. Ziehen Sie Ihre .pmtiles-Datei auf die Karte, klicken Sie, um eine Datei zu wählen, fügen Sie eine URL ein oder drücken Sie „Beispiel laden“.

2

Schritt 2: Das Archiv laden

Der Viewer liest Header und Wurzelverzeichnis, zoomt zur Ausdehnung und zeichnet alle Layer der OpenStreetMap-Daten: Wasser in Blau, Parks in Grün, Gebäude in Braun, Straßen in Orange und Ortsnamen in Rot.

3

Schritt 3: Die Layer erkunden

Der Reiter Layer listet jeden Layer mit Geometrie, den Objekten in einer Stichprobe und allen Feldern. Hier sind nur roads und water eingeschaltet, so sieht man das Straßennetz und die Seine.

4

Schritt 4: Ein Objekt anklicken

Klicken Sie auf eine Straße. Die Karte zeigt Layer, Geometrie, ID und OpenStreetMap-Attribute wie kind, kind_detail und name, und die Straße wird auf der Karte hervorgehoben.

5

Schritt 5: Die Archiv-Info lesen

Der Reiter Archiv-Info übersetzt Header und Metadaten in klare Worte: Kacheltyp MVT, gzip-Kompression, Zoom 0 bis 12, Ausdehnung, Mittelpunkt, Zahl der Kacheln und Größe der Verzeichnisse.

6

Schritt 6: Die Kacheln prüfen

Der Reiter Kacheln zeigt Kacheln und Größen je Zoomstufe und die größten Kacheln, gelesen aus den Verzeichnissen. Mit eingeschaltetem Kachelraster wird jeder Kachelrand mit z/x/y und gespeicherter Größe gezeichnet.

7

Schritt 7: Die Prüfungen ausführen

Der Reiter Prüfungen testet das Archiv gegen die Regeln von PMTiles v3 und Vektorkacheln. Die Probe besteht jede Prüfung; ein über URL geöffnetes Archiv bekommt zusätzlich eine ETag-Prüfung.

8

Schritt 8: Den Bericht laden

Der technische Bericht fasst Zusammenfassung, Kartenvorschau, Prüfungen, den vollständigen Header, die Metadaten, jeden Layer und jedes Feld, die Kachelstatistik und Empfehlungen auf einer Seite zusammen. Drucken Sie ihn oder speichern Sie ihn als PDF.

Wie öffnet man eine PMTiles-Datei? Ihre Möglichkeiten

Es gibt mehrere Wege, eine .pmtiles-Datei zu öffnen. Welcher passt, hängt davon ab, ob Sie sie ansehen, prüfen oder eine Karte damit bauen wollen.

1. Im Browser, mit diesem Viewer. Der schnellste Weg zu sehen, was in einem Vektorarchiv steckt, von der Festplatte oder über eine URL: keine Installation, kein Server, läuft unter Windows, Mac, Linux und auf Tablets. Ideal, um ein Archiv zu prüfen, Attribute zu lesen und einen Bericht zu teilen. Für Raster-PMTiles (PNG-, JPEG-, WebP-Kacheln) nutzen Sie den PMTiles-Viewer auf dieser Seite.
2. Mit dem Viewer von pmtiles.io. Der offizielle Viewer von Protomaps zeigt Header, Metadaten und einen Kachel-Inspektor. Gut für einen schnellen technischen Blick; dieser Viewer bietet zusätzlich Layerfarben, Attributfelder, Kachelstatistik, Prüfungen und Exporte.
3. In MapLibre GL JS. Binden Sie die pmtiles-Bibliothek ein, registrieren Sie das Protokoll und lassen Sie eine Vektorquelle auf pmtiles://https://example.com/datei.pmtiles zeigen. Mit einem Stil (zum Beispiel den Protomaps-Basiskartenstilen) entsteht eine fertige, schnelle Webkarte. So werden die meisten PMTiles-Karten veröffentlicht.
4. In QGIS. Eine QGIS-Version mit GDAL 3.8 oder neuer öffnet eine .pmtiles-Datei über den PMTiles-Treiber von GDAL: Layer → Layer hinzufügen → Vektorlayer hinzufügen, dann die Datei wählen. Jeder Kachel-Layer wird ein Vektorlayer. Gut, wenn Sie die Daten mit anderen GIS-Daten kombinieren wollen.
5. Mit dem Kommandozeilenwerkzeug pmtiles. Das Programm go-pmtiles zeigt den Header („pmtiles show“), schneidet ein Gebiet aus („pmtiles extract“), wandelt aus MBTiles um („pmtiles convert“) und liefert das Archiv als z/x/y-Kacheln aus („pmtiles serve“).
6. Als MBTiles. Wenn ein Werkzeug nur MBTiles liest, wandeln Sie das Archiv mit „pmtiles convert datei.pmtiles datei.mbtiles“ um. Die Kacheln bleiben gleich; für die andere Richtung gibt es auf dieser Seite einen kostenlosen MBTiles-zu-PMTiles-Konverter.

Eines ist überall gleich: Ein PMTiles-Archiv enthält Daten, keinen Stil. Jede App entscheidet selbst, wie sie die Layer färbt. Dieser Viewer wählt Farben nach den Layernamen, damit Sie den Aufbau sehen, ohne zuerst einen Stil zu schreiben.

Wie der Viewer ein PMTiles-Archiv liest und die Kacheln zeichnet

Ein PMTiles-Archiv zu öffnen braucht fünf Schritte: den Header lesen, die Kartenposition in eine Kachel-ID umrechnen, die ID in den Verzeichnissen suchen, die Bytes mit einer Range-Anfrage holen und die Kachel entpacken, dekodieren und zeichnen. Hier ist genau, was passiert, mit den Zahlen der Pariser Probe.

Bytes 0–126       Header          "PMTiles" + Version 3 + Offsets, Zahlen, Zoom, Ausdehnung
Wurzelverzeichnis muss vor Byte 16.384 enden
JSON-Metadaten    name, attribution, vector_layers, …
Blattverz.        optional, für große Archive
Kacheldaten       die Kacheln, eine nach der anderen

Pariser Probe     Wurzel 127 + 142 Bytes   Metadaten 269 + 870 Bytes
                  Kacheldaten 1.139 + 2.929.805 Bytes   24 Kacheln, Zoom 0–12
                  Ausdehnung 2.197266, 48.748945, 2.460938, 48.922499

erste ID von Zoom z = (4^z − 1) / 3       0, 1, 5, 21, 85, …
Kachel-ID = erste ID von Zoom z + Hilbert-Index d(x, y)

Zoom 1:  1/0/0 → 1   1/0/1 → 2   1/1/1 → 3   1/1/0 → 4

Paris    12/2074/1409
         erste ID von Zoom 12 = (16.777.216 − 1) / 3 = 5.592.405
         d(2074, 1409)        = 14.248.941
         Kachel-ID            = 19.841.346

Eintrag      Kachel-ID   Lauflänge   Offset     Länge
0/0/0                0       1              0     65.269
1/1/0                4       1         65.269     76.322
2/2/1               18       1        141.591    124.909
3/4/2               75       1        266.500    116.768

gespeichert  24 | 0, 4, 14, 57 | 1, 1, 1, 1 | 65269, 76322, … | 1, 0, 0, …
             Anzahl  ID-Differenzen  Lauflängen  Längen         Offsets (0 = direkt nach der vorigen Kachel)

Lauflänge 0  → der Eintrag zeigt auf ein Blattverzeichnis, nicht auf eine Kachel

GET /florence.pmtiles
Range: bytes=0-16383                 → 206 Partial Content   Header + Wurzel
Range: bytes=525-22237               → 206                   JSON-Metadaten
Range: bytes=22238-456635            → 206                   Kachel 0/0/0

Server braucht   Accept-Ranges: bytes, Status 206 für einen Bereich
                 CORS: Access-Control-Allow-Origin für Ihre Seite
                 ein ETag, damit eine ersetzte Datei bemerkt wird

Zoom der Kachel-ID t = größtes z mit (4^z − 1) / 3 ≤ t
Kacheln je Zoom     = Σ Lauflängen in dieser Zoomstufe
Größe je Zoom       = Σ Lauflänge × Länge
Abdeckung           = Kacheln / 4^z

Ersparnis durch Deduplizierung = 1 − tile_contents_count / addressed_tiles_count

Varint   300 = 1010 1100  0000 0010  → 0101100 + 0000010 × 128 = 300
Zigzag   0 → 0,  −1 → 1,  1 → 2,  −2 → 3      n = (z >>> 1) ^ −(z & 1)

Befehl = (Anzahl << 3) | id     MoveTo = 1, LineTo = 2, ClosePath = 7
9  = MoveTo 1 Punkt     18 = LineTo 2 Punkte     15 = ClosePath

Polygonring Fläche > 0  Außenring,  Fläche < 0  Loch

Maßstab = 256 × f / extent        f = 2^(z_Karte − z_Daten)
Versatz = (x mod f, y mod f) × 256

Punkt     Treffer bei Abstand ≤ 7 px
Linie     Treffer bei Abstand zu einem Segment ≤ 5 px
Polygon   Treffer, wenn ein Strahl vom Klick die Ringe ungerade oft schneidet

gespeicherte Größe = Länge im Verzeichniseintrag    Bytes, komprimiert
mittlere Größe     = Größe je Zoom / Kacheln je Zoom
Richtwert          größte Kachel < 500 KB  (512.000 Bytes)

Florenz (pmtiles.io)   größte Kachel 0/0/0 = 434.398 Bytes  → OK

PMTiles und die Exportformate im Detail

Was in einem PMTiles-Archiv steckt, wie es sich von MBTiles unterscheidet und was jeder Download aus diesem Viewer enthält.

metadata = {
  "name": "Paris, OpenStreetMap sample",
  "attribution": "© OpenStreetMap contributors",
  "vector_layers": [
    { "id": "roads", "minzoom": 3, "maxzoom": 12,
      "fields": { "kind": "String", "kind_detail": "String",
                  "name": "String", "min_zoom": "Number", … } } ]
}

{ "type": "Feature", "id": 35184380521390,
  "properties": { "kind": "highway", "kind_detail": "motorway", "name": "Avenue de Paris",
                  "min_zoom": 4, "_layer": "roads", "_tile": "11/1037/705" },
  "geometry": { "type": "LineString",
                "coordinates": [[2.3650217, 48.7375971], [2.3645496, 48.7386726], …] } }

Alle Exporte entstehen in Ihrem Browser aus dem geöffneten Archiv. Nichts wird an diese Seite geschickt.

Wer einen Vektor-PMTiles-Viewer nutzt

PMTiles hat das Karten-Hosting von Kachelservern auf einfache Dateien verlagert, daher müssen heute viele Menschen in diese Dateien hineinsehen.

1. Webkarten-Entwickler. Prüfen Sie ein Archiv, bevor Sie einen MapLibre-Stil schreiben: welche Layer es gibt, wie die Felder heißen, ab welcher Zoomstufe Daten erscheinen. Öffnen Sie die Produktions-URL, um vor dem Start zu sehen, ob Range-Anfragen und CORS funktionieren.
2. OpenStreetMap-Mapper und Datennutzer. Sehen Sie sich einen OpenStreetMap-PMTiles-Ausschnitt von Protomaps oder aus einem Planetiler-Build an, klicken Sie Straßen, Gebäude und Orte an und sehen Sie genau, welche OSM-Tags in den Kacheln gelandet sind.
3. GIS-Analysten. Bestätigen Sie, dass eine Ausgabe von tippecanoe, Planetiler oder „pmtiles convert“ die richtigen Layer, Attribute und den richtigen Zoombereich enthält, und übergeben Sie sie mit dem Bericht.
4. DevOps- und Cloud-Teams. Testen Sie einen Bucket auf S3, R2 oder Google Cloud Storage: Der Viewer zeigt CORS-Fehler, fehlende Range-Unterstützung und fehlende ETags in klaren Worten, und die Prüfungen finden zu große Kacheln und nicht geclusterte Archive.
5. Herausgeber von Daten. Prüfen Sie Quellenangabe, Ausdehnung, Mittelpunkt und Beschreibung, bevor Sie PMTiles-Karten veröffentlichen, damit Nutzer die richtige Quellenangabe und den richtigen Startausschnitt bekommen.
6. Offline- und Feldkartierung. Prüfen Sie, ob ein mit „pmtiles extract“ geschnittenes Archiv das richtige Gebiet und die richtigen Zoomstufen abdeckt, bevor Sie es auf ein Gerät ohne Netz kopieren.
7. Studierende und Lehrende. Sehen Sie, wie cloud-native Karten funktionieren: Schalten Sie das Kachelraster ein, vergleichen Sie Kachelgrößen über die Zoomstufen, lesen Sie den Header und verfolgen Sie eine Kachel-ID durch die Verzeichnisse.
8. Support und Fehlerberichte. Zeigt eine PMTiles-Karte eine Lücke, finden Sie die Kachel, laden Sie sie als .pbf und hängen Sie sie mit dem Bericht an das Ticket.

Häufige Fragen zu PMTiles

Die 20 Fragen, die am häufigsten zu PMTiles-Dateien und diesem Viewer gestellt werden.

Spezifikationen, Software und Datenquellen

Der Viewer baut auf offenen Spezifikationen, offener Software und offenen Daten auf:

• PMTiles (Protomaps) · BSD-3-Clause
  Spezifikation PMTiles v3 und JavaScript-Bibliothek pmtiles von Protomaps: Aufbau des Archivs, Hilbert-Kachel-IDs, Verzeichnisse und das Lesen von Header, Verzeichnissen und Kacheln aus einer Datei oder URL.
• Mapbox Vector Tile Specification · Specification
  Spezifikation Mapbox Vector Tile: Protobuf-Aufbau, Geometriebefehle und Umlaufregeln, denen der Decoder folgt.
• Leaflet 1.9 · BSD-2-Clause
  Interaktive Karte und die Canvas-Rasterebene, die die Kacheln zeichnet.
• OpenStreetMap · ODbL 1.0
  Kartendaten in der Pariser Probe und im Florenz-Beispiel: © OpenStreetMap contributors, unter der Open Database License.
• Protomaps Basemap and pmtiles.io · BSD-3-Clause / ODbL
  Basiskartenschema der Probe und das Florenz-Beispielarchiv auf pmtiles.io.
• Protomaps (hosted by KONAKTIVE), CARTO, OpenStreetMap, Esri World Imagery · ODbL and provider terms
  Optionale Hintergrundkarten: eigene Vektorkacheln, gehostet von KONAKTIVE, mit CARTO und OpenStreetMap als Ausweichlösung, sowie Esri World Imagery.

Das Durchlaufen der Verzeichnisse, der Vektorkachel-Decoder, der Renderer, die Prüfungen und alle Exporte wurden für diese Seite geschrieben und laufen vollständig in Ihrem Browser.

Verwandte Werkzeuge für Kacheln und GIS-Dateien