Présentation de FeatureView

Un FeatureView est une représentation accélérée, en lecture seule, d'un FeatureCollection. Contrairement à un FeatureCollection, dont les tuiles de carte matricielle sont générées instantanément, les tuiles matricielles FeatureView sont précalculées pour un rendu rapide. En plus d'accélérer le rendu, les composants FeatureView implémentent l'amincissement des éléments en fonction du niveau de zoom. L'effet est que les ensembles de données denses peuvent sembler incomplets en cas de zoom arrière (les éléments de petite taille ne sont pas dessinés), mais une plus grande partie des données devient visible lorsque vous effectuez un zoom avant, ce qui peut améliorer l'esthétique de la carte à des niveaux de zoom inférieurs. Le comportement d'amincissement d'un ensemble de données est contrôlé par plusieurs paramètres d'optimisation définis lors de l'exportation d'un FeatureCollection vers un élément FeatureView.

En tant qu'élément en lecture seule, les objets FeatureView ne peuvent pas être inclus dans les calculs ni les expressions, mais peuvent être visualisés et inspectés dans l'éditeur de code JavaScript et les applications Earth Engine en tant que FeatureViewLayer. Ils peuvent également être intégrés aux applications de l'API Google Maps.

Créer une vue des caractéristiques

La création d'un FeatureView implique de préparer un FeatureCollection avec vos données, d'appeler la fonction Export.table.toFeatureView et de démarrer la tâche d'exportation. L'exemple suivant montre comment exporter des vues de l'ensemble de données de polygones WDPA. Dans votre propre application, utilisez n'importe quel ensemble de données FeatureCollection archivé dans le catalogue de données Earth Engine ou créez-en un en important un ensemble de données vectoriel en tant qu'élément Earth Engine.

Remarque :Les composants FeatureView sont comptabilisés dans le quota de stockage total du compte/projet vers lequel ils sont exportés.

Un FeatureView peut être personnalisé à l'aide de plusieurs paramètres dans la fonction Export.table.toFeatureView.

• maxFeaturesPerTile : définit le nombre maximal d'éléments affichés dans une tuile de carte à un niveau de zoom donné. Utilisez ce paramètre pour optimiser la vitesse ou la densité des éléments géographiques.
• thinningStrategy : indique si l'amincissement des éléments géographiques pour une tuile et un niveau de zoom donnés doit être optimisé pour une densité plus élevée ou une densité cohérente entre les tuiles. Notez que l'optimisation pour une densité plus élevée peut entraîner la distinction des limites des tuiles, car la densité d'éléments par tuile est indépendante.
• thinningRanking : définit la priorité d'amincissement des éléments géographiques. Par exemple, vous pouvez optimiser l'amincissement pour cibler la rétention d'une propriété d'éléments géographiques particulière avec des valeurs élevées. En d'autres termes, lorsque vous faites un zoom arrière, les éléments géographiques dont la valeur est faible pour la propriété sélectionnée sont d'abord affinés, laissant les éléments géographiques les plus importants (selon vos règles) visibles.
• zOrderRanking : définit l'ordre z (ordre d'empilement) des éléments affichés sur la carte. Ce paramètre contrôle l'affichage des éléments géographiques qui se chevauchent en vous permettant de définir des règles de priorité en fonction des propriétés des éléments géographiques, du type de géométrie et du niveau de zoom. Par exemple, vous pouvez donner la priorité aux éléments géographiques dont la valeur d'une propriété particulière est élevée afin qu'ils se superposent aux éléments géographiques qui se croisent et dont la valeur est faible.

Pour en savoir plus sur ces paramètres et les arguments acceptés, consultez la page Optimisation de FeatureView.

