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

Home Archive for 2025

Conseils & Astuces ArcGIS Online - N°203

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.

Conseils & Astuces ArcGIS Online - N°202

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.

Conseils & Astuces ArcGIS Online - N°201

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.

Conseils & Astuces ArcGIS Online - N°200

N°200 - Dynamiser ses tableaux de bord ArcGIS avec des expressions de données

Parmi les nombreuses évolutions qu’a connues ArcGIS Dashboards, l’arrivée des expressions de données (Data Expressions) marque une avancée majeure dans la manière dont les utilisateurs peuvent transformer, manipuler et représenter leurs données. Cette fonctionnalité offre une souplesse inédite dans la conception des tableaux de bord, en permettant la création de sources de données dynamiques, calculées à la volée, directement dans l’interface du Dashboard.

Mais concrètement, que sont ces expressions de données, à quoi servent-elles, et comment peut-on les mettre en œuvre dans vos tableaux de bord ?

Qu’est-ce qu’une expression de données dans ArcGIS Dashboards ?

Une expression de données est un script Arcade utilisé pour générer une source de données virtuelle à partir d’autres couches ou tables existantes dans la carte du tableau de bord. Plutôt que de s’appuyer uniquement sur des couches brutes issues du SIG, vous pouvez créer des vues agrégées, filtrées ou transformées, en temps réel.

Cela ouvre la porte à une multitude de cas d’usages, tels que :

Calculer des agrégats ou des indicateurs synthétiques (totaux, moyennes, maximum…),
Réaliser de jointures personnalisées entre plusieurs tables/couches,
Recoder des valeurs dans des tables pour les rendre plus explicites,
Grouper des entités selon des critères personnalisés (par type, par date, par localisation…),
Fusionner plusieurs couches en une seule vue logique,
Créer des séries temporelles même si les données sources ne le permettent pas directement.

En résumé, les expressions de données agissent comme un intermédiaire intelligent entre vos données brutes et vos éléments de visualisation (indicateurs, diagrammes, listes…).

Principales étapes pour créer une expression de données

Créer une Data Expression peut sembler technique au premier abord, mais le processus est en réalité bien balisé. Voici les grandes étapes à suivre pour intégrer ce type d’expression dans votre tableau de bord :

Ajouter un élément compatible

Seuls certains éléments du tableau de bord permettent d’utiliser une "Expression de données" comme source. Il s’agit notamment des :

- Indicateurs,
- Diagrammes (en séries, en secteurs,...),
- Listes,
- Jauges,
- Tables,
- Détails,
- ...

Vous commencerez donc par ajouter un de ces éléments à votre tableau de bord.
Choisir “Nouvel expression de données” comme source.

Cela ouvre alors l’éditeur d’Arcade.
Écrire l’expression en Arcade

Dans l’éditeur, vous allez écrire un script Arcade. Celui-ci doit construire un tableau d’objets (type FeatureSet) qui servira de nouvelle source de données. Voici un exemple simple d’agrégation sur une couche contenant des inventaires de mouvement de terrain en Nouvelle-Calédonie. L'expression génère une ligne pour chaque valeur unique du champ "typologie" et compte dans un un champ "total" le nombre de mouvements de terrain regroupées par typologie:
```
var fs = FeatureSetByPortalItem(
            Portal('https://www.arcgis.com'),
            '3194d47b313e4c16809226699b50765b',
            1,
            ['*']
            );

var grouped = GroupBy(fs,['typologie'],{name:'total',expression:'1',statistic:'COUNT'});

return grouped;
```
Dans cet exemple, on regroupe les entités selon leur champ type et on calcule le nombre d’occurrences pour chaque valeur.
Tester et valider l’expression

Le tableau de bord vous indique si l’expression retourne un résultat exploitable. En cas d’erreur de syntaxe ou de logique, un message d’erreur vous aide à corriger votre expression Arcade.
Configurer l’affichage de l’élément

Une fois l’expression validée, vous pouvez configurer votre élément visuel comme avec toute autre couche : choisir les champs à afficher, ordonner les résultats, définir des couleurs ou des symboles.

Voilà pour cette brève introduction aux expressions de données dans ArcGIS Dashboards. Dans les 7 prochains "Conseils & Astuces ArcGIS Online", je vous proposerai une série d'exemples et de cas d'usage de ces expressions de données Arcade :

