REST API¶

Concepts de l’importateur¶

L’importateur api REST est construit autour d’une arborescence d’objets représentant une importation unique, structurée comme suit :

importation

workspace cible

données

tâche (un ou plusieurs)

données

film d’émail

transformation (un ou plusieurs)

Une ** importation ** fait référence à l’objet de niveau supérieur et est une “session” comme entité de l’état de l’importation de toute. Elle conserve les informations pertinentes à l’importation dans son ensemble comme utilisateur infromation, horodateurs, ainsi que les informations facultatives est uniformes le long de toutes les tâches, comme un workspace de cible, les données partagées d’entrée (par exemple, un répertoire, une base de données). Une importation est faite d’un nombre quelconque d’objets task.

A données est la description des données sources d’une importation (hors tout) ou une tâche. Dans le cas où l’importation a une définition globale des données, cela se réfère normalement à un magasin d’agrégation comme un répertoire ou une base de données et les données associées aux tâches se réfèrent à un seul élément à l’intérieur de cette agrégation, comme un seul fichier ou la table.

A tâche représente une unité de travail à l’importateur qui a besoin d’ enregistrer une nouvelle couche, ou modifier une déjà existante et contient les informations suivantes :

Les données importées
L’objectif de stocker qui est la destination de l’importation
Le calque cible
Les données d’une tâche, dénommée sa source, sont les données à traiter dans le cadre de la tâche.
Les transformations que nous devons appliquer aux données avant elle, sont importées dedans

Ces données proviennent de diverses formes, y compris :

Un fichier spatial (Shapefile, GeoTiff, KML, etc....)
Un répertoire de fichiers spatiales
Une table dans une base de données spatiales
Un emplacement distant que le serveur va télécharger à partir des données

Une tâche est classé comme “directe” ou “indirecte”. Une tâche directe est celle dans laquelle les données importées ne nécessitent pas de transformation . Elle est importée directement. Un exemple d’une telle tâche est celle qui consiste simplement à importer un Shapefile existantt. Une tâche indirecte est une qui ne nécessite qu’ une transformation aux données originales d’importation. Un exemple d’une tâche indirecte est celui qui consiste à importer un fichier de formes dans une base de données PostGIS existant. Un autre exemple de la tâche indirecte pourrait impliquer de prendre un fichier CSV comme une entrée, tourner hache et y colonne dans un point, à reconfigurer une colonne de chaîne dans un timestamp, et enfin importer le résultat dans un PostGIS.

Référence de l’API REST¶

Toutes les importations¶

/imports¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie	Paramètres
GET	Récupérer toutes les importations	200	n/a	Import Collection	n/a
POST	Créer une nouvelle importation	201 with Location header	n/a	Imports	async=false/true

Récupération de la liste de toutes les importations¶

GET /imports

nous obtenons

Status: 200 OK
Content-Type: application/json

        {
           "imports": [{
             "id": 0,
             "state": "COMPLETE",
             "href": "http://localhost:8080/geoserver/rest/imports/0"

           }, {
             "id": 1,
             "state": "PENDING",
             "href": "http://localhost:8080/geoserver/rest/imports/1"
           }]
        }

Création d’une nouvelle importation¶

Afficher le chemin d’accès /imports un objet json d’importation qui crée une nouvelle session d’importation:

Content-Type: application/json

{
   "import": {
      "targetWorkspace": {
         "workspace": {
            "name": "scratch"
         }
      },
      "targetStore": {
         "dataStore": {
            "name": "shapes"
         }
      },
      "data": {
        "type": "file",
        "file": "/data/spearfish/archsites.shp"
      }
   }
}

Les paramètres sont :

Nom	Facultatif	Description
targetWorkspace	Y	Le workspace cible pour importer dans
targetStore	Y	Le magasin target pour importer dans
données	Y	Les données à importer

La simple création ne démarre pas l’importation, mais elle peut remplir automatiquement ses tâches en fonction de la cible. Par exemple, en faisant référence à un répertoire des shapefiles importateur, la création se remplit automatiquement à une tâche pour importer chaque shapefiles comme un nouveau calque.

La réponse à la requête POST ci-dessus sera:

Status: 201 Created
Location: http://localhost:8080/geoserver/rest/imports/2
Content-Type: application/json

{
  "import": {
    "id": 2,
    "href": "http://localhost:8080/geoserver/rest/imports/2",
    "state": "READY",
    "targetWorkspace": {
      "workspace": {
        "name": "scratch"
      }
    },
    "targetStore": {
      "dataStore": {
        "name": "shapes",
        "type": "PostGIS"
      }
    },
    "data": {
      "type": "file",
      "format": "Shapefile",
      "href": "http://localhost:8080/geoserver/rest/imports/2/data",
      "file": "archsites.shp"
    },
    "tasks": [
      {
        "id": 0,
        "href": "http://localhost:8080/geoserver/rest/imports/2/tasks/0",
        "state": "READY"
      }
    ]
  }
}

L’opération de remplissage des tâches peut nécessiter du temps, surtout si elle se fait contre un grand nombre de fichiers, ou contre une donnée “à distance” (voir plus loin), dans ce cas, la requête POST peut inclure ?async=true à la fin de l’URL pour faire de l’importateur exécuté de façon asynchrone. Dans ce cas, l’importation sera créé à l’état INIT et restera dans cet état jusqu’à ce que toutes les opérations de transfert de données et de création de tâches soient terminées. En cas d’échec pour récupérer les données de l’importation cela sera cesser immédiatement, l’Etat va passer à la état INIT_ERROR, et un message d’erreur apparaîtra dans le contexte de l’importation “message” domaine

Objet d’importation¶

/imports/<importId>¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie	Paramètres
GET	Récupérer l’importation avec id <importId>	200	n/a	Imports	n/a
POST	Exécuter l’import avec id <importId>	204	n/a	n/a	async=true/false
PUT	Création d’importation ayant proposé id <importId>. Si l’id de projet devance le courant id (prochain), le code sera avancé. Si l’id proposé est inférieur ou égal à l’id courant, le courant servira. Cela permet à un système externe de dicter la gestion id.	201 with Location header	n/a	Imports	n/a
DELETE	Supprimer l’importation avec id <importId>	200	n/a	n/a	n/a

La représentation d’une importation est identique à celle contenue dans la réponse de création des importations. L’exécution d’une importation peut être une tâche longue, à ce titre, il est possible d’ajouter async=true à la demande pour le faire fonctionner de façon asynchrone, le client devra interroger la représentation importation et vérifier quand il atteint l’État “COMPLETE”.

Données¶

Une importation peut avoir une “données” qui représente la source de données à importer. Les données peuvent être de différents types, en particulier, “fichier”, “répertoire”, “mosaïque”, “database” et “à distance”. Lors de l’initialisation de l’importation, l’importateur fera analyser le contenu de ladite ressource et générer des tâches d’importation pour chaque donnée trouvée dedans.

La plupart des types de données sont discutées dans la section de la tâche, le seul type qui est spécifique au contexte toute importation est le “remote”, qui est utilisée pour demander à l’importateur de récupérer les données depuis un emplacement distant autonome, sans demander au client d’effectuer un téléchargement.

La représentation d’une ressource distante se présente comme suit:

"data": {
  "type": "remote",
  "location": "ftp://fthost/path/to/importFile.zip",
  "username": "user",
  "password": "secret",
  "domain" : "mydomain"
}

L’emplacement peut être n’importe laquelle URI pris en charge par les communes de VFS, y compris les serveurs HTTP et FTP. Le nom d'utilisateur , mot de passe et domaine éléments sont facultatifs et servent uniquement si le serveur distant demande une authentification de toutes sortes. Dans le cas où le fichier visé est compressé, il sera déballé car le téléchargement est terminé, et les tâches seront créés sur le résultat de déballage.

>>>>>>> 296f581... [GEOS-7049] Allow autonomous and asynchonous data fetching in importer REST api Tasks ^^^^^

/imports/<importId>/tasks¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer toutes les tâches d’importation avec l’id <importId>	200	n/a	Task Collection
POST	Créez une nouvelle tâche.	201 with Location header	Multipart form data	Tasks

Obtention de la liste des tâches¶

GET /imports/0/tasks

nous obtenons

