Tous les produits
Search
Centre de documentation

PolarDB:Diffuser des tuiles raster dynamiques directement depuis la base de données avec

Dernière mise à jour :Aug 11, 2026

Le pré-découpage d'images de télédétection exige un temps de traitement considérable, un espace de stockage important et un nouveau traitement après chaque mise à jour des données. La fonction ST_AsTile de GanosBase élimine cette contrainte en générant à la demande des tuiles cartographiques standard directement à partir des données raster stockées dans PolarDB. Cette approche supprime les tâches de pré-découpage, le recours à GeoServer et la maintenance d'un cache de tuiles.

Fonctionnement

Une fois les données raster importées dans la base de données, ST_AsTile gère le recadrage, la reprojection, le rééchantillonnage et le rendu lors de l'exécution de la requête. Pour chaque coordonnée de tuile demandée (Z/X/Y), la fonction produit une tuile PNG, JPEG ou GeoTIFF de 256×256 ou 512×512 en quelques centaines de millisecondes, ce qui permet une navigation fluide sur la carte.

Les tuiles étant générées à partir des données sources en temps réel, toute modification du raster d'origine devient immédiatement visible sans qu'il soit nécessaire de relancer un traitement de découpage.

ST_AsTile traite un seul objet raster à la fois. Pour afficher plusieurs images simultanément, assemblez-les d'abord en un seul raster virtuel (voir Étape 1 : Préparer les données ).

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

  • Une instance PolarDB avec la configuration suivante :

    • Moteur de base de données : compatibilité syntaxique Oracle 2.0

    • Version du noyau : 2.0.14.25.0

    • Spécifications recommandées : CPU > 4 cœurs, mémoire > 16 Go, disque > 50 Go

  • GanosBase version 6.3 ou ultérieure, avec l'extension ganos_raster installée :

    CREATE EXTENSION ganos_raster CASCADE;
  • Quatre images satellite Landsat 8 au format .TIF, téléchargées dans un bucket Object Storage Service (OSS) situé dans la même région que votre instance PolarDB

Important

Votre cluster PolarDB doit se connecter à OSS via l'endpoint interne. OSS et PolarDB doivent résider dans la même région.

Étape 1 : Préparer les données

Charger les images

Créez une table pour stocker vos données raster, puis importez chaque image depuis OSS à l'aide de ST_ImportFrom.

CREATE TABLE landsat8 (
  id integer,
  rast raster
);

