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

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

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.

Introduction à l'assistant IA ArcGIS pour Arcade

Depuis la dernière mise à jour d'ArcGIS Online en juin dernier, Esri a introduit en version beta de l'assistant IA ArcGIS pour Arcade. L'assistant Arcade utilise l'intelligence artificielle (IA) pour générer des expressions Arcade à partir d'instructions saisies en langage naturel. Cette fonctionnalité est actuellement disponible uniquement dans la visionneuse de cartes ArcGIS Online.

Ce nouvel assistant peut ajouter de la valeur à votre travail de deux manières :

Efficacité : La rédaction d'expressions peut prendre du temps. En fournissant des commandes en langage naturel clair, vous évitez les contraintes liées aux instructions logiques complexes, aux particularités syntaxiques et aux noms de champs cryptiques.
Aider les débutants : Bien que l'écriture d'Arcade ait été simplifiée grâce à l'éditeur Arcade, devenir un auteur Arcade expérimenté peut s'avérer complexe. L'assistant simplifie cette étape en effectuant pour l'utilisateur ce qu'il ne peut pas faire lui-même.

Démarrer avec l'assistant Arcade

Pour accéder à l’assistant Arcade, toutes les conditions suivantes doivent être remplies.

Vous devez être connecté à un compte d’organisation ArcGIS Online.
Les assistants IA doivent être activés dans votre organisation.
L'organisation ne doit pas refuser les fonctionnalités bêta .

Une fois les assistants IA activés dans votre organisation, ouvrez une carte contenant une ou plusieurs couches d'entités, comme celle-ci, dans la visionneuse de cartes, et connectez-vous à votre compte organisationnel. Ouvrez l'éditeur Arcade dans l'un des panneaux de configuration suivants :

Étiquetage
Style de couche
Attributs des fenêtres contextuelles
Contenu des fenêtres contextuelles
Agrégation

Vous cliquerez ensuite sur l’icône de l’assistant dans la barre d’action à droite dans l’éditeur Arcade.

Vous cliquerez ensuite sur "Continuer" (Proceed).

Vous pouvez maintenant commencer à utiliser l'assistant.

Quelques exemples d'usage...