Status: 200 OK
Content-Type: application/json

{
  "tasks": [
    {
      "id": 0,
      "href": "http://localhost:8080/geoserver/rest/imports/2/tasks/0",
      "state": "READY"
    }
  ]
}

Créer une nouvelle tâche dans le chargement d’un fichier¶

Une nouvelle tâche peut être créée par l’émission d’un POST à imports/<importId>/tasks comme un “Content-type: multipart/form-data” données codées multipart tel que défini par RFC 2388. Un ou plusieurs fichier peut être téléchargé de cette façon, et une tâche sera créée pour les importer. Dans le cas où le fichier en cours de téléchargement est un fichier zip, il sera décompressé sur le côté serveur et traitée comme un répertoire de fichiers.

La réponse à l’upload sera la création d’une nouvelle tâche, par exemple:

Status: 201 Created
Location: http://localhost:8080/geoserver/rest/imports/1/tasks/1
Content-type: application/json

{
  "task": {
    "id": 1,
    "href": "http://localhost:8080/geoserver/rest/imports/2/tasks/1",
    "state": "READY",
    "updateMode": "CREATE",
    "data": {
      "type": "file",
      "format": "Shapefile",
      "href": "http://localhost:8080/geoserver/rest/imports/2/tasks/1/data",
      "file": "bugsites.shp"
    },
    "target": {
      "href": "http://localhost:8080/geoserver/rest/imports/2/tasks/1/target",
      "dataStore": {
        "name": "shapes",
        "type": "PostGIS"
      }
    },
    "progress": "http://localhost:8080/geoserver/rest/imports/2/tasks/1/progress",
    "layer": {
      "name": "bugsites",
      "href": "http://localhost:8080/geoserver/rest/imports/2/tasks/1/layer"
    },
    "transformChain": {
      "type": "vector",
      "transforms": []
    }
  }
}

Création d’une tâche de téléchargement du formulaire¶

Ce mode de création assume le poste de imports/<importId>/tasks de forme url codée des données contenant un paramètre url:

Content-type: application/x-www-form-urlencoded

url=file:///data/spearfish/

La réponse de création sera le même que le téléchargement en plusieurs partie.

Ressource de tâche du seul¶

L’emplacement peut être n’importe quelle URI prise en charge par les communes de VFS, y compris les serveurs HTTP et FTP. Le `nom d'utilisateur` , `mot de passe` et `domaine` éléments sont facultatifs et servent uniquement si le serveur distant demande une authentification de toutes sortes. Dans le cas où le fichier visé est compressé, il sera déballé car le téléchargement est terminé, et les tâches seront créés sur le résultat de déballage.¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer la tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Task
PUT	Modifier la tâche avec l’id <taskId> importation avec l’id <importId>	200	Task	Task
DELETE	Supprimer la tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	n/a

La représentation d’une ressource de tâche est la même mentionnées dans la réponse de création de tâche.

Mise à jour d’une tâche¶

Une requête PUT sur une tâche existante peut être utilisée pour mettre à jour sa représentation. La représentation peut être partielle et ne contient que les éléments qui doivent être mis à jour.

L’updateMode d’une tâche démarre normalement qu’avec “Créer”, c’est-à-dire crée la ressource cible s’il manque. Les autres valeurs possibles sont “Remplacer”, c’est-à-dire supprimer les fonctionnalités existantes dans le calque cible et remplacer les avec la source de la tâche , ou “APPEND”, d’ajouter les fonctionnalités de la source de la tâche dans un calque existant.

La demande PUT suivante met à jour une tâche de “Création” au mode “APPEND”:

Content-Type: application/json

{
  "task": {
     "updateMode": "APPEND"
  }
}

Représentation de fichiers de répertoire¶

Les opérations suivantes sont spécifiques aux objets de données de type répertoire.

/imports/<importId>/task/<taskId>/data/files¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer la liste des fichiers pour une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Task

La réponse à une demande GET sera:

Status: 200 OK
Content-Type: application/json

