arcOrama: Le blog consacré à ArcGIS et aux technologies SIG Esri

Affichage des articles dont le libellé est Arcade. Afficher tous les articles

Optimiser ses expressions Arcade avec 5 fonctions souvent sous-utilisées

Arcade est un langage d'expression qui vous permet de créer du contenu personnalisé dans des fenêtres contextuelles, de formater des étiquettes, de créer des comportements dans les formulaires intelligents, de créer de nouvelles valeurs de données pour les cartes web et les tableaux de bord ou encore d'appliquer des règles dans divers flux de travail. J'ai déjà évoqué sur arcOrama les fonctions de base d'Arcade à partir d'exemples concrets ainsi que des cas d'usages plus avancés. Beaucoup d'entre vous utilise donc Arcade au quotidien car c'est simple et puissant.

Je vois beaucoup d'expressions Arcade réalisées par des utilisateurs ArcGIS et je les aide parfois à les améliorer. Au fil du temps, j'ai remarqué que certaines peuvent être simplifiés ou améliorées en utilisant des fonctions Arcade prêtes à l'emploi. La plupart du temps, les auteurs d'expressions ne connaissent pas certaines fonctionnalités d'Arcade qui leur manquent. Dans cet article, je vais évoquer 5 fonctions Arcade méconnues et donc sous-utilisées et j'essayerai de vous montrer comment elles peuvent améliorer vos expressions.

1. La fonction "IIf"

La fonction IIf renvoie une valeur si une expression conditionnelle prend la valeur true, et renvoie une autre valeur si la condition prend la valeur false. Ceci est particulièrement utile dans des scénarios simples tels que l'écriture d'une expression pour indiquer quand une valeur a atteint un seuil.

Généralement, dans vos expressions, vous utilisez des blocs if-else pour renvoyer des valeurs de manière conditionnelle. Par exemple, comme ceci :

// Si la valeur est supérieure à 100 retourner "fort"
// Sinon, retourner "faible"

var categorie = "";

if($feature.value > 100){
    categorie = "fort";
} else {
    categorie = "faible";
}
return categorie;

Cependant, la fonction IIf simplifie cela en deux lignes sans avoir besoin de plusieurs retours ou affectations de variables…

// Si la valeur est supérieure à 100 retourner "fort"
// Sinon, retourner "faible"

var categorie = IIF($feature.value > 100, "fort", "faible");
return categorie;

…ou à une seule ligne (grâce aux retours implicites).

IIF($feature.value > 100, "fort", "faible");

Bien entendu, il n'y a pas d'erreur à utiliser un bloc if-else pour renvoyer un contenu conditionnel. En fait, vous devez utiliser des instructions if-else si vous devez évaluer d'autres instructions qui suivent les mêmes conditions, y compris l'affectation de valeurs à des variables. Dans l'exemple suivant, la fonction IIf n'est pas appropriée car plusieurs affectations de variables ont lieu si la condition est vraie.

if($feature.value > 100){
  pourcentAuDessus = $feature.value - 100;
  categorie = "fort";
} else {
  category = "faible";
}
return `${categorie} (${pourcentAuDessus}%)`;

Retenez donc que lorsque vous avez à renvoyer une valeur basée sur une condition simple, IIf condensera et simplifiera votre expression.

2. La fonction "Text"

La fonction Text convertit une valeur de n'importe quel type de données Arcade en une valeur de type texte équivalente. Vous trouverez cette fonction particulièrement utile lors du formatage des dates, mais j'ai vu beaucoup d'expressions qui implémentent des logiques supplémentaires pour le formatage des nombres alors qu'elles pourraient être évitées simplement en tirant parti de Text.

Cela est par exemple vrai lorsqu'il s'agit d'arrondir des nombres. Vous vous demandez peut-être : pourquoi devrais-je utiliser Text pour arrondir les nombres alors qu'Arcade a déjà une fonction d'arrondi ? Par exemple, ce modèle est très courant :

Round(($feature.diplomes/$feature.PopulationAdulte) * 100, 1) + “%”;
// retourne "37.8%";

Cependant, Text vous offre une option % afin que vous n'ayez pas à faire le calcul de conversion d'un nombre décimal (0-1) en pourcentage.

Text($feature.diplomes/$feature.PopulationAdulte, "#.#%");
// retourne "37.8%";

Mais est-ce que votre expression Text est vraiment meilleure dans ce cas ? Oui car les deux approches sont différentes car Round renvoie un nombre alors Text renvoie une valeur de type texte. Voici pourquoi cette distinction est importante :

Round modifie la précision des nombres que vous utilisez pour les calculs dans une expression sans réellement formater la valeur. Text vous permet de formater un nombre en fonction d'un modèle de formatage. Bien que Text permette d'arrondir les nombres, il vous permet également de spécifier des séparateurs pour les grands nombres. En bref, Round peut arrondir vos nombres décimaux, mais la fonction Text arrondira et ajoutera des séparateurs de chiffres aux grands nombres.

Cependant, le plus grand avantage de l'utilisation Text est que la mise en forme définie dans la fonction sera conforme aux paramètres régionaux de l'application dans laquelle l'expression s'exécute. Round ne vous donne pas cet avantage.

Consultez les exemples suivants et notez les différences. Le texte renvoie toujours un résultat plus propre et plus correct.

var v = 2891.378268263982736;
Round(v, 2);
// retourne 2891.38 en anglais, sans séparateur de milliers
// retourne 2891.38 en français (mauvais séparateur de décimales), sans séparateur de milliers 

Text(v, "#,###.##");
// retourne "2,891.38" en anglais, avec séparateurs de milliers
// retourne "2 891,38" en français (bon séparateur de décimales et séparateurs de milliers

Si Text est préférable pour le formatage des nombres, quand dois-je utiliser Round ?

Dans de nombreux cas, la division de deux nombres donne un nombre avec de nombreuses décimales. Le niveau de précision qui en résulte est souvent trop élevé ou non requis par l'utilisateur final. Round vous aide à contrôler la précision de votre formule. Vous devez également l'utiliser Round lorsque vous devez renvoyer le résultat sous forme de nombre (comme dans un calcul de champ ou une valeur de rendu) ou continuer à l'utiliser comme entrée pour une autre fonction Arcade lorsque moins de précision est requise.

Je vois également parfois des utilisateurs se servir de IIf pour formater des valeurs au-dessus et en dessous d'une valeur seuil, comme ceci :

var precedente = $feature.pop2020;  // 3020
var actuelle = $feature.pop2023;   // 3333
var evolution = (actuelle - precedente) / precedente;

IIF(evolution > 0, "⬆", "⬇") + Round(evolution*100, 2) + "%";
// retourne "⬆10.4%" en anglais
// retourne "⬆10.4%" en français (séparateur de décimales incorrect)

Comme indiqué dans les résultats potentiels, cela entraînera un mauvais formatage dans de nombreux paramètres régionaux non anglais. Le paramètre de modèle de format de Text fournit en fait une option qui vous permet de spécifier un format différent pour les valeurs positives ou négatives. Séparez simplement les deux motifs par un point-virgule et Arcade fera le travail pour vous. Il n'y a pas besoin d'utiliser IIf du tout.

var precedente = $feature.pop2020;  // 3020
var actuelle = $feature.pop2023;   // 3333
var evolution = (actuelle - precedente) / precedente;

