Mehr

Wie kann man vorgerenderte Vektorkacheln im pbf-Format zwischenspeichern und serveren?

Wie kann man vorgerenderte Vektorkacheln im pbf-Format zwischenspeichern und serveren?


Ich möchte einen Vektorkachelserver im pbf-Format bereitstellen. Dafür habe ich Mapnik-Vektor-Kacheln verwendet, die von avecado gebündelt werden. Mit avecado_server kann ich pbf-Kacheln im laufenden Betrieb rendern mit

./avecado_server -b 2 test/xml/vector_imposm_nocollect.xml 7789

Aber der vollständige Planet avecado_server reicht nicht aus, um im laufenden Betrieb zu Servern, da das Rendern jeder Kachel mehr Zeit in Anspruch nimmt.
Also brauche ich Kacheln mit ./avecado vorrendern und auf der Festplatte zwischenspeichern und diese zwischengespeicherten Kacheln mit einem separaten Server serveren.

Avecado generiert Kacheln im pbf-Format.

Dafür greife ich lieber zu Tile Stache. Aber ich wusste nicht, wie man Tile Stache für dieses Szenario verwendet.

Bitte schlagen Sie mir eine beste Möglichkeit vor, die vorgerenderten Kacheln zwischenzuspeichern und bereitzustellen.


Wahrscheinlich suchen Sie nach dieser Seite: Diese Seite listet Implementierungen von Software auf, die mit Vektorkacheln im Mapbox-Protobuf-Format arbeiten.


Ein progressiver Vektorkartenbrowser für das Web

Mit der zunehmenden Popularität von webbasierten Kartenbrowsern ist es alltäglich geworden, aus der Ferne eine qualitativ hochwertige Darstellung kartografischer Informationen zu erhalten. Die meisten Web-Mapping-Systeme verlassen sich jedoch auf Server mit hoher Kapazität, die vorgerenderte gekachelte Karten im Rasterformat übertragen. Dieser Ansatz ist in der Lage, auf der Client-Seite qualitativ hochwertige Renderings zu erzeugen, während gleichzeitig eine begrenzte Bandbreite verwendet und der Bild-Cache des Browsers ausgenutzt wird. Diese Ziele sind für Karten im Vektorformat schwieriger zu erreichen. In dieser Arbeit stellen wir eine alternative Client-Server-Architektur vor, die in der Lage ist, Vektorkarten in Detailebenen (LOD) schrittweise zu übertragen, indem Techniken wie polygonale Linienvereinfachung, räumliche Datenstrukturen und vor allem ein angepasster Speicherverwaltungsalgorithmus verwendet werden. Es wird eine Multiplattform-Implementierung dieses Systems beschrieben, bei der die Client-Anwendung vollständig in JavaScript geschrieben und im Webbrowser verarbeitet wird, wodurch externe Anwendungen oder Plug-Ins vermieden werden. Es werden Ergebnisse von Experimenten präsentiert und erläutert, die darauf abzielen, sowohl die Leistung als auch die mit dem System erzielte Anzeigequalität zu messen. Es werden auch Erweiterungen des Systems diskutiert, einschließlich Themen wie Kompromisse zwischen Detailgenauigkeit und visueller Bedeutung und die Handhabung geschlossener polygonaler Linien.

Laden Sie herunter, um den vollständigen Artikeltext zu lesen


Abstrakt

Elektronische Karten (E-Maps) bieten den Menschen Komfort im realen Weltraum. Obwohl Webkartendienste Karten auf Bildschirmen anzeigen können, ist ihre Fähigkeit, auf geografische Merkmale zuzugreifen, eine wichtigere Funktion. Eine auf Rasterkacheln basierende E-Karte ist Vektorkacheln in Bezug auf die interaktive Fähigkeit unterlegen, da Vektorkarten eine bequeme und effektive Methode für den Zugriff und die Manipulation von Webkartenfunktionen bieten. Das kritische Problem beim Rendern von gekachelten Vektorkarten besteht jedoch darin, dass geografische Merkmale, die in Form von Kartensymbolen über Vektorkacheln gerendert werden, visuelle Diskontinuitäten verursachen können, wie z Hindernisse beim Erkunden von Vektorkartenkacheln im Web. Dieses Papier schlägt ein gekacheltes Vektordatenmodell für geografische Merkmale in symbolisierten Karten vor, das die Beziehungen zwischen geografischen Merkmalen, Symboldarstellungen und Kartendarstellungen berücksichtigt. Dieses Modell stellt eine Methode dar, um geografische Merkmale in Bezug auf Kartensymbole und „Hinzufügen“-(Verknüpfungs-)Operationen auf den folgenden zwei Ebenen anzupassen: geografische Merkmale und Kartenmerkmale. Somit können diese Karten das visuelle Diskontinuitätsproblem basierend auf dem vorgeschlagenen Modell lösen, ohne die Interaktivität von Vektorkarten zu schwächen. Das vorgeschlagene Modell wird durch zwei Kartendatensätze validiert, und die Ergebnisse zeigen, dass die gerenderten (symbolisierten) Webkarten eine glatte visuelle Kontinuität aufweisen.

Zitat: Li L, Hu W, Zhu H, Li Y, Zhang H (2017)Gekacheltes Vektordatenmodell für die geografischen Merkmale symbolisierter Karten. PLoS ONE 12(5): e0176387. https://doi.org/10.1371/journal.pone.0176387

Editor: George-John Nychas, Landwirtschaftliche Universität Athen, GRIECHENLAND

Erhalten: 13. Oktober 2016 Akzeptiert: 10. April 2017 Veröffentlicht: 5. Mai 2017

Urheberrechte ©: © 2017 Li et al. Dies ist ein Open-Access-Artikel, der unter den Bedingungen der Creative Commons Attribution License vertrieben wird und die uneingeschränkte Verwendung, Verbreitung und Reproduktion in jedem Medium gestattet, sofern der ursprüngliche Autor und die Quelle angegeben werden.

Datenverfügbarkeit: Alle relevanten Daten befinden sich in den Dateien mit den Hintergrundinformationen.

Finanzierung: Der Artikel wurde von der National Natural Science Foundation of China unter der Grant No.41271453 unterstützt und die URL lautet http://www.nsfc.gov.cn/, The Scientific and Technological Leading Talent Fund of National Administration of Surveying, Mapping and Geo- information (2014), das Wuhan-Programm „Yellow Crane Excellence“ (Wissenschaft und Technologie) (2014) und das unabhängige wissenschaftliche Forschungsprojekt zum Doktor der Wuhan-Universität (2012205020211). Die Geldgeber spielten keine Rolle beim Studiendesign, der Datenerhebung und -analyse, der Entscheidung zur Veröffentlichung oder der Erstellung des Manuskripts.

Konkurrierende Interessen: Die Autoren haben erklärt, dass keine konkurrierenden Interessen bestehen.


OSM-Kachelserver-Docker

Zuverlässige Karten zur Verwendung in Ihren Produkten. Starten Sie diesen Container mit detaillierten Straßenkarten, Häusern, Städten, Straßen, Autobahnen und Landnutzungsdaten - perfekt als Hintergrundkarten für Ihre Online-Anwendung. Die Software wird mit vorverarbeiteten OpenStreetMap-Daten in Form von Vektorkacheln geliefert - produziert vom OpenMapTiles-Projekt Dieser Container ermöglicht Ihnen die einfache Einrichtung eines OpenStreetMap-PNG-Kachelservers mit einer .osm.pbf-Datei. Es basiert auf dem neuesten Ubuntu 18.04 LTS-Handbuch von switch2osm.org und verwendet daher den Standard-OpenStreetMap-Stil. Einrichten des Servers Erstellen Sie zunächst ein Docker-Volume für die PostgreSQL-Datenbank, die die OpenStreetMap-Daten des OpenStreetMap-Kachelserver-Containers enthält. Dieses Repository enthält Anweisungen zum Erstellen eines Docker-Images, das den OpenStreetMap-Kachelbereitstellungs-Softwarestapel enthält. Es basiert auf den Anweisungen von Switch2OSM. Sie bietet nicht nur eine einfache Möglichkeit zum Einrichten und Ausführen der Tile-Serving-Software, sondern bietet auch Anweisungen zur Verwaltung der Back-End-Datenbank.