{
        files: [
                {
                file: "tasmania_cities.shp",
                href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data/files/tasmania_cities.shp"
                },
                {
                file: "tasmania_roads.shp",
                href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data/files/tasmania_roads.shp"
                },
                {
                file: "tasmania_state_boundaries.shp",
                href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data/files/tasmania_state_boundaries.shp"
                },
                {
                file: "tasmania_water_bodies.shp",
                href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data/files/tasmania_water_bodies.shp"
                }
        ]
}

/imports/<importId>/task/<taskId>/data/files/<fileId>¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer le fichier avec l’id <fileId> à partir des données d’une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Task
DELETE	Supprimer un fichier spécifique de la tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	n/a

En suivant le lien pour arriver à la représentation d’un seul fichier, Notez comment dans ce cas un fichier principal peut être associé aux fichiers sidecar:

Status: 200 OK
Content-Type: application/json

{
        type: "file",
        format: "Shapefile",
        location: "C:\devel\gs_data\release\data\taz_shapes",
        file: "tasmania_cities.shp",
        href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data/files/tasmania_cities.shp",
        prj: "tasmania_cities.prj",
        other: [
                "tasmania_cities.dbf",
                "tasmania_cities.shx"
        ]
}

Extensions de mosaïque¶

Dans le cas où les données d’entrée sont de type mosaïque, nous avons tous les attributs typiques d’un répertoire, plus support pour spécifier directement l’horodatage d’un granule particulière.

Afin de préciser l’horodatage d’une option de vente une PUT demande peut être émise contre le granule:

Content-Type: application/json

{
   "timestamp": "2004-01-01T00:00:00.000+0000"
}

et la réponse sera:

Status: 200 OK
Content-Type: application/json

{
  "type": "file",
  "format": "GeoTIFF",
  "href": "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data/files/bm_200401.tif",
  "location": "/data/bluemarble/mosaic",
  "file": "bm_200401.tiff",
  "prj": null,
  "other": [],
  "timestamp": "2004-01-01T00:00:00.000+0000"
}

Vos données en base de données¶

Les opérations suivantes sont spécifiques aux objets de données de type database. À l’heure ou l’écriture, l’API REST n’autorise pas la création d’une source de données de base de données, mais il peut fournir une description lecture seule de celui qui a été créé à l’aide de l’interface graphique.

/imports/<importId>/tasks/<taskId>/data¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer les paramètres de connexion de base de données pour une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Liste des paramètres de connexion de base de données et tables disponibles

Effectuant un GET sur une base de données de type, entraînera la réponse suivante:

{
        type: "database",
        format: "PostGIS",
        href: "http://localhost:8080/geoserver/rest/imports/0/data",
        parameters: {
                schema: "public",
                fetch size: 1000,
                validate connections: true,
                Connection timeout: 20,
                Primary key metadata table: null,
                preparedStatements: true,
                database: "gttest",
                port: 5432,
                passwd: "cite",
                min connections: 1,
                dbtype: "postgis",
                host: "localhost",
                Loose bbox: true,
                max connections: 10,
                user: "cite"
        },
        tables: [
                "geoline",
                "geopoint",
                "lakes",
                "line3d",
        ]
}

Table de base de données¶

Les opérations suivantes sont spécifiques aux objets de données de type tableau. À l’heure ou l’écriture, l’API REST n’autorise pas la création d’une source de données de base de données, mais il peut fournir une description lecture seule de celui qui a été créé à l’aide de l’interface graphique. Une description de la table est normalement liée à la tâche et se réfère à une base de données liée à l’importation globale.

/imports/<importId>/tasks/<taskId>/data¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer la description de la table pour une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Une table de représentation

Effectuant un GET sur une base de données de type, entraînera la réponse suivante:

{
        type: "table",
        name: "abc",
        format: "PostGIS",
        href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/data"
}

Calque cible opérationnelle¶

/imports/<importId>/tasks/<taskId>/layer¶

La couche définit comment le calque cible sera créé

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer la couche d’une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Une couche de représentation JSON
PUT	Modifier le calque cible pour une tâche avec l’id <taskId> importation avec l’id <importId>	200	Task	Task

Demander la couche spéciale se traduira par ce qui suit:

Status: 200 OK
Content-Type: application/json