Text(evolution, "⬆#.#%;⬇#.#%");
// retourne "⬆10.4%" en anglais
// retourne "⬆10,4%" en français (séparateur de décimales correct)

Les images suivantes montrent comment l'utilisation Round entraînera des valeurs contextuelles incorrectes en fonction des paramètres régionaux.

3. La fonction "Decode"

Decode permet de trouver une correspondance dans un ensemble de codes et de renvoyer une description correspondant à ce code. Cette fonction peut être utilisée pour évaluer n'importe quelle expression à une valeur et comparer le résultat à une liste de valeurs attendues et renvoyer une description, une catégorie ou une autre valeur correspondante.

Par exemple, l'attribut CodeTech dans l'exemple suivant est une valeur codée. Je vois souvent des utilisateurs renvoyer la description du code en utilisant une séquence d'instructions if-else, comme ceci :

if($feature.CodeTech == 30){
  return "Réseau cuivre";
}
if($feature.CodeTech == 40){
  return "Réseau câble ";
}
if($feature.CodeTech == 50){
  return "Fibre";
}
if($feature.CodeTech == 60){
  return "Satellite";
}
if($feature.CodeTech == 70){
  return "Sans-fil terrestre";
}
if($feature.CodeTech == 90){
  return "Ligne électrique";
}

Bien entendu, cette syntaxe est valide et renvoie un résultat correct. Vous pouvez également condenser cette expression à l'aide de la fonction When :

When(
  $feature.CodeTech == 30, "Réseau cuivre",
  $feature.CodeTech == 40, "Réseau câble",
  $feature.CodeTech == 50, "Fibre",
  $feature.CodeTech == 60, "Satellite",
  $feature.CodeTech == 70, "Sans-fil terrestre",
  $feature.CodeTech == 90, "Ligne électrique",
  "Autre"
);

Ceci est également valide et renvoie un résultat correct. Cependant, comme le code provient d'un seul champ, vous pouvez simplement utiliser Decode pour renvoyer plus directement la description :

Decode($feature.CodeTech,
  30, "Réseau cuivre",
  40, "Réseau câble",
  50, "Fibre",
  60, "Satellite",
  70, "Sans-fil terrestre",
  90, "Ligne électrique",
  "Autre"
);

Votre expression est ainsi plus compacte et un peu plus facile à lire. Decode est préférable pour évaluer une seule expression et comparer le résultat à une liste de valeurs connues. When est préférable pour évaluer plusieurs expressions dans une séquence hiérarchisée et renvoyer une valeur une fois que l'une des déclarations est vraie.

Decode peut également être utilisé de manière astucieuse, par exemple en comparant plusieurs attributs numériques de catégories concurrentes et en renvoyant l'alias ou la description du champ pour visualiser la prédominance.

