Tous les produits
Search
Centre de documentation

PolarDB:Visualiser des données vectorielles à l'échelle du milliard avec GanosBase en moins de 100 lignes de code

Dernière mise à jour :Aug 26, 2026

Cette rubrique explique comment utiliser le moteur de rendu rapide intégré à GanosBase, le moteur spatio-temporel de PolarDB for PostgreSQL (Oracle Compatible). En moins de 100 lignes de code, visualisez et interagissez avec des jeux de données géométriques à l'échelle du milliard directement en ligne, sans gérer le stockage des tuiles ni les problèmes de performance.

Contexte

La visualisation de données spatiales vectorielles à l'échelle du milliard issues d'une base de données spatio-temporelle constitue depuis longtemps un défi majeur pour l'industrie. En raison du volume massif de données, les méthodes traditionnelles exigent la publication des données sous forme de service de tuiles mises en cache pour la visualisation. Ce flux de travail est long et soulève de nombreuses questions :

  • Lors de la pré-génération des tuiles vectorielles, quelle est la durée du processus ? Combien de niveaux de zoom sont appropriés ? L'espace disque disponible suffit-il pour stocker les tuiles ?

  • Lors de l'utilisation de tuiles à la demande, le temps de réponse pour le rendu des tuiles en temps réel peut-il être garanti ?

  • Lors de l'utilisation de tuiles vectorielles, quelle peut être la taille d'une tuile à petite échelle ? Le transfert de données deviendra-t-il un goulot d'étranglement ? Quelle quantité de données le moteur de rendu côté client peut-il traiter ?

Le processus traditionnel de génération hors ligne des tuiles, conçu pour les services de fonds de carte, est trop lent et lourd pour permettre un aperçu rapide des données en ligne. Ce processus est chronophage, exige beaucoup de ressources humaines et ne prend pas en charge les mises à jour des données en ligne.

Le moteur de rendu rapide de GanosBase, le moteur spatio-temporel de PolarDB for PostgreSQL (Oracle Compatible), répond à ces problématiques. Il permet un affichage en ligne rapide et une interaction fluide avec la carte pour des données géométriques à l'échelle du milliard en moins de 100 lignes de code, éliminant ainsi les préoccupations liées au stockage des tuiles et aux performances.

Fonctionnement

Le rendu rapide en ligne de GanosBase relie la base de données à la visualisation grâce à une nouvelle technique d'indexation visuelle : l'index de pyramide vectorielle clairsemée (SVP). L'index SVP offre deux avantages majeurs : la rapidité et l'efficacité.

La rapidité fait référence aux hautes performances lors de deux étapes clés :

  • Construction rapide de la pyramide : GanosBase utilise des index spatiaux pour partitionner les données selon leur densité spatiale, puis construit un index de pyramide vectorielle clairsemée basé sur cette densité. Par rapport aux processus de tuilage traditionnels, cette approche réduit les calculs de 90 %. La construction de la pyramide s'exécute dans un modèle de traitement entièrement parallèle. Même pour 100 millions de parcelles, la génération de la pyramide ne prend qu'environ 10 minutes.

  • Rendu rapide : GanosBase utilise un algorithme d'élagage visuel basé sur le tri Z-order pour filtrer une grande quantité de données non significatives visuellement, améliorant considérablement l'efficacité de l'affichage en temps réel. GanosBase prend en charge la sortie directe de tuiles raster au format PNG et de tuiles vectorielles au format MVT. Pour le rendu en temps réel de 100 millions de parcelles, le temps de réponse se compte en secondes.

L'efficacité fait référence aux économies réalisées dans deux domaines clés :

  • Économie d'espace disque : L'index de pyramide pour 100 millions de parcelles nécessite seulement 5 % de la taille de la table d'origine comme espace de stockage supplémentaire.

  • Gain de temps de développement : Contrôlez de manière flexible l'effet d'affichage à l'aide d'instructions SQL simples et en ajustant leurs paramètres.

Utilisation

Pour utiliser le moteur de rendu rapide de GanosBase, installez l'extension.

CREATE EXTENSION ganos_geometry_pyramid CASCADE;

Construire une pyramide vectorielle clairsemée

Supposons que vous ayez créé une grande table vectorielle et chargé les données. Utilisez ensuite la fonction GanosBase ST_BuildPyramid pour créer une pyramide vectorielle et accélérer l'affichage des données. Pour plus d'informations, consultez ST_BuildPyramid.

Exemple

L'instruction SQL suivante crée une pyramide vectorielle pour la colonne geom de la table points. La pyramide est nommée points_geom et sa taille de tuile logique est définie sur 512.

Remarque