Dieses Repository enthält Anweisungen zum Erstellen eines Docker-Images, das den OpenStreetMap-Kachelbereitstellungs-Softwarestapel enthält. Es basiert auf den Anweisungen von Switch2OSM. Sie bietet nicht nur eine einfache Möglichkeit zum Einrichten und Ausführen der Tile-Serving-Software, sondern bietet auch Anweisungen zum Verwalten der Back-End-Datenbank, sodass Sie: die Datenbank erstellen OSM-Kacheln mit Docker rendern. 0. Hallo, ich versuche, den osm-Kartenkachelserver mit Docker zu erstellen. Ich habe die Anweisungen in https://medium.com/@rajitha.mail48/create-a-docker-image-of-an-offline-open-street-map-server-9fdedd433cc8 befolgt. Ich habe eine Anfrage für die Kartenebene 'ajt' erhalten, die nicht geladen werden konnte. Ich erhalte eine leere Seite als meine. Ich verwende den OSM-Kachelserver, der mit Docker aus dem Repository von Overv bereitgestellt wird, und in der Standardkonfiguration funktioniert es ziemlich gut. Im Dockerfile habe ich versucht, die openstreetmap-carto-Version manuell auf die neueste Version (heute 5.3.1) zu aktualisieren, mit nur

GitHub - Overv/openstreetmap-tile-server: Docker-Datei für

  1. Docker mit TileServer GL Wenn Sie einen Docker-Microservice und eine erweiterte Konfiguration benötigen, können Sie den Rendering-Core unseres Servers direkt verwenden. Um einen Tileserver zu installieren, der sowohl Vektor- als auch Raster-Kacheln bereitstellt, empfehlen wir die Verwendung des offiziellen Docker-Image tileserver-gl. Durch Starten des Dockers mit dem folgenden Befehl mounten Sie das Active Directory mit der zuvor heruntergeladenen MBTiles-Datei mit Vektorkacheln und führen den Kachelserver an einem lokalen Port 8080 . aus
  2. Ich verwende den OSM-Kachelserver, der mit Docker aus dem Repository von Overv bereitgestellt wird, und in der Standardkonfiguration funktioniert es ziemlich gut. Im Dockerfile habe ich versucht, openstreetmap-carto manuell auf die neueste Version (heute 5.3.1) zu aktualisieren, mit nur: RUN mkdir -p /home/renderer/src \ && cd /home/render..
  3. Der OSM-Kachelserver-Stack ist eine Sammlung von Programmen und Bibliotheken, die zusammenarbeiten, um einen Kachelserver zu erstellen. Wie so oft bei OpenStreetMap gibt es viele Wege, dieses Ziel zu erreichen und fast alle Komponenten haben Alternativen, die verschiedene spezifische Vor- und Nachteile haben. Dieses Tutorial beschreibt die Standardversion, die der auf den wichtigsten OpenStreetMap.org-Kachelservern verwendeten ähnlich ist
  4. % docker volume erstellen openstreetmap-data 2). Verwenden Sie openstreetmap-tile-server, um den Server zu erstellen, beginnen Sie mit dem Importieren der .pbf-Datei in PostgreSQL, indem Sie einen Container ausführen und die Datei als /data.osm.pbf mounten. Denken Sie daran, den physischen Dateipfad zu verwenden
  5. Liefern Sie ausschließlich vorgenerierte Kacheln von Apache über eine Leaflet-Schnittstelle: startweb Background. Dieses Image wurde von ncareol/osm-tiles-docker übernommen, das auf homme/openstreetmap-tiles-docker basiert, das auf den Switch2OSM-Anweisungen basiert. Es läuft unter Ubuntu 16.04 (Xenial) und basiert auf phusion/baseimage-docker. Es enthält: PostgreSQL 9.
  6. Hilfe, wenn es nicht funktioniert: Laden Sie zuerst eine Karte manuell über wget in einen Ordner auf Ihrem Server herunter, indem Sie auf https://openmaptiles.com gehen. Laden Sie die Datei auf Ihren Server (sie bieten einen wget-Befehl) dh /home/www/osmmaps/osm-2017-07-03-v3.6.1-europe.mbtiles Starten Sie nun den Docker, indem Sie die Datei oben in Ihren /data-Ordner binden des Docker-Image:.

GitHub - sekewei/openstreetmap-tiles-docker: Die

  1. Mit diesem Image kann jeder mit nur wenigen Befehlen einen Kachelserver ausführen, ohne sich um die Installation einer Menge Abhängigkeiten, PostgreSQL-Konfiguration und lange Kompilierungszeiten kümmern zu müssen. Es ist wirklich so einfach wie: Docker-Volume Openstreetmap-Daten erstellen Docker-Volume Openstreetmap-gerenderte-Kacheln erstellen
  2. Ich habe versucht, den https://github.com/Overv/openstreetmap-tile-server anzupassen. Unten ist mein Docker-Compose. Version: 3.7 Bände: openstreetmap-data: openstreetmap.
  3. Fliesen dienen. 2 CPUs 2 GB RAM 200 MB freie Festplattenkapazität für die Installation (zusätzlich für Kacheln) Kartenrasterisierung (ganzer Planet) 4 CPUs 16 GB RAM 100 GB für Kacheln, Schriftarten und andere Assets Caching nicht alleine lösen. Daher wird dringend empfohlen, einen Reverse-Proxy-Cache in der Produktion einzurichten. Die Rasterisierungsleistung kann in den Servereinstellungen/Rasterisierung eingestellt werden. Größe des Renderer-Pools höher einstellen.
  4. OpenStreetMap-Karten mit API für Leaflet, OpenLayers, WMS, WMTS, GIS und Mapbox SDKs. Container Linux x86-64-Anwendungsdienste
  5. Dies ist eine Liste von Online-Raster-Kachelservern basierend auf OpenStreetMap-Daten. Die Namen der physischen Server, die die Kartenkacheln von openstreetmap.org bedienen, finden Sie unter Servers/tile.In den bereitgestellten URLs $ und $ müssen durch die x- und y-Kachelnummern und $ . ersetzt werden durch die Zoomstufe. Manchmal fehlt das $. In den URLs zu Carto.com und einigen anderen gibt es auch ein die ersetzt werden sollen.

Docker-Datei für minimalen Aufwand OpenStreetMap-Kachelserver Diese Kachel wird an den Client zurückgegeben und geht zum nächsten Element in der Warteschlange. Zum Rendern werden OpenStreetMap-Daten in einer PostgreSQL-Datenbank gespeichert, die von einem Tool namens osm2pgsql erstellt wurde. Diese beiden Teile arbeiten zusammen, um einen effizienten Zugriff auf die geografischen Daten von OpenStreetMap zu ermöglichen. Es ist möglich, die Daten in der PostgreSQL-Datenbank auf dem neuesten Stand zu halten, indem alle 60 Sekunden ein Stream von Diff-Dateien auf dem OpenStreetMap-Hauptserver erstellt wird