Par exemple, dans un ensemble de données électorales, vous pouvez avoir des colonnes qui représentent le nombre total de votes pour des candidats individuels, mais aucune colonne qui indique le vainqueur (car aucun n'a encore été déclaré). Vous pouvez utiliser Decode pour renvoyer le leader actuel d'une élection lors de la mise à jour des résultats :

var votesParParti = [
  $feature.RN,
  $feature.REP,
  $feature.LREM,
  $feature.LFI,
  $feature.EELV,
  $feature.SOC,
];

// Récupère le score le plus élevé,
// trouve la correspondance avec le parti correspondant
// et retourne le nom complet du parti leader
var leader = Decode(Max(votesParParti),
  $feature.RN, "Rassemblement national",
  $feature.REP, "Les républicains",
  $feature.LREM, "La république en marche",
  $feature.LFI, "La France insoumise",
  $feature.EELV, "Europe écologie les verts",
  $feature.SOC, "Socialistes",
  "Autre"
);

return leader;

4. La fonction "DefaultValue"

DefaultValue renvoie une valeur si une valeur vide (null ou '') est détectée. Les utilisateurs souhaitent généralement afficher le texte par défaut au cas où une valeur n'existe pas. De nombreuses personnes utilisent une combinaison de IIf et IsEmpty pour tenir compte des valeurs vides.

// retourne une valeur par défaut de 0 si le champ de données est vide
IIF(!IsEmpty($feature.monchamp), $feature.monchamp, 0);

Cela fonctionne, mais la fonction DefaultValue fait tout le travail pour vous. Tout ce que vous avez à faire est de spécifier la valeur que vous souhaitez vérifier, et la valeur par défaut à retourner si elle est vide.

L'équivalent de l'expression précédente est plus facile à lire :

// retourne une valeur par défaut de 0 si le champ de données est vide
DefaultValue($feature.monchamp, 0);

Dans les fenêtres contextuelles, il peut être utile d'afficher un message indiquant qu'aucune donnée n'est disponible afin que l'utilisateur sache que les données sont collectées dans la couche, mais ne sont pas disponibles pour l'entité sélectionnée.

// retourne "Aucune donnée disponible" si le champ etat est vide
DefaultValue($feature.etat, "Aucune donnée disponible");

Je suis récemment tombé sur l'expression suivante qui aurait pu être réduite de moitié si l'auteur de l'expression avait été utilisée DefaultValue. Vous noterez comment la valeur de retour dans le if-else sont presque identiques. La seule différence est d'afficher la valeur d'un attribut ou d'un autre si le premier est vide.

var ValeurPourcent = Round(($feature.Visiteurs/$feature.TotalVisiteurs)*100, 2) + "%";
var TypeParc = Lower($feature.TYPE_PARC);
var NomParc = $feature.NOM_PARC;
var CodeParc = $feature.CODE_PARC;

if(IsEmpty(NomParc)){
  return {
    text: "{CodeParc} est un parc de type " + TypeParc + " qui a eu " +
    "{$feature.Visiteurs} visiteurs en 2022. " +
    "cela représente " + ValeurPourcent + " des visites" +
    "de tous les parcs en 2022."
  }
} else {
  return {
    text: "{NomParc} est un parc de type " + TypeParc + " qui a eu " +
    "{$feature.Visiteurs} visiteurs en 2022. " +
    "Cela représente " + ValeurPourcent + " des visites" +
    "de tous les parcs en 2022."
  }
}

Il s'agit de l'expression mise à jour tirant parti DefaultValue de la variable NomParc, ce qui entraîne moins de duplication de texte dans l'expression. J'utilise également Text pour nettoyer le formatage des nombres et rendre les valeurs sensibles aux paramètres régionaux.

var ValeurPourcent = Round(($feature.Visiteurs/$feature.TotalVisiteurs)*100, 2) + "%";
var TypeParc = Lower($feature.TYPE_PARC);
var NomParc = DefaultValue($feature.NOM_PARC, $feature.CODE_PARC);

return {
  text : NomParc + " est un parc de type " + TypeParc + " qui a eu " +
    Text($feature.Visiteurs, "#,###") +
    " visiteurs en 2022. Cela représente " +
    ValeurPourcent + " des visites de tous les parcs en 2022."
};

5. La fonction "Number"

La fonction Number convertit une valeur d'entrée de n'importe quel type en un nombre. Les gens demandent souvent une fonction pour renvoyer le nombre de millisecondes depuis le 1er janvier 1970 similaire à la méthode Date.getTime() de JavaScript. Cette fonction existe déjà ! Number le fera si vous transmettez une valeur de date en tant que paramètre à la fonction.

Number(Date())
// retourne la valeur d'époque

Il est également courant que les utilisateurs stockent des valeurs binaires en tant qu'attribut d'entité. Certains attributs sont vrais ou faux, donc la valeur sera stockée sous la forme 0 (false) ou 1 (true).

J'ai parfois vu des expressions faire ce qui suit lors du calcul d'une valeur dans les workflows de mise à jour :

IIF($feature.etat == "terminé", 1, 0);
// retourne 1 si vrai, 0 si faux

Vous pouvez également tirer parti de Number pour renvoyer un 1 ou un 0 lors de l'évaluation d'une expression booléenne.

Number($feature.etat == "terminé");
// retourne 1 si vrai, 0 si faux

Number peut également être utile si vous avez besoin d'analyser une valeur à partir d'un texte et de la convertir en nombre pour un calcul ou une visualisation numérique.

Number("38.7%", "#.#%");
// retourne 0.387

Number("1,000 personnes", "# personnes");
// retourne 1000

Et les plus sous-utilisées des fonctions, ce sont généralement vos propres fonctions !

Si vous vous retrouvez à écrire du code en double dans une expression, vous tirerez probablement profit de l'écriture d'une fonction personnalisée. Les fonctions personnalisées vous permettent d'écrire une fois du code qui, sinon, devrait être écrit plusieurs fois dans votre expression, et de leurs donner un nom pour pouvoir les appeler. Cela réduit considérablement les erreurs qui se glissent avec le copier/coller et peut réduire considérablement la taille d'une expression.

Conclusion

Comme avec tout autre langage de scripting ou d'expression, il existe plusieurs façons de résoudre une tâche ou d'arriver à un résultat correct. Cependant, les fonctions décrites dans cet article (IIf, Text, Decode, DefaultValue, Number) peuvent simplifier vos expressions, améliorer leur lisibilité et réduire les bugs. Définir vos propres fonctions peut également vous faire gagner du temps, réduire la longueur de vos expressions et réduire les bogues introduits dans les opérations de copier/coller.

Utiliser Arcade pour vos expressions dynamiques dans ArcGIS

Arcade est un langage d'expressions pouvant être utilisé sur l'ensemble du système ArcGIS. Basé sur une syntaxe simple (inspirée de Python et de JavaScript), Arcade est supporté dans l'ensemble des applications web, mobiles et bureautiques ArcGIS. Par exemple, une expression définie sur les étiquettes d'une couche dans ArcGIS Pro sera également exécutée une fois les contenus publiés et affichés dans une carte web, et inversement. Arcade peut être utilisé dans différents contextes pour :

contrôler le rendu des entités d'une couche,
définir le texte de vos étiquettes,
personnaliser le contenu des fenêtres contextuelles,
calculer les valeurs d'un champ,
définir des comportements dans vos formulaires intelligents,
personnaliser des sources de données dans vos tableaux de bord,
...

Il devient important aujourd'hui de savoir l'utiliser pour pouvoir tirer profit de tout son potentiel. Dans de nombreux cas, avec de simples expressions vous implémenterez des comportements avancés et vous vous simplifierez grandement la vie. Comme je l'ai fait il y a quelques années avec Python, qui reste toujours un langage incontournable pour l'automatisation des tâches d'administration et d'analyse dans ArcGIS, je vous propose une série d'exemples d'expressions qui, je l'espère, couvriront la majorité de vos besoins :

Quelques éléments de base avant de commencer...

L'objectif du langage d'Arcade est de pouvoir définir une expression plus ou moins évoluée qui au final doit renvoyer une valeur. Pour cela, il dispose d'une librairie de fonctions et de variables prédéfinies simples et performantes pour répondre aux besoins du contexte dans lequel vous exécutez cette expression (calcul de champ, rendu de couche, étiquetage, fenêtre contextuelle, ...).

Lors de la rédaction de votre expression, elle pourra être écrite sur une seule ligne ou sur plusieurs lignes. Par exemple, l'expression ci-dessous calcule le pourcentage d'évolution entre les valeurs du champ POP_2016 et POP_2017.

// Retour implicite
($feature.POP_2017 / $feature.POP_2016) * 100

Dans l'expression ci-dessus, la valeur de l'expression est retournée de manière explicite. L'utilisation explicite de l'instruction "return" permettra de lever toute ambiguïté le cas échéant.

// Retour explicite
return ($feature.POP_2017 / $feature.POP_2016) * 100

Dans le contexte d'une expression plus évoluée, rédigée sur plusieurs lignes, il sera d'autant plus important de définir la valeur à retourner que votre expression contiendra probablement plusieurs variables.

Vous pourrez préciser de manière implicite la variable à retourner en la mentionnant à la fin de votre expression, comme ici avec la variable "somme":

// Retour implicite
var tableau = [10,20,30,40,50,60,70]
var somme = 0;
for(var n in tableau){
	somme += tableau[n];
}
somme;

Cependant, il est préférable de définir la valeur à retourner de manière explicite, notamment pour sa lisibilité, en utilisant l'instruction "return" évoquée précédemment.

// Retour explicite
var tableau = [10,20,30,40,50,60,70]
var somme = 0;
for(var n in tableau){
	somme += tableau[n];
}
return somme;

Un autre point important du langage Arcade concerne les variables globales. Commençant par le caractère "$", elles permettent d'accéder à des objets spécifiques hérités du contexte (profil) dans lequel est exécuté l'expression. Par exemple, la variable "$feature" représente chacune des entités d'une couche lorsque vous calculez un champ ou une expression d'étiquetage. Autre exemple, la variable "$map" représentera la carte courante dans le contexte d'une expression d'étiquetage.

L'expression ci-dessous permet de diviser par 1000 les valeurs du champ contenant le chiffre d'affaires de chacun des magasins de ma table.

$feature.CA2017 / 1000

On notera également qu'à la différence d'autre langages (comme Python par exemple), Arcade ne possède qu'un seul type d'objet numérique : Number.

Enfin, dernier élément important avant de découvrir différents exemples, vous noterez qu'Arcade est un langage qui n'est pas sensible à la casse.

Expressions sur les chaînes de caractères

Concaténer deux champs de type chaîne de caractères:

$feature.MonChamp1 + $feature.MonChamp2

Concaténer deux champs de type chaîne de caractères avec un espace entre les deux chaînes:

$feature.MonChamp1 + ' ' + $feature.MonChamp2

Concatenate([$feature.MonChamp1,$feature.MonChamp2],' ')

Concaténer plusieurs champs dont certains sont de type numérique (ici: le champ Hauteur):

'La hauteur du bâtiment ' + $feature.IdBat + ' est de ' + Text($feature.Hauteur) + ' m.'

Concaténer plusieurs champs de type chaîne de caractères en intégrant un saut de ligne (Attention, pour le moment ce saut de ligne n'est pas reconnu dans le cas d'une expression utilisé pour un étiquetage):

$feature.MonChamp1 + TextFormatting.NewLine + $feature.MonChamp2

Calculer le nombre de caractères d'une chaîne:

Count($feature.MonChamp)

Remplacer un caractère par un autre caractère:

Replace($feature.MonChamp, 'é', 'e')

Remplacer les valeurs nulles du champ par la chaîne "Aucune donnée":

DefaultValue($feature.MonChamp, 'Aucune donnée')

Extraire le premier caractère d'une chaîne:

Left($feature.MonChamp,1)

Extraire le deuxième caractère d'une chaîne:

Mid($feature.MonChamp,1,1)

Extraire le dernier caractère d'une chaîne:

Right($feature.MonChamp,1)

Extraire l'avant-dernier caractère d'une chaîne:

Mid($feature.MonChamp,Count($feature.MonChamp)-2,1)

Extraire les 5 premiers caractères d'une chaîne:

Left($feature.MonChamp,5)

Extraire les 3 derniers caractères d'une chaîne:

Right($feature.MonChamp,3)

Extraire une partie quelconque d'une chaîne (ici: neuvième, dixième et onzième caractère):

Mid($feature.MonChamp,8,3)

Extraire le 4ième mot d'une chaîne (dont les mots sont séparés par un espace):

Split($feature.MonChamp,' ')[3]

Extraire la 5ième mot d'une chaîne dont les mots sont séparés par une virgule:

Split($feature.MonChamp,',')[4]

Retirer les espaces inutiles en fin de chaîne:

var end_spaces = 0
for(var i=Count($feature.MonChamp)-1; i>0; i--) {
  if($feature.MonChamp[i]==' ')
  {
    end_spaces += 1;
  }
  else
  {
    break
  }
}
return Left($feature.MonChamp,Count($feature.MonChamp)-end_spaces);

Retirer les espaces inutiles en début de chaîne:

var end_spaces = 0
for(var i=Count($feature.MonChamp)-1; i>0; i--) {
  if($feature.MonChamp[i]==' ')
  {
    end_spaces += 1;
  }
  else
  {
    break
  }
}
return Left($feature.MonChamp,Count($feature.MonChamp)-end_spaces);

Retirer les espaces inutiles en début et fin de chaîne:

var end_spaces = 0
for(var i=0; i
$feature.MonChamp)); i++) {  if($feature.MonChamp[i]==' ')
  {
    end_spaces += 1;
  }
  else
  {
    break
  }
}
return Right($feature.MonChamp,Count($feature.MonChamp)-end_spaces);