{
        layer: {
        name: "tasmania_cities",
        href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/layer",
        title: "tasmania_cities",
        originalName: "tasmania_cities",
        nativeName: "tasmania_cities",
        srs: "EPSG:4326",
        bbox: {
                minx: 147.2909004483,
                miny: -42.85110181689001,
                maxx: 147.2911004483,
                maxy: -42.85090181689,
                crs: "GEOGCS["WGS 84", DATUM["World Geodetic System 1984", SPHEROID["WGS 84", 6378137.0, 298.257223563, AUTHORITY["EPSG","7030"]], AUTHORITY["EPSG","6326"]], PRIMEM["Greenwich", 0.0, AUTHORITY["EPSG","8901"]], UNIT["degree", 0.017453292519943295], AXIS["Geodetic longitude", EAST], AXIS["Geodetic latitude", NORTH], AUTHORITY["EPSG","4326"]]"
        },
        attributes: [
                {
                        name: "the_geom",
                        binding: "com.vividsolutions.jts.geom.MultiPoint"
                },
                {
                        name: "CITY_NAME",
                        binding: "java.lang.String"
                },
                {
                        name: "ADMIN_NAME",
                        binding: "java.lang.String"
                },
                {
                        name: "CNTRY_NAME",
                        binding: "java.lang.String"
                },
                {
                        name: "STATUS",
                        binding: "java.lang.String"
                },
                {
                        name: "POP_CLASS",
                        binding: "java.lang.String"
                }
                ],
                style: {
                        name: "cite_tasmania_cities",
                        href: "http://localhost:8080/geoserver/rest/imports/0/tasks/0/layer/style"
                }
        }
}

Tous les attributs ci-dessus peuvent être mis à jour à l’aide d’une requête PUT. Même si la représentation ci-dessus est similaire à la config reste API, il ne faut pas le confondre avec lui, car il ne supporte pas toutes les mêmes propriétés, en particulier les propriétés prises en charge sont toutes celles énumérées ci-dessus.

Transformations de tâche¶

/imports/<importId>/tasks/<taskId>/transforms¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer la liste des transformations d’une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Une liste des transfromations au format JSON
POST	Créer une nouveau transormation et ajoutez-la à l’intérieur d’une tâche avec l’id <taskId> importation avec l’id <importId>	201	Une représentation de transformation de JSON	L’emplacement de la transformation

Récupération de la liste de transformation¶

Une requête GET pour la liste des transformations se traduira par la réponse suivante:

Status: 200 OK
Content-Type: application/json

{
  "transforms": [
    {
      "type": "ReprojectTransform",
      "href": "http://localhost:8080/geoserver/rest/imports/0/tasks/1/transforms/0",
      "source": null,
      "target": "EPSG:4326"
    },
    {
      "type": "DateFormatTransform",
      "href": "http://localhost:8080/geoserver/rest/imports/0/tasks/1/transforms/1",
      "field": "date",
      "format": "yyyyMMdd"
    }
  ]
}

En ajoutant une nouvelle transformation¶

Création d’une nouvelle transformation, affichant un document JSON avec une propriété de type identifier la catégorie de la transformation, ainsi que n’importe quel attribut supplémentaire requis par la transformation elle-même (il s’agit de transformation spécifique, que chacun d’eux utilise un ensemble différent d’attributs).

La requête POST suivante crée un type d’attribut remappage:

Content-Type: application/json

{
   "type": "AttributeRemapTransform",
   "field": "cat",
   "target": "java.lang.Integer"
}

La réponse sera:

Status: 201 OK
Location: http://localhost:8080/geoserver/rest/imports/0/tasks/1/transform/2

/imports/<importId>/tasks/<taskId>/transforms/<transformId>¶

Méthode	Action	Code de statut/en-têtes	Entrée	Sortie
GET	Récupérer une transformation identifiée par <transformId> à l’intérieur d’une tâche avec l’id <taskId> importation avec l’id <importId>	200	n/a	Une seule transformation au format JSON
PUT	Modifie la définition d’une transformation identifiée par <transformId> à l’intérieur d’une tâche avec l’id <taskId> importation avec l’id <importId>	200	Une représentation de transformation JSON (éventuellement juste la partie de celui-ci qui doit être modifiée)	La représentation de la transformation complète
DELETE	Supprime la transformation identifiée par <transformId> à l’intérieur d’une tâche avec l’id <taskId> importation avec l’id <importId>	200	Une représentation de transformation JSON (éventuellement juste la partie de celui-ci qui doit être modifiée)	La représentation de la transformation complète