N°201: Calculer dynamiquement des nouveaux champs
N°202: Agréger des données sur des critères attributaires ou spatiaux
N°203: Calculer des statistiques sur les données
N°204: Filtrer uniquement les dernières valeurs
N°205: Joindre des tables ou des couches d'entités
N°206: Faire pivoter les données de votre table
N°207: Combiner plusieurs jeux de données

Bonne route sur ArcGIS Online !

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

ArcGIS Maps SDKs for Game Engine 2.1 : Fluidité et Personnalisation

ArcGIS Maps SDKs for Native Apps 200.8 : Version de transition vers l’avenir

Avec la sortie de la version 200.8 des ArcGIS Maps SDKs for Native Apps, Esri propose une mise à jour à la fois stable et ambitieuse, qui marque la fin d’un cycle avant l’arrivée prochaine de la génération 300.x. Cette version est la dernière de la génération 200.x, bénéficiant du statut Long Term Support (LTS) avec un support étendu sur 5 ans, ce qui en fait un choix stratégique pour les projets nécessitant de la stabilité sur le long terme.

Un socle robuste, des capacités renforcées

Parmi les nouveautés les plus notables, on soulignera le support natif des fichiers PDF géospatiaux (GeoPDF) en tant que couches raster. Cette capacité ouvre la voie à une meilleure exploitation de documents cartographiques issus du monde papier, notamment dans des contextes d’intervention hors connexion.

Côté interaction utilisateur, les outils de dessin évoluent avec l’introduction d’un réticule programmable, offrant plus de précision dans la saisie d’objets géographiques, particulièrement utile sur tablettes ou écrans tactiles. De nouveaux événements UI permettent également de mieux intégrer ces outils dans des workflows métier personnalisés.

Vers une sécurité accrue et une architecture Zero Trust

Dans un contexte où la sécurité applicative devient une priorité, les SDK Kotlin et Swift prennent désormais en charge les proxys de type Identity-Aware Proxy (IAP). Cela permet une authentification conditionnelle fondée sur l’identité et le contexte réseau de l’utilisateur, en ligne avec les architectures Zero Trust adoptées dans de nombreuses entreprises.

La 3D arrive dans le SDK Flutter

Longtemps attendue, la prise en charge des scènes 3D est désormais effective dans le SDK Flutter. Il devient possible d’afficher des couches I3S, des élévations, des tuiles OGC 3D Tiles, ainsi que des packages de scènes mobiles. Les analyses 3D de visibilité et de champ de vision sont également de la partie, bien que la réalité augmentée ne soit pas encore intégrée.

Utility Network : mieux comprendre les associations

Toujours du côté fonctionnel, les développeurs d’applications tirant parti du Utility Network pourront désormais explorer les associations de type containment ou connectivity directement dans les formulaires ou les fenêtres contextuelles. L’édition de ces associations est prévue dans une prochaine mise à jour, mais cette première étape facilite déjà l’interprétation des relations complexes entre entités.

Des améliorations transverses bienvenues

Parmi les autres évolutions notables, on notera :

une meilleure gestion des fichiers KML complexes,
le support du mode hors ligne pour les cartes intérieures (indoors),
une API géométrique enrichie,
un support élargi de la norme WKT2,
et des gains de performance dans les opérations d’identification et de requêtes.

Les toolkits continuent de s’étoffer avec de nouveaux composants pour chaque environnement (compas, cartes d’aperçu, vues contextuelles, gestion des téléchargements, etc.).

En ligne de mire : la version 300.x

Cette version 200.8 sert également de tremplin vers la prochaine génération des SDKs. Esri prépare activement la série 300.x, attendue au printemps prochain. Celle-ci apportera une réorganisation des API, de meilleures performances sur les scènes locales, une modernisation du moteur raster et une intégration plus poussée des fonctions d’analyse spatiale.

Les développeurs sont donc invités à adopter cette version 200.8 pour bénéficier à la fois d’un socle fiable et d’une transition facilitée vers les versions futures.

Pour aller plus loin...

Pour plus de détails sur cette version 200.8 des SDKs ArcGIS Maps for Native Apps, je vous recommande la lecture de cet article de ma collègue Pauline Louis sur le blog CodeTheMap.

Spatial Analyst : Des outils supplémentaires pour ArcGIS Pro

