Envoyer une requête de couches de données

Le point de terminaison dataLayers fournit des informations détaillées sur l'énergie solaire pour une région entourant un emplacement spécifié. Le point de terminaison renvoie 17 fichiers TIFF téléchargeables, y compris:

• Modèle de surface numérique (DSM)
• Couche composite RVB (images aériennes)
• Une couche de masque qui identifie les limites de l'analyse
• Flux solaire annuel ou rendement annuel d'une surface donnée
• Flux solaire mensuel ou rendement mensuel d'une surface donnée
• Ombre horaire (24 heures)

Pour en savoir plus sur la façon dont l'API Solar définit le flux, consultez la section Concepts de l'API Solar.

À propos des demandes de couches de données

L'exemple suivant montre l'URL d'une requête REST à la méthode dataLayers:

https://solar.googleapis.com/v1/dataLayers:get?parameters

Incluez les paramètres de l'URL de votre requête qui spécifient les éléments suivants:

• Coordonnées de latitude et de longitude du lieu
• Rayon de la région entourant le lieu
• Sous-ensemble des données à renvoyer (DSM, RVB, masque, flux annuel ou flux mensuel)
• Qualité minimale autorisée dans les résultats
• Échelle minimale des données à renvoyer, en mètres par pixel

Exemple de requête de couches de données

L'exemple suivant demande toutes les informations sur les insights sur les bâtiments dans un rayon de 100 mètres pour l'emplacement aux coordonnées de latitude = 37,4450 et longitude = -122,1390:

Clé API

Pour envoyer une requête à l'URL de la réponse, ajoutez votre clé API à l'URL:

curl -X GET "https://solar.googleapis.com/v1/dataLayers:get?location.latitude=37.4450&location.longitude=-122.1390&radiusMeters=100&view=FULL_LAYERS&requiredQuality=HIGH&exactQualityRequired=true&pixelSizeMeters=0.5&key=YOUR_API_KEY"

Vous pouvez également envoyer des requêtes HTTP en collant l'URL de la requête cURL dans la barre d'URL de votre navigateur. Transmettre la clé API vous permet de bénéficier de meilleures fonctionnalités d'utilisation et d'analyse, ainsi que d'un meilleur contrôle des accès aux données de réponse.

Jeton OAuth

Remarque:Ce format est réservé à un environnement de test. Pour en savoir plus, consultez Utiliser OAuth.

Pour envoyer une requête à l'URL indiquée dans la réponse, transmettez le nom de votre projet de facturation et votre jeton OAuth:

curl -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "X-Goog-User-Project: PROJECT_NUMBER_OR_ID" \
  "https://solar.googleapis.com/v1/dataLayers:get?location.latitude=37.4450&location.longitude=-122.1390&radius_meters=100&required_quality=HIGH&exactQualityRequired=true"
        

TypeScript

Pour envoyer une requête à l'URL de la réponse, incluez votre clé API ou le jeton OAuth dans la requête. L'exemple suivant utilise une clé API:

/**
 * Fetches the data layers information from the Solar API.
 *   https://developers.google.com/maps/documentation/solar/data-layers
 *
 * @param  {LatLng} location      Point of interest as latitude longitude.
 * @param  {number} radiusMeters  Radius of the data layer size in meters.
 * @param  {string} apiKey        Google Cloud API key.
 * @return {Promise<DataLayersResponse>}  Data Layers response.
 */
export async function getDataLayerUrls(
  location: LatLng,
  radiusMeters: number,
  apiKey: string,
): Promise<DataLayersResponse> {
  const args = {
    'location.latitude': location.latitude.toFixed(5),
    'location.longitude': location.longitude.toFixed(5),
    radius_meters: radiusMeters.toString(),
    // The Solar API always returns the highest quality imagery available.
    // By default the API asks for HIGH quality, which means that HIGH quality isn't available,
    // but there is an existing MEDIUM or LOW quality, it won't return anything.
    // Here we ask for *at least* LOW quality, but if there's a higher quality available,
    // the Solar API will return us the highest quality available.
    required_quality: 'LOW',
  };
  console.log('GET dataLayers\n', args);
  const params = new URLSearchParams({ ...args, key: apiKey });
  // https://developers.google.com/maps/documentation/solar/reference/rest/v1/dataLayers/get
  return fetch(`https://solar.googleapis.com/v1/dataLayers:get?${params}`).then(
    async (response) => {
      const content = await response.json();
      if (response.status != 200) {
        console.error('getDataLayerUrls\n', content);
        throw content;
      }
      console.log('dataLayersResponse', content);
      return content;
    },
  );
}
solar.ts