Docker-Datei für minimalen Aufwand OpenStreetMap-Kachelserver (von Overv) Quellcode. Hülse. Openstreetmap-tile-server Alternativen . Ähnliche Projekte und Alternativen zu openstreetmap-tile-server osmscout-server. 2 105 6.0 C++ Maps-Server mit Kacheln, Geocoder und Router. osmand_map_creation. 2 7 6.5 Python OSM-Daten + offene Adressdaten, die für die Verwendung in OSMAnd kompiliert wurden. Erkunden. Gesponserte Scoutapm. OpenMapTiles-Karte Server. OpenMapTiles-Karte Server ist ein Software-Paket für Docker, was alle benötigten Teile beinhaltet, was man für das Hosten einer eigenen Map braucht. Das Setup ist einfach, sodass Sie Ihre Karte innerhalb von 10 Minuten hosten können. Installation. Es gibt ein grafisches Setup für Windows und Mac mit Docker und. Es besteht aus einer Reihe von Tools, mit denen jeder seine eigenen Vektorkartenkacheln aus OpenStreetMap-Daten für Hosting, Self-Hosting oder Offline-Nutzung erstellen kann. Es ist als kostenlose Software auf OpenMapTiles.org erhältlich. Es gibt auch ein Spin-off-Projekt namens MapTiler Data mit gebrauchsfertigen vorgenerierten Kartenkacheln und MapTiler Cloud für das Kartenhosting. PaulInOttawa. vor 5 Jahren. Antworten. Danke für dein Rezept! Leider bin ich. Aus dem OpenStreetMap-Wiki. Zur Navigation springen Zur Suche springen. Da die Nachfrage und Popularität auf der ganzen Welt wächst, ist es notwendig, die Bereitstellung von Kacheln an die Benutzer zu verteilen. Eine Möglichkeit, dies zu tun - ein Caching-Proxy-Server-Netzwerk zu erstellen. Tile-Proxy-Server-Software. Squid MapProxy ProxySimplePHP ProxySimplePHP5 Tilecache erstellt von CycleStreets osm-tile-proxy (einfacher Caching-Proxy geschrieben in.

Ein Kachelserver stellt entweder Vektorkacheln oder vorgerenderte Kacheln im PNG-Format bereit oder kann beides unterstützen. OpenStreetMap selbst betreibt auch einen Kachelserver (tile.openstreetmap.org), der für die Karte verwendet wird, die Sie auf der Homepage finden: https://www.openstreetmap.org Diesen Kachelserver können Sie in Ihrer Anwendung verwenden, müssen Sie jedoch einhalten mit der Nutzungsrichtlinie: https://operations.osmfoundation.org/policies/tiles . Am Anfang dachte ich erst man müsste den OpenStreetMap Tile Server aufbohren und ihn beibringen Zeitangaben zu akzeptieren. Doch mein Prof hat mir schnell erklärt, dass er vom Forken nicht viel hält, da es schwer zu warten ist und so ein.

GitHub - Geodaten/openstreetmap-tiles-docker: Der

  • Kostenloser Versand für Bestellungen über 35 $. Kaufen Sie Möbel, Wohnaccessoires, Kochgeschirr und mehr! Kostenloser Versand für alle Bestellungen über 35 $. Kaufen Sie Fliesen, Wohnaccessoires, Kochgeschirr und mehr
  • OpenMapTiles Map Server ist ein Software-Paket für Docker, welches alle benötigten Teile beinhaltet, welche man für das Hosten einer eigenen Map braucht. Das Setup ist einfach, sodass Sie Ihre Karte innerhalb von 10 Minuten hosten können
  • Also habe ich erst ein Docker System aufgebaut wo einen normalen Mapnik Tile-Server drauf lief und lernte erst einmal die einzelnen Komponenten kennen. Am Anfang dachte ich erst man müsste den OpenStreetMap Tile Server aufbohren und ihn beibringen Zeitangaben zu akzeptieren. Doch mein Prof hat mir schnell erklärt das er vom forken nicht viel hält, da es schwer zu warten ist und so ein Uniprojekt muss einfach bleiben
  • Dies ist eine Liste von Online-Raster-Kachelservern basierend auf OpenStreetMap-Daten. Die Namen der physischen Server, die die Kartenkacheln von openstreetmap.org bedienen, finden Sie unter Servers/tile.In den bereitgestellten URLs $ und $ müssen durch die x- und y-Kachelnummern und $ . ersetzt werden durch die Zoomstufe. Manchmal fehlt das $. In den URLs zu Carto.com und einigen anderen gibt es auch ein die durch die Subdomäne ersetzt werden sollte
  • Kacheln verwenden Erste Schritte mit Leaflet Erste Schritte mit OpenLayers Bereitstellen von Kacheln Manuelles Erstellen eines Kachelservers (Debian 11) Manuelles Erstellen eines Kachelservers (20.04 LTS) Verwenden eines Docker-Containers Manuelles Erstellen eines Kachelservers (18.04 LTS) Manuelles Erstellen eines Kachelservers (16.04 .) .2 LTS) Aktualisieren Ihrer Datenbank, während Personen OpenStreetMa . bearbeiten
  • docker openstreetmap-tile-server Probleme Es sind keine Probleme vorhanden. Der Issue Tracker ist der Ort, um Dinge hinzuzufügen, die in einem Projekt verbessert oder gelöst werden müssen. Sie können sich registrieren oder anmelden, um Probleme für dieses Projekt zu erstellen. Registrieren / Anmelden.

