Tous les produits
Search
Centre de documentation

PolarDB:GanosBase : requête d'agrégation de cartes thermiques en temps réel — Analyse et bonnes pratiques

Dernière mise à jour :Sep 23, 2026

Cette rubrique décrit la fonctionnalité de requête d'agrégation de cartes thermiques en temps réel et de génération dynamique de tuiles de carte thermique (Heatmap Tile) fournie par GanosBase, qui s'appuie sur PolarDB for PostgreSQL (Compatible with Oracle). Cette fonctionnalité propose une structure d'échange de données permettant de renvoyer instantanément les résultats de requête à un client.

À propos des tuiles de carte thermique

Qu'est-ce qu'une tuile de carte thermique ?

Une tuile de carte thermique (HMT, HeatMap Tile) repose sur la technologie pionnière GanosBase dédiée aux requêtes d'agrégation de cartes thermiques en temps réel sur des volumes massifs de données vectorielles et de trajectoires. Il s'agit d'une structure d'échange de données conçue pour transmettre immédiatement les résultats de requête à un client. Cette technologie bouleverse l'approche traditionnelle de l'analyse statistique par carte thermique, qui imposait un pré-encodage pour l'agrégation et un prédécoupage pour l'affichage. Elle permet d'agréger et de rendre des données à l'échelle de millions, dizaines de millions ou centaines de millions d'enregistrements en quelques secondes. HMT prend en charge diverses fonctions d'agrégation courantes ainsi que des expressions algébriques. Sélectionnez les métriques métier pertinentes pour vos analyses statistiques. Le moteur effectue également des calculs dynamiques et un rendu en temps réel à différents niveaux de zoom lors de la navigation sur la carte. Cette approche améliore considérablement l'efficacité opérationnelle et ouvre de nouvelles perspectives pour les produits destinés aux clients. Lors de la conférence Apsara 2022, GanosBase a officiellement lancé cette fonctionnalité. Une démonstration en direct a mis en avant un cas d'usage concret : l'agrégation en temps réel de trajectoires de transport à grande échelle, construite sur HMT. Cette avancée a permis de migrer entièrement en ligne des produits de données qui nécessitaient auparavant un prétraitement hors ligne. La fonctionnalité a reçu un accueil très positif et une large reconnaissance de la part du secteur.

Cas d'utilisation

Les tuiles de carte thermique excellent dans l'agrégation et le rendu en temps réel des données spatiales. Elles sont principalement utilisées dans des scénarios métier exigeant le traitement de volumes massifs de données vectorielles et la réalisation d'analyses statistiques en temps réel, tels que :

  • Transport : agrégez les données de carte thermique en temps réel sur l'ensemble d'une zone géographique à partir des historiques de trajectoires des véhicules de transport, tels que les voitures et les navires. Filtrez les données selon des critères supplémentaires, comme la période (hiver, été), l'origine/la destination ou le type de véhicule (camion, voiture particulière), afin de générer les cartes thermiques correspondantes en temps réel.

  • Gestion urbaine : agrégez des indicateurs simples pour les zones urbaines et rurales, tels que la densité des bâtiments, la hauteur moyenne des constructions ou la surface totale bâtie, à partir des données d'emprise au sol des bâtiments. Combinez également ces informations avec les données parcellaires pour agréger des indicateurs composites, comme le coefficient d'emprise au sol.

  • Mobilité partagée : agrégez une carte thermique des zones de stationnement des engins de mobilité partagée sur l'ensemble d'une zone, en vous basant sur leurs points de trajectoire. Analysez aussi les politiques de rééquilibrage et de maintenance (O&M) de ces engins en fonction de conditions telles que les événements liés aux appareils (verrouillage/déverrouillage, prise en charge/restitution, accident, dommage) et le flux de trafic.

Avantages techniques