Remarque:Consultez ce guide sur l'utilisation de TypeScript et Google Maps.

Les champs et le type de données sont un "type" en TypeScript. Dans cet exemple, nous définissons un type personnalisé pour stocker les champs d'intérêt dans la réponse, tels que les valeurs de pixel et la zone de délimitation de latitude/longitude. Vous pouvez inclure d'autres champs si vous le souhaitez.

export interface GeoTiff {
  width: number;
  height: number;
  rasters: Array<number>[];
  bounds: Bounds;
}
solar.ts

Remarque:Consultez ce guide sur l'utilisation de TypeScript et Google Maps.

Définitions des types de données

Les types de données suivants sont acceptés:

export interface DataLayersResponse {
  imageryDate: Date;
  imageryProcessedDate: Date;
  dsmUrl: string;
  rgbUrl: string;
  maskUrl: string;
  annualFluxUrl: string;
  monthlyFluxUrl: string;
  hourlyShadeUrls: string[];
  imageryQuality: 'HIGH' | 'MEDIUM' | 'LOW';
}

export interface Bounds {
  north: number;
  south: number;
  east: number;
  west: number;
}

// https://developers.google.com/maps/documentation/solar/reference/rest/v1/buildingInsights/findClosest
export interface BuildingInsightsResponse {
  name: string;
  center: LatLng;
  boundingBox: LatLngBox;
  imageryDate: Date;
  imageryProcessedDate: Date;
  postalCode: string;
  administrativeArea: string;
  statisticalArea: string;
  regionCode: string;
  solarPotential: SolarPotential;
  imageryQuality: 'HIGH' | 'MEDIUM' | 'LOW';
}

export interface SolarPotential {
  maxArrayPanelsCount: number;
  panelCapacityWatts: number;
  panelHeightMeters: number;
  panelWidthMeters: number;
  panelLifetimeYears: number;
  maxArrayAreaMeters2: number;
  maxSunshineHoursPerYear: number;
  carbonOffsetFactorKgPerMwh: number;
  wholeRoofStats: SizeAndSunshineStats;
  buildingStats: SizeAndSunshineStats;
  roofSegmentStats: RoofSegmentSizeAndSunshineStats[];
  solarPanels: SolarPanel[];
  solarPanelConfigs: SolarPanelConfig[];
  financialAnalyses: object;
}

export interface SizeAndSunshineStats {
  areaMeters2: number;
  sunshineQuantiles: number[];
  groundAreaMeters2: number;
}

export interface RoofSegmentSizeAndSunshineStats {
  pitchDegrees: number;
  azimuthDegrees: number;
  stats: SizeAndSunshineStats;
  center: LatLng;
  boundingBox: LatLngBox;
  planeHeightAtCenterMeters: number;
}

export interface SolarPanel {
  center: LatLng;
  orientation: 'LANDSCAPE' | 'PORTRAIT';
  segmentIndex: number;
  yearlyEnergyDcKwh: number;
}

export interface SolarPanelConfig {
  panelsCount: number;
  yearlyEnergyDcKwh: number;
  roofSegmentSummaries: RoofSegmentSummary[];
}

export interface RoofSegmentSummary {
  pitchDegrees: number;
  azimuthDegrees: number;
  panelsCount: number;
  yearlyEnergyDcKwh: number;
  segmentIndex: number;
}

export interface LatLng {
  latitude: number;
  longitude: number;
}

export interface LatLngBox {
  sw: LatLng;
  ne: LatLng;
}

export interface Date {
  year: number;
  month: number;
  day: number;
}