Ich verwende Docker, um den Befehl "openmaptiles-server" zu installieren. docker pull klokantech/openmaptiles-server.It beginnt mit dem Herunterladen und Extrahieren. Alles sieht gut aus. Ich benutze den Befehl docker run --rm -it -v $(pwd):/data -p 8088:80 klokantech/openmaptiles-server, um OSM zu starten und meinen Browser zu öffnen ip:8088.. Es zeigt mir, dass vorhandene MBTiles gefunden wurden in das /data volume Tile Serving ist ein Handwerk und eine Kunstform. Dieses Skript ist nur dazu gedacht, mit minimalem Aufwand einen funktionierenden Kachelserver mit OSM-Daten aufzubauen. Dieses Skript wird ohne Gewähr bereitgestellt und die Verwendung des Skripts erfolgt auf eigene Gefahr. Für das Hosten von Produktionskartenkacheln werfen Sie einen Blick auf Thunderforest oder GeoFabrik Nun wird die Datei /var/www/osm/slippymap.html mit einem Texteditor geöffnet und die Zeile. numZoomLevels: 19, <code> auf <code> numZoomLevels: 21, <code> und die Zeile <code> var localLayer = new OpenLayers.Layer.OSM (Meine Karte, http://localhost/osm/$ /$ /$ .png, ) auf Das OpenStreetMap-Projekt stellt zwar Eigenen Tile-Server zur freien Benutzung zur Verfügung. Das Angebot richtet sich jedoch hauptsächlich an jenen, sterben zu OSM ähneln und Eine Erfolgskontrolle Haben möchten und an die breite Öffentlichkeit, der OSM demonstrieren will, was with den gesammelten Daten alles möglich ist. Da sterben Server aus Spenden Einnahmen und von Freiwilligen betrieben Werden IST sterben Nutzung durch Dritte Nur in geringfügigem Umfang gestattet. Außerdem sind.

Rendern von OSM-Kacheln mit Docker - OSM Hel

  • Ich habe die Online-Version von Maputnik verwendet, um die Karte im OSM-Bright-Stil zu bearbeiten. Dann habe ich die modifizierte JSON heruntergeladen, bin mir aber nicht sicher, wie ich diesen benutzerdefinierten Stil auf meinen OpenMapTile-Server anwenden soll. Ich habe mich im Docker-Container bei Linux angemeldet und die entsprechende Datei style.json gefunden, aber meine vorgenommenen Änderungen gehen verloren, wenn der Container neu gestartet wird
  • generiere_xml.py -h. Jetzt müssen Sie die Datei osm.xml generieren, die die Kachelgenerierung steuert: Geben Sie Folgendes ein: generate_xml.py -host localhost -user postgres -dbname osm -symbols icons/ -world_boundaries world_boundaries/ -port 5432 -password postgres. Sie sind jetzt in der Lage, Kacheln zu generieren
  • 27. Januar 2021 docker, mapbox, openstreetmap, vector-tiles ist es möglich, über ein Docker-Image von openstreetmap-tile-server Tiles an eine Mapbox-Instanz zu liefern. Dieser Link ist ein Link zum Einrichten des Servers (https://switch2osm.org/serving-tiles/using-a-docker-container/)
  • Wir verwenden hier ein Docker-Image eines Drittanbieters überv/openstreetmap-tile-server, um es zu ändern. Der Docker-Container verwendet PostgreSQL und PostGIS, um geografische Daten zu speichern

Man kann es aber auch entpacken und hat dann alle Tiles welche man lokal oder auf seinem eigenen Server/Webspace hochladen kann. 2.1 Entpacken des mbtiles. Um die Karte im mbtiles Format zu entpacken benötigen wir das Tool mbutil. mbutil läuft nur unter Python. If ihr Python noch nicht installiert habt ladet es euch von hier herunter. Ich. OpenMapTiles Map Server ist ein produktionsreifes Softwarepaket mit integrierten Open-Source-Komponenten (wie Memcache oder TileServer GL) und speziell auf OpenMapTiles-Daten und eine einfache Schritt-für-Schritt-Konfiguration zugeschnitten. Docker ist eine kostenlose Open-Source-Software zur Virtualisierung auf Betriebssystemebene

Kachelschema öffnen. Unser neues Vektorkachelschema kodiert die kartografischen Entscheidungen, die auf OpenStreetMap, Natural Earth und anderen OpenData-Quellen getroffen wurden, und ist 100% offen und kann kostenlos verwendet, erweitert oder darauf aufgebaut werden. Wir hoffen, dass die Leute unser Schema und unser Datenmodell in ihren Projekten anpassen, kopieren und neu implementieren und gleichzeitig die Attribution bereitstellen. Siehe das Schema Das Setup ist nicht sehr aufwändig - bevor jemand was sagt: ich weiß, dass es Docker gibt - es gibt auch schon unzählige Docker-Container, die OpenStreetMap-Karten als Tile-Server bereitstellen. Es ging mir darum, MEIN System zu erneuern und MEIN Wissen zu vertiefen

Ich hoste meinen eigenen Tile-Server mit dem Docker-Prozess für overv/openstreetmap-tile-server. Ich habe erfolgreich Kartenkacheln von OpenStreetMap hinzugefügt und versuche jetzt, Höhendaten hinzuzufügen, indem ich den hier beschriebenen Vorgang befolge. Ich habe jetzt die Karten- und Höhendaten in einer Postgres-Datenbank auf einem Docker-Volume gespeichert und möchte verschiedene Stile mit Kosmtik testen, wie im Wiki definiert , und Bereich Ihrer Karte! So installieren Sie eine lokale OpenStreetMap-Karte auf einem Windows-Computer So installieren Sie. TileServer GL unterstützt sowohl die Bereitstellung von Vektor- als auch Rasterkacheln (über Mapbox GL Native). Es stellt auch einen WMTS-Endpunkt bereit. Weitere Informationen finden Sie in der Hauptdokumentation für TileServer GL. Dieses Tutorial zeigt, wie die von OpenMapTiles heruntergeladenen Vektorkacheln bereitgestellt werden. Installieren. Wir empfehlen, TileServer GL mit Docker zu installieren. Das Hosting wird von UCL, Bytemark Hosting und anderen Partnern unterstützt. Mehr erfahren

Antworten zu: Verwenden Sie > 5

Dies ist mit overv/openstreetmap-tile-server:1.4 möglich. um Kartendateien automatisch herunterzuladen und zu importieren, aber wir fügen die Kartendateien direkt zu unserem benutzerdefinierten Docker-Container hinzu, damit wir überspringen können. QGIS Server und Martin Vector Kacheln. Sie können ein QGIS Server-Frontend oder Martin-Vektorkacheln auf dem OSM-Spiegel ausführen, indem Sie die mitgelieferte docker-compose-web.yml-Datei verwenden. Zum Beispiel: docker-compose -f docker-compose.yml -f docker-compose-web.yml qgisserver up or. docker-compose -f docker-compose.yml -f docker-compose-web.yml martin u Wenn Sie die Standard-Kacheln von openstreetmap.org-Kachelservern in anderen Anwendungen verwenden, müssen Sie die Tile-Verwendungsrichtlinie befolgen. Karten Schlüssel . Da dieser Stil funktionsreich ist, ist der auf der OSM.org-Homepage enthaltene kurze Kartenschlüssel sehr begrenzt. Die vollständigste und aktuellste Legendenversion finden Sie unter Standardkachelebene/Schlüssel und deren Unterseiten: Hauptartikel: SymbolsTab Hauptartikel: LinesTab Hauptartikel.

Die in openstreetmap-carto enthaltene Docker-Konfiguration automatisiert die Einrichtung der Kosmtik-Entwicklungsumgebung und vereinfacht den OSM-Datenimportprozess. Das openstreetmap-carto-Repository muss ein Verzeichnis sein, das von Ihrem Hostsystem und der virtuellen Docker-Maschine gemeinsam genutzt wird. Home-Verzeichnisse werden standardmäßig freigegeben, wenn sich Ihr Repository an einem anderen Ort befindet, müssen Sie dies zur Docker-Freigabeliste hinzufügen. Die OpenStreetMap-Vektorkacheln werden mit unserer Open-Source-Software erstellt, die auf OpenMapTiles.org veröffentlicht wurde. Die Rasterkacheln werden mit MapTiler Desktop gerendert. Überprüfen Sie die News und das Changelog Die Tile-Server basieren auf der gleichen Technologie wie die Server von OpenStreetMap. Der Wechsel von OSMs zu den Kachelservern von Geofabrik erfordert keine Änderung Ihrer Anwendung, abgesehen von der Änderung der Kachelquell-URL. Unsere Kunden erhalten einen individuellen API-Schlüssel (32 langer alphanumerischer String), der in der URL bereitgestellt wird. Zusätzliche API-Schlüssel können auf Anfrage bereitgestellt werden, wenn ein Kunde dies wünscht. Importieren Sie SQL-Dateien in einem Verzeichnis in PostgreSQL und richten Sie Hilfsfunktionen für Vektorkacheln ein. Container. 50K+ Downloads. 1 Stern. openmaptiles/postserv

Dokumentation - OpenMapTile

Vielen Dank, dass Sie eine Antwort auf Stack Overflow beigetragen haben! Bitte stellen Sie sicher, dass Sie die Frage beantworten. Geben Sie Details an und teilen Sie Ihre Forschung! Aber vermeiden. Bitten um Hilfe, Erläuterungen oder Antworten auf andere Antworten Eine Demonstration, wie Sie Ihre eigene Instanz von OpenStreetMap in eineinhalb Minuten einrichten:Schritte:1) Laden Sie Vektorkacheln der Region herunter, die Sie auf der Ma.. Schreiben einer benutzerdefinierten OpenStreetMaps Service mit Docker. Pepijn Schön. 30.07.2016 · 3 Min. Lesezeit. Als Teenager liebte ich Karten und war lange Zeit davon überzeugt, Kartograph werden zu wollen. Mit Osm-Seed können Sie ganz einfach Ihr eigenes OSM-Ökosystem einrichten. Es bietet Ihnen die Leistungsfähigkeit der OSM-Software, die im Maßstab getestet wurde. Das Beste daran ist, dass es einfach zu starten ist und Sie nicht verschiedene Komponenten aneinanderreihen müssen. Osm-Seed umfasst derzeit die Rails-Port-API, den iD-Editor, einen Tile-Server und die Replikation

Entwickelt für Ihre Docker Hub-Notizen, um den Code anzuzeigen, aus dem das Image erstellt wurde. Sie können ein Commit-Badge erhalten, indem Sie Ihrem Dockerfile die Labels vcs-url und vcs-ref hinzufügen. Dadurch wird Ihr Bild mit dem Quellcode verknüpft, mit dem es erstellt wurde Joe Burkinshaw konnte einige OSM-Daten abrufen und in PosgreSQL laden. Mit der PostGIS-Erweiterung und der relativ neuen ST_AsMVT-Funktion richtete er eine Abfrage ein, die eine mvt-Kachel zurückgibt, wenn ein URL-Parameter. Zunächst richten wir eine PostGIS-Instanz auf AWS RDS ein. Es war super einfach, es einzurichten und zu starten, aber wir hatten ein Problem, weil eine Protobuf-C-Bibliothek nicht im Lieferumfang enthalten war.

Verwenden Sie > 5.2.0 openstreetmap-carto mit dockered ..

Kachel-Server. Das Einrichten von Tile-Servern aller Art gehört zu den Hauptgeschäftsfeldern der Geofabrik. Unsere besondere Stärke liegt darin, das Server-Setup individuell auf die Anforderungen des Kunden zuzuschneiden. Keine zwei Tile-Server Sind gleich, denn unsere Kunden haben die unterschiedlichsten Anwendungszwecke. Stellvertretend this stellen wir ein besonderes Projekt vor. Der. Einrichtung eines hauseigenen OpenStreetMap-Servers. Wenn keine der kostenlosen Alternativen für Sie funktioniert, können Sie trotzdem Ihren eigenen Kartenkachelserver betreiben. Aufgrund der Tatsache, dass einer der Tile-Server als Docker-Image verfügbar ist, ist der ganze Prozess dank eines Mannes namens Alexander Overvoorde ziemlich einfach Home Beschreibung des OSM-Rendering-Prozesses Installieren eines Docker-Images von Kosmtik mit Ubuntu, Windows oder Mac Installation von Kosmtik und OpenStreetMap-Carto auf Ubuntu Installation von TileMill und OpenStreetMap-Carto auf Ubuntu Installation eines OpenStreetMap Tile Servers auf Ubuntu JavaScript-Bibliotheken zur Implementierung interaktiver OSM-Karten Das Lokale beibehalten. Europa [eine Ebene höher] Die auf diesem Server bereitgestellten OpenStreetMap-Datendateien enthalten nicht die Benutzernamen, Benutzer-IDs und Changeset-IDs der OSM-Objekte, da davon ausgegangen wird, dass diese Felder personenbezogene Informationen über die OpenStreetMap-Mitwirkenden enthalten und daher dem Datenschutz unterliegen Vorschriften in der Europäischen Union

docker build -t osm-server . # 最后有一个点别漏了 .构建docker容器,构建成功后,你应该看到Erfolgreich erstellt字样。 : docker run -d -p 80: 80 osm-server. HTML文件(如果你跳过了上一部分,可以点击此处下载),应该看到地图显示结果(如果是服务器上搭建. CentOS 7 Open Street Map Fliese Server. GitHub Gist: Code, Notizen und Snippets sofort teilen


Wie kann man vorgerenderte Vektorkacheln im pbf-Format zwischenspeichern und serveren? - Geografisches Informationssystem

⚠️ Tilelive und zugehörige mapbox-eigene Tilelive-Plugins werden nicht aktiv gepflegt. Bitte öffnen Sie eine neue Ausgabe, um sich an die Projektbetreuer zu wenden, bevor Sie mit der Arbeit an neuen Funktionen beginnen.

Tilelive ist für das Streamen von Kartenkacheln von Quellen (wie benutzerdefinierte geografische Datenformate) an sinkt (Ziele, wie Dateisysteme) durch Bereitstellung einer konsistenten API. Dieses Repository ermöglicht die Interaktion zwischen Quellen und Senken und soll zusammen mit mindestens einem Tilelive-Plugin verwendet werden. Tilelive-Plugins (Module) folgen einer konsistenten Architektur (definiert in API.md) und implementieren die Logik zum Generieren und Lesen von Kartenkacheln aus einer Quelle oder zum Ablegen von Kartenkacheln an ein Ziel oder beides.

Ein Beispiel für ein Plugin, das sowohl Lesen (kann eine Quelle sein) als auch Schreiben (kann eine Senke sein) implementiert, ist tilelive-s3.

Ein Beispiel für einen Anwendungsfall für Tilelive ist das Erstellen von Vektorkacheln aus einer Geojson-Datei und deren Übertragung in Amazon S3. Dies kann erreicht werden, indem tilelive-omnivore als Quelle und Tilelive-s3 als Senke verwendet wird. Tilelive omnivore führt spezielle Operationen zum Generieren von Kartenkacheln (mit Mapnik) durch, während tilelive-s3 in der Lage ist, sich ordnungsgemäß mit Amazon S3 zu verbinden, um Kacheln an ihrem richtigen Ort zu platzieren. Das Tilelive-Modul führt das gesamte Abrufen und Einfügen innerhalb von tilelive.copy durch.

  1. Erfordere tilelive in deinem Skript, var tilelive = require('@mapbox/tilelive')
  2. Registrieren Sie benutzerdefinierte Protokolle über Plugins, CustomTileSourcePlugin.registerProtocols(tilelive) oder CustomTileSinkPlugin.registerProtocols(tilelive)
  3. Laden Sie Protokolle mit tilelive.load , dies erstellt Lese- und Schreibstreams
  4. Kopieren von der Quelle zum Ziel (das Erstellen von Kacheln bleibt dem Plugin überlassen) mit tilelive.copy (Quelle, Senke, Rückruf)
  5. Sobald die Kacheln kopiert wurden, werden die Streams geschlossen

Weitere Informationen zur Tilelive-Modul-API finden Sie unter Verwendung.

    - Implementiert die Tilelive-API zum Rendern von Mapnik-Vektorkacheln in Rasterbilder. - Implementiert die Tilelive-API zum Generieren von Mapnik-Vektorkacheln aus traditionellen Mapnik-Datenquellen. - Mapnik-Renderer-Backend für Tilelive. - Erweitert TileJSON für S3-spezifische Aufgaben. - tilelive.js-Adapter zum Lesen aus dem Dateisystem. - Eine Tilelive-Quelle für die Ausgabe von PBF-kodierten Kacheln aus PostGIS. - Ein Tilelive-Anbieter für TM2-Quellen. - Ein Caching-Wrapper für tilelive.js - Rendern Sie GeoJSON-Funktionen mit einfachen Stilen in einer Tilelive-Pipeline. - Ein Tilelive-Anbieter für tmstyle-Quellen. - Eine HTTP-Quelle für Tilelive. - Ein mbtiles-Renderer und Speicher-Backend für Tilelive. - Eine alternative Befehlszeilenschnittstelle für Tilelive. - Implementiert die Tilelive-API für eine Vielzahl von Datenquellen. - Tilelive-Vektorkachel-Visualisierung. - Eine Tilelive-Quelle, die Quellen zusammenführt. - Streaming-Funktionalität für Tilelive-Module. - Redis Wrapping-Quelle für Tilelive. - Eine Auflistung bekannter Tilelive-Module. - Laden Sie Vektorkacheln aus einer Tilelive-Quelle und dekorieren Sie sie mit Eigenschaften von redis. - Ein Tilelive-Anbieter, der sich vermischt. - Eine Quelle im Carto-Stil für Tilelive - mongotiles ist ein Tilelive-Backend-Plug-in für MongoDB GridFS. - Eine Tilelive-Quelle für die Ausgabe von PBF-kodierten Rastern aus PostGIS. - Eine Memcached-Verpackungsquelle für Tilelive. - Eine Streaming-Tilelive-Quelle für CSV-Eingaben. - Ein tilelive.js-Adapter zum Lesen von einem TMS-Dienst. - Modul zum Hinzufügen einer Caching-Schicht vor einer Tilelive-Quelle. - Rendert Vektorkacheln aus einem Kartondatensatz. - Ein Tilelive-Anbieter, der Raster als Kacheln behandelt - Ein Tilelive.js-Adapter für ArcGIS-Kachel-Caches. - Eine tilelive.js-Quelle für mapbox://-URIs. - Ein Tilelive-Anbieter, der einfarbige Kacheln generiert. - Eine Tilelive-Quelle für einfache Raster, sowohl lokal als auch entfernt. - Eine Noop-Spüle für Tilelive. - Eine No-Op-Tilelive-Quelle. - PBF → CSV mit Tilelive. - Vermeiden Sie wiederholte fehleranfällige Initialisierungen. - AWS Lambda-Quelle für Tilelive. - Eine Tilelive-Quelle für CartoDB. - Eine Tilelive-Quelle zum Speichern von Kacheln in einer Cassandra-DB - Eine Tilelive-Quelle zum Speichern von Kacheln in einer Postgres-DB - Ein Tilelive-Backend-Plug-in für CouchDB. - Kachelquellen-Backend für Online-Kachelquellen. - Ein Tilelive-Plugin zum Bereitstellen von Kacheln mit mongodb - Ein Tilelive-basierter Kachelserver. - Ein Tilelive-Plugin, das PostgreSQL-Abfragen ausführt, deren Ergebnis ein binäres MVT ist, z. mit ST_AsMVT(). Unterstützt Verbindungspooling. Entwickelt für die großflächige Kachelerzeugung.

Tilelive wird standardmäßig nicht mit Implementierungsmodulen geliefert. So registrieren Sie ein Modul, das von tilelive erkannt wird:

tilelive.list(source, callback) : Listet alle Tilesets in einem Verzeichnis auf. source ist ein Ordner, der von registrierten Implementierungen verwendet wird, um nach einzelnen Tilesets zu suchen. callback empfängt ein Fehlerobjekt (oder null ) und einen Hash, wobei Schlüssel Tilestore-IDs und Werte Tilestore-URIs sind. Beispiel:

tilelive.findID(source, id, callback) : Sucht nach einer bestimmten Tileset-ID in einem Verzeichnis. callback empfängt ein Fehlerobjekt (oder null ) und den URI des Tileset.

tilelive.load(uri, callback) : Lädt das Tilestore-Objekt, das dem angegebenen uri zugeordnet ist. callback empfängt ein Fehlerobjekt (oder null ) und das Tilestore-Objekt.

tilelive.info(uri, callback) : Lädt das Tilestore-Objekt, das dem angegebenen uri zugeordnet ist, und ruft seine Metadaten in einem TileJSON-kompatiblen Format ab. callback erhält ein error-Objekt (oder null ), den Metadaten-Hash und das Tilestore-Objekt.

tilelive.all(source, callback) : Lädt Metadaten in einem TileJSON-kompatiblen Format für alle Tilesets im Quellverzeichnis. callback empfängt ein Fehlerobjekt (oder null ) und ein Array mit TileJSON-Metadaten zu jedem Tileset in diesem Verzeichnis.

tilelive.verify(tilejson) : Validiert ein TileJSON-Objekt und gibt Fehlerobjekte für ungültige Einträge zurück.

Tilelive bietet eine Implementierung von Knotenobjektströmen zum Kopieren von Kacheln von einer Quelle in eine andere.

Sehen Sie sich die Tilelive-Copy-CLI und die Streams-Tests an, um beispielsweise die Verwendung von Copy-Streams zu sehen.

Tilelive kann einen Lesevorgang in eine beliebige Anzahl von Jobs aufteilen. Pass a job parameter to options when using tilelive.createReadStream or tilelive.deserialize :

This instructs tilelive to only read tiles that would fall into job 1 of 4 . A complete read would mean four calls each with a different num .


How to cache and server pre-rendered vector tiles in pbf format? - Geografisches Informationssystem

The Vector Tiles specification was designed for map visualization but has expanded into other uses as well, but in general the purpose is to be able to quickly provide a complete subset of data for a specific area that is highly cacheable. Most of this provided speed and cache-ability is specifically gained by preprocessing all the data you will use in your map into tiles.

The general steps for turning raw data into Vector Tiles are:

1. Determine a hierarchy of your data. For example if you are talking about roads at some zoom levels you will want to see only highways or major roads while at other zoom levels you will want all your data.

2. For each tile at each zoom level Select your data following your hierarchy rules, simplify your data based on your zoom level (for example you might need less points to display your road) and then clip your data to your tile and encode it to your Vector Tile.

The problem is that doing these steps is often very complex and requires thought about the cartography of your final resulting map, but it can also drastically effect performance. If you are dynamically serving tiles from PostGIS it is very hard to reduce large quantities of data quickly in some cases. For example take a very detailed coastline of a large lake that is very precise and you are wanting to serve this dynamically. If you are attempting to serve this data on demand each time you need a tile you have to simplify and clip a potentially massive polygon. While this might work for single requests, if you increase in scale this quickly adds lots of load to a PostGIS server. The only solution is to cache the resulting tiles for a longer period to limit load on your database or to preprocess all your data before serving.

Preprocessing of all the tiles is already something other tiling tools such as tippecanoe are really good at doing and comes with the benefit of helping you determine a hierarchy for your data. Preprocessing might seem excessive when it comes to making potentially millions of tiles, but in general it makes your application faster because it is simply serving an already created tile.

Therefore, if your data does not very change quickly I would almost always suggest using preprocessing over dynamic rendering of tiles. You might spend more effort maintaining something than you expect if you start using PostGIS to create tiles on demand over existing tiling tools.

I do an intermediate approach: my queries are sometimes too expensive to run dynamically, and my data change semi-frequently (daily/weekly basis), but when they do change I have a clear idea of what tiles are affected. So any time my data needs updating I can mark tiles as stale and then I have a sidekiq job that processes them and uploads them to S3. The tile server itself pulls from S3.

This is probably not quite as fast as a dedicated tile server, but it's far more reliable/responsive than dynamic rendering and reduces load spikes on the database.

From their you can serialize⿞serialize the whole tile and map a new field (annoying), or if your clever. map your variable value fields lower in the values index array of the vt pbf. That way assuming you have a small number of unique style by values, you could get away with simply replacing a single byte representing that style value field with another value dictating a different style, for each feature in the vector tile.

That might be a little to abstract so tl:dr version put a listener in front of fetch. One byte represents the target dynamic field in each feature in the tile (if you have a small number of unique values). Replace that single byte with your desired target byte.

I'm also really curious about the choices involving the zoom level, how do you decide to render things depending on the zoom level, when is data discarded, to have good detail or better performance and lighter tiles. I would really be willing to try build lighter maps so I can have my own mapping software on a desktop machine.

The data sizes and hardware requirements involved are generally pretty big. It could be interesting to see how much details one could achieve to make a "portable" map browser when limiting the data size to 2GB, 5GB or 10GB.

I would really like to ask why, on some mapping software, you can't see names of large enough cities/places/regions that are obviously there. It often makes it difficult to browse maps properly.

The data comes from places like the Census Bureau (roads, place names) and then a lot of it has to be collected by the like of OpenStreetMap/Google/Other Providers. (GIS Data is big business)

For Vector based approaches (See mapbox) these data are stored in special built databases and usually simplified geometries are served to the browser. The benefit is continuous zoom, but the pitfall is more server side computation and hence cost.

Because of the cost˼ompute, raster tiles (PNG, jpg, any pixel format) have been much more popular. These start the same, you collect all these data and put them in a database. The difference is the added step of rendering tiles. This one-off computation saves you work from then on. See maps.stamen.com for an example of tiles made from OSM data.

And you’re right about place names sometimes not being apparent. This is a trade off when using open data and auto generated tiles. With something like MapBox’s vector tiles, you have individual decimal level control of things like labels. And zoom level is another computational trade off. You start at 0 and define an arbitrary end. The higher the number, the computation⿚ta increases four fold each n. O(4^n)

And as far as why the size requirements are so big, geospatial data is big. You have to record information on every point for vectors which depending on quality can be a ton. And for rasters, we’re talking trillions of pixels really. That’s why all of this is server side.

And lastly to your point about lightweight desktop software, tiles don’t really have a place in the data process. They’re only really useful for the visualization aspect. And frankly, I think we’re reaching the capacity of the technique, we just might have some headroom in server efficiency.

> And lastly to your point about lightweight desktop software, tiles don’t really have a place in the data process. They’re only really useful for the visualization aspect. And frankly, I think we’re reaching the capacity of the technique, we just might have some headroom in server efficiency.

Not totally sure what you mean on your last point. data can be feature centric (e.g. stored by feature id) or area centric (stored by area location) etc. Storing data by location is important far beyond visualisation and is abstracted in databases such as PostGIS/Postgres (a branded data structure). That said, I acknowledge that ArcGIS Pro, QGIS etc. have limited support for tiled data but of course that is changing. Safe funded much (all?) of the OGR MVT development afaik.

But as far as like roads and boundaries, you should always work with the raw vectors.

I haven't tested this with dynamic tiles served from PostGIS, but with static tiles served from S3 it's quite the opposite! There's an initial cost to generating tiles, but once they're generated, you can host them on S3 with zero server cost.

The tools are rapidly evolving. There's no great single entry point and the best advice I can give is pretty generic: find a small-scale thing you want to do and do research toward accomplishing it.

The post you're commenting on is about how PostGIS databases mostly do this work for vector tiles on its own now, so "to build your own tiles", youɽ set up a PostGIS database and re-read this post. A year or two ago the advice would be pretty different. A year or two from now and the advice will be _completely_ different.

That said, from zero http://geojson.io is a dead straightforward way to do basic operations with GeoJSON data. You can paste in JSON and it renders on the map you can draw on the map and it generates GeoJSON. (https://tilejson.io does the same for raster tile sets.)

Real-world data is massive and overwhelming to work with — just drawing your own fake maps in geojson.io and working with that might make some of its concepts easier to digest.

Maperitve[1] is a free and relatively straightforward app focused on taking geo data as input and outputting maps. Work with its rendering rules and you'll understand some of the challenges with rendering at different zoom levels or in different contexts.

Then this post from 2018[2] on Tippecanoe (tile and data converter), TileServer GL (tile server), and Leaflet (Javascript front end to view served tiles) covers how to round-trip a package of vector tiles to GeoJSON data and back. It's straightforward, works with a relatively small area of data, doesn't require GIS experience, and though outdated it's still relevant for understanding by practice how a data-to-tiles pipeline can work.

Raster tiles are a little difficult to recommend learning as tooling has mostly moved on from it in favor of vector tiles, which pack more information and flexibility into less data, and I honestly don't know what tools still reliably do that work — once upon a time I used TileMill but it was already abandoned by then and has been very lightly maintained since.

Re: optimization, here's another more advanced post[3] using real-world data that illustrates some of the challenges.

The end-game is to get to a point where you can open something like QGIS[4], a heavyweight tool that can do all of the above and way too much more, or Maputnik[5], a vector tile styling tool using a CSS-ish language, and not get immediately lost.

> I would really like to ask why, on some mapping software, you can't see names of large enough cities/places/regions that are obviously there.

You won't get a great answer why to that question, I'm afraid. It's dependent on and configured in whatever the front end is, generally done algorithmically, and in some cases manually edited. An art as much as a science, and as fallible as both combined. (See Justin O➾irne's incredible reviews of Apple Map updates[6] for an example.)