Par rapport aux méthodes d'agrégation utilisant des grilles H3 ou S2 pré-encodées, les HMT présentent les avantages suivants :

  1. Haute efficacité sans pré-encodage ni surcoût de stockage. La technologie d'agrégation HMT diffère significativement des méthodes basées sur des grilles, telles que H3 et S2, tant par ses attributs techniques que par ses scénarios d'application. L'agrégation par grille est généralement utilisée dans les scénarios où les codes de grille servent de conditions de recherche. Cela nécessite d'encoder les données vectorielles après avoir défini un niveau de précision spécifique, puis d'effectuer les statistiques sur la base de ce code. En revanche, la technologie HMT ne requiert aucun pré-encodage des données. Elle effectue une agrégation dynamique en fonction de la fenêtre d'affichage actuelle. Lorsque vous zoomez ou dézoomez, le processus d'agrégation se produit en temps réel. L'efficacité reste constante quel que soit le type d'objet géométrique traité, permettant l'agrégation et le rendu de centaines de millions d'enregistrements en quelques secondes.

  2. Simplicité d'utilisation avec visualisation directe des résultats d'agrégation. HMT convertit rapidement les résultats d'agrégation en tuiles. Cela permet une intégration visuelle directe avec les moteurs de rendu frontend, garantissant une expérience « What You See Is What You Get ». De plus, HMT propose une série de fonctions statistiques qui vous aident à générer automatiquement et rapidement les palettes de couleurs optimales pour le rendu, assurant ainsi des performances frontend optimales.

Des tests menés dans plusieurs scénarios réels montrent que la technologie d'agrégation HMT est hautement efficace. Elle réalise l'agrégation complète d'une carte pour des centaines de millions d'enregistrements en quelques secondes :

Cas d'utilisation

Volume de données

Étendue de la tuile

Efficacité d'agrégation

Agrégation de trajectoires

  • Trajectoires : 450 000

  • 31 millions de points de trajectoire

  • Niveau mondial

  • Tuile 512 × 512

372 ms

Agrégation d'emprises au sol de bâtiments

308 millions d'emprises au sol de bâtiments

  • Niveau mondial

  • Tuile 512 × 512

17 s

Remarque

Les données du tableau ci-dessus illustrent l'efficacité d'agrégation pour l'intégralité des données à une échelle d'affichage mondiale. Lorsque vous zoomez sur la carte, l'efficacité d'agrégation s'améliore continuellement.

Fonctionnalités

Les tuiles de carte thermique incluent une série de fonctions SQL dédiées à la génération et à l'analyse des tuiles. Voici les principales :

  • ST_AsHMT : convertit un ensemble d'objets géométriques ou de trajectoires en une tuile matricielle de carte thermique, selon une étendue et une résolution spécifiées.

  • ST_HMTAsArray : convertit une tuile de carte thermique en une représentation matricielle sous forme de tableau, pour faciliter la consultation.

  • ST_HMTStats : calcule les informations statistiques d'une tuile de carte thermique, utiles lors du rendu.

  • ST_HMTAsRaster : convertit une tuile de carte thermique en un objet Raster, pour la visualisation et le calcul.

Conseils d'utilisation

Utilisez le traitement parallèle pour améliorer les performances

Lorsque le volume de données est important, utilisez le traitement parallèle pour booster les performances. Configurez les paramètres en fonction de l'étendue de la fenêtre d'affichage. Par exemple, utilisez 16 processus parallèles aux niveaux de zoom élevés et désactivez le traitement parallèle aux niveaux inférieurs. Si les ressources CPU sont suffisantes, garantissez que chaque requête exploite le traitement parallèle. Pour ce faire, définissez max_worker_processes et max_parallel_workers sur le produit du degré de parallélisme et du nombre de requêtes simultanées. Pour plus d'informations, consultez la documentation communautaire. L'exemple suivant montre comment définir le degré de parallélisme sur 16 :

SET max_worker_processes = 300;
SET max_parallel_workers = 260;
SET max_parallel_workers_per_gather = 16;
ALTER TABLE table_name SET (parallel_workers=16);
SET force_parallel_mode = on;

Taille des tuiles

En général, utilisez une tuile de 512 × 512 et rééchantillonnez-la en 256 × 256 pour éviter l'aliasing. Toutefois, dans certaines situations, notamment avec des volumes de données extrêmement importants, le calcul de chaque tuile peut prendre beaucoup de temps. Dans ce cas, envisagez d'utiliser des tuiles plus grandes (1024 × 1024) pour réduire le nombre de requêtes de tuiles et améliorer les performances.

Utilisez l'opérateur && pour le filtrage spatial

D'un point de vue computationnel, ST_AsHMT est nettement plus rapide que ST_Intersects. Lors du filtrage avec un index, utilisez également l'opérateur &&.

SELECT ST_AsHMT(column_name, --geometry type column
    ST_MakeEnvelope(0, 0, 10, 10, 4326), -- Define the spatial extent
    512,
    512,
    value       -- Reference value column for generating output
)
FROM table_name
WHERE column_name && ST_MakeEnvelope(0, 0, 10, 10, 4326);