export interface RequestError {
  error: {
    code: number;
    message: string;
    status: string;
  };
}
solar.ts

Remarque:Consultez ce guide sur l'utilisation de TypeScript et Google Maps.

L'API renvoie des URL au format suivant:

https://solar.googleapis.com/v1/solar/geoTiff:get?id=HASHED_ID

Vous pouvez utiliser ces URL pour accéder aux fichiers GeoTIFF contenant les données demandées.

Exemple de réponse

La requête génère une réponse JSON sous la forme suivante:

{
  "imageryDate": {
    "year": 2022,
    "month": 4,
    "day": 6
  },
  "imageryProcessedDate": {
    "year": 2023,
    "month": 8,
    "day": 4
  },
  "dsmUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=MmQyMzI0NTMyZDc3YjBjNmQ3OTgyM2ZhNzMyNzk5NjItN2ZjODJlOThkNmQ5ZDdmZDFlNWU3MDY4YWFlMWU0ZGQ6UkdCOkhJR0g=",
  "rgbUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=NzQwNGQ0NmUyMzAzYWRiNmMxNzMwZTJhN2IxMTc4NDctOTI5YTNkZTlkM2MzYjRiNjE4MGNkODVmNjNiNDhkMzE6UkdCOkhJR0g=",
  "maskUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=ZTk1YTBlZmY5Y2FhMThlNWYzMWEzZGZhYzEzMGQzOTAtM2Q4NmUyMmM5ZThjZmE0YjhhZWMwN2UzYzdmYmQ3ZjI6TUFTSzpISUdI",
  "annualFluxUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=OTE0OWIxZDM3NmNlYjkzMWY2YjQyYjY5Y2RkYzNiOTAtZjU5YTVjZGQ3MzE3ZTQ4NTNmN2M4ZmY2MWZlZGZkMzg6QU5OVUFMX0ZMVVg6SElHSA==",
  "monthlyFluxUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=Y2NhOGRhOWI2MjVmYmNiZTY3Njk4Yjk0MGJhNTk1NDUtY2MyYTI4NDJmN2Q5YTI0MmY2NDQyZGUwZWJkMWQ0ZDg6TU9OVEhMWV9GTFVYOkhJR0g=",
  "hourlyShadeUrls": [
    "https://solar.googleapis.com/v1/geoTiff:get?id=OWFhOTZmNDU2OGQyNTYxYWQ4YjZkYjQ5NWI4Zjg1ODItZGEwNDNhMmM3NDU0MTY2OGIzZDY2OGU1NTY0NTFlMzE6TU9OVEhMWV9GTFVYOkhJR0g=",
    "https://solar.googleapis.com/v1/geoTiff:get?id=MTI1ZTI2YzM1ZTRlYjA3ZDM4NWE2ODY4MjUzZmIxZTMtNTRmYTI3YmQyYzVjZDcyYjc5ZTlmMTRjZjBmYTk4OTk6TU9OVEhMWV9GTFVYOkhJR0g=",
    ...
  ],
  "imageryQuality": "HIGH"
}

Accéder aux données de réponse

L'accès aux données via des URL de réponse nécessite une authentification supplémentaire. Si vous utilisez une clé d'authentification, vous devez ajouter votre clé API à l'URL. Si vous utilisez l'authentification OAuth, vous devez ajouter des en-têtes OAuth.

Clé API

Pour envoyer une requête à l'URL de la réponse, ajoutez votre clé API à l'URL:

curl -X GET "https://solar.googleapis.com/v1/solar/geoTiff:get?id=fbde33e9cd16d5fd10d19a19dc580bc1-8614f599c5c264553f821cd034d5cf32&key=YOUR_API_KEY"

Vous pouvez également envoyer des requêtes HTTP en collant l'URL de la requête cURL dans la barre d'URL de votre navigateur. Transmettre la clé API vous permet de bénéficier de meilleures fonctionnalités d'utilisation et d'analyse, ainsi que d'un meilleur contrôle des accès aux données de réponse.

Jeton OAuth

Pour envoyer une requête à l'URL indiquée dans la réponse, transmettez le nom de votre projet de facturation et votre jeton OAuth:

curl -X GET \
-H 'X-Goog-User-Project: PROJECT_NUMBER_OR_ID' \
-H "Authorization: Bearer $TOKEN" \
"https://solar.googleapis.com/v1/solar/geoTiff:get?id=fbde33e9cd16d5fd10d19a19dc580bc1-8614f599c5c264553f821cd034d5cf32"
        

TypeScript

L'exemple suivant montre comment obtenir les valeurs de données de pixel (les informations stockées dans les pixels individuels d'une image numérique, y compris les valeurs de couleur et d'autres attributs), calculer la latitude et la longitude à partir du GeoTIFF, et les stocker dans un objet TypeScript.

Pour cet exemple spécifique, nous avons choisi d'autoriser la vérification des types, ce qui réduit les erreurs de type, ajoute de la fiabilité à votre code et facilite sa maintenance.

// npm install geotiff geotiff-geokeys-to-proj4 proj4

import * as geotiff from 'geotiff';
import * as geokeysToProj4 from 'geotiff-geokeys-to-proj4';
import proj4 from 'proj4';

/**
 * Downloads the pixel values for a Data Layer URL from the Solar API.
 *
 * @param  {string} url        URL from the Data Layers response.
 * @param  {string} apiKey     Google Cloud API key.
 * @return {Promise<GeoTiff>}  Pixel values with shape and lat/lon bounds.
 */
export async function downloadGeoTIFF(url: string, apiKey: string): Promise<GeoTiff> {
  console.log(`Downloading data layer: ${url}`);

  // Include your Google Cloud API key in the Data Layers URL.
  const solarUrl = url.includes('solar.googleapis.com') ? url + `&key=${apiKey}` : url;
  const response = await fetch(solarUrl);
  if (response.status != 200) {
    const error = await response.json();
    console.error(`downloadGeoTIFF failed: ${url}\n`, error);
    throw error;
  }

  // Get the GeoTIFF rasters, which are the pixel values for each band.
  const arrayBuffer = await response.arrayBuffer();
  const tiff = await geotiff.fromArrayBuffer(arrayBuffer);
  const image = await tiff.getImage();
  const rasters = await image.readRasters();

  // Reproject the bounding box into lat/lon coordinates.
  const geoKeys = image.getGeoKeys();
  const projObj = geokeysToProj4.toProj4(geoKeys);
  const projection = proj4(projObj.proj4, 'WGS84');
  const box = image.getBoundingBox();
  const sw = projection.forward({
    x: box[0] * projObj.coordinatesConversionParameters.x,
    y: box[1] * projObj.coordinatesConversionParameters.y,
  });
  const ne = projection.forward({
    x: box[2] * projObj.coordinatesConversionParameters.x,
    y: box[3] * projObj.coordinatesConversionParameters.y,
  });

  return {
    // Width and height of the data layer image in pixels.
    // Used to know the row and column since Javascript
    // stores the values as flat arrays.
    width: rasters.width,
    height: rasters.height,
    // Each raster reprents the pixel values of each band.
    // We convert them from `geotiff.TypedArray`s into plain
    // Javascript arrays to make them easier to process.
    rasters: [...Array(rasters.length).keys()].map((i) =>
      Array.from(rasters[i] as geotiff.TypedArray),
    ),
    // The bounding box as a lat/lon rectangle.
    bounds: {
      north: ne.y,
      south: sw.y,
      east: ne.x,
      west: sw.x,
    },
  };
}
solar.ts

Remarque:Consultez ce guide sur l'utilisation de TypeScript et Google Maps.

À l'exception de la couche RVB, tous les fichiers TIFF s'affichent comme des images vides dans les applications d'affichage d'images. Pour afficher les fichiers TIFF téléchargés, importez-les dans un logiciel d'application cartographique, tel que QGIS.

La spécification complète de cette requête et de cette réponse se trouve dans la documentation de référence.

Remarque :Les URL de réponse ne sont actives que pendant une heure après la requête initiale. Pour accéder aux URL au-delà de ce délai, vous devez renvoyer une requête au point de terminaison dataLayers.