Datenschichtanfrage senden

Der Endpunkt dataLayers liefert detaillierte Solarinformationen für eine Region rund um einen angegebenen Standort. Der Endpunkt gibt 17 herunterladbare TIFF-Dateien zurück, darunter:

  • Digitales Oberflächenmodell (DSM)
  • Zusammengesetzte RGB-Ebene (Luftbilder)
  • Eine Maskenebene, die die Grenzen der Analyse angibt
  • Jährlicher Sonnenstrom oder jährlicher Ertrag einer bestimmten Oberfläche
  • Monatlicher Sonnenstrom oder monatliche Ertrag einer bestimmten Oberfläche
  • Farbton pro Stunde (24 Stunden)

Weitere Informationen dazu, wie die Solar API Flux definiert, finden Sie unter Konzepte der Solar API.

Anfragen für Datenschichten

Das folgende Beispiel zeigt die URL einer REST-Anfrage an die Methode dataLayers:

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

Geben Sie die Parameter der Anfrage-URL an, die Folgendes angeben:

  • Breiten- und Längengradkoordinaten des Standorts
  • Der Radius der Region um den Standort
  • Die Teilmenge der zurückzugebenden Daten (DSM, RGB, Maske, jährlicher Fluss oder monatlicher Fluss)
  • Die Mindestqualität, die in den Ergebnissen zulässig ist
  • Der minimale Maßstab der zurückzugebenden Daten in Metern pro Pixel.

Beispiel für eine Datenschichtanfrage

Im folgenden Beispiel werden alle Gebäudeinformationen für den Standort mit einem Radius von 100 Metern an den Koordinaten Breitengrad = 37.4450 und Längengrad = -122.1390 angefordert:

API-Schlüssel

Um eine Anfrage an die URL in der Antwort zu stellen, hängen Sie Ihren API-Schlüssel an die URL an:

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&pixelSizeMeters=0.5&key=YOUR_API_KEY"

Sie können HTTP-Anfragen auch senden, indem Sie die URL aus der cURL-Anfrage in die URL-Leiste Ihres Browsers einfügen. Durch Übergabe des API-Schlüssels erhalten Sie bessere Nutzungs- und Analysefunktionen sowie eine bessere Zugriffssteuerung auf die Antwortdaten.

OAuth-Token

Hinweis:Dieses Format ist nur für eine Testumgebung gedacht. Weitere Informationen finden Sie unter OAuth verwenden.

Um eine Anfrage an die URL in der Antwort zu stellen, geben Sie den Namen Ihres Abrechnungsprojekts und Ihr OAuth-Token ein:

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"
        

TypeScript

Um eine Anfrage an die URL in der Antwort zu stellen, fügen Sie entweder Ihren API-Schlüssel oder das OAuth-Token in die Anfrage ein. Im folgenden Beispiel wird ein API-Schlüssel verwendet:

/**
 * 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;
    },
  );
}

Felder und der Datentyp sind in TypeScript ein "type". In diesem Beispiel definieren wir einen benutzerdefinierten Typ zum Speichern der relevanten Felder in der Antwort, wie z. B. die Pixelwerte und den Breiten-/Längengrad-Begrenzungsrahmen. Sie können bei Bedarf weitere Felder hinzufügen.

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

Datentypdefinitionen

Die folgenden Datentypen werden unterstützt:

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;
  };
}

Die API gibt URLs im folgenden Format zurück:

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

Diese URLs können verwendet werden, um auf GeoTIFF-Dateien mit den angeforderten Daten zuzugreifen.

Beispielantwort

Die Anfrage liefert eine JSON-Antwort in folgendem Format:

{
  "imageryDate": {
    "year": 2019,
    "month": 7,
    "day": 9
  },
  "imageryProcessedDate": {
    "year": 2022,
    "month": 3,
    "day": 21
  },
  "dsmUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=14f82e6931a8c33fc31ab8378e51804a-852f4ca7f056addda5b8fcb93e02c2fd",
  "rgbUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=bf769c43d72eb85493b20df583bc0c95-d13126638efaa89e44951abc8664d6a3",
  "maskUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=ed089240efc78e417c96a945460830ef-e666758b7cc183f82d1c7b7a891f858b",
  "annualFluxUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=aaa2637073d62cc7331d067eb7080bbe-f94eab79915f66759f5265b2ff8b1ad4",
  "monthlyFluxUrl": "https://solar.googleapis.com/v1/geoTiff:get?id=d1608d342a3d0393b5decd063d330271-2a2e27504a2009cad1f1f3d2b471bcd3",
  "hourlyShadeUrls": [
    "https://solar.googleapis.com/v1/geoTiff:get?id=541c2f32b936f190f7562309ea1d60fc-432bf94bcd0dc918f0c828d07aa00e7c",
    "https://solar.googleapis.com/v1/geoTiff:get?id=4eb7a0b9c0f34e0e746816d0f3085274-4794b9eb35ab18ad4fbe2c3ee59f151d",
    ...
  ],
  "imageryQuality": "HIGH"
}

Auf Antwortdaten zugreifen

Der Zugriff auf Daten über Antwort-URLs erfordert eine zusätzliche Authentifizierung. Wenn Sie einen Authentifizierungsschlüssel verwenden, müssen Sie Ihren API-Schlüssel an die URL anhängen. Wenn Sie die OAuth-Authentifizierung verwenden, müssen Sie OAuth-Header hinzufügen.

API-Schlüssel

Um eine Anfrage an die URL in der Antwort zu stellen, hängen Sie Ihren API-Schlüssel an die URL an:

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

Sie können HTTP-Anfragen auch senden, indem Sie die URL aus der cURL-Anfrage in die URL-Leiste Ihres Browsers einfügen. Durch Übergabe des API-Schlüssels erhalten Sie bessere Nutzungs- und Analysefunktionen sowie eine bessere Zugriffssteuerung auf die Antwortdaten.

OAuth-Token

Um eine Anfrage an die URL in der Antwort zu stellen, geben Sie den Namen Ihres Abrechnungsprojekts und Ihr OAuth-Token ein:

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

Das folgende Beispiel zeigt, wie Pixeldatenwerte (die in einzelnen Pixeln eines digitalen Bildes gespeicherten Informationen, einschließlich Farbwerte und andere Attribute) abgerufen werden, wie Breiten- und Längengrad aus dem GeoTIFF berechnet und in einem TypeScript-Objekt gespeichert werden.

Für dieses spezielle Beispiel haben wir uns für die Typprüfung entschieden. Dadurch werden Typfehler reduziert, die Zuverlässigkeit Ihres Codes erhöht und die Wartung vereinfacht.

// 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,
    },
  };
}

Mit Ausnahme der RGB-Ebene werden alle TIFF-Dateien in Bildanzeigen als leere Bilder angezeigt. Importieren Sie heruntergeladene TIFF-Dateien in eine Kartenanwendungssoftware wie QGIS.

Die vollständige Spezifikation dieser Anfrage und der Antwort finden Sie in der Referenzdokumentation.