Transformation du système de référence spatiale pour l'étendue de requête

Si le système de référence spatiale de l'étendue de requête ne correspond pas à celui des objets géométriques, transformez le système de référence de l'étendue de requête avant d'exécuter la requête. Sinon, une transformation automatique pourrait dégrader les performances. Après avoir récupéré la tuile, transformez l'image vers le système de référence spécifié pour l'affichage.

SELECT ST_AsHMT(column_name, -- Spatial reference system is WGS 84
    ST_Transform(ST_TileEnvelope(6, 48, 32), 4326), -- Define the tile extent
    512,
    512,
    value       -- Specify the value for rendering the tile image
)
FROM table_name
WHERE column_name && ST_Transform(ST_TileEnvelope(6, 48, 32), 4326));

Exécutez les opérations VACCUM FULL et CLUSTER sur les tables spatiales

  • L'opération VACUUM FULL récupère l'espace libre et réduit la taille du fichier sur disque, ce qui diminue le nombre d'opérations d'E/S lors des requêtes.

    VACUUM full table_name;
    CLUSTER table_name using index_name;
  • L'opération CLUSTER garantit que l'organisation des données est cohérente avec l'index. Les données spatiales contiguës sont stockées sur des pages de données contiguës, ce qui réduit la charge d'accès au disque pour la base de données lors des accès. Pour plus d'informations, consultez la documentation communautaire.

    CLUSTER table_name USING index_name;