Attention :Si la valeur de l'argument maxFeaturesPerTile fourni à Export.table.toFeatureView est trop élevée, Earth Engine peut rencontrer un délai avant expiration de la diffusion des tuiles. Dans ce cas, essayez de réduire cette valeur et de réexporter l'asset. La valeur optimale est un compromis entre le nombre de fonctionnalités affinées et le temps de chargement des tuiles (latence). La latence dépend également du type de géométrie (les points et les lignes s'affichent plus rapidement que les polygones), de la complexité de la géométrie et du nombre de règles de style.

Dans l'exemple ci-dessous, les arguments spécifiés pour ces paramètres génèrent un FeatureView où le nombre maximal d'éléments par carte à un niveau de zoom donné est de 1 500, la densité d'éléments par carte est indépendante et peut atteindre le maximum de 1 500, les polygones plus petits sont d'abord affinés et les polygones plus petits se superposent aux plus grands.

Éditeur de code (JavaScript)

// Import the WDPA feature collection.
var wdpa = ee.FeatureCollection('WCMC/WDPA/current/polygons');

// Export the WDPA FeatureCollection as a FeatureView asset.
Export.table.toFeatureView({
  collection: wdpa,
  assetId: 'wdpa-featureview-demo',
  description: 'wdpa-featureview-demo',
  maxFeaturesPerTile: 1500,
  thinningStrategy: 'HIGHER_DENSITY',
  thinningRanking: ['REP_AREA DESC'],
  zOrderRanking: ['REP_AREA DESC'],
});

L'exécution de l'extrait de code ci-dessus dans l'éditeur de code génère une tâche d'exportation. Exécutez la tâche pour lancer l'exportation.

Emplacements des composants FeatureView

Les composants FeatureView se trouvent dans le catalogue de données public et parmi vos composants personnels dans l'onglet Composants de l'éditeur de code. Tous les éléments FeatureCollection pertinents du catalogue de données disposent d'un élément FeatureView associé avec des paramètres d'ingestion généralement applicables. Votre archive d'éléments personnels inclura tous les éléments FeatureView que vous créez.

Importer des composants FeatureView dans des scripts

Les éléments FeatureView peuvent être importés dans les scripts de l'éditeur de code à l'aide des boutons des boîtes de dialogue d'éléments de l'éditeur de code et des entrées d'éléments personnels, et en fournissant un ID d'élément FeatureView en entrée du constructeur ui.Map.FeatureViewLayer.

Boîte de dialogue des composants Data Catalog

Les boîtes de dialogue des composants de table Data Catalog, accessibles depuis la barre de recherche de l'éditeur de code, comportent un bouton Importer en bas à droite avec un menu déroulant. Dans le menu déroulant, sélectionnez "Importer FeatureView". L'élément sera inclus dans la section Importations en haut de votre script.

Boîte de dialogue "Composant personnel"

Les boîtes de dialogue d'éléments FeatureView personnels, auxquelles vous accédez en sélectionnant un élément dans l'onglet Éléments de l'éditeur de code, comportent un bouton Importer en haut à droite. L'activation du bouton inclura l'élément dans la section Importations en haut de votre script. Vous pouvez également utiliser le bouton de raccourci d'importation (icône de flèche pointant vers la droite) qui s'affiche lorsque vous pointez sur un élément dans l'onglet Éléments.

ID d'élément

Les composants FeatureView disposent d'un ID qui peut être fourni en entrée au constructeur ui.Map.FeatureViewLayer, ce qui vous permet d'accéder au composant dans votre script. Vous trouverez des extraits d'importation prédéfinis sur les pages d'éléments et dans les boîtes de dialogue des éléments de Data Catalog dans l'éditeur de code.

Figure 1. Boîte de dialogue des éléments Data Catalog mettant en évidence les méthodes d'importation FeatureView.

Métadonnées FeatureView

Les informations et les métadonnées FeatureView sont disponibles dans les boîtes de dialogue des éléments mentionnées dans la section Emplacements des éléments FeatureView ci-dessus. En plus de la description et des propriétés pouvant être partagées avec la source FeatureCollection, cinq propriétés sont propres à FeatureView. Ils incluent les paramètres de paramètre d'ingestion décrits dans la section Créer un FeatureView et sourceVersion, qui correspond à la date et l'heure de la dernière modification de l'asset de table à partir duquel FeatureView a été créé. La figure 1 ci-dessus montre les propriétés spécifiques à FeatureView dans une boîte de dialogue d'élément Data Catalog. Comme pour les autres composants, vous pouvez également extraire des propriétés de manière programmatique à partir du dictionnaire renvoyé par ee.data.getAsset.

Visualiser une FeatureView

Un objet FeatureView peut être visualisé dans l'éditeur de code, les applications Earth Engine et Google Maps.

Éditeur de code

L'éditeur de code inclut le composant ui.Map.FeatureViewLayer pour visualiser les éléments FeatureView sur une carte. L'exemple suivant définit un ID d'élément FeatureView, importe l'élément en tant que FeatureViewLayer et l'affiche sur la carte.

Éditeur de code (JavaScript)

// Define the FeatureView asset ID.
var assetId = 'WCMC/WDPA/current/polygons_FeatureView';

// Import the FeatureView asset as a FeatureViewLayer.
var layer = ui.Map.FeatureViewLayer(assetId);

// Add the FeatureViewLayer to the map.
Map.add(layer);

Attribuer un style

Vous pouvez styliser FeatureViewLayer en transmettant un dictionnaire de styles à la fonction ui.Map.FeatureViewLayer ou en les ajoutant à un calque à l'aide de la méthode setVisParams. Vous trouverez ci-dessous un exemple de style:

• couleurs de contour en fonction de la propriété "MARINE" (si la zone protégée se trouve totalement ou partiellement dans l'environnement marin) ;
• couleur de remplissage en fonction de la propriété "IUCN_CAT" (catégorie de l'Union internationale pour la conservation de la nature (UICN)) ;
• Opacité de remplissage en fonction de la taille de la zone protégée définie par la propriété "REP_AREA".

Pour en savoir plus sur les options de style disponibles, consultez la page Style FeatureView.

Éditeur de code (JavaScript)

// Set visualization properties for the defined layer.
layer.setVisParams({
  color: {
    property: 'MARINE',
    categories: [
      ['0', 'purple'],
      ['1', 'green'],
      ['2', 'blue'],
    ]
  },
  fillColor: {
    property: 'IUCN_CAT',
    defaultValue: 'd3d3d3',
    categories: [
      ['Ia', 'a6cee3'],
      ['Ib', '1f78b4'],
      ['II', 'b2df8a'],
      ['III', '33a02c'],
      ['IV', 'fb9a99'],
      ['V', 'e31a1c'],
      ['VI', 'fdbf6f'],
    ]
  },
  fillOpacity: {
    property: 'REP_AREA',
    mode: 'interval',
    palette: [
      [0, 0.5],
      [80, 0.35],
      [2000, 0.22],
      [5000, 0.15],
    ],
  },
  width: 1.0,
  pointSize: 6.0,
});

Filtrage

Vous pouvez appliquer des règles de filtrage pour styliser ou masquer sélectivement des éléments géographiques en fonction de leurs propriétés. Par exemple, pour filtrer les zones protégées plus petites qu'une certaine zone donnée par un widget de curseur, vous pouvez utiliser le code suivant. Pour en savoir plus sur le champ rules, consultez la section Règles spécifiques de la page de stylisation FeatureView.

Éditeur de code (JavaScript)

// Define the FeatureView asset ID.
var assetId = 'WCMC/WDPA/current/polygons_FeatureView';

// Import the FeatureView asset as a FeatureViewLayer.
var layer = ui.Map.FeatureViewLayer(assetId, null, 'WDPA FeatureViewLayer');

// Callback function to update FeatureViewLayer style.
var updateVisParams = function() {
  layer.setVisParams({
    color: {
      property: 'MARINE',
      categories: [
        ['0', 'purple'],
        ['1', 'green'],
        ['2', 'blue'],
      ]
    },
    fillColor: {
      property: 'IUCN_CAT',
      defaultValue: 'd3d3d3',
      categories: [
        ['Ia', 'a6cee3'],
        ['Ib', '1f78b4'],
        ['II', 'b2df8a'],
        ['III', '33a02c'],
        ['IV', 'fb9a99'],
        ['V', 'e31a1c'],
        ['VI', 'fdbf6f'],
      ]
    },
    fillOpacity: {
      property: 'REP_AREA',
      mode: 'interval',
      palette: [
        [0, 0.5],
        [80, 0.35],
        [2000, 0.22],
        [5000, 0.15],
      ],
    },
    width: 1.0,
    pointSize: 6.0,
    rules: [
      {
        filter: ee.Filter.lt('REP_AREA', filterSlider.getValue()),
        isVisible: false,
      },
    ],
  });
};

// Slider widget that calls the updateVisParams function on change.
var filterSlider = ui.Slider({
  min: 0,
  max: 10000,
  step: 10,
  value: 0,
  style: { stretch: 'horizontal'},
  onChange: updateVisParams,
});
var filterSliderLabel = ui.Label(
  'Adjust slider to hide features less than the specified area (km²)');

// Add the slider to the map.
Map.add(ui.Panel([filterSliderLabel, filterSlider]));

// Initialize the FeatureViewLayer style.
updateVisParams();

// Add the FeatureViewLayer to the map.
Map.add(layer);

Figure 2. Visualisation FeatureViewLayer avec un widget de curseur pour masquer les éléments plus petits que la zone spécifiée.

API Google Maps

La visualisation d'un élément FeatureView à l'aide de l'API Google Maps se compose de quatre étapes: obtenir une clé de tuile à l'aide de ee.data.getFeatureViewTilesKey, la transmettre à une instance de FeatureViewTileSource, créer un ee.layer.ImageOverlay, puis ajouter le calque à votre instance google.maps.Map. Un exemple de code permettant de créer ImageOverlay en JavaScript est présenté ci-dessous.

var tilesKey = ee.data.getFeatureViewTilesKey({
  assetId: 'WCMC/WDPA/current/polygons_FeatureView',
  visParams: { … },
});

var tileSource = new ee.layers.FeatureViewTileSource(tilesKey);
var overlay = new ee.layers.ImageOverlay(tileSource);

Une fois cette opération effectuée, vous pouvez ajouter la superposition à votre instance google.maps.Map, comme illustré ci-dessous.

// embeddedMap is your google.maps.Map instance.
embeddedMap.overlayMapTypes.setAt(0, overlay);

Inspecter une FeatureView

Un calque FeatureViewLayer ajouté à la carte par défaut de l'éditeur de code peut être inspecté à l'aide de l'outil d'inspection. La fonctionnalité est identique à celle d'un FeatureCollection. Notez que les résultats renvoyés pour l'emplacement sur lequel vous avez cliqué ne répertorient que les éléments géographiques visibles au niveau de zoom actuel. Les géométries ne sont pas affichées pour les éléments inspectés, car elles sont simplifiées lors du processus d'exportation FeatureView.

Figure 3. Inspection d'un FeatureViewLayer. L'inspecteur affiche la couche, les éléments géographiques, l'ID de l'élément et les paramètres de visualisation.