Mettre tous les caractères des valeurs d'un champ en minuscule:

Lower($feature.MonChamp)

Mettre tous les caractères des valeurs d'un champ en majuscule:

Upper($feature.MonChamp)

Mettre le premier caractère en majuscule et le reste en minuscule:

Proper($feature.MonChamp, firstword)

Mettre une majuscule au début de chaque mot:

Proper($feature.MonChamp, everyword)

Insérer une simple-quote dans une chaîne:

'Voici l\'insertion d\'apostrophes'

Insérer une double-quote dans une chaîne:

'Voici \"la citation\"'

Choisir une chaîne de manière aléatoire parmi une liste de chaîne:

var my_list = ['Pomme','Poire','Orange','Kiwi','Fraise']
return my_list[Floor(Random()*Count(my_list))]

Compter le nombre de lettres distinctes dans une chaîne de caractères:

var my_string = $feature.MonChamp;
var my_array = [];
for(var i=0; my_string; i++) {
    my_array[i]= my_string[i]
}
return Count(Distinct(my_array))

Expressions sur les valeurs numériques

Convertir une chaîne en numérique:

Number($feature.MonChamp)

Remplacer les valeurs nulles par la valeur 0:

DefaultValue($feature.MonChamp,0)

Arrondir à l'entier inférieur ou supérieur selon les règles mathématiques classiques:

Round($feature.MonChamp)

Arrondir à l'entier supérieur:

Ceil($feature.MonChamp)

Arrondir à l'entier inférieur:

Floor($feature.MonChamp)

Arrondir à la 3ème décimale:

Round($feature.MonChamp,3)

Générer un nombre entier aléatoire entre 0 et 9:

Round(Random()*9)

Générer un nombre décimal aléatoire entre 0 et 1:

Random()

Générer un nombre décimal aléatoire entre 20 et 80:

20 + (Random()*60)

Calculer la valeur absolue d'un nombre:

Abs($feature.MonChamp)

Calculer l'opposé d'un nombre:

var myNumber = $feature.MonChamp
return -myNumber

Calculer le modulo d'un nombre:

$feature.MonChamp % 360

Calculer le carré d'un nombre:

Pow($feature.MonChamp,2)

Calculer le cube d'un nombre

Pow($feature.MonChamp,3)

Calculer la racine carrée d'un nombre

Sqrt($feature.MonChamp)

Calculer la racine cubique d'un nombre

Pow($feature.MonChamp,1/3)

Calculer le volume d'une sphère à partir du champ contenant le rayon (exemple d'utilisation de la constant Pi):

4 / 3 * PI * Pow($feature.Rayon,3)

Calculer la valeur minimum de plusieurs champs

Min([$feature.Champ1,$feature.Champ2,$feature.Champ3,$feature.Champ4])

Calculer la valeur maximum de plusieurs champs

Max([$feature.Champ1,$feature.Champ2,$feature.Champ3,$feature.Champ4])

Calculer la somme des valeurs de plusieurs champs

Sum([$feature.Champ1,$feature.Champ2,$feature.Champ3,$feature.Champ4])

Calculer la moyenne des valeurs de plusieurs champs

Mean([$feature.Champ1,$feature.Champ2,$feature.Champ3,$feature.Champ4])

Calculer l'écart-type des valeurs de plusieurs champs

Stdev([$feature.Champ1,$feature.Champ2,$feature.Champ3,$feature.Champ4])

Calculer la différence entre la valeur du champ et la valeur minimum de ce champ sur l'ensemble de la table (ou la couche)

$feature.Champ1 - Min($layer,"Champ1")

Calculer la différence entre la valeur du champ et la valeur maximum de ce champ sur l'ensemble de la table (ou la couche)

$feature.Champ1 - Max($layer,"Champ1")

Calculer la différence entre la valeur du champ et la valeur moyenne de ce champ sur l'ensemble de la table (ou la couche)

$feature.Champ1 - Mean($layer,"Champ1")

Expressions sur les dates

Calculer la date courante:

Now()

Date()

Calculer la date courante en tant que chaîne de caractères:

Text(Now(),'DD/MM/Y')
  //Retourne cette chaîne: "26/12/2018"

Créer une date et heure courante:

Text(Now(), 'DD/MM/Y HH:mm:ss')
//Retourne cette chaîne: "26/12/2018 15:46:27"

Créer une date et heure spécifique (standard ISO 8601):

Date('2017-03-19T13:57:45')
//Retourne cette date: 19/03/2017 13:57:45

Créer une date spécifique:

Date('2017-03-19')

Créer une date à partir d'une époque Unix (depuis 01/01/1970 en millisecondes):

Date(1476987783555)

Calculer le nombre de jours compris entre la date actuelle et la date d'un champ:

var startDate = Date()
var endDate = $feature.MonChampDate;
return DateDiff(startDate, endDate, 'days');

Calculer le nombre de secondes compris entre la date actuelle et la date d'un champ:

var startDate = Date()
var endDate = $feature.MonChampDate;
return DateDiff(startDate, endDate, 'seconds');

Calculer une date en ajoutant 3 mois à la date d'un champ:

var myDate = $feature.MonChampDate;
return DateAdd(myDate, 3, 'months');

Calculer une date en ajoutant 10 jours à la date d'un champ:

var myDate = $feature.MonChampDate;
return DateAdd(myDate, 10, 'days');