No single labeling strategy will make anyone (much less everyone) happy and most end-user tools don't expose customizability.


2 Answers 2

In a WMS the tiles are more or less pre saved on the server. You can of course calculate the tile-pyramid from one high resolution image, but these tiles are then saved to the server (as in a cached map service). I think for performance reasons the tiles are pre-rendered on the server, see example Bing Maps.

It would take way too much time to generate the tiles every request. If you have a high resolution raster image try using gdal2tiles to create your own tile pyramid for a TMS (Tile Map Service) and see how long this takes.

An OGC WMS (Web Map Service) is a service that provides maps on request from a client such as one built using OpenLayers. The data used as the source may be raster or vector or some combination. Whilst some WMS also provide caching, it is important to note that in a standard configuration a WMS generates the map sent on request. This is different from an OGC WMTS (Web Map Tile Service) or TMS.

The dynamic nature of a WMS can be seen in the response to a GetCapabilities request, like:

Looking at sections of this we can see that:

You can request a number of map image formats

You can request layers in a number of different projections:

and also that you can change the default symbolization by supplying your own style through SLD:

Through some client you request a map, the client generates a GetMap request like:

In the client you click on some point location to get information on the data that created the map like:

From this you see that the underlying data (in this a case vector dataset, held in a database) has attribution that includes geological history values.