Cela spécifie le nom de la pyramide vectorielle et la taille de tuile logique. Cette taille de tuile ne représente pas une tuile physique, mais plutôt une partition spatiale logique.

ST_BuildPyramid('points', 'geom', 'gid', '{"name":"points_geom","tileSize":512}')

Obtenir des tuiles raster

Une tuile raster est une tuile image et constitue l'un des formats de tuiles cartographiques les plus utilisés. La fonction GanosBase ST_AsPng rend dynamiquement les données vectorielles en tuiles raster à la demande directement dans la base de données. Elle fournit une symbologie raster de base et convient bien aux scénarios légers qui ne nécessitent pas de style complexe, tels que les systèmes de gestion de données. Pour plus d'informations, consultez ST_AsPng.

Exemple

L'instruction SQL suivante récupère les données correspondant à la tuile aux coordonnées x=2, y=1 et z=1 depuis la pyramide vectorielle, les rend en une tuile raster selon le style configuré et renvoie une image au format PNG.

ST_AsPng('points_geom', '1_2_1','{"point_size": 5,"line_width": 2,"line_color": "#003399FF","fill_color": "#6699CCCC","background": "#FFFFFF00"}')

Obtenir des tuiles vectorielles

Les tuiles vectorielles constituent une technologie de tuilage cartographique plus récente qui prend en charge un style flexible côté client et utilise le rendu WebGL pour une meilleure qualité visuelle. Des frameworks cartographiques tels que Mapbox prennent en charge ce format nativement. La fonction GanosBase ST_Tile renvoie les données d'une pyramide vectorielle sous forme de tuiles vectorielles. Pour plus d'informations, consultez ST_Tile.

Exemple

Pour appeler la fonction ST_Tile , fournissez les coordonnées standard Tile Map Service (TMS) et le nom de la table de pyramide. L'instruction SQL suivante récupère la tuile vectorielle aux coordonnées x=2, y=1 et z=1 depuis la pyramide vectorielle et renvoie les données au format MVT standard.

ST_Tile('points_geom', '1_2_1');

Bonnes pratiques

Données de test

Cet exemple utilise deux jeux de données vectorielles comme échantillons de test.

  • La table buildings contient des données polygonales avec 125 millions de lignes, ce qui illustre la visualisation en ligne à l'aide de tuiles raster.

    gid|geom                                                                                                                                                                                                                                                           |
    ---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
      1|MULTIPOLYGON(((-88.066953 34.916114 0,-88.066704 34.916114 0,-88.066704 34.91602 0,-88.066953 34.91602 0,-88.066953 34.916114 0)))                 
      2|MULTIPOLYGON(((-87.924658 34.994797 0,-87.924791 34.99476 0,-87.924817 34.994824 0,-87.924685 34.994861 0,-87.924658 34.994797 0)))
  • La table points contient des données ponctuelles avec 107 000 lignes, ce qui illustre la visualisation en ligne à l'aide de tuiles vectorielles.

    id|geom                          |
    --|------------------------------|
     1|POINT (113.5350205 22.1851929)|
     2|POINT (113.5334245 22.1829781)|

Architecture full-stack

L'architecture full-stack pour le rendu rapide de base de données se compose de trois parties : un serveur de base de données, un backend et un client.

image

Code backend

Pour garder le code concis et se concentrer sur la logique, cet exemple utilise Python pour le backend, Flask comme framework web et Psycopg2 pour la connectivité à la base de données (installez-le avec pip install psycopg2). Bien que cela implémente une fonctionnalité de base, si le service web lui-même rencontre des goulots d'étranglement de performance, optimisez-le en fonction de votre plateforme et de votre framework pour obtenir des temps de réponse plus rapides. Commencez par construire une pyramide vectorielle dans le backend, puis implémentez deux endpoints. L'endpoint de tuiles vectorielles utilise les données de la table points et l'endpoint de tuiles raster utilise les données de la table buildings avec un style défini pour que le client puisse les appeler directement. Par souci de clarté, le code backend fournit à la fois des endpoints vectoriels et raster. En pratique, choisissez celui à utiliser selon vos besoins.

# -*- coding: utf-8 -*-
# @File : Vector.py
import json
from psycopg2 import pool
from threading import Semaphore
from flask import Flask, jsonify, Response, send_from_directory
import binascii
# Connection parameters
CONNECTION = "dbname=<database_name> user=<user_name> password=<user_password> host=<host> port=<port>"
class ReallyThreadedConnectionPool(pool.ThreadedConnectionPool):
    """
    A thread-safe connection pool to improve response in high-concurrency scenarios like map tiling.
    """
    def __init__(self, minconn, maxconn, *args, **kwargs):
        self._semaphore = Semaphore(maxconn)
        super().__init__(minconn, maxconn, *args, **kwargs)
    def getconn(self, *args, **kwargs):
        self._semaphore.acquire()
        return super().getconn(*args, **kwargs)
    def putconn(self, *args, **kwargs):
        super().putconn(*args, **kwargs)
        self._semaphore.release()