Calculer une date en ajoutant 12 heures à la date d'un champ:

var myDate = $feature.MonChampDate;
return DateAdd(myDate, 12, 'hours');

Calculer le jour de la semaine (1, 2, 3,...) de la date d'un champ:

Weekday($feature.MonChampDate);

Calculer le jour de la semaine (par exemple: lundi) de la date d'un champ:

var j = Weekday($feature.MonChampDate);
var jour = Decode(j, 
           1, 'Lundi', 
           2, 'Mardi', 
           3, 'Mercredi',
           4, 'Jeudi',
           5, 'Vendredi',
           6, 'Samedi',
           7, 'Dimanche','');
return jour

Calculer une date à partir d'un champ contenant des timestamps:

Date($feature.MonChampTimestamp)

Calculer des timestamps à partir d'un champ contenant des dates:

Number($feature.MonChampDate)

Calculer une date locale à partir d'un champ contenant des dates UTC:

ToLocal($feature.MonChampDate)

Calculer une date UTC à partir d'un champ contenant des dates locales:

ToUTC($feature.MonChampDate)

Expressions sur les géométries

Calculer le X du centroïde des géométries des entités:

Centroid($feature).x

Calculer le Y du centroïde des géométries des entités:

Centroid($feature).y

Calculer le Z du centroïde des géométries des entités:

Centroid($feature).z

Calculer le périmètre des polygones ou la longueur des polylignes dans les unités de la couche:

Length($feature)

Calculer le périmètre géodésique des polygones ou la longueur géodésique des polylignes dans les unités de la couche:

LengthGeodetic($feature)

Calculer le périmètre des polygones ou la longueur des polylignes dans les unités de votre choix (ici en kilomètres):

Length($feature, 'kilometers')

Calculer le périmètre des polygones 3D ou la longueur des polylignes 3D dans les unités de la couche en tenant compte du Z des entités :

Length3D($feature)

Calculer le périmètre des polygones 3D ou la longueur des polylignes 3D dans les unités de votre choix (ici en mètres) en tenant compte du Z des entités :
Length3D($feature, 'meters')

Calculer la superficie des polygones dans les unités de la couche:

Area($feature)

Calculer la superficie géodésique des polygones dans les unités de la couche:

AreaGeodetic($feature)

Calculer la superficie des polygones dans les unités de votre choix (ici en km2):

Area($feature, 'square-kilometers')

Calculer la superficie des polygones dans les unités de votre choix (ici en hectares):

Area($feature,'hectares')

Calculer le X du premier sommet des polylignes:

var myPath = Geometry($feature).paths[0]
return myPath[0].x

Calculer le X du premier sommet des polygones:

var myRing = Geometry($feature).rings[0]
return myRing[0].x

Calculer le X du dernier sommet des polylignes (dans le cas de polygone mono-partie, le premier et le dernier sommet sont les mêmes):

var myPath = Geometry($feature).paths[0]
return myPath[Count(myPath)-1].x

Calculer le X du dernier sommet des polylignes (dans le cas de polygone mono-partie, le premier et le dernier sommet sont les mêmes):

var myRing = Geometry($feature).rings[0]
return myRing[Count(myRing)-1].x

Calculer le X du coin inférieur-gauche de l'enveloppe des polylignes ou des polygones:

var ext = Extent($feature)
return ext.xmin

Calculer le Y du coin inférieur-gauche de l'enveloppe des polylignes ou des polygones:

var ext = Extent($feature)
return ext.ymin

Calculer la largeur de l'enveloppe des polylignes ou des polygones:

var ext = Extent($feature)
return ext.xmax - ext.xmin

Calculer la hauteur de l'enveloppe des polylignes ou des polygones:

var ext = Extent($feature)
return ext.ymax - ext.ymin

Calculer le nombre de parties composant la géométrie d'entités linéaires:

var myPaths = Geometry($feature).paths
return Count(myPaths)

Calculer le nombre de parties composant la géométrie d'entités surfaciques:

var myRings = Geometry($feature).rings
return Count(myRings)

Calculer le nombre de sommets composant la géométrie d'entités linéaires:

var myPaths = Geometry($feature).paths;
var nb_points = 0;
for (var i=0;myPaths;i++){
    var myPath = myPaths[i];
    nb_points += Count(myPath);
}
return nb_points

Calculer le nombre de sommets composant la géométrie d'entités surfaciques:

var myRings = Geometry($feature).rings;
var nb_points = 0;
for (var i=0;imyRings);i++){
    var myRing = myRings[i];
    nb_points += Count(myRing);
}
return nb_points

Accéder à des données d'autres couches

Récupérer la valeur d'un champ depuis une entité située dans une autre couche. Ici on récupère le code de la zone (CodeZone) dans la couche "Zones" dans laquelle se trouve l'entité ($feature) ponctuelle, linéaire ou surfacique:

for (var my_zone in FeatureSetByName($map,"Zones")){
    if (Intersects($feature, Geometry(my_zone))){
        return my_zone.CodeZone;
    }
}

Compter le nombre d'entités (ici des bâtiments) contenus dans la géométrie courante (ici des parcelles cadastrales). Vous noterez que l'on fait tout d'abord une intersection puis la comparaison avec les centroïdes des bâtiments pour ne pas garder les bâtiments qui touchent la limite de la parcelle tout en étant à l'extérieur de celle-ci:

var intersected_features = Intersects(FeatureSetByName($map,"Bâtiments"), $feature);
var n=0;
for (var my_feature in intersected_features)
{
    var my_centroid = Centroid(my_feature);
    Console(my_centroid);
    if (Within(my_centroid,$feature)){
        n++;
    }
}
return Text(n, '#');

Récupérer la distance minimum entre l'entité courante et l'entité la plus proche dans une autre couche (ici la couche "Mes Enseignes"). Dans cet exemple, la distance maximum de recherche est fixée à 100 kilomètres:

var my_buffer = Buffer($feature, 100, 'kilometers');
var dist_min = Infinity;
for (var my_feature in Intersects(FeatureSetByName($map,"Mes Enseignes"),my_buffer))
{
  var d = Distance($feature,my_feature,'kilometers');
  dist_min = IIF(d < dist_min, d, dist_min);
}
return dist_min

Manipuler des tableaux de données

Vous aurez peut-être besoin de manipuler des tableaux de données. Voici donc quelques fonctions intéressantes...

Créer un tableau:

var couleurs = ['orange', 'rouge', 'vert']

Récupérer le deuxième élément d'un tableau:

var couleurs = ['orange', 'rouge', 'vert']
couleurs[1]
// retourne 'rouge'

Connaître le nombre d'éléments d'un tableau:

var couleurs = ['orange', 'rouge', 'vert']
Count(couleurs)
// retourne 3

Ajouter une valeur à un tableau:

var couleurs = ['orange', 'rouge', 'vert'];
couleurs.Push('Noir');
// couleurs = ['orange', 'rouge', 'vert', 'Noir']

Trier les éléments d'un tableau par ordre croissant :

var couleurs = ['orange', 'rouge', 'vert', 'bleu', 'violet']
Sort(couleurs)
// retourne ['bleu', 'orange', 'rouge', 'vert', 'violet']

Trier les éléments d'un tableau par ordre décroissant (pour des éléments simples ou plus complexes comme des tableaux de tableaux):