Bonnes pratiques

  1. Configurez la base de données.

    1. Importez les données géométriques ou de trajectoire dans la base de données. Nous recommandons d'utiliser le mécanisme Foreign Data Wrapper (FDW). Pour plus d'informations, consultez Importer rapidement des données vectorielles et raster. Assurez-vous que tous les objets partagent le même système de référence spatiale. Vous pouvez le confirmer à l'aide de la fonction ST_Srid.

    2. Créez un index spatial sur la colonne de géométrie ou de trajectoire.

      CREATE INDEX index_name ON table_name USING GIST(column_name);
    3. Interrogez les tuiles de carte thermique en fonction de l'étendue spatiale.

      Remarque

      Dans les instructions SQL suivantes, vous pouvez utiliser la fonction ST_TileEnvelope à la place de ST_MakeEnvelope pour obtenir l'étendue de la tuile.

      • Analysez l'agrégation de la carte thermique du nombre d'objets au sein de la grille.

        SELECT ST_AsHMT(column_name, --geometry type
            ST_MakeEnvelope(0, 0, 10, 10, 4326), -- Extent
            512,        -- Width
            512        -- height
        )
        FROM table_name
        WHERE column_name && ST_MakeEnvelope(0, 0, 10, 10, 4326);
      • Lors de l'agrégation de valeurs numériques au sein d'une grille spécifique, somme les valeurs du champ value.

        SELECT ST_AsHMT(column_name, --geometry type
            ST_MakeEnvelope(0, 0, 10, 10, 4326), -- Extent
            512,        -- Width
            512,        -- height
            value       -- value column
        )
        FROM table_name
        WHERE column_name && ST_MakeEnvelope(0, 0, 10, 10, 4326);
      • Lors de l'agrégation de valeurs numériques au sein d'une grille spécifique par sommation des valeurs du champ value, ajoutez également d'autres conditions de filtrage.

        SELECT ST_AsHMT(column_name, --geometry type
            ST_MakeEnvelope(0, 0, 10, 10, 4326), -- Extent
            512,        -- Width
            512,        -- height
            value       -- value column
        )
        FROM table_name
        WHERE column_name && ST_MakeEnvelope(0, 0, 10, 10, 4326);
        AND name like 'xxxx%' AND value > 100;
  2. Cet exemple utilise Node.js pour écrire une application simple illustrant un cas d'usage concret des tuiles de carte thermique.

    La structure des fichiers est la suivante :

    └── hmt_server
        ├── app.js
        ├── hmt.proto
        ├── index.html
        └── package.json

    Ici, hmt.proto est le fichier proto décrit dans ST_AsHMT. Le contenu des autres fichiers est fourni ci-dessous.

    Les fichiers de code backend, package.json et app.js, sont les suivants :

    • package.json :

      {
        "name": "hmt_server",
        "version": "1.0.0",
        "main": "app.js",
        "license": "ISC",
        "dependencies": {
          "chroma-js": "^2.4.2",
          "express": "^4.18.2",
          "lru-cache": "^10.1.0",
          "pg": "^8.11.3",
          "protobufjs": "^7.2.5",
          "sharp": "^0.32.6"
        }
      }
    • app.js :

      const express = require('express');
      const { Pool } = require('pg');
      const chroma = require('chroma-js');
      const sharp = require("sharp");
      const protobuf = require('protobufjs');
      const { LRUCache } = require('lru-cache');
      
      // Set the database connection
      const CONNECTION = {
        user: 'YOUR_USER',
        password: 'YOUR_PWD',
        host: 'YOUR_HOST',
        database: 'YOUR_DB',
        port: YOUR_PORT
      };
      
      // Target table name
      const TABLE_NAME = 'YOUR_TABLE';
      
      // Target geometry field name
      const GEOMETRY_COLUMN = 'YOUR_GEOM_COLUMN';
      
      // Set the no-data value
      const NO_DATA_VALUE = 0;
      
      // Spatial reference of the target geometry field
      const SRID = 4326
      
      // Set the color ramp
      const COLOR_MAP = [
        ['#536edb', 1],
        ['#5d96a5', 3],
        ['#68be70', 5],
        ['#91d54d', 7],
        ['#cddf37', 9],
        ['#fede28', 11],
        ['#fda938', 13],
        ['#fb7447', 15],
        ['#f75a40', 17],
        ['#f24734', 19],
        ['#e9352a', 21],
        ['#da2723', 23],
        ['#cb181d', 25]
      ];
      
      // Create a database connection pool, default is 10 connections
      const pool = new Pool(CONNECTION);
      
      // Configure color transformation
      const [colors, domains] = COLOR_MAP.reduce(([c, d], [colors, domains]) =>
        [[...c, colors], [...d, domains]], [[], []]);
      const colorMap = chroma.scale(colors).domain(domains).mode('rgb')
      
      // Load protobuf
      const hmtDecoder = protobuf.loadSync('./hmt.proto').lookupType('HMT');
      
      // Create a 1x1 transparent PNG to return as an empty tile
      const emptyPng = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAADUlEQVQImWP4//8/AwAI/AL+hc2rNAAAAABJRU5ErkJggg==', 'base64');
      
      // For small-scale tiles (z<5), where updates are less frequent, set a 24-hour cache expiration
      const globalCache = new LRUCache({ max: 1000, ttl: 1000 * 3600 * 24 });
      
      // For larger-scale tiles (z>=5), set a 12-hour cache expiration. You can modify this as needed.
      const localCache = new LRUCache({ max: 2000, ttl: 1000 * 3600 * 12 });
      
      // Register Express routes
      express()
        // Respond with the HTML page
        .get("/", (_, res) => res.sendFile('index.html', { root: __dirname }))
        // Respond to the heatmap tile service
        .get('/hmt/:z/:x/:y', async ({ params: { z, x, y } }, res) => {
          const cache = z < 5 ? globalCache : localCache;
          const key = `${z},${x},${y}`
          if (!cache.has(key)) {
            // Set the degree of parallelism, call the ST_AsHMT function, and request a 256x256 heatmap tile for the area
            const parallel = z <= 5 ? 10 : 5;
            const sql = `
        set max_parallel_workers = ${parallel};
        set max_parallel_workers_per_gather = ${parallel};
        WITH _PARAMS(_BORDER) as (VALUES(ST_Transform(ST_TileEnvelope(${key}),${SRID})))
        SELECT ST_AsHMT(${GEOMETRY_COLUMN},_BORDER,256,256) tile
        FROM ${TABLE_NAME},_PARAMS
        WHERE _BORDER && ${GEOMETRY_COLUMN};`
            // Skip the set statements and get the result of the ST_AsHMT function
            const { rows: [{ tile }] } = (await pool.query(sql))[2];
      
            // If there is no data in the area, return an empty tile directly
            if (!tile) cache.set(key, emptyPng);
            else {
              // Parse the protobuf result
              const { type, doubleValues, intValues } = hmtDecoder.decode(tile);
              const { values } = type == 1 ? doubleValues : intValues;
      
              // Convert numerical values to corresponding colors and remove no-data values
              const pixels = values.reduce((_pixels, value) => {
                _pixels.push(...colorMap(value).rgb());
                _pixels.push(value <= NO_DATA_VALUE ? 0 : 255);
                return _pixels;
              }, [])
      
              // Render as a PNG tile
              const rawConfig = { raw: { width: 256, height: 256, channels: 4 } };
              const renderedPng = await sharp(Uint8Array.from(pixels), rawConfig)
                .png().toBuffer();
              cache.set(key, renderedPng);
            }
          }
          const tile = cache.get(key)
          res.set("Content-Type", "image/png").send(tile);
        })
        // Listen on port 5500
        .listen(5500, () => console.log('HMT server started.'));

      Où :

      • Le dégradé de couleurs est continu et prend en charge divers formats, tels que les chaînes de couleurs hexadécimales et les noms de couleurs CSS3. Pour plus d'informations, consultez la documentation chroma.js.

      • Si vous souhaitez un rendu de tuile plus fluide, demandez des données brutes de 512 × 512, puis sous-échantillonnez-les à une résolution de 256 × 256. Toutefois, cela augmente le temps de réponse.

      • Ajustez le degré de parallélisme en fonction du volume de données, de la configuration du cluster de base de données et des exigences en matière de vitesse de réponse.

        Remarque

        Dans cet exemple, le degré de parallélisme est judicieusement réduit lorsque Z <= 5.

    • Le code frontend, index.html, utilise Mapbox comme SDK de cartographie frontend. Demandez et consultez votre token ici.

      Étant donné que les tuiles de carte thermique sont finalement rendues au format PNG, elles sont compatibles avec la plupart des SDK de cartographie.

      <!DOCTYPE html>
      <html>
      <head>
        <meta charset="utf-8">
        <title>HMT Viewer</title>
        <meta name="viewport" content="initial-scale=1,maximum-scale=1,user-scalable=no">
        <link href="https://api.mapbox.com/mapbox-gl-js/v2.14.1/mapbox-gl.css" rel="stylesheet">
        <script src="https://api.mapbox.com/mapbox-gl-js/v2.14.1/mapbox-gl.js"></script>
      </head>
      <body>
        <div id="map" style="position: absolute;left:0; top: 0; bottom: 0; width: 100%;"></div>
        <script>
          let CENTER = [YOUR_LONGITUDE, YOUR_LATITUDE]
          mapboxgl.accessToken = YOUR_MAPBOX_TOKEN;
          const map = new mapboxgl.Map({
            container: 'map',
            style: "mapbox://styles/mapbox/navigation-night-v1",
            center: CENTER,
            zoom: 5
          })
          map.on("load", () => {
            map.addSource('hmt_source', {
              type: 'raster',
              minzoom: 3,
              tiles: [`${window.location.href}hmt/{z}/{x}/{y}`],
              tileSize: 256,
            });
            map.addLayer({
              id: 'hmt',
              type: 'raster',
              source: 'hmt_source',
            });
          });
        </script>
      </body>
      </html>
  3. Installez et déployez l'application.

    ## Navigate to the hmt_server directory
    cd ./hmt_server
    ## Install dependency libraries
    npm i
    ## Run the heatmap tile service
    node .
    ## You can now open a browser and go to http://localhost:5500/ to see the result
  4. Aperçu

    • Agrégation en temps réel des trajectoires de navires

      Agrégation en temps réel de 31 millions de points de trajectoire et de 450 000 lignes de trajectoire.

      船舶轨迹线-1

      传播轨迹线-2

    • Agrégation en temps réel des emprises au sol des bâtiments

      Agrégation en temps réel de 308 millions d'emprises au sol de bâtiments.

      建筑底面

Résumé

GanosBase prend en charge des milliers de scénarios d'application dans des dizaines de secteurs industriels. La stabilité, le rapport qualité-prix, les performances et la simplicité d'utilisation ont toujours été les objectifs à long terme de GanosBase. HMT constitue une compétence centrale de GanosBase pour l'agrégation efficace et la visualisation de données spatiales à grande échelle. Elle offre une solution performante et facile à utiliser pour l'analyse et l'exploration de données massives. Nous vous invitons à l'essayer.

Essai gratuit

Visitez la page Essai gratuit PolarDB et sélectionnez la base de données cloud-native PolarDB for PostgreSQL pour découvrir la fonctionnalité de requête statistique de carte thermique en temps réel HMT de GanosBase.