Tous les produits
Search
Centre de documentation

PolarDB:GanosBase: Prise en main du rendu rapide de vecteurs 2D et 3D (partie 1)

Dernière mise à jour :Sep 20, 2026

La fonctionnalité de visualisation vectorielle 2D rapide de GanosBase résout les problèmes clés des schémas de tuilage traditionnels, tels que le temps de génération des tuiles et l'espace de stockage requis, tout en prenant en charge les mises à jour partielles. Elle offre des améliorations significatives en termes d'efficacité, de stockage et de fonctionnalités par rapport aux systèmes existants. La fonctionnalité de visualisation vectorielle 3D de GanosBase étend les tuiles vectorielles 2D pour visualiser les données Geometry3D, ce qui permet l'affichage efficace de scènes 3D à grande échelle. Cette rubrique présente des exemples de création et de mise à jour de pyramides vectorielles 2D, ainsi que l'utilisation de la fonctionnalité de visualisation d'objets vectoriels 3D.

Présentation des fonctionnalités

Rendu rapide de vecteurs 2D

Les systèmes traditionnels visualisent principalement les données vectorielles via un tuilage hors ligne. Lorsqu'une demande de visualisation arrive, le serveur traite les tuiles préconstruites et les renvoie au client. Cette approche présente deux inconvénients majeurs. Premièrement, elle est lente. Le tuilage hors ligne sur des jeux de données volumineux peut prendre plusieurs heures, voire plusieurs jours. Deuxièmement, elle nécessite une quantité importante de stockage. Un service cartographique prenant en charge jusqu'à 16 niveaux de zoom doit stocker des milliards de tuiles à l'avance, ce qui entraîne un encombrement de stockage considérable. La lenteur du traitement rend également les mises à jour de données difficiles. Cela est particulièrement vrai dans les systèmes SIG dotés de faibles capacités de gestion des données, car ces systèmes ne peuvent pas détecter quelles tuiles sont affectées par les mises à jour. Si des données sont mises à jour, même dans une petite zone locale, la seule solution consiste à reconstruire toutes les tuiles, ce qui prend du temps et consomme beaucoup de ressources.

La fonctionnalité de rendu rapide de vecteurs 2D du moteur de rendu rapide GanosBase est conçue pour visualiser des jeux de données vectoriels 2D contenant des centaines de millions d'enregistrements, tels que des points, des lignes et des polygones. Cette fonctionnalité résout efficacement les défis courants de visualisation. GanosBase introduit un index de pyramide clairsemée innovant qui ignore la génération de tuiles pour les zones de données peu denses. Combinée à l'optimisation des requêtes de base de données et à un algorithme d'élimination de visibilité visuelle, cette approche filtre une grande quantité de données n'affectant pas le rendu visuel. Cette méthode résout les deux principaux problèmes liés aux longs temps de génération des tuiles et à l'encombrement excessif du stockage. De plus, GanosBase prend en charge les mises à jour dynamiques de l'index de pyramide clairsemée. Lorsque des mises à jour locales sont effectuées sur une petite zone des données vectorielles, GanosBase identifie automatiquement les tuiles concernées et limite les mises à jour à la zone la plus petite possible. Cette méthode évite la reconstruction de l'intégralité de l'index de pyramide clairsemée et améliore considérablement l'efficacité des mises à jour. Lors de tests effectués sur un cluster PolarDB for PostgreSQL (Compatible with Oracle) standard à 8 cœurs, la construction d'un index de pyramide clairsemée pour un jeu de données de bâtiments contenant 70 millions d'enregistrements ne prend que 6 minutes. Lorsque plus d'un million d'enregistrements de données sont mis à jour, l'index de pyramide clairsemée peut être actualisé en moins d'une minute. Lors de la réponse aux demandes de visualisation, le temps moyen de retour d'une tuile est inférieur à 1 milliseconde. Avec de telles performances, l'espace de stockage sur disque requis n'est que d'environ 3 Go.

Visualisation vectorielle 3D