var couleurs = ['orange', 'rouge', 'vert', 'bleu', 'violet']
Sort(couleurs)
// retourne ['violet', 'vert', 'rouge', 'orange', 'bleu']

Trier les éléments d'un tableau par ordre décroissant (pour des éléments simples de type String ou Number):


var couleurs = ['orange', 'rouge', 'vert', 'bleu', 'violet']
Reverse(Sort(couleurs))
// retourne ['violet', 'vert', 'rouge', 'orange', 'bleu']

Récupérer et supprimer la dernière valeur d'un tableau:

var couleurs = ['orange', 'rouge', 'vert'];
derniereCouleur = Pop(couleurs);
// derniereCouleur = 'vert' et couleurs = ['orange', 'rouge']

Compter le nombre de valeurs uniques dans un tableau:

var couleurs = ['orange', 'orange', 'vert', 'rouge', 'vert']
var couleursUniques = Distinct(couleurs)
// couleursUniques = ['orange', 'vert', 'rouge']

Tester si certaines valeurs sont vides dans un tableau:

var tableau = [$feature.champ1, $feature.champ2, $feature.champ3, $feature.champ4]
Any(tableau, isEmpty)
// retourne True si une des valeurs est vide, sinon retourne False

Autres expressions utiles

Retourner une valeur vide (Null):

Null

Construire une chaîne à partir des valeurs de différents champs en utilisant un séparateur:

Concatenate([$feature.Jour,$feature.Mois,$feature.Annee],"/")

