GanosBase intègre un moteur de grille géospatiale fondé sur le système de grille hexagonale hiérarchique H3. Encodez, interrogez, agrégez et visualisez des données ponctuelles spatiales à grande échelle directement dans la base de données, sans recourir à des intergiciels externes ni à des pipelines de prétraitement.
Contexte
Une grille géographique divise la surface terrestre en cellules polygonales à plusieurs échelles, du plus grossier au plus fin. Chaque cellule reçoit un code unique, ce qui permet de représenter, d'indexer et de joindre des entités spatiales avec d'autres données spatio-temporelles. Les grilles géographiques tridimensionnelles prennent en compte non seulement la latitude et la longitude, mais incluent également l'altitude dans la plage de subdivision et d'encodage.
GanosBase prend en charge deux systèmes de grille :
GeoSOT : Système d'identification de localisation régionale multi-échelle basé sur la théorie de la subdivision géospatiale développée en Chine.
H3 : Système de grille hexagonale globale bidimensionnelle développé par Uber. H3 couvre la surface terrestre avec une structure hexagonale unifiée et multicouche.
Les cellules hexagonales de H3 possèdent trois propriétés qui les rendent particulièrement adaptées à l'analyse spatiale : une distance uniforme entre voisins, des relations fixes à six voisins et l'absence de biais directionnel. Ces propriétés simplifient la planification d'itinéraires, le géocodage, le géorepérage (geofencing) et l'analyse de densité par rapport aux systèmes de grille carrés ou triangulaires.
GanosBase étend H3 avec le calcul de grille dégénérée, qui exprime une plage spatiale en utilisant l'ensemble minimal de cellules de grille sur plusieurs niveaux de hiérarchie, réduisant ainsi les coûts de stockage de l'encodage. GanosBase fournit également un index de grille développé en interne pour des requêtes efficaces sur les codes de grille et des calculs d'agrégation.