En plus de l'affichage rapide de vecteurs 2D, GanosBase prend également en charge la visualisation de données vectorielles 3D, une fonctionnalité développée conjointement avec l'équipe DataV d'Alibaba Cloud. Pour ce faire, GanosBase et DataV ont étendu la norme existante des segments vectoriels 2D afin de créer des segments vectoriels 3D pour la visualisation d'objets vectoriels 3D. La figure suivante illustre le résultat :

2

Étapes d'utilisation

Étapes d'utilisation du rendu rapide de vecteurs 2D

Préparer une table de données

Préparez une table de données contenant un attribut Geometry. GanosBase fournit plusieurs fonctions pour écrire des données vectorielles dans une table de données, telles que les fonctions courantes ST_GeomFromText, ST_GeomFromWKT et ST_GeomFromWKB. Pour utiliser la fonctionnalité d'affichage vectoriel rapide de GanosBase, assurez-vous que la table de données contient une clé primaire ID et une colonne d'attribut Geometry.

  1. Avant de pouvoir utiliser la fonctionnalité d'affichage rapide de GanosBase, installez l'extension ganos_geometry_pyramid.

    CREATE EXTENSIION ganos_geometry_pyramid CASCADE;
  2. Créez une table de données contenant une colonne de clé primaire id et une colonne geom.

    CREATE TABLE try_ganos_viz(id SERIAL NOT NULL, geom Geometry);
  3. Importez un jeu de données vectorielles dans la table à l'aide d'un script ou d'un autre outil. Le script ou l'outil doit uniquement générer des commandes SQL similaires à celle de l'exemple suivant. Cet exemple suppose que le fichier de jeu de données stocke les données au format WKT avec le système de coordonnées 4326.

    INSERT INTO try_ganos_viz(geom) VALUES (ST_GeomFromText('WKT FORMAT TEXT', 4326));

    L'instruction SQL précédente stocke les données dans la base de données avec le système de coordonnées 4326. Vous pouvez également spécifier d'autres systèmes de coordonnées.

  4. Une fois toutes les données importées, créez un index spatial sur la colonne d'attribut Geometry.

    CREATE INDEX ON try_ganos_viz USING gist(geom);

Construire une pyramide clairsemée

ST_BuildPyramid

La fonction ST_BuildPyramid encapsule la fonctionnalité de construction d'une pyramide clairsemée. Pour plus d'informations, consultez ST_BuildPyramid. Les exemples suivants fournissent plus de détails.

  • Créez une pyramide clairsemée avec les paramètres par défaut.

    SELECT ST_BuildPyramid('try_ganos_viz', 'geom', 'id', '');
  • Spécifiez le degré de parallélisme pour la construction de la pyramide clairsemée dans le paramètre config. Exécutez la commande suivante pour construire une pyramide vectorielle avec un degré de parallélisme de 32 :

    SELECT ST_BuildPyramid('try_ganos_viz', 'geom', 'id', '{"parallel":32}');
  • Spécifiez les valeurs de tileSize et tileExtend dans le paramètre config pour définir la taille en pixels et l'étendue de découpage des tuiles.

    SELECT ST_BuildPyramid('try_ganos_viz', 'geom', 'id', '{"parallel":32, "tileSize":4096, "tileExtend":128}');
  • GanosBase vous permet d'utiliser les paramètres maxLevel et splitSize pour contrôler la structure de la pyramide clairsemée et équilibrer les performances avec l'encombrement du stockage.

    • Pour privilégier les performances des requêtes plutôt que l'encombrement du stockage, définissez splitSize sur une valeur plus faible. Si le nombre d'entités dans une tuile est inférieur à splitSize, la tuile est construite dynamiquement au moment de la requête. Cette méthode garantit qu'autant de tuiles que possible sont construites avant l'exécution des requêtes.

    • Pour privilégier l'encombrement du stockage, définissez splitSize sur une valeur plus élevée. Vous pouvez également définir maxLevel sur une valeur plus faible pour contrôler la hauteur de la pyramide, ce qui réduit le nombre de tuiles à maintenir.

    L'exemple suivant construit une pyramide clairsemée avec un maxLevel de 10 et un splitSize de 1000 :

    SELECT ST_BuildPyramid('try_ganos_viz', 'geom', '{"maxLevel":10, "splitSize":1000}');
  • Le paramètre buildRules offre un contrôle flexible sur les règles de construction de la pyramide clairsemée. Par exemple, pour visualiser uniquement les entités dont la surface est supérieure à 100 dans les tuiles aux niveaux 5 ou inférieurs, exécutez la commande suivante :

    SELECT ST_BuildPyramid('try_ganos_viz', 'geom', '{"maxLevel":10, "buildRules":[
                           {"level":[0,1,2,3,4,5], "value":{"filter": "ST_Area(geom)>100"}}
    ]}');

    La condition de filtre correspondant à filter dans l'instruction SQL précédente peut être toute instruction conditionnelle suivant une clause WHERE.