Construire une chaîne en mettant les "0" nécessaires à droite de la valeur numérique (ici un exemple où on force le nombre à faire 4 caractères, par exemple pour 0.75 on obtiendra la chaîne "0.750":

Text($feature.MonChampNum, '0.000')

Construire une chaîne en mettant les "0" nécessaires à gauche de la valeur numérique (ici un exemple où on force le nombre à faire 4 caractères, par exemple pour 82 on obtiendra la chaîne "0082":

Text($feature.MonChampNum, '0000')

Retourner le nom de l'utilisateur actuellement connecté:

var userInfo = GetUser();
if(HasValue(userInfo, "username")){
	return userInfo.username;
}

Retourner le nom complet de l'utilisateur actuellement connecté:

var userInfo = GetUser();
if(HasValue(userInfo, "fullName")){
	return userInfo. fullName;
}

Retourner l'ID de l'utilisateur actuellement connecté:

var userInfo = GetUser();
if(HasValue(userInfo, "id")){
	return userInfo.id;
}

Retourner l'email de l'utilisateur actuellement connecté:

var userInfo = GetUser();
if(HasValue(userInfo, "email")){
	return userInfo.email;
}

Retourner les groupes auxquels appartient l'utilisateur actuellement connecté:

var userInfo = GetUser();
if(HasValue(userInfo, "groups")){
	return userInfo.groups;
}

Retourner la langue du contexte applicatif exécutant l'expression Arcade:

var env = GetEnvironment()
var locale = IIF(HasValue(env, "locale"), env.locale, "");
return locale;
// retourne par exemple 'en-us', 'fr-fr', ...

Retourner la version du contexte applicatif exécutant l'expression Arcade:

var env = GetEnvironment()
var locale = IIF(HasValue(env, "version"), env.version , "");
return locale;
// retourne par exemple '1.23'

Retourner la version du contexte applicatif exécutant l'expression Arcade:

var env = GetEnvironment()
var locale = IIF(HasValue(env, "application"),
env. application,"");
// retourne par exemple 'ArcGISMapViewer'

Pour plus d'informations sur les différents profils, le guide de référence des fonctions et la syntaxe des expressions Arcade, il est important de consulter la documentation en ligne.

Note: Cet article a été publié initialement le 23/01/2019 et mis à jour le 17/08/2023

Conseils & Astuces ArcGIS Online - N°171

N° 171 - Utiliser Arcade pour gérer des profils de données à afficher dans vos fenêtres contextuelles

Sur un portail ArcGIS, il est fréquent de créer une carte web et de l'utiliser dans plusieurs applications. Parfois ces applications sont à destination de différents profils d'utilisateurs. Dès lors, il peut être intéressant de prévoir l'affichage d'informations selon les utilisateurs adressés, en particulier pour ne pas charger inutilement les fenêtres contextuelles de vos cartes web en contenus inutiles et simplifier l'information présentée. Pour cela, les expressions Arcade peuvent vous aider à personnaliser le contenu de vos fenêtres contextuelles en prenant en compte le profil de l'utilisateur qui consulte votre carte.

L'exemple que je vous propose est illustré par l'image ci-dessus. Nous disposons d'une couche avec des parcelles cadastrales avec des attributs que nous ne souhaitons présenter (ou pas) selon le profil des utilisateurs qui consulte la carte web. Lorsque l'utilisateur n'est pas connecté, on veut lui présenter uniquement les informations d'identification de la parcelle. Lorsque l'utilisateur est connecté à l'organisation, on veut en plus lui présenter les informations de surfaces. Enfin, lorsque l'utilisateur est connecté et fait partie d'un groupe spécifique, alors il peut voir des informations plus détaillées sur la parcelle comme le propriétaire par exemple. A travers cet exemple, voici donc comment nous allons procéder :

Connectez-vous tout d'abord sur votre portail ArcGIS. Vous vérifierez que vous avez créé un groupe contenant les utilisateurs qui auront accès à la totalité des informations dans la fenêtre contextuelle. Dans mon exemple, ce groupe se nomme "Equipe_Cadastre" et contient trois utilisateurs.
Vous ouvrirez ensuite la carte web contenant la couche d'entités dont vous souhaitez configurer la fenêtre contextuelle. Dans notre exemple, la carte web est destinée à différentes applications dont certaines sont publiques. La couche d'entités est donc partagée de manière publique. Par défaut, la fenêtre contextuelle présente la liste de tous les attributs.
Dans la zone de configuration des fenêtres contextuelles la couche, vous pouvez supprimer l'élément "Liste de champs" proposé par défaut puis ajouter un élément de contenu Arcade. Ce dernier nous permettra de réaliser les calculs statistiques nécessaires et configurer un rendu personnalisé (en HTML) de nos informations.

Dans l'éditeur Arcade, vous effacerez les instructions déjà présentes par l'expression Arcade ci-dessous :

// Nom du groupe des utilisateurs ayant accès à la totalité du contenu
var group_name = "Equipe_Cadastre"
var UserHasPrivileges = false

// Récupération d'un nom de l'utilisateur. Si ce dernier est anonyme alors
// la fonction GetUser renvoit un objet vide.
var user_name = iif(IsEmpty(GetUser($layer, false)),"Anonyme",GetUser($layer, true).username)

// On vérifie si l'utilisateur appartient au groupe ayant les privilèges
// si ce n'est pas le cas la variable UserHasPrivileges reste à false
if (user_name != "Anonyme"){
  var groups = GetUser($layer, false).groups
  for (var i in groups){
    if(Lower(groups[i].title)==Lower(group_name)){
      UserHasPrivileges=true
    }
  }
}

// On commence à construire la chaine HTML correspondant au contenu de la
// fenêtre contextuelle à l'aide d'un élément <table>
var HTML = "<table>"
// On ajoute les attributs visibles par tout le monde
HTML += "<tr><td>Code Commune :</td><td>"+$feature.CODCOMM+"</td></tr>"
HTML += "<tr><td>Code Section :</td><td>"+$feature.CODSEC+"</td></tr>"
HTML += "<tr><td>N° Parcelle :</td><td>"+$feature.NUMERO+"</td></tr>"

// On ajoute ensuite les attributs visibles à tout utilisateur connecté
if (user_name != "Anonyme"){
HTML += "<tr><td>Adresse Parcelle :</td><td>"+$feature.Adresse+"</td></tr>"
HTML += "<tr><td>Surface foncière :</td><td>"+$feature.SUPF+" m²</td></tr>"
HTML += "<tr><td>Surface batie :</td><td>"+$feature.SUPB+" m²</td></tr>"
}

// On ajoute les attributs visibles aux utilisateurs du groupe "Equipe_Cadastre"
if (UserHasPrivileges){
  HTML += "<tr><td>ID Propriétaire :</td><td>"+$feature.ID_Prop+"</td></tr>"
  HTML += "<tr><td>Nom Propriétaire :</td><td>"+$feature.Nom_Prop+"</td></tr>"  
  HTML += "<tr><td>Adresse Propriétaire :</td><td>"+$feature.Adresse_Prop+"</td></tr>"  
  HTML += "<tr><td>Valeur cadastrale :</td><td>"+$feature.Valeur_Cadastrale+" €</td></tr>" 
  HTML += "<tr><td>Bâtiments :</td><td>"+$feature.NB_BATIMENTS+"</td></tr>"  
  HTML += "<tr><td>Année de construction :</td><td>"+$feature["Année_Construction"]+"</td></tr>"  
}
// On termine la chaine HTML
HTML += "</table>"

// On renvoie la chaine HTML personnalisée en fonction du profil de l'utilisateur
return { 
  type : 'text', 
  text : HTML
}

On notera l'usage de la fonction GetUser() qui permet de récupérer l'utilisateur actuellement connecté à la source de données du FeatureSet passé en paramètre. Dans le contexte d'une couche d'entités hébergée ArcGIS Online, il s'agit de l'utilisateur affichant la carte web. Si ce dernier n'est pas connecté et accède à la carte en tant qu'utilisateur "Anonyme", la fonction renvoie un dictionnaire vide.

On notera également que la propriété "groups" du dictionnaire renvoyé par la fonction GetUser() permet de lister les groupes auxquels appartient l'utilisateur.

Vous pouvez maintenant cliquer sur le bouton "Terminé" pour valider l'expression.
La fenêtre contextuelle s'affiche désormais avec les informations en fonction du profil de l'utilisateur courant.

Ici je suis connecté avec un utilisateur faisant partie du groupe "Equipe_Cadastre", je visualise donc la fenêtre contextuelle complète.

Ici, je suis connecté avec un utilisateur de l'organisation ne faisant pas partie du groupe "Equipe_Cadastre". Il ne voit donc pas les attributs sensibles.

Ici, je suis connecté avec un utilisateur public ne faisant pas partie de l'organisation. Il ne voit donc pas les attributs sensibles.

Ici, je ne suis pas connecté avec un utilisateur nommé. Je ne vois donc que les trois attributs de base.

Remarque : La méthode proposée ici permet de filtrer, dans la fenêtre contextuelle, les informations pertinentes en fonction du profil de l'utilisateur courant. Elle ne constitue cependant pas une protection absolue des données ainsi masquée. Par exemple, selon l'application dans laquelle la carte est affichée, les utilisateurs peuvent ouvrir la table de la couche avec la totalité des attributs. De même, cette couche peut potentiellement être accédée en dehors de votre carte web avec l'ensemble de ses attributs. Pour véritablement protéger l'accès à certains attributs, la création de vues est le mécanisme à privilégier.

J'espère que cet exemple vous inspirera et que vous pourrez l'adapter à vos cas d'usage.

Bonne route sur ArcGIS Online !

Pour retrouver l'ensemble des Conseils & Astuces ArcGIS Online, cliquez sur ce lien

Conseils & Astuces ArcGIS Online - N°170

N° 170 - Intégrer des vidéos dans vos fenêtres contextuelles

Lorsque vous gérez un SIG, vous êtes parfois amenés à associer des documents multimédias tels que des fichiers vidéo aux entités de vos couches. Il est alors intéressant de pouvoir les visualiser dans les fenêtres contextuelles. Dans cet article, je vous propose de voir 3 cas d'usage (selon votre contexte) pour proposer l'accès à ces vidéos dans les fenêtres contextuelles de vos cartes web.

Cas n°1 - Vos vidéos sont stockées en pièces jointes et votre couche d'entité n'est pas publique

Lorsque vos vidéos sont gérées en tant que pièces jointes, une première option consiste simplement à ajouter un bloc de type "Pièces jointes" dans la fenêtre contextuelle. Dans ce cas, un lien permettra à l'utilisateur d'ouvrir la vidéo dans un nouvel onglet. Voici comment procéder :

Connectez-vous tout d'abord sur votre portail ArcGIS puis ouvrir la carte dans laquelle figure la couche d'entités ayant des vidéos en pièces jointes. Dans la boîte de dialogue de configuration de la fenêtre contextuelle, ajoutez un bloc de contenu de type "Pièces jointes".
Vous pouvez définir un titre et une description (qui peuvent venir des attributs de la couche). Vous pourrez aussi choisir d'afficher le lien vers la vidéo dans une liste ou dans une bibliothèque (si vous avez plusieurs vidéos par entité). L'option "Automatique" permet d'adapter automatiquement la présentation selon le nombre de vidéos associées.
Une fois les paramètres validés, votre fenêtre contextuelle s'affiche avec un lien permettant d'ouvrir la vidéo.

Cas n°2 - Vos vidéos sont stockées en pièces jointes et votre couche d'entités est publique

Lorsque vos vidéos sont gérées en tant que pièces jointes et que la couche d'entités est partagée de manière publique, alors nous pouvons faire mieux et afficher directement la vidéo dans la fenêtre contextuelle. Pour cela nous allons utiliser une expression Arcade. Voici comment procéder :

Connectez-vous tout d'abord sur votre portail ArcGIS puis ouvrir la carte dans laquelle figure la couche d'entités ayant des vidéos en pièces jointes.
Dans la zone de configuration des fenêtres contextuelles la couche, vous pouvez supprimer l'élément "Liste de champs" proposé par défaut puis ajouter un élément de contenu Arcade. Ce dernier nous permettra de réaliser les calculs statistiques nécessaires et configurer un rendu personnalisé (en HTML) de nos informations.

Dans l'éditeur Arcade, vous effacerez les instructions déjà présentes par l'expression Arcade ci-dessous :

// On spécifie la liste des attributs dont on a besoin dans cette expression Arcade
Expects($feature, "*")

// La variable pour récupérer l'URL de la vidéo
var url = ""
// La variable pour récupérer le type mime de la vidéo
var type_video = ""

// On vérifie qu'il y a une pièce jointe et on suppose que c'est une vidéo
// sinon il faudra ajouter un test supplémentaire sur le type mime
if (Count(Attachments($feature))>0) {
  // On stocke ici l'url du service web de la couche d'entités. Celui-ci se trouve
  // dans la page de description de l'item
  var Partie1 = "https://services.arcgis.com/d3voDfTFbHOCRwVR/arcgis/rest/services/Inspections_Canalisations/FeatureServer/0"
  var ObjectID = $feature.OBJECTID
  var Partie2 = "/attachments/"
  // On ne récupère ici que la première vidéo mais on pourrait boucler sur les
  // différentes vidéos
  var AttachID = First(Attachments($feature)).ID 
  // On construit l'url complète pour accéder à la pièce jointe
  url = Partie1 + "/" + ObjectID + Partie2 + AttachID
  // On récupère le type mime qui est stocké par ArcGIS dans les métadonnées de la pièce jointe
  type_video = First(Attachments($feature)).contenttype

  // On renvoie la chaîne HTML complète en utilisant la balise <video> avec les paramètres de
  // démarrage automatique et l'affichage des controles de lecture de la vidéo
  return { 
  type : 'text', 
  text : `<video controls autoplay width="100%">
         <source src="${url}" type="${type_video}">
         </source></video>`
  }
}
else{
  return null
}

Vous ferrez attention à ce que l'url du service web de la couche d'entités intègre bien l'index de la couche au sein du service web (le "/0" dans cet exemple).

On notera l'usage du caractère backtick ( ` et non ') pour utiliser des littéraux et construire la chaîne HTML souhaitée.

On rappellera enfin que cette expression Arcade n'est valide que si la couche d'entités est partagée de manière publique.

Vous pouvez maintenant cliquer sur le bouton "Terminé" pour valider l'expression.
La fenêtre contextuelle s'affiche désormais avec la vidéo qui démarre automatiquement à l'ouverture de la fenêtre contextuelle.

Cas n°3 - Vos vidéos sont référencées via une URL stockée dans un attribut de votre couche d'entités

Lorsque vos vidéos sont référencées par une url stockée dans un attribut de la couche d'entités (qu'elle soit privée ou publique), alors nous pouvons afficher directement la vidéo dans la fenêtre contextuelle. Pour cela nous allons repartir de l'expression Arcade précédente et l'adapter en récupérant directement l'url de la vidéo (dans notre exemple l'attribut se nomme "URL_Video"). L'expression Arcade sera alors la suivante :