Cas d'utilisation
Les grilles H3 sont utilisées dans diverses charges de travail de données spatiales :
Logistique et services de voyage : Planification d'itinéraires, analyse de la couverture zonale, délimitation des zones de livraison et découverte de points chauds.
Analyse de données : Analyse de la densité de population, analyse du comportement des utilisateurs mobiles et segmentation géographique du marché.
Internet des objets (IoT) : Analyse de la distribution spatiale des données de surveillance dans les scénarios de ville intelligente, de surveillance environnementale et de suivi des actifs.
Réseaux sociaux : Services basés sur la localisation (LBS), partage de la position des amis et notifications d'événements.
Intervention d'urgence et services publics : Analyse de la répartition des catastrophes, cartes thermiques pour l'alerte précoce, allocation des ressources d'urgence et délimitation des zones de secours.
Fonctionnalités
GanosBase H3 prend en charge les opérations suivantes :
Encoder des points, des lignes et des polygones sous forme de codes de grille H3
Décoder les codes de grille pour retrouver la géométrie spatiale
Déterminer les relations parent-enfant entre les grilles
Calculer la distance et le parcours des chemins de grille
Interroger les grilles par plage spatiale, niveau ou proximité
Convertir les codes de grille H3 en type Geometry de GanosBase pour l'analyse spatiale avec des données vectorielles
Exécuter des statistiques pixel en combinant les grilles H3 avec des données raster
Appliquer le calcul de grille dégénérée pour minimiser le stockage de l'encodage
Pour la référence complète des fonctions, consultez Référence SQL GeomGrid.
Avantages techniques
GanosBase H3 offre plusieurs capacités allant au-delà de la bibliothèque H3 open source :
Types d'entrée d'encodage plus riches : Encodez directement les types de géométrie Point, LineString et Polygon de GanosBase en codes de grille H3, et pas seulement les coordonnées latitude/longitude.
Optimisation des performances : Débit d'encodage et efficacité des requêtes de grille optimisés pour les grands ensembles de données.
Analyse de requêtes inter-modèles : Joignez les grilles H3 à d'autres modèles spatiaux de GanosBase, tels que la conversion de la géométrie en encodage H3 ou l'exécution de statistiques pixel sur des données raster.
Stockage hiérarchisé pour les données à grande échelle : Tire parti du stockage hiérarchisé polymorphe de PolarDB pour encoder et stocker des données ponctuelles à grande échelle dans Object Storage Service (OSS), réduisant considérablement les coûts de stockage.
Bonnes pratiques
Cette rubrique décrit un flux de travail complet pour le stockage, l'encodage, l'interrogation et la visualisation de données ponctuelles spatiales à l'aide de GanosBase H3. L'ensemble de données utilisé est le jeu de données FOIL (Freedom of Information Law) des prises en charge de taxis à New York en 2023 d'Uber.
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
Un cluster PolarDB avec GanosBase activé
Un compartiment OSS contenant les données CSV FOIL
Des identifiants de base de données avec l'autorisation de créer des extensions et des tables
Importer les données
Étape 1 : Installez l'extension GeomGrid.
CREATE EXTENSION ganos_geomgrid CASCADE;
Étape 2 : Créez une table avec le type de champ h3grid.
GeomGrid fournit le type h3grid pour stocker les codes de grille H3. Le champ h3_lev13 stocke les codes H3 de niveau 13. Différents niveaux H3 correspondent à différentes résolutions spatiales ; choisissez le niveau qui correspond à la granularité de votre analyse. Pour connaître la résolution spatiale correspondant à chaque niveau de H3, consultez le tableau des résolutions H3.
-- h3_lev13 stores level-13 H3 codes
CREATE TABLE FOIL2013 (
id text,
lon float,
lat float,
h3_lev13 h3grid
);
Étape 3 : Installez l'extension FDW et chargez les données CSV depuis OSS.
GanosBase FDW (foreign data wrapper) vous permet d'interroger les fichiers CSV sur OSS comme s'il s'agissait de tables locales, puis d'insérer les résultats directement.
-
Installez l'extension FDW.
CREATE EXTENSION ganos_fdw CASCADE; -
Créez un serveur pointant vers le fichier CSV sur OSS. Remplacez les espaces réservés par vos identifiants et votre chemin réels. Pour le format
datasource, consultez Chemin de fichier dans OSS.CREATE SERVER csvserver FOREIGN DATA WRAPPER ganos_fdw OPTIONS ( datasource 'OSS://<access_id>:<secrect_key>@[<Endpoint>]/<bucket>/path_to/file.csv', format 'CSV' ); CREATE USER MAPPING FOR CURRENT_USER SERVER csvserver OPTIONS (user '<access_id>', password '<secrect_key>'); -
Mappez le fichier CSV à une table étrangère. Les colonnes
medallion,pickup_longitudeetpickup_latitudesont mappées à la table étrangèretrip_data_1.CREATE FOREIGN TABLE trip_data_1 ( medallion varchar, pickup_longitude varchar, pickup_latitude varchar) SERVER csvserver OPTIONS ( layer 'trip_data_1' ); -
Vérifiez que la table étrangère est accessible.
SELECT * FROM trip_data_1; -
Insérez les données dans
FOIL2013.INSERT INTO FOIL2013 SELECT medallion AS id, CAST(pickup_longitude AS double precision) AS lon, CAST(pickup_latitude AS double precision) AS lat FROM trip_data_1; -
Vérifiez l'importation.
SELECT * FROM FOIL2013;
Encoder les points en codes de grille H3
GanosBase H3 prend en charge plusieurs méthodes d'encodage :
| Fonction | Entrée | À utiliser lorsque |
|---|---|---|
| ST_H3FromLatLng | Latitude, longitude, niveau | Encodage de coordonnées brutes |
| ST_H3FromText | Chaîne H3 standard | Importation de chaînes H3 existantes |
| ST_H3FromInt | Encodage H3 entier | Utilisation d'ID H3 au format entier |
| ST_AsH3Grid | Géométrie de point | Conversion directe depuis le type Point de GanosBase |
Cet exemple utilise ST_H3FromLatLng pour générer des codes H3 de niveau 13 à partir des colonnes lat et lon, puis stocke le résultat dans h3_lev13.
-- Generate level-13 H3 codes from lat/lon
UPDATE FOIL2013 SET h3_lev13 = ST_H3FromLatLng(lat, lon, 13);
-- Verify: display H3 codes as text
SELECT id, lon, lat, ST_AsText(h3_lev13) AS h3
FROM FOIL2013
LIMIT 100;
Agréger les données de grille
Les grilles H3 sont bien adaptées à l'agrégation spatiale, permettant de regrouper les points par cellule de grille pour générer des cartes thermiques et des cartes thématiques. L'exemple suivant compte les prises en charge de taxis par cellule de grille au niveau 13.
-- Count points per H3 cell and store results
CREATE TABLE h3_count_lev13 AS
SELECT ST_AsText(h3_lev13) AS h3code, COUNT(*) AS count
FROM FOIL2013
GROUP BY h3_lev13;
-- Query the top cells by pickup count
SELECT ST_AsText(h3_lev13), ST_AsText(geometry), count
FROM h3_count_lev13
ORDER BY count DESC;
Interroger par proximité de grille
Utilisez ST_GridDistance pour filtrer les points en fonction du nombre de pas de grille qui les séparent d'une cible. La requête suivante renvoie tous les points de prise en charge situés à moins de 10 pas de grille des coordonnées (40.71481749, -73.99100368) au niveau 13.
SELECT *
FROM foil2013
WHERE ST_GridDistance(
ST_H3FromLatLng(40.71481749, -73.99100368, 13),
h3_lev13
) < 10;
La distance de grille compte le nombre de sauts de cellule entre deux cellules H3 au même niveau, et non la distance euclidienne.
Visualiser les grilles H3
GanosBase peut servir les grilles H3 sous forme de tuiles vectorielles Mapbox (MVT) directement depuis la base de données. Un backend Python interroge la base de données pour la zone visible actuelle de la carte et diffuse les tuiles vectorielles vers un navigateur, sans nécessiter de serveur de tuiles distinct.
GanosBase prend également en charge la génération dynamique de grilles H3 au moment de la visualisation. Par exemple, si une table stocke des données de niveau 13 mais que la carte demande des tuiles de niveau 10, utilisez ST_AsMVTGeom(ST_H3FromLatLng(lat, lon, 10), ...) pour les générer à la volée. Les grilles précalculées sont plus rapides ; la génération dynamique évite de stocker plusieurs niveaux de grille.
Les étapes ci-dessous utilisent des grilles précalculées issues de h3_count_lev13.
Étape 1 : Créez un index de grille pour accélérer les requêtes de tuiles.
CREATE INDEX ON h3_count_lev13 USING GIST(h3_lev13);
Étape 2 : Interrogez les tuiles vectorielles par coordonnées de tuile.
La requête suivante renvoie la MVT pour la tuile (z=14, x=4826, y=6157). Les coordonnées de la tuile proviennent du frontend de la carte en fonction de la zone visible de l'utilisateur et du niveau de zoom.
SELECT ST_AsMVT(tile)
FROM (
SELECT ST_AsMVTGeom(
h3_lev13,
ST_Transform(ST_TileEnvelope(14, 4826, 6157), 4326)
) AS grid,
count
FROM h3_count_lev13
WHERE h3_lev13 && ST_Transform(ST_TileEnvelope(14, 4826, 6157), 4326)
) AS tile;
Étape 3 : Exécutez le frontend.
Le frontend de visualisation utilise un backend Python (Quart + asyncpg) et une page HTML avec Mapbox GL JS. Démarrez le script Python, puis ouvrez localhost:5100 dans un navigateur. Le script génère dynamiquement le SQL de requête de tuile à partir de la position actuelle et du niveau de zoom de la carte, et colore chaque cellule selon le nombre de prises en charge.

