Tous les produits
Search
Centre de documentation

PolarDB:Modèle de grille géographique GeoSOT basé sur

Dernière mise à jour :Aug 11, 2026

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.

Degenerated grid computation diagram

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 : cross ou strict_octothorpe

  • distance : 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.xml complet 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

Test data oblique photography overview

É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éfinissez ignore_texture et ignore_normal à true pour 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, remplacez WHERE lod = 19 par WHERE children IS NULL afin 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 :

  1. 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.

  2. ST_Translate — Applique le décalage du point d'ancrage pour convertir toutes les coordonnées relatives en coordonnées absolues.

  3. ST_SetSrid — Attribue l'identifiant du système de référence spatiale correct à partir des métadonnées.

  4. 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.

  5. ST_Transform — Reprojette tous les points vers EPSG:4490, le système de référence de coordonnées utilisé par les grilles GeoSOT.

Important

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 :

  1. 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.

  2. Applique un pré-aplatissement avec ST_Flatten et reprojette vers le système de coordonnées d'origine avec ST_Transform.

  3. Décale les coordonnées vers une origine locale à l'aide de ST_Translate.

  4. Triangule le maillage avec ST_Triangulate et réduit le volume de données grâce à ST_MergeGeomByMaterial et ST_3DRemoveDuplicateVertex.

  5. 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 70414975c9d1496ea6e85e321f917e06
Niveau 25 c11c33b7a03d464584d6ca5753b886e3
Niveau 24 24bf8942858a469f8ca33ef071644701

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'));
GridToJson convertit la référence spatiale de chaque cellule de grille d'EPSG:4490 vers EPSG:4479 lors du calcul du champ center. Les valeurs de size restent exprimées dans l'échelle EPSG:4490 (directions latitude/longitude/hauteur). Adaptez l'appel à ST_Transform si 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.

Level 24 grid overlaid on oblique photography in Cesium

É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 :

Path planning result in Cesium — top view

tiu6hs7lgzu44_2bd2c03c8d3d414e9a4d465d96f33e83tiu6hs7lgzu44_d496f4033f4748e1877bbf968e656824

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

strict_octothorpe movement — top view

tiu6hs7lgzu44_64f6ef2d064d4e11ba56915ccbf0f1d7tiu6hs7lgzu44_a3d48bf8de084ffb9c5b0d7a1d82bfe3

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 :

Risk zone (orange) added to the scene

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 :

Multi-cost path result — top view

7image

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

Comparison: multi-cost path vs. baseline path (purple)

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.