INSERT INTO landsat8 VALUES (1, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file1.TIF'));
INSERT INTO landsat8 VALUES (2, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file2.TIF'));
INSERT INTO landsat8 VALUES (3, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file3.TIF'));
INSERT INTO landsat8 VALUES (4, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file4.TIF'));

Remplacez <access_id>, <secret_key>, <endpoint> et <bucket> par vos identifiants OSS et le chemin d'accès réels. N'incluez pas les chevrons dans la chaîne de connexion finale.

Important

Évitez d'inscrire en dur les identifiants dans les scripts SQL stockés sous contrôle de version. Dans la mesure du possible, utilisez un rôle RAM associé à l'instance PolarDB pour accorder l'accès à OSS sans intégrer de clé d'accès ni de secret.

Pour vérifier l'importation, interrogez les métadonnées du raster :

SELECT ST_Name(rast), ST_Width(rast), ST_Height(rast), ST_SRID(rast), ST_NumBands(rast)
FROM landsat8;

image

Assembler les images et construire les pyramides

Une fois les quatre images distinctes chargées, assemblez-les en un seul objet raster virtuel (id 101) et activez l'équilibrage des couleurs pour obtenir un rendu visuel homogène :

-- Mosaic all four images with color balancing
INSERT INTO landsat8 VALUES (101, ST_MosaicFrom(
  Array(SELECT rast FROM landsat8 WHERE id < 5),
  'rbt_mosaic',
  '',
  '{"srid":4326, "cell_size":[0.0002,0.0002], "nodata":true, "nodatavalue":0, "color_balance":true}'
));

Construisez ensuite les pyramides sur le raster assemblé. Ces pyramides constituent des vues réduites qui accélèrent le rendu aux différents niveaux de zoom :

-- Build pyramids for the mosaicked raster (id=101)
UPDATE landsat8 SET rast = ST_BuildPyramid(rast) WHERE id = 101;

Après l'équilibrage des couleurs, le raster exporté présente l'aspect suivant :

image

Étape 2 : Générer des tuiles avec ST_AsTile

ST_AsTile prend en entrée un objet raster et une enveloppe de tuile (définie par le niveau de zoom Z et les coordonnées X/Y), puis renvoie une tuile d'image rendue. ST_TileEnvelope convertit une adresse de tuile Z/X/Y en une boîte englobante géographique requise par ST_AsTile.

Le troisième argument de ST_AsTile correspond à un objet de configuration JSON :

Paramètre Description Valeur par défaut
format Format de sortie : PNG, JPEG ou GTiff. Utilisez GTiff pour conserver les valeurs brutes des pixels. PNG
bands Indices de bandes mappés sur RVB (par exemple, "0,1,2"). Trois premières bandes
strength Amélioration de l'affichage : none (aucun étirement), stats (étirement statistique) ou ratio (étirement basé sur un pourcentage). stats
alpha Inclut un canal alpha pour la transparence. —

Exemple 1 : Image standard à 3 bandes

Pour une image RVB standard sans étirement particulier :

SELECT ST_AsTile(
  rast,
  ST_TileEnvelope(tile_zoom, tile_column, tile_row),
  '{"strength":"none", "format":"PNG", "alpha":true}'
)
FROM landsat8 WHERE id = 101;

Exemple 2 : Image multibande avec étirement du contraste

Pour les images multibandes telles que Landsat, sélectionnez des bandes spécifiques et appliquez un étirement par pourcentage afin d'améliorer le rendu visuel :

SELECT ST_AsTile(
  rast,
  ST_TileEnvelope(tile_zoom, tile_column, tile_row),
  '{"strength":"ratio", "format":"PNG", "bands":"0,1,2", "alpha":true}'
)
FROM landsat8 WHERE id = 101;

Dans cet exemple, les bandes 0, 1 et 2 sont mappées respectivement aux canaux R, V et B, tandis que la méthode ratio applique un étirement du contraste basé sur un pourcentage. Les valeurs tile_zoom, tile_column et tile_row correspondent directement aux paramètres de chemin {z}, {x} et {y} de l'URL HTTP de tuile servie à l'étape 3.

Étape 3 : Mettre en place un serveur de tuiles

Cette étape consiste à créer un service web Python minimaliste qui diffuse les tuiles générées par votre base de données. Ce service s'appuie sur le framework web asynchrone Quart et sur asyncpg pour garantir un accès non bloquant à la base de données.

Installer les dépendances

pip install asyncpg quart

Créer app.py

Le service expose deux routes :

  • / : diffuse la page HTML de la carte et calcule les limites initiales de la carte à partir de l'étendue du raster.

  • /raster/{z}/{x}/{y} : traite une requête de tuile, exécute ST_AsTile pour les coordonnées Z/X/Y spécifiées et renvoie la tuile PNG.

from quart import Quart, send_file, render_template
import asyncpg
import io
import re

# Database connection parameters
CONNECTION = {
    "host": "<database-endpoint>",
    "port": "<port>",
    "user": "<username>",
    "password": "<password>",
    "database": "<database-name>"
}

TABLE_NAME = "landsat8"    # Target table
RASTER_COLUMN = "rast"     # Raster column name
RASTER_ID = "101"          # ID of the mosaicked raster

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({RASTER_COLUMN}), 4326))
    FROM {TABLE_NAME}
    WHERE ID = {RASTER_ID};
    '''
    async with app.db_pool.acquire() as connection:
        box = await connection.fetchval(sql)
        box = re.findall(r'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.jinja2', center=str(center), bounds=str(bounds))

@app.route("/raster/<int:z>/<int:x>/<int:y>")
async def raster(z, x, y):
    # Select bands 0,1,2 as RGB with percentage-based contrast stretch
    config = '{"strength":"ratio","bands":"0,1,2","alpha":true}'
    sql = f'''
    SELECT (
      ST_AsTile({RASTER_COLUMN},
        ST_Transform(
          ST_TileEnvelope($1, $2, $3),
          ST_Srid({RASTER_COLUMN})),
        \'{config}\')
      ).data AS tile
    FROM {TABLE_NAME}
    WHERE ID = {RASTER_ID};'''
    async with app.db_pool.acquire() as connection:
        tile = await connection.fetchval(sql, z, x, y)
        return await send_file(io.BytesIO(tile), mimetype='image/png')

if __name__ == "__main__":
    app.run(port=5500)  # Change the port if needed

Remplacez les valeurs de CONNECTION par l'endpoint, le port, les identifiants et le nom de la base de données de votre instance PolarDB.

Étape 4 : Créer la page cartographique

Dans le même répertoire que app.py, créez le fichier index.jinja2. Ce fichier HTML charge MapLibre GL JS et configure sa source de tuiles raster pour pointer vers l'endpoint /raster/{z}/{x}/{y} défini à l'étape 3.

Exécuter l'application

Démarrez le serveur de tuiles :

python app.py

Ouvrez http://127.0.0.1:5500 dans votre navigateur. La carte affiche vos images satellite Landsat, toutes les tuiles étant générées en temps réel depuis PolarDB.

image

Voir aussi