Le frontend nécessite un jeton d'accès Mapbox. RemplacezYOUR_TOKENdansindex.htmlpar votre propre jeton.
Conclusion
La grille géographique est essentielle pour les scénarios d'application liés aux objets mobiles, offrant une valeur commerciale significative lorsqu'elle est intégrée à des types de données tels que les trajectoires, les vecteurs et les rasters. En tant que première base de données au monde à prendre en charge les objets mobiles (MOD), GanosBase a validé ses capacités de grille géospatiale auprès de clients dans des secteurs tels que les transports, la logistique, le voyage et l'automobile. Par rapport aux implémentations traditionnelles via intergiciels ou code métier, GanosBase fournit un cadre de traitement spatio-temporel pour les objets mobiles à grande échelle au niveau du système de base de données, améliorant considérablement l'efficacité du calcul et réduisant les coûts globaux.
Annexe
Le code suivant fournit une implémentation frontend complète pour la visualisation des grilles H3.
Backend Python (app.py)
from quart import Quart, send_file, render_template
import asyncpg
import io
import re
## Database connection parameters
CONNECTION = {"host": "YOUR-HOST-NAME-OR-IP", "port": PORT_NO, "database": "DATABASE_NAME",
"user": "USER_NAME", "password": "PASSWORD"}
## Target table name/field/ID
TABLE = "h3_count_lev13"
H3_COL = "h3_lev13"
H3_GEOM_COL = "geometry"
AGG_VAL_COL = "count"
COL_SRID = 4326
app = Quart(__name__, template_folder='./')
@app.before_serving
async def create_db_pool():
app.db_pool = await asyncpg.create_pool(**CONNECTION)
@app.after_serving
async def close_db_pool():
await app.db_pool.close()
@app.route("/")
async def home():
sql = f'''
SELECT ST_Extent(ST_Transform(ST_Envelope({H3_GEOM_COL}), 4326))
FROM {TABLE};
'''
async with app.db_pool.acquire() as connection:
box = await connection.fetchval(sql)
box = re.findall('BOX\((.*?) (.*?),(.*?) (.*?)\)', box)[0]
min_x, min_y, max_x, max_y = list(map(float, box))
bounds = [[min_x, min_y], [max_x, max_y]]
center = [(min_x + max_x) / 2, (min_y + max_y) / 2]
return await render_template('./index.html', center=str(center), bounds=str(bounds))
@app.route("/h3_mvt/<int:z>/<int:x>/<int:y>")
async def h3_mvt(z, x, y):
sql = f'''
SELECT ST_AsMVT(tile.*)
FROM
(SELECT ST_AsMVTGeom({H3_COL}, ST_Transform(ST_TileEnvelope($1,$2,$3),{COL_SRID}), 4096, 512, true) geometry,
{AGG_VAL_COL} count
FROM {TABLE}
WHERE ({H3_COL} && ST_Transform(ST_TileEnvelope($1,$2,$3),{COL_SRID}))) tile'''
async with app.db_pool.acquire() as connection:
tile = await connection.fetchval(sql, z, x, y)
return await send_file(io.BytesIO(tile), mimetype='application/vnd.mapbox-vector-tile')
if __name__ == "__main__":
app.run(port=5100)
Frontend HTML (index.html)
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>map 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>
<script src="https://cdnjs.cloudflare.com/ajax/libs/chroma-js/2.4.2/chroma.min.js"></script>
</head>
<body>
<div id="map" style="position: absolute;left:0; top: 0; bottom: 0; width: 100%;cursor:pointer;"></div>
<div class="counter"
style="position: absolute;left:2%;font-size: 20px;padding: .1em .1em;text-shadow: 3px 3px 3px black;">
<span>Current grid count:</span>
<span id="count">0</span>
</div>
<script>
let YOUR_TOKEN = "pk.eyJ1Ijoia3pmaWxlIiwiYSI6ImNqbHZueXdlZjB2cG4zdnFucGl1OHJsMjkifQ.kW_Utrh8ETQltRk6fnpa_A"
mapboxgl.accessToken = YOUR_TOKEN;
const map = new mapboxgl.Map({
container: "map",
style: "mapbox://styles/mapbox/navigation-night-v1",
center: {{ center }},
zoom: 1
})
map.on("load", () => {
map.fitBounds({{ bounds }})
map.on('mousemove', 'h3', (e) => {
map.getCanvas().style.cursor = "default";
if (e.features.length > 0)
document.getElementById('count').innerText = e.features[0].properties.count
})
map.on('mouseleave', 'h3', () => {
map.getCanvas().style.cursor = "grab";
document.getElementById('count').innerText = 0
})
map.addSource("h3_source", {
type: "vector",
tiles: [`${window.location.href}h3_mvt/{z}/{x}/{y}`],
tileSize: 512
});
// make color map
const MIN = 1
const MAX = 600
const STEP = 10
color_map = chroma.scale(["#536edb", "#5d96a5", "#68be70", "#91d54d", "#cddf37", "#fede28", "#fda938", "#fb7447", "#f75a40", "#f24734", "#e9352a", "#da2723", "#cb181d"])
.domain([MIN, MAX]);
let colors = []
for (let i = MIN; i < MAX; i += STEP)
colors.push(color_map(i).hex(), i)
colors.push(color_map(MAX).hex())
map.addLayer({
id: "h3",
type: "fill",
source: "h3_source",
"source-layer": "default",
paint: {
"fill-color": [
"step", ["get", "count"],
...colors
],
"fill-opacity": 0.8
}
});
});
</script>
</body>
</html>