We want to know what other areas in the map are from the Triassic, so we create an SLD that colours the map according to a query, and send that SLD back to the server as part of a GetMap request like:


Debian packages in contrib or non-free

pycsw is an OGC CSW server implementation written in Python. pycsw fully implements the OpenGIS Catalogue Service Implementation Specification (Catalogue Service for the Web). Initial development started in 2010 (more formally announced in 2011). The project is certified OGC Compliant, and is an OGC Reference Implementation. Since 2015, pycsw is an official OSGeo Project. pycsw allows for the publishing and discovery of geospatial metadata via numerous APIs (CSW 2/CSW 3, OpenSearch, OAI-PMH, SRU). Existing repositories of geospatial metadata can also be exposed, providing a standards-based metadata and catalogue component of spatial data infrastructures. pycsw is Open Source, released under an MIT license, and runs on all major platforms (Windows, Linux, Mac OS X).

This package contains the pycsw-admin utility and configuration files.

TinyOWS is a lightweight and fast implementation of the OGC WFS-T specification. Web Feature Service (WFS) allows querying and retrieval of features. The transactional profile (WFS-T) allows inserting, updating or deleting such features.

From a technical point of view WFS-T is a Web Service API in front of a spatial database. TinyOWS is deeply tied to PostgreSQL/PostGIS because of this.

