Planet Georezo » arcOrama

Un Planet est un site Web dynamique qui agrège le plus souvent sur une seule page, le contenu de notes, d'articles ou de billets publiés sur des blogs ou sites Web afin d'accentuer leur visibilité et de faire ressortir des contenus pertinents aux multiples formats (texte, audio, vidéo, Podcast). C'est un agrégateur de flux RSS. Il s'apparente à un portail web.
Vous pouvez lire le billet sur le blog La Minute pour plus d'informations sur les RSS !

Canaux

5416 éléments (724 non lus) dans 51 canaux

Dans la presse

Cybergeo (483 non lus)
SIGMAG & SIGTV.FR - Un autre regard sur la géomatique (6 non lus)
Mappemonde (60 non lus)
Dans les algorithmes (1 non lus)

Du côté des éditeurs

Imagerie Géospatiale
Toute l’actualité des Geoservices de l'IGN (15 non lus)
arcOpole - Actualités du Programme
Géoclip, le générateur d'observatoires cartographiques
arcOrama (9 non lus)

Toile géomatique francophone

Géoblogs (GeoRezo.net) (5 non lus)
UrbaLine (le blog d'Aline sur l'urba, la géomatique, et l'habitat)
Séries temporelles (CESBIO) (2 non lus)
Datafoncier, données pour les territoires (Cerema)
Cartes et figures du monde
SIGEA: actualités des SIG pour l'enseignement agricole
Data and GIS tips
Neogeo Technologies
ReLucBlog
L'Atelier de Cartographie
My Geomatic
archeomatic (le blog d'un archéologue à l’INRAP)
Cartographies numériques
Makina Corpus (1 non lus)
Carnet (neo)cartographique
GEOMATIQUE
Évènements – Afigéo (12 non lus)
Geotribu (50 non lus)
Icem7
Oslandia (1 non lus)
Les Cafés Géo (1 non lus)
CartONG (2 non lus)
Afigéo (12 non lus)
GEOMATICK (6 non lus)
Geomatys (3 non lus)
Conseil national de l'information géolocalisée (9 non lus)

Géomatique anglophone

Blogs GeoRezo.net

Abonnez vous à cette page (RSS) !

arcOrama (9 non lus)

01 September 2025
9:27
Le fond Open Basemap et les styles associés sont disponibles dans ArcGIS
sur arcOrama
Pour Esri, il a toujours été important de proposer à ses utilisateurs des référentiels de données cartographiques de haute qualité, fiables et accessibles. Dans ce domaine, l'usage de données ouvertes permet des projets cartographiques plus complets, plus précis et plus extensibles. C'est pourquoi, comme annoncé dans cet article en juillet 2024, Esri confirme aujourd'hui la sortie officielle des styles du nouveau fond de carte vectoriel "Open Basemap" créé à partir des données Overture Maps. En beta depuis juillet 2024, ces styles sont désormais officiellement accessibles sur ArcGIS Online et ArcGIS Location Platform (l'offre PaaS d'Esri pour les développeurs).

La fondation Overture Maps crée des données cartographiques ouvertes, faciles à utiliser et interopérables, avec pour vision que le partage de couches de base ouvertes (OpenStreetMap entre autres) favorisera la collaboration et l'innovation entre les secteurs industriels et les communautés.
Esri s'attache depuis longtemps à enrichir les cartes et services de données mondiales accessibles à tous en facilitant (via le programme Community Maps par exemple) le partage de données locales entre les campus, les villes, les EPCI, les régions et les états. En rejoignant, en 2023, l'Overture Maps Foundation en tant que membre général, Esri poursuit cette initiative et contribue au partage de données ouvertes et fiables pour l'ensemble de la communauté SIG.
Les données et les styles de ce fond de carte représentent l'occupation du sol, l'hydrographie, les routes, les bâtiments, la toponymie et les contours administratifs. "Open Basemap" est déclinée en 2D (Web Mercator et WGS84) et en 3D et sera proposé dans de nombreux styles, dont voici quelques exemples :
- OSM Style
- OSM style relief
- OSM style relief base
- Navigation
- Navigation dark
- Streets
- Streets relief
- Streets relief base
- Streets night
Pour plus d'informations sur les différents styles disponibles et accéder à liste complète des styles, vous pouvez visiter les styles la l'Open Basemap via ce groupe ArcGIS Online ou, pour les développeurs sur la page des styles de basemaps ArcGIS (onglet "Open Basemap".

Si vous souhaitez comparer le nouveau fond de carte "Open Basemap" avec l'ancien fond de carte "OSM Basemap" en terme de contenu et de style, je vous ai configuré cette Instant App ArcGIS en choisissant le style de rendu "OSM"

Les actions à envisager
Esri a mis à jour le fond de carte vectoriel "OpenStreetMap" en support mature en décembre 2024, ce qui signifie qu'il n'est mis à jour depuis cette date. Il continuera cependant d'être en ligne jusqu'en 2026 et au-delà.
Bien qu'il n'y ai pas d'urgence à modifier vos cartes/scènes web utilisant le fond de carte "OpenStreetMap Basemap", Esri vous recommande d'utiliser dès que possible le nouveau fond de carte "Open Basemap" basé sur les données d'Overture Maps Foundation incluant des données ouvertes issues d'OpenStreetMap et d'autres sources. Ce dernier étant actualisé mensuellement, il vous garantit un fond de carte toujours à jour.

Remarque:
Si vous utilisez le style de fond de carte "OpenStreetMap - Pastels" que j'avais réalisé en 2021 et que j'ai plusieurs fois évoqué sur blog, sachez que j'ai réalisé le style équivalent pour la nouveau fond de carte "Open Basemap", vous retrouverez cette carte web et vous pouvez ainsi l'ajouter à votre galerie de fonds de carte.
26 August 2025
16:04
Action requise pour les organisations ArcGIS Online utilisant SAML
sur arcOrama
Les administrateurs d'organisation ArcGIS Online qui ont activé les assertions signées et/ou chiffrées conformément aux bonnes pratiques d'ArcGIS Online pour la sécurité SAML doivent obtenir le nouveau fichier de métadonnées + certificat du fournisseur de services ArcGIS Online et l'associer à leur fournisseur d'identité SAML (par exemple, les applications d'entreprise utilisant Azure Active Directory avec chiffrement par jetons) avant le 19 septembre 2025, sinon les connexions ArcGIS Online avec les comptes d'entreprise (SAML) échoueront.
Vous devez suivre les étapes suivantes :
Étape 1 - Téléchargez le fichier de métadonnées mis à jour depuis ArcGIS Online :
1. Connectez-vous à www.arcgis.com avec vos identifiants administratifs
2. Cliquez sur "Organisation" puis "Paramètres" puis sur "Sécurité"
3. Faites défiler jusqu'à "Connexions > Connexion SAML", puis cliquez sur le lien "Télécharger les métadonnées du fournisseur de services" (comme indiqué ci-dessous). Cette action téléchargera le fichier de métadonnées (qui contient le certificat mis à jour) qui sera chargé sur votre fournisseur d'identité SAML.
Étape 2 - Téléchargez le fichier de métadonnées dans votre IDP SAML :
1. Dans la configuration de votre application d’entreprise qui vous permet de configurer le fournisseur d’identité SAML, recherchez l’entrée correspondant à votre organisation ArcGIS Online.
2. Téléchargez le fichier de métadonnées mis à jour téléchargé depuis ArcGIS Online vers votre fournisseur d'identité SAML. Consultez les instructions IDP SAML d'ArcGIS Online pour obtenir des instructions spécifiques à l'IDP sur la manière d'enregistrer le XML de métadonnées du fournisseur de services auprès de votre IDP.
Les administrateurs qui ont activé la fonctionnalité "Autoriser l'assertion de chiffrement" des bonnes pratiques pour la sécurité SAML doivent également suivre les étapes 3 à 4 ci-dessous :

Étape 3 - Extraire le certificat du fichier de métadonnées ArcGIS Online :
1. Extrayez et validez le certificat dans le fichier metadata.xml en copiant les caractères entre les balises <X509Certificate> et </X509Certificate>, en collant les données dans un fichier vide et en l'enregistrant avec une extension .cer.
Étape 4 - Mettre à jour le certificat de chiffrement de jeton dans le fournisseur d’identité :
1. Dans la configuration de votre application d’entreprise de fournisseur d’identité SAML, recherchez l’entrée correspondant à votre organisation ArcGIS Online.
2. Fournissez le certificat extrait dans la fonctionnalité « Chiffrement » de l'application ArcGIS Online. Reportez-vous à la documentation de votre fournisseur d'identité SAML pour obtenir des instructions spécifiques sur ce flux de travail.
En cas de soucis :
- Problème : lorsque j'essaie de me connecter à l'aide de SAML, j'obtiens le message d'erreur suivant: "Impossible de se connecter à l'aide d'IDP. Échec de la validation du déballage de l'assertion chiffrée".
  Cause principale : le fournisseur d'identité chiffre l'assertion SAML à l'aide d'un certificat expiré ou d'un certificat qu'ArcGIS Online ne reconnaît pas.
  Solution : effectuez les étapes 3 à 4 du blog ci-dessus. Ensuite, dans la configuration Fournisseur d'identité > SAML > Chiffrement de jeton pour l'application ArcGIS Online, désactivez (ou supprimez) les certificats précédemment configurés ou expirés.
- Pout tout autre problème ou question, n'hésitez pas à contacter votre interlocuteur technique chez Esri ou le support technique.
25 August 2025

8:00

Conseils & Astuces ArcGIS Online - N°207

sur arcOrama

N°207 - Expressions de données ArcGIS Dashboards - Combiner plusieurs jeux de données
Dans ce précédent article, je vous présentais la notion très puissante d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose un exemple d'expression de données permettant de combiner (assembler) plusieurs jeux de données avant de les utiliser dans votre tableau de bord.

Exemple:
Je dispose de plusieurs jeux de données contenant l'inventaire des maternités en France pour différentes années de 2019 à 2023.
2019

Cliquez sur l'image pour l'agrandir

2020

Cliquez sur l'image pour l'agrandir

... 2023

Cliquez sur l'image pour l'agrandir

L'objectif est tout simplement de combiner ces 5 jeux de données en une seule table pour pouvoir réaliser différentes représentations dans mon tableau de bord ArcGIS.

L'expression de données suivante pourra alors être utilisée :


// Récupération du portail, ici ArcGIS Online
var myportal = Portal("https://www.arcgis.com");

// Jeux de données à combiner
var datasets = [
  {id: "e916f4bfd43a45749430259e0f2cd705", lyr: 0},
  {id: "15ad737ec56047718e39bee66defe5fa", lyr: 0},
  {id: "d8042ec1eb38412aa17460d13b2f9f91", lyr: 0},
  {id: "a655dc01634749dc8da4bb57b2d147c4", lyr: 0},
  {id: "4b83cbea7c7041928394bf92be79c84b", lyr: 0},
];

// Résultats de la combinaison
var features = [];

// Boucle sur chaque jeu de données
for (var i in datasets) {
  var fs = FeatureSetByPortalItem(myportal, datasets[i].id, datasets[i].lyr,
     ["ANNEE","NOM_MAT","TYPE","STATUT","FI_ET","FI_EJ","NOMCOM","LIT_OBS",
     "SALTRAV","ACCTOT"], false);
  
  for (var f in fs) {
    Push(features, {
      attributes: {
        ANNEE: f["ANNEE"],
        NOM_MAT: f["NOM_MAT"],
        TYPE: f["TYPE"],
        STATUT: f["STATUT"],
        FI_ET: f["FI_ET"],
        FI_EJ: f["FI_EJ"],
        NOMCOM: f["NOMCOM"],
        LIT_OBS: f["LIT_OBS"],
        SALTRAV: f["SALTRAV"],
        ACCTOT: f["ACCTOT"]
      }
    });
  }
}

// Construction de la défintion du featureset (schéma + entités)
var json = {
  fields: [
    {name: "ANNEE", type: "esriFieldTypeInteger"},
    {name: "NOM_MAT", type: "esriFieldTypeString"},
    {name: "TYPE", type: "esriFieldTypeString"},
    {name: "STATUT", type: "esriFieldTypeString"},
    {name: "FI_ET", type: "esriFieldTypeString"},
    {name: "FI_EJ", type: "esriFieldTypeString"},
    {name: "NOMCOM", type: "esriFieldTypeString"},
    {name: "LIT_OBS", type: "esriFieldTypeInteger"},
    {name: "SALTRAV", type: "esriFieldTypeInteger"},
    {name: "ACCTOT", type: "esriFieldTypeInteger"}
  ],
  geometryType: "",
  features: features
};

// Conversion en FeatureSet
return FeatureSet(Text(json));

Le jeu de données généré est alors le suivant, il contient l'ensemble des données sur les maternités de 2019 à 2023 (soit au total 2286 enregistrements) :

Cliquez sur l'image pour l'agrandir

Vous pouvez, par exemple, représenter ces données combinées dans un tableau de bord à l'aide d'un diagramme en barres pour suivre l'évolution du nombre de lits obstétriques sur les 5 années par type de maternité :

Cliquez sur l'image pour l'agrandir

Vous pourrez également, par exemple, représenter le nombre d'accouchement total par année :

Cliquez sur l'image pour l'agrandir

Dans cet exemple, mes 5 jeux de données ont strictement le même schéma mais des variantes peuvent être introduites dans l'expression de données Arcade si nécessaire.

A travers cet exemple, vous avez pu découvrir comment utiliser une expression de données avec Arcade pour combiner (assembler) plusieurs jeux de données en un seul. Il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

En conclusion
Cet article conclut cette série de 6 articles (voir le premier article ici :"Conseils & Astuces ArcGIS Online" (N°200) consacrés à l'usage des expressions de données Arcade dans ArcGIS Dashboards. Je n'ai pas couvert tous les cas d'usage de cette récente capacité ajoutée dans ArcGIS Dashboards mais, je l'espère, les plus courants. Je terminerai en signalant également que les expressions de données existent aussi dans le concepteur d'application ArcGIS Experience Builder et que vous pouvez de la même manière les utilser pour personnaliser les sources de donnés alimentant vos widgets.
N'hésitez pas à me faire part de vos commentaires, poser des questions ou présenter des cas d'usages qui vous paraissent intéressants à partager via ce blog.

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

21 August 2025
8:18
Conseils & Astuces ArcGIS Online - N°206
sur arcOrama
N°206 - Expressions de données ArcGIS Dashboards - Faire pivoter les données de votre table
Dans ce précédent article, je vous présentais la notion très puissante d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose un exemple d'expression de données permettant de faire pivoter des lignes en colonnes dans les données avant de les utiliser dans votre tableau de bord.
Exemple:
Je dispose d'une table contenant pour chaque région française, le type de culture et la quantité produite correspondante.

Cliquez sur l'image pour l'agrandir

Pour mon tableau de bord ArcGIS, je souhaiterais faire pivoter les valeurs du champ "Culture" pour obtenir un enregistrement par région et autant de champs qu'il y a de type de culture. Le champ "Production" sera utilisé pour remplir les valeurs de production dans chacun de ces champs. On pourra également créer un champ contenant la production totale.

Cliquez sur l'image pour l'agrandir

L'expression de données suivante pourra alors être utilisée :
```
// Récupération du portail ArcGIS, ici ArcGIS Online
var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '329dbc62855e4b8780af7ef56bcd5fc9',
    0,
    ['*'],
    false
);

// Extraire toutes les valeurs uniques de "Culture"
var cultures = Distinct(fs, "Culture");

// Construire une liste dynamique des noms de produits
var listeCultures = [];
for (var p in cultures) {
    Push(listeCultures, p["Culture"]);
}

// Construire la structure de pivot
var pivot = {};

// Boucle sur les enregistrements pour agréger les ventes
for (var f in fs) {
    var region = f["Région"];
    var culture = f["Culture"];
    var productions = f["Production_milliers_de_tonnes"];

    // Initialiser la région si nécessaire
    if (!(HasKey(pivot, region))) {
        var dictCultures = {};
        for (var lp in listeCultures) {
            dictCultures[listeCultures[lp]] = 0;
        }
        dictCultures["Production totale"] = 0;
        pivot[region] = dictCultures;
    }

    // Ajouter les valeurs
    pivot[region][culture] += productions;
    pivot[region]["Production totale"] += productions;
}

// Définir les champs dynamiquement
var fields = [
    { name: "Région", type: "esriFieldTypeString" }
];

for (var lp in listeCultures) {
    Push(fields, { name: listeCultures[lp], type: "esriFieldTypeInteger" });
}
Push(fields, { name: "Production totale", type: "esriFieldTypeInteger" });

// Construire le FeatureSet en sortie
var outDict = {
    fields: fields,
    geometryType: "",
    features: []
};

for (var r in pivot) {
    var attrs = { "Région": r };
    for (var lp in listeCultures) {
        var prod = listeCultures[lp];
        attrs[prod] = pivot[r][prod];
    }
    attrs["Production totale"] = pivot[r]["Production totale"];

    Push(outDict.features, { attributes: attrs });
}

// On renvoie le featureset en sortie
return FeatureSet(Text(outDict));
```
Le jeu de données généré est alors le suivant :

Vous pouvez par exemple représenter ces données pivotées dans votre tableau de bord à l'aide de diagrammes à secteurs :

Cliquez sur l'image pour l'agrandir

Ou encore représenter la proportion de certaines cultures oopour chaque région à l'aide d'un diagramme de séries empilées :

Cliquez sur l'image pour l'agrandir

A travers cet exemple, vous avez pu découvrir comment utiliser une expression de données avec Arcade pour faire pivoter des lignes en colonnes. Il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

Bonne route sur ArcGIS Online ! Pour retrouver l'ensemble des Conseils & Astuces ArcGIS Online, cliquez sur ce lien.
19 August 2025

9:12

Conseils & Astuces ArcGIS Online - N°205

sur arcOrama

N°205 - Expressions de données ArcGIS Dashboards - Joindre des tables ou des couches d'entités
Dans ce précédent article, je vous présentais la notion très puissante d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose un exemple d'expression de données permettant de réaliser une jointure entre deux sources de données avant d'utiliser le résultat de cette jointure dans votre tableau de bord.

Exemple:
Je dispose d'une couche contenant les contours des ilots statistiques IRIS de l'INSEE. Ces derniers contiennent notamment le code et le nom de l'IRIS ainsi que le code et le nom de la commune dans laquelle ils se trouvent.

Cliquez sur l'image pour l'agrandir

Dans une autre table je dispose d'une série d'indicateurs statistiques de l'INSEE relatifs aux disparités de revenus par IRIS.

Cliquez sur l'image pour l'agrandir

L'objectif est de réaliser une jointure (de type "1 à 1" sur le code des IRIS) entre ces deux sources de données afin de isposer d'un jeu de données unique pour l'exploiter plus facilement dans mon tableau de bord.

L'expression de données suivante pourra alors être utilisée :


// Récupération du portail, ici ArcGIS Online
var myportal = Portal("https://www.arcgis.com/");

// Récupération de la couche contenant les descriptions des IRIS de l'INSEE
var IRIS_fs = FeatureSetByPortalItem(
    myportal,
    "0e189c922943465281c38f6274963405",
    0,
    ["*"],
    false
);

// Récupération de la table contenant les statistiques INSEE de revenus disponbles
var INSEE_fs = FeatureSetByPortalItem(
    myportal,
    "28e680ce40f44a1981792432d4250040",
    0,
    ["*"],
    false
);

// La couche contient tous les IRIS, on ne souhaite 
var IRIS_fs_filtre = Filter (IRIS_fs,"CODE_IRIS like '29%'")

// Créer le tableau pour les entités en sortie
var features = [];
var feat;

// Remplissage du tableau avec les attributs de la couche et de
// la table
for (var t in INSEE_fs) {
    var IRIS_ID = t["IRIS"]
    Console(IRIS_ID)
    for (var p in Filter(IRIS_fs_filtre, "CODE_IRIS = '"+IRIS_ID+"'")){
        feat = {
            attributes: {
                CODE_IRIS: IRIS_ID,
                NOM_IRIS: p["NOM_IRIS"],
                CODE_COMMUNE: p["INSEE_COM"],
                NOM_COMMUNE: p["NOM_COM"],
                DISP_GI21: t["DISP_GI21"],
                DISP_PACT21: t["DISP_PACT21"],
                DISP_PTSA21: t["DISP_PTSA21"],
                DISP_PCHO21: t["DISP_PCHO21"],
                DISP_PBEN21: t["DISP_PBEN21"],
                DISP_PPSOC21: t["DISP_PPSOC21"],
                DISP_PPFAM21: t["DISP_PPFAM21"],
                DISP_PPMINI21: t["DISP_PPMINI21"],
                DISP_PPLOGT21: t["DISP_PPLOGT21"],
                DISP_PIMPOT21: t["DISP_PIMPOT21"]
            }
        }
    Push(features, feat)
    }
}

// Dictionnaire pour définir le FeatureSet en sortie
var def_fs_output = {
    fields: [
        { name: "CODE_IRIS",
        alias:"Code IRIS", 
        type: "esriFieldTypeString" },
        { name: "NOM_IRIS", 
        alias:"Nom IRIS", 
        type: "esriFieldTypeString" },	
        { name: "CODE_COMMUNE", 
        alias:"Code INSEE Commune", 
        type: "esriFieldTypeString" },
        { name: "NOM_COMMUNE", 
        alias:"Nom Commune", 
        type: "esriFieldTypeString" },
        { name: "DISP_GI21", 
        alias: "Indice de Gini", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PACT21", 
        alias: "Part des revenus d’activité (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PTSA21", 
        alias: "dont part des salaires et traitements (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PCHO21", 
        alias: "dont part des indemnités de chômage (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PBEN21",
        alias: "dont part des revenus des activités non salariées (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PPSOC21", 
        alias: "Part de l'ensemble des prestations sociales (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PPFAM21", 
        alias: "dont part des prestations familiales (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PPMINI21", 
        alias: "dont part des minima sociaux (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PPLOGT21", 
        alias: "dont part des prestations logement (%)", 
        type: "esriFieldTypeInteger" },
        { name: "DISP_PIMPOT21", 
        alias: "Part des impôts (%)", 
        type: "esriFieldTypeInteger" },
    ],
    'geometryType': '',
    'features':features
};

// On renvoie le FeatureSet en sortie
return FeatureSet(def_fs_output);

Le jeu de données généré est alors le suivant :

Cliquez sur l'image pour l'agrandir

Vous pouvez par exemple le représenter dans votre tableau de bord à l'aide d'une fiche de détails et d'un diagramme en barres :

A travers cet exemple, vous avez pu découvrir comment utiliser des expressions de données avec Arcade pour réaliser une jointure entre les données de deux tables (ou couches d'entités). On notera que ce cette approche est intéressante car elle offre beaucoup de souplesse sur la manipulation des champs et des valeurs calculées à la volées, permettant par exemple des scenarii de jointure de type 1:N (multiplication). Cependant, elle ne doit être utilisée que sur des jeux de données peu volumineux (quelques centaines d'enregistrements maximum). Si vous souhaitez réaliser des jointures efficaces sur des volumes plus important, il est recommandé de créer une vue de couche. Une fois ces considérations prises en compte, il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

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

18 August 2025
8:15
Conseils & Astuces ArcGIS Online - N°204
sur arcOrama
N°204 - Expressions de données ArcGIS Dashboards - Filtrer uniquement les dernières valeurs
Dans ce précédent article, je vous présentais la notion très puissante d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose un exemple d'expression de données permettant de filtrer uniquement les enregistrements d'une table correspondants aux dates/heures les plus récentes avant de les utiliser dans votre tableau de bord.

Exemple:
Je dispose d'une table contenant, pour chaque station météo de mon territoire, des mesures de précipitations au cours du mois d'avril. Dans mon tableaux de bord, je souhaite afficher uniquement la dernière quantité de précipitation mesurée (Champ "DateHeure" le plus récent) pour chaque station (Champ "Station").

L'expression de données suivante pourra alors être utilisée :
```
// Récupération du portail ArcGIS, ici ArcGIS Online
var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    'af3d8ef69f8f490181a237540eabdc26',
    0,
    ['*'],
    false
);


// Grouper par station et trouver la date la plus récente
var grouped = GroupBy(
    fs,
    ["Station"],
    [{ name: "DateMesure", expression: "DateHeure", statistic: "MAX" }]
);


// Préparer la liste de features de sortie
var features = [];

for (var g in grouped) {
    var stationID = g["Station"];

    // Récupérer le dernier enregistrement pour la station en ordonnant sur le 
    // champs DateHeure décroissants
    var lastRec = Top(OrderBy(Filter(fs, "Station = @stationID"), "DateHeure DESC"),1);

    for (var rec in lastRec) {
        Push(features, {
            attributes: {
                "Station": stationID,
                "DateMesure": rec["DateHeure"],
                "Precipitations_mm": rec["Precipitations_mm"]
            }
        });
    }
}

// Définir le schéma du FeatureSet de sortie (sans géométrie)
var fs_final =  FeatureSet({
    fields: [
        { name: "Station", type: "esriFieldTypeString", alias: "Station" },
        { name: "DateMesure", type: "esriFieldTypeDate", alias: "Date/Heure de Mesure" },
        { name: "Precipitations_mm", type: "esriFieldTypeDouble", alias: "Précipitation (mm)" }
    ],
    geometryType: "",
    features: features
});

// Renvoie FeatureSet complet sans géométrie
return fs_final
```
Le jeu de données généré est alors le suivant :

Vous pouvez par exemple le représenter dans votre tableau de bord à l'aide d'un diagramme en barres :

A travers cet exemple, vous avez pu découvrir comment utiliser des expressions de données avec Arcade pour filtrer uniquement les enregistrements d'une table correspondant à la date/heure la plus récente. Il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

Bonne route sur ArcGIS Online ! Pour retrouver l'ensemble des Conseils & Astuces ArcGIS Online, cliquez sur ce lien.
14 August 2025

9:48

Conseils & Astuces ArcGIS Online - N°203

sur arcOrama

N°203 - Expressions de données ArcGIS Dashboards - Calculer des statistiques sur les données
Dans ce précédent article, je vous présentais la notion très puissante d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose plusieurs exemples d'expressions de données permettant de calculer dynamiquement des statistiques sur les données avant de les utiliser dans votre tableau de bord.

Exemple 1:
Je dispose d'une table contenant pour chaque pays européen la production agricole en milliard d'euros. Je souhaite tout simplement afficher dans une liste le pourcentage que représente cette production pour chaque pays par rapport au total. Pour cela une expression Arcade va nous permettre de calculer ce pourcentage.

Cliquez sur l'image pour l'agrandir

L'expression de données suivante pourra alors être utilisée :


// Récupération du portail ArcGIS, ici ArcGIS Online
var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '2a359efa6e014709bd13476f2f862d9f',
    0,
    ['*'],
    false
);

// On calcule la somme des valeurs du champ "Production_agricole_milliards_e"
var Production_agricole_totale = Sum(fs, "Production_agricole_milliards_e"); 

// Création du tableau pour les nouvelles entités
var new_features = []

for (var f in fs) {
    var feat = {
        attributes: {
            "Pays": f["Pays"],
            // On calcule le % de la prod agricole du pays par rapport au total
            "Pourcentage_Production": 100*f["Production_agricole_milliards_e"]/Production_agricole_totale
        }
    };
    Push(new_features,feat);
}

// Création du nouveau FeatureSet
var new_featureset = {
    fields: [
        // Schéma de la table
        { name: "Pays", type: "esriFieldTypeString" },
        { name: "Pourcentage_Production", type: "esriFieldTypeDouble" }
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

// On renvoie le nouveau jeu de onnées après l'avoir trié sur le champ
// "Pourcentage_Production"
return OrderBy(FeatureSet(new_featureset), 'Pourcentage_Production DESC');

Le jeu de données généré est alors le suivant :

Vous pouvez par exemple le représenter dans votre tableau de bord à l'aide d'une liste :

Vous pouvez aussi le représenter dans votre tableau de bord à l'aide d'un diagramme en série :

Remarque : Si vous souhaitiez utiliser utiliser un diagramme en secteurs, le calcul du pourcentage aurait été réalisé automatiquement sans avoir à construire un jeu de donnée à l'aide d'une expression Arcade.

Exemple 2:
Nous disposons maintenant d'une couche de stations météo qui possèdent les dernières valeurs de température et de pression mesurées par les capteurs de chaque station. Chacune d'entre-elle dispose d'un champ indiquant la commune et nous souhaitons disposer de statistiques indiquant, par commune, la température moyenne, l'écart-type entre les différentes valeurs mesurées ainsi que le nombre de stations disponibles. Grace aux capacités de statistiques multi-attributs d'Arcade, nous allons pouvoir construire l'expression de données adéquate.

L'expression de données suivante pourra alors être utilisée :


// Récupération du portail ArcGIS, ici ArcGIS Online
var portal = Portal('https://www.arcgis.com/');

// Récupération des couches d'entités
var fs = FeatureSetByPortalItem(
    portal,
    'e6808c2691d143c9a10426d7e358cf04',
    0,
    [
        'Ville',
        'Temperature',
        'Pression'
    ],
    false
);

// Création du FeatureSet correspndant à l'agrégation par commune
// et calcul des statistiques
var feature_stats = GroupBy(fs, ['Ville'], 
[{name: 'Nombre_de_stations', expression: '1', statistic: 'COUNT' }, 
 {name: 'Temperature_moyenne', expression: 'Temperature', statistic: 'AVG' },
 {name: 'Temperature_ecart_type', expression: 'Temperature', statistic: 'STDEV' },
 {name: 'Pression_moyenne', expression: 'Pression', statistic: 'AVG' }]); 

// On renvoie le jeu de données en retirant les valeurs de ville et de 
// températures moyennes non vide
return Filter(feature_stats,"(Ville NOT LIKE '') and (Temperature_moyenne IS NOT NULL)")

Le jeu de données généré est alors le suivant :

Vous pouvez maintenant le représenter dans votre tableau de bord à l'aide d'une liste :

Exemple 3:
Je dispose maintenant d'une table contenant les demandes de permis de végétaliser à Paris. Pour chaque demande nous disposons notamment de l'arrondissement et du type de demande (Jardinières mobiles, Pieds d'arbres, mur.

Cliquez sur l'image pour l'agrandir

L'expression de données suivante pourra alors être utilisée :



// Récupération du portail ArcGIS, ici ArcGIS Online
var myportal = Portal('https://www.arcgis.com/');

// Récupération des couches d'entités
var fs = FeatureSetByPortalItem(
    myportal,
    '1a729ebfbee741eea41ba35f89843ef9',
    0,
    ['*'],
    false
);

// Regroupement des demandes par arrondissement et par type de permis
var grouped = GroupBy(fs, 
    ["rv_arrdt", "rv_type"], 
    [{name: "Nb_Demandes", expression: "1", statistic: "COUNT"}]
);


// Création d’un dictionnaire pour stocker le Nb_demandes max par arrondissement
var result = {};
for (var g in grouped) {
    var arr = Text(g["rv_arrdt"]);
    var type = g["rv_type"];
    var Nb_Demandes = g["Nb_Demandes"];
    // Si on change d'arrondissement ou si le nombre de demandes est supérieure
    // à la valeur précédente, alors on ajoute le triplé de arr;type;Nb_Demandes
    // dans le dictionnaire des résultats
    if (!HasKey(result, arr) || result[arr].Nb_Demandes < Nb_Demandes) {
        result[arr] = {
            "Arrondissement": arr,
            "Type_Permis": type,
            "Nb_Demandes": Nb_Demandes
        };
    }
}

// Construction du FeatureSet final
var features = [];
for (var key in result) {
    Push(features, {
        attributes: result[key]
    });
}
var fs_final =  FeatureSet({
    fields: [
        { name: "Arrondissement", type: "esriFieldTypeString" },
        { name: "Type_Permis", type: "esriFieldTypeString" },
        { name: "Nb_Demandes", type: "esriFieldTypeInteger" }
    ],
    geometryType: "",
    features: features
});

// On renvoie le featureset final
return fs_final

Le jeu de données généré est alors le suivant :

Il peut alors être utilisé dans un tableau de bord pour créer ce diagramme en série :

A travers ces 3 exemples, vous avez pu découvrir comment utiliser des expressions de données avec Arcade pour calculer des statistiques sur un ou plusieurs champ(s). Il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

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

13 August 2025

14:23

Conseils & Astuces ArcGIS Online - N°202

sur arcOrama

N°202 - Expressions de données ArcGIS Dashboards - Agréger dynamiquement des données
Dans ce précédent article, je vous présentais la notion très puissante d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose plusieurs exemples d'expressions de données permettant d'agréger dynamiquement les données avant de les utiliser dans votre tableau de bord.

Exemple 1:
Je dispose d'une couche des hébergements AirBnB à Partis contenant notamment le type de propriété (Appartement, Maison, Loft, Bateau, ...), le type de logement (Logement entier, Chambre privée, Chambre partagée,...) ainsi que le prix de la nuitée. Je souhaite tout simplement agréger mes données selon le type de propriété et le type de logement, puis faire la moyenne du prix de la nuitée par catégorie. En standard dans ArcGIS Dashboard je peux agrégé par catégorie sur un seul champ ce qui ne conviendra pas. En revanche, une expression de données Arcade va me permettre de construire dynamiquement le jeu de données souhaité.

Cliquez sur l'image pour l'agrandir

L'expression de données suivante pourra alors être utilisée :


// Récupération du portail ArcGIS, ici ArcGIS Online
var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '440753e53d144f9089b4c2debc566395',
    0,
    ['*'],
    false
);

// Filtrage pour ne garder que les types qui sont non nuls
var fs_filtered = Filter(fs, "(Type_de_propriete IS NOT NULL) AND (Type_de_logement IS NOT NULL)");

// Agrégation du jeu de données selon les types de propriété et de logement
var featuresStats = GroupBy(fs_filtered,
  [  // Champs d'agrégation
    { name: 'Type_de_propriete', expression: 'Type_de_propriete'},
    { name: 'Type_de_logement', expression: 'Type_de_logement'}
  ],
  [  // Statistique à renvoyer : la myenne du prix des nuitées
    { name: 'Nuitée_Moyenne', expression: 'Prix_nuitee', statistic: 'AVG' }
  ]
);

// Création du tableau pour les nouvelles entités
var new_features = []

for (var g in featuresStats) {
    var feat = {
        attributes: {
            "Type_de_propriete": g["Type_de_propriete"],
            "Type_de_logement": g["Type_de_logement"],
            "Nuitée_Moyenne": g["Nuitée_Moyenne"]
        }
    };
    Push(new_features,feat);
}

// Création du nouveau FeatureSet
var new_featureset = {
    fields: [
        // Schéma de la table
        { name: "Type_de_propriete", type: "esriFieldTypeString" },
        { name: "Type_de_logement", type: "esriFieldTypeString" },
        { name: "Nuitée_Moyenne", type: "esriFieldTypeDouble" },
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(new_featureset);

Le jeu de données généré est alors le suivant :

Vous pouvez par exemple le représenter dans votre tableau de bord à l'aide d'une liste :

Imaginons que vous souhaitiez une autre représentation comme un diagramme en séries par exemple. Il vous faudra alors disposer des combinaisons "Type de propriété" et "Type de logement" dans un seul et même champ. L'expression de données sera adaptée de la manière suivante :


// Récupération du portail ArcGIS, ici ArcGIS Online
var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '440753e53d144f9089b4c2debc566395',
    0,
    ['*'],
    false
);

// Filtrage pour ne garder que les types qui sont non nuls
var fs_filtered = Filter(fs, "(Type_de_propriete IS NOT NULL) AND (Type_de_logement IS NOT NULL)");

// Agrégation du jeu de données selon les types de propriété et de logement
var featuresStats = GroupBy(fs_filtered,
  [  // Champs d'agrégation
    { name: 'Type_de_propriete', expression: 'Type_de_propriete'},
    { name: 'Type_de_logement', expression: 'Type_de_logement'}
  ],
  [  // Statistique à renvoyer : la myenne du prix des nuitées
    { name: 'Nuitée_Moyenne', expression: 'Prix_nuitee', statistic: 'AVG' }
  ]
);

// Création du tableau pour les nouvelles entités
var new_features = []

for (var g in featuresStats) {
    var feat = {
        attributes: {
            "Type": g["Type_de_propriete"] + " - " + g["Type_de_logement"],
            "Nuitée_Moyenne": g["Nuitée_Moyenne"]
        }
    };
    Push(new_features,feat);
}

// Création du nouveau FeatureSet
var new_featureset = {
    fields: [
        // Schéma de la table
        { name: "Type", type: "esriFieldTypeString" },
        { name: "Nuitée_Moyenne", type: "esriFieldTypeDouble" },
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(new_featureset);

Le jeu de données généré est alors le suivant :

Vous pouvez maintenant le représenter dans votre tableau de bord à l'aide d'un diagramme en série :

Exemple 2:
Je dispose maintenant d'une couche contenant des informations sur les accidents sur la métropole de Rennes durant l'année 2022. Nous savons qu'il est possible de représenter des données en utilisant un champ de type Date et de les agréger par jour, par mois ou par année à l'aide des options adéquates de l'interface d'ArcGIS Dashboard. Imaginez maintenant que vous souhaitiez faire cette agrégation en fonction du jour de la semaine. dans ce cas, une expression de données Arcade sera la solution.

Cliquez sur l'image pour l'agrandir

L'expression de données suivante pourra alors être utilisée :


var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    'ab9e8b72221b439daaf20334549363c8',
    0,
    ['*'],
    false
);

// Agrégation du jeu de données selon les jours de la semaine sur le
// champ Date_Accident
var featuresStats = GroupBy(fs,
  [  // On définit l'expression SQL permettant d'extraire le jour de la semaine
    { name: 'JourSemaine', expression: "EXTRACT(DOW FROM Date_Accident)"}
  ],
  [  // statistique à renvoyer : un comptage des lignes
    { name: 'Total', expression: '1', statistic: 'COUNT' }
  ]
);

// Création du tableau pour les nouvelles entités
var new_features = []

// Décodage de jour de la semaine 
for (var g in featuresStats) {
    var code_jour = g["JourSemaine"];
    var nom_jour = Decode(code_jour,
        0, "Dimanche",
        1, "Lundi",
        2, "Mardi",
        3, "Mercredi",
        4, "Jeudi",
        5, "Vendredi",
        6, "Samedi",
        "Inconnu"
    );

    var feat = {
        attributes: {
            "jour": nom_jour,
            "total": g["Total"]
        }
    };
    Push(new_features,feat);
}

// Création du nouveau FeatureSet
var new_featureset = {
    fields: [
        // Schéma de la table
        { name: "jour", type: "esriFieldTypeString" },
        { name: "total", type: "esriFieldTypeInteger" },
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(new_featureset);

Le jeu de données généré est alors le suivant :

Il peut alors être utilisé dans un tableau de bord pour créer ce diagramme en série :

Exemple 3:
Dans ce dernier exemple, je dispose des observations de la couche iNaturalist du Living Atlas et de la couche des départements français. Je souhaite disposer d'un jeu de données qui dynamiquement compte le nombre d'observations par département. C'est ici, la relation spatiale entre les points des observations et les polygones des départements qui sera exploité par mon expression de données Arcade.

L'expression de données suivante pourra alors être utilisée :


var myportal = Portal('https://www.arcgis.com');

// Récupération de la couche des départements
var fs_departements = FeatureSetByPortalItem(
    myportal,
    '694e1ed261b54a539b84cba47640b710',
    5,
    ['*'],
    true
);

// Récupération de la couche des observations iNaturalist
var fs_observations = FeatureSetByPortalItem(
    myportal,
    '99e3e9ccfaec422db6d4266569aa19d7',
    0,
    ['*'],
    false
);

// Création du tableau pour les nouvelles entités
var new_features = []

// On boucle sur chaque département
for (var dept in fs_departements) {
    // Récupérer les points qui intersectent ce polygone
    var pts = Intersects(dept, fs_observations);

    // On compte le nombre de points
    var nb_points = Count(pts);

    // On crée une nouvelle entités
    var feat = {
        attributes: {
            "Département": dept["NOM_DEP"],
            "Nb_Observations": nb_points
        }
    };
    Push(new_features,feat);
}

// Création du nouveau FeatureSet
var new_featureset = {
    fields: [
        // Schéma de la table
        { name: "Département", type: "esriFieldTypeString" },
        { name: "Nb_Observations", type: "esriFieldTypeInteger" },
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(new_featureset);

Le jeu de données généré est alors le suivant :

Il peut, par exemple, être utilisé dans un tableau de bord pour créer ce diagramme à secteurs :

A travers ces 3 exemples, vous avez pu découvrir comment utiliser des expressions de données avec Arcade pour agréger dynamiquement sur un ou plusieurs champ(s) ou selon des critères spatiaux. Il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

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

12 August 2025

9:45

Conseils & Astuces ArcGIS Online - N°201

sur arcOrama

N°201 - Expressions de données ArcGIS Dashboards - Calculer dynamiquement des champs
Dans ce précédent article, je vous présentais la puissante notion d'expression de données dans ArcGIS Dashboards ainsi que l'interface permettant de les créer. Dans cet article, je vous propose maintenant de découvrir des exemples concrets de cas d'usages de ces expressions. Je vous présente plusieurs exemples d'expressions de données permettant de calculer des nouveaux champs avant de les ajouter dans votre tableau de bord.

Exemple 1:
Je dispose d'une couche contenant des informations issues de capteurs de températures. Ces températures sont exprimées en degrés Celsius mais, pour des enjeux d'internationalisation de mon tableau de bord, je veux également disposer d'un champ contenant ces valeurs en degrés Fahrenheit. Je veux également ne retenir que les capteurs qui sont actifs.

L'expression de données suivante pourra alors être utilisée :


var myportal = Portal('https://www.arcgis.com');
// Récupération de la couche d'entités d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '0d3c42f93c974fbd93f9cc1560d08f81',
    0,
    ['*'],
    false
);

// Filtrage des équipements actifs uniquement
var featuresRecents = Filter(fs, "etat like 'actif'");

var new_features = [];

// Création des entités à mettre dans le nouveau FeatureSet
for (var f in featuresRecents) {
  var celsius = f["temperature_C"]
  // Conversion en degrés Fahrenheit
  var fahrenheit = (celsius * 9 / 5) + 32
  // On ajoute une nouvelle entités dans le tableau
  Push(new_features, {
      attributes: {
          "id_capteur": f["id_capteur"],
          "etat": f["etat"],
          "temperature_C": Round(f["temperature_C"],1),
          "temperature_F": Round(fahrenheit)
      }
  });
}

// Définition du nouveau FeatureSet
var def_new_featureset = {
    fields: [
        // Champs déjà présents dans la couche
        { name: "id_capteur", type: "esriFieldTypeString" },
        { name: "etat", type: "esriFieldTypeString" },
        { name: "temperature_C", type: "esriFieldTypeDouble" },
        // Nouveau champ
        { name: "temperature_F", type: "esriFieldTypeDouble" },
        
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(def_new_featureset);

Le jeu de données généré est alors le suivant :

Il peut alors être utilisé dans un tableau de bord pour créer cet indicateur :

Exemple 2:
Je dispose maintenant d'une table contenant des informations relatives à des pannes sur un réseau de fibre optique. On dispose d'une date de début de panne (DateDebut) et d'une date de réparation (DateReparation). L'objectif est de générer dynamiquement un jeu de données concernant uniquement les pannes du dernier mois et de calculer un champ supplémentaire correspondant au délais de répération (en nombre de jours).

L'expression de données suivante pourra alors être utilisée :

var myportal = Portal('https://www.arcgis.com');
// Récupération de la table d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '3cd2e38946904d50af4f1b2dd113f78c',
    0,
    ['*'],
    false
);
     
// Calcul de la date limite (6 mois en arrière)
var unMoisAvant = DateAdd(Now(), -1, "months");

// Filtrage des enregistrements récents
var featuresRecents = Filter(fs, "DateReparation >= @unMoisAvant");

var new_features = [];

// Création des entités à mettre dans le nouveau FeatureSet
for (var f in featuresRecents) {
    var delai_resolution = null;
    if (!IsEmpty(f["DateDebut"]) && !IsEmpty(f["DateReparation"])) {
        delai_resolution = DateDiff(f["DateReparation"], f["DateDebut"], "days");
    }

    Push(new_features, {
        attributes: {
            "TypePanne": f["TypePanne"],
            "DateDebut": f["DateDebut"],
            "DateReparation": f["DateReparation"],
            "IdEquipement": f["IdEquipement"],
            "DelaisResolution": Round(delai_resolution,2)
        }
    });
}

// Création du nouveau FeatureSet
var new_featureset = {
    fields: [
        // Champs déjà présents dans la couche
        { name: "TypePanne", type: "esriFieldTypeString" },
        { name: "DateDebut", type: "esriFieldTypeDate" },
        { name: "DateReparation", type: "esriFieldTypeDate" },
        { name: "IdEquipement", type: "esriFieldTypeString" },
        // Nouveau champs à ajouter et à calculer
        { name: "DelaisResolution", type: "esriFieldTypeDouble" }
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(new_featureset);

Le jeu de données généré est alors le suivant :

Il peut alors être utilisé dans un tableau de bord pour créer ce diagramme qui représente le délais moyen de réparation par type de panne pour le mois précédent :

Exemple 3 :
Je dispose maintenant d'une table contenant des informations (fictives) concernant des faits de délinquance. Au-delà du type de fait et de la description, ces derniers possèdent une date et une heure. L'objectif est d'ajouter à ce jeu de données indiquant si le fait s'est déroulé la nuit (0h-6h), le matin (6h-12h), l'après-midi (12h-18h) ou le soir (18h-0h).

L'expression de données suivante pourra alors être utilisée :

var myportal = Portal('https://www.arcgis.com');
// Récupération de la couche d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    'e2b3e63cbfb34a2fbed4dae62d080ef3',
    0,
    ['*'],
    false
);

var new_features = [];

// Création des entités à mettre dans le nouveau FeatureSet
for (var f in fs) {
  // Récupération de l'heure du fait
  var heure = Hour(f["Date_Heure"])
  // Période de la journée
  var periode
  periode = IIf(heure < 6, 'nuit', IIf(heure < 12, 'matin', IIf(heure < 18, 'après-midi','soir')));

  Push(new_features, {
      attributes: {
          "Type_fait": f["Type_fait"],
          "Adresse": f["Adresse"],
          "Description": f["Description"],
          "Nb_Auteurs": f["Nb_Auteurs"],
          "Nb_Victimes": f["Nb_Victimes"],
          "Periode": periode,
      },
  });
}

// Définition du nouveau FeatureSet
var def_new_featureset = {
    fields: [
        // Champs déjà présents dans la couche
        { name: "Type_fait", type: "esriFieldTypeString" },
        { name: "Adresse", type: "esriFieldTypeString" },
        { name: "Description", type: "esriFieldTypeString" },
        { name: "Nb_Auteurs", type: "esriFieldTypeInteger" },
        { name: "Nb_Victimes", type: "esriFieldTypeInteger" },
        // Nouveau champ
        { name: "Periode", type: "esriFieldTypeString" }
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

return FeatureSet(def_new_featureset);

Le jeu de données généré est alors le suivant :

Il peut alors être utilisé dans un tableau de bord pour créer ces diagrammes qui représente la répartition des faits selon la période de la journée :

Exemple 4 :
Nous disposons d'un jeu de données contenant les signalements issus de l'application "Dans Ma Rue" mise à disposition des citoyens par la ville de Paris. Celle-ci contient le type et sous-type du signalement aibnsi qu'une date. L'objectif est d'ajouter un champ contenant le jour de la semaine afin de présenter des statistiques sur cet axe.

L'expression de données suivante pourra alors être utilisée :

var myportal = Portal('https://www.arcgis.com');
// Récupération de la couche d'origine
var fs = FeatureSetByPortalItem(
    myportal,
    '567c9ad9fbf04d1aac18bec41574cd78',
    0,
    ['adresse','datedecl','type','soustype'],
    false
);

var new_features = [];

// Création des entités à mettre dans le nouveau FeatureSet
for (var f in fs) {
  // Récupération du jour de la semaine
  var num_jour = ISOWeekday(f["datedecl"])
  // Codage du nom du jour
  var nom_jour = Decode(num_jour, 1, 'Lundi', 2, 'Mardi', 
                        3, 'Mercredi',  4, "Jeudi", 5 , "Vendredi",
                        6, "Samedi", 7, "Dimanche","");

  Push(new_features, {
      attributes: {
          "adresse": f["adresse"],
          "datedecl": f["datedecl"],
          "type": f["type"],
          "soustype": f["soustype"],
          "num_jour": num_jour,
          "nom_jour": nom_jour
      },
  });
}

// Définition du nouveau FeatureSet
var def_new_featureset = {
    fields: [
        // Champs déjà présents dans la couche
        { name: "adresse", type: "esriFieldTypeString" },
        { name: "datedecl", type: "esriFieldTypeDate" },
        { name: "type", type: "esriFieldTypeString" },
        { name: "soustype", type: "esriFieldTypeString" },
        // Nouveaux champs
        { name: "num_jour", type: "esriFieldTypeInteger" },
        { name: "nom_jour", type: "esriFieldTypeString" }
    ],
    // Ici nous créons une table (sans géométrie)
    geometryType: "",
    features : new_features
};

// On retourne le FeatureSet en le triant sur le numéro du jour afin
// d'avoir ensuite un tri correct du lundi au dimanche dans le diagramme
return OrderBy(FeatureSet(def_new_featureset), 'num_jour ASC');

Le jeu de données généré est alors le suivant :

Il peut alors être utilisé dans un tableau de bord pour créer ce diagramme qui représente la répartition des signalement selon le type et le jour dans la semaine :

A travers ces 4 exemples, vous avez pu découvrir comment utiliser des expressions de données avec Arcade pour calculer dynamiquement un ou plusieurs champ(s) supplémentaire(s). Il ne vous reste plus qu'à l'appliquer à vos propres cas d'usage.

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

← Géoclip, le géné... Géoblogs (GeoRezo.net) →

Communauté	Ressources	L'emploi	Le marché	L'association	Fils RSS
Forum Blogs Wiki Planet Sites amis	Agenda Biblio Fiches AMO-CNIG Paris PCGIS Téléchargements	Offres d'emploi Banque de CV Formations Démarche Métiers	Geo-Entreprises Geo-Communiqué Appels d'offres	L'association Qui sommes-nous ? Nous aider Bienfaiteurs Partenaires Historique Statuts	Tout le site Job Géomatique Services GeoBlogs ...	Faire un don Mentions légales

Le portail francophone de la géomatique

Canaux

arcOrama (9 non lus)