Bien connue des utilisateurs de Spatial Analyst avec ArcMap depuis très longtemps, la version 1.0 des outils supplémentaires Spatial Analyst pour ArcGIS Pro est maintenant disponible depuis près de 12 ans. Aujourd'hui, une version 2.0 voit le jour. Cette version 2.0 de la boîte à outils, développée pour ArcGIS Pro, s'appuie sur la boîte à outils supplémentaire d'origine avec plusieurs outils nouveaux et améliorés pour l'analyse et la visualisation raster. Ces outils supplémentaires offrent de nouvelles fonctionnalités, absentes de la boîte à outils Spatial Analyst d'ArcGIS Pro, pour améliorer les capacités d'analyse, de visualisation et de modélisation. Comme dans les versions précédentes, ces outils peuvent être utilisés directement ou personnalisés pour prendre en charge vos flux de travail spécifiques.

Prérequis à l'utilisation des ces outils

Il est nécessaire de posséder ArcGIS Pro et l'extension Spatial Analyst. Pour mémoire, si vous disposez d'un utilisateur nommé de type "Professional Plus" vous disposez automatiquement d'une licence Spatial Analyst dans ArcGIS Pro.

Nouveaux outils introduits en version 2.0

Deux nouveaux outils apparaissent dans cette nouvelle version

Créer un raster de simulation d'inondation

Cet outil crée un jeu de données raster multidimensionnel à partir des résultats de simulation d'inondation (profondeur, élévation de la surface de l'eau et vitesse de l'eau), générés à l'aide de la simulation d'inondation dans ArcGIS Pro. Il crée également une mosaïque temporelle. Les jeux de données multidimensionnels obtenus permettent la visualisation et l'analyse spatiales et temporelles de la dynamique des inondations. La sortie de vitesse de l'eau affiche les composantes U et V à l'aide de la symbologie de champ vectoriel et peut être utilisée avec le moteur de rendu de flux dans Map Viewer . Les résultats étant multidimensionnels, il est possible d'utiliser le curseur temporel pour animer les variables d'inondation au fil du temps.

Sortie de vitesse de l'eau à partir de l'outil "Créer un raster de simulation d'inondation", affichant les composants U et V à l'aide de la symbologie de champ vectoriel.

Localiser les statistiques zonales

Si vous cherchez à identifier l'emplacement des cellules correspondant à une valeur statistique zonale calculée (notamment le minimum et le maximum) dans chaque zone, vous pouvez utiliser l'outil « Localiser les statistiques zonales ». Il implémente d'abord l'outil « Statistiques zonales » largement utilisé pour calculer la statistique spécifiée pour le raster de valeurs dans les zones définies. L'outil renvoie ensuite un raster de sortie contenant uniquement les cellules contenant la valeur statistique zonale calculée pour chaque zone, ainsi qu'une classe d'entités dont les cellules de la première sortie sont converties en points ou en polygones. Cet outil est utile pour identifier les extrêmes dans les régions définies.

Outils de la version précédente

Les outils suivants de la version précédente ont été améliorés pour fonctionner dans ArcGIS Pro.

Créer un dendrogramme

Cet outil génère un dendrogramme, un diagramme arborescent illustrant la relation hiérarchique entre les classes spectrales dans un fichier de signatures. Il lit un fichier de signatures (.gsg) et construit une représentation visuelle des distances entre les classes, permettant d'évaluer la séparabilité des clusters. L'analyse du dendrogramme permet de déterminer si les clusters identifiés dans le fichier de signatures sont suffisamment distincts pour donner un bon résultat de classification.

Dessiner des signatures

L'outil "Dessiner des signatures" crée un PDF avec des ellipses représentant la structure de covariance des classes spectrales dans un fichier de signatures. Il permet de visualiser le chevauchement entre les classes en traçant des ellipses pour toutes les combinaisons de bandes. Les ellipses délimitent la distribution de l'échantillon définie par un nombre spécifié d'écarts types.

Effacer les valeurs raster

L'outil "Effacer les valeurs raster" permet de supprimer ou de remplacer sélectivement les valeurs des cellules raster à l'aide d'un masque. Les masques d'entités et raster sont pris en charge. Il est ainsi possible d'attribuer une valeur NoData ou spécifique aux cellules concernées. Cet outil simplifie les flux de travail qui nécessitaient auparavant plusieurs étapes avec les outils "Con" et "SetNull".

Altitude maximale en amont