class VectorViewer:
    def __init__(self, connect, table_name, column_name, fid):
        self.table_name = table_name
        self.column_name = column_name
        # Create a connection pool.
        self.connect = ReallyThreadedConnectionPool(5, 10, connect)
        # Pyramid table naming convention.
        self.pyramid_table = f"{self.table_name}_{self.column_name}"
        self.fid = fid
        self.tileSize = 512
        # self._build_pyramid()
    def _build_pyramid(self):
        """Build the pyramid."""
        config = {
            "name": self.pyramid_table,
            "tileSize": self.tileSize
        }
        sql = f"select st_BuildPyramid('{self.table_name}','{self.column_name}','{self.fid}','{json.dumps(config)}')"
        self.poll_query(sql)
    def poll_query(self, query: str):
        pg_connection = self.connect.getconn()
        pg_cursor = pg_connection.cursor()
        pg_cursor.execute(query)
        record = pg_cursor.fetchone()
        pg_connection.commit()
        pg_cursor.close()
        self.connect.putconn(pg_connection)
        if record is not None:
            return record[0]
class PngViewer(VectorViewer):
    def get_png(self, x, y, z):
        # Default parameters
        config = {
            "point_size": 5,
            "line_width": 2,
            "line_color": "#003399FF",
            "fill_color": "#6699CCCC",
            "background": "#FFFFFF00"
        }
        # With psycopg2, returning binary data as a hex string is more efficient.
        sql = f"select encode(st_aspng('{self.pyramid_table}','{z}_{x}_{y}','{json.dumps(config)}'),'hex')"
        result = self.poll_query(sql)
        # Convert the hex string back to binary before sending the response.
        result = binascii.a2b_hex(result)
        return result
class MvtViewer(VectorViewer):
    def get_mvt(self, x, y, z):
        # With psycopg2, returning binary data as a hex string is more efficient.
        sql = f"select encode(st_tile('{self.pyramid_table}','{z}_{x}_{y}'),'hex')"
        result = self.poll_query(sql)
        # Convert the hex string back to binary before sending the response.
        result = binascii.a2b_hex(result)
        return result
app = Flask(__name__)
@app.route('/vector')
def vector_demo():
    return send_from_directory("./", "Vector.html")
# Define table name, column name, etc.
pngViewer = PngViewer(CONNECTION, 'usbf', 'geom', 'gid')
@app.route('/vector/png/<int:z>/<int:x>/<int:y>')
def vector_png(z, x, y):
    png = pngViewer.get_png(x, y, z)
    return Response(
        response=png,
        mimetype="image/png"
    )
mvtViewer = MvtViewer(CONNECTION, 'points', 'geom', 'gid')
@app.route('/vector/mvt/<int:z>/<int:x>/<int:y>')
def vector_mvt(z, x, y):
    mvt = mvtViewer.get_mvt(x, y, z)
    return Response(
        response=mvt,
        mimetype="application/vnd.mapbox-vector-tile"
    )
if __name__ == "__main__":
    app.run(port=5000, threaded=True)

Enregistrez le code ci-dessus dans un fichier Vector.py et démarrez le service en exécutant la commande python Vector.py . Le code montre que, quel que soit le langage de programmation ou le framework utilisé, vous pouvez implémenter la même fonctionnalité en encapsulant les instructions SQL pour les tuiles vectorielles ou raster en tant qu'endpoint HTTP.

Par rapport à la publication de services cartographiques traditionnels, l'utilisation de la fonctionnalité de pyramide vectorielle de GanosBase pour la visualisation en ligne est une option plus légère et plus pratique.

  • Pour les tuiles raster, contrôlez les styles en modifiant le code, ce qui offre une flexibilité significative.

  • Obtenez des performances satisfaisantes sans composants tiers ni optimisations spécialisées.

  • Utilisez votre langage de programmation et votre framework préférés sans avoir besoin de configuration complexe de paramètres spécialisés, ce qui rend la solution plus accessible aux développeurs sans background SIG.

Code côté client