Examinons quelques exemples de création de contenu de fenêtre contextuelle à l'aide de l'assistant. Chaque exemple utilise cette carte web (n'oubliez pas de vous connecter à votre organisation pour en faire une copie si vous le souhaitez). Cette carte web contient une couche de données démographiques par commune en France.

Exemple 1

Je souhaiterais afficher le pourcentage de la population âgée de moins de 15 ans dans la fenêtre contextuelle. Cependant, ce champ n'existe pas directement dans les données. Arcade peut le calculer avec les champs disponibles.

Le prompt proposé dans l'assistant Arcade pourra alors ressembler à ceci :

Calculer le pourcentage de la population agée de moins de 15 ans par rapport à la population totale. Arrondir le résultat au pourcentage entier le plus proche. Résumer en une phrase où les pourcentages seront gras et, si inférieures à 15% seront en rouge. Renvoyer le résultat sous forme d'élément de texte.

Cliquez sur l'image pour l'agrandir

Une fois qu'une réponse est générée, je peux choisir de remplacer l'expression existante par le résultat, ou simplement l'ajouter à l'éditeur à l'emplacement du curseur.

Il est important d'examiner attentivement la réponse de l'assistant. Elle n'est pas toujours parfaite et comporte parfois des erreurs. Par exemple, les noms de champs dans l'expression peuvent être incorrect si l'IA n'a pas "deviné" le bon champ à utiliser. Il est donc essentiel de vérifier le résultat pour détecter d'éventuels problèmes de performances ou des erreurs.

La réponse semblant ici satisfaisante, on l'applique à notre fenêtre contextuelle. Voici le résultat.

Bien que cela ne soit pas le cas dans ce jeu de données, imaginez que des valeurs de population ne soient pas renseignées pour certaines communes. Dans ce cas, l'expression retournera la valeur "Infinity" et vous obtiendrez cette fenêtre contextuelle.

Vous pouvez donc l'anticiper et le spécifier en complétant votre prompt comme ceci :

Calculer le pourcentage de la population agée de 0 et 14 ans par rapport à la population totale. Arrondir le résultat au pourcentage entier le plus proche. Résumer en une phrase où les pourcentages seront gras et, si inférieures à 15% seront en rouge. Renvoyer le résultat sous forme d'élément de texte. Si la zone est inhabitée, renvoyez "Zone sans population" en italique. Renvoyer sous forme d'élément de texte.

Cliquez sur l'image pour l'agrandir

Voici alors le résultat pour les entités n'ayant pas de valeur de population.

L'affichage conditionnel des éléments de contenu en fonction des valeurs de données est l'une des fonctionnalités puissantes qu'Arcade propose et que vous ne pouvez pas réaliser dans l'interface utilisateur de configuration des fenêtres contextuelles de Map Viewer.

Remarque : Un aspect important de l'utilisation de l'assistant Arcade c'est qu'il peut être nécessaire de l'interroger plusieurs fois avant d'obtenir le résultat escompté. Malgré cela, l'assistant n'est pas un chatbot. Il ne mémorise pas les informations fournies lors des précédents prompts. Lorsque vous peaufinez un prompt précédent, assurez-vous d'inclure tous les détails pertinents, comme si vous la posiez pour la première fois

Exemple 2 :

Ma couche contient plusieurs dizaines de champs et la fenêtre contextuelle par défaut est trop encombrée d'informations inutiles pour ma carte. Arcade me permet également de créer des tableaux dynamiques dans lesquels je vais pouvoir définir les informations souhaitées.

Fenêtre contextuelle par défaut dans la visionneuse de carte avec une longue liste de champs.

Via l'interface de configuration des fenêtres contextuelles vous pouvez restreindre la liste des champs visibles. Cependant, avec Arcade vous pourrez non seulement réduire la liste de champs à quelques valeurs, mais vous pourrez également trier dynamiquement les lignes en fonction de la valeur la plus élevée, supprimer des lignes en fonction des types d'entités interrogées ou encore mettre en évidence les lignes en fonction des valeurs des champs. Tout cela, vous pouvez le faire en renvoyant le résultat de l'expression Arcade sous forme de tableau HTML.

Cependant, créer un tableau HTML de A à Z peut s'avérer fastidieux et sujet à des erreurs plus ou moins difficiles à corriger selon vos connaissance en HTML. Heureusement, l'assistant Arcade génère efficacement ces tableaux HTML dynamiques pour vous.

Le prompt proposé dans l'assistant Arcade pourra alors ressembler à ceci :

Créer un tableau HTML des valeurs de population avec deux colonnes Homme et Femme, et les lignes correspondant aux tranches d'âges. Les valeurs de population doivent être arrondies en entiers.

Cliquez sur l'image pour l'agrandir

La réponse semblant ici satisfaisante, on l'applique à notre fenêtre contextuelle. Voici le résultat.

Si maintenant je veux que mon tableau occupe toute la largeur de la fenêtre contextuelle, qu'il est des bordures en gris clair et, de plus, souligner la ligne ayant la valeur la plus elevée, et bien je n'ai qu'à demander.

Je peux compléter mon précédent prompt comme ceci :

Créer un tableau HTML des valeurs de population avec deux colonnes Homme et Femme, et les lignes correspondant aux tranches d'âges. Les valeurs de population doivent être arrondies en entiers. Surligner la ligne contenant la valeur la plus élevée en bleu clair. Formatez le tableau de manière à ce que la largeur remplisse le conteneur et que la bordure soit gris clair.

Cliquez sur l'image pour l'agrandir

La réponse est de nouveau satisfaisante, on l'applique à notre fenêtre contextuelle. Voici le résultat.

Je ne l'ai pas fait ici, mais comme dans l'exemple précédent, je pourrais prendre en compte les communes sans valeur de population en affichant un texte de remplacement.

Exemple 3:

Pour terminer, je vais vous montrer que l'on peut également demander à l'assistant Arcade de générer une expression pour créer un diagramme. Par exemple ici, je souhaite créer un diagramme en barre contenant les différente population par catégorie socio-professionnelle. Dans ma table, ces informations sont dispatcher entre homme et femmes, il faudra donc en faire la somme avant de les représenter.

Le prompt proposé dans l'assistant Arcade pourra alors ressembler à ceci :

Créer un élément multimédia avec un diagramme en barre avec les valeurs suivantes : Agriculteurs, Artisans, Cadres, Professions intermédiaires, Employés, Ouvriers et Retraités. Tu feras la sommes des valeurs des hommes et des femmes.

On notera que dans ce contexte, étant donné la diversité des types de diagrammes, il faudra être précis sur le type de diagramme (en utilisant les bons termes en français) et sur ce que vous souhaitez représenter (y compris la liste des champs).

Cliquez sur l'image pour l'agrandir

La réponse est de nouveau satisfaisante, on l'applique à notre fenêtre contextuelle. Voici le résultat, avec un titre proposé en interprétant le contexte des noms de champs !

Enfin pour parfaire la représentation du diagramme, nous souhaitons préciser les couleurs des barres en demandant un dégradé su vert au jaune. Là encore, il suffit de demander !

Créer un élément multimédia avec un diagramme en barre avec les valeurs suivantes : Agriculteurs, Artisans, Cadres, Professions intermédiaires, Employés, Ouvriers et Retraités. Tu feras la sommes des valeurs des hommes et des femmes. Faire un dégradé du vert au jaune pour les couleurs des barres.

Cliquez sur l'image pour l'agrandir

La réponse est de nouveau satisfaisante, on l'applique à notre fenêtre contextuelle. Voici le résultat :

Une autre possibilité pour modifier les couleurs aurait été de le faire directement dans l'éditeur d'expression Arcade.

Comment rédiger un prompt efficace pour l'assistant Arcade

J'espère que ces exemples vous inspireront et vous auront permis d'apprendre à interagir efficacement avec l'assistant Arcade. Pour terminer, voici quelques conseils pour une interaction réussie avec l'assistant.

Soyez clair et concis dans votre demande. Un langage trop verbeux peut dérouter l'assistant.
Évitez les ambiguïtés et les formulations vagues. Préciser le type de données et de colonne souhaité pour générer des tables est plus efficace que de simplement indiquer "générer une table".
L'utilisation de noms de champs exacts n'est pas obligatoire, mais fournissez suffisamment de détails surtout si ces derniers n'ont pas de noms d'alias facilitant le travail de l'assistant.
Comprendre le contexte d'utilisation d'Arcade. Dans tous les cas actuellement disponibles, Arcade ne prend en compte que les champs de la couche dans laquelle il est appliqué. L'assistant ne prend pas en compte les valeurs et propriétés de symbologie, les autres expressions de la couche, les valeurs de données spécifiques d'un champ, ni les autres couches de la carte ou du portail (pour le moment).

Partagez vos commentaires !

Pendant la phase beta de ce projet (et même au-delà), vos commentaires sont essentiels pour aider les équipe d'Esri à améliorer l'expérience de génération d'expressions Arcade en langage naturel. Pour faire part de vos commentaires, utilisez l'icône "Pouce levé" ou "Ppouce baissé" dans la zone de l'asssitant affichant la réponse à votre question.

Remplissez ensuite le formulaire (de préférence en anglais mais ce n'est pas obligatoire) puis soumettez-le.

Plus les développeurs de cet assistant recevront de commentaires, mieux ce sera qu'elles soient positives et négatives. Qu'est-ce qui a bien fonctionné et qu'est-ce qui n'a pas fonctionné ? Vos attentes ont-elles été satisfaites ? L'assistant s'est-il trompé ? Quelles améliorations espérez-vous voir à l'avenir ? Toutes ces informations peuvent être communiquées via le formulaire.

Si vous êtes entièrement satisfait de la réponse et de votre expérience, n'hésitez pas à en faire part également ! Toutes les informations que vous fournirez aideront à améliorer l'assistant, même si elles vous semblent inutiles. Elles seront totalement anonymisées comme pour tous les programmes d'amélioration d'expérience d'Esri.

Pour conclure

Gardez à l'esprit que l'assistant Arcade en est encore à ses balbutiements et qu'il n'est donc pas parfait. Il peut parfois générer des réponses incorrectes ou renvoyer une erreur. Dans ce cas, il suffit de soumettre à nouveau la question ou de la reformuler. L'assistant peut se bloquer sur un terme spécifique de votre prompt et nécessiter un remplacement.

De plus, évaluez systématiquement votre propre langage et imaginez comment vous interagiriez avec un humain si vous demandiez à un expert d'Arcade d'écrire une expression pour vous. Lorsque des collègues interagissent, il faut souvent des questions complémentaires, des croquis au tableau blanc et plusieurs tentatives avant qu'une personne ne comprenne parfaitement l'autre. Cette dynamique de communication est identique lors des interactions avec des assistants IA.

Inscription à : Articles ( Atom )

Conseils & Astuces ArcGIS Online - N°203

Conseils & Astuces ArcGIS Online - N°202

Conseils & Astuces ArcGIS Online - N°201

Conseils & Astuces ArcGIS Online - N°200

Introduction à l'assistant IA ArcGIS pour Arcade

Archives du blog

Articles les plus consultés

HTML_arcorama_2

Visiteurs actuellement connectés

Suivre arcOrama - RSS et email

Suivre arcOrama par email :

Qui êtes-vous ?