Cet outil calcule l'altitude maximale en amont de chaque cellule. Il utilise des rasters d'altitude et de direction d'écoulement et trace les trajectoires d'écoulement pour déterminer l'altitude maximale atteinte en amont. Cet outil est particulièrement utile pour modéliser les coulées de débris potentielles dues aux pluies extrêmes ou dans les zones montagneuses touchées par les incendies de forêt.

Sommet

L'outil Pic identifie les points hauts locaux dans un raster de surface. Il est l'inverse de l'outil Puits, bien connu en analyse hydrologique pour détecter les dépressions dans les données d'altitude. Cet outil localise les pics en inversant d'abord le raster d'altitude et en calculant la direction d'écoulement pour cette surface. Il identifie ensuite les puits, qui correspondent aux pics de la surface d'origine. Les cellules présentant les altitudes maximales au sein de ces puits inversés sont extraites et enregistrées sous forme de raster avec des valeurs uniques pour chaque pic.

Champ de vision le long du chemin

L'outil « Champ de vision le long du chemin » calcule la visibilité le long d'un chemin linéaire, simulant un observateur en mouvement avec un champ de vision limité. Alors que l'analyse traditionnelle du champ de vision suppose généralement un champ de vision à 360 degrés, cet outil restreint l'angle de visibilité, simulant des scénarios tels qu'un conducteur conduisant un véhicule avec une visibilité limitée. Il densifie le chemin, convertit les sommets en points d'observation, attribue des limites de vue précises en azimut et en verticalité à chaque point d'observation, puis calcule la visibilité en conséquence.

Comment accéder aux outils

Vous pouvez accéder aux outils et les utiliser de deux manières :

Télécharger localement

La boîte à outils supplémentaire Spatial Analyst est disponible en téléchargement ici : Outils supplémentaires de Spatial Analyst

Une fois le fichier téléchargé sur votre ordinateur, extrayez-en le contenu. Ensuite, dans le volet Catalogue d'ArcGIS Pro, accédez à l'emplacement d'extraction des fichiers ou, si vous le souhaitez, ajoutez une connexion à un dossier . La boîte à outils contenant les outils de script devrait alors s'afficher .

Ajoutez à votre projet ArcGIS Pro depuis ArcGIS Online

Dans ArcGIS Pro, connectez-vous à votre compte ArcGIS Online et définissez-le comme portail actif . Recherchez ensuite les outils supplémentaires Spatial Analyst sur ArcGIS Online. Vous pouvez également filtrer les résultats de recherche uniquement par type d'élément "Outils" pour faciliter la recherche. Après avoir localisé la boîte à outils "Spatial Analyst Supplemental Tools v2.0 for ArcGIS Pro" , faites un clic droit dessus et sélectionnez Ajouter au projet . Vous pouvez désormais y accéder depuis l'onglet Boîtes à outils du volet Géotraitement . Cette opération ajoutera également la boîte à outils aux boîtes à outils du projet et créera une connexion à la racine du dossier contenant la boîte à outils.

La boîte à outils Spatial Analyst Supplemental Tools a ajouter au projet
ArcGIS Pro depuis ArcGIS Online.

Historique des versions

v2.0 - Développement de la boîte à outils pour ArcGIS Pro. Ajout des nouveaux outils « Créer un raster de simulation d'inondation » et « Localiser les statistiques zonales », et amélioration des outils « Créer un dendrogramme », « Dessiner des signatures », « Effacer les valeurs raster », « Altitude maximale en amont », « Pic» et « Champ de vision le long du chemin » de la version précédente.

Suppression des outils « Capacité de stockage », « Tableau de la zone 2 », « Statistiques zonales sous forme de tableau 2 » et « Courbes de niveau remplies », désormais disponibles dans la boîte à outils Spatial Analyst d'ArcGIS Pro.
v1.4 -Ajout de l’outil Capacité de stockage.
v1.3 -Ajout de l'outil Tabuler la zone 2 et de l'outil Statistiques zonales en tant que tableau 2, et ajout d'un nouveau paramètre à l'outil Élévation maximale en amont.
v1.2 -Ajout des outils Effacer les valeurs raster et Statistiques zonales sous forme de tableau pour les polygones superposés.
v1.1 -Mises à jour pour ArcGIS 10.1 SP1.
v1.0 -Les outils Créer un dendrogramme, Dessiner des signatures, Contours remplis, Élévation maximale en amont, Champ de vision le long du chemin, Pic et Champ de vision ont été mis à disposition.