Accéder aux attributs d’une autre couche avec ArcGIS Arcade
Préparation
Dans un premier temps, vous allez configurer une nouvelle carte Web dans Map Viewer et ajouter une nouvelle expression Arcade. Vous partirez d’une carte Web préexistante, qui contient déjà quelques couches de données et expressions Arcade. Vous copierez cette carte dans votre compte ArcGIS Online de façon à pouvoir la modifier et y ajouter de nouveaux éléments.
- Ouvrez la carte Web Global Power Generation and Consumption (Production et consommation électrique mondiale) dans votre navigateur Web.
La carte s’affiche dans Map Viewer avec la fenêtre Legend (Légende) ouverte.
La fenêtre Legend (Légende) répertorie deux couches :
- Global Power Plants (Centrales électriques dans le monde) contient un inventaire complet des centrales électriques dans le monde entier.
- World Countries Electricity Consumption (Consommation électrique mondiale par pays) contient des informations sur la population et la consommation électrique de chaque pays du monde.
Remarque :
Si vous avez déjà suivi le didacticiel Prise en main de ArcGIS Arcade, vous pouvez utiliser à la place la carte obtenue dans ce didacticiel.
- Cliquez sur le bouton Sign in (Se connecter).
- Connectez-vous à votre compte d’organisation ArcGIS.
Remarque :
Si vous ne disposez pas d’un compte d’organisation, consultez les options disponibles pour accéder aux logiciels.
- Dans la barre d’outils Contents (Contenu) (foncée), cliquez sur Save and open (Enregistrer et ouvrir) et choisissez Save as (Enregistrer sous).
- Dans la fenêtre Save map (Enregistrer la carte), pour Title (Titre), ajoutez vos initiales à la fin du titre pour le rendre unique dans votre organisation, puis cliquez sur Save (Enregistrer).
La copie de la carte s’affiche, prête à être modifiée. À présent, vous allez ajouter une nouvelle expression Arcade à la carte en vue de l’utiliser dans les fenêtres contextuelles de la couche Global Power Plants (Centrales électriques dans le monde).
Remarque :
ArcGIS Arcade est un langage d’expression portable, léger et sécurisé qui a été écrit pour vous permettre d’utiliser de façon dynamique vos données dans ArcGIS. Comme les autres langages de programmation, il permet d’effectuer des opérations mathématiques, de manipuler du texte et d’évaluer des instructions logiques. Il permet aux utilisateurs de manipuler des données existantes et de produire de nouvelles informations en créant, partageant et exécutant des expressions personnalisées dans ArcGIS Pro, ArcGIS Runtime, ArcGIS Online, ArcGIS Enterprise et ArcGIS API for JavaScript. Dans Map Viewer, Arcade est utile pour travailler avec des données dans les étiquettes et les fenêtres contextuelles et pour attribuer un style à une couche. Pour découvrir d’autres didacticiels sur Arcade, consultez ce parcours d’apprentissage Arcade.
- Dans la barre d’outils Contents (Contenu), cliquez sur Layers (couches).
Remarque :
Par défaut, les barres d’outils latérales peuvent n’afficher que l’icône de l’outil au lieu de son nom. Vous pouvez cliquer sur le bouton Expand (Développer) au bas de chaque barre d’outils pour voir les noms. Les images du didacticiel correspondent aux barres d’outils développées.
La fenêtre Layers (Couches) apparaît.
- Dans la fenêtre Layers (Couches), cliquez sur la couche Global Power Plants pour la sélectionner.
- Dans la barre d’outils Settings (Paramètres) (claire), cliquez sur Pop-ups (Fenêtres contextuelles).
La fenêtre Pop-ups (Fenêtres contextuelles) et un aperçu d’une fenêtre contextuelle s’affichent.
Il s’agit de la fenêtre contextuelle de la centrale électrique SMN Barka en Arabie Saoudite. Elle contient déjà des informations intéressantes sur cette centrale électrique. L’expression Arcade que vous allez créer dans ce didacticiel ajoutera un ou plusieurs paragraphes de texte dans la fenêtre contextuelle.
- Fermez la fenêtre contextuelle.
Remarque :
Vous pouvez également ouvrir la fenêtre contextuelle pour n’importe quelle centrale électrique de la carte. À l’aide de la molette de la souris, effectuez un zoom avant sur une zone d’intérêt de la carte, par exemple Séville en Espagne. Cliquez ensuite sur l’un des points de centrale électrique.
- Dans la fenêtre Pop-ups (Fenêtres contextuelles), cliquez sur Attribute expressions (Expressions attributaires).
Remarque :
Il existe déjà deux expressions pour la fenêtre contextuelle dans la couche Global Power Plants (Centrales électriques dans le monde). Ces expressions servent à déterminer la couleur du texte pour le type d’énergie et à calculer le nombre d’ampoules de 60 watts que la centrale électrique peut alimenter. Les deux figurent dans la fenêtre contextuelle des centrales électriques. Arcade vous permet de réutiliser tout ou partie de ces expressions existantes dans vos nouvelles expressions. C’est l’une des choses que vous allez apprendre dans ce didacticiel.
La fenêtre Attribute expressions (Expressions attributaires) apparaît.
- Dans la fenêtre Attribute expressions (Expressions attributaires), cliquez sur Add expressions (Ajouter des expressions) pour ouvrir l’éditeur d’expressions Arcade.
L’éditeur d’expressions Arcade s’affiche. C’est dans celui-ci que vous allez créer et modifier les expressions Arcade. Dans un premier temps, vous allez examiner ses composants.
- C’est dans la fenêtre Expression que vous écrivez le code.
- L’onglet Profile variables (Variables de profil) présente la liste des variables prédéfinies, notamment les champs attributaires et la géométrie des entités de la couche.
- Les onglets Functions (Fonctions) répertorient toutes les fonctions Arcade. Vous pouvez cliquer sur le bouton d'information à droite de chaque fonction pour accéder à l'aide intégrée correspondante sur ses paramètres, sa syntaxe et son utilisation.
- L’onglet Suggestions vous donne accès aux attributs et à la géométrie des entités de la couche via une liste de variables prédéfinies. Il permet également d’accéder aux entités des autres couches de la carte Web, ce que vous ferez ultérieurement dans ce didacticiel.
- L’onglet Help (Aide) ouvre la page Web d’aide Arcade.
L’éditeur d’expressions Arcade vous permet également de tester votre expression au fil de son développement, à l’aide du bouton Run (Exécuter).
- Cliquez sur Run (Exécuter).
Les onglets Output (Sortie), Console et Log (Journal) apparaissent. Une fois l’expression créée, vous pouvez cliquer sur le bouton Run (Exécuter) pour tester la sortie de l’expression. Mais pour l’heure, comme vous n’avez pas écrit de code Arcade, ces onglets ne contiennent pas beaucoup de données.
- L’onglet Output (Sortie) affiche la sortie de l’expression.
- Vous pouvez aussi ajouter des fonctions Console() à votre code et voir leur valeur sous l’onglet Console.
Initialiser des variables
Vous allez maintenant écrire le code de votre expression Arcade. Vous allez faire cela en trois temps :
- Pour commencer, vous allez initialiser (créer) plusieurs variables contenant des valeurs qui vous seront nécessaires par la suite dans l’expression Arcade.
- À présent, vous allez créer un FeatureSet à partir de la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays) pour pouvoir utiliser les attributs de cette couche dans votre expression.
- Enfin, vous utiliserez toutes ces données pour produire de nouvelles informations, à savoir le nombre de citoyens auxquels chaque centrale électrique peut fournir de l’électricité.
Dans cette section, vous allez vous concentrer sur l’initialisation et le test des variables.
- Dans la fenêtre Expression, saisissez (ou copiez et collez) var countryName =.
Vous allez créer une première variable, countryName, qui contiendra le nom du pays dans lequel la centrale électrique se situe. Dans Arcade, utilisez la syntaxe Var <nomVariable> = <valeur> pour définir les variables à utiliser par la suite dans l’expression. Vous allez spécifier la valeur de la variable en récupérant l’attribut correspondant dans la couche Global Power Plants.
- Si nécessaire, cliquez sur l’onglet Profile variables (Variables de profil). Développez l’élément $feature en cliquant sur la flèche.
La liste d’attributs de la couche Global Power Plants (Centrales électriques dans le monde) s’affiche.
Remarque :
Comme nous l’avons vu, cette expression Arcade s’exécutera lorsque l’utilisateur cliquera sur le nom d’une centrale électrique sur la carte et que la fenêtre contextuelle d’information s’affichera pour cette entité. L’élément $feature vous donne accès aux données de cette entité de centrale électrique spécifique dans la couche Global Power Plants (Centrales électriques dans le monde). Elle comporte tous ses attributs et sa géométrie.
Elle se distingue de $layer, qui accède à toutes les entités de la couche et non à une seule entité. Par exemple, vous pouvez utiliser $layer pour obtenir la moyenne d’une valeur attributaire pour toutes les entités d’une couche d’entités.
- Faites défiler la liste des attributs et cliquez sur $feature.country_long.
![Cliquez sur $feature["country_long"].](GUID-2F3C2AA8-4923-4084-A1A3-ADCAE330DC06-web.png "Cliquez sur $feature[\"country_long\"].")
Votre ligne de code est complète.
L’expression aura également besoin de variables contenant le nom de la centrale électrique ainsi qu’une estimation de sa production électrique annuelle. Au lieu de créer ces deux variables en partant de zéro, vous allez copier le code existant de l’une des expressions Arcade préexistantes.
- Appuyez sur la touche Entrée pour commencer la ligne suivante de l’expression.
- Mettez en surbrillance les deux lignes de code suivantes, puis appuyez sur les touches Ctrl+C pour les copier.
var plantName = $feature.name
var annualGenerationGwh = $feature["estimated_generation_gwh"]
Remarque :
Vous pouvez également copier les lignes en cliquant avec le bouton droit sur le texte en surbrillance et en sélectionnant Copy (Copier).
- Dans la fenêtre Expression, appuyez sur les touches Ctrl+V pour coller le code. Cliquez sur la ligne 3, puis appuyez sur la touche Retour arrière.
Remarque :
Vous pouvez également coller les lignes en cliquant avec le bouton droit sur le point d’insertion et en sélectionnant Paste (Coller).
Vous allez maintenant tester ces instructions de variable pour vérifier qu’elles fonctionnement comme prévu. Pour cela, vous allez ajouter une instruction return à la fin de votre code, en commençant par la première variable.
- Cliquez sur la fin de la ligne 3 et appuyez sur Entrée pour démarrer la ligne de code suivante, puis saisissez return countryName. Cliquez sur Run (Exécuter).
La sortie finale du script s’affiche dans la fenêtre Output (Sortie). Il s’agit de la valeur de l’instruction return et indique Afghanistan.
Cela est dû au fait que, pour les besoins du test, l’éditeur d’expressions utilise la première entité de la table attributaire. Dans ce cas, la première entité est une centrale électrique située en Afghanistan. Vous allez maintenant tester la valeur de la deuxième variable.
- Dans la fenêtre Expression, mettez à jour la dernière ligne de votre script pour qu’elle indique return plantName. Cliquez sur Run (Exécuter).
La valeur Kajaki Hydroelectric Power Plant Afghanistan s’affiche dans la fenêtre Output (Sortie). Il s’agit du nom de la centrale électrique afghane par défaut.
Vous allez maintenant tester la valeur de la troisième variable.
- Dans la fenêtre Expression, mettez de nouveau à jour la ligne pour qu’elle indique return annualGenerationGwh, puis cliquez sur Run (Exécuter).
Dans la fenêtre Output (Sortie), aucune valeur n’est répertoriée et le résultat est Null (Nul).
Cela est dû au fait qu’il n’existe pas de données d’estimation de production électrique annuelle pour la centrale électrique par défaut (Kajaki Hydroelectric Power Plant Afghanistan). En pareil cas, vous pouvez spécifier manuellement une valeur différente pour les besoins du test.
- Au-dessus de la ligne return annualGenerationGwh, ajoutez la fonction annualGenerationGwh = 10, puis cliquez sur Run (Exécuter).
Dans la fenêtre Output (Sortie), la valeur 10 (gigawattheures ou gWh) est renvoyée. Vous utiliserez cette valeur de test dans les sections suivantes du didacticiel.
- Dans la fenêtre Expression, supprimez la ligne return annualGenerationGwh, car vous n’en aurez plus besoin.
Avant de poursuivre le développement de votre expression, vous allez la nommer et l’enregistrer. Il est important de donner un nom aux expressions que vous créez pour en faciliter l’identification et l’utilisation dans votre carte.
- Dans la partie supérieure de la fenêtre de l’éditeur, cliquez sur New expression (Nouvelle expression), mettez-le en évidence, puis supprimez le texte. Saisissez Nombre de citoyens que la centrale électrique peut alimenter sur une année.
- Au bas de la fenêtre de l’éditeur, cliquez sur Done (Terminé) pour fermer l’éditeur d’expressions.
L’expression apparaît dans la fenêtre Attribute expressions (Expressions attributaires).
- Dans la barre d’outils Contents (Contenu), cliquez sur Save and open (Enregistrer et ouvrir), puis sélectionnez Save (Enregistrer) pour enregistrer votre carte et l’expression Arcade.
Remarque :
Il est recommandé d’enregistrer l’expression Arcade et la carte régulièrement.
Obtenir les données d’une autre couche
Pour déterminer le nombre de citoyens qu’une centrale électrique peut alimenter en électricité dans la fenêtre contextuelle Global Power Plants (Centrales électriques dans le monde), vous devez diviser l’estimation de production électrique annuelle de la centrale électrique par la consommation électrique par tête du pays où est située la centrale.
Vous avez obtenu le premier chiffre dans la section précédente, qui est stocké dans la variable annualGenerationGwh. Le deuxième chiffre peut être dérivé des attributs de population et de consommation électrique totale de la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays). Cela signifie que vous allez devoir accéder aux attributs de World Countries Electricity Consumption (Consommation électrique mondiale par pays) dans la fenêtre contextuelle Global Power Plants (Centrales électriques dans le monde). Pour cela, vous allez créer un FeatureSet.
Un FeatureSet vous permet d’accéder aux entités de n’importe quelle couche de la carte ou d’un service d’entités externe à la carte. Vous pouvez ensuite filtrer les entités auxquelles vous avez accédé selon des critères de pertinence. Dans votre cas, vous allez accéder aux entités de World Countries Electricity Consumption (Consommation électrique mondiale par pays) (c’est-à-dire, à la liste de tous les pays du monde et à leurs attributs), et vous allez rechercher le pays où est située la centrale électrique en question. Par exemple, pour la centrale hydroélectrique de Kajaki, vous allez filtrer la liste sur la seule entité Afghanistan. Ainsi, l’entité Global Power Plants (Centrales électriques dans le monde) sera connectée à l’entité appropriée de World Countries Electricity Consumption (Consommation électrique mondiale par pays) du fait de la correspondance des valeurs attributaires de nom de pays. Pour en savoir plus sur les FeatureSets, consultez la documentation Arcade.
Remarque :
Compte tenu du temps de traitement des requêtes qui retournent beaucoup de données, les FeatureSets peuvent s’avérer moins performants avec les jeux de données volumineux.
Vous allez maintenant créer le FeatureSet à l’aide de FeatureSetByName.
Remarque :
FeatureSetByName est l’une des nombreuses options permettant de créer un FeatureSet.
- Dans la fenêtre Attribute expressions (Expressions attributaires), cliquez sur Number of Citizens the Power Plant can Supply Annually (Nombre de citoyens que la centrale électrique peut alimenter sur une année) pour rouvrir l’expression dans l’éditeur d’expressions Arcade.
- Dans la fenêtre Expression, dans la prochaine ligne vide, saisissez var countriesGenFset =.
- Cliquez sur l’onglet Profile variables (Variables de profil). Développez l’élément $map en cliquant sur la flèche.
La liste de toutes les couches contenues dans la carte s’affiche à l’écran.
- Sous Layers (Couches), pour World Countries Electricity Consumption (Consommation électrique mondiale par pays), cliquez sur la flèche.
- Sous World Countries Electricity Consumption (Consommation électrique mondiale par pays), cliquez sur FeatureSetByName($map, "World Countries Electricity Consumption").
La fonction FeatureSetbyName est ajoutée à la fenêtre Expression. Dans la fenêtre Expression, l’instruction se présente comme suit :
var countriesGenFset = FeatureSetByName($map, "World Countries Electricity Consumption")
FeatureSetByName() utilise la valeur de $map pour son premier paramètre, donnant essentiellement instruction de rechercher cette couche dans la carte actuelle. Le deuxième paramètre est le nom de la couche elle-même. Il doit correspondre au nom de la couche dans la fenêtre Layers (Couches).
Vous allez maintenant ajouter quelques arguments facultatifs à la fonction FeatureSetByName() pour affiner la définition de votre FeatureSet.
Remarque :
Vous pouvez indiquer précisément les attributs qui vous intéressent pour éviter de charger l’intégralité de la table attributaire. Par exemple, pour ce didacticiel, seuls vous intéressent le nom du pays, le total de la consommation électrique annuelle et la population totale. Le fait de demander uniquement les champs nécessaires profite aux performances, car il y a alors moins de données à envoyer.
Vous pouvez également demander à inclure la géométrie dans le FeatureSet de façon à pouvoir accéder aux polygones pour chaque pays. Cela se fait avec une valeur booléenne (valeur true ou false). Sachant que vous n’aurez pas besoin de la géométrie dans ce didacticiel, vous allez définir la valeur booléenne sur false. Le fait de ne pas demander la géométrie profite également aux performances, et d’une manière générale, la géométrie ne doit être incluse dans l’expression qu’en cas de nécessité.
Si ces paramètres ne sont pas définis, tous les attributs et la géométrie sont inclus dans le FeatureSet.
Vous allez maintenant modifier la ligne FeatureSetByName() de sorte que le FeatureSet contienne uniquement les trois champs dont vous avez besoin, sans la géométrie.
Remarque :
Compte tenu de la longueur de l’instruction, il est recommandé de la scinder en plusieurs lignes afin d’améliorer la lisibilité. Pour cela, ajoutez des sauts de ligne entre les arguments (après chaque virgule).
- Pour la ligne FeatureSetByName(), après "World Countries Electricity Consumption", supprimez la parenthèse fermante et entrez une virgule. Copiez/collez le texte suivant :
['COUNTRY', 'Annual_Electricity_Consumption_', 'POP'], false)
Vous allez ajouter une instruction return pour tester et inspecter le FeatureSet.
- Dans la fenêtre Expression, dans la prochaine ligne vide, saisissez return countriesGenFset.
- Cliquez sur Run (Exécuter).
Le FeatureSet est renvoyé dans la fenêtre Output (Sortie). Il regroupe toutes les entités de la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays) ainsi que les seuls attributs que vous avez demandés.
Vous allez maintenant utiliser la fonction Filter() pour filtrer les lignes du FeatureSet en fonction de la valeur stockée dans la variable countryName. Filter() accepte deux paramètres : la couche ou le FeatureSet à filtrer et l’expression SQL qui assure le filtrage.
- Dans la fenêtre Expression, au-dessus de l’instruction return countriesGenFset, appuyez sur la touche Entrée pour ajouter une nouvelle ligne, puis saisissez var filteredCountryFSet =.
- Cliquez sur l’onglet Functions (Fonctions), puis, dans la zone de recherche, saisissez Filter (Filtrer). Dans les résultats de la recherche, cliquez sur Filter(features, sqlExpression) pour l’ajouter à votre instruction.
Filter() est ajouté à l’éditeur d’expressions avec deux espaces réservés pour les arguments, features et sqlExpression.
Remarque :
Dans l’onglet Functions (Fonctions), vous pouvez obtenir des informations supplémentaires sur une fonction en cliquant sur la flèche à côté du nom de la fonction.
- Modifiez les espaces réservés d’argument de Filter() pour former l’instruction suivante :
var filteredCountryFSet = Filter(countriesGenFset, 'COUNTRY = @countryName')
Le symbole @ dans @countryName signifie que countryName est une variable qui a été définie antérieurement dans l’expression. Cette expression SQL parcourt toutes les lignes du FeatureSet et conserve uniquement celles dont l’attribut COUNTRY a la même valeur que la variable countryName (en l’occurrence, Afghanistan). La variable filteredCountryFSet contient uniquement les lignes du FeatureSet qui réussissent le test.
- Modifiez l’instruction return pour qu’elle indique return filteredCountryFSet, puis cliquez sur Run (Exécuter).
Désormais, la fenêtre Output (Sortie) ne contient plus que la ligne pour Afghanistan.
Remarque :
Il existe d’autres façons de filtrer les entités d’un FeatureSet. Si un FeatureSet comprend la géométrie des entités, les fonctions Arcade Intersects() et Contains() peuvent atteindre le même objectif final qui est de connecter les entités du FeatureSet à celles de la couche de fenêtre contextuelle. Cela s’avère utile dans les cas où les deux couches ne partagent pas un même attribut, mais où les entités des couches s’intersectent spatialement de façon significative.
Même si la variable filteredCountryFset contient une seule ligne, il s’agit quand même d’un FeatureSet, et la ligne est intégrée dans une structure de table. Vous allez maintenant extraire les données de la table de façon à pouvoir les utiliser plus facilement. Dans Arcade, la fonction First() est couramment utilisée dans ce cas. Elle extrait la première entité d’un FeatureSet et la renvoie.
- Dans la fenêtre Expression (Expression), ajoutez une nouvelle ligne au-dessus de l’instruction return filteredCountryFSet, puis saisissez var filteredCountry =.
- Dans l’onglet Functions (Fonctions), dans la zone de recherche, saisissez first. Sous FeatureSet functions (Fonctions de jeux d’entités), cliquez sur First(features) -> Feature pour ajouter cette fonction à l’expression.
La fonction est ajoutée avec un espace réservé d’argument : First(features).
- Remplacez l’espace réservé d’argument par ce qui suit :
var filteredCountry = First(filteredCountryFset)
- Modifiez l’instruction return pour qu’elle indique return filteredCountry, puis cliquez sur Run (Exécuter).
Dans la fenêtre Output (Sortie), les données apparaissent désormais sous la forme d’une entité unique.
Vous allez utiliser ces données dans les prochaines instructions de l’expression Arcade.
Calculer l’alimentation en électricité
Vous allez maintenant utiliser les informations que vous avez extraites du FeatureSet pour calculer le nombre de citoyens qu’une centrale électrique peut alimenter en électricité. Ensuite, vous mettrez en forme le nombre obtenu.
Pour commencer, vous allez obtenir la consommation électrique annuelle du pays de la centrale. Ces données sont stockées dans l’entité filteredCountry, dans le champ de son attribut Annual_Electricity_Consumption_. Pour accéder aux attributs d’une entité dans Arcade, utilisez la syntaxe feature["attribute"] ou feature.attribute.
Comme vous avez pu le voir dans les résultats du test précédent, cet attribut s’appelle Annual_Electricity_Consumption_. Toutefois, vous pouvez aussi retrouver cette information en explorant les champs de manière interactive dans la fenêtre Globals (Globaux).
- Cliquez sur l’onglet Profile variables (Variables de profil). Si nécessaire, cliquez sur le bouton Back (Retour). Développez l’élément $map en cliquant sur la flèche.
- Sous le groupe Layers (Couches), cliquez sur la flèche de World Countries Electricity Consumption (Consommation électrique mondiale par pays).
La liste d’attributs de la couche s’affiche, notamment l’attribut Annual_Electricity_Consumption_.
Maintenant que vous avez identité avec certitude le nom de l’attribut qui vous intéresse, vous allez écrire l’instruction pour l’ajouter à une variable.
- Dans la fenêtre Expression, ajoutez une nouvelle ligne au-dessus de l’instruction return filteredCountry, puis saisissez ce qui suit :
var electricityConsumption = filteredCountry.Annual_Electricity_Consumption_
- Modifiez l’instruction return pour qu’elle indique return electricityConsumption, puis cliquez sur Run (Exécuter).
Dans la fenêtre Output (Sortie), comme le pays de test est l’Afghanistan, c’est la consommation électrique annuelle de l’Afghanistan qui est renvoyée : 5526000000 (kilowattheures ou kWh).
De la même manière, vous allez accéder aux données de population stockées dans l’entité filteredCountry.
Comme vous avez défini annualGenerationGwh = 10, la sortie est 0. Vous devez supprimer cette valeur dans le code à exécuter en fonction des valeurs données provenant de la table attributaire.
- Supprimez la ligne annualGenerationGwh = 10 et cliquez sur Run (Exécuter).
- Dans la fenêtre Expression, ajoutez une nouvelle ligne au-dessus de l’instruction return, puis saisissez var population = filteredCountry.POP;.
- Modifiez l’instruction return pour qu’elle indique return population, puis cliquez sur Run (Exécuter).
La fenêtre Output (Sortie) affiche la population totale de l’Afghanistan : 37466414.
Ensuite, vous allez calculer la consommation par habitant en divisant la consommation annuelle estimée par la population totale.
- Dans la fenêtre Expression, ajoutez une nouvelle ligne au-dessus de l’instruction return, puis saisissez ce qui suit :
var consumptionPerCapita = electricityConsumption / population
- Modifiez l’instruction return pour qu’elle indique return consumptionPerCapita, puis cliquez sur Run (Exécuter).
La fenêtre Output (Sortie) affiche la consommation par habitant : 147,4920978559624 (kWh).
Pour obtenir une estimation du nombre de citoyens que la centrale électrique peut alimenter en électricité sur une année, vous allez diviser la production électrique annuelle estimée de la centrale électrique (convertie de gWh en kWh en multipliant cette valeur par 1000000) par la consommation électrique par habitant du pays que vous venez de calculer (en kWh)
Voici la formule correspondante : annualGenerationGwh * 1000000) / consumptionPerCapita.
Vous allez ensuite utiliser la fonction Round() pour renvoyer un nombre entier et non décimal, car les personnes doivent être représentées par des nombres entiers.
- Dans la fenêtre Expression, ajoutez une nouvelle ligne au-dessus de l’instruction return, puis saisissez var numCitizensAnnually =.
- Sous l’onglet Functions (Fonctions), recherchez la fonction Round, puis cliquez dessus pour l’insérer dans votre instruction.
La fonction est ajoutée avec des espaces réservés pour les arguments : Round(value, ). À la place de value, vous allez insérer la formule définie ci-dessus.
- Pour la fonction Round, dans les parenthèses, remplacez value par (annualGenerationGwh * 1000000) / consumptionPerCapita.
Le deuxième argument Round(), numPlaces, indique le nombre de décimales à appliquer pour arrondir le nombre.
- Après l’expression, saisissez une virgule, un espace et 0.
- Modifiez l’instruction return pour qu’elle indique return numCitizensAnnually, puis cliquez sur Run (Exécuter).
Remarque :
Si le résultat est 0 pour vous, rajoutez annualGenerationGwh = 10 au-dessus de la ligne de la variable NumCitizensAnnually = Round.
La fenêtre Output (Sortie) présente le résultat de cette formule : 67800 (citoyens).
Vous allez maintenant mettre en forme ce nombre arrondi pour ajouter des séparateurs de milliers à l’aide de la fonction Text().
- Dans la fenêtre Expression (Expression), ajoutez une nouvelle ligne au-dessus de l’instruction return, puis saisissez var displayNumCitizensAnnually = et ajoutez un espace.
- Cliquez sur l’onglet Functions (Fonctions), recherchez la fonction Text, puis cliquez dessus pour l’insérer dans votre instruction.
La fonction est ajoutée avec des espaces réservés pour les arguments : value
- Remplacez value par numCitizensAnnually, puis saisissez , '###,###,###' pour admettre les valeurs comportant jusqu’à neuf chiffres.
- Modifiez l’instruction return pour qu’elle indique return displayNumCitizensAnnually, puis cliquez sur Run (Exécuter).
Dans la fenêtre Results (Résultats), 67800 devient 67,800, qui est le format que vous visiez.
La centrale hydroélectrique de Kajaki en Afghanistan peut alimenter 67,800 citoyens afghans par an (estimation).
Maintenant que vous avez calculé le nombre estimatif de citoyens que la centrale électrique peut alimenter en électricité sur une année, vous allez renvoyer cette valeur dans une phrase qui s’affichera dans la fenêtre contextuelle. Pour ce faire, vous allez utiliser un littéral de modèle et incorporer une mise en forme de texte supplémentaire. Un littéral de modèle est délimité par des accents graves (`) et utilise la syntaxe ${variableName} pour insérer des variables ou des expressions dans une chaîne. Cela signifie que la phrase renvoyée variera en fonction de la valeur des variables pour chaque centrale électrique de la carte.
- Dans la fenêtre Expression (Expression), ajoutez une nouvelle ligne au-dessus de l’instruction return, puis copiez et collez la ligne suivante :
var dataTL = `On average, a citizen in ${ countryName } consumes ${ text(round(consumptionPerCapita, 0), '###,###,###,###') } kilowatt-hours of electricity per year. ${ plantName } supplies electricity for ${ displayNumCitizensAnnually } citizens in ${ countryName } annually.`
Remarque :
Vous ne devez pas ajouter des sauts de ligne car ils s’afficheraient dans la sortie.
- Modifiez l’instruction return pour qu’elle indique return dataTL, puis cliquez sur Run (Exécuter).
La fenêtre Output (Sortie) présente la phrase de sortie, dans laquelle les variables ont été remplacées par les valeurs évaluées correspondantes.
Gérer les valeurs manquantes
Votre expression Arcade est presque prête. Cependant, il vous reste à vous pencher sur les rares cas où il manque des valeurs attributaires. Il existe trois cas notables :
- Absence de données d’estimation de production électrique annuelle pour une entité de centrale électrique.
- Une entité de centrale électrique de la couche Global Power Plants (Centrales électriques dans le monde) peut faire référence à un pays qui n’existe pas dans la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays).
- Absence de données de consommation électrique pour le pays de la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays).
Pour commencer, vous allez traiter le cas où il n’existe pas de données d’estimation de production électrique annuelle pour la centrale électrique. Vous avez déjà rencontré ce cas de figure dans le didacticiel avec l’entité de centrale électrique de test (la centrale hydroélectrique de Kajaki en Afghanistan). Vous allez reprendre le travail qui a été fait dans l’expression préexistante Estimated Annual Generation in Lightbulbs (Estimation de production annuelle exprimée en ampoules électriques) pour résoudre le problème des valeurs manquantes.
- Cliquez sur l’onglet Suggestions. Pour Estimated Annual Generation in Lightbulbs (Estimation de production annuelle exprimée en ampoules électriques), cliquez sur la flèche pour développer et afficher un aperçu du code.
- Mettez en surbrillance l’extrait de l’expression de var generationCheck jusqu’à l’accolade fermante (incluse) à la suite de return noGenerationTL. Appuyez sur les touches Ctrl+C pour le copier.
- Dans la fenêtre Expression, repérez la ligne déclarant la variable annualGenerationGwh, ajoutez une nouvelle ligne, puis appuyez sur les touches Ctrl+V pour coller le texte copié.
Remarque :
Les lignes qui commencent par // sont des commentaires, qui n’ont aucune incidence sur le comportement de l’expression. Vous pouvez éventuellement les supprimer.
Le code que vous avez inséré crée une variable booléenne (true ou false) à partir de la valeur de la fonction IsEmpty(). IsEmpty() vérifie si une variable est vide ou null et renvoie True si c’est le cas. Par conséquent, vous vérifiez si la variable annualGenerationGwh, qui contient la valeur d’estimation de production électrique annuelle, est vide. Si c’est le cas, l’instruction if renvoie une phrase expliquant le problème. Pour en savoir plus sur le code que vous venez de réutiliser, reportez-vous au didacticiel Prise en main de ArcGIS Arcade.
Vous allez modifier le littéral de modèle pour qu’il reflète mieux le scénario spécifique auquel répond l’expression Arcade.
- Dans le texte que vous venez de coller, mettez en surbrillance le texte qui suit var noGenerationTL =, puis remplacez-le par le texte suivant :
`${ plantName } does not have estimated annual generation data. Unable to calculate the number of citizens the power plant can supply electricity for annually.`
Pour tester ce cas, vous allez supprimer la valeur de test 10 que vous aviez ajoutée à l’attribut $feature.estimated_annual_generation.
- Dans le code, recherchez la ligne annualGenerationGwh = 10 et saisissez // devant pour la mettre en commentaire.
- Cliquez sur Run (Exécuter).
Le résultat affiche la phrase de données manquantes, ce qui est logique puisque l’entité de test ne dispose pas de données d’estimation de production électrique annuelle.
- Dans le code, supprimez les commentaires de la ligne annualGenerationGwh = 10.
Pour terminer, vous allez vous occuper du troisième cas de valeurs manquantes, à savoir l’absence de données de consommation électrique pour un pays de la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays). Vous allez partir du principe que s’il n’existe pas de données d’estimation de consommation annuelle pour le pays, la variable electricityConsumption aura la valeur null.
- Dans la fenêtre Expression, après la ligne déclarant la variable electricityConsumption, ajoutez une nouvelle ligne, puis saisissez ce qui suit :
if (electricityConsumption == null) {
var noConsumptionTL = `There is no annual electricity consumption data for ${ countryName }. Unable to calculate the number of citizens the power plant can supply electricity for annually.`
return noConsumptionTL
}
Remarque :
L’utilisation de la fonction IsEmpty() était également envisageable, mais == null teste précisément si la variable a la valeur null.
Pour tester ce cas, vous allez utiliser l’exemple de Boulaos à Djibouti, qui est un pays de la couche World Countries Electricity Consumption (Consommation électrique mondiale par pays) qui ne présente pas de données de consommation électrique annuelle.
- Cliquez sur Done (Terminé) dans la fenêtre Expression.
- Sur la carte, cliquez sur le bouton Search (Rechercher) pour Djibouti, puis cliquez sur le symbole ponctuel Global Power Plant (Centrale électrique mondiale) pour ouvrir la fenêtre contextuelle.
Maintenant que vous avez traité les différents cas de données manquantes, vous pouvez être assuré que votre expression renverra toujours un message cohérent à l’utilisateur. Votre Arcade expression est à présent complète.
- Dans la barre d’outils Contents (Contenu), cliquez sur Save and open (Enregistrer et ouvrir), puis sélectionnez Save (Enregistrer) pour enregistrer votre carte et l’expression Arcade.
L’expression complète du didacticiel est disponible pour référence ci-dessous. Des commentaires ont été ajoutés pour aider le lecteur à comprendre le code.
// Save the country and power plant name to variables for later use
var countryName = $feature["country_long"]
// Save the power plant name and annual generation to a variable
// for later use
var plantName = $feature.name
var annualGenerationGwh = $feature["estimated_generation_gwh"]
// Check if there is a value in the estimated annual generation
// attribute field. isEmpty(fieldOrValue) returns true if empty
var generationCheck = isEmpty(annualGenerationGwh)
// If there is not annual generation data, return a sentence for use
// in the pop-up that informs the user about this.
// The below expression uses conditional logic and a template literal:
if (generationCheck) {
var noGenerationTL = `${ plantName } does not have estimated annual generation data. Unable to calculate the number of citizens the power plant can supply electricity for annually.`
return noGenerationTL
}
// If there is average annual generation data, the script continues:
// Create a FeatureSet from the World Countries Electricity Consumption layer
var countriesGenFset = FeatureSetByName($map,
"World Countries Electricity Consumption",
['COUNTRY', 'Annual_Electricity_Consumption_', 'POP'], false)
// Filter the countries feature set. COUNTRY is attribute field in World
// Countries Population and Annual Electricity Consumption
// filteredCountryFset will be a FeatureSet with only one feature,
// because the powerplant country value is only equal to one country
var filteredCountryFset = filter(countriesGenFset,
'COUNTRY = @countryName')
// Select the first country in the filtered FeatureSet
// This essentially changes the data type from FeatureSet to a feature
// because in this case, there is only one feature in each FeatureSet
var filteredCountry = first(filteredCountryFset)
}
// Access the electricity consumption value for the country
// from the countries layer
// Note: bracket [] and . notation are both accepted
var electricityConsumption = filteredCountry.Annual_Electricity_Consumption_;
// Check if there is annual electricity consumption data for the country
// Instead of using isEmpty, we will check if the value is null
// If it isn't, return a sentence indicating this and exit the script
if (electricityConsumption == null) {
var noConsumptionTL = `There is no annual electricity consumption data for ${ countryName }. Unable to calculate the number of citizens the power plant can supply electricity for annually.`
return noConsumptionTL
}
// Access the population value for the country from the countries layer
var population = filteredCountry.POP;
// Compute the consumption per capita for that country
var consumptionPerCapita = electricityConsumption / population
// Calculate the number of citizens the plant can supply annually
var numCitizensAnnually = round(
(annualGenerationGwh * 1000000) /
(consumptionPerCapita), 0)
// Change the number to text so we can add thousand separators
var displayNumCitizensAnnually = Text(numCitizensAnnually,"###,###,###");
// Use a template literal to return the string we will display
// in the pop-up
var dataTL = `On average, a citizen in ${ countryName } consumes ${ text(round(consumptionPerCapita, 0), '###,###,###,###') } kilowatt-hours of electricity per year. ${ plantName } supplies electricity for ${ displayNumCitizensAnnually } citizens in ${ countryName } annually.`
return dataTLAfficher les résultats dans la fenêtre contextuelle
Maintenant que votre expression Arcade est complète, il est temps de l’utiliser dans le texte des fenêtres contextuelles de la couche Global Power Plants (Centrales électriques dans le monde).
- Dans la fenêtre Layers (Couches), vérifiez que la couche Global Power Plants (Centrales électriques dans le monde) est sélectionnée.
- Dans la fenêtre Attribute expressions (Expressions attributaires), cliquez sur le bouton de retour.
- Au bas de la fenêtre Pop-ups (Fenêtres contextuelles), cliquez sur Text (Texte), puis sur Edit text (Modifier le texte).
La fenêtre de l’éditeur de texte de fenêtre contextuelle apparaît, avec le texte actuellement affiché dans la couche Global Power Plants (Centrales électriques dans le monde). Vous allez ajouter le résultat de votre expression Arcade au texte existant.
- Dans l’éditeur de texte de fenêtre contextuelle, placez votre curseur à la fin de {expression/expr1}, puis appuyez sur Entrée.
- Saisissez une suite de tirets (-------------------------------) pour créer une séparation entre les paragraphes. Appuyez sur la touche Entrée.
- Saisissez une accolade : {.
La liste des champs et des expressions Arcade disponible apparaît.
- Cliquez sur l’expression que vous venez de créer Number of Citizens the Power Plant can Supply Annually (Nombre de citoyens que la centrale électrique peut alimenter sur une année).
Remarque :
Vous voyez que l'expression Arcade que vous avez créée est répertoriée comme n'importe quel autre champ attributaire disponible. Elle est facilement reconnaissable grâce au nom explicite que vous lui avez donné plus tôt.
L'expression est ajoutée à l'élément Text (Texte) avec l’identifiant unique {expression/expr2}.
Remarque :
Si vous avez ajouté ou supprimé d’autres expressions, il se peut que l’identifiant unique utilise un autre nombre que 2, par exemple {expression/exp3}.
- Cliquez sur OK pour fermer l’éditeur de texte de fenêtre contextuelle.
- Enregistrez la carte.
Vous allez maintenant tester les fenêtres contextuelles.
- Fermez les fenêtres Pop-ups (Fenêtres contextuelles) et Layers (Couches) pour libérer de la place sur la carte.
- Faites un zoom avant sur une zone d’intérêt, par exemple Séville en Espagne.
- Cliquez sur une centrale électrique pour afficher la fenêtre contextuelle.
La fenêtre contextuelle affiche maintenant le nouveau paragraphe de texte que votre expression Arcade a généré.
- Dans la fenêtre contextuelle, examinez les informations concernant la consommation électrique par citoyen et le nombre de citoyens desservis par la centrale électrique.
- Cliquez sur d’autres centrales électriques pour afficher la fenêtre contextuelle correspondante.
Dans ce didacticiel, vous avez développé une expression ArcGIS Arcade afin de calculer le nombre de citoyens qu’une centrale électrique pouvait alimenter en électricité pendant un an. Vous avez découvert comment il est possible d’accéder aux données de plusieurs couches en utilisant des FeatureSet et la fonction Filter(). Vous avez ensuite utilisé ces données dans plusieurs calculs, traité plusieurs cas de données manquantes et utilisé l’expression dans des fenêtres contextuelles. L’expression Arcade est exécutée dynamiquement, sans aucune incidence sur les données sous-jacentes. Ce didacticiel n’a présenté que certaines des fonctionnalités d’Arcade. Pour en savoir plus, explorez le parcours d’apprentissage Arcade.
Vous trouverez d’autres didacticiels dans la bibliothèque des didacticiels.