Récupérer une seule transformation¶

Demander une seule transformation par identificateur se traduira par la réponse suivante:

Status: 200 OK
Content-Type: application/json

{
  "type": "ReprojectTransform",
  "href": "http://localhost:8080/geoserver/rest/imports/0/tasks/1/transforms/0",
  "source": null,
  "target": "EPSG:4326"
}

Modifier une transformation existante¶

En supposant que nous avons une transformation de la reprojection, et qu’il faut changer le type de cible SRS, la demande PUT suivante va faire le travail:

Content-Type: application/json
{
   "type": "ReprojectTransform",
   "target": "EPSG:3005"
}

La réponse sera:

Status: 200 OK
    Content-Type: application/json

    {
      "type": "ReprojectTransform",
      "href": "http://localhost:8080/geoserver/rest/imports/0/tasks/1/transform/0",
      "source": null,
      "target": "EPSG:3005"
    }

Référence de la transformation¶

AttributeRemapTransform¶

Remappe un certain champ d’un type de données cible donnée

Paramètre	Facultatif	Description
champ	N	Le nom du champ à été remappé
target	N	Le champ “cible” type, comme un nom de classe qualifié complet Java

AttributesToPointGeometryTransform¶

Deux champs de type numérique latField et lngField transforme une représentation de la géométrie de point POINT(lngField,latField), les sources de champs seront supprimées.

Paramètre	Facultatif	Description
latField	N	Le champ “latitude”
lngField	N	Le champ “longitude”

CreateIndexTransform¶

Pour les objectifs de base de données seulement, crée un index sur une colonne donnée après avoir importé les données dans la base de données

Paramètre	Facultatif	Description
champ	N	Le champ à indexer

DateFormatTransform¶

Analyse une représentation sous forme de chaîne d’une date dans un objet Date/Timestamp

Paramètre	Facultatif	Description
champ	N	Le domaine à analyser
format	Y	Une date de l’analyse de modèle, le programme d’installation en utilisant le Java SimpleDateFormat syntaxe. Dans le cas où il est absent, un certain nombre de mises en forme intégrées est jugée à la place (formats de date ISO courte et complet, dates sans séparateur).

IntegerFieldToDateTransform¶

Prend un champ de type entier et transforme le à une date, interpréter le champ comme une date

Paramètre	Facultatif	Description
champ	N	Le champ contenant les informations de l’année

ReprojectTransform¶

Reprojects une couche vecteur d’une source de CRS à une cible CRS

Paramètre	Facultatif	Description
source	Y	Identificateur de la source référentiel (celui natif sera utilisé si absent)
target	N	Identificateur du système de coordonnées de référence cible

GdalTranslateTransform¶

S’applique gdal_translate à un seul fichier raster d’entrée. gdal_translate a besoin pour se trouver dans le chemin d’accès utilisé par le conteneur web exécutant GeoServer.

Paramètre	Facultatif	Description
options	N	Tableau des options qui seront transmises à ``gdal_translate``(à côté des noms d’entrée et de sortie, qui sont gérés en interne)

GdalWarpTransform¶

Applies gdalwarp to a single file raster input. Requires gdalwarp to be inside the PATH used by the web container running GeoServer.

Paramètre	Facultatif	Description
options	N	Tableau des options qui seront transmis à ``gdalwarp``(à côté des noms d’entrée et de sortie, qui sont gérés en interne)

GdalAddoTransform¶

Appliquer gdaladdo à un seul fichier raster d’entrée. gdaladdo a besoin de se trouver dans le chemin d’accès utilisé par le conteneur web exécutant GeoServer.

Paramètre	Facultatif	Description
options	N	Tableau d’options qui seront passées aux ``gdaladdo``(à côté de nom de fichier d’entrée, qui est géré en interne)
niveaux	N	Tableau d’entiers avec les niveaux de présentation qui seront passés au `gdaladdo`