From a1506c9d8f77f20ef2cd98ebed409cd1aa5846a8 Mon Sep 17 00:00:00 2001
From: lgrd
Date: Thu, 7 May 2020 14:05:57 +0200
Subject: [PATCH 01/14] feat(isochrone): appel au nouveau service d'isochrone
---
package.json | 4 +-
src/Services/DefaultUrlService.js | 10 +-
.../ProcessIsoCurve/ProcessIsoCurve.js | 133 +++++++++----
.../Request/ProcessIsoCurveRequest.js | 178 +++++-------------
.../Request/model/ProcessIsoCurveParam.js | 144 ++++++++------
src/Services/Services.js | 16 +-
6 files changed, 245 insertions(+), 240 deletions(-)
diff --git a/package.json b/package.json
index e13353ba..1c3ddf8d 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
{
"name": "geoportal-access-lib",
- "version": "2.1.6",
- "date": "03/10/2019",
+ "version": "2.1.8-alpha.1",
+ "date": "04/05/2020",
"description": "French Geoportal resources access library",
"module": "src/Gp.js",
"main": "dist/GpServices-src.js",
diff --git a/src/Services/DefaultUrlService.js b/src/Services/DefaultUrlService.js
index b2e84a72..7b2f7414 100644
--- a/src/Services/DefaultUrlService.js
+++ b/src/Services/DefaultUrlService.js
@@ -108,20 +108,14 @@ var DefaultUrlService = {
* @property {Function} url (key) - Returns isocurve service default urls with or without geoportal access key given as a parameter. The result is a javascript object with different urls given used protocols ("iso-json" or "iso-xml").
*/
ProcessIsoCurve : {
- _key : {
- "iso-json" : "/isochrone/isochrone.json", // rest (geoconcept)
- "iso-xml" : "/isochrone/isochrone.xml" // rest (geoconcept)
- },
+ _key : "simple/1.0.0/isochrone",
/**
* url
* @param {String} key - key
* @returns {String} url
*/
url : function (key) {
- return {
- "iso-json" : DefaultUrlService.url(key, this._key["iso-json"]),
- "iso-xml" : DefaultUrlService.url(key, this._key["iso-xml"])
- };
+ return DefaultUrlService.url(key, this._key);
}
},
/**
diff --git a/src/Services/ProcessIsoCurve/ProcessIsoCurve.js b/src/Services/ProcessIsoCurve/ProcessIsoCurve.js
index bb9ecbbc..fa4032ed 100644
--- a/src/Services/ProcessIsoCurve/ProcessIsoCurve.js
+++ b/src/Services/ProcessIsoCurve/ProcessIsoCurve.js
@@ -6,6 +6,7 @@ import CommonService from "../CommonService";
import DefaultUrlService from "../DefaultUrlService";
import ProcessIsoCurveRequest from "./Request/ProcessIsoCurveRequest";
import ProcessIsoCurveResponseFactory from "./Response/ProcessIsoCurveResponseFactory";
+import TileMatrixSet from "../AutoConf/Response/model/TileMatrixSet";
/**
* @classdesc
@@ -17,11 +18,10 @@ import ProcessIsoCurveResponseFactory from "./Response/ProcessIsoCurveResponseFa
* @extends {Gp.Services.CommonService}
* @alias Gp.Services.ProcessIsoCurve
* @param {Object} options - options spécifiques au service (+ les options heritées)
+ *
+ * @param {String} options.resource - La ressource utilisée pour le calcul. Ce paramètre devrait être obligatoire car il l'est dans l'appel au service. Mais il ne l'est pas pour des raisons de rétrocompatibilité.
*
- * @param {String} options.outputFormat - Le format de la réponse du service iso : 'xml' ou 'json'.
- * Ce paramètre déterminera l'extension '.xml' ou '.json' du service.
- * Nécessaire si serverUrl est renseigné pour connaître le format dans lequel sera fournie la réponse (pour son traitement).
- * Par défaut, ce paramètre vaut 'json'.
+ * @param {String} options.outputFormat - Le format de la réponse du service iso : 'json' uniquement et par défaut.
*
* @param {Object} options.position - Point de départ du calcul.
* Coordonnées exprimées en longitudes, latitudes (EPSG:4326)
@@ -36,14 +36,25 @@ import ProcessIsoCurveResponseFactory from "./Response/ProcessIsoCurveResponseFa
* @param {String} [options.graph = "voiture"] - Nom du graphe à utiliser pour le calcul (« Pieton » ou « Voiture »).
* La valeur par défaut est : «voiture»
*
- * @param {Array.} [options.exclusions] - Critères d'exclusions à appliquer pour le calcul.
+ * @param {Array.} [options.exclusions] - DEPRECATED: Ce paramètre est conservé pour une rétrocompatibilité de l'api. Le nouveau paramètre à utiliser est options.constraints.
+ * Critères d'exclusions à appliquer pour le calcul.
* On précise ici le type de tronçons que l'on ne veut pas que l'isochrone/distance emprunte
* (valeurs possibles : « toll » (éviter les péages), « bridge », « tunnel »).
*
+ * @param {Object[]} [options.constraints] - Critères de contraintes à appliquer sur un itinéraire. Les valeurs disponibles dépendent de la ressource utilisée. Il est donc utile de regarder le getCapabilities.
+ * @param {String} [options.constraints.constraintType] - Type de la contrainte. Généralement "banned".
+ * @param {String} [options.constraints.key] - Clé de la contrainte. Généralement "wayType".
+ * @param {String} [options.constraints.operator] - Opérateur de la contrainte. Généralement "=".
+ * @param {String} [options.constraints.value] - Valeur de la contrainte. Généralement "autoroute".
+ *
* @param {String} [options.method = "time"] - Méthode utilisée pour le calcul de la courbe iso.
* Les valeurs possible sont "time" pour un calcul d'isochrone, "distance" pour un calcul d'isodistance.
* Pas de valeur spécifié équivaut à un calcul d'isochrone.
- *
+ *
+ * @param {String} [options.distanceUnit = "km"] - Indique si la distance doit être exprimée en km ou m dans la réponse ("m" or "km").
+ *
+ * @param {String} [options.timeUnit = "standard"] - Indique si la durée doit être exprimée en seconde, minute ou heure dans la réponse ("standard", "second", "minute", "hour"). Il peut-être formatté hh:mm::ss avec la valeur standard.
+ *
* @param {Float} options.time - Durée maximum (exprimée en secondes) à utiliser pour le calcul de la courbe à partir du ou jusqu'au point « location ».
* Ce paramètre doit être renseigné si l'option "méthod" a la valeur "time".
* Si l'option method n'est pas renseignée, ce paramètre doit être renseigné.
@@ -82,11 +93,8 @@ import ProcessIsoCurveResponseFactory from "./Response/ProcessIsoCurveResponseFa
* distance : 200,
* [time : ]
* method : "distance",
- * exclusions : ["Bridge", "Tunnel", "Toll"],
* graph : "voiture",
- * reverse : false,
- * smoothing : false,
- * holes : false
+ * reverse : false
* };
* @private
*/
@@ -149,22 +157,98 @@ function ProcessIsoCurve (options) {
this.options.method = this.options.method || "time";
// options par defaut du service
+ // TODO: modifier lors de la mise en production du service
+ this.options.resource = options.resource || "bduni-idf-osrm";
this.options.exclusions = options.exclusions || null;
- this.options.graph = options.graph || "Voiture"; // TODO test de la valeur à faire !
this.options.reverse = options.reverse || false;
- this.options.smoothing = options.smoothing || false;
- this.options.holes = options.holes || false;
this.options.srs = options.srs || "EPSG:4326";
+ this.options.distanceUnit = options.distanceUnit || "km";
+ this.options.timeUnit = options.timeUnit || "standard";
+
+ //options depreciees
+ if (options.smoothing) {
+ this.logger.warn("options.smoothing is DEPRECATED");
+ }
+ this.options.smoothing = false;
+ if (options.holes) {
+ this.logger.warn("options.holes is DEPRECATED");
+ }
+ this.options.holes = false;
+
+ // Gestion du graphe
+ if (options.graph) {
+ if (options.graph === "Voiture") {
+ this.options.graph = "car";
+ }
+ if (options.graph === "Pieton") {
+ this.options.graph = "pedestrian";
+ }
+ } else {
+ this.options.graph = "car";
+ }
+
+ // Gestions des contraintes
+ this.options.constraints = [];
+ if (options.constraints) {
+ if (Array.isArray(options.constraints)) {
+ for (var k = 0; k < options.constraints.length; k++) {
+ this.options.constraints.push(options.constraints[k]);
+ }
+ } else {
+ throw new Error(_.getMessage("PARAM_TYPE", "constraints"));
+ }
+ }
+
+ // Gestion de l'ancien paramètre exclusions
+ var constraintTunnel = {};
+ var constraintPont = {};
+ var constraintAutoroute = {};
+ if (options.exclusions) {
+ if (options.exclusions.length !== 0) {
+ this.logger.warn("options.exclusions is DEPRECATED !!");
+ for(var c = 0; c < options.exclusions.length; c++) {
+ if (typeof options.exclusions[c] === "string") {
+ options.exclusions[c] = options.exclusions[c].toLowerCase();
+ } else {
+ // on ne crée pas une erreur pour rétro-compatibilité avec les anciennes versions
+ continue;
+ }
+ if (options.exclusions[c] === "toll") {
+ constraintAutoroute.constraintType = "banned";
+ constraintAutoroute.key = "wayType";
+ constraintAutoroute.operator = "=";
+ constraintAutoroute.value = "autoroute";
+ this.options.constraints.push(constraintAutoroute);
+ }
+ if (options.exclusions[c] === "tunnel") {
+ constraintTunnel.constraintType = "banned";
+ constraintTunnel.key = "wayType";
+ constraintTunnel.operator = "=";
+ constraintTunnel.value = "tunnel";
+ this.options.constraints.push(constraintTunnel);
+ }
+ if (options.exclusions[c] === "bridge") {
+ constraintPont.constraintType = "banned";
+ constraintPont.key = "wayType";
+ constraintPont.operator = "=";
+ constraintPont.value = "pont";
+ this.options.constraints.push(constraintPont);
+ }
+ }
+ }
+ }
// on passe l'option outputFormat en minuscules afin d'éviter des exceptions.
this.options.outputFormat = (typeof options.outputFormat === "string") ? options.outputFormat.toLowerCase() : "json";
+ if (options.outputFormat && options.outputFormat !== "json") {
+ this.logger.warn("options.outputFormat could only be json");
+ }
+ this.options.outputFormat = "json";
// gestion de l'url du service par defaut
// si l'url n'est pas renseignée, il faut utiliser les urls par defaut
if (!this.options.serverUrl) {
- var lstUrlByDefault = DefaultUrlService.ProcessIsoCurve.url(this.options.apiKey);
-
- var urlFound = lstUrlByDefault["iso" + "-" + this.options.outputFormat];
+ var urlFound = DefaultUrlService.ProcessIsoCurve.url(this.options.apiKey);
if (!urlFound) {
throw new Error("Url by default not found !");
}
@@ -172,23 +256,6 @@ function ProcessIsoCurve (options) {
this.logger.trace("Serveur URL par defaut : " + this.options.serverUrl);
}
- // gestion du type de service
- // si l'extension de l'url est .json ou .xml, on surcharge le format de sortie (outputFormat)
- var idx = this.options.serverUrl.lastIndexOf(".");
- if (idx !== -1) {
- var extension = this.options.serverUrl.substring(idx + 1);
- if (extension && extension.length < 5) { // FIXME extension de moins de 4 car. ...
- this.logger.trace("Serveur Extension URL : " + extension);
- switch (extension.toLowerCase()) {
- case "json":
- case "xml":
- this.options.outputFormat = extension.toLowerCase();
- break;
- default:
- throw new Error("type of service : unknown or unsupported (json or xml) !");
- }
- }
- }
}
/**
diff --git a/src/Services/ProcessIsoCurve/Request/ProcessIsoCurveRequest.js b/src/Services/ProcessIsoCurve/Request/ProcessIsoCurveRequest.js
index eb81af40..8df2a870 100644
--- a/src/Services/ProcessIsoCurve/Request/ProcessIsoCurveRequest.js
+++ b/src/Services/ProcessIsoCurve/Request/ProcessIsoCurveRequest.js
@@ -7,7 +7,7 @@ import ProcessIsoCurveParam from "./model/ProcessIsoCurveParam";
* @classdesc
* Classe de gestion des requêtes sur le service de calcul d'isoschrone/isodistance.
* Les requêtes peuvent être en mode GET ou POST,
- * et le format de sorti est en JSON ou en XML.
+ * et le format de sorti est en JSON.
*
* @constructor
* @alias Gp.Services.ProcessIsoCurve.Request.ProcessIsoCurveRequest
@@ -17,17 +17,14 @@ import ProcessIsoCurveParam from "./model/ProcessIsoCurveParam";
* var options = {
* httpMethod : 'GET', // GET|POST
* // spécifique au service
- * exclusions : ['Bridge', 'Tunnel'],
* position : {
* x : 2.3242664298058053,
* y : 48.86118017324745
* },
- * graph : "Voiture",
+ * graph : "car",
* method : 'time',
* time : 1000, //distance : 200
* reverse : false,
- * smoothing : false,
- * holes : false,
* srs : 'EPSG:4326'
* };
*
@@ -88,87 +85,35 @@ ProcessIsoCurveRequest.prototype = {
*/
constructor : ProcessIsoCurveRequest,
- /**
- * Template de la requête (POST)
- * * __X__ __Y__ __SRS__ __GRAPHNAME__ __METHOD__ (obligatoire)
- * * __REVERSE__ __SMOOTHING__ __HOLES__ (par defaut)
- * * __TIME__ __TIMEVALUE__ (choix)
- * * __DISTANCE__ __DISTANCEVALUE__ (choix)
- * * __EXCLUSIONS__ __EXCLUSIONFEATURE__ __EXCLUSIONVALUE__ (optionnel)
- * * __PROFIL__ __PROFILID__ __PROFILNAME__ (très optionnel)
- * * __ID__ __IDVALUE__ (très optionnel)
- */
- template : {
- container : "\n" +
- "\n" +
- "__ID__" +
- "\t\n" +
- "\t\t__X__\n" +
- "\t\t__Y__\n" +
- "\t\n" +
- "\t__SRS__\n" +
- "\t__GRAPHNAME__\n" +
- "__PROFIL__" +
- "__EXCLUSIONS__" +
- "\t__METHOD__\n" +
- "__TIME__" +
- "__DISTANCE__" +
- "\t__REVERSE__\n" +
- "\t__SMOOTHING__\n" +
- "\t__HOLES__\n" +
- "",
- id : "\t__IDVALUE__\n",
- profil : "\t__PROFILID__\n" + "\t__PROFILNAME__\n",
- exclusions : {
- container : "\t\n" +
- "__EXCLUSIONFEATURE__\n" +
- "\t\n",
- feature : "\t\t__EXCLUSIONVALUE__"
- },
- time : "\t\n",
- distance : "\t__DISTANCEVALUE__\n"
- },
-
/**
* Construction de la requête.
*
* @example
* // GET out :
- * // (http://wxs.ign.fr/KEY/isochrone/isochrone.json?)
- * // location=&
- * // time=& ou distance=&
- * // method="DISTANCE|TIME"&
- * // graph=Pieton&
- * // graphName=Pieton&
- * // exclusions=&
- * // reverse=10&
- * // smoothing=&
- * // holes=&
- * // srs=
+ * // (http://wxs.ign.fr/KEY/isochrone?)
+ * // resource=&
+ * // point=&
+ * // costValue=&
+ * // costType=&
+ * // profile=&
+ * // constraints=&
+ * // direction=&
+ * // crs=
*
* // POST out :
- * //
- * //
- * // 1
- * //
- * // -1.557189
- * // 47.217122
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
- * //
+ * {
+ * resource: "bduni-idf-pgr",
+ * point: "2.337306,48.849319",
+ * costValue: 100,
+ * costType: "time",
+ * profile: "car",
+ * constraints: [{
+ * constraintType: "banned",
+ * key: "ways_type",
+ * operator: "=",
+ * value: "autoroute"
+ * }]
+ * }
*
* @returns {String} request
*/
@@ -196,64 +141,39 @@ ProcessIsoCurveRequest.prototype = {
case "POST":
this.logger.trace("Process POST Request");
+ // creation du JSON
+ var postRequest = {};
- request = this.template.container;
+ postRequest.resource = this.settings.resource;
- // options non prises en compte car non implémentées !
- // clean : id
- request = request.replace(/__ID__/g, "");
- // clean : profil
- request = request.replace(/__PROFIL__/g, "");
+ postRequest.point = this.settings.position.x + "," + this.settings.position.y;
+
+ if (this.options.method === "distance") {
+ this.costType = "distance";
+ this.costValue = this.options.distance;
+ } else {
+ this.costType = "time";
+ this.costValue = this.options.time;
+ }
+
+ postRequest.profile = this.settings.graph;
- // options obligatoires
- request = request.replace(/__X__/g, this.settings.position.x);
- request = request.replace(/__Y__/g, this.settings.position.y);
- request = request.replace(/__GRAPHNAME__/g, this.settings.graph);
+ if (this.settings.reverse) {
+ postRequest.direction = "arrival";
+ } else {
+ postRequest.direction = "departure";
+ }
- // options par defaut
- request = request.replace(/__SRS__/g, this.settings.srs);
- request = request.replace(/__SMOOTHING__/g, this.settings.smoothing);
- request = request.replace(/__HOLES__/g, this.settings.holes);
- request = request.replace(/__REVERSE__/g, this.settings.reverse);
+ postRequest.constraints = this.settings.constraints;
- // options conditionnelles
+ postRequest.distanceUnit = this.settings.distanceUnit;
- // exclusions
- if (this.settings.exclusions) {
- var tmplExclusions = this.template.exclusions.container;
- var exclusions = [];
- for (i = 0; i < this.settings.exclusions.length; i++) {
- var tmplFeature = this.template.exclusions.feature;
- tmplFeature = tmplFeature.replace(/__EXCLUSIONVALUE__/, this.settings.exclusions[i]);
- exclusions.push(tmplFeature);
- }
- tmplExclusions = tmplExclusions.replace(/__EXCLUSIONFEATURE__/, exclusions.join("\n"));
- request = request.replace(/__EXCLUSIONS__/g, tmplExclusions);
- }
- // clean exclusions
- request = request.replace(/__EXCLUSIONS__/g, "");
+ postRequest.timeUnit = this.settings.timeUnit;
- // distance
- if (this.settings.distance) {
- var tmplDistance = this.template.distance;
- tmplDistance = tmplDistance.replace(/__DISTANCEVALUE__/g, this.settings.distance);
- request = request.replace(/__DISTANCE__/g, tmplDistance);
- // method
- request = request.replace(/__METHOD__/g, "distance");
- }
- // clean
- request = request.replace(/__DISTANCE__/g, "");
+ postRequest.crs = this.settings.srs;
- // time
- if (this.settings.time) {
- var tmplTime = this.template.time;
- tmplTime = tmplTime.replace(/__TIMEVALUE__/g, this.settings.time);
- request = request.replace(/__TIME__/g, tmplTime);
- // method
- request = request.replace(/__METHOD__/g, "time");
- }
- // clean
- request = request.replace(/__TIME__/g, "");
+ // conversion en chaîne de caractères
+ request = JSON.stringify(postRequest);
break;
default:
diff --git a/src/Services/ProcessIsoCurve/Request/model/ProcessIsoCurveParam.js b/src/Services/ProcessIsoCurve/Request/model/ProcessIsoCurveParam.js
index 9aa419fb..bc1f2470 100644
--- a/src/Services/ProcessIsoCurve/Request/model/ProcessIsoCurveParam.js
+++ b/src/Services/ProcessIsoCurve/Request/model/ProcessIsoCurveParam.js
@@ -31,49 +31,40 @@ function ProcessIsoCurveParam (options) {
/** Identifiant de l’isochrone */
this.id = this.options.id;
+ /** Resource */
+ this.resource = this.options.resource;
+
/** Coordonnées de départ (ou arrivée si le reverse est à true). */
- this.location = this.options.position;
+ this.point = this.options.position;
/** projection (code EPSG comme epsg:4326 ou wgs84) */
- this.srs = this.options.srs;
+ this.crs = this.options.srs;
/**
* Profil de véhicule à utiliser pour le calcul.
* Voiture ou Pieton
*/
- this.graphName = this.options.graph;
-
- /**
- * Identifiant et nom du véhicule
- * FIXME non utilisé
- */
- this.profileId = this.options.profileId || null; // TODO !
- this.profileName = this.options.profileName || null; // TODO !
+ this.profile = this.options.graph;
/** Liste des règles de restrictions à utiliser */
- this.exclusions = this.options.exclusions;
+ this.constraints = this.options.constraints;
this.reverse = this.options.reverse;
- this.smoothing = this.options.smoothing;
- this.holes = this.options.holes;
+
+ this.timeUnit = this.options.timeUnit;
+
+ this.distanceUnit = this.options.distanceUnit;
/**
* "time" pour isochrone ou "distance" for isodistance.
* Par defaut, time...
*/
- var value = this.options.method;
- switch (value) {
- case "time":
- this.method = "time";
- this.time = this.options.time;
- break;
- case "distance":
- this.method = "distance";
- this.distance = this.options.distance;
- break;
- default:
- this.logger.warn("Par defaut, on calcule un isochrone !");
- this.method = "time";
+ if (this.options.method === "distance") {
+ this.costType = "distance";
+ this.costValue = this.options.distance;
+ } else {
+ this.costType = "time";
+ this.costValue = this.options.time;
}
}
@@ -94,19 +85,52 @@ ProcessIsoCurveParam.prototype = {
constructor : ProcessIsoCurveParam,
/**
- * Retourne la liste des exclusions
+ * Retourne le point
* @returns {String} x,y
*/
getLocation : function () {
- return this.location.x + "," + this.location.y;
+ return this.point.x + "," + this.point.y;
+ },
+
+ /**
+ * Retourne l'unité de temps
+ * @returns {String}
+ */
+ getTimeUnit : function () {
+ if (this.distanceUnit === "m") {
+ return "meter";
+ }
+ if (this.distanceUnit === "km") {
+ return "kilometer";
+ }
+ return "";
+ },
+
+ /**
+ * Retourne la liste des contraintes
+ * @returns {String}
+ */
+ getConstraints : function () {
+ var constraintArray = [];
+
+ if (this.constraints.length !== 0) {
+ for (var k = 0; k < this.constraints.length; k++) {
+ constraintArray.push(JSON.stringify(this.constraints[k]));
+ }
+ }
+ return constraintArray.join("|");
},
/**
- * Retourne la liste des exclusions
- * @returns {String} exclusions
+ * Retourne la direction
+ * @returns {String}
*/
- getExclusions : function () {
- return this.exclusions.join(";");
+ getDirection : function () {
+ if (this.reverse) {
+ return "arrival";
+ } else {
+ return "departure";
+ }
}
};
@@ -119,60 +143,56 @@ ProcessIsoCurveParam.prototype.getParams = function () {
var map = [];
map.push({
- k : "location",
- v : this.getLocation()
+ k : "resource",
+ v : this.resource
});
map.push({
- k : "smoothing",
- v : this.smoothing
+ k : "point",
+ v : this.getLocation()
});
map.push({
- k : "holes",
- v : this.holes
+ k : "direction",
+ v : this.getDirection()
});
map.push({
- k : "reverse",
- v : this.reverse
+ k : "costType",
+ v : this.costType
});
map.push({
- k : "method",
- v : this.method
+ k : "costValue",
+ v : this.costValue
});
- if (this.time) {
- map.push({
- k : "time",
- v : this.time
- });
- }
+ map.push({
+ k : "profile",
+ v : this.profile
+ });
- if (this.distance) {
- map.push({
- k : "distance",
- v : this.distance
- });
- }
+ map.push({
+ k : "timeUnit",
+ v : this.timeUnit
+ });
map.push({
- k : "graphName",
- v : this.graphName
+ k : "distanceUnit",
+ v : this.getDistanceUnit()
});
- if (this.exclusions) {
+ if (this.crs) {
map.push({
- k : "exclusions",
- v : this.getExclusions()
+ k : "crs",
+ v : this.crs
});
}
- if (this.srs) {
+ if (this.constraints) {
map.push({
- k : "srs",
- v : this.srs
+ k : "constraints",
+ v : this.getConstraints()
});
}
diff --git a/src/Services/Services.js b/src/Services/Services.js
index 476f5ea0..253c53bb 100644
--- a/src/Services/Services.js
+++ b/src/Services/Services.js
@@ -228,19 +228,23 @@ var Services = {
* @method isoCurve
* @param {Object} options - Options for function call.
* @param {String} options.apiKey - Access key to Geoportal platform, obtained [here]{@link http://professionnels.ign.fr/ign/contrats}.
+ * @param {String} options.resource - Resource used to compute the route. Available values are in the GetCapabilities.
* @param {Gp.Point} options.position - Start or Arrival (options.reverse===true) Point for the computing. Expressed in CRS:84 coordinates system (position.x corresponds to longitude, position.y corresponds to latitude).
- * @param {String} [options.graph = "Voiture"] - User profile to use to compute the isoCurve : "Voiture" (using a vehicule) or "Pieton" (pedestrian). Has an influence on the kind of roads to use and the average speed.
- * @param {Array.} [options.exclusions] - Indicates if route has to avoid some features ("toll", "bridge" or "tunnel").
- * @param {String} [options.method = "time"] - Computing method to use : "time" (using a duration as a constraint) or "distance" (using a distance as a constraint).
+ * @param {String} [options.graph = "Voiture"] - User profile to use to compute the isoCurve : "Voiture" (using a vehicule) or "Pieton" (pedestrian). Has an influence on the kind of roads to use and the average speed. Available values are in the GetCapabilities.
+ * @param {Array.} [options.exclusions] - DEPRECATED: use options.constraints. Indicates if route has to avoid some features ("toll", "bridge" or "tunnel").
+ * @param {Array.
-
+
+