ST_BuildPyramidUseGeomSideLen

Vous pouvez également utiliser la fonction ST_BuildPyramidUseGeomSideLen pour construire une pyramide vectorielle. Cette fonction est optimisée pour les performances par rapport à ST_BuildPyramid. Elle peut améliorer considérablement l'efficacité de construction de la pyramide clairsemée lorsque la table de données contient de nombreuses entités de petite superficie. Pour plus d'informations, consultez ST_BuildPyramidUseGeomSideLen.

Avant d'utiliser la fonction ST_BuildPyramidUseGeomSideLen, la table de données doit disposer d'une colonne d'attribut de type nombre réel. Cette colonne enregistre la valeur la plus élevée entre ST_XMax(geom)-ST_XMin(geom) et ST_YMax(geom)-ST_YMin(geom) pour la colonne geom. Vous devez également créer un index sur cette colonne d'attribut. En utilisant la table try_ganos_viz comme exemple, exécutez les instructions suivantes pour ajouter une colonne d'attribut max_side_len et créer un index B-tree pour celle-ci :

ALTER TABLE try_ganos_viz
ADD COLUMN max_side_len DOUBLE PRECISION;

CREATE OR REPLACE FUNCTION add_max_len_values() RETURNS VOID AS $$
DECLARE
  t_curs CURSOR FOR
    SELECT * FROM try_ganos_viz;
  t_row usbf%ROWTYPE;
  gm GEOMETRY;
  x_min DOUBLE PRECISION;
  x_max DOUBLE PRECISION;
  y_min DOUBLE PRECISION;
  y_max DOUBLE PRECISION;
BEGIN
  FOR t_row IN t_curs LOOP
    SELECT t_row.geom INTO gm;
    SELECT ST_XMin(gm) INTO x_min;
    SELECT ST_XMax(gm) INTO x_max;
    SELECT ST_YMin(gm) INTO y_min;
    SELECT ST_YMax(gm) INTO y_max;
    UPDATE try_ganos_viz
      SET max_side_len = GREATEST(x_max - x_min, y_max - y_min)
    WHERE CURRENT OF t_curs;
  END LOOP;
END;
$$ LANGUAGE plpgsql;
SELECT add_max_len_values();

CREATE INDEX ON try_ganos_viz USING btree(max_side_len);

Lorsque vous appelez ST_BuildPyramidUseGeomSideLen, indiquez le nom de la nouvelle colonne. Les autres paramètres sont identiques à ceux de ST_BuildPyramid. Exécutez l'instruction suivante pour construire une pyramide clairsemée pour la table try_ganos_viz, qui inclut désormais la colonne max_side_len :

SELECT ST_BuildPyramidUseGeomSideLen('try_ganos_viz', 'geom', 'max_side_len', 'id', '{"parallel":32}');

ST_BuildPyramidUseGeomSideLen prend également en charge plusieurs paramètres de configuration pour ajuster de manière flexible les règles de construction de la pyramide clairsemée.

Mettre à jour la pyramide

