Vous pouvez utiliser une base de données PolarDB for PostgreSQL (Compatible with Oracle) avec le moteur de base de données spatio-temporelle GanosBase pour gérer et afficher rapidement les images de télédétection à l'aide de simples instructions SQL, sans aucun outil tiers. GanosBase propose deux méthodes pour visualiser les images non découpées. La première utilise le plugin Raster de GanosBase pour récupérer et afficher les données d'image en fonction d'une plage de fenêtre. La seconde méthode récupère les données d'image selon une plage de tuiles fixe. Cette rubrique décrit en détail la première méthode et fournit des exemples de code côté client et côté serveur pour vous aider à comprendre rapidement comment utiliser le plugin Raster de GanosBase.
Contexte
La gestion d'une collection croissante de données de télédétection et leur affichage sur une carte soulèvent souvent plusieurs questions :
Le tuilage et la publication traditionnels sont-ils trop complexes pour des images utilisées uniquement occasionnellement ? Où stocker les tuiles ? Comment gérer les données de tuiles ?
Le tuilage en temps réel, sans pré-génération des tuiles, peut-il répondre aux exigences de temps de réponse du front-end ? Quelles sont les performances avec des images exceptionnellement grandes ?
Cependant, avec ou PolarDB for PostgreSQL (Compatible with Oracle), vous pouvez utiliser l'extension Raster de GanosBase pour afficher efficacement les images de votre base de données sur une carte en utilisant uniquement SQL, sans outils tiers.
Bonnes pratiques
Préparation
Importer les données d'image
-
Installez l'extension ganos_raster.
CREATE EXTENSION ganos_raster CASCADE; -
Créez une table de test nommée raster_table qui contient une colonne de type raster.
CREATE TABLE raster_table (ID INT PRIMARY KEY NOT NULL,name text,rast raster); -
Importez une image depuis Object Storage Service (OSS) en tant que données de test. Utilisez la fonction ST_ImportFrom pour importer les données d'image dans la
chunk_table. Pour plus d'informations sur la syntaxe, consultez ST_ImportFrom.INSERT INTO raster_table VALUES (1, 'xxxx image', ST_ImportFrom('chunk_table','oss://<access_id>:<secret_key>@<Endpoint>/<bucket>/path_to/file.tif'));
Créer une pyramide
Une pyramide est la base d'une navigation rapide dans les images. Pour les données nouvellement importées, créez d'abord une pyramide. GanosBase fournit la fonction ST_BuildPyramid pour créer une pyramide. Pour plus d'informations sur la syntaxe, consultez ST_BuildPyramid.
UPDATE raster_table SET rast = st_buildpyramid(rast,'chunk_table') WHERE name = 'xxxx image';
Parcours des requêtes
Après avoir créé une pyramide, utilisez la fonction ST_AsImage de GanosBase pour récupérer une image d'une étendue spécifiée depuis la base de données. Le code suivant présente la syntaxe de base de la fonction ST_AsImage. Pour plus d'informations, consultez ST_AsImage.
bytea ST_AsImage(raster raster_obj,
box extent,
integer pyramidLevel default 0,
cstring bands default '',
cstring format default 'PNG',
cstring option default '');
Les paramètres de la fonction ST_AsImage sont soit statiques, soit dynamiques.
Paramètres statiques
Ces paramètres ne changent pas avec les opérations de l'utilisateur ; codez-les en dur pour simplifier votre code.
-
bands : La liste des bandes à récupérer.
Vous pouvez spécifier les bandes dans des formats tels que
'0-3'ou'0,1,2,3'. Les bandes spécifiées ne peuvent pas dépasser le nombre total de bandes de l'image. -
format : Le format de sortie de l'image.
La compression sans perte du PNG est moins efficace pour le transfert de données que la compression avec perte du JPEG. Nous recommandons le JPEG lorsque la transparence n'est pas requise.
option : Une chaîne JSON qui spécifie les options de conversion. Vous pouvez définir des paramètres de rendu supplémentaires.
Paramètres dynamiques
Ces paramètres changent avec les opérations de l'utilisateur et doivent être générés dynamiquement.
-
extent : L'étendue de l'image à récupérer.
Une étendue d'affichage plus grande nécessite plus de temps de traitement par la base de données et renvoie une image plus grande, augmentant ainsi le temps de réponse global. Par conséquent, récupérez uniquement les données situées dans la zone d'affichage de l'utilisateur pour un transfert efficace.
-
pyramidLevel : Le niveau de pyramide de l'image à utiliser.
Un niveau de pyramide plus élevé offre une image plus nette, mais augmente également sa taille. Sélectionnez le niveau de pyramide le plus approprié pour équilibrer la clarté et l'efficacité de transmission.
Cadre de délimitation de l'image
Utilisez la fonction GanosBase ST_Envelope pour obtenir le cadre de délimitation de l'image. Ensuite, utilisez la fonction ST_Transform pour la convertir dans un système de coordonnées commun, tel que WGS 84 dans cet exemple. Enfin, convertissez-la dans un format adapté au front-end.
SELECT replace((box2d(st_transform(st_envelope(rast),4326)))::text,'BOX','') FROM raster_table WHERE name = 'xxxx image';
Meilleur niveau de pyramide
Utilisez la fonction ST_BestPyramidLevel de GanosBase pour calculer le meilleur niveau de pyramide pour une étendue d'image spécifique. Le code suivant présente la syntaxe de base de la fonction. Pour plus d'informations, consultez ST_BestPyramidLevel.
integer ST_BestPyramidLevel(raster rast,
Box extent,
integer width,
integer height)
Paramètres :
extent : L'étendue de l'image à récupérer pour la zone d'affichage. Elle doit être identique à l'étendue utilisée dans la fonction ST_AsImage.
width/height : Les dimensions en pixels de la zone d'affichage, généralement la taille du conteneur de carte sur le front-end.
Notez que les fonctions ST_BestPyramidLevel et ST_AsImage utilisent le type natif Box, et non le type compatible Geometry, ce qui nécessite une conversion. Le front-end renvoie un tableau BBox. Pour le convertir en type natif Box, suivez ces étapes :
Dans l'instruction SQL, construisez un objet Geometry à partir de la chaîne envoyée par le front-end.
Convertissez l'objet Geometry en objet texte.
Utilisez le remplacement de texte pour rendre l'objet texte compatible avec le type Box.
Convertissez l'objet texte vers le type natif Box.
SELECT Replace(Replace(Replace(box2d(st_transform(st_setsrid(ST_Multi(ST_Union(st_point(-180,-58.077876),st_point(180,58.077876))),4326),st_srid(rast)))::text, 'BOX', '') , ',', '),('),' ',',')::box FROM raster_table WHERE name = 'xxxx image';
Ganos Version 6.0 fournit une fonction pour convertir entre les types Raster Box et Geometry Box2d, ce qui vous permet de simplifier l'opération de remplacement imbriquée mentionnée ci-dessus en appelant ::box pour effectuer la conversion.
SELECT st_extent(rast)::box2d::box FROM raster_table WHERE name = 'xxxx image';
Implémentation
Vous pouvez généralement parcourir les données raster en les publiant en tant que service à l'aide de GeoServer. GanosBase prend également en charge la publication de services raster et vectoriels basés sur GeoServer. Pour plus d'informations, consultez Map services. Cette rubrique présente une méthode plus simple, low-code, qui ne nécessite aucun outil de serveur GIS. Avec un minimum de code Python, vous pouvez construire une application cartographique qui met à jour et affiche dynamiquement une image spécifiée lorsque les utilisateurs effectuent des panoramiques et des zooms. Cette méthode est plus facile à intégrer dans les systèmes métier.
Structure globale
Code back-end
Pour simplifier le code et se concentrer sur la description de la logique, cet exemple utilise Python comme langage back-end, le framework Flask basé sur Python et le framework de connexion à la base de données Psycopg2 basé sur Python (qui peut être installé en utilisant pip install psycopg2). Le back-end implémente un service de carte simple qui construit automatiquement des pyramides et renvoie les données d'image pour une plage spécifiée en réponse aux requêtes du front-end. Enregistrez le code suivant dans un fichier Raster.py et exécutez la commande python Raster.py pour démarrer le service.
## -*- coding: utf-8 -*-
## @File : Raster.py
import json
from flask import Flask, request, Response, send_from_directory
import binascii
import psycopg2
## Connection parameters
CONNECTION = "dbname=<database_name> user=<user_name> password=<user_password> host=<host> port=<port>"
## Image URL in OSS
OSS_RASTER = "oss://<access_id>:<secret_key>@<Endpoint>/<bucket>/path_to/file.tif"
## Name of the raster in the table
RASTER_NAME = "xxxx image"
## Chunk table name
CHUNK_TABLE = "chunk_table"
## Raster table name
RASTER_TABLE = "raster_table"
## Raster column name
RASTER_COLUMN = "rast"
## Default rendering parameters
DEFAULT_CONFIG = {
"strength": "ratio",
"quality": 70
}
class RasterViewer:
def __init__(self):
self.pg_connection = psycopg2.connect(CONNECTION)
self.column_name = RASTER_COLUMN
self.table_name = RASTER_TABLE
self._make_table()
self._import_raster(OSS_RASTER)
def poll_query(self, query: str):
pg_cursor = self.pg_connection.cursor()
pg_cursor.execute(query)
record = pg_cursor.fetchone()
self.pg_connection.commit()
pg_cursor.close()
if record is not None:
return record[0]
def poll_command(self, query: str):
pg_cursor = self.pg_connection.cursor()
pg_cursor.execute(query)
self.pg_connection.commit()
pg_cursor.close()
def _make_table(self):
sql = f"create table if not exists {self.table_name} (ID INT PRIMARY KEY NOT NULL,name text, {self.column_name} raster);"
self.poll_command(sql)
def _import_raster(self, raster):
sql = f"insert into {self.table_name} values (1, '{RASTER_NAME}', ST_ComputeStatistics(st_buildpyramid(ST_ImportFrom('{CHUNK_TABLE}','{raster}'),'{CHUNK_TABLE}'))) on conflict (id) do nothing;;"
self.poll_command(sql)
self.identify = f" name= '{RASTER_NAME}'"
def get_extent(self) -> list:
"""Get the image extent."""
import re
sql = f"select replace((box2d(st_transform(st_envelope({self.column_name}),4326)))::text,'BOX','') from {self.table_name} where {self.identify}"
result = self.poll_query(sql)
# Convert to a format that the front end can easily recognize.
bbox = [float(x) for x in re.split(
'\(|,|\s|\)', result) if x != '']
return bbox
def get_jpeg(self, bbox: list, width: int, height: int) -> bytes:
"""
Get the image at a specified location.
:param bbox: The bounding box of the specified location.
:param width: The width of the viewport control.
:param height: The height of the viewport control.
"""
# Specify the bands and rendering parameters.
bands = "0-2"
options = json.dumps(DEFAULT_CONFIG)
# Get the extent.
boxSQl = f"Replace(Replace(Replace(box2d(st_transform(st_setsrid(ST_Multi(ST_Union(st_point({bbox[0]},{bbox[1]}),st_point({bbox[2]},{bbox[3]}))),4326),st_srid({self.column_name})))::text, 'BOX', ''), ',', '),('),' ',',')::box"
sql = f"select encode(ST_AsImage({self.column_name},{boxSQl} ,ST_BestPyramidLevel({self.column_name},{boxSQl},{width},{height}),'{bands}','jpeg','{options}'),'hex') from {self.table_name} where {self.identify}"
result = self.poll_query(sql)
result = binascii.a2b_hex(result)
return result
rasterViewer = RasterViewer()
app = Flask(__name__)
@app.route('/raster/image')
def raster_image():
bbox = request.args['bbox'].split(',')
width = int(request.args['width'])
height = int(request.args['height'])
return Response(
response=rasterViewer.get_jpeg(bbox, width, height),
mimetype="image/jpeg"
)
@app.route('/raster/extent')
def raster_extent():
return Response(
response=json.dumps(rasterViewer.get_extent()),
mimetype="application/json",
)
@app.route('/raster')
def raster_demo():
"""Serve the front-end page."""
return send_from_directory("./", "Raster.html")
if __name__ == "__main__":
app.run(port=5000, threaded=True)
Le code back-end implémente les trois fonctions principales suivantes pour les données d'image :
Initialiser les données : Créez la table de test, importez les données, construisez la pyramide et calculez les statistiques.
Obtenir l'emplacement de l'image : Aide la carte front-end à localiser et à accéder à la position de l'image.
-
Extraire l'image dans un format d'image :
Pour cette image, nous savons grâce à ses métadonnées qu'elle possède trois bandes. Vous pouvez également obtenir dynamiquement le nombre de bandes en utilisant la fonction ST_NumBands.
Déterminez l'étendue de l'image en fonction des informations d'étendue et des dimensions en pixels du contrôle de zone d'affichage renvoyées par le front-end.
Lors de l'utilisation de la bibliothèque psycopg2, la transmission des données au format hexadécimal est plus efficace. Si vous utilisez un autre framework ou langage, vous pouvez récupérer les données directement au format binaire sans conversion d'encodage.
Cet exemple utilise Python, mais vous pouvez obtenir les mêmes résultats en implémentant la même logique dans d'autres langages.
Code front-end
Cet exemple utilise Mapbox comme framework de carte front-end et la bibliothèque spatiale front-end Turf.js. Lorsqu'un utilisateur fait glisser ou zoome sur la carte, l'application calcule l'intersection entre la zone d'affichage actuelle et l'image d'origine, puis demande au serveur une image plus claire pour cette zone. Cela permet à l'image de la carte de se mettre à jour lors de l'interaction de l'utilisateur. Dans le même répertoire que le code back-end, créez un nouveau fichier nommé Raster.html et ajoutez le code suivant. Après le démarrage du service back-end, vous pouvez accéder à la page à l'adresse http://localhost:5000/raster.
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title></title>
<link href="https://cdn.bootcdn.net/ajax/libs/mapbox-gl/1.13.0/mapbox-gl.min.css" rel="stylesheet" />
</head>
<script src="https://cdn.bootcdn.net/ajax/libs/mapbox-gl/1.13.0/mapbox-gl.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/axios/0.21.0/axios.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/lodash.js/4.17.20/lodash.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/Turf.js/5.1.6/turf.min.js"></script>
<body>
<div id="map" style="height: 100vh" />
<script>
// Initialize the map control.
const map = new mapboxgl.Map({
container: "map",
style: { version: 8, layers: [], sources: {} },
});
class Extent {
constructor(geojson) {
// Use GeoJSON format by default.
this._extent = geojson;
}
static FromBBox(bbox) {
// Create an Extent object from a BBox.
return new Extent(turf.bboxPolygon(bbox));
}
static FromBounds(bounds) {
// Create an Extent object from Mapbox Bounds.
const bbox = [
bounds._sw.lng,
bounds._sw.lat,
bounds._ne.lng,
bounds._ne.lat,
];
return Extent.FromBBox(bbox);
}
intersect(another) {
// Check for intersection.
const inrersect = turf.intersect(this._extent, another._extent);
return inrersect ? new Extent(inrersect) : null;
}
toQuery() {
// Convert to query format.
return turf.bbox(this._extent).join(",");
}
toBBox() {
// Convert to BBox format.
return turf.bbox(this._extent);
}
toMapboxCoordinates() {
// Convert to Mapbox Coordinate format.
const bbox = this.toBBox();
const coordinates = [
[bbox[0], bbox[3]],
[bbox[2], bbox[3]],
[bbox[2], bbox[1]],
[bbox[0], bbox[1]],
];
return coordinates;
}
}
map.on("load", async () => {
map.resize();
const location = window.location.href;
// Construct the query URL.
const getUrl = (extent) => {
const params = {
bbox: extent.toQuery(),
height: map.getCanvas().height,
width: map.getCanvas().width,
};
// Construct the request body.
const url = `${location}/image?${Object.keys(params)
.map((key) => `${key}=${params[key]}`)
.join("&")}`;
return url;
};
// Query the image extent.
const result = await axios.get(`${location}/extent`);
const extent = Extent.FromBBox(result.data);
const coordinates = extent.toMapboxCoordinates();
// Add a data source.
map.addSource("raster_source", {
type: "image",
url: getUrl(extent),
coordinates,
});
//Add a layer.
//This uses a Mapbox layer of the image type to attach the image to a specified location for display.
map.addLayer({
id: "raster_layer",
paint: { "raster-fade-duration": 300 },
type: "raster",
layout: { visibility: "visible" },
source: "raster_source",
});
// Navigate to the image location.
map.fitBounds(extent.toBBox());
// Bind the refresh method.
map.once("moveend", () => {
const updateRaster = () => {
const _extent = Extent.FromBounds(map.getBounds());
let intersect;
// Do not send a new request if the viewport does not contain the image.
if (!_extent || !(intersect = extent.intersect(_extent))) return;
// Update the image.
map.getSource("raster_source").updateImage({
url: getUrl(intersect),
coordinates: intersect.toMapboxCoordinates(),
});
};
// Add debouncing to reduce invalid requests.
const _updateRaster = _.debounce(updateRaster, 200);
map.on("zoomend", _updateRaster);
map.on("moveend", _updateRaster);
});
});
</script>
</body>
</html>
Étant donné que l'API actuelle de récupération d'images n'est pas une interface de protocole de carte standard, vous devez implémenter manuellement la logique de mise à jour de l'image. Le principal défi consiste à déterminer l'étendue de l'image dans la zone d'affichage de l'utilisateur.
Obtenez l'étendue spatiale de l'image.
Obtenez l'étendue spatiale de la zone d'affichage actuelle de l'utilisateur.
Calculez l'intersection des deux étendues. Cette intersection correspond à l'étendue cible de l'image.
Cet exemple utilise Turf.js sur le front-end pour les vérifications spatiales, ce qui aide à réduire les requêtes inutiles. Pour simplifier ces vérifications et les conversions de format, nous avons créé une classe d'assistance nommée Extent avec les fonctionnalités suivantes :
-
Conversion de format :
BBox <=> GeoJSON
Coordonnée Mapbox <=> GeoJSON
GeoJSON => Requête
Bounds => GeoJSON
Encapsule les méthodes de vérification spatiale de Turf.js.
Résultats
Démo de l'application

Navigation d'images dans pgAdmin
Vous pouvez intégrer cette fonctionnalité de navigation d'images dans pgAdmin, un client de base de données compatible avec PolarDB. Cela vous permet de parcourir les données raster de votre base de données, d'obtenir un aperçu des données et d'améliorer votre expérience de gestion des données.
Dans pgAdmin, développez la base de données asimage_db > schema > public > table. Sélectionnez la table raster_table et exécutez la requête SELECT * FROM public.raster_table. Le résultat de la requête montre que la table contient trois colonnes : ID (entier), name (texte) et rast (raster).
Résumé
En utilisant les fonctions Raster de GanosBase, vous pouvez extraire les données d'image de votre base de données et construire une carte interactive pour parcourir les images de télédétection avec un minimum de code. L'utilisation de GanosBase pour gérer des collections croissantes d'images de télédétection réduit les coûts. L'extension Ganos Raster vous permet également de parcourir les données d'image directement dans la base de données avec un minimum de code et sans outils tiers, améliorant considérablement l'expérience de gestion des données.