Le moteur de grille géographique GeoSOT de GanosBase permet la planification de trajectoires 3D par grille pour les applications de drones (UAV). Cette fonctionnalité s'applique aux environnements modélisés à l'aide de modèles numériques d'élévation (MNE), de modèles numériques de surface (MNS) et de photographies obliques.
Concepts clés
Une grille géographique divise la surface terrestre en une hiérarchie de cellules polygonales. Chaque cellule possède un identifiant unique permettant le positionnement spatial et l'attribution d'attributs dans un cadre cohérent. La variante 3D étend cet encodage à la dimension de hauteur, en plus de la latitude et de la longitude.
GanosBase prend en charge deux types de grilles géographiques :
GeoSOT — Système discret d'identification de localisation multi-échelle, développé à partir d'une théorie chinoise de subdivision terrestre. Ce guide l'utilise pour la planification de trajectoires 3D.
H3 — Grille hexagonale bidimensionnelle développée par Uber. Pour plus de détails, consultez la documentation sur les capacités de la grille géographique H3.
GanosBase gère également le calcul de grilles dégénérées. Cette méthode utilise des combinaisons compactes de grilles pour représenter efficacement des étendues spatiales. L'index de grille géographique intégré accélère les requêtes d'encodage de grille et les agrégations.

Fonctionnement
Le pipeline de planification de trajectoire comprend cinq étapes. Chacune fait appel à des fonctions spécifiques de GanosBase :
| Étape | Description | Fonctions principales |
|---|---|---|
| 1. Importation | Chargement des données de photographie oblique OSGB depuis OSS vers PolarDB | ST_ImportOSGB |
| 2. Conversion | Conversion des tuiles au format GLB via un type intermédiaire SfMesh | ST_ImportGLB, ST_AsGLB, ST_YupToZup, ST_Translate, ST_SetSrid, ST_Flatten, ST_Transform |
| 3. Construction de la grille | Encodage de la géométrie sous forme de tableau d'obstacles GeomGrid | ST_As3DGrid |
| 4. Attribution des coûts | Définition des coûts de déplacement pour les zones infranchissables et les zones à risque | ST_SetCost, ST_CostUnion, ST_MatchGridLevel |
| 5. Planification de la trajectoire | Calcul de la trajectoire optimale en grille 3D entre deux points | ST_3DGridPath |
Fonctions principales
ST_SetCost
Définit le coût de déplacement pour un tableau de grilles représentant un obstacle. Les obstacles peuvent être des structures physiques (comme des bâtiments) ou des contraintes spatiales (telles que des zones de balayage radar ou des champs de vent). Avant d'appeler cette fonction, convertissez l'étendue spatiale de l'obstacle en un tableau de grilles.
Conventions de coût :
-1— infranchissable (blocage absolu)1— franchissable par défaut (aucune pénalité)Tout entier positif supérieur à 1 — franchissable avec pénalité (utilisé pour les zones à risque)
Lorsqu'une grille de zone à risque chevauche une grille infranchissable, le coût infranchissable est prioritaire.
ST_3DGridPath
Calcule la trajectoire optimale en grille 3D entre un point de départ et un point d'arrivée, à partir d'une boîte englobante et d'un tableau de jeux de grilles avec coûts assignés. Cette fonction prend en charge plusieurs algorithmes de cheminement, modes de déplacement et méthodes de calcul de distance.
Paramètres utilisés dans l'exemple :
algorithm:astar(algorithme A*)movement:crossoustrict_octothorpedistance:euclidean
Toutes les géométries fournies à ST_3DGridPath ainsi que les requêtes de filtrage de grille doivent utiliser le système de référence spatiale EPSG:4490.
ST_MatchGridLevel
Détermine le niveau de grille maximal adapté à la résolution de vos données d'élévation du terrain. N'utilisez pas un niveau de grille supérieur à cette valeur dans les calculs de trajectoire, car cela dépasserait la précision des données sous-jacentes.
ST_CostUnion
Fusionne plusieurs tableaux de coûts de grilles d'obstacles en une seule entrée pour la planification de trajectoire. En cas de chevauchement de grilles, le coût maximal s'applique.
Référence des niveaux de grille
La fonction ST_As3DGrid accepte un paramètre de niveau de grille qui contrôle la résolution spatiale. Des niveaux plus élevés produisent des grilles plus fines, mais augmentent considérablement le temps de traitement.
| Niveau | Taille approximative | Niveau | Taille approximative | Niveau | Taille approximative |
|---|---|---|---|---|---|
| 0 | Globe entier | 11 | 29,6 km | 22 | 15,5 m |
| 1 | 1/4 de la Terre | 12 | 14,8 km | 23 | 7,7 m |
| 2 | — | 13 | 7,4 km | 24 | 3,9 m |
| 3 | — | 14 | 3,7 km | 25 | 1,9 m |
| 4 | — | 15 | 1,8 km | 26 | 1,0 m |
| 5 | — | 16 | 989,5 m | 27 | 0,5 m |
| 6 | 890,5 km | 17 | 494,7 m | 28 | 24,2 cm |
| 7 | 445,3 km | 18 | 247,4 m | 29 | 12,0 cm |
| 8 | 222,6 km | 19 | 123,7 m | 30 | 6,0 cm |
| 9 | 111,3 km | 20 | 61,8 m | 31 | 3,0 cm |
| 10 | 59,2 km | 21 | 30,9 m | 32 | 1,5 cm |
Appelez toujours ST_MatchGridLevel pour confirmer le niveau maximal utilisable pour vos données de terrain avant de lancer les calculs de trajectoire.
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
-
Un cluster PolarDB for PostgreSQL (Compatible with Oracle) 2.0 répondant aux spécifications minimales suivantes :
Version du moteur : 2.0.14.23.1
CPU : 4 cœurs ou plus
Mémoire : 16 Go ou plus (plus de 16 Go recommandés pour l'importation et le traitement OSGB)
Disque : 100 Go ou plus
Version de GanosBase : 6,7 ou ultérieure
Des données de photographie oblique OSGB téléchargées dans un bucket Object Storage Service (OSS)
Les données obliques originales doivent inclure un fichier
metadata.xmlcomplet afin de permettre la récupération du point d'ancrage et du système de référence de coordonnées lors de l'importation
Planifier une trajectoire 3D pour drone
Cette section illustre la planification de trajectoire 3D à partir de données de photographie oblique d'un parc.
Données de test

Étape 1 : Installer les extensions
Installez les extensions requises. Si une instruction échoue, contactez le support pour obtenir de l'aide.
CREATE EXTENSION IF NOT EXISTS ganos_geomgrid CASCADE;
CREATE EXTENSION IF NOT EXISTS ganos_utility CASCADE;
Étape 2 : Importer les données OSGB
Importez les données de photographie oblique stockées dans OSS à l'aide de ST_ImportOSGB. Pour la référence complète de la fonction, consultez ST_ImportOSGB.
SELECT
ST_ImportOSGB(
'test_oblique',
'OSS://<access_id>:<secret_key>@<Endpoint>/<bucket>/path_to/file',
'{"parallel":16,"project":"building"}');
Remplacez les espaces réservés suivants :
| Espace réservé | Description |
|---|---|
<access_id> |
Votre AccessKey ID Alibaba Cloud |
<secret_key> |
Votre AccessKey Secret Alibaba Cloud |
<Endpoint> |
L'endpoint OSS de votre région |
<bucket> |
Le nom du bucket OSS |
Étape 3 : Convertir les tuiles en GLB
Convertissez les tuiles du niveau de détail (LOD) cible au format GLB en utilisant SfMesh comme type intermédiaire, puis stockez le résultat dans une table temporaire.
SELECT
ST_ImportGLB(
'temp_glb',
ST_AsGLB(ST_Combine(tile)),
'temp_glb_1',
'{"ignore_texture":true,"ignore_normal":true}'
)
FROM test_oblique_tile WHERE lod = 19 AND project_name = 'building';
Définissezignore_textureetignore_normalàtruepour ignorer les données inutiles lors de la construction de la grille.
lod = 19 sélectionne les tuiles au niveau de détail 19. Ajustez cette valeur selon vos données. Des valeurs LOD plus élevées produisent des résultats plus précis, mais augmentent le temps de traitement.
Cet exemple utilise la convention de nommage standard des fichiers OSGB (par exemple,Tile_+006_+004_L14_0.osgb), où le LOD peut être extrait du nom de fichier. Si vos données utilisent une convention non standard, remplacezWHERE lod = 19parWHERE children IS NULLafin de sélectionner les nœuds feuilles offrant la précision la plus élevée.
Étape 4 : Reprojeter les coordonnées vers EPSG:4490
Les données de photographie oblique utilisent généralement des coordonnées relatives ancrées à une origine locale. Cette étape applique les coordonnées absolues correctes, établit le système de référence spatiale CGC 2000 (EPSG:4490) et pré-aplatit les matrices de rotation.
UPDATE temp_glb
SET
gltf_data = ST_Transform(
ST_Flatten(
ST_SetSrid(
ST_Translate(
ST_YupToZup(gltf_data),
x_off, y_off, z_off),
srid),
FALSE),
4490)
FROM
(SELECT
srid,
ST_X(anchor) x_off,
ST_Y(anchor) y_off,
ST_Z(anchor) z_off
FROM test_oblique WHERE project_name = 'building') metadata
WHERE gltf_id = 'temp_glb_1';
Cette instruction exécute séquentiellement les opérations suivantes :
ST_YupToZup — Le format OSGB utilise l'axe Y comme référence verticale. Cette fonction réoriente le repère de coordonnées vers Z-up avant toute autre transformation.
ST_Translate — Applique le décalage du point d'ancrage pour convertir toutes les coordonnées relatives en coordonnées absolues.
ST_SetSrid — Attribue l'identifiant du système de référence spatiale correct à partir des métadonnées.
ST_Flatten — Applique les matrices de rotation intégrées aux coordonnées réelles des sommets, ce qui est nécessaire avant la reprojection.
ST_Transform — Reprojette tous les points vers EPSG:4490, le système de référence de coordonnées utilisé par les grilles GeoSOT.
Cette opération nécessite que les données obliques originales incluent un fichier metadata.xml complet. Sans celui-ci, le point d'ancrage et le système de référence spatiale ne peuvent pas être récupérés.
Étape 5 : Construire la grille d'obstacles
Convertissez la géométrie en un tableau GeomGrid et stockez-le dans la table de grille. Supprimez la table GLB temporaire une fois l'opération terminée.
-- Create the grid table
CREATE TABLE IF NOT EXISTS building_grid
(
id SERIAL,
grid GEOMGRID,
grid_type TEXT
);
-- Generate GeomGrid data and insert into the grid table
INSERT INTO building_grid (grid, grid_type)
SELECT grid, 'border'
FROM
(SELECT unnest(ST_As3DGrid(gltf_data, 24, TRUE)) grid
FROM temp_glb WHERE gltf_id = 'temp_glb_1') tmp;
-- Remove the temporary table
DROP TABLE temp_glb;
Le second argument de ST_As3DGrid définit le niveau de grille. Le niveau 24 (~3,9 m par cellule) est utilisé ici. Consultez la Référence des niveaux de grille pour le tableau complet des tailles.
Vérification : Prévisualiser la géométrie de la grille
Exportez la grille au format GLB pour vérifier la forme des obstacles avant de lancer la planification de trajectoire.
SELECT
ST_AsGLB(
ST_ZupToYup(
ST_3DRemoveDuplicateVertex(
ST_MergeGeomByMaterial(
ST_Triangulate(
ST_Translate(
ST_Transform(
ST_Flatten(
ST_Collect(
ST_AsMeshgeom(array (SELECT grid FROM building_grid WHERE grid_type = 'border')):: sfmesh[]),
TRUE
),
srid
),
- ST_X(anchor), - ST_Y(anchor), - ST_Z(anchor)
)
)
),
0.1
)
)
)
FROM test_oblique WHERE project_name = 'building';
Cette instruction effectue les opérations suivantes :
Convertit le tableau de grilles en un tableau MeshGeom via ST_AsMeshGeom, puis combine tous les éléments en un seul SfMesh avec ST_Collect.
Applique un pré-aplatissement avec
ST_Flattenet reprojette vers le système de coordonnées d'origine avec ST_Transform.Décale les coordonnées vers une origine locale à l'aide de ST_Translate.
Triangule le maillage avec ST_Triangulate et réduit le volume de données grâce à
ST_MergeGeomByMaterialet ST_3DRemoveDuplicateVertex.Convertit le repère de coordonnées Z-up vers Y-up (conformément aux exigences glTF) avec ST_ZupToYup, puis exporte au format GLB via ST_AsGLB.
Le tableau suivant compare la sortie de grille à deux niveaux différents.
| Niveau | Résultat |
|---|---|
| Données brutes | ![]() |
| Niveau 25 | ![]() |
| Niveau 24 | ![]() |
Visualiser les grilles dans Cesium
Utilisez la fonction utilitaire GridToJson pour générer des données de grille compatibles avec Cesium.
-- Create the helper function
CREATE OR REPLACE FUNCTION GridToJson(geomgrid[])
RETURNS json AS $$
SELECT to_json(
array_agg(
json_build_object('center', array_to_json(array[ST_X(center), ST_Y(center), ST_Z(center)]),
'size', array_to_json(array[ST_DistanceSpheroid(min_point, ST_Point(ST_X(max_point), ST_Y(min_point), 4490)), ST_DistanceSpheroid(min_point, ST_Point(ST_X(min_point), ST_Y(max_point), 4490)), z]))))
FROM
(SELECT ST_Transform(ST_PointZ(ST_X(st_centroid(geom)), ST_Y(st_centroid(geom)), (ST_ZMax(geom) + ST_ZMin(geom)) / 2, 4490), 4479) center,
ST_SetSrid(BOX[0]::geometry, 4490) min_point,
ST_SetSrid(BOX[1]::geometry, 4490) max_point,
ST_ZMax(geom) - ST_ZMin(geom) z
FROM
(SELECT ST_ASBox(grid) BOX, ST_AsGeometry(grid) geom
FROM (SELECT unnest($1) grid) a)b)c $$
LANGUAGE 'sql';
-- Call GridToJson to generate the result
SELECT GridToJson(array (SELECT grid FROM building_grid WHERE grid_type = 'border'));
GridToJsonconvertit la référence spatiale de chaque cellule de grille d'EPSG:4490 vers EPSG:4479 lors du calcul du champcenter. Les valeurs desizerestent exprimées dans l'échelle EPSG:4490 (directions latitude/longitude/hauteur). Adaptez l'appel àST_Transformsi votre configuration Cesium requiert un système de référence de coordonnées différent.
La fonction retourne un tableau JSON :
[
{
"center": [-1583397.2647956165, 5313841.088458569, 3142388.7651142543],
"size": [3.3600142470488144, 3.848872238575258, 3.3680849811062217]
},
...
]
center: Centre de la cellule de grille en EPSG:4479.size: Dimensions approximatives de la cellule selon les directions latitude, longitude et hauteur.
Chargez le résultat dans Cesium à l'aide du code HTML suivant :
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<script src="https://cesium.com/downloads/cesiumjs/releases/1.89/Build/Cesium/Cesium.js"></script>
<link href="https://cesium.com/downloads/cesiumjs/releases/1.89/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
<style>
html, body, #cesium_container {
width: 100%; height: 100%;
margin: 0; padding: 0; overflow: hidden;
}
</style>
</head>
<body>
<div id="cesium_container"></div>
<script>
Cesium.Ion.defaultAccessToken = YOUR_CESIUM_TOKEN
const viewer = new Cesium.Viewer('cesium_container', ['timeline', 'animation', 'infoBox', 'navigationHelpButton'].reduce((opts, opt) => (opts[opt] = false) || opts, {}))
// Specify the grids to display
const grids = [{ "center": [-1583315.44750805, 5313895.98214751, 3142303.525767127], "size":...
const add_grids = (grids, material) =>
grids.forEach(({ center, size }) => viewer.entities.add({
position: new Cesium.Cartesian3(...center),
box: {dimensions: new Cesium.Cartesian3(...size),
material, outline: true, outlineColor: Cesium.Color.BLACK}}))
// Display grids in semi-transparent red
add_grids(grids, Cesium.Color.RED.withAlpha(0.2))
// Jump to the grid location
viewer.zoomTo(viewer.entities)
</script>
</body>
</html>
Remplacez YOUR_CESIUM_TOKEN par votre jeton d'accès Cesium Ion.
La figure suivante montre la grille de niveau 24 superposée aux données de photographie oblique. Pour le code complet permettant de charger les données obliques, consultez l'Annexe.

Étape 6 : Exécuter la planification de trajectoire
Planifiez une trajectoire 3D à travers la grille à l'aide de ST_3DGridPath. La requête définit le point de départ, le point d'arrivée et une boîte englobante limitant l'espace de recherche aux seules grilles pertinentes.
-- Define start point, end point, and search bounds
WITH vals (start_p, end_p, box_range) AS (
VALUES
(
ST_PointZ(106.59182291666669, 29.70644097140958, 355.322855208642, 4490),
ST_PointZ(106.59244791666666, 29.707135415854022, 348.58669235736755, 4490),
'BOX3D(106.591788194444 29.7062326380763 341.85053662386713, 106.592899305556 29.7071701380762 362.0590251699541)' :: box3d
)),
border AS (
SELECT DISTINCT grid, grid_type
FROM building_grid, vals
WHERE
-- Filter to grids within the bounding box only.
-- All geometry inputs must use EPSG:4490.
ST_3DIntersects(ST_SetSrid(box_range :: meshgeom, 4490), grid)
OR ST_3DContains(ST_SetSrid(box_range :: meshgeom, 4490), grid)
)
SELECT ST_3DGridPath(
start_p,
end_p,
box_range,
array[ST_SetCost(array (SELECT grid FROM border WHERE grid_type = 'border'), -1)],
'{"algorithm":"astar","movement":"cross","distance":"euclidean"}'
) result
FROM vals;
ST_SetCost(..., -1) marque toutes les grilles de bâtiments comme infranchissables. L'algorithme A* trouve alors le chemin euclidien le plus court en évitant ces cellules.
Visualisez le résultat avec GridToJson dans Cesium :



Le passage au mode de déplacement strict_octothorpe produit une trajectoire différente :



Planification de trajectoire à coûts multiples
Attribuez des coûts de déplacement différents à diverses zones afin que l'algorithme sélectionne la trajectoire présentant le coût total le plus faible. Cet exemple ajoute une zone à risque au scénario précédent, forçant ainsi la trajectoire planifiée à la contourner.
1. Insérez la grille de la zone à risque.
INSERT INTO building_grid (grid, grid_type)
SELECT grid, 'risk_zone'
FROM
(SELECT unnest(ST_As3DGrid(ST_SetSrid('BOX3D(106.59192708333332 29.706614582520686 341.8505366235368, 106.59220486111111 29.706892360298472 365.4271128197744)' :: box3d :: meshgeom, 4490), 24)) grid) tmp;
La zone orange dans la figure suivante représente la zone à risque :

Les grilles de zones à risque chevauchant des grilles infranchissables sont traitées comme infranchissables.
2. Exécutez la planification de trajectoire avec deux jeux de coûts.
WITH vals (start_p, end_p, box_range) AS (
VALUES
(
ST_PointZ(106.59182291666669, 29.70644097140958, 355.322855208642, 4490),
ST_PointZ(106.59244791666666, 29.707135415854022, 348.58669235736755, 4490),
'BOX3D(106.591788194444 29.7062326380763 341.85053662386713, 106.592899305556 29.7071701380762 362.0590251699541)' :: box3d
)),
border AS (
SELECT DISTINCT grid, grid_type
FROM building_grid, vals
WHERE
ST_3DIntersects(ST_SetSrid(box_range :: meshgeom, 4490), grid)
OR ST_3DContains(ST_SetSrid(box_range :: meshgeom, 4490), grid)
)
-- border grids: non-passable (-1); risk_zone grids: cost 2
SELECT ST_3DGridPath(
start_p,
end_p,
box_range,
array[
ST_SetCost(array (SELECT grid FROM border WHERE grid_type = 'border'), -1),
ST_SetCost(array (SELECT grid FROM border WHERE grid_type = 'risk_zone'), 2)
],
'{"algorithm":"astar","movement":"cross","distance":"euclidean"}'
) result
FROM vals;
L'algorithme A* contourne la zone à risque pour minimiser le coût total de la trajectoire :



La figure suivante compare la trajectoire sans zone à risque (en violet) à celle qui évite cette zone :

Annexe
Cette annexe fournit un service backend Node.js agissant comme proxy pour les requêtes 3D Tiles, avec Cesium comme interface de visualisation frontend.
1. Créez le fichier de dépendances package.json dans le répertoire de votre projet.
{
"dependencies": {
"koa": "^2.14.2",
"koa-router": "^12.0.0",
"koa-send": "^5.0.1",
"pg": "^8.10.0"
}
}
2. Exécutez npm install, puis créez index.js dans le même répertoire.
const Koa = require('koa');
const Send = require('koa-send');
const Router = require('koa-router');
const router = new Router()
const { Pool } = require('pg');
const pool = new Pool({ user: <YOUR_USER>, host: <YOUR_HOST>, database: <YOUR_DB_NAME>, port: <YOUR_PORT> });
const TABLE_NAME = 'test_osgb'
const PROJECT_NAME = 'prj1'
router.get('/', (_) => Send(_, '/index.html'))
/* Get metadata of the current project */
router.get('/project', async (ctx) => {
const sql = `SELECT (REGEXP_MATCHES(ST_ASTEXT(ST_TRANSFORM(ANCHOR,4326)), 'POINT Z \\((.*?)\\)'))[1] _ANCHOR, PROJECT_ID FROM ${TABLE_NAME} WHERE PROJECT_NAME='${PROJECT_NAME}';`
const { rows: [{ _anchor, project_id }] } = await pool.query(sql)
const anchor = _anchor.split(' ').map(x => parseFloat(x))
const url = `/tileset/${project_id}/${project_id}`
ctx.body = { url, anchor }
})
router.get('/tileset/:project_id/:uid', async (ctx) => {
const { params: { project_id, uid } } = ctx
const sql = `SELECT TILESET FROM ${TABLE_NAME}_TILESET WHERE PROJECT_ID=$1::UUID AND UID=$2::UUID;`
const { rows: [{ tileset }] } = await pool.query(sql, [project_id, uid])
ctx.body = tileset
})
router.get('/b3dm/:project_id/:uid', async (ctx) => {
const { params: { project_id, uid } } = ctx
const sql = `SELECT ST_ASB3DM(TILE) TILE FROM ${TABLE_NAME}_TILE WHERE PROJECT_ID=$1::UUID AND UID=$2::UUID;`
const { rows: [{ tile }] } = await pool.query(sql, [project_id, uid])
ctx.body = tile
})
new Koa().use(router.routes()).listen(5500, '0.0.0.0');
Remplacez <YOUR_USER>, <YOUR_HOST>, <YOUR_DB_NAME> et <YOUR_PORT> par vos informations de connexion PolarDB.
3. Créez index.html dans le même répertoire.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<script src="https://cesium.com/downloads/cesiumjs/releases/1.89/Build/Cesium/Cesium.js"></script>
<link href="https://cesium.com/downloads/cesiumjs/releases/1.89/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
<style>
html, body, #cesium_container {
width: 100%; height: 100%;
margin: 0; padding: 0; overflow: hidden;
}
</style>
</head>
<body>
<div id="cesium_container"></div>
<script>
Cesium.Ion.defaultAccessToken = <SET_YOUR_OWN_TOKEN_HERE>
const disable_opt = ['timeline', 'animation', 'infoBox', 'navigationHelpButton']
.reduce((opts, opt) => (opts[opt] = false) || opts, {})
const viewer = new Cesium.Viewer('cesium_container', disable_opt)
fetch('/project')
.then(res => res.json())
.then(({ anchor, url }) => {
const position = Cesium.Cartesian3.fromDegrees(...anchor)
const modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(position)
const tileset = new Cesium.Cesium3DTileset({ url, modelMatrix })
tileset.readyPromise.then(() => viewer.zoomTo(tileset))
viewer.scene.primitives.add(tileset)
})
</script>
</div>
</body>
</html>
4. Démarrez le service et ouvrez la visionneuse.
node index.js
Ouvrez http://localhost:5500 dans votre navigateur pour afficher les données de photographie oblique.