Lorsque les données d'une table de données sont mises à jour, utilisez la fonction ST_UpdatePyramid de GanosBase pour mettre à jour la pyramide. Il vous suffit de fournir la boîte englobante de la mise à jour des données. Pour plus d'informations, consultez ST_UpdatePyramid.

  • Supposons que plusieurs enregistrements de données soient insérés dans la plage de longitude et de latitude [(lon1, lat1), (lon2, lat2)]. Pour mettre à jour toutes les tuiles concernées (en supposant que maxLevel=16), exécutez l'instruction suivante :

    SELECT ST_UpdatePyramid('try_ganos_viz', 'geom', 'id', ST_MakeEnvelope(0,-10,20,30, 4326), '{"updateBoxScale":100000}');

    Dans l'instruction SQL précédente, lon1 est supposé être 0, lat1 est -10, lon2 est 20 et lat2 est 30.

  • Si vous ne souhaitez pas effectuer une mise à jour globale à grande échelle, spécifiez une valeur plus faible pour le paramètre updateBoxScale. Cela empêche la mise à jour des tuiles aux niveaux inférieurs. L'instruction suivante met à jour uniquement les tuiles dans une plage légèrement plus large et les tuiles aux niveaux inférieurs :

    SELECT ST_UpdatePyramid('try_ganos_viz', 'geom', 'id', ST_MakeEnvelope(0,-10,20,30, 4326), '{"updateBoxScale":2}');
Remarque
  • Lorsque vous appelez ST_UpdatePyramid, vous n'avez pas besoin de spécifier le degré de parallélisme. La fonction utilise automatiquement la valeur de parallélisme fournie lors de l'appel à ST_BuildPyramid ou ST_BuildPyramidUseGeomSideLen.

  • La mise à jour d'une pyramide implique la mise à jour de la pyramide clairsemée, la suppression des anciennes tuiles et la génération de nouvelles tuiles. Si une mise à jour de données à grande échelle se produit, reconstruisez directement la pyramide en appelant ST_BuildPyramid ou ST_BuildPyramidUseGeomSideLen.

Obtenir des tuiles vectorielles

Les tuiles vectorielles présentent l'avantage de conserver les informations sur les entités. Dans les services cartographiques, les tuiles vectorielles offrent des transitions plus fluides pour le zoom à plusieurs niveaux et une meilleure expérience visuelle que les tuiles raster traditionnelles. GanosBase fournit la fonction ST_Tile pour récupérer des tuiles vectorielles en temps réel. Pour plus d'informations, consultez ST_Tile.

Exécutez l'une des instructions suivantes pour récupérer la tuile contenant la Chine : z=1, x=1, y=0.

SELECT ST_Tile('try_ganos_viz', '1_1_0');

SELECT ST_Tile('try_ganos_viz', 1, 0, 1);

Obtenir des tuiles raster

GanosBase prend également en charge les tuiles raster, largement utilisées. Les tuiles raster sont présentées sous forme d'images. Contrairement aux tuiles vectorielles, les tuiles raster ne prennent pas en charge le rendu dynamique côté client et imposent donc des exigences de performance moindres aux systèmes clients. GanosBase fournit la fonction ST_AsPng. Cette fonction vous permet de rendre dynamiquement les données vectorielles en tuiles raster à la demande côté base de données et de renvoyer les résultats au client. Cette fonction offre des capacités de symbolisation raster de base et convient principalement aux scénarios légers ne nécessitant pas de symbolisation complexe. Pour plus d'informations, consultez ST_AsPng.

Appelez l'instruction suivante pour renvoyer la tuile raster portant le numéro de tuile '1_1_0'. La tuile est rendue selon les paramètres de rendu fournis et sortie au format PNG.

SELECT ST_AsPng('try_ganos_viz', '1_1_0', '{"point_size":5, "line_width":2, "line_color":"#003399FF", 
                "fill_color":"#6699CCCC", "background":"#FFFFFF00"}');

Étapes d'utilisation de la visualisation vectorielle 3D

Préparer une table de données

Préparez une table de données contenant une colonne d'attribut Geometry3D. Vous pouvez importer des données à l'aide de fonctions telles que ST_GeomFromText, ST_GeomFromWKT et ST_GeomFromWKB.

  1. Avant de pouvoir utiliser la fonctionnalité de visualisation vectorielle 3D de GanosBase, installez l'extension ganos_geometry.

    CREATE EXTENSIION ganos_geometry CASCADE;
  2. Créez une table de données contenant une colonne de clé primaire id et une colonne geom.

    CREATE TABLE try_ganos_viz3d(id SERIAL NOT NULL, geom Geometry);