TinyOWS implements strictly OGC standards and pass successfully all WFS OGC CITE tests (and even beta ones).

TinyOWS is part of MapServer Suite, but provided as a distinct module (i.e you could use it in conjunction with MapServer and MapCache, or as a standalone app). But both MapServer and TinyOWS could use the same configuration file, if you want to (or native TinyOWS XML config file).


Generating the map cache

ArcGIS Server creates cache tiles using a geoprocessing service named CachingTools. This service is configured for you in the System folder when you create the ArcGIS Server site. The number of instances you allow for the CachingTools service determines how much power your machine can dedicate toward caching jobs.

Estimated map cache generation time

Client access to the cached data would deliver tiles that correspond to the requested map scale. Tiles would be blended together as a single reference layer by the client application. Total pre-processing time would depend on the total number of tiles in the map cache and the average map service time for rendering each map tile image. Figure 4.13 can be used to get a rough estimate of the expected map cache generate time.

Map cache generation time is a function of the number of tiles and average tile generation time.

  • Chart shows one tile at the top layer (multiply result by number of tiles in top layer)
  • The number of tiles increases by a factor of four with each additional layer.
  • Tile render time can vary from less than one second to several seconds, depending on the average tile map complexity.
  • Processing hours based on single CachingTools service instance (divide result by total concurrent service instances used when generating the cache).