// On spécifie la liste des attributs dont on a besoin dans cette expression Arcade
Expects($feature, "*")

// La variable pour récupérer l'URL de la vidéo
var url = ""
// La variable pour récupérer le type mime de la vidéo
var type_video = ""


url = $feature.URL_Video
// On doit définir manuellement le type mime
type_video = "video/mp4"

// On renvoie la chaîne HTML complète en utilisant la balise <video> avec les paramètres de
// démarrage automatique et l'affichage des controles de lecture de la vidéo
return { 
  type : 'text', 
  text : `<video controls autoplay width="100%">
         <source src="${url}" type="${type_video}">
         </source></video>`
}

J'espère que cet exemple vous inspirera et que vous pourrez l'adapter à vos cas d'usage.

Bonne route sur ArcGIS Online !

Pour retrouver l'ensemble des Conseils & Astuces ArcGIS Online, cliquez sur ce lien

Conseils & Astuces ArcGIS Online - N°169

N° 169 - Utiliser Arcade et une API tiers pour ajouter un QR Code dans vos fenêtres contextuelles

Si vous avez besoin de présenter une URL dans vos fenêtres contextuelles pour permettre accès à une ressource web, vous pouvez simplement utiliser la notion de lien HTML. Une option intéressante consiste à proposer, en plus, un QR Code. Cela permet, par exemple, de pouvoir le scanner avec son téléphone en restant dans la carte qui s'affiche sur votre écran d'ordinateur.

Dans cet exemple, nous disposons d'une couche d'entités sur les campings sur l'Ile de Ré dans laquelle un attribut contient l'url d'une photo ainsi que l'url du site web. L'objectif est de présenter la photo, le QR Code du site ainsi qu'un lien HTML classique dans la fenêtre contextuelle de notre couche. Etant donné que les QR Codes ne sont pas des éléments disponibles en standard dans les fenêtres contextuelles ArcGIS, nous utiliserons donc une API tiers pour les générer. Voici donc comment nous allons procéder :

Connectez-vous tout d'abord sur votre portail ArcGIS puis ouvrez la carte web contenant la couche d'entités. Par défaut, la fenêtre contextuelle présente la liste des différents attributs. Si certaines valeurs sont des url web correctement formatées, un lien permet d'ouvrir cette url.
Dans la zone de configuration des fenêtres contextuelles la couche, vous pouvez supprimer l'élément "Liste de champs" proposé par défaut puis ajouter un élément de contenu Arcade. Ce dernier nous permettra de réaliser les calculs statistiques nécessaires et configurer un rendu personnalisé (en HTML) de nos informations.

Dans l'éditeur Arcade, vous effacerez les instructions déjà présentes par l'expression Arcade ci-dessous :

// On précise les attributs dont on a besoin dans l'expression Arcade
Expects($feature, ["Photo","Site_Web"])

// Récupération de l'url du site web
var url_site = $feature.Site_Web

// Construction de l'url sur l'API QuickChart pour la génération du QR Code
// On se base sur l'exemple de diagramme suivant : https://tinyurl.com/43zjzkuf
var url_QRCode = "https://quickchart.io/qr?text=" + url_site

// Récupération de l'url de la photo
var url_photo = $feature.Photo

// On construit la chaîne HTML à l'aide d'un élément HTML <table>
var HTML = `<table>
          <tr>
          <td width='70%'><img src='${url_photo}'/></td>
          <td width='30%' style='text-align: center'>
          <img src='${url_QRCode}'/><br/>
          <a style='font-size: 7pt' href='${url_site}'>Accéder au site</a>
          </td>
          </tr>
          </table>`

// On renvoie la chaîne HTML pour le contenu de notre fenêtre contextuelle
return { 
  type : 'text', 
  text : HTML
}

On notera l'usage de l'API QuickChart qui permet de générer différents types de diagrammes à partir d'une url et une série de paramètres. Celle-ci est basée sur des librairies Open Source que vous pouvez installer sur votre propose serveur ou utiliser en ligne de manière gratuite (avec une limite sur le nombre de requêtes). Une version payante permet un accès illimité.

On notera également l'usage du caractère backtick ( ` et non ') pour utiliser des littéraux et construire la chaîne HTML souhaitée.

Vous pouvez maintenant cliquer sur le bouton "Terminé" pour valider l'expression.
La fenêtre contextuelle s'affiche désormais avec la photo, le QR Code et le lien d'accès au site en-dessus.

J'espère que cet exemple vous inspirera et que vous pourrez l'adapter à vos cas d'usage.

Bonne route sur ArcGIS Online !

Pour retrouver l'ensemble des Conseils & Astuces ArcGIS Online, cliquez sur ce lien

Inscription à : Articles ( Atom )

Optimiser ses expressions Arcade avec 5 fonctions souvent sous-utilisées

Utiliser Arcade pour vos expressions dynamiques dans ArcGIS

Conseils & Astuces ArcGIS Online - N°171

Conseils & Astuces ArcGIS Online - N°170

Conseils & Astuces ArcGIS Online - N°169

Archives du blog

Articles les plus consultés

HTML_arcorama_2

Visiteurs actuellement connectés

Suivre arcOrama - RSS et email

Obtenez les nouveaux articles par mail :

Qui êtes-vous ?