Obtenir des tuiles vectorielles 3D

Avant de pouvoir utiliser la fonctionnalité de visualisation de données vectorielles 3D, appelez deux fonctions fournies par GanosBase : ST_AsMVTGeom3D et ST_AsMVT3D.

  • ST_AsMVTGeom3D

    La fonction ST_AsMVTGeom3D est une version étendue de la fonction PostGIS ST_AsMVTGeom pour les données vectorielles 2D. Elle peut transformer l'espace de coordonnées des données Geometry3D en espace de coordonnées MVT. Si nécessaire, elle découpe également les données Geometry3D en fonction de la boîte englobante de la tuile. Pour plus d'informations sur la fonction, consultez ST_AsMVTGeom3D. Voici un exemple :

    SELECT ST_AsText(ST_AsMVTGeom3D(ST_Transform('SRID=4326; LINESTRING(-10 -10 30, -10 -20 30)'::geometry, 3857), ST_TileEnvelope(1, 0, 0))) AS geom;

    Le résultat suivant est renvoyé :

                                            geom                                        
    ------------------------------------------------------------------------------------
     MULTILINESTRING Z ((3868.44444444444 4324.7197219642 30,3868.44444444444 4352 30))
    (1 row)
  • ST_AsMVT3D

    La fonction ST_AsMVT3D est une fonction d'agrégation similaire à la fonction PostGIS ST_AsMVT pour les données vectorielles 2D. Elle encapsule plusieurs lignes de données dans une tuile vectorielle 3D. Chaque enregistrement de données encapsulé correspond à des données Geometry3D transformées dans l'espace de coordonnées MVT. Ces enregistrements de données encapsulés forment ensemble une couche de tuiles. Pour plus d'informations sur la fonction, consultez ST_AsMVT3D. Voici un exemple :

    WITH mvtgeom AS
    (
      SELECT ST_AsMVTGeom3D(
        ST_Transform('SRID=4326; MULTIPOLYGON(((100 50 0, -100 50 1, -100 -50 2, 100 -50 3, 100 50 0)), ((0 0 0, 1 0 1, 2 2 2, 0 0 0)))'::geometry, 3857),
        ST_TileEnvelope(1, 0, 0)) AS geom,  'test' AS name
    )
    SELECT ST_AsMVT3D(mvtgeom.*) FROM mvtgeom;

    Le résultat suivant est renvoyé :

                                                                                                                         st_asmvt3d                                                                                                                     
    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     \x1a760a0764656661756c74125812020000180322500d8044a842b83116ff23d80105802400080f0d810481041d162e000e2e590e0f0dd920dc0405168024d70106c727f3160d0f0dc827f4160e1600f31615c72700080f0d0000001600cc1808c80300000f1a046e616d6522060a04746573742880207802
    (1 row)

Bonnes pratiques

Ce tutoriel utilise la fonctionnalité d'affichage vectoriel 2D rapide de GanosBase pour vous montrer comment configurer rapidement un service de carte web.

Architecture full-stack

Ce service de carte web se compose de trois parties : un serveur de base de données, un backend Python et un client utilisateur. La figure suivante montre l'architecture full-stack.

image

Base de données

Importez les données cartographiques dans la base de données et construisez les index requis pour la pyramide clairsemée. Pour plus d'informations, consultez Étapes d'utilisation du rendu rapide de vecteurs 2D.

Code backend

