Les données¶

L’API s’appuie sur des ressources qui s’appuient sur des jeux de données au format ROK4. Pour de plus amples informations sur les mécanismes sous-jacents à ce format, nous vous invitons à vous référer à la documentation projet ROK4.

Pour pouvoir récupérer l’élévation à partir d’un jeu de données ROK4, l’API s’appuie sur la librairie rok4, open-source et publiée sur PyPi.

Le dépôt Github : https://github.com/rok4/core-python
La documentation : https://rok4.github.io/core-python/

Générer votre jeu de donnés au format ROK4 : exemple en utilisant les données de la RGE ALTI¶

Pyramides ROK4 en mode file¶

Vous trouverez plus d’informations sur le lien suivant : https://hub.docker.com/r/rok4/pregeneration

mkdir rok4_config
cd rok4_config
mkdir confs
mkdir data
mkdir pyramids
mkdir scripts
mkdir common
mkdir tmp

Dans confs/, création d’un fichier rgealti.json :

{
    "datasources": [{
        "top": "0",
        "bottom": "<AUTO>",
        "source": {
            "type": "IMAGES",
            "directory": "/data/",
            "srs": "EPSG:4326"
        }
    }],
    "pyramid": {
        "type": "GENERATION",
        "name": "RGEALTI",
        "compression": "zip",
        "tms": "4326.json",
        "storage": {
            "type": "FILE",
            "root": "/pyramids/RGEALTI"
        },
        "nodata": [-99999]
    },
    "process": {
        "directories": {
            "scripts": "/scripts",
            "local_tmp": "/tmp",
            "shared_tmp": "/common"
        },
        "parallelization": 2
    }
}

Mettre les données source dans data/.
Conversion des fichiers .asc en .tif à l’aide du bash suivant :

#!/bin/bash

DIR="/home/sbe/data/rgealti/1_DONNEES_LIVRAISON_2021-07-00189/RGEALTI_MNT_1M_ASC_LAMB93_IGN69_D014_20210730/*.asc"

for filename in $DIR; do
    rootfilename="${filename%.*}"
    gdal_translate "$filename" "$rootfilename".tif

done

Reprojection des .tif en 4326 :

#!/bin/bash

DIR="/home/sbe/data/rgealti/1_DONNEES_LIVRAISON_2021-07-00189/RGEALTI_MNT_1M_ASC_LAMB93_IGN69_D014_20210730/*.tif"

for filename in $DIR; do
    rootfilename="${filename%.*}"
    gdalwarp -overwrite "$filename" "$rootfilename"_4326.tif -s_srs EPSG:2154 -t_srs EPSG:4326
done

Une fois les .tif générés et reprojetés, vous pouvez lancer la commande suivante :

docker run --rm \
    --user $(id -u):$(id -g) \
    -v $PWD/confs:/confs:ro \
    -v $PWD/data:/data:ro \
    -v $PWD/pyramids:/pyramids \
    -v $PWD/scripts:/scripts \
    -v $PWD/common:/common \
    rok4/pregeneration:4.2.0 \
    be4.pl --conf /confs/rgealti.json

Suite à cette commande, les scripts main.sh, SCRIPT_1.sh, SCRIPT_2.sh, SCRIPT_FINISHER.sh sont générés dans scripts/.

Nous allons maintenant lancer la génération des pyramides. Pour plus d’infos, vous pouvez consulter le lien suivant : https://hub.docker.com/r/rok4/generation

docker run --rm \
    --user $(id -u):$(id -g) \
    -v $PWD/data:/data:ro \
    -v $PWD/pyramids:/pyramids \
    -v $PWD/scripts:/scripts \
    -v $PWD/common:/common \
    rok4/generation \
    bash /scripts/main.sh 10

La pyramide sera créée dans pyramids/.

Pyramides ROK4 en mode S3¶

Utilisation d’un serveur minio¶

Téléchargez le docker : https://gitlab.gpf-tech.ign.fr/geoplateforme/traitements-vecteurs/gpf-pyr-up-from-raster/-/blob/main/tests/dev/docker-compose.dev.yml
Lancez la commande : docker compose up

L’interface web du serveur est accessible à l’adresse localhost:9001.

Les crédentials sont :

nom d’utilisateur : admin
mot de passe : minioadmin

Une api est disponible à l’adresse localhost:9000

Via l’interface web, il faut créer une clef d’accès avec sa clef secrète. Elles serviront à définir des variables d’environnement dans l’API Python. Ces variables seront lues par la librairie ROK4.