Rendering time increases exponentially with each tile layer.

  • Generation time: Nine (9) hours for seven layers
  • Generation time: 40 hours for eight layers

Estimating map cache generation time.

  • Build a small area to test the output symbology, labeling, and performance criteria for your primary map client.
  • Execute cache jobs in sections to manage production time.

Cache processing profile

Figure 4.14 provides an example of taking advantage of the hardware, as described above. ArcGIS for Server will use the CachingTools maximum available service instances to process the map cache as quickly as possible with the available hardware.

Cache processing timelines can be improved by increasing the number of concurrent processor cores utilized in the caching process. Recommended CachingTools service instance configuration is N+1, where N=number of physical server core processors. If you want to view caching status and manage cache jobs while executing the cache, maximum number of instances = physical server process core leaves some processing resources for managing caching services.

Testing was performed on identical 4-core server platforms.

  • Single service instance (thread) on a single 4-core server took 500 hours.
  • Five (5) service instances (threads) on a 4-core server took 125 hours (four times faster).
  • 10 service instances on two 4-core servers took 65 hours (eight times faster).

This video on [ArcGIS 10.1 Map Caching in ArcGIS for Server] provides a demo showing the new workflows and features of map caching in ArcGIS 10.1 for Server.

Manage Services caching tools

Manage services caching instances are configured during site installation to enable background caching services.

  • CachingControllers: Establish number of concurrent caching jobs per server machine supported by the CachingTools instances.
  • CachingTools: Establish number of caching service instances per server machine available for caching job processing.
  • You should always run the CachingTools service and the CachingControllers service in the same cluster.

Service Editor service configurations apply to every GIS Server machine within the assigned cluster.

Production servers within the GIS Server Site can be reassigned to the Map Caching cluster to expand caching capacity during off-peak hours.

System Caching Processes configurations

Figure 4.17 shows the CachingController processes configuration. An identical tab will be configured for the CachingTools processes configuration.

Map cache generation is an intense batch process which can often run for hours and days at a time often generating hundreds of thousands of cached map tiles. It is important to support this type of service with the most stable process configuration. For this reason, both the CachingController and CachingTools SOC processes should be configured in high isolation mode.

Recycling the processes can ensure stable instances during the map cache build, promoting optimum performance during cache generation. Caching jobs are processed in bundles of 16,384 tiles. CachingTools instances can be recycled between processing bundles once during each recycle process. CachingControllers and CachingTools processes configurations should be scheduled for a recycle every 24 hours to promote optimum site stability and performance. CachingController instances will recycle between caching jobs. CachingTools instances can recycle during job processing between bundle caching assignments.

System Caching Pooling configurations

A dedicated CachingControllers instance is required for each caching job. Pooling and Processes settings must be configured for the CachingControllers service. CachingTools will be configured to optimize utilization of available platform hardware resources during peak cache processing loads.

Figure 4.18 shows the CachingTools processes configuration. An identical tab will be configured for the CachingControllers processes configuration.

CachingControllers Pooling settings
  • Min service instances = 0. There is no need to have instances running if there are no assigned caching jobs. CachingController instance will be running to manage each active caching job.
  • Max service instance setting identifies the max number of concurrent caching jobs. If all available instances are busy, the job will be held in the process queue until a CachingControllers instance is available.
  • Timeouts should match the CachingTools settings below.
CachingTools Pooling settings

Figure 4.18 shows the Pooling settings for the CachingTools service. The recommended service instance setting for caching services is N+1 (number of available core on the server machine plus one). Maximum setting of 3 service instances would be appropriate for 2-core GIS Server machines.

The CachingControllers manage caching jobs to take advantage of all available CachingTool service instances. For a single caching job, the CachingController will assign multiple caching processes to leverage all available CachingTool service instances (up to the total number of bundles in the caching configuration). Multiple concurrent jobs will share available CachingTool service instances. Assignment of multiple concurrent caching jobs (multiple CachingControllers) will optimize utilization of available server processing resources.

Timeout settings should be appropriate to the caching service.

  • Maximum time a client can use a service = 360000 seconds (provide sufficient time to complete the caching job). CachingController process will be dedicated for the complete caching job. CachingTools instances will be reassigned after completing each bundled cache assignment.
  • Maximum time a client can wait to use a service = The caching service is the client within this configuration, and the caching service wait time is hard coded to around 30 days (use default setting).
  • Maximum time an idle instance can be kept running = 180 seconds (this can be set for a short time, allowing instances to be shut down if not in use).

Debian GIS Openstreetmap packages

„libosmgpsmap“ — бібліотека для вбудовування мап у застосунки, яка, після введення GPS-координат, виводить маршрут та точки з корисними об’єктами інфраструктури на дисплеї, що показує переміщення по мапв. Дозволяє звантажувати картографічні дані з різних веб-сайтів, включаючи openstreetmap.org, openaerialmap.org та деякі інші.

Пакунок додає до бібліотеки підтримку Python.

GpsPrune is an application for viewing, editing and converting coordinate data from GPS systems. It's a tool for preparing GPS data before you go on a trip, and for playing with your collected GPS data after you get home again.

It can load data from arbitrary text-based formats (for example, any tab-separated or comma-separated file) or XML, or directly from a GPS receiver. It can display the data (as map view using OpenStreetMap images and as altitude profile), edit this data (for example delete points and ranges, sort waypoints, compress tracks), and save the data (in various text-based formats). It can also export data as a GPX file, or as KML/KMZ for import into Google Earth, or send it to a GPS receiver.

Some example uses of GpsPrune include cleaning up tracks by deleting wayward points - either recorded by error or by unintended detours. It can also be used to compare and combine tracks, convert to and from various formats, compress tracks, export data to Google Earth, or to analyse data to calculate distances, altitudes and so on.

Furthermore, GpsPrune is able to display the tracks in 3d format and lets you spin the model round to look at it from various directions. You can also export the model in POV format so that you can render a nice picture using Povray. You can also create charts of altitudes or speeds. It can also load Jpegs and read their coordinates from the EXIF tags, and export thumbnails of these photos to Kmz format so that they appear as popups in Google Earth. If your photos don't have coordinates yet, GpsPrune can be used to connect them (either manually or automatically using the photo timestamps) to data points, and write these coordinates into the EXIF tags.