Cet exemple utilise Mapbox comme framework cartographique frontal pour afficher les couches de tuiles vectorielles et raster fournies par le backend, et configure les paramètres de rendu pour la couche de tuiles vectorielles. Par souci de clarté, le code frontal ajoute à la fois une couche vectorielle et une couche raster. En pratique, choisissez celle à utiliser selon vos besoins. Dans le même répertoire que le code backend, créez un fichier nommé Vector.html et ajoutez le code suivant. Une fois le service backend démarré, accédez-y à l'adresse http://localhost:5000/vector .

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title></title>
    <link
      href="https://cdn.bootcdn.net/ajax/libs/mapbox-gl/1.13.0/mapbox-gl.min.css"
      rel="stylesheet"
    />
  </head>
  <script src="https://cdn.bootcdn.net/ajax/libs/mapbox-gl/1.13.0/mapbox-gl.min.js"></script>
  <script src="https://cdn.bootcdn.net/ajax/libs/axios/0.21.0/axios.min.js"></script>
  <body>
    <div id="map" style="height: 100vh" />
    <script>
      const sources = {
        osm: {
          type: "raster",
          tiles: ["https://b.tile.openstreetmap.org/{z}/{x}/{y}.png"],
          tileSize: 256,
        },
      };
      const layers = [
        {
          id: "base_map",
          type: "raster",
          source: "osm",
          layout: { visibility: "visible" },
        },
      ];
      const map = new mapboxgl.Map({
        container: "map",
        style: { version: 8, layers, sources },
      });
      map.on("load", async () => {
        map.resize();
        // Add a raster tile data source.
        map.addSource("png_source", {
          type: "raster",
          minzoom: 1,
          tiles: [`${window.location.href}/png/{z}/{x}/{y}`],
          tileSize: 512,
        });
        // Add a raster tile layer.
        map.addLayer({
          id: "png_layer",
          type: "raster",
          layout: { visibility: "visible" },
          source: "png_source",
        });
        // Add a vector tile data source.
        map.addSource("mvt_source", {
          type: "vector",
          minzoom: 1,
          tiles: [`${window.location.href}/mvt/{z}/{x}/{y}`],
          tileSize: 512,
        });
        // Add a vector tile layer and style it.
        map.addLayer({
          id: "mvt_layer",
          paint: {
            "circle-radius": 4,
            "circle-color": "#6699CC",
            "circle-stroke-width": 2,
            "circle-opacity": 0.8,
            "circle-stroke-color": "#ffffff",
            "circle-stroke-opacity": 0.9,
          },
          type: "circle",
          source: "mvt_source",
          "source-layer": "points_geom",
        });
      });
    </script>
  </body>
</html>

Démonstration

Effets dynamiques des tuiles vectorielles

2

Ajustez le style visuel côté client. Après avoir ajusté les paramètres de la couche, le résultat est le suivant :

{
  "circle-radius": 4,
  "circle-color": "#000000",
  "circle-stroke-width": 2,
  "circle-opacity": 0.3,
  "circle-stroke-color": "#003399",
  "circle-stroke-opacity": 0.9,
}

Effets dynamiques des tuiles raster

2

Intégration avec pgAdmin

pgAdmin, l'outil de gestion de base de données PostgreSQL, prend en charge nativement la visualisation des données vectorielles. Cependant, sans technologie de rendu rapide, il ne peut afficher que des objets uniques ou des ensembles de résultats limités et ne permet pas de parcourir fluidement l'ensemble du jeu de données. En intégrant la fonctionnalité Vector Fast-Render de GanosBase avec pgAdmin, parcourez l'ensemble du jeu de données en ligne après l'ingestion des données pour obtenir rapidement un aperçu des données, améliorant considérablement l'expérience de gestion des données.

Dans l'arborescence d'objets pgAdmin à gauche, développez le nœud Tables sous le schéma public. Cliquez avec le bouton droit sur la table cible (par exemple, roads) et choisissez Vector Fast-Render dans le menu contextuel pour lancer la fonctionnalité.

Résumé

En tirant parti des principes et des avantages de la pyramide vectorielle clairsemée, utilisez GanosBase pour implémenter diverses fonctionnalités de visualisation en ligne et construire un service de visualisation cartographique capable de gérer des centaines de millions de points de données avec seulement quelques centaines de lignes de code. Outre la visualisation, utilisez également les capacités rapides de requête et d'analyse côté serveur de la base de données cloud-native cloud-native database PolarDB et de GanosBase pour effectuer des fonctions plus complexes, telles que les object attribute queries , les spatial selection et les spatial analysis . C'est la révolution déclenchée par l'index de pyramide vectorielle clairsemée, une technologie d'accélération de l'affichage graphique spatial à grande échelle de GanosBase . Pour plus d'informations, consultez l'Introduction . Visitez la page d'achat de cluster PolarDBPolarDB cluster purchase page pour activer le service PolarDB .