Exemple :

import os
os.environ["ROK4_S3_URL"] = 's3://regalti/'
os.environ["ROK4_S3_KEY"] = 'xvMnuUE6YUHC2uHd'
os.environ["ROK4_S3_SECRETKEY"] = '9ZfxgUuWYaK7Q0UgRMgvjRaEFuHK7eqa'

Ces variables sont désormais disponibles dans les settings de l’API, donc à redéfinir localement dans le .env.

Via l’interface, nous allons créer des buckets et uploadés certains fichiers :

pyramids
tilematrixsets :
- via Object Browser, upload des fichiers suivants : 4326.json, PM.json, LAMB_93.json

Génération de la pyramide dans le serveur S3 (minio)¶

Dans confs/** (cf. création des répertoires nécessaires au début de la section Pyramides ROK4 en mode file), nous allons créer un fichier rgealti_s3.json :

{
    "datasources": [{
        "top": "0",
        "bottom": "<AUTO>",
        "source": {
            "type": "IMAGES",
            "directory": "/data/",
            "srs": "EPSG:4326"
        }
    }],
    "pyramid": {
        "type": "GENERATION",
        "name": "RGEALTI",
        "compression": "zip",
        "tms": "4326.json",
        "storage": {
            "type": "S3",
            "root": "pyramids"
        },
        "nodata": [-99999]
    },
    "process": {
        "directories": {
            "scripts": "/scripts",
            "local_tmp": "/tmp",
            "shared_tmp": "/common"
        },
        "parallelization": 2
    }
}

Pour du 2154 :

{
    "datasources": [{
        "top": "0",
        "bottom": "<AUTO>",
        "source": {
            "type": "IMAGES",
            "directory": "/data/",
            "srs": "IGNF:LAMB93"
        }
    }],
    "pyramid": {
        "type": "GENERATION",
        "name": "RGEALTI_14_2154",
        "compression": "zip",
        "tms": "PM.json",
        "storage": {
            "type": "S3",
            "root": "pyramids"
        },
        "nodata": [-99999]
    },
    "process": {
        "directories": {
            "scripts": "/scripts",
            "local_tmp": "/tmp",
            "shared_tmp": "/common"
        },
        "parallelization": 2
    }
}

Lancement de la prégéneration :

docker run --rm \
    --network host \
    --user $(id -u):$(id -g) \
    -v $PWD/confs:/confs:ro \
    -v $PWD/data:/data:ro \
    -v $PWD/pyramids:/pyramids \
    -v $PWD/scripts:/scripts \
    -v $PWD/common:/common \
    -e ROK4_S3_URL='http://localhost:9000' \
    -e ROK4_S3_KEY='WGf60sYKKY1Nuvkm' \
    -e ROK4_S3_SECRETKEY='WbnsKucyiB9wgO6cDerJEW0tLuJ9MHCw' \
    rok4/pregeneration:4.2.0 \
    be4.pl --conf /confs/rgealti.json

A l’issue de cette commande, l’index (RGEALTI.json) sera présent dans le stockage S3.

Lancement de la génération :

docker run --rm \
    --network host \
    --user $(id -u):$(id -g) \
    -v $PWD/confs:/confs:ro \
    -v $PWD/data:/data:ro \
    -v $PWD/pyramids:/pyramids \
    -v $PWD/scripts:/scripts \
    -v $PWD/common:/common \
    -v $PWD/tmp:/tmp \
    -e ROK4_S3_URL='http://localhost:9000' \
    -e ROK4_S3_KEY='WGf60sYKKY1Nuvkm' \
    -e ROK4_S3_SECRETKEY='WbnsKucyiB9wgO6cDerJEW0tLuJ9MHCw' \
    rok4/generation \
    bash /scripts/main.sh 10

A l’issue de cette commande, la pyramide est dans le S3 et prête à être utilisée par l’API.

NOTE: Il faut également rajouter les TMS dans le S3. Vous pouvez les trouver au bon format à partir d’un docker. docker run -p 9000:9000 -p 9001:9001 rok4/dataset:minio Une interface graphique de gestion disponible à : http://localhost:9001/buckets (credentials : rok4 / rok4S3storage)

Pour publier votre jeu de données, vous devez publier une nouvelle ressource. Veuillez vous référer à la section Publier une ressource dans l’entrepôt pour qu’elle soit utilisable par l’API.