Par souci de simplicité et pour se concentrer sur la logique, cette étude de cas utilise Python comme langage backend. Le framework web est Flask et le framework de connexion à la base de données est Psycopg2. Installez Psycopg2 en exécutant pip install psycopg2. Notez que cette implémentation couvre uniquement les fonctionnalités les plus basiques. Si le service web rencontre des goulots d'étranglement en termes de performances, vous pouvez l'optimiser en fonction des différentes plateformes et frameworks pour obtenir de meilleures performances de réponse. Commencez par construire la pyramide vectorielle côté backend. Ensuite, implémentez deux interfaces. L'interface de tuiles vectorielles utilise les données de la table points. L'interface de tuiles raster utilise les données de la table buildings et définit les styles correspondants pour des appels directs depuis le frontend. Pour plus de clarté, le code backend fournit à la fois des interfaces vectorielles et raster. En pratique, vous pouvez choisir celle à 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 connection pool for multi-threaded applications 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)
        # Convention for the pyramid table name
        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"
        }
        # When using psycopg2, it is more efficient to return binary data as a hexadecimal string
        sql = f"select encode(st_aspng('{self.pyramid_table}','{z}_{x}_{y}','{json.dumps(config)}'),'hex')"
        result = self.poll_query(sql)
        # This conversion is only needed when the data is returned as a hexadecimal string
        result = binascii.a2b_hex(result)
        return result

class MvtViewer(VectorViewer):
    def get_mvt(self, x, y, z):
        # When using psycopg2, it is more efficient to return binary data as a hexadecimal string
        sql = f"select encode(st_tile('{self.pyramid_table}','{z}_{x}_{y}'),'hex')"
        result = self.poll_query(sql)
        # This conversion is only needed when the data is returned as a hexadecimal string
        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, field names, 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 précédent dans un fichier Vector.py et exécutez la commande python Vector.py pour démarrer le service. Comme vous pouvez le voir dans le code, vous pouvez obtenir la même fonctionnalité quel que soit le langage de programmation ou le framework. Il vous suffit d'encapsuler les instructions SQL pour les tuiles vectorielles ou raster dans une interface.

L'utilisation de la fonctionnalité de pyramide vectorielle de GanosBase pour réaliser une visualisation en ligne constitue une alternative plus légère et plus pratique à la publication de services cartographiques traditionnels.

  • Pour les tuiles raster, vous pouvez contrôler les styles en modifiant le code, ce qui améliore considérablement la flexibilité.

  • Vous pouvez obtenir des performances de réponse satisfaisantes sans introduire de composants tiers ni effectuer d'optimisations spéciales.

  • Elle permet de choisir librement des langages de programmation et des frameworks familiers. Elle ne nécessite pas de configuration complexe de paramètres professionnels, ce qui la rend plus accessible aux non-spécialistes de la géomatique.

Code côté client

Cette étude de cas utilise Mapbox comme framework cartographique frontal. Elle affiche les couches de tuiles vectorielles et raster fournies par le backend et configure les paramètres de rendu pour la couche de tuiles vectorielles. Pour plus de clarté, le code frontal ajoute à la fois des couches vectorielles et raster. En pratique, vous pouvez choisir celle à utiliser selon vos besoins. Dans le même répertoire que le code backend, créez un nouveau fichier nommé Vector.html et ajoutez le code suivant. Une fois le service backend démarré, vous pouvez accéder au service à 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 the raster tile data source
        map.addSource("png_source", {
          type: "raster",
          minzoom: 1,
          tiles: [`${window.location.href}/png/{z}/{x}/{y}`],
          tileSize: 512,
        });
        // Add the raster tile layer
        map.addLayer({
          id: "png_layer",
          type: "raster",
          layout: { visibility: "visible" },
          source: "png_source",
        });

        // Add the vector tile data source
        map.addSource("mvt_source", {
          type: "vector",
          minzoom: 1,
          tiles: [`${window.location.href}/mvt/{z}/{x}/{y}`],
          tileSize: 512,
        });

        // Add the vector tile layer and add styles for the vector tiles
        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>

Résumé

La fonctionnalité d'affichage rapide 2D de GanosBase visualise efficacement les données vectorielles 2D contenant des centaines de millions d'entrées. Elle répond de manière significative aux deux principaux inconvénients des solutions de tuilage traditionnelles : le temps de tuilage et l'encombrement du stockage. De plus, la fonctionnalité prend en charge les mises à jour partielles et offre des améliorations importantes en termes d'efficacité, de stockage et de fonctionnalités par rapport aux systèmes existants. La fonctionnalité de visualisation vectorielle 3D de GanosBase, extension du tuilage vectoriel 2D, prend en charge la visualisation des données Geometry3D pour des scénarios 3D à grande échelle.